@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1441

package/esm2022/lib/shared/testing/spy-factory.spec.mjs

@@ -0,0 +1,40 @@
+export class SpyFactory {
+    /**
+     * Create a jasmine Spy Object with spies for the methods of the given type.
+     *
+     * @param {Type<T>} type Type you want as a mock object, full of spies
+     * @returns {jasmine.SpyObj<T>} Spy object, full of spies, with type definitions
+     */
+    static createSpy(type) {
+        const methodNames = Object.getOwnPropertyNames(type.prototype);
+        const spyObj = jasmine.createSpyObj(methodNames);
+        return spyObj;
+    }
+    /**
+     * Create a jasmine Spy Object with spies for the type's properties and methods.
+     *
+     * @param {Type<T>} type Type you want as a mock object
+     * @returns {jasmine.SpyObj<T>} Spy object with method and property spies
+     */
+    static createSpyWithProperties(type) {
+        const methodNames = Object.getOwnPropertyNames(type.prototype);
+        // Passing in "new type()" as the second param here creates spies for the properties
+        // on the provided type that return the default values for each property. To access the spies
+        // to modify return values for these properties, use getPropertySpy()
+        const spyObj = jasmine.createSpyObj(methodNames, new type());
+        return spyObj;
+    }
+    /**
+     * Returns the jasmine spy for the given property on the spy object.
+     * NOTE: This will only work for properties on spy objects created using createSpyWithProperties() as
+     * createSpy() only creates spies for the type's methods
+     *
+     * @param {jasmine.SpyObj<T>} spyObj
+     * @param {K extends keyof T} property
+     * @returns
+     */
+    static getPropertySpy(spyObj, property) {
+        return Object.getOwnPropertyDescriptor(spyObj, property)?.get;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3B5LWZhY3Rvcnkuc3BlYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2xpYi9zaGFyZWQvdGVzdGluZy9zcHktZmFjdG9yeS5zcGVjLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxVQUFVO0lBQ25COzs7OztPQUtHO0lBQ0ksTUFBTSxDQUFDLFNBQVMsQ0FBSSxJQUFhO1FBQ3BDLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDL0QsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQXNCLENBQUM7UUFDdEUsT0FBTyxNQUFNLENBQUM7SUFDbEIsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksTUFBTSxDQUFDLHVCQUF1QixDQUFtQixJQUFhO1FBQ2pFLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDL0Qsb0ZBQW9GO1FBQ3BGLDZGQUE2RjtRQUM3RixxRUFBcUU7UUFDckUsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBc0IsQ0FBQztRQUNsRixPQUFPLE1BQU0sQ0FBQztJQUNsQixDQUFDO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSSxNQUFNLENBQUMsY0FBYyxDQUF1QixNQUF5QixFQUFFLFFBQVc7UUFDckYsT0FBTyxNQUFNLENBQUMsd0JBQXdCLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxFQUFFLEdBQThCLENBQUM7SUFDN0YsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuZXhwb3J0IGNsYXNzIFNweUZhY3Rvcnkge1xyXG4gICAgLyoqXHJcbiAgICAgKiBDcmVhdGUgYSBqYXNtaW5lIFNweSBPYmplY3Qgd2l0aCBzcGllcyBmb3IgdGhlIG1ldGhvZHMgb2YgdGhlIGdpdmVuIHR5cGUuXHJcbiAgICAgKlxyXG4gICAgICogQHBhcmFtIHtUeXBlPFQ+fSB0eXBlIFR5cGUgeW91IHdhbnQgYXMgYSBtb2NrIG9iamVjdCwgZnVsbCBvZiBzcGllc1xyXG4gICAgICogQHJldHVybnMge2phc21pbmUuU3B5T2JqPFQ+fSBTcHkgb2JqZWN0LCBmdWxsIG9mIHNwaWVzLCB3aXRoIHR5cGUgZGVmaW5pdGlvbnNcclxuICAgICAqL1xyXG4gICAgcHVibGljIHN0YXRpYyBjcmVhdGVTcHk8VD4odHlwZTogVHlwZTxUPik6IGphc21pbmUuU3B5T2JqPFQ+IHtcclxuICAgICAgICBjb25zdCBtZXRob2ROYW1lcyA9IE9iamVjdC5nZXRPd25Qcm9wZXJ0eU5hbWVzKHR5cGUucHJvdG90eXBlKTtcclxuICAgICAgICBjb25zdCBzcHlPYmogPSBqYXNtaW5lLmNyZWF0ZVNweU9iaihtZXRob2ROYW1lcykgYXMgamFzbWluZS5TcHlPYmo8VD47XHJcbiAgICAgICAgcmV0dXJuIHNweU9iajtcclxuICAgIH1cclxuXHJcbiAgICAvKipcclxuICAgICAqIENyZWF0ZSBhIGphc21pbmUgU3B5IE9iamVjdCB3aXRoIHNwaWVzIGZvciB0aGUgdHlwZSdzIHByb3BlcnRpZXMgYW5kIG1ldGhvZHMuXHJcbiAgICAgKiBcclxuICAgICAqIEBwYXJhbSB7VHlwZTxUPn0gdHlwZSBUeXBlIHlvdSB3YW50IGFzIGEgbW9jayBvYmplY3RcclxuICAgICAqIEByZXR1cm5zIHtqYXNtaW5lLlNweU9iajxUPn0gU3B5IG9iamVjdCB3aXRoIG1ldGhvZCBhbmQgcHJvcGVydHkgc3BpZXNcclxuICAgICAqL1xyXG4gICAgcHVibGljIHN0YXRpYyBjcmVhdGVTcHlXaXRoUHJvcGVydGllczxUIGV4dGVuZHMgb2JqZWN0Pih0eXBlOiBUeXBlPFQ+KTogamFzbWluZS5TcHlPYmo8VD4ge1xyXG4gICAgICAgIGNvbnN0IG1ldGhvZE5hbWVzID0gT2JqZWN0LmdldE93blByb3BlcnR5TmFtZXModHlwZS5wcm90b3R5cGUpO1xyXG4gICAgICAgIC8vIFBhc3NpbmcgaW4gXCJuZXcgdHlwZSgpXCIgYXMgdGhlIHNlY29uZCBwYXJhbSBoZXJlIGNyZWF0ZXMgc3BpZXMgZm9yIHRoZSBwcm9wZXJ0aWVzXHJcbiAgICAgICAgLy8gb24gdGhlIHByb3ZpZGVkIHR5cGUgdGhhdCByZXR1cm4gdGhlIGRlZmF1bHQgdmFsdWVzIGZvciBlYWNoIHByb3BlcnR5LiBUbyBhY2Nlc3MgdGhlIHNwaWVzXHJcbiAgICAgICAgLy8gdG8gbW9kaWZ5IHJldHVybiB2YWx1ZXMgZm9yIHRoZXNlIHByb3BlcnRpZXMsIHVzZSBnZXRQcm9wZXJ0eVNweSgpXHJcbiAgICAgICAgY29uc3Qgc3B5T2JqID0gamFzbWluZS5jcmVhdGVTcHlPYmoobWV0aG9kTmFtZXMsIG5ldyB0eXBlKCkpIGFzIGphc21pbmUuU3B5T2JqPFQ+O1xyXG4gICAgICAgIHJldHVybiBzcHlPYmo7XHJcbiAgICB9XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBSZXR1cm5zIHRoZSBqYXNtaW5lIHNweSBmb3IgdGhlIGdpdmVuIHByb3BlcnR5IG9uIHRoZSBzcHkgb2JqZWN0LlxyXG4gICAgICogTk9URTogVGhpcyB3aWxsIG9ubHkgd29yayBmb3IgcHJvcGVydGllcyBvbiBzcHkgb2JqZWN0cyBjcmVhdGVkIHVzaW5nIGNyZWF0ZVNweVdpdGhQcm9wZXJ0aWVzKCkgYXNcclxuICAgICAqIGNyZWF0ZVNweSgpIG9ubHkgY3JlYXRlcyBzcGllcyBmb3IgdGhlIHR5cGUncyBtZXRob2RzXHJcbiAgICAgKiBcclxuICAgICAqIEBwYXJhbSB7amFzbWluZS5TcHlPYmo8VD59IHNweU9ialxyXG4gICAgICogQHBhcmFtIHtLIGV4dGVuZHMga2V5b2YgVH0gcHJvcGVydHkgXHJcbiAgICAgKiBAcmV0dXJucyBcclxuICAgICAqL1xyXG4gICAgcHVibGljIHN0YXRpYyBnZXRQcm9wZXJ0eVNweTxULCBLIGV4dGVuZHMga2V5b2YgVD4oc3B5T2JqOiBqYXNtaW5lLlNweU9iajxUPiwgcHJvcGVydHk6IEspOiBqYXNtaW5lLlNweTwoKSA9PiBUW0tdPiB7XHJcbiAgICAgICAgcmV0dXJuIE9iamVjdC5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3Ioc3B5T2JqLCBwcm9wZXJ0eSk/LmdldCBhcyBqYXNtaW5lLlNweTwoKSA9PiBUW0tdPjtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2022/lib/shared/testing/translation-mocks.spec.mjs

@@ -0,0 +1,57 @@
+import { of } from "rxjs";
+export const clickEvent = new MouseEvent('click');
+;
+/**
+ * returns an object that is formatted the same way as an API error would be
+ * if the provided message was the message coming from the API
+ * @param message
+ */
+export function getApiError(message) {
+    return {
+        error: {
+            status: {
+                message: message
+            }
+        }
+    };
+}
+export class MockTranslateService {
+    constructor(suffix) {
+        this.suffix = suffix;
+        this.currentLang = 'en_US';
+    }
+    get(key, interpolateParams) {
+        return of(key + (this.suffix || ''));
+    }
+    stream(key, interpolateParams) {
+        return of(key + (this.suffix || ''));
+    }
+    instant(key, interpolateParams) {
+        return key + (this.suffix || '');
+    }
+    setTranslation(langKey, languagePack, shouldMerge) {
+        //do nothing
+    }
+    setDefaultLang(lang) {
+        //do nothing
+    }
+    use(lang) {
+        //do nothing
+    }
+}
+export class MockTranslationHelperService {
+    translateObjectArray(items, prop) {
+        return Promise.resolve(items);
+    }
+    translateObjectProperty(item, prop, interpolateParams) {
+        return of(item);
+    }
+    getKendoLocaleId() {
+        return 'en';
+    }
+    translateCorePopValue(key, defaultValue) {
+        return defaultValue;
+    }
+    setLanguage() { }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/user-preference.service.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class UserPreferenceService {
+    getPreferences() {
+        return of({ preference: { dateFormat: 'MM/DD/YYYY', timeFormat: 'h:mm:ss a' } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UserPreferenceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UserPreferenceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UserPreferenceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1wcmVmZXJlbmNlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9saWIvc2hhcmVkL3VzZXItcHJlZmVyZW5jZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFVdEMsTUFBTSxPQUFPLHFCQUFxQjtJQUV6QixjQUFjO1FBQ2pCLE9BQU8sRUFBRSxDQUFDLEVBQUMsVUFBVSxFQUFDLEVBQUMsVUFBVSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFDLEVBQUMsQ0FBQyxDQUFDO0lBQ2hGLENBQUM7K0dBSlUscUJBQXFCO21IQUFyQixxQkFBcUIsY0FGdEIsTUFBTTs7NEZBRUwscUJBQXFCO2tCQUhqQyxVQUFVO21CQUFDO29CQUNaLFVBQVUsRUFBRSxNQUFNO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJztcclxuXHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIERhdGVQcmVmZXJlbmNlQ29udGFpbmVyIHtcclxuICBwcmVmZXJlbmNlOiB7ZGF0ZUZvcm1hdDogc3RyaW5nfG51bGx8dW5kZWZpbmVkLCB0aW1lRm9ybWF0OiBzdHJpbmd8bnVsbHx1bmRlZmluZWR9IHwgbnVsbCB8IHVuZGVmaW5lZFxyXG59XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbnByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgVXNlclByZWZlcmVuY2VTZXJ2aWNlIHtcclxuXHJcbiAgcHVibGljIGdldFByZWZlcmVuY2VzKCk6IE9ic2VydmFibGU8RGF0ZVByZWZlcmVuY2VDb250YWluZXI+IHsgXHJcbiAgICAgIHJldHVybiBvZih7cHJlZmVyZW5jZTp7ZGF0ZUZvcm1hdDogJ01NL0REL1lZWVknLCB0aW1lRm9ybWF0OiAnaDptbTpzcyBhJ319KTtcclxuICB9XHJcbiAgXHJcbn1cclxuIl19

package/esm2022/lib/shared/wizard/wizard-base/wizard-base.component.mjs

@@ -0,0 +1,246 @@
+import { Directive } from '@angular/core';
+import { upperFirst } from 'lodash';
+import { takeUntil } from 'rxjs/operators';
+import { TelemetryService } from '../../../core/telemetry.service';
+import { PageBaseComponent } from '../../page/page-base/page-base.component';
+import * as i0 from "@angular/core";
+export class WizardBaseComponent extends PageBaseComponent {
+    get tabGroup() {
+        return this._tabGroup;
+    }
+    set tabGroup(value) {
+        this._tabGroup = value;
+    }
+    get currentTab() {
+        return this._currentTab;
+    }
+    constructor(injector) {
+        super(injector);
+        this.isWizardMode = true;
+        this.showWizardSaveSuccess = false;
+        /** True when there are no custom fields or when in wizard mode on the custom fields tab */
+        this.showSave = true;
+        /** True when in wizard mode you do not want to show the next or save button*/
+        this.hideNextSaveButton = false;
+        /** True when in wizard mode and on the custom fields tab */
+        this.showBack = false;
+        this.cancelLabel = 'Cancel';
+        this.dialogId = '';
+        this.telemetryService = injector.get(TelemetryService);
+    }
+    onFirstInit() {
+        this._tabGroup = this.configureTabs();
+        this.setCurrentTab(this._tabGroup.selected);
+        this.subscribeToTabChanges();
+    }
+    onWizardSaveSuccess() { }
+    async onAfterViewInit() {
+        this.updateButtons();
+    }
+    //
+    // PageBase lifecycle hooks. Override in derived class if needed.
+    //
+    async applyModelUpdates() { }
+    async saveToApi() { }
+    onSaveComplete(entityId) { }
+    async onSave(event) {
+        // Mark the current tab as completed if the tab is valid before attempting to save.
+        if (this._currentTab && this.isCurrentTabValid()) {
+            this._currentTab.completed = true;
+        }
+        await super.onSave(event);
+        if (this.showWizardSaveSuccess) {
+            this.onWizardSaveSuccess();
+            this.telemetryService.trackEvent(`${this.dialogId}_WizardSuccess`);
+        }
+    }
+    /**
+     * Navigates to the next tab in the tab group. Calls canGoToNextTab() to determine if navigating to the next tab
+     * is allowed or not. If tab validation succeeds, enables the next tab (if it is disabled) and selects it.
+     * @memberof WizardBaseComponent
+     */
+    nextTab() {
+        const currentTabIndex = this._tabGroup.items.findIndex(t => t === this._currentTab);
+        // If there is a current tab selected and the current tab is not the last tab,
+        // update the selected tab in the tabGroup to the next tab
+        if (currentTabIndex > -1 && currentTabIndex < this._tabGroup.items.length - 1) {
+            const nextTab = this._tabGroup.items[currentTabIndex + 1];
+            if (this.canGoToNextTab(nextTab)) {
+                // Enable the next tab if it is disabled
+                if (nextTab.disabled) {
+                    nextTab.disabled = false;
+                }
+                this._tabGroup.selected = nextTab;
+                this.telemetryService.trackEvent(`${this.dialogId}_${upperFirst(nextTab.id?.toString())}`);
+            }
+            else {
+                this.onTabChangeFailed();
+            }
+        }
+    }
+    /**
+     * Navigates to the previous tab in the tab group. Calls canGoToPreviousTab() to determine if navigating to the previous tab
+     * is allowed or not. Navigates to the tab if validation succeeds
+     * @memberof WizardBaseComponent
+     */
+    previousTab() {
+        const currentTabIndex = this._tabGroup.items.findIndex(t => t === this._currentTab);
+        // If there is a current tab selected and the current tab is not the first tab,
+        // update the selected tab in the tabGroup to the previous tab
+        if (currentTabIndex > 0 && currentTabIndex < this._tabGroup.items.length) {
+            const prevTab = this._tabGroup.items[currentTabIndex - 1];
+            if (this.canGoToPreviousTab(prevTab)) {
+                this._tabGroup.selected = prevTab;
+                this.telemetryService.trackEvent(`${this.dialogId}_${upperFirst(prevTab.id?.toString())}`);
+            }
+            else {
+                this.onTabChangeFailed();
+            }
+        }
+    }
+    updateButtons() {
+        if (this.isWizardMode) {
+            if (this.currentTab) {
+                const tabIndex = this._tabGroup.items.findIndex(t => t === this.currentTab);
+                if (tabIndex > 0) {
+                    // Show the back button and set the label to the previous tab when not on the first tab
+                    this.showBack = true;
+                    const prevTabKey = this._tabGroup.items[tabIndex - 1].label;
+                    this.backLabel = `${this.translateService.instant('Back_TC')}: ${this.translateService.instant(prevTabKey)}`;
+                }
+                else {
+                    // Hide the back button when on the first tab
+                    this.showBack = false;
+                }
+                if (tabIndex < this._tabGroup.items.length - 1) {
+                    // Show the next button and set the label to the next tab when not on the last tab
+                    this.showSave = false;
+                    const nextTabKey = this._tabGroup.items[tabIndex + 1].label;
+                    this.nextLabel = `${this.translateService.instant('Next_TC')}: ${this.translateService.instant(nextTabKey)}`;
+                }
+                else {
+                    this.nextLabel = undefined;
+                    // Show the save button instead of next when on the last tab
+                    this.showSave = true;
+                }
+            }
+        }
+        else {
+            this.showBack = false;
+            this.showSave = true;
+        }
+    }
+    /**
+     * Used to determine whether navigation to the next tab is prevented or not. Fired in nextTab(), but not when a tab is
+     * clicked or selected programmatically. By default, this checks the validity of the current tab's form model and
+     * prevents navigation if it is invalid. Can be overridden if different logic is needed.
+     * @param nextTab - The tab being navigated to
+     * @memberof WizardBaseComponent
+     */
+    canGoToNextTab(nextTab) {
+        return this.isCurrentTabValid();
+    }
+    /**
+     * Used to determine whether navigation to the previous tab is prevented or not. Fired in previousTab(), but not when a tab is
+     * clicked or selected programmatically. By default, this checks the validity of the current tab's form model and
+     * prevents navigation if it is invalid. Can be overridden if different logic is needed.
+     * @param prevTab - The tab being navigated to
+     * @memberof WizardBaseComponent
+     */
+    canGoToPreviousTab(prevTab) {
+        return this.isCurrentTabValid();
+    }
+    /**
+     * Used to determine whether navigating away from the current tab is prevented or not. Fired any time the selected tab
+     * changes in the tabGroup. By default, this checks the validity of the current tab's form model and prevents navigation
+     * if it is invalid. Can be overridden if different logic is needed.
+     * @memberof WizardBaseComponent
+     */
+    canLeaveCurrentTab() {
+        return this.isCurrentTabValid();
+    }
+    /**
+     * Triggers validation on the current wizard tab's form control. Returns true if the form control is valid, false if not.
+     * Returns true if the formModelPath for the tab is not defined or no form control is found. Can be overridden if different
+     * logic is needed to validate the form control for the current tab.
+     * @memberof WizardBaseComponent
+     */
+    isCurrentTabValid() {
+        if (this._currentTab && this._currentTab.formModelPath) {
+            let formModel = this.formGroup.get(this._currentTab.formModelPath);
+            if (formModel) {
+                formModel.markAllAsTouched();
+                return formModel.valid || formModel.disabled;
+            }
+        }
+        return true;
+    }
+    /**
+     * Fired if navigation to a tab succeeds. Hides the error banner by default, but can be overridden if logic is needed.
+     * @memberof WizardBaseComponent
+     */
+    onTabChangeSuccess() {
+        this.updateButtons();
+        this.hideErrorBanner();
+    }
+    /**
+     * Fired if navigation to a tab fails. By default, shows the error banner with the default invalid form message, but
+     * can be overridden if different logic is needed.
+     * @memberof WizardBaseComponent
+     */
+    onTabChangeFailed() {
+        this.showErrorBanner(this.defaultInvalidFormMessage);
+    }
+    /**
+     * Listen for when the tabGroup's selected item is changed (I.E. when a tab is clicked or selected programmatically)
+     * and navigate to that tab.
+     */
+    subscribeToTabChanges() {
+        // Whenever the tabGroup's selected tab changes, go to the selected tab
+        this._tabGroup.selectedChanges.pipe(takeUntil(this.destroyed)).subscribe(tab => {
+            this.goToTab(tab);
+        });
+    }
+    /**
+     * Triggered when the tabGroup's selected item changes. If the current tab passes validation, updates
+     * the current tab to the selected tab.
+     * @param tab - the tab that was selected
+     */
+    goToTab(tab) {
+        // Only continue if the current tab is not the tab that was selected. They are the same
+        // when we are resetting the tab group's selected tab back to the current tab when validation fails.
+        // Without this check, we could end up in an infinite loop.
+        if (tab !== this._currentTab) {
+            if (this.canLeaveCurrentTab()) {
+                // Mark the current tab as complete before switching
+                if (this._currentTab) {
+                    this._currentTab.completed = true;
+                }
+                this.setCurrentTab(tab);
+                this.onTabChangeSuccess();
+            }
+            else {
+                // Because the tabGroup's selected tab is updated when a tab is clicked before we can run any form validation,
+                // we need to reset the selected tab back to the current tab if validation fails.
+                // Without this we would have no way to prevent the user from leaving the current tab if the form is invalid.
+                this._tabGroup.selected = this._currentTab;
+                this.onTabChangeFailed();
+            }
+        }
+    }
+    /**
+     * Updates the current tab, title, and help.
+     * @param tab Tab to set
+     */
+    setCurrentTab(tab) {
+        this._currentTab = tab;
+        this.help = tab ? tab.help : undefined;
+        this.title = tab ? tab.title : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WizardBaseComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: WizardBaseComponent, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WizardBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/shared/wizard/wizard-base/wizard-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Injector } from '@angular/core';\r\nimport { upperFirst } from 'lodash';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { NavGroup } from '../../../controls/navigation/nav-group';\r\nimport { NavItem } from '../../../controls/navigation/nav-item';\r\nimport { TelemetryService } from '../../../core/telemetry.service';\r\nimport { Help } from '../../../display/help/help-types';\r\nimport { PageBaseComponent, PageInitResult } from '../../page/page-base/page-base.component';\r\n\r\nexport interface WizardTab extends NavItem {\r\n  /**\r\n   * Path to a form group/array/control contained in the form's main form group.\r\n   * Used to map a tab to it's form model for form validation in WizardBaseComponent.\r\n   * See https://angular.io/api/forms/AbstractControl#get-usage-notes for details on paths.\r\n   */\r\n  formModelPath?: string | (string | number)[];\r\n  help?: Help;\r\n  title?: string;\r\n  completed?: boolean;\r\n}\r\n\r\n@Directive()\r\nexport abstract class WizardBaseComponent extends PageBaseComponent {\r\n\r\n  public isWizardMode: boolean = true;\r\n  public showWizardSaveSuccess: boolean = false;\r\n\r\n  /** True when there are no custom fields or when in wizard mode on the custom fields tab */\r\n  public showSave: boolean = true;\r\n\r\n  /** True when in wizard mode you do not want to show the next or save button*/\r\n  public hideNextSaveButton: boolean = false;\r\n\r\n  /** True when in wizard mode and on the custom fields tab */\r\n  public showBack: boolean = false;\r\n\r\n  /** Labels for the cancel, next and back buttons */\r\n  public nextLabel?: string;\r\n  public backLabel?: string;\r\n  public cancelLabel: string = 'Cancel';\r\n\r\n  public dialogId: string = '';\r\n\r\n  /**\r\n   * Contains the available wizard tabs. Passed to TabsComponent.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  private _tabGroup!: NavGroup;\r\n  public get tabGroup(): NavGroup {\r\n    return this._tabGroup;\r\n  }\r\n  public set tabGroup(value: NavGroup) {\r\n    this._tabGroup = value;\r\n  }\r\n\r\n  /**\r\n   * Contains the tab that is currently selected.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  private _currentTab?: WizardTab;\r\n  public get currentTab(): WizardTab | undefined {\r\n    return this._currentTab;\r\n  }\r\n\r\n  protected initPromise!: Promise<WizardBaseComponent>;\r\n\r\n  protected telemetryService: TelemetryService;\r\n\r\n  constructor(injector: Injector) {\r\n    super(injector);\r\n\r\n    this.telemetryService = injector.get(TelemetryService);\r\n  }\r\n\r\n  protected onFirstInit() {\r\n    this._tabGroup = this.configureTabs();\r\n    this.setCurrentTab(this._tabGroup.selected);\r\n    this.subscribeToTabChanges();\r\n  }\r\n\r\n  protected abstract onInit(): Promise<PageInitResult>;\r\n\r\n  protected onWizardSaveSuccess(): void { }\r\n\r\n  protected async onAfterViewInit(): Promise<void> {\r\n    this.updateButtons();\r\n  }\r\n\r\n  //\r\n  // PageBase lifecycle hooks. Override in derived class if needed.\r\n  //\r\n  protected async applyModelUpdates() {}\r\n  protected async saveToApi(): Promise<number|void> {}\r\n  protected onSaveComplete(entityId: number) {}\r\n\r\n  public async onSave(event: Event) {\r\n    // Mark the current tab as completed if the tab is valid before attempting to save.\r\n    if (this._currentTab && this.isCurrentTabValid()) {\r\n      this._currentTab.completed = true;\r\n    }\r\n\r\n    await super.onSave(event);\r\n\r\n    if (this.showWizardSaveSuccess) {\r\n      this.onWizardSaveSuccess();\r\n      this.telemetryService.trackEvent(`${this.dialogId}_WizardSuccess`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Navigates to the next tab in the tab group. Calls canGoToNextTab() to determine if navigating to the next tab\r\n   * is allowed or not. If tab validation succeeds, enables the next tab (if it is disabled) and selects it.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  public nextTab() {\r\n    const currentTabIndex = this._tabGroup.items.findIndex(t => t === this._currentTab);\r\n    // If there is a current tab selected and the current tab is not the last tab,\r\n    // update the selected tab in the tabGroup to the next tab\r\n    if (currentTabIndex > -1 && currentTabIndex < this._tabGroup.items.length - 1) {\r\n      const nextTab = this._tabGroup.items[currentTabIndex + 1];\r\n      if (this.canGoToNextTab(nextTab)) {\r\n        // Enable the next tab if it is disabled\r\n        if (nextTab.disabled) {\r\n          nextTab.disabled = false;\r\n        }\r\n        this._tabGroup.selected = nextTab;\r\n        this.telemetryService.trackEvent(`${this.dialogId}_${upperFirst(nextTab.id?.toString())}`);\r\n      } else {\r\n        this.onTabChangeFailed();\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Navigates to the previous tab in the tab group. Calls canGoToPreviousTab() to determine if navigating to the previous tab\r\n   * is allowed or not. Navigates to the tab if validation succeeds\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  public previousTab() {\r\n    const currentTabIndex = this._tabGroup.items.findIndex(t => t === this._currentTab);\r\n    // If there is a current tab selected and the current tab is not the first tab,\r\n    // update the selected tab in the tabGroup to the previous tab\r\n    if (currentTabIndex > 0 && currentTabIndex < this._tabGroup.items.length) {\r\n      const prevTab = this._tabGroup.items[currentTabIndex - 1];\r\n      if (this.canGoToPreviousTab(prevTab)) {\r\n        this._tabGroup.selected = prevTab;\r\n        this.telemetryService.trackEvent(`${this.dialogId}_${upperFirst(prevTab.id?.toString())}`);\r\n      } else {\r\n        this.onTabChangeFailed();\r\n      }\r\n    }\r\n  }\r\n\r\n  protected updateButtons() {\r\n    if (this.isWizardMode) {\r\n      if (this.currentTab) {\r\n        const tabIndex = this._tabGroup.items.findIndex(t => t === this.currentTab);\r\n        if (tabIndex > 0) {\r\n          // Show the back button and set the label to the previous tab when not on the first tab\r\n          this.showBack = true;\r\n          const prevTabKey = this._tabGroup.items[tabIndex - 1].label!;\r\n          this.backLabel = `${this.translateService.instant('Back_TC')}: ${this.translateService.instant(prevTabKey)}`;\r\n        } else {\r\n          // Hide the back button when on the first tab\r\n          this.showBack = false;\r\n        }\r\n\r\n        if (tabIndex < this._tabGroup.items.length - 1) {\r\n          // Show the next button and set the label to the next tab when not on the last tab\r\n          this.showSave = false;\r\n          const nextTabKey = this._tabGroup.items[tabIndex + 1].label!;\r\n          this.nextLabel = `${this.translateService.instant('Next_TC')}: ${this.translateService.instant(nextTabKey)}`;\r\n        } else {\r\n          this.nextLabel = undefined;\r\n          // Show the save button instead of next when on the last tab\r\n          this.showSave = true;\r\n        }\r\n      }\r\n    } else {\r\n      this.showBack = false;\r\n      this.showSave = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Required to configure the tabs and default tab for the wizard. Runs in onFirstInit, before onInit.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected abstract configureTabs(): NavGroup;\r\n\r\n  /**\r\n   * Used to determine whether navigation to the next tab is prevented or not. Fired in nextTab(), but not when a tab is\r\n   * clicked or selected programmatically. By default, this checks the validity of the current tab's form model and\r\n   * prevents navigation if it is invalid. Can be overridden if different logic is needed.\r\n   * @param nextTab - The tab being navigated to\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected canGoToNextTab(nextTab: WizardTab): boolean {\r\n    return this.isCurrentTabValid();\r\n  }\r\n\r\n  /**\r\n   * Used to determine whether navigation to the previous tab is prevented or not. Fired in previousTab(), but not when a tab is\r\n   * clicked or selected programmatically. By default, this checks the validity of the current tab's form model and\r\n   * prevents navigation if it is invalid. Can be overridden if different logic is needed.\r\n   * @param prevTab - The tab being navigated to\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected canGoToPreviousTab(prevTab: WizardTab): boolean {\r\n    return this.isCurrentTabValid();\r\n  }\r\n\r\n  /**\r\n   * Used to determine whether navigating away from the current tab is prevented or not. Fired any time the selected tab\r\n   * changes in the tabGroup. By default, this checks the validity of the current tab's form model and prevents navigation\r\n   * if it is invalid. Can be overridden if different logic is needed.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected canLeaveCurrentTab(): boolean {\r\n    return this.isCurrentTabValid();\r\n  }\r\n\r\n  /**\r\n   * Triggers validation on the current wizard tab's form control. Returns true if the form control is valid, false if not.\r\n   * Returns true if the formModelPath for the tab is not defined or no form control is found. Can be overridden if different\r\n   * logic is needed to validate the form control for the current tab.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected isCurrentTabValid(): boolean {\r\n    if (this._currentTab && this._currentTab.formModelPath) {\r\n      let formModel = this.formGroup.get(this._currentTab.formModelPath);\r\n      if (formModel) {\r\n        formModel.markAllAsTouched();\r\n        return formModel.valid || formModel.disabled;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Fired if navigation to a tab succeeds. Hides the error banner by default, but can be overridden if logic is needed.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected onTabChangeSuccess(): void {\r\n    this.updateButtons();\r\n    this.hideErrorBanner();\r\n  }\r\n\r\n  /**\r\n   * Fired if navigation to a tab fails. By default, shows the error banner with the default invalid form message, but\r\n   * can be overridden if different logic is needed.\r\n   * @memberof WizardBaseComponent\r\n   */\r\n  protected onTabChangeFailed(): void {\r\n    this.showErrorBanner(this.defaultInvalidFormMessage);\r\n  }\r\n\r\n  /**\r\n   * Listen for when the tabGroup's selected item is changed (I.E. when a tab is clicked or selected programmatically)\r\n   * and navigate to that tab.\r\n   */\r\n  private subscribeToTabChanges() {\r\n    // Whenever the tabGroup's selected tab changes, go to the selected tab\r\n    this._tabGroup.selectedChanges.pipe(takeUntil(this.destroyed)).subscribe(tab => {\r\n      this.goToTab(tab);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Triggered when the tabGroup's selected item changes. If the current tab passes validation, updates\r\n   * the current tab to the selected tab.\r\n   * @param tab - the tab that was selected\r\n   */\r\n  private goToTab(tab: WizardTab) {\r\n    // Only continue if the current tab is not the tab that was selected. They are the same\r\n    // when we are resetting the tab group's selected tab back to the current tab when validation fails.\r\n    // Without this check, we could end up in an infinite loop.\r\n    if (tab !== this._currentTab) {\r\n      if (this.canLeaveCurrentTab()) {\r\n        // Mark the current tab as complete before switching\r\n        if (this._currentTab) {\r\n          this._currentTab.completed = true;\r\n        }\r\n        this.setCurrentTab(tab);\r\n        this.onTabChangeSuccess();\r\n      } else {\r\n        // Because the tabGroup's selected tab is updated when a tab is clicked before we can run any form validation,\r\n        // we need to reset the selected tab back to the current tab if validation fails.\r\n        // Without this we would have no way to prevent the user from leaving the current tab if the form is invalid.\r\n        this._tabGroup.selected = this._currentTab;\r\n        this.onTabChangeFailed();\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Updates the current tab, title, and help.\r\n   * @param tab Tab to set\r\n   */\r\n  private setCurrentTab(tab?: WizardTab) {\r\n    this._currentTab = tab;\r\n    this.help = tab ? tab.help : undefined;\r\n    this.title = tab ? tab.title : undefined;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/shared/wizard/wizard-buttons/wizard-buttons.component.mjs

@@ -0,0 +1,68 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../controls/button/button.component";
+export class WizardButtonsComponent {
+    constructor() {
+        this.nextLabel = 'Next_TC';
+        this.backLabel = 'Back_TC';
+        this.cancelLabel = 'Cancel';
+        this.saveLabel = 'Save';
+        this.cancelId = 'cancelWizardDialog';
+        this.saveId = 'saveWizardDialog';
+        this.tabindex = 0;
+        this.cancel = new EventEmitter();
+        this.save = new EventEmitter();
+        this.nextTab = new EventEmitter();
+        this.previousTab = new EventEmitter();
+    }
+    onCancel() {
+        this.cancel.emit();
+    }
+    onSave(event) {
+        this.save.emit(event);
+    }
+    onPreviousTab() {
+        this.previousTab.emit();
+    }
+    onNextTab() {
+        this.nextTab.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WizardButtonsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: WizardButtonsComponent, selector: "ec-wizard-buttons", inputs: { nextLabel: "nextLabel", backLabel: "backLabel", cancelLabel: "cancelLabel", saveLabel: "saveLabel", cancelId: "cancelId", saveId: "saveId", tabindex: "tabindex", status: "status", showBack: "showBack", showSave: "showSave", hideNextSaveButton: "hideNextSaveButton" }, outputs: { cancel: "cancel", save: "save", nextTab: "nextTab", previousTab: "previousTab" }, ngImport: i0, template: "<ec-button id=\"{{saveId}}\"\r\n           class=\"ml-2\"\r\n           *ngIf=\"!hideNextSaveButton\"\r\n           type=\"primary\"\r\n           [label]=\"(!showSave ? nextLabel : saveLabel)\"\r\n           [tabindex]=\"!tabindex ? 0 : tabindex\"\r\n           (clicked)=\"!showSave ? onNextTab() : onSave($event)\"\r\n           [disabled]=\"status?.status === 'pending' || status?.status === 'error'\">\r\n</ec-button>\r\n<ec-button id=\"previousTab\"\r\n           class=\"ml-2\"\r\n           *ngIf=\"showBack\"\r\n           type=\"secondary\"\r\n           [label]=\"backLabel\"\r\n           [tabindex]=\"!tabindex ? 0 : tabindex+1\"\r\n           (clicked)=\"onPreviousTab()\">\r\n</ec-button>\r\n<ec-button id=\"{{cancelId}}\"\r\n           type=\"secondary\"\r\n           [label]=\"cancelLabel\"\r\n           [tabindex]=\"!tabindex ? 0 : tabindex+2\"\r\n           (clicked)=\"onCancel()\">\r\n</ec-button>\r\n", styles: [":host{display:flex;flex-direction:row-reverse}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.ButtonComponent, selector: "ec-button", inputs: ["id", "disabled", "icon", "label", "badge", "tabindex", "type", "pending", "pendingIcon", "customTemplate", "isSubmit", "autofocus"], outputs: ["clicked"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WizardButtonsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-wizard-buttons', template: "<ec-button id=\"{{saveId}}\"\r\n           class=\"ml-2\"\r\n           *ngIf=\"!hideNextSaveButton\"\r\n           type=\"primary\"\r\n           [label]=\"(!showSave ? nextLabel : saveLabel)\"\r\n           [tabindex]=\"!tabindex ? 0 : tabindex\"\r\n           (clicked)=\"!showSave ? onNextTab() : onSave($event)\"\r\n           [disabled]=\"status?.status === 'pending' || status?.status === 'error'\">\r\n</ec-button>\r\n<ec-button id=\"previousTab\"\r\n           class=\"ml-2\"\r\n           *ngIf=\"showBack\"\r\n           type=\"secondary\"\r\n           [label]=\"backLabel\"\r\n           [tabindex]=\"!tabindex ? 0 : tabindex+1\"\r\n           (clicked)=\"onPreviousTab()\">\r\n</ec-button>\r\n<ec-button id=\"{{cancelId}}\"\r\n           type=\"secondary\"\r\n           [label]=\"cancelLabel\"\r\n           [tabindex]=\"!tabindex ? 0 : tabindex+2\"\r\n           (clicked)=\"onCancel()\">\r\n</ec-button>\r\n", styles: [":host{display:flex;flex-direction:row-reverse}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { nextLabel: [{
+                type: Input
+            }], backLabel: [{
+                type: Input
+            }], cancelLabel: [{
+                type: Input
+            }], saveLabel: [{
+                type: Input
+            }], cancelId: [{
+                type: Input
+            }], saveId: [{
+                type: Input
+            }], tabindex: [{
+                type: Input
+            }], status: [{
+                type: Input
+            }], showBack: [{
+                type: Input
+            }], showSave: [{
+                type: Input
+            }], hideNextSaveButton: [{
+                type: Input
+            }], cancel: [{
+                type: Output
+            }], save: [{
+                type: Output
+            }], nextTab: [{
+                type: Output
+            }], previousTab: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/wizard/wizard-progress/wizard-progress.component.mjs

@@ -0,0 +1,18 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+export class WizardProgressComponent {
+    constructor() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WizardProgressComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: WizardProgressComponent, selector: "ec-wizard-progress", inputs: { tabGroup: "tabGroup", currentTab: "currentTab" }, ngImport: i0, template: "<div *ngFor=\"let tab of tabGroup?.items; index as index; first as isFirst; last as isLast\"\r\n     class=\"progress-tab\"\r\n     [class.ml-2]=\"!isFirst\"\r\n     [class.is-active]=\"currentTab?.id === tab.id\">\r\n\r\n   <i *ngIf=\"tab.completed\"\r\n      class=\"ec-icon icon-check-circle mr-1 font-color-success\"></i>\r\n   <span *ngIf=\"!tab.completed\">{{index+1}}.&nbsp;</span>\r\n   <span>{{tab.label | translate}}</span>\r\n   <i *ngIf=\"!isLast\"\r\n      class=\"ec-icon icon-angle-down rotate-270 ml-2\"></i>\r\n</div>", styles: [":host{display:flex;align-items:center;padding:0 1rem}.progress-tab{display:flex;align-items:center}.progress-tab.is-active{font-weight:700}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WizardProgressComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-wizard-progress', template: "<div *ngFor=\"let tab of tabGroup?.items; index as index; first as isFirst; last as isLast\"\r\n     class=\"progress-tab\"\r\n     [class.ml-2]=\"!isFirst\"\r\n     [class.is-active]=\"currentTab?.id === tab.id\">\r\n\r\n   <i *ngIf=\"tab.completed\"\r\n      class=\"ec-icon icon-check-circle mr-1 font-color-success\"></i>\r\n   <span *ngIf=\"!tab.completed\">{{index+1}}.&nbsp;</span>\r\n   <span>{{tab.label | translate}}</span>\r\n   <i *ngIf=\"!isLast\"\r\n      class=\"ec-icon icon-angle-down rotate-270 ml-2\"></i>\r\n</div>", styles: [":host{display:flex;align-items:center;padding:0 1rem}.progress-tab{display:flex;align-items:center}.progress-tab.is-active{font-weight:700}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { tabGroup: [{
+                type: Input
+            }], currentTab: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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