@alfresco/adf-core 8.1.0-16295066092 → 8.1.0-16320806191

package/esm2022/lib/about/about.module.mjs

@@ -0,0 +1,75 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { AboutServerSettingsComponent } from './about-server-settings/about-server-settings.component';
+import { AboutExtensionListComponent } from './about-extension-list/about-extension-list.component';
+import { AboutLicenseListComponent } from './about-license-list/about-license-list.component';
+import { PackageListComponent } from './about-package/package-list.component';
+import { AboutStatusListComponent } from './about-status-list/about-status-list.component';
+import { ModuleListComponent } from './about-module-list/module-list.component';
+import { AboutComponent } from './about.component';
+import { AboutPanelDirective } from './about-panel.directive';
+import { AboutRepositoryInfoComponent } from './about-repository-info/about-repository-info.component';
+import * as i0 from "@angular/core";
+export const ABOUT_DIRECTIVES = [
+    AboutExtensionListComponent,
+    AboutLicenseListComponent,
+    ModuleListComponent,
+    AboutRepositoryInfoComponent,
+    PackageListComponent,
+    AboutStatusListComponent,
+    AboutServerSettingsComponent,
+    AboutPanelDirective,
+    AboutComponent
+];
+/** @deprecated import `ABOUT_DIRECTIVES` or standalone components instead */
+export class AboutModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AboutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AboutModule, imports: [AboutExtensionListComponent,
+            AboutLicenseListComponent,
+            ModuleListComponent,
+            AboutRepositoryInfoComponent,
+            PackageListComponent,
+            AboutStatusListComponent,
+            AboutServerSettingsComponent,
+            AboutPanelDirective,
+            AboutComponent], exports: [AboutExtensionListComponent,
+            AboutLicenseListComponent,
+            ModuleListComponent,
+            AboutRepositoryInfoComponent,
+            PackageListComponent,
+            AboutStatusListComponent,
+            AboutServerSettingsComponent,
+            AboutPanelDirective,
+            AboutComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AboutModule, imports: [AboutExtensionListComponent,
+            AboutLicenseListComponent,
+            ModuleListComponent,
+            AboutRepositoryInfoComponent,
+            PackageListComponent,
+            AboutStatusListComponent,
+            AboutServerSettingsComponent,
+            AboutComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AboutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...ABOUT_DIRECTIVES],
+                    exports: [...ABOUT_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJvdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvcmUvc3JjL2xpYi9hYm91dC9hYm91dC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSx5REFBeUQsQ0FBQztBQUN2RyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx1REFBdUQsQ0FBQztBQUNwRyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxtREFBbUQsQ0FBQztBQUM5RixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUM5RSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpREFBaUQsQ0FBQztBQUMzRixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNoRixPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDbkQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDOUQsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0seURBQXlELENBQUM7O0FBRXZHLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBQzVCLDJCQUEyQjtJQUMzQix5QkFBeUI7SUFDekIsbUJBQW1CO0lBQ25CLDRCQUE0QjtJQUM1QixvQkFBb0I7SUFDcEIsd0JBQXdCO0lBQ3hCLDRCQUE0QjtJQUM1QixtQkFBbUI7SUFDbkIsY0FBYztDQUNSLENBQUM7QUFFWCw2RUFBNkU7QUFLN0UsTUFBTSxPQUFPLFdBQVc7K0dBQVgsV0FBVztnSEFBWCxXQUFXLFlBaEJwQiwyQkFBMkI7WUFDM0IseUJBQXlCO1lBQ3pCLG1CQUFtQjtZQUNuQiw0QkFBNEI7WUFDNUIsb0JBQW9CO1lBQ3BCLHdCQUF3QjtZQUN4Qiw0QkFBNEI7WUFDNUIsbUJBQW1CO1lBQ25CLGNBQWMsYUFSZCwyQkFBMkI7WUFDM0IseUJBQXlCO1lBQ3pCLG1CQUFtQjtZQUNuQiw0QkFBNEI7WUFDNUIsb0JBQW9CO1lBQ3BCLHdCQUF3QjtZQUN4Qiw0QkFBNEI7WUFDNUIsbUJBQW1CO1lBQ25CLGNBQWM7Z0hBUUwsV0FBVyxZQWhCcEIsMkJBQTJCO1lBQzNCLHlCQUF5QjtZQUN6QixtQkFBbUI7WUFDbkIsNEJBQTRCO1lBQzVCLG9CQUFvQjtZQUNwQix3QkFBd0I7WUFDeEIsNEJBQTRCO1lBRTVCLGNBQWM7OzRGQVFMLFdBQVc7a0JBSnZCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQztvQkFDOUIsT0FBTyxFQUFFLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQztpQkFDakMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBYm91dFNlcnZlclNldHRpbmdzQ29tcG9uZW50IH0gZnJvbSAnLi9hYm91dC1zZXJ2ZXItc2V0dGluZ3MvYWJvdXQtc2VydmVyLXNldHRpbmdzLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBYm91dEV4dGVuc2lvbkxpc3RDb21wb25lbnQgfSBmcm9tICcuL2Fib3V0LWV4dGVuc2lvbi1saXN0L2Fib3V0LWV4dGVuc2lvbi1saXN0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBYm91dExpY2Vuc2VMaXN0Q29tcG9uZW50IH0gZnJvbSAnLi9hYm91dC1saWNlbnNlLWxpc3QvYWJvdXQtbGljZW5zZS1saXN0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQYWNrYWdlTGlzdENvbXBvbmVudCB9IGZyb20gJy4vYWJvdXQtcGFja2FnZS9wYWNrYWdlLWxpc3QuY29tcG9uZW50JztcbmltcG9ydCB7IEFib3V0U3RhdHVzTGlzdENvbXBvbmVudCB9IGZyb20gJy4vYWJvdXQtc3RhdHVzLWxpc3QvYWJvdXQtc3RhdHVzLWxpc3QuY29tcG9uZW50JztcbmltcG9ydCB7IE1vZHVsZUxpc3RDb21wb25lbnQgfSBmcm9tICcuL2Fib3V0LW1vZHVsZS1saXN0L21vZHVsZS1saXN0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBYm91dENvbXBvbmVudCB9IGZyb20gJy4vYWJvdXQuY29tcG9uZW50JztcbmltcG9ydCB7IEFib3V0UGFuZWxEaXJlY3RpdmUgfSBmcm9tICcuL2Fib3V0LXBhbmVsLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBBYm91dFJlcG9zaXRvcnlJbmZvQ29tcG9uZW50IH0gZnJvbSAnLi9hYm91dC1yZXBvc2l0b3J5LWluZm8vYWJvdXQtcmVwb3NpdG9yeS1pbmZvLmNvbXBvbmVudCc7XG5cbmV4cG9ydCBjb25zdCBBQk9VVF9ESVJFQ1RJVkVTID0gW1xuICAgIEFib3V0RXh0ZW5zaW9uTGlzdENvbXBvbmVudCxcbiAgICBBYm91dExpY2Vuc2VMaXN0Q29tcG9uZW50LFxuICAgIE1vZHVsZUxpc3RDb21wb25lbnQsXG4gICAgQWJvdXRSZXBvc2l0b3J5SW5mb0NvbXBvbmVudCxcbiAgICBQYWNrYWdlTGlzdENvbXBvbmVudCxcbiAgICBBYm91dFN0YXR1c0xpc3RDb21wb25lbnQsXG4gICAgQWJvdXRTZXJ2ZXJTZXR0aW5nc0NvbXBvbmVudCxcbiAgICBBYm91dFBhbmVsRGlyZWN0aXZlLFxuICAgIEFib3V0Q29tcG9uZW50XG5dIGFzIGNvbnN0O1xuXG4vKiogQGRlcHJlY2F0ZWQgaW1wb3J0IGBBQk9VVF9ESVJFQ1RJVkVTYCBvciBzdGFuZGFsb25lIGNvbXBvbmVudHMgaW5zdGVhZCAqL1xuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbLi4uQUJPVVRfRElSRUNUSVZFU10sXG4gICAgZXhwb3J0czogWy4uLkFCT1VUX0RJUkVDVElWRVNdXG59KVxuZXhwb3J0IGNsYXNzIEFib3V0TW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/about/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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 * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2Fib3V0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/lib/about/interfaces.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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 {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvYWJvdXQvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgUGFja2FnZUluZm8ge1xuICAgIG5hbWU6IHN0cmluZztcbiAgICB2ZXJzaW9uOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3RhdHVzRGF0YSB7XG4gICAgcHJvcGVydHk6IHN0cmluZztcbiAgICB2YWx1ZTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIExpY2Vuc2VEYXRhIHtcbiAgICBwcm9wZXJ0eTogc3RyaW5nO1xuICAgIHZhbHVlOiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/about/public-api.mjs

@@ -0,0 +1,28 @@
+/*!
+ * @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 * from './about-extension-list/about-extension-list.component';
+export * from './about-license-list/about-license-list.component';
+export * from './about-module-list/module-list.component';
+export * from './about-package/package-list.component';
+export * from './about-server-settings/about-server-settings.component';
+export * from './about-status-list/about-status-list.component';
+export * from './about.component';
+export * from './about-panel.directive';
+export * from './about-repository-info/about-repository-info.component';
+export * from './about-repository-info/repository-info.interface';
+export * from './about.module';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app-config/app-config-storage-prefix.factory.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 { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { AppConfigService, AppConfigValues } from './app-config.service';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./app-config.service";
+export const STORAGE_PREFIX_FACTORY_SERVICE = new InjectionToken('STORAGE_PREFIX_FACTORY_SERVICE');
+export class StoragePrefixFactory {
+    constructor(appConfigService, storagePrefixFactory) {
+        this.appConfigService = appConfigService;
+        this.storagePrefixFactory = storagePrefixFactory;
+    }
+    getPrefix() {
+        return this.appConfigService.select(AppConfigValues.STORAGE_PREFIX).pipe(switchMap((prefix) => {
+            if (prefix) {
+                return of(prefix);
+            }
+            return this.storagePrefixFactory ? this.storagePrefixFactory.getPrefix() : of(prefix);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StoragePrefixFactory, deps: [{ token: i1.AppConfigService }, { token: STORAGE_PREFIX_FACTORY_SERVICE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StoragePrefixFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StoragePrefixFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [STORAGE_PREFIX_FACTORY_SERVICE]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app-config/app-config.loader.mjs

@@ -0,0 +1,41 @@
+/*!
+ * @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 { AppConfigValues } from './app-config.service';
+/**
+ * Create a factory to load app configuration
+ *
+ * @param appConfigService app config service
+ * @param storageService storage service
+ * @param adfHttpClient http client
+ * @param storagePrefixFactory prefix factory
+ * @returns factory function
+ */
+export function loadAppConfig(appConfigService, storageService, adfHttpClient, storagePrefixFactory) {
+    const init = () => {
+        adfHttpClient.disableCsrf = appConfigService.get(AppConfigValues.DISABLECSRF, true);
+        const withCredentials = appConfigService.get(AppConfigValues.AUTH_WITH_CREDENTIALS);
+        if (withCredentials !== undefined && withCredentials !== null) {
+            adfHttpClient.setDefaultSecurityOption({ withCredentials });
+        }
+        storageService.prefix = appConfigService.get(AppConfigValues.STORAGE_PREFIX, '');
+        storagePrefixFactory.getPrefix().subscribe((property) => {
+            storageService.prefix = property;
+        });
+    };
+    return () => appConfigService.load(init);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app-config/app-config.module.mjs

@@ -0,0 +1,33 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { AppConfigPipe } from './app-config.pipe';
+import * as i0 from "@angular/core";
+/** @deprecated This module is deprecated, consider importing AppConfigPipe directly */
+export class AppConfigModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AppConfigModule, imports: [AppConfigPipe], exports: [AppConfigPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AppConfigPipe],
+                    exports: [AppConfigPipe]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWNvbmZpZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2FwcC1jb25maWcvYXBwLWNvbmZpZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBTWxELHVGQUF1RjtBQUN2RixNQUFNLE9BQU8sZUFBZTsrR0FBZixlQUFlO2dIQUFmLGVBQWUsWUFKZCxhQUFhLGFBQ2IsYUFBYTtnSEFHZCxlQUFlOzs0RkFBZixlQUFlO2tCQUwzQixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLGFBQWEsQ0FBQztvQkFDeEIsT0FBTyxFQUFFLENBQUMsYUFBYSxDQUFDO2lCQUMzQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFwcENvbmZpZ1BpcGUgfSBmcm9tICcuL2FwcC1jb25maWcucGlwZSc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW0FwcENvbmZpZ1BpcGVdLFxuICAgIGV4cG9ydHM6IFtBcHBDb25maWdQaXBlXVxufSlcbi8qKiBAZGVwcmVjYXRlZCBUaGlzIG1vZHVsZSBpcyBkZXByZWNhdGVkLCBjb25zaWRlciBpbXBvcnRpbmcgQXBwQ29uZmlnUGlwZSBkaXJlY3RseSAqL1xuZXhwb3J0IGNsYXNzIEFwcENvbmZpZ01vZHVsZSB7fVxuIl19

package/esm2022/lib/app-config/app-config.pipe.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.
+ */
+import { Pipe } from '@angular/core';
+import { AppConfigService } from './app-config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./app-config.service";
+export class AppConfigPipe {
+    constructor(config) {
+        this.config = config;
+    }
+    transform(value, fallback) {
+        return this.config.get(value, fallback);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigPipe, deps: [{ token: i1.AppConfigService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AppConfigPipe, isStandalone: true, name: "adfAppConfig" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'adfAppConfig',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app-config/app-config.service.mjs

@@ -0,0 +1,243 @@
+/*!
+ * @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 { HttpClient } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { ObjectUtils } from '../common/utils/object-utils';
+import { ReplaySubject } from 'rxjs';
+import { map, distinctUntilChanged, take } from 'rxjs/operators';
+import { ExtensionService, mergeObjects } from '@alfresco/adf-extensions';
+import * as i0 from "@angular/core";
+/* spellchecker: disable */
+// eslint-disable-next-line no-shadow
+export var AppConfigValues;
+(function (AppConfigValues) {
+    AppConfigValues["APP_CONFIG_LANGUAGES_KEY"] = "languages";
+    AppConfigValues["PROVIDERS"] = "providers";
+    AppConfigValues["OAUTHCONFIG"] = "oauth2";
+    AppConfigValues["ECMHOST"] = "ecmHost";
+    AppConfigValues["BASESHAREURL"] = "baseShareUrl";
+    AppConfigValues["BPMHOST"] = "bpmHost";
+    AppConfigValues["IDENTITY_HOST"] = "identityHost";
+    AppConfigValues["AUTHTYPE"] = "authType";
+    AppConfigValues["CONTEXTROOTECM"] = "contextRootEcm";
+    AppConfigValues["CONTEXTROOTBPM"] = "contextRootBpm";
+    AppConfigValues["ALFRESCO_REPOSITORY_NAME"] = "alfrescoRepositoryName";
+    AppConfigValues["LOG_LEVEL"] = "logLevel";
+    AppConfigValues["LOGIN_ROUTE"] = "loginRoute";
+    AppConfigValues["DISABLECSRF"] = "disableCSRF";
+    AppConfigValues["AUTH_WITH_CREDENTIALS"] = "auth.withCredentials";
+    AppConfigValues["APPLICATION"] = "application";
+    AppConfigValues["STORAGE_PREFIX"] = "application.storagePrefix";
+    AppConfigValues["NOTIFY_DURATION"] = "notificationDefaultDuration";
+    AppConfigValues["CONTENT_TICKET_STORAGE_LABEL"] = "ticket-ECM";
+    AppConfigValues["PROCESS_TICKET_STORAGE_LABEL"] = "ticket-BPM";
+    AppConfigValues["UNSAVED_CHANGES_MODAL_HIDDEN"] = "unsaved_changes__modal_hidden";
+})(AppConfigValues || (AppConfigValues = {}));
+// eslint-disable-next-line no-shadow
+export var Status;
+(function (Status) {
+    Status["INIT"] = "init";
+    Status["LOADING"] = "loading";
+    Status["LOADED"] = "loaded";
+})(Status || (Status = {}));
+/* spellchecker: enable */
+export class AppConfigService {
+    get isLoaded() {
+        return this.status === Status.LOADED;
+    }
+    constructor() {
+        this.http = inject(HttpClient);
+        this.extensionService = inject(ExtensionService);
+        this.config = {
+            application: {
+                name: 'Alfresco ADF Application'
+            },
+            ecmHost: 'http://{hostname}{:port}/ecm',
+            bpmHost: 'http://{hostname}{:port}/bpm',
+            logLevel: 'silent'
+        };
+        this.status = Status.INIT;
+        this.onLoadSubject = new ReplaySubject();
+        this.onLoad = this.onLoadSubject.asObservable();
+        this.extensionService.setup$.subscribe((config) => {
+            this.onExtensionsLoaded(config);
+        });
+    }
+    /**
+     * Requests notification of a property value when it is loaded.
+     *
+     * @param property The desired property value
+     * @returns Property value, when loaded
+     */
+    select(property) {
+        return this.onLoadSubject.pipe(map((config) => ObjectUtils.getValue(config, property)), distinctUntilChanged());
+    }
+    /**
+     * Gets the value of a named property.
+     *
+     * @param key Name of the property
+     * @param defaultValue Value to return if the key is not found
+     * @returns Value of the property
+     */
+    get(key, defaultValue) {
+        let result = ObjectUtils.getValue(this.config, key);
+        if (typeof result === 'string') {
+            const keywords = new Map();
+            keywords.set('hostname', this.getLocationHostname());
+            keywords.set(':port', this.getLocationPort(':'));
+            keywords.set('port', this.getLocationPort());
+            keywords.set('protocol', this.getLocationProtocol());
+            result = this.formatString(result, keywords);
+        }
+        if (typeof result === 'object') {
+            result = JSON.parse(JSON.stringify(result).replace(/{hostname}/g, this.getLocationHostname()));
+            result = JSON.parse(JSON.stringify(result).replace(/{:port}/g, this.getLocationPort(':')));
+            result = JSON.parse(JSON.stringify(result).replace(/{protocol}/g, this.getLocationProtocol()));
+        }
+        if (result === undefined) {
+            return defaultValue;
+        }
+        return result;
+    }
+    /**
+     * Gets the location.protocol value.
+     *
+     * @returns The location.protocol string
+     */
+    getLocationProtocol() {
+        return location.protocol;
+    }
+    /**
+     * Gets the location.hostname property.
+     *
+     * @returns Value of the property
+     */
+    getLocationHostname() {
+        return location.hostname;
+    }
+    /**
+     * Gets the location.port property.
+     *
+     * @param prefix Text added before port value
+     * @returns Port with prefix
+     */
+    getLocationPort(prefix = '') {
+        return location.port ? prefix + location.port : '';
+    }
+    onLoaded() {
+        this.onLoadSubject.next(this.config);
+    }
+    onDataLoaded() {
+        this.onLoadSubject.next(this.config);
+        this.extensionService.setup$.pipe(take(1)).subscribe((config) => this.onExtensionsLoaded(config));
+    }
+    onExtensionsLoaded(config) {
+        if (config) {
+            const customConfig = config.appConfig;
+            if (customConfig) {
+                this.config = mergeObjects(this.config, customConfig);
+            }
+        }
+    }
+    /**
+     * Loads the config file.
+     *
+     * @param callback an optional callback to execute when configuration is loaded
+     * @returns Notification when loading is complete
+     */
+    load(callback) {
+        return new Promise((resolve) => {
+            const configUrl = `app.config.json?v=${Date.now()}`;
+            if (this.status === Status.INIT) {
+                this.status = Status.LOADING;
+                this.http.get(configUrl).subscribe((data) => {
+                    this.status = Status.LOADED;
+                    this.config = Object.assign({}, this.config, data || {});
+                    callback?.();
+                    resolve(data);
+                    this.onDataLoaded();
+                }, () => {
+                    // eslint-disable-next-line no-console
+                    console.error('app.config.json contains validation errors');
+                    resolve(this.config);
+                });
+            }
+            else if (this.status === Status.LOADED) {
+                resolve(this.config);
+            }
+            else if (this.status === Status.LOADING) {
+                this.onLoad.subscribe(() => {
+                    resolve(this.config);
+                });
+            }
+        });
+    }
+    /**
+     * Call the discovery API to fetch configuration
+     *
+     * @param hostIdp host address
+     * @returns Discovery configuration
+     */
+    loadWellKnown(hostIdp) {
+        return new Promise((resolve, reject) => {
+            this.http.get(`${hostIdp}/.well-known/openid-configuration`).subscribe({
+                next: (res) => {
+                    resolve(res);
+                },
+                error: (err) => {
+                    // eslint-disable-next-line no-console
+                    console.error('hostIdp not correctly configured or unreachable');
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * OAuth2 configuration
+     *
+     * @returns auth config model
+     */
+    get oauth2() {
+        const config = this.get(AppConfigValues.OAUTHCONFIG, {});
+        const implicitFlow = config['implicitFlow'] === true || config['implicitFlow'] === 'true';
+        const silentLogin = config['silentLogin'] === true || config['silentLogin'] === 'true';
+        const codeFlow = config['codeFlow'] === true || config['codeFlow'] === 'true';
+        return {
+            ...config,
+            implicitFlow,
+            silentLogin,
+            codeFlow
+        };
+    }
+    formatString(str, keywords) {
+        let result = str;
+        keywords.forEach((value, key) => {
+            const expr = new RegExp('{' + key + '}', 'gm');
+            result = result.replace(expr, value);
+        });
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-config.service.js","sourceRoot":"","sources":["../../../../../../lib/core/src/lib/app-config/app-config.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 { HttpClient } from '@angular/common/http';\nimport { inject, Injectable } from '@angular/core';\nimport { ObjectUtils } from '../common/utils/object-utils';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map, distinctUntilChanged, take } from 'rxjs/operators';\nimport { ExtensionConfig, ExtensionService, mergeObjects } from '@alfresco/adf-extensions';\nimport { OpenidConfiguration } from '../auth/interfaces/openid-configuration.interface';\nimport { OauthConfigModel } from '../auth/models/oauth-config.model';\n\n/* spellchecker: disable */\n\n// eslint-disable-next-line no-shadow\nexport enum AppConfigValues {\n    APP_CONFIG_LANGUAGES_KEY = 'languages',\n    PROVIDERS = 'providers',\n    OAUTHCONFIG = 'oauth2',\n    ECMHOST = 'ecmHost',\n    BASESHAREURL = 'baseShareUrl',\n    BPMHOST = 'bpmHost',\n    IDENTITY_HOST = 'identityHost',\n    AUTHTYPE = 'authType',\n    CONTEXTROOTECM = 'contextRootEcm',\n    CONTEXTROOTBPM = 'contextRootBpm',\n    ALFRESCO_REPOSITORY_NAME = 'alfrescoRepositoryName',\n    LOG_LEVEL = 'logLevel',\n    LOGIN_ROUTE = 'loginRoute',\n    DISABLECSRF = 'disableCSRF',\n    AUTH_WITH_CREDENTIALS = 'auth.withCredentials',\n    APPLICATION = 'application',\n    STORAGE_PREFIX = 'application.storagePrefix',\n    NOTIFY_DURATION = 'notificationDefaultDuration',\n    CONTENT_TICKET_STORAGE_LABEL = 'ticket-ECM',\n    PROCESS_TICKET_STORAGE_LABEL = 'ticket-BPM',\n    UNSAVED_CHANGES_MODAL_HIDDEN = 'unsaved_changes__modal_hidden'\n}\n\n// eslint-disable-next-line no-shadow\nexport enum Status {\n    INIT = 'init',\n    LOADING = 'loading',\n    LOADED = 'loaded'\n}\n\n/* spellchecker: enable */\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AppConfigService {\n    protected http = inject(HttpClient);\n    protected extensionService = inject(ExtensionService);\n\n    config: any = {\n        application: {\n            name: 'Alfresco ADF Application'\n        },\n        ecmHost: 'http://{hostname}{:port}/ecm',\n        bpmHost: 'http://{hostname}{:port}/bpm',\n        logLevel: 'silent'\n    };\n\n    status: Status = Status.INIT;\n    protected onLoadSubject: ReplaySubject<any>;\n    onLoad: Observable<any>;\n\n    get isLoaded() {\n        return this.status === Status.LOADED;\n    }\n\n    constructor() {\n        this.onLoadSubject = new ReplaySubject();\n        this.onLoad = this.onLoadSubject.asObservable();\n\n        this.extensionService.setup$.subscribe((config) => {\n            this.onExtensionsLoaded(config);\n        });\n    }\n\n    /**\n     * Requests notification of a property value when it is loaded.\n     *\n     * @param property The desired property value\n     * @returns Property value, when loaded\n     */\n    select(property: string): Observable<any> {\n        return this.onLoadSubject.pipe(\n            map((config) => ObjectUtils.getValue(config, property)),\n            distinctUntilChanged()\n        );\n    }\n\n    /**\n     * Gets the value of a named property.\n     *\n     * @param key Name of the property\n     * @param defaultValue Value to return if the key is not found\n     * @returns Value of the property\n     */\n    get<T>(key: string, defaultValue?: T): T {\n        let result: any = ObjectUtils.getValue(this.config, key);\n        if (typeof result === 'string') {\n            const keywords = new Map<string, string>();\n            keywords.set('hostname', this.getLocationHostname());\n            keywords.set(':port', this.getLocationPort(':'));\n            keywords.set('port', this.getLocationPort());\n            keywords.set('protocol', this.getLocationProtocol());\n            result = this.formatString(result, keywords);\n        }\n\n        if (typeof result === 'object') {\n            result = JSON.parse(JSON.stringify(result).replace(/{hostname}/g, this.getLocationHostname()));\n            result = JSON.parse(JSON.stringify(result).replace(/{:port}/g, this.getLocationPort(':')));\n            result = JSON.parse(JSON.stringify(result).replace(/{protocol}/g, this.getLocationProtocol()));\n        }\n\n        if (result === undefined) {\n            return defaultValue;\n        }\n\n        return result;\n    }\n\n    /**\n     * Gets the location.protocol value.\n     *\n     * @returns The location.protocol string\n     */\n    getLocationProtocol(): string {\n        return location.protocol;\n    }\n\n    /**\n     * Gets the location.hostname property.\n     *\n     * @returns Value of the property\n     */\n    getLocationHostname(): string {\n        return location.hostname;\n    }\n\n    /**\n     * Gets the location.port property.\n     *\n     * @param prefix Text added before port value\n     * @returns Port with prefix\n     */\n    getLocationPort(prefix: string = ''): string {\n        return location.port ? prefix + location.port : '';\n    }\n\n    protected onLoaded() {\n        this.onLoadSubject.next(this.config);\n    }\n\n    protected onDataLoaded() {\n        this.onLoadSubject.next(this.config);\n\n        this.extensionService.setup$.pipe(take(1)).subscribe((config) => this.onExtensionsLoaded(config));\n    }\n\n    protected onExtensionsLoaded(config: ExtensionConfig) {\n        if (config) {\n            const customConfig = config.appConfig;\n\n            if (customConfig) {\n                this.config = mergeObjects(this.config, customConfig);\n            }\n        }\n    }\n\n    /**\n     * Loads the config file.\n     *\n     * @param callback an optional callback to execute when configuration is loaded\n     * @returns Notification when loading is complete\n     */\n    load(callback?: (...args: any[]) => any): Promise<any> {\n        return new Promise((resolve) => {\n            const configUrl = `app.config.json?v=${Date.now()}`;\n\n            if (this.status === Status.INIT) {\n                this.status = Status.LOADING;\n                this.http.get(configUrl).subscribe(\n                    (data: any) => {\n                        this.status = Status.LOADED;\n                        this.config = Object.assign({}, this.config, data || {});\n                        callback?.();\n                        resolve(data);\n                        this.onDataLoaded();\n                    },\n                    () => {\n                        // eslint-disable-next-line no-console\n                        console.error('app.config.json contains validation errors');\n                        resolve(this.config);\n                    }\n                );\n            } else if (this.status === Status.LOADED) {\n                resolve(this.config);\n            } else if (this.status === Status.LOADING) {\n                this.onLoad.subscribe(() => {\n                    resolve(this.config);\n                });\n            }\n        });\n    }\n\n    /**\n     * Call the discovery API to fetch configuration\n     *\n     * @param hostIdp host address\n     * @returns Discovery configuration\n     */\n    loadWellKnown(hostIdp: string): Promise<OpenidConfiguration> {\n        return new Promise((resolve, reject) => {\n            this.http.get<OpenidConfiguration>(`${hostIdp}/.well-known/openid-configuration`).subscribe({\n                next: (res: OpenidConfiguration) => {\n                    resolve(res);\n                },\n                error: (err: any) => {\n                    // eslint-disable-next-line no-console\n                    console.error('hostIdp not correctly configured or unreachable');\n                    reject(err);\n                }\n            });\n        });\n    }\n\n    /**\n     * OAuth2 configuration\n     *\n     * @returns auth config model\n     */\n    get oauth2(): OauthConfigModel {\n        const config = this.get(AppConfigValues.OAUTHCONFIG, {});\n        const implicitFlow = config['implicitFlow'] === true || config['implicitFlow'] === 'true';\n        const silentLogin = config['silentLogin'] === true || config['silentLogin'] === 'true';\n        const codeFlow = config['codeFlow'] === true || config['codeFlow'] === 'true';\n\n        return {\n            ...(config as OauthConfigModel),\n            implicitFlow,\n            silentLogin,\n            codeFlow\n        };\n    }\n\n    private formatString(str: string, keywords: Map<string, string>): string {\n        let result = str;\n\n        keywords.forEach((value, key) => {\n            const expr = new RegExp('{' + key + '}', 'gm');\n            result = result.replace(expr, value);\n        });\n\n        return result;\n    }\n}\n"]}