@valtimo/components 11.3.2 → 12.1.0

package/esm2022/lib/pipes/is-array.pipe.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,11 +19,11 @@ export class IsArrayPipe {
     transform(value, minLength = 0) {
         return Array.isArray(value) && value.length >= minLength;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IsArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: IsArrayPipe, isStandalone: true, name: "isArray" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: IsArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: IsArrayPipe, isStandalone: true, name: "isArray" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IsArrayPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: IsArrayPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'isArray', standalone: true }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtYXJyYXkucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vY29tcG9uZW50cy9zcmMvbGliL3BpcGVzL2lzLWFycmF5LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSCxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQzs7QUFHbEQsTUFBTSxPQUFPLFdBQVc7SUFDdEIsU0FBUyxDQUFDLEtBQVUsRUFBRSxTQUFTLEdBQUcsQ0FBQztRQUNqQyxPQUFPLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxDQUFDLE1BQU0sSUFBSSxTQUFTLENBQUM7SUFDM0QsQ0FBQzsrR0FIVSxXQUFXOzZHQUFYLFdBQVc7OzRGQUFYLFdBQVc7a0JBRHZCLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AUGlwZSh7bmFtZTogJ2lzQXJyYXknLCBzdGFuZGFsb25lOiB0cnVlfSlcbmV4cG9ydCBjbGFzcyBJc0FycmF5UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IGFueSwgbWluTGVuZ3RoID0gMCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiBBcnJheS5pc0FycmF5KHZhbHVlKSAmJiB2YWx1ZS5sZW5ndGggPj0gbWluTGVuZ3RoO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtYXJyYXkucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vY29tcG9uZW50cy9zcmMvbGliL3BpcGVzL2lzLWFycmF5LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSCxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQzs7QUFHbEQsTUFBTSxPQUFPLFdBQVc7SUFDdEIsU0FBUyxDQUFDLEtBQVUsRUFBRSxTQUFTLEdBQUcsQ0FBQztRQUNqQyxPQUFPLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxDQUFDLE1BQU0sSUFBSSxTQUFTLENBQUM7SUFDM0QsQ0FBQzs4R0FIVSxXQUFXOzRHQUFYLFdBQVc7OzJGQUFYLFdBQVc7a0JBRHZCLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyNCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AUGlwZSh7bmFtZTogJ2lzQXJyYXknLCBzdGFuZGFsb25lOiB0cnVlfSlcbmV4cG9ydCBjbGFzcyBJc0FycmF5UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IGFueSwgbWluTGVuZ3RoID0gMCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiBBcnJheS5pc0FycmF5KHZhbHVlKSAmJiB2YWx1ZS5sZW5ndGggPj0gbWluTGVuZ3RoO1xuICB9XG59XG4iXX0=

package/esm2022/lib/pipes/menu-item-translation.pipe.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,11 +37,11 @@ export class MenuItemTranslationPipe {
             return menuItem.title;
         }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MenuItemTranslationPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: MenuItemTranslationPipe, name: "menuItemTranslate" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: MenuItemTranslationPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: MenuItemTranslationPipe, name: "menuItemTranslate" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MenuItemTranslationPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: MenuItemTranslationPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'menuItemTranslate' }]
-        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1pdGVtLXRyYW5zbGF0aW9uLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2NvbXBvbmVudHMvc3JjL2xpYi9waXBlcy9tZW51LWl0ZW0tdHJhbnNsYXRpb24ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILE9BQU8sRUFBQyxJQUFJLEVBQWdCLE1BQU0sZUFBZSxDQUFDO0FBRWxELE9BQU8sRUFBQyxhQUFhLEVBQUUsR0FBRyxFQUFhLE1BQU0sTUFBTSxDQUFDOzs7QUFJcEQsTUFBTSxPQUFPLHVCQUF1QjtJQUNsQyxZQUE2QixnQkFBa0M7UUFBbEMscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFrQjtJQUFHLENBQUM7SUFFbkUsU0FBUyxDQUFDLFFBQWtCO1FBQzFCLE1BQU0sa0JBQWtCLEdBQUcsUUFBUSxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUFFLEdBQUcsUUFBUSxDQUFDO1FBQzlFLE1BQU0sbUJBQW1CLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQztRQUUzQyxPQUFPLGFBQWEsQ0FBQztZQUNuQixJQUFJLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLGtCQUFrQixDQUFDO1lBQ2hELElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxNQUFNLENBQUMsbUJBQW1CLENBQUM7U0FDbEQsQ0FBQyxDQUFDLElBQUksQ0FDTCxHQUFHLENBQUMsQ0FBQyxDQUFDLGVBQWUsRUFBRSx3QkFBd0IsQ0FBQyxFQUFFLEVBQUU7WUFDbEQsSUFBSSxlQUFlLEtBQUssa0JBQWtCLEVBQUUsQ0FBQztnQkFDM0MsT0FBTyxlQUFlLENBQUM7WUFDekIsQ0FBQztpQkFBTSxJQUFJLHdCQUF3QixLQUFLLG1CQUFtQixFQUFFLENBQUM7Z0JBQzVELE9BQU8sd0JBQXdCLENBQUM7WUFDbEMsQ0FBQztZQUVELE9BQU8sUUFBUSxDQUFDLEtBQUssQ0FBQztRQUN4QixDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ0osQ0FBQzs4R0FyQlUsdUJBQXVCOzRHQUF2Qix1QkFBdUI7OzJGQUF2Qix1QkFBdUI7a0JBRG5DLElBQUk7bUJBQUMsRUFBQyxJQUFJLEVBQUUsbUJBQW1CLEVBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyNCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtNZW51SXRlbX0gZnJvbSAnQHZhbHRpbW8vY29uZmlnJztcbmltcG9ydCB7Y29tYmluZUxhdGVzdCwgbWFwLCBPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcbmltcG9ydCB7VHJhbnNsYXRlU2VydmljZX0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSc7XG5cbkBQaXBlKHtuYW1lOiAnbWVudUl0ZW1UcmFuc2xhdGUnfSlcbmV4cG9ydCBjbGFzcyBNZW51SXRlbVRyYW5zbGF0aW9uUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHRyYW5zbGF0ZVNlcnZpY2U6IFRyYW5zbGF0ZVNlcnZpY2UpIHt9XG5cbiAgdHJhbnNmb3JtKG1lbnVJdGVtOiBNZW51SXRlbSk6IE9ic2VydmFibGU8c3RyaW5nPiB7XG4gICAgY29uc3QgcGFnZVRyYW5zbGF0aW9uS2V5ID0gJ3BhZ2VzLicgKyBtZW51SXRlbS50aXRsZS50b0xvd2VyQ2FzZSgpICsgJy50aXRsZSc7XG4gICAgY29uc3QgdGl0bGVUcmFuc2xhdGlvbktleSA9IG1lbnVJdGVtLnRpdGxlO1xuXG4gICAgcmV0dXJuIGNvbWJpbmVMYXRlc3QoW1xuICAgICAgdGhpcy50cmFuc2xhdGVTZXJ2aWNlLnN0cmVhbShwYWdlVHJhbnNsYXRpb25LZXkpLFxuICAgICAgdGhpcy50cmFuc2xhdGVTZXJ2aWNlLnN0cmVhbSh0aXRsZVRyYW5zbGF0aW9uS2V5KSxcbiAgICBdKS5waXBlKFxuICAgICAgbWFwKChbcGFnZVRyYW5zbGF0aW9uLCBtZW51SXRlbVRpdGxlVHJhbnNsYXRpb25dKSA9PiB7XG4gICAgICAgIGlmIChwYWdlVHJhbnNsYXRpb24gIT09IHBhZ2VUcmFuc2xhdGlvbktleSkge1xuICAgICAgICAgIHJldHVybiBwYWdlVHJhbnNsYXRpb247XG4gICAgICAgIH0gZWxzZSBpZiAobWVudUl0ZW1UaXRsZVRyYW5zbGF0aW9uICE9PSB0aXRsZVRyYW5zbGF0aW9uS2V5KSB7XG4gICAgICAgICAgcmV0dXJuIG1lbnVJdGVtVGl0bGVUcmFuc2xhdGlvbjtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiBtZW51SXRlbS50aXRsZTtcbiAgICAgIH0pXG4gICAgKTtcbiAgfVxufVxuIl19

package/esm2022/lib/services/cds-theme.service.mjs

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2015-2024 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, Observable, Subscription } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { CurrentCarbonTheme, SelectableCarbonTheme } from '../models';
+import * as i0 from "@angular/core";
+export class CdsThemeService {
+    get preferredTheme$() {
+        return this._preferredTheme$.pipe(filter(theme => !!theme));
+    }
+    get currentTheme$() {
+        return this._currentTheme$.pipe(filter(theme => !!theme));
+    }
+    constructor() {
+        this._preferredTheme$ = new BehaviorSubject(SelectableCarbonTheme.G10);
+        this._currentTheme$ = new BehaviorSubject(null);
+        this._subscriptions = new Subscription();
+        this.openDarkModeSubscription();
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    setPreferredTheme(selectedTheme) {
+        if (selectedTheme)
+            this._preferredTheme$.next(selectedTheme);
+    }
+    openDarkModeSubscription() {
+        combineLatest([this.getBrowserPrefersDarkModeObservable(), this.preferredTheme$]).subscribe(([browserPrefersDarkMode, preferredTheme]) => {
+            switch (preferredTheme) {
+                case SelectableCarbonTheme.SYSTEM:
+                    if (browserPrefersDarkMode) {
+                        this.setThemeOnDocument(CurrentCarbonTheme.G90);
+                    }
+                    else {
+                        this.setThemeOnDocument(CurrentCarbonTheme.G10);
+                    }
+                    break;
+                case SelectableCarbonTheme.G10:
+                    this.setThemeOnDocument(CurrentCarbonTheme.G10);
+                    break;
+                case SelectableCarbonTheme.G90:
+                    this.setThemeOnDocument(CurrentCarbonTheme.G90);
+                    break;
+            }
+        });
+    }
+    setThemeOnDocument(theme) {
+        document.documentElement.setAttribute('data-carbon-theme', theme);
+        this._currentTheme$.next(theme);
+    }
+    getBrowserPrefersDarkModeObservable(signal) {
+        return new Observable(subscriber => {
+            if (!window.matchMedia) {
+                subscriber.error(new Error('No windows Media Match available'));
+            }
+            function emitValue(event) {
+                subscriber.next(event.matches);
+            }
+            const mediaListQuery = window.matchMedia('(prefers-color-scheme: dark)');
+            if (signal) {
+                signal.onabort = () => {
+                    mediaListQuery.removeEventListener('change', emitValue);
+                    !subscriber.closed && subscriber.complete();
+                };
+            }
+            mediaListQuery.addEventListener('change', emitValue);
+            subscriber.next(mediaListQuery.matches);
+            return () => {
+                mediaListQuery.removeEventListener('change', emitValue);
+                !subscriber.closed && subscriber.complete();
+            };
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CdsThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CdsThemeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CdsThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cds-theme.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/services/cds-theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 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 */\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable, Subscription} from 'rxjs';\nimport {filter} from 'rxjs/operators';\nimport {CurrentCarbonTheme, SelectableCarbonTheme} from '../models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CdsThemeService implements OnDestroy {\n  private readonly _preferredTheme$ = new BehaviorSubject<SelectableCarbonTheme>(\n    SelectableCarbonTheme.G10\n  );\n  private readonly _currentTheme$ = new BehaviorSubject<CurrentCarbonTheme | null>(null);\n\n  public get preferredTheme$(): Observable<SelectableCarbonTheme> {\n    return this._preferredTheme$.pipe(filter(theme => !!theme));\n  }\n\n  public get currentTheme$(): Observable<CurrentCarbonTheme> {\n    return this._currentTheme$.pipe(filter(theme => !!theme));\n  }\n\n  private readonly _subscriptions = new Subscription();\n\n  constructor() {\n    this.openDarkModeSubscription();\n  }\n\n  public ngOnDestroy(): void {\n    this._subscriptions.unsubscribe();\n  }\n\n  public setPreferredTheme(selectedTheme: SelectableCarbonTheme): void {\n    if (selectedTheme) this._preferredTheme$.next(selectedTheme);\n  }\n\n  private openDarkModeSubscription(): void {\n    combineLatest([this.getBrowserPrefersDarkModeObservable(), this.preferredTheme$]).subscribe(\n      ([browserPrefersDarkMode, preferredTheme]) => {\n        switch (preferredTheme) {\n          case SelectableCarbonTheme.SYSTEM:\n            if (browserPrefersDarkMode) {\n              this.setThemeOnDocument(CurrentCarbonTheme.G90);\n            } else {\n              this.setThemeOnDocument(CurrentCarbonTheme.G10);\n            }\n            break;\n          case SelectableCarbonTheme.G10:\n            this.setThemeOnDocument(CurrentCarbonTheme.G10);\n            break;\n          case SelectableCarbonTheme.G90:\n            this.setThemeOnDocument(CurrentCarbonTheme.G90);\n            break;\n        }\n      }\n    );\n  }\n\n  private setThemeOnDocument(theme: CurrentCarbonTheme): void {\n    document.documentElement.setAttribute('data-carbon-theme', theme);\n    this._currentTheme$.next(theme);\n  }\n\n  private getBrowserPrefersDarkModeObservable(signal?: AbortSignal): Observable<boolean> {\n    return new Observable<boolean>(subscriber => {\n      if (!window.matchMedia) {\n        subscriber.error(new Error('No windows Media Match available'));\n      }\n\n      function emitValue(event: Event) {\n        subscriber.next((event as MediaQueryListEvent).matches);\n      }\n\n      const mediaListQuery = window.matchMedia('(prefers-color-scheme: dark)');\n\n      if (signal) {\n        signal.onabort = () => {\n          mediaListQuery.removeEventListener('change', emitValue);\n          !subscriber.closed && subscriber.complete();\n        };\n      }\n\n      mediaListQuery.addEventListener('change', emitValue);\n      subscriber.next(mediaListQuery.matches);\n\n      return () => {\n        mediaListQuery.removeEventListener('change', emitValue);\n        !subscriber.closed && subscriber.complete();\n      };\n    });\n  }\n}\n"]}

package/esm2022/lib/services/choice-field.service.mjs

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@valtimo/config";
+export class ChoiceFieldService {
+    constructor(http, configService) {
+        this.http = http;
+        this.configService = configService;
+        this.valtimoApiConfig = this.configService.config.valtimoApi;
+    }
+    query(params) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}v1/choice-fields`, {
+            observe: 'response',
+            params,
+        });
+    }
+    queryPage(params) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}v2/choice-fields`, {
+            params,
+        });
+    }
+    get(id) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}v1/choice-fields/${id}`);
+    }
+    create(choiceField) {
+        return this.http.post(`${this.valtimoApiConfig.endpointUri}v1/choice-fields`, choiceField);
+    }
+    delete(id) {
+        return this.http.delete(`${this.valtimoApiConfig.endpointUri}v1/choice-fields/${id}`);
+    }
+    update(choiceField) {
+        return this.http.put(`${this.valtimoApiConfig.endpointUri}v1/choice-fields`, choiceField);
+    }
+    queryValues(keyName, params) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}v1/choice-field-values/${keyName}/values`, { observe: 'response', params });
+    }
+    queryValuesPage(keyName, params) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}v2/choice-field-values/${keyName}/values`, { params });
+    }
+    getValue(choiceFieldId) {
+        return this.http.get(`${this.valtimoApiConfig.endpointUri}v1/choice-field-values/${choiceFieldId}`);
+    }
+    updateValue(choiceFieldValue, choiceFieldName) {
+        return this.http.put(`${this.valtimoApiConfig.endpointUri}v1/choice-field-values`, choiceFieldValue, {
+            params: { choice_field_name: choiceFieldName },
+        });
+    }
+    createValue(choiceFieldValue, choiceFieldName) {
+        return this.http.post(`${this.valtimoApiConfig.endpointUri}v1/choice-field-values`, choiceFieldValue, { params: { choice_field_name: choiceFieldName } });
+    }
+    getChoiceFieldByName(name) {
+        return this.http.get(this.valtimoApiConfig.endpointUri + 'v1/choice-fields/name/' + name);
+    }
+    getChoiceFieldValueByNameAndValue(name, value) {
+        return this.http.get(this.valtimoApiConfig.endpointUri +
+            'v1/choice-field-values/choice-field/' +
+            name +
+            '/value/' +
+            value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ChoiceFieldService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ChoiceFieldService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ChoiceFieldService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"choice-field.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/services/choice-field.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 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 */\nimport {HttpClient} from '@angular/common/http';\nimport {Injectable} from '@angular/core';\nimport {ConfigService, Page} from '@valtimo/config';\nimport {Observable} from 'rxjs';\nimport {ChoiceField, ChoiceFieldValue, ChoicefieldValue} from '../models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ChoiceFieldService {\n  private valtimoApiConfig: any;\n\n  constructor(\n    private http: HttpClient,\n    private configService: ConfigService\n  ) {\n    this.valtimoApiConfig = this.configService.config.valtimoApi;\n  }\n\n  query(params?: any): Observable<any> {\n    return this.http.get<ChoiceField>(`${this.valtimoApiConfig.endpointUri}v1/choice-fields`, {\n      observe: 'response',\n      params,\n    });\n  }\n\n  queryPage(params?: any): Observable<Page<ChoiceField>> {\n    return this.http.get<Page<ChoiceField>>(\n      `${this.valtimoApiConfig.endpointUri}v2/choice-fields`,\n      {\n        params,\n      }\n    );\n  }\n\n  get(id: string): Observable<any> {\n    return this.http.get<ChoiceField>(`${this.valtimoApiConfig.endpointUri}v1/choice-fields/${id}`);\n  }\n\n  create(choiceField: any): Observable<any> {\n    return this.http.post(`${this.valtimoApiConfig.endpointUri}v1/choice-fields`, choiceField);\n  }\n\n  delete(id: any) {\n    return this.http.delete(`${this.valtimoApiConfig.endpointUri}v1/choice-fields/${id}`);\n  }\n\n  update(choiceField: any): Observable<any> {\n    return this.http.put(`${this.valtimoApiConfig.endpointUri}v1/choice-fields`, choiceField);\n  }\n\n  queryValues(keyName: string, params?: any): Observable<any> {\n    return this.http.get<ChoiceField>(\n      `${this.valtimoApiConfig.endpointUri}v1/choice-field-values/${keyName}/values`,\n      {observe: 'response', params}\n    );\n  }\n\n  queryValuesPage(keyName: string, params?: any): Observable<Page<ChoiceFieldValue>> {\n    return this.http.get<Page<ChoiceFieldValue>>(\n      `${this.valtimoApiConfig.endpointUri}v2/choice-field-values/${keyName}/values`,\n      {params}\n    );\n  }\n\n  getValue(choiceFieldId: string): Observable<any> {\n    return this.http.get<ChoiceField>(\n      `${this.valtimoApiConfig.endpointUri}v1/choice-field-values/${choiceFieldId}`\n    );\n  }\n\n  updateValue(choiceFieldValue: any, choiceFieldName: string): Observable<any> {\n    return this.http.put(\n      `${this.valtimoApiConfig.endpointUri}v1/choice-field-values`,\n      choiceFieldValue,\n      {\n        params: {choice_field_name: choiceFieldName},\n      }\n    );\n  }\n\n  createValue(choiceFieldValue: any, choiceFieldName: string): Observable<any> {\n    return this.http.post(\n      `${this.valtimoApiConfig.endpointUri}v1/choice-field-values`,\n      choiceFieldValue,\n      {params: {choice_field_name: choiceFieldName}}\n    );\n  }\n\n  getChoiceFieldByName(name: string): Observable<any> {\n    return this.http.get(this.valtimoApiConfig.endpointUri + 'v1/choice-fields/name/' + name);\n  }\n\n  getChoiceFieldValueByNameAndValue(name: string, value: string): Observable<any> {\n    return this.http.get(\n      this.valtimoApiConfig.endpointUri +\n        'v1/choice-field-values/choice-field/' +\n        name +\n        '/value/' +\n        value\n    );\n  }\n}\n"]}

package/esm2022/lib/services/index.mjs

@@ -1,7 +1,28 @@
+/*
+ * Copyright 2015-2024 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.
+ */
 export * from './modal.service';
 export * from './prompt.service';
 export * from './shell.service';
 export * from './stepper.service';
 export * from './user-interface.service';
 export * from './valtimo-modal.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2NvbXBvbmVudHMvc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kYWwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Byb21wdC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2hlbGwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0ZXBwZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXItaW50ZXJmYWNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi92YWx0aW1vLW1vZGFsLnNlcnZpY2UnO1xuIl19
+export * from './page-header.service';
+export * from './cds-theme.service';
+export * from './choice-field.service';
+export * from './page-subtitle.service';
+export * from './page-title.service';
+export * from './key-generator.service';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/key-generator.service.mjs

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2015-2024 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 * as i0 from "@angular/core";
+export class KeyGeneratorService {
+    getUniqueKey(entityName, usedKeys) {
+        const dashCaseKey = `${entityName}`
+            .toLowerCase()
+            .replace(/[^a-z0-9-_]+|-[^a-z0-9]+/g, '-')
+            .replace(/_[-_]+/g, '_')
+            .replace(/^[^a-z]+/g, '');
+        if (!usedKeys.includes(dashCaseKey)) {
+            return dashCaseKey;
+        }
+        return this.getUniqueKeyWithNumber(dashCaseKey, usedKeys);
+    }
+    getUniqueKeyWithNumber(dashCaseKey, usedKeys) {
+        const numbersFromCurrentKey = (dashCaseKey.match(/^\d+|\d+\b|\d+(?=\w)/g) || []).map((numberValue) => +numberValue);
+        const lastNumberFromCurrentKey = numbersFromCurrentKey.length > 0 && numbersFromCurrentKey[numbersFromCurrentKey.length - 1];
+        const newKey = lastNumberFromCurrentKey
+            ? `${dashCaseKey.replace(`${lastNumberFromCurrentKey}`, `${lastNumberFromCurrentKey + 1}`)}`
+            : `${dashCaseKey}-1`;
+        if (usedKeys.includes(newKey)) {
+            return this.getUniqueKeyWithNumber(newKey, usedKeys);
+        }
+        return newKey;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: KeyGeneratorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: KeyGeneratorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: KeyGeneratorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/key-state.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { fromEvent, merge, Subject } from 'rxjs';
+import { map, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class KeyStateService {
+    constructor() {
+        this._isCtrlOrCmdPressed = false;
+        this._destroy$ = new Subject();
+        const keyDowns$ = fromEvent(document, 'keydown').pipe(map(event => event.ctrlKey || event.metaKey));
+        const keyUps$ = fromEvent(document, 'keyup').pipe(map(() => false));
+        merge(keyDowns$, keyUps$)
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(isPressed => {
+            this._isCtrlOrCmdPressed = isPressed;
+        });
+    }
+    getCtrlOrCmdState() {
+        return this._isCtrlOrCmdPressed;
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: KeyStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: KeyStateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: KeyStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -116,13 +116,13 @@ export class ModalService {
     enablePageScroll() {
         this.renderer.removeStyle(document.getElementsByTagName('html')[0], 'overflow');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ModalService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ModalService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ModalService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ModalService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ModalService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/services/modal.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,UAAU,EAA+B,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAC,eAAe,EAAE,aAAa,EAAa,MAAM,MAAM,CAAC;AAChE,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;;AAO9C,MAAM,OAAO,YAAY;IAUvB,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IAChD,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;IAC5C,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,YAAmB,gBAAkC;QAAlC,qBAAgB,GAAhB,gBAAgB,CAAkB;QArCpC,gBAAW,GAAG,IAAI,eAAe,CAAS,EAAE,CAAC,CAAC;QAC9C,mBAAc,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QACrD,gBAAW,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAClD,mBAAc,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QACrD,uBAAkB,GAAG,IAAI,eAAe,CAAS,GAAG,CAAC,CAAC;QACtD,gBAAW,GAAG,IAAI,eAAe,CAAY,EAAE,CAAC,CAAC;QAiChE,IAAI,CAAC,QAAQ,GAAG,gBAAgB,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED,eAAe,CAAC,cAA+B;QAC7C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,YAAY,CAAC,SAAoB;QAC/B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,SAAS,CAAC,cAAgC,EAAE,SAAqB;QAC/D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,IAAI,cAAc,EAAE;YAClB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,EAAE;gBAC1D,IAAI,cAAc,CAAC,IAAI,KAAK,gBAAgB,EAAE;oBAC5C,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;iBACtC;YACH,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,SAAS,EAAE;YACb,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;SAC9B;IACH,CAAC;IAED,UAAU,CAAC,gBAA6B;QACtC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,IAAI,gBAAgB,EAAE;YACpB,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,gBAAgB,EAAE,CAAC;YACrB,CAAC,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;SAC3B;IACH,CAAC;IAED,eAAe,CAAC,SAAiB;QAC/B,OAAO,aAAa,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAChE,GAAG,CACD,CAAC,CAAC,mBAAmB,EAAE,gBAAgB,CAAC,EAAE,EAAE,CAC1C,mBAAmB,IAAI,gBAAgB,KAAK,SAAS,CACxD,EACD,GAAG,CAAC,OAAO,CAAC,EAAE;YACZ,IAAI,OAAO,EAAE;gBACX,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC5B,IAAI,CAAC,mBAAmB,EAAE,CAAC;aAC5B;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,iBAAiB,CAAC,gBAAwB;QACxC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACjD,CAAC;IAEO,mBAAmB;QACzB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,EAAE;YACjE,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC,EAAE,gBAAgB,CAAC,CAAC;QACvB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,EAAE;YACjE,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAChC,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,CAAC,EAAE,gBAAgB,CAAC,CAAC;QACvB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EACxC,UAAU,EACV,QAAQ,EACR,mBAAmB,CAAC,SAAS,CAC9B,CAAC;IACJ,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IAClF,CAAC;+GApIU,YAAY;mHAAZ,YAAY,cAFX,MAAM;;4FAEP,YAAY;kBAHxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","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, Renderer2, RendererFactory2, RendererStyleFlags2} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable} from 'rxjs';\nimport {map, take, tap} from 'rxjs/operators';\nimport {VModalComponent} from '../components/v-modal/modal.component';\nimport {ModalData} from '../models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModalService {\n  private readonly _modalUuid$ = new BehaviorSubject<string>('');\n  private readonly _modalVisible$ = new BehaviorSubject<boolean>(false);\n  private readonly _appearing$ = new BehaviorSubject<boolean>(false);\n  private readonly _disappearing$ = new BehaviorSubject<boolean>(false);\n  private readonly _appearingDelayMs$ = new BehaviorSubject<number>(140);\n  private readonly _modalData$ = new BehaviorSubject<ModalData>({});\n\n  private renderer!: Renderer2;\n\n  get modalUuid$() {\n    return this._modalUuid$.asObservable();\n  }\n\n  get modalVisible$() {\n    return this._modalVisible$.asObservable();\n  }\n\n  get appearing$() {\n    return this._appearing$.asObservable();\n  }\n\n  get disappearing$() {\n    return this._disappearing$.asObservable();\n  }\n\n  get appearingDelayMs$() {\n    return this._appearingDelayMs$.asObservable();\n  }\n\n  get appearingDelayMs() {\n    return this._appearingDelayMs$.getValue();\n  }\n\n  get modalData$() {\n    return this._modalData$.asObservable();\n  }\n\n  constructor(public rendererFactory2: RendererFactory2) {\n    this.renderer = rendererFactory2.createRenderer(null, null);\n  }\n\n  setCurrentModal(modalComponent: VModalComponent): void {\n    this._modalUuid$.next(modalComponent.uuid);\n  }\n\n  setModalData(modalData: ModalData): void {\n    this._modalData$.next(modalData);\n  }\n\n  clearModalData(): void {\n    this._modalData$.next({});\n  }\n\n  openModal(modalComponent?: VModalComponent, modalData?: ModalData): void {\n    this._modalVisible$.next(true);\n    this.disablePageScroll();\n\n    if (modalComponent) {\n      this._modalUuid$.pipe(take(1)).subscribe(currentModalUuid => {\n        if (modalComponent.uuid !== currentModalUuid) {\n          this.setCurrentModal(modalComponent);\n        }\n      });\n    }\n\n    if (modalData) {\n      this.setModalData(modalData);\n    }\n  }\n\n  closeModal(callBackFunction?: () => void): void {\n    this._disappearing$.next(true);\n    this.setDisappearingTimeout();\n    this._modalVisible$.next(false);\n    this.enablePageScroll();\n\n    if (callBackFunction) {\n      setTimeout(() => {\n        this.clearModalData();\n        callBackFunction();\n      }, this.appearingDelayMs);\n    }\n  }\n\n  getModalVisible(modalUuid: string): Observable<boolean> {\n    return combineLatest([this._modalVisible$, this._modalUuid$]).pipe(\n      map(\n        ([currentModalVisible, currentModalUuid]) =>\n          currentModalVisible && currentModalUuid === modalUuid\n      ),\n      tap(visible => {\n        if (visible) {\n          this._appearing$.next(true);\n          this.setAppearingTimeout();\n        }\n      })\n    );\n  }\n\n  setAppearingDelay(appearingDelayMs: number): void {\n    this._appearingDelayMs$.next(appearingDelayMs);\n  }\n\n  private setAppearingTimeout(): void {\n    this._appearingDelayMs$.pipe(take(1)).subscribe(appearingDelayMs => {\n      setTimeout(() => {\n        this._appearing$.next(false);\n      }, appearingDelayMs);\n    });\n  }\n\n  private setDisappearingTimeout(): void {\n    this._appearingDelayMs$.pipe(take(1)).subscribe(appearingDelayMs => {\n      setTimeout(() => {\n        this._disappearing$.next(false);\n        this.clearModalData();\n      }, appearingDelayMs);\n    });\n  }\n\n  private disablePageScroll(): void {\n    this.renderer.setStyle(\n      document.getElementsByTagName('html')[0],\n      'overflow',\n      'hidden',\n      RendererStyleFlags2.Important\n    );\n  }\n\n  private enablePageScroll(): void {\n    this.renderer.removeStyle(document.getElementsByTagName('html')[0], 'overflow');\n  }\n}\n"]}
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/components/src/lib/services/modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 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, Renderer2, RendererFactory2, RendererStyleFlags2} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable} from 'rxjs';\nimport {map, take, tap} from 'rxjs/operators';\nimport {VModalComponent} from '../components/v-modal/modal.component';\nimport {ModalData} from '../models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModalService {\n  private readonly _modalUuid$ = new BehaviorSubject<string>('');\n  private readonly _modalVisible$ = new BehaviorSubject<boolean>(false);\n  private readonly _appearing$ = new BehaviorSubject<boolean>(false);\n  private readonly _disappearing$ = new BehaviorSubject<boolean>(false);\n  private readonly _appearingDelayMs$ = new BehaviorSubject<number>(140);\n  private readonly _modalData$ = new BehaviorSubject<ModalData>({});\n\n  private renderer!: Renderer2;\n\n  get modalUuid$() {\n    return this._modalUuid$.asObservable();\n  }\n\n  get modalVisible$() {\n    return this._modalVisible$.asObservable();\n  }\n\n  get appearing$() {\n    return this._appearing$.asObservable();\n  }\n\n  get disappearing$() {\n    return this._disappearing$.asObservable();\n  }\n\n  get appearingDelayMs$() {\n    return this._appearingDelayMs$.asObservable();\n  }\n\n  get appearingDelayMs() {\n    return this._appearingDelayMs$.getValue();\n  }\n\n  get modalData$() {\n    return this._modalData$.asObservable();\n  }\n\n  constructor(public rendererFactory2: RendererFactory2) {\n    this.renderer = rendererFactory2.createRenderer(null, null);\n  }\n\n  setCurrentModal(modalComponent: VModalComponent): void {\n    this._modalUuid$.next(modalComponent.uuid);\n  }\n\n  setModalData(modalData: ModalData): void {\n    this._modalData$.next(modalData);\n  }\n\n  clearModalData(): void {\n    this._modalData$.next({});\n  }\n\n  openModal(modalComponent?: VModalComponent, modalData?: ModalData): void {\n    this._modalVisible$.next(true);\n    this.disablePageScroll();\n\n    if (modalComponent) {\n      this._modalUuid$.pipe(take(1)).subscribe(currentModalUuid => {\n        if (modalComponent.uuid !== currentModalUuid) {\n          this.setCurrentModal(modalComponent);\n        }\n      });\n    }\n\n    if (modalData) {\n      this.setModalData(modalData);\n    }\n  }\n\n  closeModal(callBackFunction?: () => void): void {\n    this._disappearing$.next(true);\n    this.setDisappearingTimeout();\n    this._modalVisible$.next(false);\n    this.enablePageScroll();\n\n    if (callBackFunction) {\n      setTimeout(() => {\n        this.clearModalData();\n        callBackFunction();\n      }, this.appearingDelayMs);\n    }\n  }\n\n  getModalVisible(modalUuid: string): Observable<boolean> {\n    return combineLatest([this._modalVisible$, this._modalUuid$]).pipe(\n      map(\n        ([currentModalVisible, currentModalUuid]) =>\n          currentModalVisible && currentModalUuid === modalUuid\n      ),\n      tap(visible => {\n        if (visible) {\n          this._appearing$.next(true);\n          this.setAppearingTimeout();\n        }\n      })\n    );\n  }\n\n  setAppearingDelay(appearingDelayMs: number): void {\n    this._appearingDelayMs$.next(appearingDelayMs);\n  }\n\n  private setAppearingTimeout(): void {\n    this._appearingDelayMs$.pipe(take(1)).subscribe(appearingDelayMs => {\n      setTimeout(() => {\n        this._appearing$.next(false);\n      }, appearingDelayMs);\n    });\n  }\n\n  private setDisappearingTimeout(): void {\n    this._appearingDelayMs$.pipe(take(1)).subscribe(appearingDelayMs => {\n      setTimeout(() => {\n        this._disappearing$.next(false);\n        this.clearModalData();\n      }, appearingDelayMs);\n    });\n  }\n\n  private disablePageScroll(): void {\n    this.renderer.setStyle(\n      document.getElementsByTagName('html')[0],\n      'overflow',\n      'hidden',\n      RendererStyleFlags2.Important\n    );\n  }\n\n  private enablePageScroll(): void {\n    this.renderer.removeStyle(document.getElementsByTagName('html')[0], 'overflow');\n  }\n}\n"]}

package/esm2022/lib/services/page-header.service.mjs

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2015-2024 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 { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/config";
+export class PageHeaderService {
+    get headerViewContainerRef$() {
+        return this._headerViewContainerRef$.pipe(filter(ref => !!ref));
+    }
+    get contentViewContainerRef$() {
+        return this._contentViewContainerRef$.pipe(filter(ref => !!ref));
+    }
+    get compactMode$() {
+        return this._compactMode$.asObservable();
+    }
+    get showUserNameInTopBar$() {
+        return this._showUserNameInTopBar$.asObservable();
+    }
+    get pageActionsHasContent$() {
+        return this._pageActionsHasContent$.asObservable();
+    }
+    get pageHeadHeight$() {
+        return this._pageHeadHeight$.pipe(filter(height => height !== null));
+    }
+    constructor(configService) {
+        this.configService = configService;
+        this._headerViewContainerRef$ = new BehaviorSubject(null);
+        this._contentViewContainerRef$ = new BehaviorSubject(null);
+        this._compactMode$ = new BehaviorSubject(!!this.configService?.config?.featureToggles?.compactModeOnByDefault);
+        this._showUserNameInTopBar$ = new BehaviorSubject(this.getDefaultShowUserNameInTopBarValue());
+        this._pageActionsHasContent$ = new BehaviorSubject(false);
+        this._pageHeadHeight$ = new BehaviorSubject(null);
+    }
+    setHeaderViewContainerRef(ref) {
+        this._headerViewContainerRef$.next(ref);
+    }
+    setContentViewContainerRef(ref) {
+        this._contentViewContainerRef$.next(ref);
+    }
+    setCompactMode(compactMode) {
+        this._compactMode$.next(compactMode);
+    }
+    setShowUserNameInTopBar(show) {
+        this._showUserNameInTopBar$.next(show);
+    }
+    setPageActionsHasContent(hasContent) {
+        this._pageActionsHasContent$.next(hasContent);
+    }
+    setPageHeadHeight(height) {
+        this._pageHeadHeight$.next(height);
+    }
+    getDefaultShowUserNameInTopBarValue() {
+        const featureToggles = this.configService?.config?.featureToggles;
+        if (featureToggles && featureToggles.hasOwnProperty('showUserNameInTopBar')) {
+            return featureToggles.showUserNameInTopBar;
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PageHeaderService, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PageHeaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PageHeaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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