@valtimo/components 10.8.0 → 11.1.0

package/esm2022/lib/services/shell.service.mjs

@@ -0,0 +1,213 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, fromEvent, map, Subject, } from 'rxjs';
+import { debounceTime, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/config";
+export class ShellService {
+    get sideBarExpanded$() {
+        return this._sideBarExpanded$.asObservable();
+    }
+    get panelExpanded$() {
+        return this._panelExpanded$.asObservable();
+    }
+    get largeScreen$() {
+        return this._largeScreen$.asObservable();
+    }
+    get mouseOnTopBar$() {
+        return this._mouseOnTopBar$.asObservable();
+    }
+    get sidenavWidth$() {
+        return this._sidenavWidth$.asObservable();
+    }
+    get collapsibleWidescreenMenu$() {
+        return this._collapsibleWidescreenMenu$.asObservable();
+    }
+    get mainContentResized$() {
+        return this._mainContentResized$.asObservable();
+    }
+    constructor(rendererFactory2, configService) {
+        this.rendererFactory2 = rendererFactory2;
+        this.configService = configService;
+        this._sideBarExpanded$ = new BehaviorSubject(true);
+        this._panelExpanded$ = new BehaviorSubject(false);
+        this._largeScreen$ = new BehaviorSubject(true);
+        this._mouseOnTopBar$ = new BehaviorSubject(false);
+        this._sidenavWidth$ = new BehaviorSubject(300);
+        this._sidenavElement$ = new BehaviorSubject(undefined);
+        this._contentElement$ = new BehaviorSubject(undefined);
+        this._resizeBorderElement$ = new BehaviorSubject(undefined);
+        this._mouseX$ = fromEvent(document.body, 'mousemove').pipe(map((e) => e.pageX));
+        this._isResizing$ = new BehaviorSubject(false);
+        this._collapsibleWidescreenMenu$ = new BehaviorSubject(false);
+        this._mainContentResized$ = new Subject();
+        this.renderer = rendererFactory2.createRenderer(null, null);
+        this.openSidenavSizeSubscription();
+        this.openMouseSubscriptions();
+        this.initMenuWidth(configService.config);
+    }
+    ngOnDestroy() {
+        this.sidenavSizeSubscription.unsubscribe();
+    }
+    toggleSideBar() {
+        const isExpanded = this._sideBarExpanded$.getValue();
+        this._sideBarExpanded$.next(!isExpanded);
+    }
+    collapseSideBar() {
+        this._sideBarExpanded$.next(false);
+    }
+    togglePanel() {
+        const isExpanded = this._panelExpanded$.getValue();
+        this._panelExpanded$.next(!isExpanded);
+    }
+    setPanelExpanded(isExpanded) {
+        this._panelExpanded$.next(isExpanded);
+    }
+    setSideBarExpanded(isExpanded) {
+        this._sideBarExpanded$.next(isExpanded);
+    }
+    setLargeScreen(isLarge) {
+        this._largeScreen$.next(isLarge);
+    }
+    setMouseOnTopBar(mouseOnTopBar) {
+        this._mouseOnTopBar$.next(mouseOnTopBar);
+    }
+    setSidenavElement(element) {
+        this._sidenavElement$.next(element);
+        this.createResizeBorderElement(element);
+    }
+    setContentElement(element) {
+        this._contentElement$.next(element);
+    }
+    setCollapsibleWidescreenMenu(collapsible) {
+        this._collapsibleWidescreenMenu$.next(collapsible);
+        if (collapsible) {
+            this.collapseSideBar();
+        }
+    }
+    onMainContentResize() {
+        this._mainContentResized$.next(null);
+    }
+    createResizeBorderElement(sidenavElement) {
+        const borderElement = this.renderer.createElement('div');
+        this.renderer.addClass(borderElement, 'resize-border');
+        this.renderer.appendChild(sidenavElement, borderElement);
+        this._resizeBorderElement$.next(borderElement);
+        this.renderer.listen(borderElement, 'mouseenter', () => {
+            this.renderer.addClass(borderElement, 'resize-hover');
+        });
+        this.renderer.listen(borderElement, 'mouseleave', () => {
+            this._isResizing$.pipe(take(1)).subscribe(isResizing => {
+                if (!isResizing) {
+                    this.renderer.removeClass(borderElement, 'resize-hover');
+                }
+            });
+        });
+        this.renderer.listen(borderElement, 'mousedown', (event) => {
+            this._sidenavWidth$.pipe(take(1)).subscribe(sidenavWidth => {
+                this.sidenavWidthOnClick = sidenavWidth;
+                this.xOnClick = event.pageX;
+                this._isResizing$.next(true);
+                this.renderer.setStyle(document.body, 'user-select', 'none');
+                this.renderer.setStyle(document.body, 'cursor', 'col-resize');
+                this.renderer.setStyle(document.querySelector('.cds--side-nav__navigation'), 'pointer-events', 'none');
+                this.renderer.setStyle(document.querySelector('.main-content'), 'pointer-events', 'none');
+            });
+        });
+    }
+    openSidenavSizeSubscription() {
+        this.sidenavSizeSubscription = combineLatest([
+            this._largeScreen$,
+            this._sidenavWidth$,
+            this._sidenavElement$,
+            this._contentElement$,
+            this._resizeBorderElement$,
+            this._collapsibleWidescreenMenu$,
+        ]).subscribe(([largeScreen, sidenavWidth, sidenavElement, contentElement, resizeBorderElement, collapsibleWidescreenMenu,]) => {
+            if ((!largeScreen || collapsibleWidescreenMenu) &&
+                sidenavElement &&
+                contentElement &&
+                resizeBorderElement) {
+                this.renderer.removeStyle(sidenavElement, 'min-width');
+                this.renderer.removeStyle(sidenavElement, 'width');
+                this.renderer.removeStyle(sidenavElement, 'transition');
+                this.renderer.removeStyle(contentElement, 'padding-left');
+                this.renderer.addClass(resizeBorderElement, 'resize-border--invisible');
+            }
+            else if (largeScreen &&
+                sidenavElement &&
+                contentElement &&
+                typeof sidenavWidth === 'number') {
+                const pixelWidth = `${sidenavWidth}px`;
+                this.renderer.setStyle(sidenavElement, 'min-width', `${pixelWidth}`);
+                this.renderer.setStyle(sidenavElement, 'width', `${pixelWidth}`);
+                this.renderer.setStyle(sidenavElement, 'transition', 'none');
+                this.renderer.setStyle(contentElement, 'padding-left', `calc(2rem + ${pixelWidth})`);
+                this.renderer.removeClass(resizeBorderElement, 'resize-border--invisible');
+            }
+        });
+    }
+    openMouseSubscriptions() {
+        this.mouseXSubscription = combineLatest([this._mouseX$, this._isResizing$])
+            .pipe(debounceTime(3))
+            .subscribe(([x, isResizing]) => {
+            if (isResizing) {
+                const offSetWidth = this.xOnClick - x;
+                const newSidenavWidth = this.sidenavWidthOnClick - offSetWidth;
+                if (newSidenavWidth <= this.maxMenuWidth && newSidenavWidth >= this.minMenuWidth) {
+                    this._sidenavWidth$.next(newSidenavWidth);
+                }
+            }
+        });
+        this.mouseUpSubscription = fromEvent(document, 'mouseup').subscribe(() => {
+            this.stopResizing();
+        });
+    }
+    stopResizing() {
+        const mainContent = document.querySelector('.main-content');
+        const sideNav = document.querySelector('.cds--side-nav__navigation');
+        this.renderer.removeStyle(document.body, 'user-select');
+        this.renderer.removeStyle(document.body, 'cursor');
+        this._isResizing$.next(false);
+        this.renderer.removeClass(this._resizeBorderElement$.getValue(), 'resize-hover');
+        if (sideNav) {
+            this.renderer.removeStyle(sideNav, 'pointer-events');
+        }
+        if (mainContent) {
+            this.renderer.removeStyle(mainContent, 'pointer-events');
+        }
+        localStorage.setItem('sidenavWidth', this._sidenavWidth$.getValue().toString());
+    }
+    initMenuWidth(config) {
+        const customLeftSidebar = config?.customLeftSidebar;
+        const localStorageWidth = localStorage.getItem('sidenavWidth');
+        const localStorageWidthNumber = localStorageWidth && +localStorageWidth;
+        const configWidth = customLeftSidebar?.defaultMenuWidth;
+        this._sidenavWidth$.next(localStorageWidthNumber || configWidth || 256);
+        this.minMenuWidth = customLeftSidebar?.minMenuWidth || 150;
+        this.maxMenuWidth = customLeftSidebar?.maxMenuWidth || 500;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ShellService, deps: [{ token: i0.RendererFactory2 }, { token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ShellService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ShellService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }, { type: i1.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/services/shell.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable, OnDestroy, Renderer2, RendererFactory2} from '@angular/core';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  fromEvent,\n  map,\n  Observable,\n  Subject,\n  Subscription,\n} from 'rxjs';\nimport {debounceTime, take} from 'rxjs/operators';\nimport {ConfigService, ValtimoConfig} from '@valtimo/config';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ShellService implements OnDestroy {\n  private renderer!: Renderer2;\n  private readonly _sideBarExpanded$ = new BehaviorSubject<boolean>(true);\n  private readonly _panelExpanded$ = new BehaviorSubject<boolean>(false);\n  private readonly _largeScreen$ = new BehaviorSubject<boolean>(true);\n  private readonly _mouseOnTopBar$ = new BehaviorSubject<boolean>(false);\n  private readonly _sidenavWidth$ = new BehaviorSubject<number>(300);\n  private readonly _sidenavElement$ = new BehaviorSubject<HTMLElement>(undefined);\n  private readonly _contentElement$ = new BehaviorSubject<HTMLElement>(undefined);\n  private readonly _resizeBorderElement$ = new BehaviorSubject<HTMLElement>(undefined);\n  private readonly _mouseX$ = fromEvent(document.body, 'mousemove').pipe(\n    map((e: MouseEvent) => e.pageX)\n  );\n  private readonly _isResizing$ = new BehaviorSubject<boolean>(false);\n  private readonly _collapsibleWidescreenMenu$ = new BehaviorSubject<boolean>(false);\n  private readonly _mainContentResized$ = new Subject<null>();\n  private sidenavWidthOnClick!: number;\n  private xOnClick!: number;\n  private sidenavSizeSubscription!: Subscription;\n  private mouseXSubscription!: Subscription;\n  private mouseUpSubscription!: Subscription;\n  private maxMenuWidth!: number;\n  private minMenuWidth!: number;\n\n  get sideBarExpanded$(): Observable<boolean> {\n    return this._sideBarExpanded$.asObservable();\n  }\n  get panelExpanded$(): Observable<boolean> {\n    return this._panelExpanded$.asObservable();\n  }\n  get largeScreen$(): Observable<boolean> {\n    return this._largeScreen$.asObservable();\n  }\n  get mouseOnTopBar$(): Observable<boolean> {\n    return this._mouseOnTopBar$.asObservable();\n  }\n\n  get sidenavWidth$(): Observable<number> {\n    return this._sidenavWidth$.asObservable();\n  }\n\n  get collapsibleWidescreenMenu$(): Observable<boolean> {\n    return this._collapsibleWidescreenMenu$.asObservable();\n  }\n\n  get mainContentResized$(): Observable<null> {\n    return this._mainContentResized$.asObservable();\n  }\n\n  constructor(\n    private readonly rendererFactory2: RendererFactory2,\n    private readonly configService: ConfigService\n  ) {\n    this.renderer = rendererFactory2.createRenderer(null, null);\n    this.openSidenavSizeSubscription();\n    this.openMouseSubscriptions();\n    this.initMenuWidth(configService.config);\n  }\n\n  ngOnDestroy(): void {\n    this.sidenavSizeSubscription.unsubscribe();\n  }\n\n  toggleSideBar(): void {\n    const isExpanded = this._sideBarExpanded$.getValue();\n    this._sideBarExpanded$.next(!isExpanded);\n  }\n\n  collapseSideBar(): void {\n    this._sideBarExpanded$.next(false);\n  }\n\n  togglePanel(): void {\n    const isExpanded = this._panelExpanded$.getValue();\n    this._panelExpanded$.next(!isExpanded);\n  }\n\n  setPanelExpanded(isExpanded: boolean): void {\n    this._panelExpanded$.next(isExpanded);\n  }\n\n  setSideBarExpanded(isExpanded: boolean): void {\n    this._sideBarExpanded$.next(isExpanded);\n  }\n\n  setLargeScreen(isLarge: boolean): void {\n    this._largeScreen$.next(isLarge);\n  }\n\n  setMouseOnTopBar(mouseOnTopBar: boolean): void {\n    this._mouseOnTopBar$.next(mouseOnTopBar);\n  }\n\n  setSidenavElement(element: HTMLElement): void {\n    this._sidenavElement$.next(element);\n    this.createResizeBorderElement(element);\n  }\n\n  setContentElement(element: HTMLElement): void {\n    this._contentElement$.next(element);\n  }\n\n  setCollapsibleWidescreenMenu(collapsible: boolean) {\n    this._collapsibleWidescreenMenu$.next(collapsible);\n\n    if (collapsible) {\n      this.collapseSideBar();\n    }\n  }\n\n  onMainContentResize(): void {\n    this._mainContentResized$.next(null);\n  }\n\n  private createResizeBorderElement(sidenavElement: HTMLElement): void {\n    const borderElement = this.renderer.createElement('div');\n    this.renderer.addClass(borderElement, 'resize-border');\n    this.renderer.appendChild(sidenavElement, borderElement);\n    this._resizeBorderElement$.next(borderElement);\n\n    this.renderer.listen(borderElement, 'mouseenter', () => {\n      this.renderer.addClass(borderElement, 'resize-hover');\n    });\n\n    this.renderer.listen(borderElement, 'mouseleave', () => {\n      this._isResizing$.pipe(take(1)).subscribe(isResizing => {\n        if (!isResizing) {\n          this.renderer.removeClass(borderElement, 'resize-hover');\n        }\n      });\n    });\n\n    this.renderer.listen(borderElement, 'mousedown', (event: MouseEvent) => {\n      this._sidenavWidth$.pipe(take(1)).subscribe(sidenavWidth => {\n        this.sidenavWidthOnClick = sidenavWidth;\n        this.xOnClick = event.pageX;\n        this._isResizing$.next(true);\n        this.renderer.setStyle(document.body, 'user-select', 'none');\n        this.renderer.setStyle(document.body, 'cursor', 'col-resize');\n        this.renderer.setStyle(\n          document.querySelector('.cds--side-nav__navigation'),\n          'pointer-events',\n          'none'\n        );\n        this.renderer.setStyle(document.querySelector('.main-content'), 'pointer-events', 'none');\n      });\n    });\n  }\n\n  private openSidenavSizeSubscription(): void {\n    this.sidenavSizeSubscription = combineLatest([\n      this._largeScreen$,\n      this._sidenavWidth$,\n      this._sidenavElement$,\n      this._contentElement$,\n      this._resizeBorderElement$,\n      this._collapsibleWidescreenMenu$,\n    ]).subscribe(\n      ([\n        largeScreen,\n        sidenavWidth,\n        sidenavElement,\n        contentElement,\n        resizeBorderElement,\n        collapsibleWidescreenMenu,\n      ]) => {\n        if (\n          (!largeScreen || collapsibleWidescreenMenu) &&\n          sidenavElement &&\n          contentElement &&\n          resizeBorderElement\n        ) {\n          this.renderer.removeStyle(sidenavElement, 'min-width');\n          this.renderer.removeStyle(sidenavElement, 'width');\n          this.renderer.removeStyle(sidenavElement, 'transition');\n          this.renderer.removeStyle(contentElement, 'padding-left');\n          this.renderer.addClass(resizeBorderElement, 'resize-border--invisible');\n        } else if (\n          largeScreen &&\n          sidenavElement &&\n          contentElement &&\n          typeof sidenavWidth === 'number'\n        ) {\n          const pixelWidth = `${sidenavWidth}px`;\n          this.renderer.setStyle(sidenavElement, 'min-width', `${pixelWidth}`);\n          this.renderer.setStyle(sidenavElement, 'width', `${pixelWidth}`);\n          this.renderer.setStyle(sidenavElement, 'transition', 'none');\n          this.renderer.setStyle(contentElement, 'padding-left', `calc(2rem + ${pixelWidth})`);\n          this.renderer.removeClass(resizeBorderElement, 'resize-border--invisible');\n        }\n      }\n    );\n  }\n\n  private openMouseSubscriptions(): void {\n    this.mouseXSubscription = combineLatest([this._mouseX$, this._isResizing$])\n      .pipe(debounceTime(3))\n      .subscribe(([x, isResizing]) => {\n        if (isResizing) {\n          const offSetWidth = this.xOnClick - x;\n          const newSidenavWidth = this.sidenavWidthOnClick - offSetWidth;\n\n          if (newSidenavWidth <= this.maxMenuWidth && newSidenavWidth >= this.minMenuWidth) {\n            this._sidenavWidth$.next(newSidenavWidth);\n          }\n        }\n      });\n\n    this.mouseUpSubscription = fromEvent(document, 'mouseup').subscribe(() => {\n      this.stopResizing();\n    });\n  }\n\n  private stopResizing(): void {\n    const mainContent = document.querySelector('.main-content');\n    const sideNav = document.querySelector('.cds--side-nav__navigation');\n\n    this.renderer.removeStyle(document.body, 'user-select');\n    this.renderer.removeStyle(document.body, 'cursor');\n    this._isResizing$.next(false);\n    this.renderer.removeClass(this._resizeBorderElement$.getValue(), 'resize-hover');\n\n    if (sideNav) {\n      this.renderer.removeStyle(sideNav, 'pointer-events');\n    }\n\n    if (mainContent) {\n      this.renderer.removeStyle(mainContent, 'pointer-events');\n    }\n    localStorage.setItem('sidenavWidth', this._sidenavWidth$.getValue().toString());\n  }\n\n  private initMenuWidth(config: ValtimoConfig): void {\n    const customLeftSidebar = config?.customLeftSidebar;\n    const localStorageWidth = localStorage.getItem('sidenavWidth');\n    const localStorageWidthNumber = localStorageWidth && +localStorageWidth;\n    const configWidth = customLeftSidebar?.defaultMenuWidth;\n\n    this._sidenavWidth$.next(localStorageWidthNumber || configWidth || 256);\n    this.minMenuWidth = customLeftSidebar?.minMenuWidth || 150;\n    this.maxMenuWidth = customLeftSidebar?.maxMenuWidth || 500;\n  }\n}\n"]}

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

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, Subject } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class StepperService {
+    constructor() {
+        this._steps$ = new BehaviorSubject([]);
+        this._currentStepIndex$ = new BehaviorSubject(0);
+        this._returnToFirstStep$ = new Subject();
+        this._cancelClick$ = new Subject();
+        this._complete$ = new Subject();
+        this._nextStep$ = new Subject();
+        this._disabled$ = new BehaviorSubject(false);
+    }
+    get currentStepIndex$() {
+        return this._currentStepIndex$.asObservable();
+    }
+    get steps$() {
+        return this._steps$.asObservable();
+    }
+    get nextStepAvailable$() {
+        return combineLatest([this._steps$, this._currentStepIndex$]).pipe(map(([steps, currentStepIndex]) => currentStepIndex < steps.length - 1));
+    }
+    get previousStepAvailable$() {
+        return this._currentStepIndex$.pipe(map(currentStepIndex => currentStepIndex > 0));
+    }
+    get returnToFirstStep$() {
+        return this._returnToFirstStep$.asObservable();
+    }
+    get cancelClick$() {
+        return this._cancelClick$.asObservable();
+    }
+    get complete$() {
+        return this._complete$.asObservable();
+    }
+    get nextStep$() {
+        return this._nextStep$.asObservable();
+    }
+    get disabled$() {
+        return this._disabled$.asObservable();
+    }
+    setSteps(steps) {
+        const mappedSteps = steps.map((step, index) => ({
+            ...step,
+            isFirst: index === 0,
+            isLast: index === steps.length - 1,
+        }));
+        this._steps$.next(mappedSteps);
+    }
+    setCurrentStepIndex(index) {
+        this._currentStepIndex$.next(index);
+    }
+    goToNextStep() {
+        combineLatest([this.nextStepAvailable$, this._currentStepIndex$])
+            .pipe(take(1))
+            .subscribe(([nextStepAvailable, currentStepIndex]) => {
+            if (nextStepAvailable) {
+                this.setCurrentStepIndex(currentStepIndex + 1);
+                this._nextStep$.next(currentStepIndex);
+            }
+        });
+    }
+    goToPreviousStep() {
+        combineLatest([this.previousStepAvailable$, this._currentStepIndex$])
+            .pipe(take(1))
+            .subscribe(([previousStepAvailable, currentStepIndex]) => {
+            if (previousStepAvailable) {
+                this.setCurrentStepIndex(currentStepIndex - 1);
+            }
+        });
+    }
+    cancelClick() {
+        this._cancelClick$.next(null);
+    }
+    complete() {
+        this._complete$.next(null);
+    }
+    disable() {
+        this._disabled$.next(true);
+    }
+    enable() {
+        this._disabled$.next(false);
+    }
+    returnToFirstStep() {
+        this.setCurrentStepIndex(0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: StepperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: StepperService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: StepperService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepper.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/services/stepper.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Subject} from 'rxjs';\nimport {map, take} from 'rxjs/operators';\nimport {Step} from '../models';\n\n@Injectable()\nexport class StepperService {\n  private readonly _steps$ = new BehaviorSubject<Array<Step>>([]);\n  private readonly _currentStepIndex$ = new BehaviorSubject<number>(0);\n  private readonly _returnToFirstStep$ = new Subject();\n  private readonly _cancelClick$ = new Subject();\n  private readonly _complete$ = new Subject();\n  private readonly _nextStep$ = new Subject<number>();\n  private readonly _disabled$ = new BehaviorSubject<boolean>(false);\n\n  get currentStepIndex$() {\n    return this._currentStepIndex$.asObservable();\n  }\n\n  get steps$() {\n    return this._steps$.asObservable();\n  }\n\n  get nextStepAvailable$() {\n    return combineLatest([this._steps$, this._currentStepIndex$]).pipe(\n      map(([steps, currentStepIndex]) => currentStepIndex < steps.length - 1)\n    );\n  }\n\n  get previousStepAvailable$() {\n    return this._currentStepIndex$.pipe(map(currentStepIndex => currentStepIndex > 0));\n  }\n\n  get returnToFirstStep$() {\n    return this._returnToFirstStep$.asObservable();\n  }\n\n  get cancelClick$() {\n    return this._cancelClick$.asObservable();\n  }\n\n  get complete$() {\n    return this._complete$.asObservable();\n  }\n\n  get nextStep$() {\n    return this._nextStep$.asObservable();\n  }\n\n  get disabled$() {\n    return this._disabled$.asObservable();\n  }\n\n  setSteps(steps: Array<Step>): void {\n    const mappedSteps = steps.map((step, index) => ({\n      ...step,\n      isFirst: index === 0,\n      isLast: index === steps.length - 1,\n    }));\n\n    this._steps$.next(mappedSteps);\n  }\n\n  setCurrentStepIndex(index: number): void {\n    this._currentStepIndex$.next(index);\n  }\n\n  goToNextStep(): void {\n    combineLatest([this.nextStepAvailable$, this._currentStepIndex$])\n      .pipe(take(1))\n      .subscribe(([nextStepAvailable, currentStepIndex]) => {\n        if (nextStepAvailable) {\n          this.setCurrentStepIndex(currentStepIndex + 1);\n          this._nextStep$.next(currentStepIndex);\n        }\n      });\n  }\n\n  goToPreviousStep(): void {\n    combineLatest([this.previousStepAvailable$, this._currentStepIndex$])\n      .pipe(take(1))\n      .subscribe(([previousStepAvailable, currentStepIndex]) => {\n        if (previousStepAvailable) {\n          this.setCurrentStepIndex(currentStepIndex - 1);\n        }\n      });\n  }\n\n  cancelClick(): void {\n    this._cancelClick$.next(null);\n  }\n\n  complete(): void {\n    this._complete$.next(null);\n  }\n\n  disable(): void {\n    this._disabled$.next(true);\n  }\n\n  enable(): void {\n    this._disabled$.next(false);\n  }\n\n  returnToFirstStep(): void {\n    this.setCurrentStepIndex(0);\n  }\n}\n"]}

package/esm2022/lib/services/user-interface.service.mjs

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class UserInterfaceService {
+    constructor() {
+        this._showPageHeader$ = new BehaviorSubject(true);
+    }
+    get showPageHeader$() {
+        return this._showPageHeader$.asObservable();
+    }
+    showPageHeader() {
+        this._showPageHeader$.next(true);
+    }
+    hidePageHeader() {
+        this._showPageHeader$.next(false);
+    }
+    togglePageHeader() {
+        this._showPageHeader$.pipe(take(1)).subscribe(showPageHeader => {
+            this._showPageHeader$.next(!showPageHeader);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserInterfaceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserInterfaceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserInterfaceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/services/valtimo-modal.service.mjs

@@ -33,13 +33,13 @@ export class ValtimoModalService {
     setDocumentDefinitionName(documentDefinitionName) {
         this._documentDefinitionName$.next(documentDefinitionName);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValtimoModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValtimoModalService, providedIn: 'root' }); }
 }
-ValtimoModalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ValtimoModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ValtimoModalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ValtimoModalService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ValtimoModalService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValtimoModalService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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