@odx/angular 1.0.4 → 2.1.1

package/esm2020/components/wizard/lib/wizard.component.mjs

@@ -0,0 +1,155 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, inject, Input, Output, QueryList, Renderer2, ViewEncapsulation, } from '@angular/core';
+import { WindowRef } from '@odx/angular';
+import { CSSComponent, CSSModifier } from '@odx/angular/internal';
+import { injectElement, Transform, untilDestroyed } from '@odx/angular/utils';
+import { debounceTime, fromEvent, merge, tap } from 'rxjs';
+import { WizardStepComponent } from './components';
+import * as i0 from "@angular/core";
+let WizardComponent = class WizardComponent {
+    constructor() {
+        this.destroyed = untilDestroyed();
+        this.renderer = inject(Renderer2);
+        this.visibleStepsSegments = 0;
+        this.dottedLineStart = this.renderer.createElement('div');
+        this.dottedLineEnd = this.renderer.createElement('div');
+        this.windowRef = inject(WindowRef);
+        this.activeStep = 0;
+        this.element = injectElement();
+        this.vertical = false;
+        this.activeStepChanged = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        if (!this.steps)
+            return;
+        [this.dottedLineStart, this.dottedLineEnd].forEach((l) => this.renderer.addClass(l, 'odx-wizard-step__dotted-line'));
+        this.visibleStepsSegments = this.calculateVisibleStepsSegments();
+        this.setActiveStep();
+        merge(fromEvent(this.windowRef.nativeWindow, 'resize'), this.steps.changes)
+            .pipe(this.destroyed(), debounceTime(600))
+            .subscribe(() => {
+            this.visibleStepsSegments = this.calculateVisibleStepsSegments();
+            this.setHiddenSteps();
+        });
+        this.clickStepSubscriber();
+    }
+    nextStep() {
+        this.activeStep < this.steps.length - 1 && this.changeStepHandler(this.steps.get(this.activeStep + 1));
+    }
+    previousStep() {
+        this.activeStep > 0 && this.changeStepHandler(this.steps.get(this.activeStep - 1));
+    }
+    setActiveStepValid() {
+        this.steps.get(this.activeStep)?.setValid(true);
+    }
+    calculateVisibleStepsSegments() {
+        const container = this.element.nativeElement;
+        const { width, height } = container.getBoundingClientRect();
+        const containerSize = this.vertical ? height : width;
+        let visibleSteps = 0;
+        let summaryStepsSize = 0;
+        const prop = this.vertical ? 'flex-basis' : 'min-width';
+        const minStepSize = parseInt(this.getStyleFromCSS(this.steps.first.element.nativeElement, prop));
+        this.steps.forEach(() => {
+            summaryStepsSize += minStepSize;
+            if (summaryStepsSize < containerSize)
+                visibleSteps++;
+        });
+        return visibleSteps;
+    }
+    getStyleFromCSS(el, prop) {
+        return this.windowRef.nativeWindow.getComputedStyle(el).getPropertyValue(prop);
+    }
+    setActiveStep() {
+        const touched = [];
+        this.steps.forEach((step, index) => {
+            step.active = false;
+            step.isLastTouched = false;
+            if (this.activeStep === index)
+                step.touched = true;
+            step.touched && touched.push(step);
+            this.activeStep === index && (step.active = true);
+            step.passed = index <= this.activeStep;
+        });
+        const lastTouched = touched.pop();
+        lastTouched && (lastTouched.isLastTouched = true);
+        this.setHiddenSteps();
+    }
+    clickStepSubscriber() {
+        merge(...this.steps.map((step) => step.stepChosen$))
+            .pipe(this.destroyed(), tap((step) => this.changeStepHandler(step)))
+            .subscribe();
+    }
+    changeStepHandler(step) {
+        const index = this.steps.toArray().indexOf(step);
+        const isPreviousStepValid = this.steps.get(index - 1)?.valid;
+        const isFirstStepTarget = index === 0;
+        if ((isPreviousStepValid || isFirstStepTarget) && index !== this.activeStep) {
+            this.activeStep = index;
+            this.activeStepChanged.emit(this.activeStep);
+            this.setActiveStep();
+        }
+    }
+    setHiddenSteps() {
+        const length = this.steps.length;
+        [this.dottedLineStart, this.dottedLineEnd].forEach((l) => this.setDottedLineActive(l, true));
+        this.renderer.insertBefore(this.element.nativeElement, this.dottedLineStart, this.steps.get(1)?.element.nativeElement);
+        this.renderer.insertBefore(this.element.nativeElement, this.dottedLineEnd, this.steps.get(length - 1)?.element.nativeElement);
+        const start = this.activeStep < length / 2;
+        const stepsForHide = this.steps.toArray().slice(1, -1);
+        const visibleStepsSegments = this.visibleStepsSegments - 2;
+        stepsForHide.forEach((step, i) => {
+            if (length > this.visibleStepsSegments) {
+                step.visible = start
+                    ? i < visibleStepsSegments - 1 || this.isNeighbors(i, stepsForHide)
+                    : i > stepsForHide.length - (visibleStepsSegments - 1) || this.isNeighbors(i, stepsForHide);
+            }
+            else {
+                step.visible = true;
+            }
+        });
+        const filteredVisibleSteps = stepsForHide.filter((s) => s.visible);
+        if (visibleStepsSegments - 1 < filteredVisibleSteps.length && length > this.visibleStepsSegments) {
+            const overflowSize = filteredVisibleSteps.length - visibleStepsSegments + 1;
+            const index = start ? overflowSize : filteredVisibleSteps.length - overflowSize - 1;
+            filteredVisibleSteps.forEach((s, i) => {
+                (start ? i <= index : i >= index) && !this.isNeighbors(i, filteredVisibleSteps) && (s.visible = false);
+            });
+        }
+        this.steps.last.active && (stepsForHide[stepsForHide.length - 1].visible = true);
+        this.steps.first.active && (stepsForHide[0].visible = true);
+        !this.steps.get(1)?.visible && this.setDottedLineActive(this.dottedLineStart);
+        !this.steps.get(length - 2)?.visible && this.setDottedLineActive(this.dottedLineEnd);
+    }
+    isNeighbors(index, steps) {
+        const activeStep = steps.indexOf(steps.find((s) => s.active));
+        return activeStep !== -1 && (index === activeStep - 1 || index === activeStep + 1 || index === activeStep);
+    }
+    setDottedLineActive(line, unset) {
+        unset ? this.renderer.removeClass(line, 'odx-wizard-step__dotted-line--active') : this.renderer.addClass(line, 'odx-wizard-step__dotted-line--active');
+    }
+};
+WizardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WizardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+WizardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: WizardComponent, isStandalone: true, selector: "odx-wizard", inputs: { vertical: "vertical" }, outputs: { activeStepChanged: "activeStepChanged" }, queries: [{ propertyName: "steps", predicate: WizardStepComponent }], ngImport: i0, template: "<ng-content select=\"odx-wizard-step\"></ng-content>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+__decorate([
+    CSSModifier(),
+    Transform(coerceBooleanProperty),
+    __metadata("design:type", Object)
+], WizardComponent.prototype, "vertical", void 0);
+WizardComponent = __decorate([
+    CSSComponent('wizard')
+], WizardComponent);
+export { WizardComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WizardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'odx-wizard', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<ng-content select=\"odx-wizard-step\"></ng-content>\n" }]
+        }], propDecorators: { steps: [{
+                type: ContentChildren,
+                args: [WizardStepComponent]
+            }], vertical: [{
+                type: Input
+            }], activeStepChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/wizard/src/lib/wizard.component.ts","../../../../../../../libs/angular/components/wizard/src/lib/wizard.component.html"],"names":[],"mappings":";AAAA,OAAO,EAAgB,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAEL,uBAAuB,EACvB,SAAS,EACT,eAAe,EACf,YAAY,EACZ,MAAM,EACN,KAAK,EACL,MAAM,EACN,SAAS,EACT,SAAS,EACT,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;;AAU5C,IAAM,eAAe,GAArB,MAAM,eAAe;IAArB;QAKY,cAAS,GAAG,cAAc,EAAE,CAAC;QAC7B,aAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;QAEtC,yBAAoB,GAAG,CAAC,CAAC;QAChB,oBAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACrD,kBAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAEnD,cAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;QACvC,eAAU,GAAG,CAAC,CAAC;QAEP,YAAO,GAAG,aAAa,EAAE,CAAC;QAKnC,aAAQ,GAAG,KAAK,CAAC;QAGjB,sBAAiB,GAAyB,IAAI,YAAY,EAAE,CAAC;KAmIrE;IAjIQ,eAAe;QACpB,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QACxB,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,8BAA8B,CAAC,CAAC,CAAC;QACrH,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,6BAA6B,EAAE,CAAC;QACjE,IAAI,CAAC,aAAa,EAAE,CAAC;QAErB,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;aACxE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC;aACzC,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,6BAA6B,EAAE,CAAC;YACjE,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAwB,CAAC,CAAC;IAChI,CAAC;IAEM,YAAY;QACjB,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAwB,CAAC,CAAC;IAC5G,CAAC;IAEM,kBAAkB;QACvB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAEO,6BAA6B;QACnC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;QAC7C,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC,qBAAqB,EAAE,CAAC;QAC5D,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;QAErD,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,gBAAgB,GAAG,CAAC,CAAC;QACzB,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC;QACxD,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;QAEjG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE;YACtB,gBAAgB,IAAI,WAAW,CAAC;YAChC,IAAI,gBAAgB,GAAG,aAAa;gBAAE,YAAY,EAAE,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,eAAe,CAAC,EAAe,EAAE,IAAY;QACnD,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACjF,CAAC;IAEO,aAAa;QACnB,MAAM,OAAO,GAA0B,EAAE,CAAC;QAC1C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACjC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAC3B,IAAI,IAAI,CAAC,UAAU,KAAK,KAAK;gBAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACnD,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnC,IAAI,CAAC,UAAU,KAAK,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;YAClD,IAAI,CAAC,MAAM,GAAG,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC;QACzC,CAAC,CAAC,CAAC;QACH,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAClC,WAAW,IAAI,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAEO,mBAAmB;QACzB,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aACjD,IAAI,CACH,IAAI,CAAC,SAAS,EAAE,EAChB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAC5C;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;IAEO,iBAAiB,CAAC,IAAyB;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjD,MAAM,mBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC;QAC7D,MAAM,iBAAiB,GAAG,KAAK,KAAK,CAAC,CAAC;QAEtC,IAAI,CAAC,mBAAmB,IAAI,iBAAiB,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,UAAU,EAAE;YAC3E,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,CAAC,aAAa,EAAE,CAAC;SACtB;IACH,CAAC;IAEO,cAAc;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAEjC,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;QAE7F,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;QACvH,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;QAC9H,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,GAAG,MAAM,GAAG,CAAC,CAAC;QAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACvD,MAAM,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC;QAC3D,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;YAC/B,IAAI,MAAM,GAAG,IAAI,CAAC,oBAAoB,EAAE;gBACtC,IAAI,CAAC,OAAO,GAAG,KAAK;oBAClB,CAAC,CAAC,CAAC,GAAG,oBAAoB,GAAG,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC;oBACnE,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,MAAM,GAAG,CAAC,oBAAoB,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;aAC/F;iBAAM;gBACL,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;aACrB;QACH,CAAC,CAAC,CAAC;QACH,MAAM,oBAAoB,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACnE,IAAI,oBAAoB,GAAG,CAAC,GAAG,oBAAoB,CAAC,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC,oBAAoB,EAAE;YAChG,MAAM,YAAY,GAAG,oBAAoB,CAAC,MAAM,GAAG,oBAAoB,GAAG,CAAC,CAAC;YAC5E,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,oBAAoB,CAAC,MAAM,GAAG,YAAY,GAAG,CAAC,CAAC;YAEpF,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBACpC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;YACzG,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;QACjF,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;QAE5D,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC9E,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,OAAO,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACvF,CAAC;IAEO,WAAW,CAAC,KAAa,EAAE,KAA4B;QAC7D,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAwB,CAAC,CAAC;QACrF,OAAO,UAAU,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,KAAK,UAAU,GAAG,CAAC,IAAI,KAAK,KAAK,UAAU,GAAG,CAAC,IAAI,KAAK,KAAK,UAAU,CAAC,CAAC;IAC7G,CAAC;IAEO,mBAAmB,CAAC,IAAiB,EAAE,KAAe;QAC5D,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,sCAAsC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,sCAAsC,CAAC,CAAC;IACzJ,CAAC;;4GAzJU,eAAe;gGAAf,eAAe,mLAGT,mBAAmB,6BC/BtC,wDACA;AD4CE;IAAC,WAAW,EAAE;IACb,SAAS,CAAC,qBAAqB,CAAC;;iDAET;AApBb,eAAe;IAR3B,YAAY,CAAC,QAAQ,CAAC;GAQV,eAAe,CA0J3B;SA1JY,eAAe;2FAAf,eAAe;kBAP3B,SAAS;+BACE,YAAY,cAEV,IAAI,mBACC,uBAAuB,CAAC,MAAM,iBAChC,iBAAiB,CAAC,IAAI;8BAMpB,KAAK;sBADrB,eAAe;uBAAC,mBAAmB;gBAiB7B,QAAQ;sBADd,KAAK;gBAIC,iBAAiB;sBADvB,MAAM","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  inject,\n  Input,\n  Output,\n  QueryList,\n  Renderer2,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { WindowRef } from '@odx/angular';\nimport { CSSComponent, CSSModifier } from '@odx/angular/internal';\nimport { injectElement, Transform, untilDestroyed } from '@odx/angular/utils';\nimport { debounceTime, fromEvent, merge, tap } from 'rxjs';\nimport { WizardStepComponent } from './components';\n\n@CSSComponent('wizard')\n@Component({\n  selector: 'odx-wizard',\n  templateUrl: './wizard.component.html',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class WizardComponent implements AfterViewInit {\n  public static ngAcceptInputType_vertical: BooleanInput;\n\n  @ContentChildren(WizardStepComponent)\n  private readonly steps!: QueryList<WizardStepComponent>;\n  private readonly destroyed = untilDestroyed();\n  private readonly renderer = inject(Renderer2);\n\n  private visibleStepsSegments = 0;\n  private readonly dottedLineStart = this.renderer.createElement('div');\n  private readonly dottedLineEnd = this.renderer.createElement('div');\n\n  private readonly windowRef = inject(WindowRef);\n  private activeStep = 0;\n\n  public readonly element = injectElement();\n\n  @CSSModifier()\n  @Transform(coerceBooleanProperty)\n  @Input()\n  public vertical = false;\n\n  @Output()\n  public activeStepChanged: EventEmitter<number> = new EventEmitter();\n\n  public ngAfterViewInit(): void {\n    if (!this.steps) return;\n    [this.dottedLineStart, this.dottedLineEnd].forEach((l) => this.renderer.addClass(l, 'odx-wizard-step__dotted-line'));\n    this.visibleStepsSegments = this.calculateVisibleStepsSegments();\n    this.setActiveStep();\n\n    merge(fromEvent(this.windowRef.nativeWindow, 'resize'), this.steps.changes)\n      .pipe(this.destroyed(), debounceTime(600))\n      .subscribe(() => {\n        this.visibleStepsSegments = this.calculateVisibleStepsSegments();\n        this.setHiddenSteps();\n      });\n    this.clickStepSubscriber();\n  }\n\n  public nextStep(): void {\n    this.activeStep < this.steps.length - 1 && this.changeStepHandler(this.steps.get(this.activeStep + 1) as WizardStepComponent);\n  }\n\n  public previousStep(): void {\n    this.activeStep > 0 && this.changeStepHandler(this.steps.get(this.activeStep - 1) as WizardStepComponent);\n  }\n\n  public setActiveStepValid(): void {\n    this.steps.get(this.activeStep)?.setValid(true);\n  }\n\n  private calculateVisibleStepsSegments(): number {\n    const container = this.element.nativeElement;\n    const { width, height } = container.getBoundingClientRect();\n    const containerSize = this.vertical ? height : width;\n\n    let visibleSteps = 0;\n    let summaryStepsSize = 0;\n    const prop = this.vertical ? 'flex-basis' : 'min-width';\n    const minStepSize = parseInt(this.getStyleFromCSS(this.steps.first.element.nativeElement, prop));\n\n    this.steps.forEach(() => {\n      summaryStepsSize += minStepSize;\n      if (summaryStepsSize < containerSize) visibleSteps++;\n    });\n\n    return visibleSteps;\n  }\n\n  private getStyleFromCSS(el: HTMLElement, prop: string): string {\n    return this.windowRef.nativeWindow.getComputedStyle(el).getPropertyValue(prop);\n  }\n\n  private setActiveStep(): void {\n    const touched: WizardStepComponent[] = [];\n    this.steps.forEach((step, index) => {\n      step.active = false;\n      step.isLastTouched = false;\n      if (this.activeStep === index) step.touched = true;\n      step.touched && touched.push(step);\n      this.activeStep === index && (step.active = true);\n      step.passed = index <= this.activeStep;\n    });\n    const lastTouched = touched.pop();\n    lastTouched && (lastTouched.isLastTouched = true);\n    this.setHiddenSteps();\n  }\n\n  private clickStepSubscriber(): void {\n    merge(...this.steps.map((step) => step.stepChosen$))\n      .pipe(\n        this.destroyed(),\n        tap((step) => this.changeStepHandler(step))\n      )\n      .subscribe();\n  }\n\n  private changeStepHandler(step: WizardStepComponent): void {\n    const index = this.steps.toArray().indexOf(step);\n    const isPreviousStepValid = this.steps.get(index - 1)?.valid;\n    const isFirstStepTarget = index === 0;\n\n    if ((isPreviousStepValid || isFirstStepTarget) && index !== this.activeStep) {\n      this.activeStep = index;\n      this.activeStepChanged.emit(this.activeStep);\n      this.setActiveStep();\n    }\n  }\n\n  private setHiddenSteps() {\n    const length = this.steps.length;\n\n    [this.dottedLineStart, this.dottedLineEnd].forEach((l) => this.setDottedLineActive(l, true));\n\n    this.renderer.insertBefore(this.element.nativeElement, this.dottedLineStart, this.steps.get(1)?.element.nativeElement);\n    this.renderer.insertBefore(this.element.nativeElement, this.dottedLineEnd, this.steps.get(length - 1)?.element.nativeElement);\n    const start = this.activeStep < length / 2;\n    const stepsForHide = this.steps.toArray().slice(1, -1);\n    const visibleStepsSegments = this.visibleStepsSegments - 2;\n    stepsForHide.forEach((step, i) => {\n      if (length > this.visibleStepsSegments) {\n        step.visible = start\n          ? i < visibleStepsSegments - 1 || this.isNeighbors(i, stepsForHide)\n          : i > stepsForHide.length - (visibleStepsSegments - 1) || this.isNeighbors(i, stepsForHide);\n      } else {\n        step.visible = true;\n      }\n    });\n    const filteredVisibleSteps = stepsForHide.filter((s) => s.visible);\n    if (visibleStepsSegments - 1 < filteredVisibleSteps.length && length > this.visibleStepsSegments) {\n      const overflowSize = filteredVisibleSteps.length - visibleStepsSegments + 1;\n      const index = start ? overflowSize : filteredVisibleSteps.length - overflowSize - 1;\n\n      filteredVisibleSteps.forEach((s, i) => {\n        (start ? i <= index : i >= index) && !this.isNeighbors(i, filteredVisibleSteps) && (s.visible = false);\n      });\n    }\n\n    this.steps.last.active && (stepsForHide[stepsForHide.length - 1].visible = true);\n    this.steps.first.active && (stepsForHide[0].visible = true);\n\n    !this.steps.get(1)?.visible && this.setDottedLineActive(this.dottedLineStart);\n    !this.steps.get(length - 2)?.visible && this.setDottedLineActive(this.dottedLineEnd);\n  }\n\n  private isNeighbors(index: number, steps: WizardStepComponent[]): boolean {\n    const activeStep = steps.indexOf(steps.find((s) => s.active) as WizardStepComponent);\n    return activeStep !== -1 && (index === activeStep - 1 || index === activeStep + 1 || index === activeStep);\n  }\n\n  private setDottedLineActive(line: HTMLElement, unset?: boolean): void {\n    unset ? this.renderer.removeClass(line, 'odx-wizard-step__dotted-line--active') : this.renderer.addClass(line, 'odx-wizard-step__dotted-line--active');\n  }\n}\n","<ng-content select=\"odx-wizard-step\"></ng-content>\n"]}

package/esm2020/components/wizard/lib/wizard.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CoreModule } from '@odx/angular';
+import { WizardStepComponent } from './components';
+import { WizardComponent } from './wizard.component';
+import * as i0 from "@angular/core";
+const modules = [WizardComponent, WizardStepComponent];
+export class WizardModule {
+}
+WizardModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WizardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+WizardModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: WizardModule, imports: [WizardComponent, WizardStepComponent], exports: [CoreModule, WizardComponent, WizardStepComponent] });
+WizardModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WizardModule, imports: [modules, CoreModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WizardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: modules,
+                    exports: [CoreModule, ...modules],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l6YXJkLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21wb25lbnRzL3dpemFyZC9zcmMvbGliL3dpemFyZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzFDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUNuRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRXJELE1BQU0sT0FBTyxHQUFHLENBQUMsZUFBZSxFQUFFLG1CQUFtQixDQUFDLENBQUM7QUFNdkQsTUFBTSxPQUFPLFlBQVk7O3lHQUFaLFlBQVk7MEdBQVosWUFBWSxZQU5SLGVBQWUsRUFBRSxtQkFBbUIsYUFJekMsVUFBVSxFQUpMLGVBQWUsRUFBRSxtQkFBbUI7MEdBTXhDLFlBQVksWUFIZCxPQUFPLEVBQ04sVUFBVTsyRkFFVCxZQUFZO2tCQUp4QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxPQUFPO29CQUNoQixPQUFPLEVBQUUsQ0FBQyxVQUFVLEVBQUUsR0FBRyxPQUFPLENBQUM7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvcmVNb2R1bGUgfSBmcm9tICdAb2R4L2FuZ3VsYXInO1xuaW1wb3J0IHsgV2l6YXJkU3RlcENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cyc7XG5pbXBvcnQgeyBXaXphcmRDb21wb25lbnQgfSBmcm9tICcuL3dpemFyZC5jb21wb25lbnQnO1xuXG5jb25zdCBtb2R1bGVzID0gW1dpemFyZENvbXBvbmVudCwgV2l6YXJkU3RlcENvbXBvbmVudF07XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IG1vZHVsZXMsXG4gIGV4cG9ydHM6IFtDb3JlTW9kdWxlLCAuLi5tb2R1bGVzXSxcbn0pXG5leHBvcnQgY2xhc3MgV2l6YXJkTW9kdWxlIHt9XG4iXX0=

package/esm2020/components/wizard/odx-angular-components-wizard.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2R4LWFuZ3VsYXItY29tcG9uZW50cy13aXphcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy93aXphcmQvc3JjL29keC1hbmd1bGFyLWNvbXBvbmVudHMtd2l6YXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2020/internal/decorators/css-component.mjs

@@ -16,4 +16,4 @@ export function CSSComponent(name, prefix = 'odx') {
         })(target.prototype.ngOnInit);
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3NzLWNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9pbnRlcm5hbC9zcmMvZGVjb3JhdG9ycy9jc3MtY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVuRCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxxQkFBcUIsQ0FBQyxjQUFjLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFPaEYsZ0JBQWdCO0FBQ2hCLDBCQUEwQjtBQUMxQixNQUFNLFVBQVUsWUFBWSxDQUFDLElBQVksRUFBRSxNQUFNLEdBQUcsS0FBSztJQUN2RCxPQUFPLENBQUMsTUFBMEIsRUFBRSxFQUFFO1FBQ3BDLE1BQU0sUUFBUSxHQUFHLEdBQUcsTUFBTSxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ3JDLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxrQkFBa0IsRUFBRTtZQUMxRCxLQUFLLEVBQUUsUUFBUTtTQUNoQixDQUFDLENBQUM7UUFFSCxDQUFDLFVBQXlCLFFBQXFCO1lBQzdDLE1BQU0sQ0FBQyxTQUFTLENBQUMsUUFBUSxHQUFHO2dCQUMxQixJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO2dCQUNuRCxRQUFRLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3ZCLENBQUMsQ0FBQztRQUNKLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDaEMsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYsIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGRlY29yYXRvclByb3BlcnR5TmFtZSB9IGZyb20gJy4uL2hlbHBlcnMnO1xuXG5leHBvcnQgY29uc3QgQ1NTX0NPTVBPTkVOVF9OQU1FID0gZGVjb3JhdG9yUHJvcGVydHlOYW1lKCdDU1NDb21wb25lbnQnLCAnbmFtZScpO1xuXG4vKiogQGludGVybmFsICovXG5leHBvcnQgaW50ZXJmYWNlIENTU0NvbXBvbmVudCB7XG4gIHJlYWRvbmx5IGVsZW1lbnQ6IEVsZW1lbnRSZWY8SFRNTEVsZW1lbnQ+O1xufVxuXG4vKiogQGludGVybmFsICovXG4vKiBpc3RhbmJ1bCBpZ25vcmUgbmV4dCAqL1xuZXhwb3J0IGZ1bmN0aW9uIENTU0NvbXBvbmVudChuYW1lOiBzdHJpbmcsIHByZWZpeCA9ICdvZHgnKSB7XG4gIHJldHVybiAodGFyZ2V0OiBUeXBlPENTU0NvbXBvbmVudD4pID0+IHtcbiAgICBjb25zdCBjc3NDbGFzcyA9IGAke3ByZWZpeH0tJHtuYW1lfWA7XG4gICAgT2JqZWN0LmRlZmluZVByb3BlcnR5KHRhcmdldC5wcm90b3R5cGUsIENTU19DT01QT05FTlRfTkFNRSwge1xuICAgICAgdmFsdWU6IGNzc0NsYXNzLFxuICAgIH0pO1xuXG4gICAgKGZ1bmN0aW9uICh0aGlzOiB1bmtub3duLCBuZ09uSW5pdD86ICgpID0+IHZvaWQpIHtcbiAgICAgIHRhcmdldC5wcm90b3R5cGUubmdPbkluaXQgPSBmdW5jdGlvbiAodGhpczogQ1NTQ29tcG9uZW50KSB7XG4gICAgICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmNsYXNzTGlzdC5hZGQoY3NzQ2xhc3MpO1xuICAgICAgICBuZ09uSW5pdD8uY2FsbCh0aGlzKTtcbiAgICAgIH07XG4gICAgfSkodGFyZ2V0LnByb3RvdHlwZS5uZ09uSW5pdCk7XG4gIH07XG59XG4iXX0=

package/esm2020/internal/decorators/css-modifier.mjs

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { camelToKebabCase, decoratorPropertyName, ɵwithMultipleDescriptors } from '../helpers';
 import { CSS_COMPONENT_NAME } from './css-component';
 /** @internal */
@@ -23,32 +22,28 @@ export function CSSModifier(options) {
             }
             return null;
         }
+        function getter() {
+            return this[propertySymbol];
+        }
         function setter(value) {
-            const values = options?.isArray ? value : [value];
-            this[propertySymbol] ?? (this[propertySymbol] = []);
-            this[propertyDefaultValue] ?? (this[propertyDefaultValue] = values);
-            for (let i = 0; i < values.length; ++i) {
-                const nextValue = values[i] ?? this[propertyDefaultValue]?.[i] ?? null;
-                const currentValue = this[propertySymbol][i] ?? null;
-                if (this[propertySymbol].length < 1 || nextValue !== currentValue) {
-                    const currentModifierClass = createModifierClass.apply(this, [currentValue]);
-                    if (currentModifierClass !== null) {
-                        this.element.nativeElement.classList.remove(currentModifierClass);
-                    }
-                    this[propertySymbol][i] = nextValue;
-                    const newModifierClass = createModifierClass.apply(this, [nextValue]);
-                    if (newModifierClass !== null && (typeof nextValue === 'boolean' ? nextValue : true)) {
-                        this.element.nativeElement.classList.add(newModifierClass);
-                    }
+            this[propertyDefaultValue] ?? (this[propertyDefaultValue] = value);
+            const currentValue = this[propertySymbol] ?? null;
+            const nextValue = value ?? this[propertyDefaultValue] ?? null;
+            if (nextValue !== currentValue) {
+                const currentModifierClass = createModifierClass.call(this, currentValue);
+                if (currentModifierClass !== null) {
+                    this.element.nativeElement.classList.remove(currentModifierClass);
+                }
+                const newModifierClass = createModifierClass.call(this, nextValue);
+                if (newModifierClass !== null && (typeof nextValue === 'boolean' ? nextValue : true)) {
+                    this.element.nativeElement.classList.add(newModifierClass);
                 }
             }
-        }
-        function getter() {
-            return options?.isArray ? this[propertySymbol] : this[propertySymbol]?.[0];
+            this[propertySymbol] = nextValue;
         }
         descriptors.addSetter(setter);
         descriptors.addGetter(getter);
         descriptors.init();
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/internal/helpers/get-css-variables.mjs

@@ -1,29 +1,22 @@
 /* istanbul ignore next */
-function isSameDomain(styleSheet) {
-    if (!styleSheet.href) {
-        return true;
-    }
-    return styleSheet.href.indexOf(window.location.origin) === 0;
+function isSameDomain({ href }) {
+    return !href || href.startsWith(window.location.origin);
 }
 /** @internal */
 /* istanbul ignore next */
-export function getCSSVariables(filter) {
-    const stylesheets = Array.from(document.styleSheets).filter(isSameDomain);
+export function getCSSVariables(filter, doc) {
+    const stylesheets = Array.from((doc ?? document).styleSheets).filter(isSameDomain);
     return stylesheets.reduce((variables, { cssRules }) => {
-        for (const { style, type } of Array.from(cssRules)) {
-            if (type === 1) {
-                for (const prop of Array.from(style ?? [])) {
-                    const name = prop.trim();
-                    if (name.startsWith('--') && filter.test(name)) {
-                        variables.push({
-                            name: name,
-                            value: style.getPropertyValue(prop).trim(),
-                        });
-                    }
-                }
+        const rules = Array.from(cssRules).filter(({ type }) => type === CSSRule.STYLE_RULE);
+        for (const { style } of rules) {
+            for (const propName of Array.from(style)) {
+                const name = propName.trim();
+                if (!name.startsWith('--') || !filter.test(name))
+                    continue;
+                variables.push({ name, value: style.getPropertyValue(propName).trim() });
             }
         }
         return variables;
     }, []);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/window-ref.mjs

@@ -21,6 +21,9 @@ export class WindowRef {
     getLanguage() {
         return this.nativeWindow.navigator.language;
     }
+    getLanguageCode() {
+        return this.getLanguage().split(/-|_/)[0].toLowerCase();
+    }
     getOrigin() {
         return this.location.origin;
     }
@@ -40,4 +43,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2015/odx-angular-breakpoints.mjs

@@ -0,0 +1,111 @@
+import { createConfigTokens, untilDestroyed } from '@odx/angular/utils';
+import * as i0 from '@angular/core';
+import { inject, Injectable, TemplateRef, ViewContainerRef, Directive, Input, NgModule } from '@angular/core';
+import { coerceArray } from '@angular/cdk/coercion';
+import { of, map, distinctUntilChanged, shareReplay, BehaviorSubject, switchMap, tap } from 'rxjs';
+import { BreakpointObserver } from '@angular/cdk/layout';
+
+function configureBreakpoint(name, min, max) {
+    return {
+        [`<${name}`]: `(max-width: ${min - 1}px)`,
+        [`=${name}`]: `(min-width: ${min}px) and (max-width: ${max - 1}px)`,
+        [`>${name}`]: `(min-width: ${min}px)`,
+    };
+}
+
+const DEFAULT_BREAKPOINTS = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, configureBreakpoint('phone-s', 360, 480)), configureBreakpoint('phone', 480, 768)), configureBreakpoint('tablet', 768, 960)), configureBreakpoint('desktop-s', 960, 1200)), configureBreakpoint('desktop', 1200, 9999));
+const { BreakpointsConfig, BreakpointsDefaultConfig, injectBreakpointsConfig, provideBreakpointsConfig } = createConfigTokens('Breakpoints', '@odx/angular/breakpoints', {
+    breakpoints: DEFAULT_BREAKPOINTS,
+});
+
+class BreakpointsService {
+    constructor() {
+        this.breakpointObserver = inject(BreakpointObserver);
+        this.config = injectBreakpointsConfig();
+    }
+    observe(breakpoints) {
+        const mediaQueries = this.getMediaQueries(breakpoints);
+        return this.createBreakpointObserver(mediaQueries);
+    }
+    matches(breakpoints) {
+        const mediaQueries = this.getMediaQueries(breakpoints);
+        return this.breakpointObserver.isMatched(mediaQueries);
+    }
+    getMediaQueries(breakpointNames) {
+        return breakpointNames.map((name) => this.config.breakpoints[name]).filter(Boolean);
+    }
+    createBreakpointObserver(mediaQueries) {
+        if (mediaQueries.length < 1)
+            return of(false);
+        return this.breakpointObserver.observe(mediaQueries).pipe(map(({ matches }) => matches), distinctUntilChanged(), shareReplay({ refCount: true }));
+    }
+}
+BreakpointsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BreakpointsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class MatchBreakpointsDirective {
+    constructor() {
+        this.breakpoints$$ = new BehaviorSubject([]);
+        this.breakpointsService = inject(BreakpointsService);
+        this.takeUntilDestroyed = untilDestroyed();
+        this.template = inject(TemplateRef);
+        this.viewContainer = inject(ViewContainerRef);
+        // eslint-disable-next-line @angular-eslint/no-input-rename
+        this.elseTemplate = null;
+    }
+    set breakpoints(value) {
+        this.breakpoints$$.next(coerceArray(value !== null && value !== void 0 ? value : []));
+    }
+    ngOnInit() {
+        this.breakpoints$$
+            .pipe(switchMap((breakpoints) => this.breakpointsService.observe(breakpoints)), tap((matchesBreakpoints) => this.render(matchesBreakpoints)), this.takeUntilDestroyed())
+            .subscribe();
+    }
+    render(matchesBreakpoints) {
+        this.viewContainer.clear();
+        const template = matchesBreakpoints ? this.template : this.elseTemplate;
+        if (template) {
+            this.viewContainer.createEmbeddedView(template);
+        }
+    }
+}
+MatchBreakpointsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MatchBreakpointsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+MatchBreakpointsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: MatchBreakpointsDirective, isStandalone: true, selector: "ng-template[odxMatchBreakpoints]", inputs: { breakpoints: ["odxMatchBreakpoints", "breakpoints"], elseTemplate: ["odxMatchBreakpointsElse", "elseTemplate"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MatchBreakpointsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'ng-template[odxMatchBreakpoints]',
+                }]
+        }], propDecorators: { breakpoints: [{
+                type: Input,
+                args: ['odxMatchBreakpoints']
+            }], elseTemplate: [{
+                type: Input,
+                args: ['odxMatchBreakpointsElse']
+            }] } });
+
+const modules = [MatchBreakpointsDirective];
+class BreakpointsModule {
+}
+BreakpointsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BreakpointsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsModule, imports: [MatchBreakpointsDirective], exports: [MatchBreakpointsDirective] });
+BreakpointsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BreakpointsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: modules,
+                    exports: modules,
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BreakpointsConfig, BreakpointsDefaultConfig, BreakpointsModule, BreakpointsService, DEFAULT_BREAKPOINTS, MatchBreakpointsDirective, configureBreakpoint, injectBreakpointsConfig, provideBreakpointsConfig };
+//# sourceMappingURL=odx-angular-breakpoints.mjs.map

package/fesm2015/odx-angular-breakpoints.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"odx-angular-breakpoints.mjs","sources":["../../../../libs/angular/breakpoints/src/lib/helpers/configure-breakpoint.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.config.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.service.ts","../../../../libs/angular/breakpoints/src/lib/directives/match-breakpoints.directive.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.module.ts","../../../../libs/angular/breakpoints/src/odx-angular-breakpoints.ts"],"sourcesContent":["type BreakpointOperators = '<' | '=' | '>';\ntype BreakpointConfig<T extends string> = Record<`${BreakpointOperators}${T}`, string>;\n\nexport function configureBreakpoint<T extends string>(name: T, min: number, max: number): BreakpointConfig<T> {\n  return {\n    [`<${name}` as const]: `(max-width: ${min - 1}px)`,\n    [`=${name}` as const]: `(min-width: ${min}px) and (max-width: ${max - 1}px)`,\n    [`>${name}` as const]: `(min-width: ${min}px)`,\n  } as BreakpointConfig<T>;\n}\n","import { createConfigTokens } from '@odx/angular/utils';\nimport { configureBreakpoint } from './helpers/configure-breakpoint';\n\nexport const DEFAULT_BREAKPOINTS = {\n  ...configureBreakpoint('phone-s', 360, 480),\n  ...configureBreakpoint('phone', 480, 768),\n  ...configureBreakpoint('tablet', 768, 960),\n  ...configureBreakpoint('desktop-s', 960, 1200),\n  ...configureBreakpoint('desktop', 1200, 9999),\n} as const;\n\nexport interface BreakpointsConfig {\n  breakpoints: Partial<OdxAngular.Breakpoints>;\n}\n\nexport const { BreakpointsConfig, BreakpointsDefaultConfig, injectBreakpointsConfig, provideBreakpointsConfig } = createConfigTokens(\n  'Breakpoints',\n  '@odx/angular/breakpoints',\n  {\n    breakpoints: DEFAULT_BREAKPOINTS,\n  } as BreakpointsConfig\n);\n","import { BreakpointObserver } from '@angular/cdk/layout';\nimport { inject, Injectable } from '@angular/core';\nimport { distinctUntilChanged, map, Observable, of, shareReplay } from 'rxjs';\nimport { injectBreakpointsConfig } from './breakpoints.config';\nimport { BreakpointName } from './models';\n\n@Injectable({ providedIn: 'root' })\nexport class BreakpointsService {\n  private readonly breakpointObserver = inject(BreakpointObserver);\n  private readonly config = injectBreakpointsConfig();\n\n  public observe(breakpoints: BreakpointName[]): Observable<boolean> {\n    const mediaQueries = this.getMediaQueries(breakpoints);\n\n    return this.createBreakpointObserver(mediaQueries);\n  }\n\n  public matches(breakpoints: BreakpointName[]): boolean {\n    const mediaQueries = this.getMediaQueries(breakpoints);\n\n    return this.breakpointObserver.isMatched(mediaQueries);\n  }\n\n  private getMediaQueries(breakpointNames: BreakpointName[]): string[] {\n    return breakpointNames.map((name) => this.config.breakpoints[name] as string).filter(Boolean);\n  }\n\n  private createBreakpointObserver(mediaQueries: string[]): Observable<boolean> {\n    if (mediaQueries.length < 1) return of(false);\n\n    return this.breakpointObserver.observe(mediaQueries).pipe(\n      map(({ matches }) => matches),\n      distinctUntilChanged(),\n      shareReplay({ refCount: true })\n    );\n  }\n}\n","import { coerceArray } from '@angular/cdk/coercion';\nimport { Directive, inject, Input, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { untilDestroyed } from '@odx/angular/utils';\nimport { BehaviorSubject, switchMap, tap } from 'rxjs';\nimport { BreakpointsService } from '../breakpoints.service';\nimport { BreakpointName } from '../models';\n\n@Directive({\n  standalone: true,\n  selector: 'ng-template[odxMatchBreakpoints]',\n})\nexport class MatchBreakpointsDirective implements OnInit {\n  private readonly breakpoints$$ = new BehaviorSubject<BreakpointName[]>([]);\n  private readonly breakpointsService = inject(BreakpointsService);\n  private readonly takeUntilDestroyed = untilDestroyed();\n  private readonly template = inject(TemplateRef);\n  private readonly viewContainer = inject(ViewContainerRef);\n\n  @Input('odxMatchBreakpoints')\n  public set breakpoints(value: BreakpointName | BreakpointName[] | null | undefined) {\n    this.breakpoints$$.next(coerceArray(value ?? []));\n  }\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxMatchBreakpointsElse')\n  public elseTemplate?: TemplateRef<unknown> | null = null;\n\n  public ngOnInit(): void {\n    this.breakpoints$$\n      .pipe(\n        switchMap((breakpoints) => this.breakpointsService.observe(breakpoints)),\n        tap((matchesBreakpoints) => this.render(matchesBreakpoints)),\n        this.takeUntilDestroyed()\n      )\n      .subscribe();\n  }\n\n  private render(matchesBreakpoints: boolean): void {\n    this.viewContainer.clear();\n    const template = matchesBreakpoints ? this.template : this.elseTemplate;\n    if (template) {\n      this.viewContainer.createEmbeddedView(template);\n    }\n  }\n}\n","import { NgModule } from '@angular/core';\nimport { MatchBreakpointsDirective } from './directives';\n\nconst modules = [MatchBreakpointsDirective];\n\n@NgModule({\n  imports: modules,\n  exports: modules,\n})\nexport class BreakpointsModule {}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;;;SAGgB,mBAAmB,CAAmB,IAAO,EAAE,GAAW,EAAE,GAAW,EAAA;IACrF,OAAO;QACL,CAAC,CAAA,CAAA,EAAI,IAAI,CAAW,CAAA,GAAG,CAAe,YAAA,EAAA,GAAG,GAAG,CAAC,CAAK,GAAA,CAAA;QAClD,CAAC,CAAA,CAAA,EAAI,IAAI,CAAA,CAAW,GAAG,CAAe,YAAA,EAAA,GAAG,CAAuB,oBAAA,EAAA,GAAG,GAAG,CAAC,CAAK,GAAA,CAAA;AAC5E,QAAA,CAAC,IAAI,IAAI,CAAA,CAAW,GAAG,CAAA,YAAA,EAAe,GAAG,CAAK,GAAA,CAAA;KACxB,CAAC;AAC3B;;MCNa,mBAAmB,GAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAC3B,mBAAmB,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,CAAC,CACxC,EAAA,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA,EACtC,mBAAmB,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,GACvC,mBAAmB,CAAC,WAAW,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA,EAC3C,mBAAmB,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,EACpC;AAME,MAAA,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,GAAG,kBAAkB,CAClI,aAAa,EACb,0BAA0B,EAC1B;AACE,IAAA,WAAW,EAAE,mBAAmB;AACZ,CAAA;;MCbX,kBAAkB,CAAA;AAD/B,IAAA,WAAA,GAAA;AAEmB,QAAA,IAAA,CAAA,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;AAChD,QAAA,IAAM,CAAA,MAAA,GAAG,uBAAuB,EAAE,CAAC;KA2BrD;AAzBQ,IAAA,OAAO,CAAC,WAA6B,EAAA;QAC1C,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;AAEvD,QAAA,OAAO,IAAI,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;KACpD;AAEM,IAAA,OAAO,CAAC,WAA6B,EAAA;QAC1C,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;QAEvD,OAAO,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;KACxD;AAEO,IAAA,eAAe,CAAC,eAAiC,EAAA;QACvD,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAW,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;KAC/F;AAEO,IAAA,wBAAwB,CAAC,YAAsB,EAAA;AACrD,QAAA,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC;AAAE,YAAA,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;AAE9C,QAAA,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,IAAI,CACvD,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,EAC7B,oBAAoB,EAAE,EACtB,WAAW,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAChC,CAAC;KACH;;+GA5BU,kBAAkB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,UAAA,EAAA,CAAA,CAAA;AAAlB,kBAAA,CAAA,KAAA,GAAA,EAAA,CAAA,qBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,QAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,kBAAkB,cADL,MAAM,EAAA,CAAA,CAAA;2FACnB,kBAAkB,EAAA,UAAA,EAAA,CAAA;kBAD9B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE,CAAA;;;MCKrB,yBAAyB,CAAA;AAJtC,IAAA,WAAA,GAAA;QAKmB,IAAA,CAAA,aAAa,GAAG,IAAI,eAAe,CAAmB,EAAE,CAAC,CAAC;AAC1D,QAAA,IAAA,CAAA,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;AAChD,QAAA,IAAkB,CAAA,kBAAA,GAAG,cAAc,EAAE,CAAC;AACtC,QAAA,IAAA,CAAA,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;AAC/B,QAAA,IAAA,CAAA,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;;AASnD,QAAA,IAAY,CAAA,YAAA,GAAiC,IAAI,CAAC;KAmB1D;IA1BC,IACW,WAAW,CAAC,KAA2D,EAAA;AAChF,QAAA,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,KAAL,IAAA,IAAA,KAAK,cAAL,KAAK,GAAI,EAAE,CAAC,CAAC,CAAC;KACnD;IAMM,QAAQ,GAAA;AACb,QAAA,IAAI,CAAC,aAAa;AACf,aAAA,IAAI,CACH,SAAS,CAAC,CAAC,WAAW,KAAK,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,EACxE,GAAG,CAAC,CAAC,kBAAkB,KAAK,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,EAC5D,IAAI,CAAC,kBAAkB,EAAE,CAC1B;AACA,aAAA,SAAS,EAAE,CAAC;KAChB;AAEO,IAAA,MAAM,CAAC,kBAA2B,EAAA;AACxC,QAAA,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;AAC3B,QAAA,MAAM,QAAQ,GAAG,kBAAkB,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC;AACxE,QAAA,IAAI,QAAQ,EAAE;AACZ,YAAA,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AACjD,SAAA;KACF;;sHAhCU,yBAAyB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA,CAAA;0GAAzB,yBAAyB,EAAA,YAAA,EAAA,IAAA,EAAA,QAAA,EAAA,kCAAA,EAAA,MAAA,EAAA,EAAA,WAAA,EAAA,CAAA,qBAAA,EAAA,aAAA,CAAA,EAAA,YAAA,EAAA,CAAA,yBAAA,EAAA,cAAA,CAAA,EAAA,EAAA,QAAA,EAAA,EAAA,EAAA,CAAA,CAAA;2FAAzB,yBAAyB,EAAA,UAAA,EAAA,CAAA;kBAJrC,SAAS;AAAC,YAAA,IAAA,EAAA,CAAA;AACT,oBAAA,UAAU,EAAE,IAAI;AAChB,oBAAA,QAAQ,EAAE,kCAAkC;iBAC7C,CAAA;8BASY,WAAW,EAAA,CAAA;sBADrB,KAAK;uBAAC,qBAAqB,CAAA;gBAOrB,YAAY,EAAA,CAAA;sBADlB,KAAK;uBAAC,yBAAyB,CAAA;;;ACrBlC,MAAM,OAAO,GAAG,CAAC,yBAAyB,CAAC,CAAC;MAM/B,iBAAiB,CAAA;;8GAAjB,iBAAiB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,QAAA,EAAA,CAAA,CAAA;+GAAjB,iBAAiB,EAAA,OAAA,EAAA,CANb,yBAAyB,CAAA,EAAA,OAAA,EAAA,CAAzB,yBAAyB,CAAA,EAAA,CAAA,CAAA;+GAM7B,iBAAiB,EAAA,CAAA,CAAA;2FAAjB,iBAAiB,EAAA,UAAA,EAAA,CAAA;kBAJ7B,QAAQ;AAAC,YAAA,IAAA,EAAA,CAAA;AACR,oBAAA,OAAO,EAAE,OAAO;AAChB,oBAAA,OAAO,EAAE,OAAO;iBACjB,CAAA;;;ACRD;;AAEG;;;;"}