@dsivd/prestations-ng 15.5.13 → 16.0.0-beta2

package/esm2020/foehn-nav13/foehn-input-nav13.module.mjs

@@ -0,0 +1,32 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FoehnInputModule } from '../foehn-input/foehn-input.module';
+import { FoehnValidationAlertsModule } from '../foehn-validation-alerts/foehn-validation-alerts.module';
+import { SdkDictionaryModule } from '../sdk-dictionary/sdk-dictionary.module';
+import { FoehnInputNav13Component } from './foehn-input-nav13.component';
+import * as i0 from "@angular/core";
+export class FoehnInputNav13Module {
+}
+FoehnInputNav13Module.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnInputNav13Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FoehnInputNav13Module.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.2", ngImport: i0, type: FoehnInputNav13Module, declarations: [FoehnInputNav13Component], imports: [CommonModule,
+        FoehnValidationAlertsModule,
+        FoehnInputModule,
+        SdkDictionaryModule], exports: [FoehnInputNav13Component] });
+FoehnInputNav13Module.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnInputNav13Module, imports: [CommonModule,
+        FoehnValidationAlertsModule,
+        FoehnInputModule,
+        SdkDictionaryModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnInputNav13Module, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FoehnValidationAlertsModule,
+                        FoehnInputModule,
+                        SdkDictionaryModule
+                    ],
+                    declarations: [FoehnInputNav13Component],
+                    exports: [FoehnInputNav13Component]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/foehn-navigation/foehn-navigation.component.mjs

@@ -0,0 +1,94 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./foehn-navigation.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+import * as i4 from "../foehn-icons/foehn-icon-chevron-left.component";
+import * as i5 from "../foehn-icons/foehn-icon-chevron-right.component";
+import * as i6 from "../gesdem-action-recovery/gesdem-action-recovery-registration/gesdem-action-recovery-registration.component";
+import * as i7 from "../sdk-dictionary/sdk-dictionary.pipe";
+export class FoehnNavigationComponent {
+    constructor(navigationService, activatedRoute) {
+        this.navigationService = navigationService;
+        this.activatedRoute = activatedRoute;
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onNext = new EventEmitter();
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onPrevious = new EventEmitter();
+        this.nextLabel = 'foehn-navigation.next.label';
+        this.prevLabel = 'foehn-navigation.previous.label';
+        this.transmitLabel = 'foehn-navigation.transmit.label';
+        this.continueLaterLabel = 'foehn-navigation.continue-later.label';
+        this.showContinueLaterButton = true;
+        this.showNextButton = true;
+    }
+    ngOnInit() {
+        this.navigationService.activatedRoute = this.activatedRoute;
+        this.navigationService.updateRouteInformations();
+    }
+    goToNext() {
+        this.onNext.emit();
+    }
+    goToPrevious() {
+        this.onPrevious.emit();
+    }
+    canShowNextButton() {
+        if (!this.showNextButton) {
+            // In case the user explicitly disable the next button, for validation or error purposes.
+            return false;
+        }
+        const nextRouteIndex = this.getNextRouteIndex();
+        if (nextRouteIndex === null) {
+            return false;
+        }
+        // This assumes that the route orders are lower than the last one. For instance the last one being the confirmation page,
+        // its order must be greater than all the other orders.
+        return nextRouteIndex <= this.navigationService.getLastRouteOrder();
+    }
+    canShowPreviousButton() {
+        return !this.navigationService.isFirstFormPage();
+    }
+    isLastFormPage() {
+        return this.navigationService.isLastFormPage();
+    }
+    getNextRouteIndex() {
+        return this.navigationService.getNextRouteIndex();
+    }
+    getPreviousRouteIndex() {
+        return this.navigationService.getPreviousRouteIndex();
+    }
+    getTotalRoutesSize() {
+        // Assumes that last route is the confirmation page and thus isn't considered as a step.
+        return this.navigationService.getTotalRoutesSize() - 1;
+    }
+    isLinearRouting() {
+        return this.navigationService.isLinearRouting();
+    }
+}
+FoehnNavigationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationComponent, deps: [{ token: i1.FoehnNavigationService }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+FoehnNavigationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.2", type: FoehnNavigationComponent, selector: "foehn-navigation", inputs: { nextLabel: "nextLabel", prevLabel: "prevLabel", transmitLabel: "transmitLabel", continueLaterLabel: "continueLaterLabel", showContinueLaterButton: "showContinueLaterButton", showNextButton: "showNextButton" }, outputs: { onNext: "onNext", onPrevious: "onPrevious" }, ngImport: i0, template: "<gesdem-action-recovery-registration\n    *ngIf=\"showContinueLaterButton\"\n    [continueLaterLabel]=\"continueLaterLabel | fromDictionary\"\n></gesdem-action-recovery-registration>\n\n<nav class=\"vd-pagination\" id=\"foehn_navContainer\" aria-label=\"Pagination\">\n    <ul class=\"vd-pagination__list\">\n        <li\n            class=\"vd-pagination__item vd-pagination__item--previous\"\n            *ngIf=\"canShowPreviousButton()\"\n        >\n            <button\n                id=\"prevButton\"\n                type=\"button\"\n                class=\"btn-link vd-pagination__link vd-pagination__link-reset\"\n                (click)=\"$event.preventDefault(); goToPrevious()\"\n            >\n                <span class=\"vd-pagination__title\">\n                    <foehn-icon-chevron-left\n                        class=\"mr-1\"\n                        aria-hidden=\"true\"\n                    ></foehn-icon-chevron-left>\n                    {{ prevLabel | fromDictionary }}\n                </span>\n                <span class=\"sr-only\" *ngIf=\"isLinearRouting()\">:</span>\n                <span class=\"vd-pagination__label\" *ngIf=\"isLinearRouting()\">\n                    {{ getPreviousRouteIndex() }}\n                    {{\n                        'foehn-navigation.route.index.separator'\n                            | fromDictionary\n                    }}\n                    {{ getTotalRoutesSize() }}\n                </span>\n            </button>\n        </li>\n        <li\n            class=\"vd-pagination__item vd-pagination__item--next\"\n            *ngIf=\"!isLastFormPage() && canShowNextButton()\"\n        >\n            <button\n                id=\"nextButton\"\n                type=\"submit\"\n                class=\"btn-link vd-pagination__link vd-pagination__link-reset\"\n                (click)=\"$event.preventDefault(); goToNext()\"\n            >\n                <span class=\"vd-pagination__title\">\n                    {{ nextLabel | fromDictionary }}\n                    <foehn-icon-chevron-right\n                        class=\"ml-1\"\n                        aria-hidden=\"true\"\n                    ></foehn-icon-chevron-right>\n                </span>\n                <span class=\"sr-only\" *ngIf=\"isLinearRouting()\">:</span>\n                <span class=\"vd-pagination__label\" *ngIf=\"isLinearRouting()\">\n                    {{ getNextRouteIndex() }}\n                    {{\n                        'foehn-navigation.route.index.separator'\n                            | fromDictionary\n                    }}\n                    {{ getTotalRoutesSize() }}\n                </span>\n            </button>\n        </li>\n        <li\n            class=\"vd-pagination__item vd-pagination__item--next\"\n            *ngIf=\"isLastFormPage() && canShowNextButton()\"\n        >\n            <button\n                *ngIf=\"isLastFormPage() && canShowNextButton()\"\n                type=\"submit\"\n                id=\"transmitButton\"\n                (click)=\"goToNext()\"\n                class=\"btn btn-success vd-btn-pagination-submit\"\n            >\n                {{ transmitLabel | fromDictionary }}\n            </button>\n        </li>\n    </ul>\n</nav>\n", styles: [".vd-pagination__link-reset{background:none;border:none;font-weight:inherit;text-decoration-line:none;text-align:inherit;cursor:pointer}.vd-pagination__link-reset:focus{background-color:var(--vd-focus)}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.FoehnIconChevronLeftComponent, selector: "foehn-icon-chevron-left" }, { kind: "component", type: i5.FoehnIconChevronRightComponent, selector: "foehn-icon-chevron-right" }, { kind: "component", type: i6.GesdemActionRecoveryRegistrationComponent, selector: "gesdem-action-recovery-registration", inputs: ["continueLaterLabel"] }, { kind: "pipe", type: i7.SdkDictionaryPipe, name: "fromDictionary" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'foehn-navigation', template: "<gesdem-action-recovery-registration\n    *ngIf=\"showContinueLaterButton\"\n    [continueLaterLabel]=\"continueLaterLabel | fromDictionary\"\n></gesdem-action-recovery-registration>\n\n<nav class=\"vd-pagination\" id=\"foehn_navContainer\" aria-label=\"Pagination\">\n    <ul class=\"vd-pagination__list\">\n        <li\n            class=\"vd-pagination__item vd-pagination__item--previous\"\n            *ngIf=\"canShowPreviousButton()\"\n        >\n            <button\n                id=\"prevButton\"\n                type=\"button\"\n                class=\"btn-link vd-pagination__link vd-pagination__link-reset\"\n                (click)=\"$event.preventDefault(); goToPrevious()\"\n            >\n                <span class=\"vd-pagination__title\">\n                    <foehn-icon-chevron-left\n                        class=\"mr-1\"\n                        aria-hidden=\"true\"\n                    ></foehn-icon-chevron-left>\n                    {{ prevLabel | fromDictionary }}\n                </span>\n                <span class=\"sr-only\" *ngIf=\"isLinearRouting()\">:</span>\n                <span class=\"vd-pagination__label\" *ngIf=\"isLinearRouting()\">\n                    {{ getPreviousRouteIndex() }}\n                    {{\n                        'foehn-navigation.route.index.separator'\n                            | fromDictionary\n                    }}\n                    {{ getTotalRoutesSize() }}\n                </span>\n            </button>\n        </li>\n        <li\n            class=\"vd-pagination__item vd-pagination__item--next\"\n            *ngIf=\"!isLastFormPage() && canShowNextButton()\"\n        >\n            <button\n                id=\"nextButton\"\n                type=\"submit\"\n                class=\"btn-link vd-pagination__link vd-pagination__link-reset\"\n                (click)=\"$event.preventDefault(); goToNext()\"\n            >\n                <span class=\"vd-pagination__title\">\n                    {{ nextLabel | fromDictionary }}\n                    <foehn-icon-chevron-right\n                        class=\"ml-1\"\n                        aria-hidden=\"true\"\n                    ></foehn-icon-chevron-right>\n                </span>\n                <span class=\"sr-only\" *ngIf=\"isLinearRouting()\">:</span>\n                <span class=\"vd-pagination__label\" *ngIf=\"isLinearRouting()\">\n                    {{ getNextRouteIndex() }}\n                    {{\n                        'foehn-navigation.route.index.separator'\n                            | fromDictionary\n                    }}\n                    {{ getTotalRoutesSize() }}\n                </span>\n            </button>\n        </li>\n        <li\n            class=\"vd-pagination__item vd-pagination__item--next\"\n            *ngIf=\"isLastFormPage() && canShowNextButton()\"\n        >\n            <button\n                *ngIf=\"isLastFormPage() && canShowNextButton()\"\n                type=\"submit\"\n                id=\"transmitButton\"\n                (click)=\"goToNext()\"\n                class=\"btn btn-success vd-btn-pagination-submit\"\n            >\n                {{ transmitLabel | fromDictionary }}\n            </button>\n        </li>\n    </ul>\n</nav>\n", styles: [".vd-pagination__link-reset{background:none;border:none;font-weight:inherit;text-decoration-line:none;text-align:inherit;cursor:pointer}.vd-pagination__link-reset:focus{background-color:var(--vd-focus)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.FoehnNavigationService }, { type: i2.ActivatedRoute }]; }, propDecorators: { 
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        onNext: [{
+                type: Output
+            }], 
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        onPrevious: [{
+                type: Output
+            }], nextLabel: [{
+                type: Input
+            }], prevLabel: [{
+                type: Input
+            }], transmitLabel: [{
+                type: Input
+            }], continueLaterLabel: [{
+                type: Input
+            }], showContinueLaterButton: [{
+                type: Input
+            }], showNextButton: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"foehn-navigation.component.js","sourceRoot":"","sources":["../../../../projects/prestations-ng/src/foehn-navigation/foehn-navigation.component.ts","../../../../projects/prestations-ng/src/foehn-navigation/foehn-navigation.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;;;;;;;;;AAU/E,MAAM,OAAO,wBAAwB;IA2BjC,YACY,iBAAyC,EACzC,cAA8B;QAD9B,sBAAiB,GAAjB,iBAAiB,CAAwB;QACzC,mBAAc,GAAd,cAAc,CAAgB;QA3B1C,+DAA+D;QAC/D,WAAM,GAAG,IAAI,YAAY,EAAQ,CAAC;QAGlC,+DAA+D;QAC/D,eAAU,GAAG,IAAI,YAAY,EAAQ,CAAC;QAGtC,cAAS,GAAG,6BAA6B,CAAC;QAG1C,cAAS,GAAG,iCAAiC,CAAC;QAG9C,kBAAa,GAAG,iCAAiC,CAAC;QAGlD,uBAAkB,GAAG,uCAAuC,CAAC;QAG7D,4BAAuB,GAAG,IAAI,CAAC;QAG/B,mBAAc,GAAG,IAAI,CAAC;IAKnB,CAAC;IAEJ,QAAQ;QACJ,IAAI,CAAC,iBAAiB,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAC5D,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,EAAE,CAAC;IACrD,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACvB,CAAC;IAED,YAAY;QACR,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAED,iBAAiB;QACb,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;YACtB,yFAAyF;YACzF,OAAO,KAAK,CAAC;SAChB;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAChD,IAAI,cAAc,KAAK,IAAI,EAAE;YACzB,OAAO,KAAK,CAAC;SAChB;QAED,yHAAyH;QACzH,uDAAuD;QACvD,OAAO,cAAc,IAAI,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;IACxE,CAAC;IAED,qBAAqB;QACjB,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,CAAC;IACrD,CAAC;IAED,cAAc;QACV,OAAO,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,CAAC;IACnD,CAAC;IAED,iBAAiB;QACb,OAAO,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;IACtD,CAAC;IAED,qBAAqB;QACjB,OAAO,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,CAAC;IAC1D,CAAC;IAED,kBAAkB;QACd,wFAAwF;QACxF,OAAO,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;IAC3D,CAAC;IAED,eAAe;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,CAAC;IACpD,CAAC;;qHApFQ,wBAAwB;yGAAxB,wBAAwB,6UCVrC,8rGA+EA;2FDrEa,wBAAwB;kBALpC,SAAS;+BACI,kBAAkB;;QAM5B,+DAA+D;QAC/D,MAAM;sBAFL,MAAM;;QAKP,+DAA+D;QAC/D,UAAU;sBAFT,MAAM;gBAKP,SAAS;sBADR,KAAK;gBAIN,SAAS;sBADR,KAAK;gBAIN,aAAa;sBADZ,KAAK;gBAIN,kBAAkB;sBADjB,KAAK;gBAIN,uBAAuB;sBADtB,KAAK;gBAIN,cAAc;sBADb,KAAK","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\n\nimport { FoehnNavigationService } from './foehn-navigation.service';\n\n@Component({\n    selector: 'foehn-navigation',\n    templateUrl: './foehn-navigation.component.html',\n    styleUrls: ['./foehn-navigation.component.css']\n})\nexport class FoehnNavigationComponent implements OnInit {\n    @Output()\n    // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n    onNext = new EventEmitter<void>();\n\n    @Output()\n    // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n    onPrevious = new EventEmitter<void>();\n\n    @Input()\n    nextLabel = 'foehn-navigation.next.label';\n\n    @Input()\n    prevLabel = 'foehn-navigation.previous.label';\n\n    @Input()\n    transmitLabel = 'foehn-navigation.transmit.label';\n\n    @Input()\n    continueLaterLabel = 'foehn-navigation.continue-later.label';\n\n    @Input()\n    showContinueLaterButton = true;\n\n    @Input()\n    showNextButton = true;\n\n    constructor(\n        private navigationService: FoehnNavigationService,\n        private activatedRoute: ActivatedRoute\n    ) {}\n\n    ngOnInit(): void {\n        this.navigationService.activatedRoute = this.activatedRoute;\n        this.navigationService.updateRouteInformations();\n    }\n\n    goToNext(): void {\n        this.onNext.emit();\n    }\n\n    goToPrevious(): void {\n        this.onPrevious.emit();\n    }\n\n    canShowNextButton(): boolean {\n        if (!this.showNextButton) {\n            // In case the user explicitly disable the next button, for validation or error purposes.\n            return false;\n        }\n\n        const nextRouteIndex = this.getNextRouteIndex();\n        if (nextRouteIndex === null) {\n            return false;\n        }\n\n        // This assumes that the route orders are lower than the last one. For instance the last one being the confirmation page,\n        // its order must be greater than all the other orders.\n        return nextRouteIndex <= this.navigationService.getLastRouteOrder();\n    }\n\n    canShowPreviousButton(): boolean {\n        return !this.navigationService.isFirstFormPage();\n    }\n\n    isLastFormPage(): boolean {\n        return this.navigationService.isLastFormPage();\n    }\n\n    getNextRouteIndex(): number {\n        return this.navigationService.getNextRouteIndex();\n    }\n\n    getPreviousRouteIndex(): number {\n        return this.navigationService.getPreviousRouteIndex();\n    }\n\n    getTotalRoutesSize(): number {\n        // Assumes that last route is the confirmation page and thus isn't considered as a step.\n        return this.navigationService.getTotalRoutesSize() - 1;\n    }\n\n    isLinearRouting(): boolean {\n        return this.navigationService.isLinearRouting();\n    }\n}\n","<gesdem-action-recovery-registration\n    *ngIf=\"showContinueLaterButton\"\n    [continueLaterLabel]=\"continueLaterLabel | fromDictionary\"\n></gesdem-action-recovery-registration>\n\n<nav class=\"vd-pagination\" id=\"foehn_navContainer\" aria-label=\"Pagination\">\n    <ul class=\"vd-pagination__list\">\n        <li\n            class=\"vd-pagination__item vd-pagination__item--previous\"\n            *ngIf=\"canShowPreviousButton()\"\n        >\n            <button\n                id=\"prevButton\"\n                type=\"button\"\n                class=\"btn-link vd-pagination__link vd-pagination__link-reset\"\n                (click)=\"$event.preventDefault(); goToPrevious()\"\n            >\n                <span class=\"vd-pagination__title\">\n                    <foehn-icon-chevron-left\n                        class=\"mr-1\"\n                        aria-hidden=\"true\"\n                    ></foehn-icon-chevron-left>\n                    {{ prevLabel | fromDictionary }}\n                </span>\n                <span class=\"sr-only\" *ngIf=\"isLinearRouting()\">:</span>\n                <span class=\"vd-pagination__label\" *ngIf=\"isLinearRouting()\">\n                    {{ getPreviousRouteIndex() }}\n                    {{\n                        'foehn-navigation.route.index.separator'\n                            | fromDictionary\n                    }}\n                    {{ getTotalRoutesSize() }}\n                </span>\n            </button>\n        </li>\n        <li\n            class=\"vd-pagination__item vd-pagination__item--next\"\n            *ngIf=\"!isLastFormPage() && canShowNextButton()\"\n        >\n            <button\n                id=\"nextButton\"\n                type=\"submit\"\n                class=\"btn-link vd-pagination__link vd-pagination__link-reset\"\n                (click)=\"$event.preventDefault(); goToNext()\"\n            >\n                <span class=\"vd-pagination__title\">\n                    {{ nextLabel | fromDictionary }}\n                    <foehn-icon-chevron-right\n                        class=\"ml-1\"\n                        aria-hidden=\"true\"\n                    ></foehn-icon-chevron-right>\n                </span>\n                <span class=\"sr-only\" *ngIf=\"isLinearRouting()\">:</span>\n                <span class=\"vd-pagination__label\" *ngIf=\"isLinearRouting()\">\n                    {{ getNextRouteIndex() }}\n                    {{\n                        'foehn-navigation.route.index.separator'\n                            | fromDictionary\n                    }}\n                    {{ getTotalRoutesSize() }}\n                </span>\n            </button>\n        </li>\n        <li\n            class=\"vd-pagination__item vd-pagination__item--next\"\n            *ngIf=\"isLastFormPage() && canShowNextButton()\"\n        >\n            <button\n                *ngIf=\"isLastFormPage() && canShowNextButton()\"\n                type=\"submit\"\n                id=\"transmitButton\"\n                (click)=\"goToNext()\"\n                class=\"btn btn-success vd-btn-pagination-submit\"\n            >\n                {{ transmitLabel | fromDictionary }}\n            </button>\n        </li>\n    </ul>\n</nav>\n"]}

package/esm2020/foehn-navigation/foehn-navigation.module.mjs

@@ -0,0 +1,32 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FoehnIconsModule } from '../foehn-icons/foehn-icons.module';
+import { GesdemActionRecoveryModule } from '../gesdem-action-recovery/gesdem-action-recovery.module';
+import { SdkDictionaryModule } from '../sdk-dictionary/sdk-dictionary.module';
+import { FoehnNavigationComponent } from './foehn-navigation.component';
+import * as i0 from "@angular/core";
+export class FoehnNavigationModule {
+}
+FoehnNavigationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FoehnNavigationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationModule, declarations: [FoehnNavigationComponent], imports: [CommonModule,
+        FoehnIconsModule,
+        GesdemActionRecoveryModule,
+        SdkDictionaryModule], exports: [FoehnNavigationComponent] });
+FoehnNavigationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationModule, imports: [CommonModule,
+        FoehnIconsModule,
+        GesdemActionRecoveryModule,
+        SdkDictionaryModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FoehnIconsModule,
+                        GesdemActionRecoveryModule,
+                        SdkDictionaryModule
+                    ],
+                    declarations: [FoehnNavigationComponent],
+                    exports: [FoehnNavigationComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/foehn-navigation/foehn-navigation.service.mjs

@@ -0,0 +1,303 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ServiceLocator } from '../service-locator';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../gesdem/gesdem-handler.service";
+import * as i3 from "../gesdem-action-recovery/gesdem-action-recovery.service";
+import * as i4 from "@angular/common";
+export var NavigationDirection;
+(function (NavigationDirection) {
+    NavigationDirection[NavigationDirection["FORWARD"] = 1] = "FORWARD";
+    NavigationDirection[NavigationDirection["BACKWARD"] = -1] = "BACKWARD";
+})(NavigationDirection || (NavigationDirection = {}));
+export class FoehnNavigationService {
+    constructor(router, gesdemService, gesdemActionRecoveryService, route, location) {
+        this.router = router;
+        this.gesdemService = gesdemService;
+        this.gesdemActionRecoveryService = gesdemActionRecoveryService;
+        this.route = route;
+        this.location = location;
+        this.isInit = false;
+        this.initializedAndRouteActivated = new BehaviorSubject(false);
+        this.linearRouting = true;
+    }
+    get initialized() {
+        return this.isInit;
+    }
+    set activatedRoute(value) {
+        this.throwIfNotInit();
+        this._activatedRoute = value;
+        this.initializedAndRouteActivated.next(true);
+    }
+    static getRootRouteRecursive(route) {
+        if (route) {
+            if (route.routeConfig &&
+                route.routeConfig.data &&
+                route.routeConfig.data.root) {
+                return route.routeConfig;
+            }
+            return this.getRootRouteRecursive(route.parent);
+        }
+        return null;
+    }
+    initRoute(route) {
+        if (route) {
+            this.orderedRoutes = this.indexRoutesByOrder(route);
+            // By default the prefix should be the path of the route. (e.g. in /validation/123123-12321/page1,
+            // the prefix is "validation"). However, if the application is code-splitted with the routing defined
+            // in a module, this won't work. In this case, you can specify the path in $.data.basePath so the GesDem
+            // service knows where to send the request to the backend.
+            const prefix = route.data.basePath || route.path;
+            this.gesdemService.prefix = prefix;
+            this.gesdemActionRecoveryService.prefix = prefix;
+            this.linearRouting = route.data.linearRouting !== false;
+        }
+        this.throwIfNotInit();
+    }
+    throwIfNotInit() {
+        if (!this.isInit) {
+            throw new TypeError("No route is identified as 'root'. Have you called initRoute() ?");
+        }
+    }
+    updateRouteInformations() {
+        this.throwIfNotInit();
+        const currentRoute = this._activatedRoute.routeConfig;
+        let currentRouteOrder = 1;
+        if (!!currentRoute &&
+            !!currentRoute.data &&
+            !!currentRoute.data.order) {
+            currentRouteOrder = currentRoute.data.order;
+        }
+        this.currentRouteOrder = currentRouteOrder;
+    }
+    getFirstRoute() {
+        return this.orderedRoutes[1];
+    }
+    current() {
+        this.throwIfNotInit();
+        if (!this.gesdemService.lastResponse) {
+            return Promise.reject('Erreur navigationService#current');
+        }
+        const currentRoute = this.orderedRoutes[this.currentRouteOrder];
+        const prefix = this.gesdemService.prefix;
+        const commands = [];
+        if (prefix) {
+            commands.push(prefix);
+        }
+        if (this.gesdemService.lastResponse.meta.reference) {
+            commands.push(this.gesdemService.lastResponse.meta.reference, currentRoute.path);
+            const tree = this.router.createUrlTree(commands);
+            const url = this.router.serializeUrl(tree) +
+                this.getQueryParamsToForwardAsString();
+            this.location.replaceState(url);
+        }
+        return Promise.resolve(true);
+    }
+    hasBeenInitialized() {
+        return this.initializedAndRouteActivated.asObservable();
+    }
+    getQueryParamsToForwardAsString() {
+        const params = this.getQueryParamsToForward() || [];
+        let stringParams = '';
+        for (const key of Object.keys(params)) {
+            const value = params[key];
+            stringParams += stringParams ? '&' : '?';
+            stringParams += `${key}=${value}`;
+        }
+        return stringParams;
+    }
+    getQueryParamsToForward() {
+        const reCaptchaByPassUUID = this.route.snapshot.queryParams
+            .reCaptchaByPassUUID;
+        const scrollTo = this.route.snapshot.queryParams.scrollTo;
+        if (!!reCaptchaByPassUUID || !!scrollTo) {
+            const params = {};
+            if (!!reCaptchaByPassUUID) {
+                params.reCaptchaByPassUUID = reCaptchaByPassUUID;
+            }
+            if (!!scrollTo) {
+                params.scrollTo = scrollTo;
+            }
+            return params;
+        }
+        return null;
+    }
+    next() {
+        this.throwIfNotInit();
+        return this.redirectToAvailableRoute(NavigationDirection.FORWARD);
+    }
+    previous() {
+        this.throwIfNotInit();
+        return this.redirectToAvailableRoute(NavigationDirection.BACKWARD);
+    }
+    last() {
+        this.throwIfNotInit();
+        const route = this.getAvailableRoutes();
+        const nextRoutePath = route[route.length - 1].path;
+        return this.redirect(nextRoutePath);
+    }
+    redirect(newPath) {
+        const routes = [];
+        if (this.gesdemService.prefix) {
+            routes.push(this.gesdemService.prefix);
+        }
+        routes.push(this.gesdemService.lastResponse.meta.reference, newPath);
+        return this.router
+            .navigate(routes, {
+            queryParams: this.getQueryParamsToForward()
+        })
+            .then(success => {
+            if (success) {
+                this.setFocusOnPageTitle();
+            }
+            return success;
+        });
+    }
+    getAvailableRoutes() {
+        return this.orderedRoutes.filter(route => this.isRouteAvailable(route));
+    }
+    getCurrentRouteIndex() {
+        // This evaluates all the guards
+        const availableRoutes = this.getAvailableRoutes();
+        const currentRoute = availableRoutes.find(route => route.data.order === this.currentRouteOrder);
+        if (!currentRoute) {
+            return null;
+        }
+        return availableRoutes.indexOf(currentRoute);
+    }
+    getTotalRoutesSize() {
+        return this.getAvailableRoutes().length;
+    }
+    getLastRouteOrder() {
+        const routes = this.getAvailableRoutes();
+        return routes[routes.length - 1].data.order;
+    }
+    getNextAvailableRoute(direction) {
+        // This evaluates all the guards
+        const availableRoutes = this.getAvailableRoutes();
+        // Assumes that the next or previous route is the next or previous on the array of available routes.
+        const currentRoute = this.getCurrentRoute(availableRoutes);
+        if (!currentRoute) {
+            throw new Error('Invalid routing, at least one route must be available');
+        }
+        const currentRouteIndex = availableRoutes.indexOf(currentRoute);
+        const targetRoute = availableRoutes[currentRouteIndex + direction];
+        if (!targetRoute) {
+            return null;
+        }
+        // The display index isn't always the route order as we support guards on available routes.
+        // The display index is 1-based.
+        targetRoute.data.displayIndex =
+            availableRoutes.indexOf(targetRoute) + 1;
+        return targetRoute;
+    }
+    isFirstFormPage() {
+        if (!this.getCurrentRoute(this.getAvailableRoutes())) {
+            return true;
+        }
+        return (this.getNextAvailableRoute(NavigationDirection.BACKWARD) === null);
+    }
+    isLastFormPage() {
+        if (!this.orderedRoutes?.length) {
+            return false;
+        }
+        if (!this.getCurrentRoute(this.getAvailableRoutes())) {
+            return true;
+        }
+        const nextRoute = this.getNextAvailableRoute(NavigationDirection.FORWARD);
+        if (!nextRoute) {
+            return true;
+        }
+        return nextRoute.data.order === this.getLastRouteOrder();
+    }
+    getNextRouteIndex() {
+        const nextRoute = this.getNextAvailableRoute(NavigationDirection.FORWARD);
+        if (!nextRoute) {
+            return null;
+        }
+        return nextRoute.data.displayIndex;
+    }
+    getPreviousRouteIndex() {
+        const previousRoute = this.getNextAvailableRoute(NavigationDirection.BACKWARD);
+        if (!previousRoute) {
+            return null;
+        }
+        return previousRoute.data.displayIndex;
+    }
+    isLinearRouting() {
+        return this.linearRouting;
+    }
+    getCurrentRoute(availableRoutes) {
+        return availableRoutes.find(route => route.data.order === this.currentRouteOrder);
+    }
+    redirectToAvailableRoute(direction) {
+        const route = this.getNextAvailableRoute(direction);
+        return this.redirect(route.path);
+    }
+    isRouteAvailable(route) {
+        const { canActivate } = route;
+        if (!canActivate || !canActivate.length) {
+            return true;
+        }
+        // All the guards must be evaluated to true
+        return !canActivate.some(guardType => !this.evaluateGuard(guardType));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    evaluateGuard(guardType) {
+        const guard = ServiceLocator.injector.get(guardType);
+        const guardResult = guard.canActivate(this.route.snapshot, null);
+        if (typeof guardResult !== 'boolean') {
+            throw new Error('Not implemented: Dynamic routing guards only support boolean results');
+        }
+        return guardResult;
+    }
+    /**
+     * reindexe les routes par "order"
+     *
+     * @param applicationRoute as route
+     * @returns Route[]
+     */
+    indexRoutesByOrder(applicationRoute) {
+        this.isInit = false;
+        const routesToCrawl = applicationRoute.children;
+        if (!routesToCrawl.length) {
+            return [];
+        }
+        const result = this.flattenRoutes(routesToCrawl);
+        if (result.length > 0) {
+            this.isInit = true;
+        }
+        return result;
+    }
+    flattenRoutes(routesToCrawl, result = []) {
+        routesToCrawl.forEach(value => {
+            if (value.children && value.children.length) {
+                this.flattenRoutes(value.children, result);
+            }
+            if (!!value.data && !!value.data.order) {
+                result[value.data.order] = value;
+            }
+            return result;
+        });
+        return result;
+    }
+    setFocusOnPageTitle() {
+        // Ensures that the focus is properly set after the page is updated.
+        setTimeout(() => {
+            const title = document.getElementById('page-title');
+            if (title) {
+                title.focus();
+            }
+        }, 0);
+    }
+}
+FoehnNavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationService, deps: [{ token: i1.Router }, { token: i2.GesdemHandlerService }, { token: i3.GesdemActionRecoveryService }, { token: i1.ActivatedRoute }, { token: i4.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+FoehnNavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.GesdemHandlerService }, { type: i3.GesdemActionRecoveryService }, { type: i1.ActivatedRoute }, { type: i4.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"foehn-navigation.service.js","sourceRoot":"","sources":["../../../../projects/prestations-ng/src/foehn-navigation/foehn-navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable } from '@angular/core';\nimport {\n    ActivatedRoute,\n    ActivatedRouteSnapshot,\n    CanActivate,\n    Params,\n    Route,\n    Router\n} from '@angular/router';\nimport { BehaviorSubject, Observable } from 'rxjs';\n\nimport { GesdemHandlerService } from '../gesdem/gesdem-handler.service';\nimport { GesdemActionRecoveryService } from '../gesdem-action-recovery/gesdem-action-recovery.service';\nimport { ServiceLocator } from '../service-locator';\n\nexport enum NavigationDirection {\n    FORWARD = +1,\n    BACKWARD = -1\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FoehnNavigationService {\n    currentRouteOrder: number;\n    orderedRoutes: Route[];\n    private _activatedRoute: ActivatedRoute;\n    private isInit = false;\n    private initializedAndRouteActivated: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(\n        false\n    );\n    private linearRouting = true;\n\n    constructor(\n        private router: Router,\n        private gesdemService: GesdemHandlerService,\n        private gesdemActionRecoveryService: GesdemActionRecoveryService,\n        private route: ActivatedRoute,\n        private location: Location\n    ) {}\n\n    get initialized(): boolean {\n        return this.isInit;\n    }\n\n    set activatedRoute(value: ActivatedRoute) {\n        this.throwIfNotInit();\n        this._activatedRoute = value;\n        this.initializedAndRouteActivated.next(true);\n    }\n\n    static getRootRouteRecursive(route: ActivatedRouteSnapshot): Route {\n        if (route) {\n            if (\n                route.routeConfig &&\n                route.routeConfig.data &&\n                route.routeConfig.data.root\n            ) {\n                return route.routeConfig;\n            }\n            return this.getRootRouteRecursive(route.parent);\n        }\n        return null;\n    }\n\n    initRoute(route: Route): void {\n        if (route) {\n            this.orderedRoutes = this.indexRoutesByOrder(route);\n\n            // By default the prefix should be the path of the route. (e.g. in /validation/123123-12321/page1,\n            // the prefix is \"validation\"). However, if the application is code-splitted with the routing defined\n            // in a module, this won't work. In this case, you can specify the path in $.data.basePath so the GesDem\n            // service knows where to send the request to the backend.\n            const prefix = route.data.basePath || route.path;\n            this.gesdemService.prefix = prefix;\n            this.gesdemActionRecoveryService.prefix = prefix;\n            this.linearRouting = route.data.linearRouting !== false;\n        }\n        this.throwIfNotInit();\n    }\n\n    throwIfNotInit(): void {\n        if (!this.isInit) {\n            throw new TypeError(\n                \"No route is identified as 'root'. Have you called initRoute() ?\"\n            );\n        }\n    }\n\n    updateRouteInformations(): void {\n        this.throwIfNotInit();\n        const currentRoute = this._activatedRoute.routeConfig;\n\n        let currentRouteOrder = 1;\n\n        if (\n            !!currentRoute &&\n            !!currentRoute.data &&\n            !!currentRoute.data.order\n        ) {\n            currentRouteOrder = currentRoute.data.order;\n        }\n        this.currentRouteOrder = currentRouteOrder;\n    }\n\n    getFirstRoute(): Route {\n        return this.orderedRoutes[1];\n    }\n\n    current(): Promise<boolean> {\n        this.throwIfNotInit();\n        if (!this.gesdemService.lastResponse) {\n            return Promise.reject('Erreur navigationService#current');\n        }\n        const currentRoute = this.orderedRoutes[this.currentRouteOrder];\n\n        const prefix = this.gesdemService.prefix;\n        const commands: string[] = [];\n        if (prefix) {\n            commands.push(prefix);\n        }\n\n        if (this.gesdemService.lastResponse.meta.reference) {\n            commands.push(\n                this.gesdemService.lastResponse.meta.reference,\n                currentRoute.path\n            );\n\n            const tree = this.router.createUrlTree(commands);\n            const url =\n                this.router.serializeUrl(tree) +\n                this.getQueryParamsToForwardAsString();\n            this.location.replaceState(url);\n        }\n\n        return Promise.resolve(true);\n    }\n\n    hasBeenInitialized(): Observable<boolean> {\n        return this.initializedAndRouteActivated.asObservable();\n    }\n\n    getQueryParamsToForwardAsString(): string {\n        const params = this.getQueryParamsToForward() || [];\n        let stringParams = '';\n        for (const key of Object.keys(params)) {\n            const value = params[key];\n            stringParams += stringParams ? '&' : '?';\n            stringParams += `${key}=${value}`;\n        }\n        return stringParams;\n    }\n\n    getQueryParamsToForward(): Params {\n        const reCaptchaByPassUUID = this.route.snapshot.queryParams\n            .reCaptchaByPassUUID;\n        const scrollTo = this.route.snapshot.queryParams.scrollTo;\n        if (!!reCaptchaByPassUUID || !!scrollTo) {\n            const params: Params = {};\n            if (!!reCaptchaByPassUUID) {\n                params.reCaptchaByPassUUID = reCaptchaByPassUUID;\n            }\n            if (!!scrollTo) {\n                params.scrollTo = scrollTo;\n            }\n            return params;\n        }\n        return null;\n    }\n\n    next(): Promise<boolean> {\n        this.throwIfNotInit();\n        return this.redirectToAvailableRoute(NavigationDirection.FORWARD);\n    }\n\n    previous(): Promise<boolean> {\n        this.throwIfNotInit();\n        return this.redirectToAvailableRoute(NavigationDirection.BACKWARD);\n    }\n\n    last(): Promise<boolean> {\n        this.throwIfNotInit();\n        const route = this.getAvailableRoutes();\n        const nextRoutePath = route[route.length - 1].path;\n        return this.redirect(nextRoutePath);\n    }\n\n    redirect(newPath: string): Promise<boolean> {\n        const routes = [];\n        if (this.gesdemService.prefix) {\n            routes.push(this.gesdemService.prefix);\n        }\n        routes.push(this.gesdemService.lastResponse.meta.reference, newPath);\n\n        return this.router\n            .navigate(routes, {\n                queryParams: this.getQueryParamsToForward()\n            })\n            .then(success => {\n                if (success) {\n                    this.setFocusOnPageTitle();\n                }\n                return success;\n            });\n    }\n\n    getAvailableRoutes(): Route[] {\n        return this.orderedRoutes.filter(route => this.isRouteAvailable(route));\n    }\n\n    getCurrentRouteIndex(): number {\n        // This evaluates all the guards\n        const availableRoutes = this.getAvailableRoutes();\n\n        const currentRoute = availableRoutes.find(\n            route => route.data.order === this.currentRouteOrder\n        );\n\n        if (!currentRoute) {\n            return null;\n        }\n\n        return availableRoutes.indexOf(currentRoute);\n    }\n\n    getTotalRoutesSize(): number {\n        return this.getAvailableRoutes().length;\n    }\n\n    getLastRouteOrder(): number {\n        const routes = this.getAvailableRoutes();\n        return routes[routes.length - 1].data.order;\n    }\n\n    getNextAvailableRoute(direction: NavigationDirection): Route {\n        // This evaluates all the guards\n        const availableRoutes = this.getAvailableRoutes();\n\n        // Assumes that the next or previous route is the next or previous on the array of available routes.\n        const currentRoute = this.getCurrentRoute(availableRoutes);\n        if (!currentRoute) {\n            throw new Error(\n                'Invalid routing, at least one route must be available'\n            );\n        }\n\n        const currentRouteIndex = availableRoutes.indexOf(currentRoute);\n        const targetRoute = availableRoutes[currentRouteIndex + direction];\n        if (!targetRoute) {\n            return null;\n        }\n\n        // The display index isn't always the route order as we support guards on available routes.\n        // The display index is 1-based.\n        targetRoute.data.displayIndex =\n            availableRoutes.indexOf(targetRoute) + 1;\n        return targetRoute;\n    }\n\n    isFirstFormPage(): boolean {\n        if (!this.getCurrentRoute(this.getAvailableRoutes())) {\n            return true;\n        }\n        return (\n            this.getNextAvailableRoute(NavigationDirection.BACKWARD) === null\n        );\n    }\n\n    isLastFormPage(): boolean {\n        if (!this.orderedRoutes?.length) {\n            return false;\n        }\n\n        if (!this.getCurrentRoute(this.getAvailableRoutes())) {\n            return true;\n        }\n        const nextRoute = this.getNextAvailableRoute(\n            NavigationDirection.FORWARD\n        );\n        if (!nextRoute) {\n            return true;\n        }\n\n        return nextRoute.data.order === this.getLastRouteOrder();\n    }\n\n    getNextRouteIndex(): number {\n        const nextRoute = this.getNextAvailableRoute(\n            NavigationDirection.FORWARD\n        );\n        if (!nextRoute) {\n            return null;\n        }\n\n        return nextRoute.data.displayIndex;\n    }\n\n    getPreviousRouteIndex(): number {\n        const previousRoute = this.getNextAvailableRoute(\n            NavigationDirection.BACKWARD\n        );\n        if (!previousRoute) {\n            return null;\n        }\n\n        return previousRoute.data.displayIndex;\n    }\n\n    isLinearRouting(): boolean {\n        return this.linearRouting;\n    }\n\n    private getCurrentRoute(availableRoutes: Route[]): Route {\n        return availableRoutes.find(\n            route => route.data.order === this.currentRouteOrder\n        );\n    }\n\n    private redirectToAvailableRoute(\n        direction: NavigationDirection\n    ): Promise<boolean> {\n        const route = this.getNextAvailableRoute(direction);\n        return this.redirect(route.path);\n    }\n\n    private isRouteAvailable(route: Route): boolean {\n        const { canActivate } = route;\n        if (!canActivate || !canActivate.length) {\n            return true;\n        }\n\n        // All the guards must be evaluated to true\n        return !canActivate.some(guardType => !this.evaluateGuard(guardType));\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private evaluateGuard(guardType: any): boolean {\n        const guard: CanActivate = ServiceLocator.injector.get<CanActivate>(\n            guardType\n        );\n        const guardResult = guard.canActivate(this.route.snapshot, null);\n\n        if (typeof guardResult !== 'boolean') {\n            throw new Error(\n                'Not implemented: Dynamic routing guards only support boolean results'\n            );\n        }\n\n        return guardResult;\n    }\n\n    /**\n     * reindexe les routes par \"order\"\n     *\n     * @param applicationRoute as route\n     * @returns Route[]\n     */\n    private indexRoutesByOrder(applicationRoute: Route): Route[] {\n        this.isInit = false;\n\n        const routesToCrawl = applicationRoute.children;\n        if (!routesToCrawl.length) {\n            return [];\n        }\n\n        const result = this.flattenRoutes(routesToCrawl);\n\n        if (result.length > 0) {\n            this.isInit = true;\n        }\n\n        return result;\n    }\n\n    private flattenRoutes(\n        routesToCrawl: Route[],\n        result: Route[] = []\n    ): Route[] {\n        routesToCrawl.forEach(value => {\n            if (value.children && value.children.length) {\n                this.flattenRoutes(value.children, result);\n            }\n\n            if (!!value.data && !!value.data.order) {\n                result[value.data.order] = value;\n            }\n\n            return result;\n        });\n\n        return result;\n    }\n\n    private setFocusOnPageTitle(): void {\n        // Ensures that the focus is properly set after the page is updated.\n        setTimeout(() => {\n            const title = document.getElementById('page-title');\n            if (title) {\n                title.focus();\n            }\n        }, 0);\n    }\n}\n"]}

package/{esm2015/foehn-notfound/foehn-notfound.component.js → esm2020/foehn-notfound/foehn-notfound.component.mjs}

@@ -2,8 +2,8 @@ import { Component, Input } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
 import * as i2 from "../foehn-page/foehn-page.service";
-import * as i3 from "../foehn-debug-summary/foehn-debug-summary.component";
-import * as i4 from "@angular/common";
+import * as i3 from "@angular/common";
+import * as i4 from "../foehn-debug-summary/foehn-debug-summary.component";
 export class FoehnNotfoundComponent {
     constructor(router, foehnPageService) {
         this.router = router;
@@ -48,17 +48,14 @@ export class FoehnNotfoundComponent {
         }
     }
 }
-FoehnNotfoundComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: FoehnNotfoundComponent, deps: [{ token: i1.Router }, { token: i2.FoehnPageService }], target: i0.ɵɵFactoryTarget.Component });
-FoehnNotfoundComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.4", type: FoehnNotfoundComponent, selector: "foehn-notfound", inputs: { setPageTitle: "setPageTitle", shouldRedirect: "shouldRedirect" }, ngImport: i0, template: "<div class=\"container mt-5\">\n    <div class=\"alert alert-danger text-center\">\n        <p class=\"h2\">Erreur</p>\n        <p>Ressource inexistante</p>\n        <p class=\"h2\">\n            Vous allez \u00EAtre redirig\u00E9 dans {{ seconds }}\n            <span *ngIf=\"seconds > 1\">secondes</span>\n            <span *ngIf=\"seconds <= 1\">seconde</span>\n        </p>\n    </div>\n\n    <foehn-debug-summary></foehn-debug-summary>\n</div>\n", components: [{ type: i3.FoehnDebugSummaryComponent, selector: "foehn-debug-summary" }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: FoehnNotfoundComponent, decorators: [{
+FoehnNotfoundComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNotfoundComponent, deps: [{ token: i1.Router }, { token: i2.FoehnPageService }], target: i0.ɵɵFactoryTarget.Component });
+FoehnNotfoundComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.2", type: FoehnNotfoundComponent, selector: "foehn-notfound", inputs: { setPageTitle: "setPageTitle", shouldRedirect: "shouldRedirect" }, ngImport: i0, template: "<div class=\"container mt-5\">\n    <div class=\"alert alert-danger text-center\">\n        <p class=\"h2\">Erreur</p>\n        <p>Ressource inexistante</p>\n        <p class=\"h2\">\n            Vous allez \u00EAtre redirig\u00E9 dans {{ seconds }}\n            <span *ngIf=\"seconds > 1\">secondes</span>\n            <span *ngIf=\"seconds <= 1\">seconde</span>\n        </p>\n    </div>\n\n    <foehn-debug-summary></foehn-debug-summary>\n</div>\n", dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.FoehnDebugSummaryComponent, selector: "foehn-debug-summary" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.2", ngImport: i0, type: FoehnNotfoundComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'foehn-notfound',
-                    templateUrl: './foehn-notfound.component.html'
-                }]
+            args: [{ selector: 'foehn-notfound', template: "<div class=\"container mt-5\">\n    <div class=\"alert alert-danger text-center\">\n        <p class=\"h2\">Erreur</p>\n        <p>Ressource inexistante</p>\n        <p class=\"h2\">\n            Vous allez \u00EAtre redirig\u00E9 dans {{ seconds }}\n            <span *ngIf=\"seconds > 1\">secondes</span>\n            <span *ngIf=\"seconds <= 1\">seconde</span>\n        </p>\n    </div>\n\n    <foehn-debug-summary></foehn-debug-summary>\n</div>\n" }]
         }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.FoehnPageService }]; }, propDecorators: { setPageTitle: [{
                 type: Input
             }], shouldRedirect: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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