@rg-software/angular-archwizard
Version:
A fork of the Angular Arch Wizard adapted for angular versions 17+.
161 lines • 19.3 kB
JavaScript
import { ContentChild, EventEmitter, HostBinding, Input, Output, Directive } from '@angular/core';
import { WizardStepSymbolDirective } from '../directives/wizard-step-symbol.directive';
import { WizardStepTitleDirective } from '../directives/wizard-step-title.directive';
import * as i0 from "@angular/core";
/**
* Basic functionality every type of wizard step needs to provide
*
* @author Marc Arndt
*/
/* tslint:disable-next-line directive-class-suffix */
export class WizardStep {
constructor() {
/**
* A symbol property, which contains an optional symbol for the step inside the navigation bar.
* Takes effect when `stepSymbolTemplate` is not defined or null.
*/
this.navigationSymbol = { symbol: '' };
/**
* A boolean describing if the wizard step is currently selected
*/
this.selected = false;
/**
* A boolean describing if the wizard step has been completed
*/
this.completed = false;
/**
* A boolean describing if the wizard step is shown as completed when the wizard is presented to the user
*
* Users will typically use `CompletedStepDirective` to set this flag
*/
this.initiallyCompleted = false;
/**
* A boolean describing if the wizard step is being edited after being competed
*
* This flag can only be true when `selected` is true.
*/
this.editing = false;
/**
* A boolean describing, if the wizard step should be selected by default, i.e. after the wizard has been initialized as the initial step
*/
this.defaultSelected = false;
/**
* A boolean describing if the wizard step is an optional step
*/
this.optional = false;
/**
* A function or boolean deciding, if this step can be entered
*/
this.canEnter = true;
/**
* A function or boolean deciding, if this step can be exited
*/
this.canExit = true;
/**
* This [[EventEmitter]] is called when the step is entered.
* The bound method should be used to do initialization work.
*/
this.stepEnter = new EventEmitter();
/**
* This [[EventEmitter]] is called when the step is exited.
* The bound method can be used to do cleanup work.
*/
this.stepExit = new EventEmitter();
}
/**
* Returns true if this wizard step should be visible to the user.
* If the step should be visible to the user false is returned, otherwise true
*/
get hidden() {
return !this.selected;
}
/**
* This method returns true, if this wizard step can be transitioned with a given direction.
* Transitioned in this case means either entered or exited, depending on the given `condition` parameter.
*
* @param condition A condition variable, deciding if the step can be transitioned
* @param direction The direction in which this step should be transitioned
* @returns A [[Promise]] containing `true`, if this step can transitioned in the given direction
* @throws An `Error` is thrown if `condition` is neither a function nor a boolean
*/
static canTransitionStep(condition, direction) {
if (typeof (condition) === typeof (true)) {
return Promise.resolve(condition);
}
else if (condition instanceof Function) {
return Promise.resolve(condition(direction));
}
else {
return Promise.reject(new Error(`Input value '${condition}' is neither a boolean nor a function`));
}
}
/**
* A function called when the step is entered
*
* @param direction The direction in which the step is entered
*/
enter(direction) {
this.stepEnter.emit(direction);
}
/**
* A function called when the step is exited
*
* @param direction The direction in which the step is exited
*/
exit(direction) {
this.stepExit.emit(direction);
}
/**
* This method returns true, if this wizard step can be entered from the given direction.
* Because this method depends on the value `canEnter`, it will throw an error, if `canEnter` is neither a boolean
* nor a function.
*
* @param direction The direction in which this step should be entered
* @returns A [[Promise]] containing `true`, if the step can be entered in the given direction, false otherwise
* @throws An `Error` is thrown if `anEnter` is neither a function nor a boolean
*/
canEnterStep(direction) {
return WizardStep.canTransitionStep(this.canEnter, direction);
}
/**
* This method returns true, if this wizard step can be exited into given direction.
* Because this method depends on the value `canExit`, it will throw an error, if `canExit` is neither a boolean
* nor a function.
*
* @param direction The direction in which this step should be left
* @returns A [[Promise]] containing `true`, if the step can be exited in the given direction, false otherwise
* @throws An `Error` is thrown if `canExit` is neither a function nor a boolean
*/
canExitStep(direction) {
return WizardStep.canTransitionStep(this.canExit, direction);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: WizardStep, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: WizardStep, inputs: { stepId: "stepId", stepTitle: "stepTitle", navigationSymbol: "navigationSymbol", canEnter: "canEnter", canExit: "canExit" }, outputs: { stepEnter: "stepEnter", stepExit: "stepExit" }, host: { properties: { "hidden": "this.hidden" } }, queries: [{ propertyName: "stepTitleTemplate", first: true, predicate: WizardStepTitleDirective, descendants: true }, { propertyName: "stepSymbolTemplate", first: true, predicate: WizardStepSymbolDirective, descendants: true }], ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: WizardStep, decorators: [{
type: Directive
}], propDecorators: { stepTitleTemplate: [{
type: ContentChild,
args: [WizardStepTitleDirective]
}], stepSymbolTemplate: [{
type: ContentChild,
args: [WizardStepSymbolDirective]
}], stepId: [{
type: Input
}], stepTitle: [{
type: Input
}], navigationSymbol: [{
type: Input
}], canEnter: [{
type: Input
}], canExit: [{
type: Input
}], stepEnter: [{
type: Output
}], stepExit: [{
type: Output
}], hidden: [{
type: HostBinding,
args: ['hidden']
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard-step.interface.js","sourceRoot":"","sources":["../../../../../src/lib/util/wizard-step.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,yBAAyB,EAAC,MAAM,4CAA4C,CAAC;AACrF,OAAO,EAAC,wBAAwB,EAAC,MAAM,2CAA2C,CAAC;;AAInF;;;;GAIG;AAEH,qDAAqD;AACrD,MAAM,OAAgB,UAAU;IAFhC;QA+BE;;;WAGG;QAEI,qBAAgB,GAAqB,EAAC,MAAM,EAAE,EAAE,EAAC,CAAC;QAEzD;;WAEG;QACI,aAAQ,GAAG,KAAK,CAAC;QAExB;;WAEG;QACI,cAAS,GAAG,KAAK,CAAC;QAEzB;;;;WAIG;QACI,uBAAkB,GAAG,KAAK,CAAC;QAElC;;;;WAIG;QACI,YAAO,GAAG,KAAK,CAAC;QAEvB;;WAEG;QACI,oBAAe,GAAG,KAAK,CAAC;QAE/B;;WAEG;QACI,aAAQ,GAAG,KAAK,CAAC;QAExB;;WAEG;QAEI,aAAQ,GAA6G,IAAI,CAAC;QAEjI;;WAEG;QAEI,YAAO,GAA6G,IAAI,CAAC;QAEhI;;;WAGG;QAEI,cAAS,GAAkC,IAAI,YAAY,EAAmB,CAAC;QAEtF;;;WAGG;QAEI,aAAQ,GAAkC,IAAI,YAAY,EAAmB,CAAC;KA4EtF;IA1EC;;;OAGG;IACH,IACW,MAAM;QACf,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;IACxB,CAAC;IAED;;;;;;;;OAQG;IACK,MAAM,CAAC,iBAAiB,CAAC,SAES,EACT,SAA0B;QACzD,IAAI,OAAM,CAAC,SAAS,CAAC,KAAK,OAAM,CAAC,IAAI,CAAC,EAAE;YACtC,OAAO,OAAO,CAAC,OAAO,CAAC,SAAoB,CAAC,CAAC;SAC9C;aAAM,IAAI,SAAS,YAAY,QAAQ,EAAE;YACxC,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;SAC9C;aAAM;YACL,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gBAAgB,SAAS,uCAAuC,CAAC,CAAC,CAAC;SACpG;IACH,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,SAA0B;QACrC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACI,IAAI,CAAC,SAA0B;QACpC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;OAQG;IACI,YAAY,CAAC,SAA0B;QAC5C,OAAO,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;;;OAQG;IACI,WAAW,CAAC,SAA0B;QAC3C,OAAO,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC/D,CAAC;8GAzKmB,UAAU;kGAAV,UAAU,6TAMhB,wBAAwB,qFAOxB,yBAAyB;;2FAbnB,UAAU;kBAF/B,SAAS;8BASD,iBAAiB;sBADvB,YAAY;uBAAC,wBAAwB;gBAQ/B,kBAAkB;sBADxB,YAAY;uBAAC,yBAAyB;gBAOhC,MAAM;sBADZ,KAAK;gBAQC,SAAS;sBADf,KAAK;gBAQC,gBAAgB;sBADtB,KAAK;gBAyCC,QAAQ;sBADd,KAAK;gBAOC,OAAO;sBADb,KAAK;gBAQC,SAAS;sBADf,MAAM;gBAQA,QAAQ;sBADd,MAAM;gBAQI,MAAM;sBADhB,WAAW;uBAAC,QAAQ","sourcesContent":["import { ContentChild, EventEmitter, HostBinding, Input, Output, Directive } from '@angular/core';\nimport {WizardStepSymbolDirective} from '../directives/wizard-step-symbol.directive';\nimport {WizardStepTitleDirective} from '../directives/wizard-step-title.directive';\nimport {MovingDirection} from './moving-direction.enum';\nimport {NavigationSymbol} from './navigation-symbol.interface';\n\n/**\n * Basic functionality every type of wizard step needs to provide\n *\n * @author Marc Arndt\n */\n@Directive()\n/* tslint:disable-next-line directive-class-suffix */\nexport abstract class WizardStep {\n  /**\n   * A step title property, which contains the visible header title of the step.\n   * This title is then shown inside the navigation bar.\n   * Compared to `stepTitle` this property can contain any html content and not only plain text\n   */\n  @ContentChild(WizardStepTitleDirective)\n  public stepTitleTemplate: WizardStepTitleDirective;\n\n  /**\n   * A step symbol property that, if defined, overrides `navigationSymbol`.\n   * Allows to display arbitrary content as a step symbol instead of plain text.\n   */\n  @ContentChild(WizardStepSymbolDirective)\n  public stepSymbolTemplate: WizardStepSymbolDirective;\n\n  /**\n   * A step id, unique to the step\n   */\n  @Input()\n  public stepId: string;\n\n  /**\n   * A step title property, which contains the visible header title of the step.\n   * This title is only shown inside the navigation bar, if `stepTitleTemplate` is not defined or null.\n   */\n  @Input()\n  public stepTitle: string;\n\n  /**\n   * A symbol property, which contains an optional symbol for the step inside the navigation bar.\n   * Takes effect when `stepSymbolTemplate` is not defined or null.\n   */\n  @Input()\n  public navigationSymbol: NavigationSymbol = {symbol: ''};\n\n  /**\n   * A boolean describing if the wizard step is currently selected\n   */\n  public selected = false;\n\n  /**\n   * A boolean describing if the wizard step has been completed\n   */\n  public completed = false;\n\n  /**\n   * A boolean describing if the wizard step is shown as completed when the wizard is presented to the user\n   *\n   * Users will typically use `CompletedStepDirective` to set this flag\n   */\n  public initiallyCompleted = false;\n\n  /**\n   * A boolean describing if the wizard step is being edited after being competed\n   *\n   * This flag can only be true when `selected` is true.\n   */\n  public editing = false;\n\n  /**\n   * A boolean describing, if the wizard step should be selected by default, i.e. after the wizard has been initialized as the initial step\n   */\n  public defaultSelected = false;\n\n  /**\n   * A boolean describing if the wizard step is an optional step\n   */\n  public optional = false;\n\n  /**\n   * A function or boolean deciding, if this step can be entered\n   */\n  @Input()\n  public canEnter: ((direction: MovingDirection) => boolean) | ((direction: MovingDirection) => Promise<boolean>) | boolean = true;\n\n  /**\n   * A function or boolean deciding, if this step can be exited\n   */\n  @Input()\n  public canExit: ((direction: MovingDirection) => boolean) | ((direction: MovingDirection) => Promise<boolean>) | boolean = true;\n\n  /**\n   * This [[EventEmitter]] is called when the step is entered.\n   * The bound method should be used to do initialization work.\n   */\n  @Output()\n  public stepEnter: EventEmitter<MovingDirection> = new EventEmitter<MovingDirection>();\n\n  /**\n   * This [[EventEmitter]] is called when the step is exited.\n   * The bound method can be used to do cleanup work.\n   */\n  @Output()\n  public stepExit: EventEmitter<MovingDirection> = new EventEmitter<MovingDirection>();\n\n  /**\n   * Returns true if this wizard step should be visible to the user.\n   * If the step should be visible to the user false is returned, otherwise true\n   */\n  @HostBinding('hidden')\n  public get hidden(): boolean {\n    return !this.selected;\n  }\n\n  /**\n   * This method returns true, if this wizard step can be transitioned with a given direction.\n   * Transitioned in this case means either entered or exited, depending on the given `condition` parameter.\n   *\n   * @param condition A condition variable, deciding if the step can be transitioned\n   * @param direction The direction in which this step should be transitioned\n   * @returns A [[Promise]] containing `true`, if this step can transitioned in the given direction\n   * @throws An `Error` is thrown if `condition` is neither a function nor a boolean\n   */\n  private static canTransitionStep(condition: ((direction: MovingDirection) => boolean) |\n                                     ((direction: MovingDirection) => Promise<boolean>) |\n                                     boolean,\n                                   direction: MovingDirection): Promise<boolean> {\n    if (typeof(condition) === typeof(true)) {\n      return Promise.resolve(condition as boolean);\n    } else if (condition instanceof Function) {\n      return Promise.resolve(condition(direction));\n    } else {\n      return Promise.reject(new Error(`Input value '${condition}' is neither a boolean nor a function`));\n    }\n  }\n\n  /**\n   * A function called when the step is entered\n   *\n   * @param direction The direction in which the step is entered\n   */\n  public enter(direction: MovingDirection): void {\n    this.stepEnter.emit(direction);\n  }\n\n  /**\n   * A function called when the step is exited\n   *\n   * @param direction The direction in which the step is exited\n   */\n  public exit(direction: MovingDirection) {\n    this.stepExit.emit(direction);\n  }\n\n  /**\n   * This method returns true, if this wizard step can be entered from the given direction.\n   * Because this method depends on the value `canEnter`, it will throw an error, if `canEnter` is neither a boolean\n   * nor a function.\n   *\n   * @param direction The direction in which this step should be entered\n   * @returns A [[Promise]] containing `true`, if the step can be entered in the given direction, false otherwise\n   * @throws An `Error` is thrown if `anEnter` is neither a function nor a boolean\n   */\n  public canEnterStep(direction: MovingDirection): Promise<boolean> {\n    return WizardStep.canTransitionStep(this.canEnter, direction);\n  }\n\n  /**\n   * This method returns true, if this wizard step can be exited into given direction.\n   * Because this method depends on the value `canExit`, it will throw an error, if `canExit` is neither a boolean\n   * nor a function.\n   *\n   * @param direction The direction in which this step should be left\n   * @returns A [[Promise]] containing `true`, if the step can be exited in the given direction, false otherwise\n   * @throws An `Error` is thrown if `canExit` is neither a function nor a boolean\n   */\n  public canExitStep(direction: MovingDirection): Promise<boolean> {\n    return WizardStep.canTransitionStep(this.canExit, direction);\n  }\n}\n"]}