@design-factory/design-factory 15.2.3 → 16.0.1

package/esm2022/lib/angular/stepper/stepper.directive.mjs

@@ -0,0 +1,174 @@
+import { Directive, ElementRef, HostListener, Renderer2, inject } from '@angular/core';
+import { DfDirectionDetectionService, RightToLeftDirectionEnum } from '../right-to-left/directionDetection.service';
+import { DfStepperService } from './stepper.service';
+import * as i0 from "@angular/core";
+export const DF_STEP_CLASS = 'df-stepper-step';
+export class DfStepperStepDirective {
+    constructor() {
+        this.unlistener = [];
+        this.renderer2 = inject(Renderer2);
+        this.element = inject(ElementRef);
+    }
+    ngOnInit() {
+        this.unlistener.push(this.renderer2.listen(this.element.nativeElement, 'focus', () => {
+            this.handleFocusTabIndex();
+        }));
+        this.unlistener.push(this.renderer2.listen(this.element.nativeElement, 'blur', (event) => {
+            this.handleBlurTabIndex(event);
+        }));
+    }
+    handleFocusTabIndex() {
+        this.element.nativeElement.tabIndex = 0;
+    }
+    handleBlurTabIndex(event) {
+        if (event.relatedTarget &&
+            'classList' in event.relatedTarget &&
+            event.relatedTarget.classList.contains(DF_STEP_CLASS)) {
+            this.element.nativeElement.tabIndex = -1;
+        }
+    }
+    ngOnDestroy() {
+        this.unlistener.forEach((ul) => ul());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperStepDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfStepperStepDirective, isStandalone: true, selector: "[dfStepperStep]", exportAs: ["dfStepperStep"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperStepDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfStepperStep]',
+                    exportAs: 'dfStepperStep',
+                    standalone: true
+                }]
+        }] });
+export class DfStepperDirective {
+    constructor() {
+        this.stepperService = inject(DfStepperService);
+        this.element = inject(ElementRef);
+        this.rtlDirectionService = inject(DfDirectionDetectionService);
+    }
+    ngOnInit() {
+        this.direction = this.rtlDirectionService.getPageDirection(this.element);
+    }
+    handleEnterDown() {
+        this.handleSelect();
+    }
+    handleSpaceDown() {
+        this.handleSelect();
+    }
+    handleGoPrevious() {
+        if (this.direction === RightToLeftDirectionEnum.LeftToRight) {
+            this.arrowLeftInnerHandler();
+        }
+        else {
+            this.arrowRightInnerHandler();
+        }
+    }
+    handleGoNext() {
+        if (this.direction === RightToLeftDirectionEnum.LeftToRight) {
+            this.arrowRightInnerHandler();
+        }
+        else {
+            this.arrowLeftInnerHandler();
+        }
+    }
+    handleKeyDownRight(event) {
+        if (!this.stepperService.state.isVertical) {
+            this.handleGoNext();
+            event.preventDefault();
+        }
+    }
+    handleKeyDown(event) {
+        if (!this.stepperService.state.isVertical) {
+            this.handleGoPrevious();
+            event.preventDefault();
+        }
+    }
+    handleKeyDownUp(event) {
+        if (this.stepperService.state.isVertical) {
+            this.handleGoNext();
+            event.preventDefault();
+        }
+    }
+    handleKeyDownDown(event) {
+        if (this.stepperService.state.isVertical) {
+            this.handleGoPrevious();
+            event.preventDefault();
+        }
+    }
+    getSteps() {
+        return this.element.nativeElement.querySelectorAll(`:scope .${DF_STEP_CLASS}`);
+    }
+    handleSelect() {
+        const listStep = this.getSteps();
+        const currentPos = Array.prototype.indexOf.call(listStep, document.activeElement);
+        if (currentPos !== -1) {
+            listStep[currentPos].click();
+        }
+    }
+    arrowRightInnerHandler() {
+        const listStep = this.getSteps();
+        const currentPos = Array.prototype.indexOf.call(listStep, document.activeElement);
+        // Test if the focus is in the list (otherwise we do nothing)
+        if (currentPos !== -1) {
+            // we put the focus on the next element.
+            if (currentPos === listStep.length - 1) {
+                listStep[0].focus();
+            }
+            else {
+                listStep[currentPos + 1].focus();
+            }
+        }
+    }
+    arrowLeftInnerHandler() {
+        const listStep = this.getSteps();
+        const currentPos = Array.prototype.indexOf.call(listStep, document.activeElement);
+        // Test if the focus is in the list (otherwise we do nothing)
+        if (currentPos !== -1) {
+            // we put the focus on the next element.
+            if (currentPos === 0) {
+                listStep[listStep.length - 1].focus();
+            }
+            else {
+                listStep[currentPos - 1].focus();
+            }
+        }
+    }
+    ngAfterViewChecked() {
+        // Put back the focus on the active elements
+        if (this.stepperService.setFocus) {
+            const listStep = this.getSteps();
+            listStep[this.stepperService.state.active].focus();
+            this.stepperService.resetFocus();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfStepperDirective, isStandalone: true, selector: "[dfStepperLogic]", host: { listeners: { "keydown.Enter": "handleEnterDown()", "keydown.Space": "handleSpaceDown()", "keydown.arrowRight": "handleKeyDownRight($event)", "keydown.arrowLeft": "handleKeyDown($event)", "keydown.arrowDown": "handleKeyDownUp($event)", "keydown.arrowUp": "handleKeyDownDown($event)" } }, exportAs: ["dfStepperLogic"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dfStepperLogic]',
+                    exportAs: 'dfStepperLogic',
+                    standalone: true
+                }]
+        }], propDecorators: { handleEnterDown: [{
+                type: HostListener,
+                args: ['keydown.Enter']
+            }], handleSpaceDown: [{
+                type: HostListener,
+                args: ['keydown.Space']
+            }], handleKeyDownRight: [{
+                type: HostListener,
+                args: ['keydown.arrowRight', ['$event']]
+            }], handleKeyDown: [{
+                type: HostListener,
+                args: ['keydown.arrowLeft', ['$event']]
+            }], handleKeyDownUp: [{
+                type: HostListener,
+                args: ['keydown.arrowDown', ['$event']]
+            }], handleKeyDownDown: [{
+                type: HostListener,
+                args: ['keydown.arrowUp', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepper.directive.js","sourceRoot":"","sources":["../../../../../../projects/design-factory/src/lib/angular/stepper/stepper.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewChecked,\n  Directive,\n  ElementRef,\n  HostListener,\n  OnDestroy,\n  OnInit,\n  Renderer2,\n  inject\n} from '@angular/core';\nimport { DfDirectionDetectionService, RightToLeftDirectionEnum } from '../right-to-left/directionDetection.service';\nimport { DfStepperService } from './stepper.service';\nexport const DF_STEP_CLASS = 'df-stepper-step';\n\n@Directive({\n  selector: '[dfStepperStep]',\n  exportAs: 'dfStepperStep',\n  standalone: true\n})\nexport class DfStepperStepDirective implements OnInit, OnDestroy {\n  private readonly unlistener: Array<() => void> = [];\n\n  private readonly renderer2: Renderer2 = inject(Renderer2);\n  private readonly element: ElementRef = inject(ElementRef);\n\n  ngOnInit() {\n    this.unlistener.push(\n      this.renderer2.listen(this.element.nativeElement, 'focus', () => {\n        this.handleFocusTabIndex();\n      })\n    );\n    this.unlistener.push(\n      this.renderer2.listen(this.element.nativeElement, 'blur', (event: FocusEvent) => {\n        this.handleBlurTabIndex(event);\n      })\n    );\n  }\n\n  handleFocusTabIndex() {\n    this.element.nativeElement.tabIndex = 0;\n  }\n\n  handleBlurTabIndex(event: FocusEvent) {\n    if (\n      event.relatedTarget &&\n      'classList' in event.relatedTarget &&\n      (event.relatedTarget.classList as DOMTokenList).contains(DF_STEP_CLASS)\n    ) {\n      this.element.nativeElement.tabIndex = -1;\n    }\n  }\n\n  ngOnDestroy() {\n    this.unlistener.forEach((ul) => ul());\n  }\n}\n\n@Directive({\n  selector: '[dfStepperLogic]',\n  exportAs: 'dfStepperLogic',\n  standalone: true\n})\nexport class DfStepperDirective implements OnInit, AfterViewChecked {\n  private direction!: string;\n  stepperService = inject(DfStepperService);\n  private readonly element: ElementRef = inject(ElementRef);\n  private readonly rtlDirectionService: DfDirectionDetectionService = inject(DfDirectionDetectionService);\n\n  ngOnInit(): void {\n    this.direction = this.rtlDirectionService.getPageDirection(this.element);\n  }\n\n  @HostListener('keydown.Enter')\n  handleEnterDown() {\n    this.handleSelect();\n  }\n\n  @HostListener('keydown.Space')\n  handleSpaceDown() {\n    this.handleSelect();\n  }\n\n  private handleGoPrevious() {\n    if (this.direction === RightToLeftDirectionEnum.LeftToRight) {\n      this.arrowLeftInnerHandler();\n    } else {\n      this.arrowRightInnerHandler();\n    }\n  }\n\n  private handleGoNext() {\n    if (this.direction === RightToLeftDirectionEnum.LeftToRight) {\n      this.arrowRightInnerHandler();\n    } else {\n      this.arrowLeftInnerHandler();\n    }\n  }\n\n  @HostListener('keydown.arrowRight', ['$event'])\n  handleKeyDownRight(event: KeyboardEvent) {\n    if (!this.stepperService.state.isVertical) {\n      this.handleGoNext();\n      event.preventDefault();\n    }\n  }\n\n  @HostListener('keydown.arrowLeft', ['$event'])\n  handleKeyDown(event: KeyboardEvent) {\n    if (!this.stepperService.state.isVertical) {\n      this.handleGoPrevious();\n      event.preventDefault();\n    }\n  }\n\n  @HostListener('keydown.arrowDown', ['$event'])\n  handleKeyDownUp(event: KeyboardEvent) {\n    if (this.stepperService.state.isVertical) {\n      this.handleGoNext();\n      event.preventDefault();\n    }\n  }\n\n  @HostListener('keydown.arrowUp', ['$event'])\n  handleKeyDownDown(event: KeyboardEvent) {\n    if (this.stepperService.state.isVertical) {\n      this.handleGoPrevious();\n      event.preventDefault();\n    }\n  }\n\n  getSteps(): HTMLButtonElement[] {\n    return this.element.nativeElement.querySelectorAll(`:scope .${DF_STEP_CLASS}`);\n  }\n\n  private handleSelect() {\n    const listStep = this.getSteps();\n    const currentPos = Array.prototype.indexOf.call(listStep, document.activeElement);\n    if (currentPos !== -1) {\n      listStep[currentPos].click();\n    }\n  }\n\n  private arrowRightInnerHandler() {\n    const listStep = this.getSteps();\n    const currentPos = Array.prototype.indexOf.call(listStep, document.activeElement);\n    // Test if the focus is in the list (otherwise we do nothing)\n    if (currentPos !== -1) {\n      // we put the focus on the next element.\n      if (currentPos === listStep.length - 1) {\n        listStep[0].focus();\n      } else {\n        listStep[currentPos + 1].focus();\n      }\n    }\n  }\n\n  private arrowLeftInnerHandler() {\n    const listStep = this.getSteps();\n    const currentPos = Array.prototype.indexOf.call(listStep, document.activeElement);\n    // Test if the focus is in the list (otherwise we do nothing)\n    if (currentPos !== -1) {\n      // we put the focus on the next element.\n      if (currentPos === 0) {\n        listStep[listStep.length - 1].focus();\n      } else {\n        listStep[currentPos - 1].focus();\n      }\n    }\n  }\n\n  ngAfterViewChecked() {\n    // Put back the focus on the active elements\n    if (this.stepperService.setFocus) {\n      const listStep: HTMLButtonElement[] = this.getSteps();\n      listStep[this.stepperService.state.active].focus();\n      this.stepperService.resetFocus();\n    }\n  }\n}\n"]}

package/esm2022/lib/angular/stepper/stepper.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { DfStepperDirective, DfStepperStepDirective } from './stepper.directive';
+import { DfStepperComponent, DfStepperStepContentDirective } from './stepper.component';
+import * as i0 from "@angular/core";
+export class DfStepperModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfStepperModule, imports: [DfStepperDirective, DfStepperStepDirective, DfStepperComponent, DfStepperStepContentDirective], exports: [DfStepperDirective, DfStepperStepDirective, DfStepperComponent, DfStepperStepContentDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperModule, imports: [DfStepperComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DfStepperDirective, DfStepperStepDirective, DfStepperComponent, DfStepperStepContentDirective],
+                    exports: [DfStepperDirective, DfStepperStepDirective, DfStepperComponent, DfStepperStepContentDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tZmFjdG9yeS9zcmMvbGliL2FuZ3VsYXIvc3RlcHBlci9zdGVwcGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxzQkFBc0IsRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQ2hGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSw2QkFBNkIsRUFBQyxNQUFNLHFCQUFxQixDQUFDOztBQU12RixNQUFNLE9BQU8sZUFBZTs4R0FBZixlQUFlOytHQUFmLGVBQWUsWUFIaEIsa0JBQWtCLEVBQUUsc0JBQXNCLEVBQUUsa0JBQWtCLEVBQUUsNkJBQTZCLGFBQzdGLGtCQUFrQixFQUFFLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLDZCQUE2QjsrR0FFNUYsZUFBZSxZQUg0QixrQkFBa0I7OzJGQUc3RCxlQUFlO2tCQUozQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLDZCQUE2QixDQUFDO29CQUN4RyxPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSw2QkFBNkIsQ0FBQztpQkFDekciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRGZTdGVwcGVyRGlyZWN0aXZlLCBEZlN0ZXBwZXJTdGVwRGlyZWN0aXZlfSBmcm9tICcuL3N0ZXBwZXIuZGlyZWN0aXZlJztcbmltcG9ydCB7IERmU3RlcHBlckNvbXBvbmVudCwgRGZTdGVwcGVyU3RlcENvbnRlbnREaXJlY3RpdmV9IGZyb20gJy4vc3RlcHBlci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbRGZTdGVwcGVyRGlyZWN0aXZlLCBEZlN0ZXBwZXJTdGVwRGlyZWN0aXZlLCBEZlN0ZXBwZXJDb21wb25lbnQsIERmU3RlcHBlclN0ZXBDb250ZW50RGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW0RmU3RlcHBlckRpcmVjdGl2ZSwgRGZTdGVwcGVyU3RlcERpcmVjdGl2ZSwgRGZTdGVwcGVyQ29tcG9uZW50LCBEZlN0ZXBwZXJTdGVwQ29udGVudERpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgRGZTdGVwcGVyTW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/angular/stepper/stepper.service.mjs

@@ -0,0 +1,213 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DfStepperService {
+    constructor() {
+        this.setFocus = false;
+        this._stepperState$ = new BehaviorSubject({
+            steps: [],
+            active: 0,
+            isLinear: false,
+            isInline: false,
+            isVertical: false
+        });
+        this._state = {
+            steps: [],
+            active: 0,
+            isLinear: false,
+            isInline: false,
+            isVertical: false
+        };
+        this._completedLabel = 'Completed';
+        this._warningLabel = 'Warning';
+        this._stepperAriaLabel = 'Stepper';
+    }
+    get stepperState$() {
+        return this._stepperState$.asObservable();
+    }
+    // initState must be used to push new Steps to the service
+    get state() {
+        return this._state;
+    }
+    dispatchStepperState() {
+        this._stepperState$.next(this._state);
+    }
+    updateStepperState() {
+        this._state = this.normalizeState(this._state);
+        this.dispatchStepperState();
+    }
+    // API
+    /**
+     * Use this to init the list of Elements from your stepper
+     *
+     * Here we are not deep copying the array --> the function will change it
+     */
+    initStepperState(state) {
+        // normalize the steps here
+        this._state = this.normalizeState(state);
+        this.dispatchStepperState();
+    }
+    /**
+     * Use this to normalize the state of the stepper (completed, warning, current, future)
+     * @param state
+     * @returns
+     */
+    normalizeState(state) {
+        const stepsList = [];
+        for (let i = 0; i < state.steps.length; i++) {
+            if (state.steps[i].warning) {
+                stepsList.push({ ...state.steps[i], type: 'warning' });
+            }
+            else if (i === state.active) {
+                stepsList.push({ ...state.steps[i], type: 'current' });
+            }
+            else if (state.steps[i].completed) {
+                stepsList.push({ ...state.steps[i], type: 'completed' });
+            }
+            else {
+                stepsList.push({ ...state.steps[i], type: 'future' });
+            }
+        }
+        return { ...state, steps: stepsList };
+    }
+    /**
+     * Internal to get the stepper aria label in the template
+     */
+    get stepperAriaLabel() {
+        return this._stepperAriaLabel;
+    }
+    /**
+     * Use this to set the stepper aria label (i18n)
+     */
+    set stepperAriaLabel(label) {
+        this._stepperAriaLabel = label;
+    }
+    /**
+     * Internal to get the completed label in the template
+     */
+    get completedLabel() {
+        return this._completedLabel;
+    }
+    /**
+     * Internal to get the waring label in the template
+     */
+    get warningLabel() {
+        return this._warningLabel;
+    }
+    /**
+     * Use this to set the completed label (i18n)
+     */
+    set completedLabel(label) {
+        this._completedLabel = label;
+    }
+    /**
+     * Use this to set the warning label (i18n)
+     */
+    set warningLabel(label) {
+        this._warningLabel = label;
+    }
+    /**
+     * TODO make it customizable
+     * @param index - index of the step
+     * @returns - string of the step number to display
+     */
+    getStepNumberLabel(index) {
+        return `${index + 1}`;
+    }
+    resetFocus() {
+        this.setFocus = false;
+    }
+    /**
+     *
+     * @param isLinear - true if the stepper is linear
+     */
+    setLinear(isLinear) {
+        this._state.isLinear = isLinear;
+        this.dispatchStepperState();
+    }
+    /**
+     *
+     * @param isInline - true if the stepper is inline
+     */
+    setInline(isInline) {
+        this._state.isInline = isInline;
+        this.dispatchStepperState();
+    }
+    /**
+     *
+     * @param index - index of the step to select start at 0
+     */
+    selectStep(index) {
+        if (index < 0 || index >= this._state.steps.length) {
+            return;
+        }
+        this._state.active = index;
+        this.updateStepperState();
+    }
+    /**
+     * Same as selectStep but with focus on the step selected
+     * @param index - index of the step to select start at 0
+     */
+    selectWithFocus(index) {
+        if (index < 0 || index >= this._state.steps.length) {
+            return;
+        }
+        this.setFocus = true;
+        this.selectStep(index);
+    }
+    /**
+     *
+     * @param index - index of the step to complete start at 0
+     */
+    completeStep(index) {
+        if (index < 0 || index >= this._state.steps.length) {
+            return;
+        }
+        this._state.steps[index].completed = true;
+        this._state.steps[index].warning = false;
+        this.updateStepperState();
+    }
+    /**
+     *
+     * @param index - index of the step to complete start at 0
+     */
+    completeStepAndGoNext(index) {
+        this.completeStep(index);
+        this.selectStep(index + 1);
+    }
+    /**
+     * Attention if the step was completed it will be uncompleted after.
+     * @param index - index of the step to make Warning start at 0
+     * @param warningLabel - label to display in the warning by default it will take the warningLabel if it exists or the label
+     */
+    makeWarning(index, warningLabel) {
+        if (index < 0 || index >= this._state.steps.length) {
+            return;
+        }
+        this._state.steps[index].warning = true;
+        this._state.steps[index].completed = false;
+        this._state.steps[index].warningLabel = warningLabel
+            ? warningLabel
+            : this._state.steps[index].warningLabel
+                ? this._state.steps[index].warningLabel
+                : this._state.steps[index].label;
+        this.updateStepperState();
+    }
+    /**
+     *
+     * @param index - index of the step to remove Warning start at 0
+     */
+    removeWarning(index) {
+        if (index < 0 || index >= this._state.steps.length) {
+            return;
+        }
+        this._state.steps[index].warning = false;
+        this.updateStepperState();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfStepperService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepper.service.js","sourceRoot":"","sources":["../../../../../../projects/design-factory/src/lib/angular/stepper/stepper.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAc,MAAM,MAAM,CAAC;;AAgCnD,MAAM,OAAO,gBAAgB;IAD7B;QAEE,aAAQ,GAAG,KAAK,CAAC;QACA,mBAAc,GAAG,IAAI,eAAe,CAA2B;YAC9E,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;QACK,WAAM,GAA6B;YACzC,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,KAAK;SAClB,CAAC;QACM,oBAAe,GAAG,WAAW,CAAC;QAC9B,kBAAa,GAAG,SAAS,CAAC;QAC1B,sBAAiB,GAAG,SAAS,CAAC;KAyMvC;IAvMC,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IACD,0DAA0D;IAC1D,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAEO,oBAAoB;QAC1B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAEO,kBAAkB;QACxB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAwB,CAAC,CAAC;QACjE,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,MAAM;IACN;;;;OAIG;IACH,gBAAgB,CAAC,KAAqB;QACpC,2BAA2B;QAC3B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAqB;QAClC,MAAM,SAAS,GAA8B,EAAE,CAAC;QAChD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC3C,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE;gBAC1B,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;aACxD;iBAAM,IAAI,CAAC,KAAK,KAAK,CAAC,MAAM,EAAE;gBAC7B,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;aACxD;iBAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE;gBACnC,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;aAC1D;iBAAM;gBACL,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;aACvD;SACF;QACD,OAAO,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,IAAI,gBAAgB,CAAC,KAAa;QAChC,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,IAAI,cAAc,CAAC,KAAa;QAC9B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,IAAI,YAAY,CAAC,KAAa;QAC5B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,KAAa;QAC9B,OAAO,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC;IACxB,CAAC;IAED,UAAU;QACR,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,QAAiB;QACzB,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,QAAiB;QACzB,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAa;QACtB,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;YAClD,OAAO;SACR;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,KAAa;QAC3B,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;YAClD,OAAO;SACR;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,KAAa;QACxB,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;YAClD,OAAO;SACR;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;QACzC,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,qBAAqB,CAAC,KAAa;QACjC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,KAAa,EAAE,YAAqB;QAC9C,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;YAClD,OAAO;SACR;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC;QACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,GAAG,KAAK,CAAC;QAC3C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,YAAY,GAAG,YAAY;YAClD,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,YAAY;gBACvC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,YAAY;gBACvC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC;QACnC,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,KAAa;QACzB,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;YAClD,OAAO;SACR;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;QACzC,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;8GA1NU,gBAAgB;kHAAhB,gBAAgB;;2FAAhB,gBAAgB;kBAD5B,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\n\nexport interface DfStepperStep {\n  warning: boolean;\n  completed: boolean;\n  label: string;\n  ariaControl: string;\n  warningLabel?: string;\n  optionalLabel?: string;\n}\n\nexport type DfStepType = 'warning' | 'current' | 'completed' | 'future';\n\nexport interface DfStepperNormalizedStep extends DfStepperStep {\n  type: DfStepType;\n}\nexport interface DfStepperState {\n  steps: DfStepperStep[];\n  active: number;\n  isLinear: boolean;\n  isInline: boolean;\n  isVertical: boolean;\n}\nexport interface DfStepperNormalizedState {\n  steps: DfStepperNormalizedStep[];\n  active: number;\n  isLinear: boolean;\n  isInline: boolean;\n  isVertical: boolean;\n}\n\n@Injectable()\nexport class DfStepperService {\n  setFocus = false;\n  private readonly _stepperState$ = new BehaviorSubject<DfStepperNormalizedState>({\n    steps: [],\n    active: 0,\n    isLinear: false,\n    isInline: false,\n    isVertical: false\n  });\n  private _state: DfStepperNormalizedState = {\n    steps: [],\n    active: 0,\n    isLinear: false,\n    isInline: false,\n    isVertical: false\n  };\n  private _completedLabel = 'Completed';\n  private _warningLabel = 'Warning';\n  private _stepperAriaLabel = 'Stepper';\n\n  get stepperState$(): Observable<DfStepperNormalizedState> {\n    return this._stepperState$.asObservable();\n  }\n  // initState must be used to push new Steps to the service\n  get state(): DfStepperNormalizedState {\n    return this._state;\n  }\n\n  private dispatchStepperState() {\n    this._stepperState$.next(this._state);\n  }\n\n  private updateStepperState() {\n    this._state = this.normalizeState(this._state as DfStepperState);\n    this.dispatchStepperState();\n  }\n\n  // API\n  /**\n   * Use this to init the list of Elements from your stepper\n   *\n   * Here we are not deep copying the array --> the function will change it\n   */\n  initStepperState(state: DfStepperState) {\n    // normalize the steps here\n    this._state = this.normalizeState(state);\n    this.dispatchStepperState();\n  }\n\n  /**\n   * Use this to normalize the state of the stepper (completed, warning, current, future)\n   * @param state\n   * @returns\n   */\n  normalizeState(state: DfStepperState): DfStepperNormalizedState {\n    const stepsList: DfStepperNormalizedStep[] = [];\n    for (let i = 0; i < state.steps.length; i++) {\n      if (state.steps[i].warning) {\n        stepsList.push({ ...state.steps[i], type: 'warning' });\n      } else if (i === state.active) {\n        stepsList.push({ ...state.steps[i], type: 'current' });\n      } else if (state.steps[i].completed) {\n        stepsList.push({ ...state.steps[i], type: 'completed' });\n      } else {\n        stepsList.push({ ...state.steps[i], type: 'future' });\n      }\n    }\n    return { ...state, steps: stepsList };\n  }\n\n  /**\n   * Internal to get the stepper aria label in the template\n   */\n  get stepperAriaLabel(): string {\n    return this._stepperAriaLabel;\n  }\n\n  /**\n   * Use this to set the stepper aria label (i18n)\n   */\n  set stepperAriaLabel(label: string) {\n    this._stepperAriaLabel = label;\n  }\n\n  /**\n   * Internal to get the completed label in the template\n   */\n  get completedLabel(): string {\n    return this._completedLabel;\n  }\n\n  /**\n   * Internal to get the waring label in the template\n   */\n  get warningLabel(): string {\n    return this._warningLabel;\n  }\n\n  /**\n   * Use this to set the completed label (i18n)\n   */\n  set completedLabel(label: string) {\n    this._completedLabel = label;\n  }\n\n  /**\n   * Use this to set the warning label (i18n)\n   */\n  set warningLabel(label: string) {\n    this._warningLabel = label;\n  }\n\n  /**\n   * TODO make it customizable\n   * @param index - index of the step\n   * @returns - string of the step number to display\n   */\n  getStepNumberLabel(index: number): string {\n    return `${index + 1}`;\n  }\n\n  resetFocus() {\n    this.setFocus = false;\n  }\n\n  /**\n   *\n   * @param isLinear - true if the stepper is linear\n   */\n  setLinear(isLinear: boolean) {\n    this._state.isLinear = isLinear;\n    this.dispatchStepperState();\n  }\n\n  /**\n   *\n   * @param isInline - true if the stepper is inline\n   */\n  setInline(isInline: boolean) {\n    this._state.isInline = isInline;\n    this.dispatchStepperState();\n  }\n\n  /**\n   *\n   * @param index - index of the step to select start at 0\n   */\n  selectStep(index: number) {\n    if (index < 0 || index >= this._state.steps.length) {\n      return;\n    }\n    this._state.active = index;\n    this.updateStepperState();\n  }\n\n  /**\n   * Same as selectStep but with focus on the step selected\n   * @param index - index of the step to select start at 0\n   */\n  selectWithFocus(index: number) {\n    if (index < 0 || index >= this._state.steps.length) {\n      return;\n    }\n    this.setFocus = true;\n    this.selectStep(index);\n  }\n\n  /**\n   *\n   * @param index - index of the step to complete start at 0\n   */\n  completeStep(index: number) {\n    if (index < 0 || index >= this._state.steps.length) {\n      return;\n    }\n    this._state.steps[index].completed = true;\n    this._state.steps[index].warning = false;\n    this.updateStepperState();\n  }\n\n  /**\n   *\n   * @param index - index of the step to complete start at 0\n   */\n  completeStepAndGoNext(index: number) {\n    this.completeStep(index);\n    this.selectStep(index + 1);\n  }\n\n  /**\n   * Attention if the step was completed it will be uncompleted after.\n   * @param index - index of the step to make Warning start at 0\n   * @param warningLabel - label to display in the warning by default it will take the warningLabel if it exists or the label\n   */\n  makeWarning(index: number, warningLabel?: string) {\n    if (index < 0 || index >= this._state.steps.length) {\n      return;\n    }\n    this._state.steps[index].warning = true;\n    this._state.steps[index].completed = false;\n    this._state.steps[index].warningLabel = warningLabel\n      ? warningLabel\n      : this._state.steps[index].warningLabel\n      ? this._state.steps[index].warningLabel\n      : this._state.steps[index].label;\n    this.updateStepperState();\n  }\n\n  /**\n   *\n   * @param index - index of the step to remove Warning start at 0\n   */\n  removeWarning(index: number) {\n    if (index < 0 || index >= this._state.steps.length) {\n      return;\n    }\n    this._state.steps[index].warning = false;\n    this.updateStepperState();\n  }\n}\n"]}

package/esm2022/lib/angular/tooltip/truncate/tooltipTruncate.directive.mjs

@@ -1,5 +1,4 @@
 import { Directive } from '@angular/core';
-import { hasOverflow } from '../../utils/html-element-helper';
 import * as i0 from "@angular/core";
 import * as i1 from "@ng-bootstrap/ng-bootstrap";
 /**
@@ -15,7 +14,10 @@ export class DfTooltipTruncateDirective {
         this.renderer.addClass(this.elementRef.nativeElement, 'text-truncate');
     }
     ngDoCheck() {
-        this.tooltip.disableTooltip = !hasOverflow(this.elementRef.nativeElement);
+        this.tooltip.disableTooltip = !this.hasOverflow(this.elementRef.nativeElement);
+    }
+    hasOverflow(element) {
+        return element?.offsetHeight < element?.scrollHeight || element?.offsetWidth < element?.scrollWidth;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfTooltipTruncateDirective, deps: [{ token: i1.NgbTooltip }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfTooltipTruncateDirective, isStandalone: true, selector: "[dfTooltipTruncate]", exportAs: ["dfTooltipTruncate"], ngImport: i0 }); }
@@ -28,4 +30,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImpor
                     standalone: true
                 }]
         }], ctorParameters: function () { return [{ type: i1.NgbTooltip }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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