@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/feature-flags/lib/providers/debug-feature-flags.provider.mjs

@@ -0,0 +1,51 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { APP_INITIALIZER } from '@angular/core';
+import { FlagsOverrideToken, FeaturesServiceToken, WritableFeaturesServiceConfigToken, WritableFeaturesServiceToken } from '../interfaces/features.interface';
+import { StorageFeaturesService } from '../services/storage-features.service';
+import { DebugFeaturesService } from '../services/debug-features.service';
+import { QaFeaturesHelper } from '../services/qa-features.helper';
+import { DOCUMENT } from '@angular/common';
+/**
+ *
+ * @param config Configuration for the Feature Flags
+ * @returns Environment Providers for Feature Flags
+ */
+export function provideDebugFeatureFlags(config) {
+    return [
+        { provide: FlagsOverrideToken, useValue: true },
+        { provide: FeaturesServiceToken, useClass: DebugFeaturesService },
+        { provide: WritableFeaturesServiceConfigToken, useValue: config },
+        { provide: WritableFeaturesServiceToken, useClass: StorageFeaturesService },
+        { provide: QaFeaturesHelper, useClass: QaFeaturesHelper },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (featuresService) => () => featuresService.init(),
+            deps: [WritableFeaturesServiceToken],
+            multi: true
+        },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (qaFeaturesHelper, document) => () => {
+                document[config.helperExposeKeyOnDocument ?? 'featureOverrides'] = qaFeaturesHelper;
+            },
+            deps: [QaFeaturesHelper, DOCUMENT],
+            multi: true
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVidWctZmVhdHVyZS1mbGFncy5wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL2ZlYXR1cmUtZmxhZ3Mvc3JjL2xpYi9wcm92aWRlcnMvZGVidWctZmVhdHVyZS1mbGFncy5wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2hELE9BQU8sRUFDSCxrQkFBa0IsRUFDbEIsb0JBQW9CLEVBR3BCLGtDQUFrQyxFQUNsQyw0QkFBNEIsRUFDL0IsTUFBTSxrQ0FBa0MsQ0FBQztBQUMxQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUM5RSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUMxRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNsRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFM0M7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSx3QkFBd0IsQ0FBQyxNQUE4RDtJQUNuRyxPQUFPO1FBQ0gsRUFBRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtRQUMvQyxFQUFFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxRQUFRLEVBQUUsb0JBQW9CLEVBQUU7UUFDakUsRUFBRSxPQUFPLEVBQUUsa0NBQWtDLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRTtRQUNqRSxFQUFFLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxRQUFRLEVBQUUsc0JBQXNCLEVBQUU7UUFDM0UsRUFBRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsUUFBUSxFQUFFLGdCQUFnQixFQUFFO1FBQ3pEO1lBQ0ksT0FBTyxFQUFFLGVBQWU7WUFDeEIsVUFBVSxFQUFFLENBQUMsZUFBdUMsRUFBRSxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRTtZQUNyRixJQUFJLEVBQUUsQ0FBQyw0QkFBNEIsQ0FBQztZQUNwQyxLQUFLLEVBQUUsSUFBSTtTQUNkO1FBQ0Q7WUFDSSxPQUFPLEVBQUUsZUFBZTtZQUN4QixVQUFVLEVBQUUsQ0FBQyxnQkFBa0MsRUFBRSxRQUF3RCxFQUFFLEVBQUUsQ0FBQyxHQUFHLEVBQUU7Z0JBQy9HLFFBQVEsQ0FBQyxNQUFNLENBQUMseUJBQXlCLElBQUksa0JBQWtCLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQztZQUN4RixDQUFDO1lBQ0QsSUFBSSxFQUFFLENBQUMsZ0JBQWdCLEVBQUUsUUFBUSxDQUFDO1lBQ2xDLEtBQUssRUFBRSxJQUFJO1NBQ2Q7S0FDSixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgQVBQX0lOSVRJQUxJWkVSIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICAgIEZsYWdzT3ZlcnJpZGVUb2tlbixcbiAgICBGZWF0dXJlc1NlcnZpY2VUb2tlbixcbiAgICBRYUZlYXR1cmVzSGVscGVyQ29uZmlnLFxuICAgIFdyaXRhYmxlRmVhdHVyZXNTZXJ2aWNlQ29uZmlnLFxuICAgIFdyaXRhYmxlRmVhdHVyZXNTZXJ2aWNlQ29uZmlnVG9rZW4sXG4gICAgV3JpdGFibGVGZWF0dXJlc1NlcnZpY2VUb2tlblxufSBmcm9tICcuLi9pbnRlcmZhY2VzL2ZlYXR1cmVzLmludGVyZmFjZSc7XG5pbXBvcnQgeyBTdG9yYWdlRmVhdHVyZXNTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvc3RvcmFnZS1mZWF0dXJlcy5zZXJ2aWNlJztcbmltcG9ydCB7IERlYnVnRmVhdHVyZXNTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvZGVidWctZmVhdHVyZXMuc2VydmljZSc7XG5pbXBvcnQgeyBRYUZlYXR1cmVzSGVscGVyIH0gZnJvbSAnLi4vc2VydmljZXMvcWEtZmVhdHVyZXMuaGVscGVyJztcbmltcG9ydCB7IERPQ1VNRU5UIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuLyoqXG4gKlxuICogQHBhcmFtIGNvbmZpZyBDb25maWd1cmF0aW9uIGZvciB0aGUgRmVhdHVyZSBGbGFnc1xuICogQHJldHVybnMgRW52aXJvbm1lbnQgUHJvdmlkZXJzIGZvciBGZWF0dXJlIEZsYWdzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlRGVidWdGZWF0dXJlRmxhZ3MoY29uZmlnOiBXcml0YWJsZUZlYXR1cmVzU2VydmljZUNvbmZpZyAmIFFhRmVhdHVyZXNIZWxwZXJDb25maWcpIHtcbiAgICByZXR1cm4gW1xuICAgICAgICB7IHByb3ZpZGU6IEZsYWdzT3ZlcnJpZGVUb2tlbiwgdXNlVmFsdWU6IHRydWUgfSxcbiAgICAgICAgeyBwcm92aWRlOiBGZWF0dXJlc1NlcnZpY2VUb2tlbiwgdXNlQ2xhc3M6IERlYnVnRmVhdHVyZXNTZXJ2aWNlIH0sXG4gICAgICAgIHsgcHJvdmlkZTogV3JpdGFibGVGZWF0dXJlc1NlcnZpY2VDb25maWdUb2tlbiwgdXNlVmFsdWU6IGNvbmZpZyB9LFxuICAgICAgICB7IHByb3ZpZGU6IFdyaXRhYmxlRmVhdHVyZXNTZXJ2aWNlVG9rZW4sIHVzZUNsYXNzOiBTdG9yYWdlRmVhdHVyZXNTZXJ2aWNlIH0sXG4gICAgICAgIHsgcHJvdmlkZTogUWFGZWF0dXJlc0hlbHBlciwgdXNlQ2xhc3M6IFFhRmVhdHVyZXNIZWxwZXIgfSxcbiAgICAgICAge1xuICAgICAgICAgICAgcHJvdmlkZTogQVBQX0lOSVRJQUxJWkVSLFxuICAgICAgICAgICAgdXNlRmFjdG9yeTogKGZlYXR1cmVzU2VydmljZTogU3RvcmFnZUZlYXR1cmVzU2VydmljZSkgPT4gKCkgPT4gZmVhdHVyZXNTZXJ2aWNlLmluaXQoKSxcbiAgICAgICAgICAgIGRlcHM6IFtXcml0YWJsZUZlYXR1cmVzU2VydmljZVRva2VuXSxcbiAgICAgICAgICAgIG11bHRpOiB0cnVlXG4gICAgICAgIH0sXG4gICAgICAgIHtcbiAgICAgICAgICAgIHByb3ZpZGU6IEFQUF9JTklUSUFMSVpFUixcbiAgICAgICAgICAgIHVzZUZhY3Rvcnk6IChxYUZlYXR1cmVzSGVscGVyOiBRYUZlYXR1cmVzSGVscGVyLCBkb2N1bWVudDogRG9jdW1lbnQgJiB7IFtrZXk6IHN0cmluZ106IFFhRmVhdHVyZXNIZWxwZXIgfSkgPT4gKCkgPT4ge1xuICAgICAgICAgICAgICAgIGRvY3VtZW50W2NvbmZpZy5oZWxwZXJFeHBvc2VLZXlPbkRvY3VtZW50ID8/ICdmZWF0dXJlT3ZlcnJpZGVzJ10gPSBxYUZlYXR1cmVzSGVscGVyO1xuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIGRlcHM6IFtRYUZlYXR1cmVzSGVscGVyLCBET0NVTUVOVF0sXG4gICAgICAgICAgICBtdWx0aTogdHJ1ZVxuICAgICAgICB9XG4gICAgXTtcbn1cbiJdfQ==

package/esm2022/feature-flags/lib/providers/dummy-feature-flags.provider.mjs

@@ -0,0 +1,36 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { IsFlagsOverrideOn } from '../guards/is-flags-override-on.guard';
+import { IsFeatureOn } from '../guards/is-feature-on.guard';
+import { IsFeatureOff } from '../guards/is-feature-off.guard';
+import { FeaturesServiceToken, FlagsOverrideToken } from '../interfaces/features.interface';
+import { DummyFeaturesService } from '../services/dummy-features.service';
+/**
+ * Provides the dummy feature flags.
+ *
+ * @returns Environment Providers for Feature Flags.
+ */
+export function provideDummyFeatureFlags() {
+    return [
+        { provide: FeaturesServiceToken, useClass: DummyFeaturesService },
+        { provide: FlagsOverrideToken, useValue: false },
+        IsFeatureOn,
+        IsFeatureOff,
+        IsFlagsOverrideOn
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/feature-flags/lib/services/debug-features.service.mjs

@@ -0,0 +1,94 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { filter, switchMap } from 'rxjs/operators';
+import { OverridableFeaturesServiceToken, WritableFeaturesServiceToken, WritableFeaturesServiceConfigToken } from '../interfaces/features.interface';
+import * as i0 from "@angular/core";
+export class DebugFeaturesService {
+    get storageKey() {
+        return `${this.config?.storageKey || 'feature-flags'}-override`;
+    }
+    constructor(overriddenFeaturesService, writableFeaturesService, config) {
+        this.overriddenFeaturesService = overriddenFeaturesService;
+        this.writableFeaturesService = writableFeaturesService;
+        this.config = config;
+        this.isInDebugModeSubject = new BehaviorSubject(false);
+        this.isInDebugMode$ = this.isInDebugModeSubject.asObservable();
+        this.initSubject = new BehaviorSubject(false);
+        this.init();
+        combineLatest({
+            debugMode: this.isInDebugModeSubject,
+            init: this.waitForInitializationToFinish()
+        }).subscribe(({ debugMode }) => {
+            sessionStorage.setItem(this.storageKey, JSON.stringify(debugMode));
+        });
+    }
+    isOn$(key) {
+        return this.isInDebugMode$.pipe(switchMap((isInDebugMode) => (isInDebugMode ? this.writableFeaturesService : this.overriddenFeaturesService).isOn$(key)));
+    }
+    isOff$(key) {
+        return this.isInDebugMode$.pipe(switchMap((isInDebugMode) => (isInDebugMode ? this.writableFeaturesService : this.overriddenFeaturesService).isOff$(key)));
+    }
+    /**
+     * Gets the flags as an observable.
+     *
+     * @returns the observable that emits the flag changeset.
+     */
+    getFlags$() {
+        return this.isInDebugMode$.pipe(switchMap((isInDebugMode) => (isInDebugMode ? this.writableFeaturesService : this.overriddenFeaturesService).getFlags$()));
+    }
+    /**
+     * Resets the specified flags.
+     *
+     * @param flags The flags to reset.
+     */
+    resetFlags(flags) {
+        this.writableFeaturesService.resetFlags(flags);
+    }
+    enable(on) {
+        this.isInDebugModeSubject.next(on);
+    }
+    isEnabled$() {
+        return this.isInDebugMode$;
+    }
+    init() {
+        const storedOverride = JSON.parse(sessionStorage.getItem(this.storageKey) || 'false');
+        this.isInDebugModeSubject.next(storedOverride);
+        this.initSubject.next(true);
+    }
+    waitForInitializationToFinish() {
+        return this.initSubject.pipe(filter((initialized) => !!initialized));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugFeaturesService, deps: [{ token: OverridableFeaturesServiceToken }, { token: WritableFeaturesServiceToken }, { token: WritableFeaturesServiceConfigToken, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugFeaturesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugFeaturesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [OverridableFeaturesServiceToken]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WritableFeaturesServiceToken]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WritableFeaturesServiceConfigToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug-features.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/feature-flags/src/lib/services/debug-features.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (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 *     http://www.apache.org/licenses/LICENSE-2.0\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 { Inject, Injectable, Optional } from '@angular/core';\nimport { BehaviorSubject, Observable, combineLatest } from 'rxjs';\nimport { filter, switchMap } from 'rxjs/operators';\nimport {\n    IDebugFeaturesService,\n    IFeaturesService,\n    FlagChangeset,\n    OverridableFeaturesServiceToken,\n    WritableFeaturesServiceToken,\n    WritableFeaturesServiceConfigToken,\n    WritableFeaturesServiceConfig,\n    FlagSet,\n    IWritableFeaturesService\n} from '../interfaces/features.interface';\n\n@Injectable()\nexport class DebugFeaturesService implements IDebugFeaturesService {\n    private readonly isInDebugModeSubject = new BehaviorSubject<boolean>(false);\n    private readonly isInDebugMode$ = this.isInDebugModeSubject.asObservable();\n    private readonly initSubject = new BehaviorSubject<boolean>(false);\n\n    get storageKey(): string {\n        return `${this.config?.storageKey || 'feature-flags'}-override`;\n    }\n\n    constructor(\n        @Inject(OverridableFeaturesServiceToken) private overriddenFeaturesService: IFeaturesService,\n        @Inject(WritableFeaturesServiceToken) private writableFeaturesService: IFeaturesService & IWritableFeaturesService,\n        @Optional() @Inject(WritableFeaturesServiceConfigToken) private config?: WritableFeaturesServiceConfig\n    ) {\n        this.init();\n\n        combineLatest({\n            debugMode: this.isInDebugModeSubject,\n            init: this.waitForInitializationToFinish()\n        }).subscribe(({ debugMode }) => {\n            sessionStorage.setItem(this.storageKey, JSON.stringify(debugMode));\n        });\n    }\n\n    isOn$(key: string): Observable<boolean> {\n        return this.isInDebugMode$.pipe(\n            switchMap((isInDebugMode) => (isInDebugMode ? this.writableFeaturesService : this.overriddenFeaturesService).isOn$(key))\n        );\n    }\n\n    isOff$(key: string): Observable<boolean> {\n        return this.isInDebugMode$.pipe(\n            switchMap((isInDebugMode) => (isInDebugMode ? this.writableFeaturesService : this.overriddenFeaturesService).isOff$(key))\n        );\n    }\n\n    /**\n     * Gets the flags as an observable.\n     *\n     * @returns the observable that emits the flag changeset.\n     */\n    getFlags$(): Observable<FlagChangeset> {\n        return this.isInDebugMode$.pipe(\n            switchMap((isInDebugMode) => (isInDebugMode ? this.writableFeaturesService : this.overriddenFeaturesService).getFlags$())\n        );\n    }\n\n    /**\n     * Resets the specified flags.\n     *\n     * @param flags The flags to reset.\n     */\n    resetFlags(flags: FlagSet): void {\n        this.writableFeaturesService.resetFlags(flags);\n    }\n\n    enable(on: boolean): void {\n        this.isInDebugModeSubject.next(on);\n    }\n\n    isEnabled$(): Observable<boolean> {\n        return this.isInDebugMode$;\n    }\n\n    private init() {\n        const storedOverride = JSON.parse(sessionStorage.getItem(this.storageKey) || 'false');\n        this.isInDebugModeSubject.next(storedOverride);\n        this.initSubject.next(true);\n    }\n\n    private waitForInitializationToFinish(): Observable<boolean> {\n        return this.initSubject.pipe(filter((initialized) => !!initialized));\n    }\n}\n"]}

package/esm2022/feature-flags/lib/services/dummy-features.service.mjs

@@ -0,0 +1,40 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DummyFeaturesService {
+    init() {
+        return of();
+    }
+    isOn$() {
+        return of(false);
+    }
+    isOff$(_key) {
+        return of(true);
+    }
+    getFlags$() {
+        return of({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DummyFeaturesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DummyFeaturesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DummyFeaturesService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/feature-flags/lib/services/flagset.parser.mjs

@@ -0,0 +1,38 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class FlagSetParser {
+    static serialize(flags) {
+        return Object.keys(flags).reduce((acc, key) => ({
+            ...acc,
+            [key]: {
+                current: flags[key].current,
+                fictive: flags[key].fictive
+            }
+        }), {});
+    }
+    static deserialize(serializedFlags) {
+        return Object.keys(serializedFlags).reduce((acc, key) => ({
+            ...acc,
+            [key]: {
+                current: serializedFlags[key].current,
+                previous: null,
+                ...(serializedFlags[key].fictive ? { fictive: true } : {})
+            }
+        }), {});
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/feature-flags/lib/services/qa-features.helper.mjs

@@ -0,0 +1,62 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { ApplicationRef, Inject, Injectable } from '@angular/core';
+import { FeaturesServiceToken } from '../interfaces/features.interface';
+import { DebugFeaturesService } from './debug-features.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./debug-features.service";
+export class QaFeaturesHelper {
+    constructor(applicationRef, debugFeaturesService) {
+        this.applicationRef = applicationRef;
+        this.debugFeaturesService = debugFeaturesService;
+    }
+    isOn(key) {
+        let isOn = false;
+        this.debugFeaturesService.isOn$(key).subscribe((on) => {
+            isOn = on;
+        });
+        return isOn;
+    }
+    resetFlags(flags) {
+        this.debugFeaturesService.resetFlags(flags);
+        this.applicationRef.tick();
+    }
+    enable() {
+        this.debugFeaturesService.enable(true);
+        this.applicationRef.tick();
+    }
+    disable() {
+        this.debugFeaturesService.enable(false);
+        this.applicationRef.tick();
+    }
+    isEnabled() {
+        let enabled = false;
+        this.debugFeaturesService.isEnabled$().subscribe((isEnabled) => {
+            enabled = isEnabled;
+        });
+        return enabled;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: QaFeaturesHelper, deps: [{ token: i0.ApplicationRef }, { token: FeaturesServiceToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: QaFeaturesHelper }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: QaFeaturesHelper, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.ApplicationRef }, { type: i1.DebugFeaturesService, decorators: [{
+                    type: Inject,
+                    args: [FeaturesServiceToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/feature-flags/lib/services/storage-features.service.mjs

@@ -0,0 +1,126 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, combineLatest, of } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { WritableFeaturesServiceConfigToken } from '../interfaces/features.interface';
+import { FlagSetParser } from './flagset.parser';
+import * as i0 from "@angular/core";
+export class StorageFeaturesService {
+    constructor(config) {
+        this.config = config;
+        this.currentFlagState = {};
+        this.flags = new BehaviorSubject({});
+        this.flags$ = this.flags.asObservable();
+        this.initSubject = new BehaviorSubject(false);
+        combineLatest({
+            flags: this.flags,
+            init: this.waitForInitializationToFinish()
+        }).subscribe(({ flags }) => {
+            this.currentFlagState = flags;
+            sessionStorage.setItem(this.storageKey, JSON.stringify(FlagSetParser.serialize(flags)));
+        });
+    }
+    get storageKey() {
+        return this.config?.storageKey || 'feature-flags';
+    }
+    init() {
+        const storedFlags = JSON.parse(sessionStorage.getItem(this.storageKey) || '{}');
+        const initialFlagChangeSet = FlagSetParser.deserialize(storedFlags);
+        this.flags.next(initialFlagChangeSet);
+        this.initSubject.next(true);
+        return of(initialFlagChangeSet);
+    }
+    isOn$(key) {
+        return this.flags$.pipe(map((flags) => !!flags[key]?.current));
+    }
+    isOff$(key) {
+        return this.flags$.pipe(map((flags) => !flags[key]?.current));
+    }
+    getFlags$() {
+        return this.flags$;
+    }
+    setFlag(key, value) {
+        let fictive = {};
+        if (!this.currentFlagState[key]) {
+            fictive = { fictive: true };
+        }
+        else {
+            fictive = this.currentFlagState[key]?.fictive ? { fictive: true } : {};
+        }
+        this.flags.next({
+            ...this.currentFlagState,
+            [key]: {
+                current: value,
+                previous: this.currentFlagState[key]?.current ?? null,
+                ...fictive
+            }
+        });
+    }
+    removeFlag(key) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { [key]: _, ...flags } = this.currentFlagState;
+        this.flags.next(flags);
+    }
+    resetFlags(flags) {
+        this.flags.next(Object.keys(flags).reduce((acc, key) => ({
+            ...acc,
+            [key]: {
+                current: flags[key],
+                previous: null,
+                fictive: true
+            }
+        }), {}));
+    }
+    mergeFlags(flags) {
+        const mergedFlags = Object.keys(flags).reduce((acc, key) => {
+            const current = this.currentFlagState[key]?.current;
+            return {
+                ...acc,
+                [key]: {
+                    current: current ?? flags[key].current,
+                    previous: current ?? null
+                }
+            };
+        }, {});
+        Object.keys(this.currentFlagState)
+            .filter((key) => !flags[key])
+            .forEach((key) => {
+            mergedFlags[key] = {
+                current: this.currentFlagState[key].current,
+                previous: this.currentFlagState[key].previous,
+                fictive: true
+            };
+        });
+        this.flags.next(mergedFlags);
+    }
+    waitForInitializationToFinish() {
+        return this.initSubject.pipe(filter((initialized) => !!initialized));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFeaturesService, deps: [{ token: WritableFeaturesServiceConfigToken, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFeaturesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFeaturesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WritableFeaturesServiceConfigToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-features.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/feature-flags/src/lib/services/storage-features.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (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 *     http://www.apache.org/licenses/LICENSE-2.0\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 { Inject, Injectable, Optional } from '@angular/core';\nimport { BehaviorSubject, combineLatest, Observable, of } from 'rxjs';\nimport { filter, map } from 'rxjs/operators';\nimport {\n    FlagChangeset,\n    IFeaturesService,\n    FlagSet,\n    IWritableFeaturesService,\n    WritableFeaturesServiceConfigToken,\n    WritableFlagChangeset,\n    WritableFeaturesServiceConfig\n} from '../interfaces/features.interface';\nimport { FlagSetParser } from './flagset.parser';\n\n@Injectable({ providedIn: 'root' })\nexport class StorageFeaturesService implements IFeaturesService, IWritableFeaturesService {\n    private currentFlagState: WritableFlagChangeset = {};\n    private readonly flags = new BehaviorSubject<WritableFlagChangeset>({});\n    private readonly flags$ = this.flags.asObservable();\n    private readonly initSubject = new BehaviorSubject<boolean>(false);\n\n    constructor(@Optional() @Inject(WritableFeaturesServiceConfigToken) private config?: WritableFeaturesServiceConfig) {\n        combineLatest({\n            flags: this.flags,\n            init: this.waitForInitializationToFinish()\n        }).subscribe(({ flags }) => {\n            this.currentFlagState = flags;\n            sessionStorage.setItem(this.storageKey, JSON.stringify(FlagSetParser.serialize(flags)));\n        });\n    }\n\n    get storageKey(): string {\n        return this.config?.storageKey || 'feature-flags';\n    }\n\n    init(): Observable<WritableFlagChangeset> {\n        const storedFlags = JSON.parse(sessionStorage.getItem(this.storageKey) || '{}');\n        const initialFlagChangeSet = FlagSetParser.deserialize(storedFlags);\n        this.flags.next(initialFlagChangeSet);\n        this.initSubject.next(true);\n        return of(initialFlagChangeSet);\n    }\n\n    isOn$(key: string): Observable<boolean> {\n        return this.flags$.pipe(map((flags) => !!flags[key]?.current));\n    }\n\n    isOff$(key: string): Observable<boolean> {\n        return this.flags$.pipe(map((flags) => !flags[key]?.current));\n    }\n\n    getFlags$(): Observable<WritableFlagChangeset> {\n        return this.flags$;\n    }\n\n    setFlag(key: string, value: any): void {\n        let fictive = {};\n        if (!this.currentFlagState[key]) {\n            fictive = { fictive: true };\n        } else {\n            fictive = this.currentFlagState[key]?.fictive ? { fictive: true } : {};\n        }\n\n        this.flags.next({\n            ...this.currentFlagState,\n            [key]: {\n                current: value,\n                previous: this.currentFlagState[key]?.current ?? null,\n                ...fictive\n            }\n        });\n    }\n\n    removeFlag(key: string): void {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const { [key]: _, ...flags } = this.currentFlagState;\n        this.flags.next(flags);\n    }\n\n    resetFlags(flags: FlagSet): void {\n        this.flags.next(\n            Object.keys(flags).reduce(\n                (acc, key) => ({\n                    ...acc,\n                    [key]: {\n                        current: flags[key],\n                        previous: null,\n                        fictive: true\n                    }\n                }),\n                {}\n            )\n        );\n    }\n\n    mergeFlags(flags: FlagChangeset): void {\n        const mergedFlags: WritableFlagChangeset = Object.keys(flags).reduce((acc, key) => {\n            const current = this.currentFlagState[key]?.current;\n            return {\n                ...acc,\n                [key]: {\n                    current: current ?? flags[key].current,\n                    previous: current ?? null\n                }\n            };\n        }, {});\n\n        Object.keys(this.currentFlagState)\n            .filter((key) => !flags[key])\n            .forEach((key) => {\n                mergedFlags[key] = {\n                    current: this.currentFlagState[key].current,\n                    previous: this.currentFlagState[key].previous,\n                    fictive: true\n                };\n            });\n\n        this.flags.next(mergedFlags);\n    }\n\n    private waitForInitializationToFinish(): Observable<boolean> {\n        return this.initSubject.pipe(filter((initialized) => !!initialized));\n    }\n}\n"]}

package/esm2022/lib/about/about-extension-list/about-extension-list.component.mjs

@@ -0,0 +1,51 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatTableModule } from '@angular/material/table';
+import { TranslatePipe } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/table";
+export class AboutExtensionListComponent {
+    constructor() {
+        this.columns = [
+            {
+                columnDef: 'name',
+                header: 'ABOUT.PLUGINS.NAME',
+                cell: (row) => `${row.$name}`
+            },
+            {
+                columnDef: 'version',
+                header: 'ABOUT.PLUGINS.VERSION',
+                cell: (row) => `${row.$version}`
+            }
+        ];
+        this.displayedColumns = this.columns.map((x) => x.columnDef);
+        this.data = [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AboutExtensionListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: AboutExtensionListComponent, isStandalone: true, selector: "adf-about-extension-list", inputs: { data: "data" }, ngImport: i0, template: "<mat-table [dataSource]=\"data\">\n  <ng-container *ngFor=\"let column of columns\" [matColumnDef]=\"column.columnDef\">\n    <mat-header-cell *matHeaderCellDef>\n      {{ column.header | translate }}\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row\">{{ column.cell(row) }}</mat-cell>\n  </ng-container>\n\n  <mat-header-row *matHeaderRowDef=\"displayedColumns\" />\n  <mat-row *matRowDef=\"let row; columns: displayedColumns\" />\n</mat-table>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "ngmodule", type: MatTableModule }, { kind: "component", type: i2.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i2.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i2.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i2.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i2.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i2.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i2.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i2.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i2.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i2.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AboutExtensionListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-about-extension-list', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [CommonModule, MatTableModule, TranslatePipe], template: "<mat-table [dataSource]=\"data\">\n  <ng-container *ngFor=\"let column of columns\" [matColumnDef]=\"column.columnDef\">\n    <mat-header-cell *matHeaderCellDef>\n      {{ column.header | translate }}\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row\">{{ column.cell(row) }}</mat-cell>\n  </ng-container>\n\n  <mat-header-row *matHeaderRowDef=\"displayedColumns\" />\n  <mat-row *matRowDef=\"let row; columns: displayedColumns\" />\n</mat-table>\n" }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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