nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/core/services/extension/extension-loader.service.js

@@ -0,0 +1,127 @@
+import { Injectable } from '@angular/core';
+import { ContentActionType } from './action.extensions';
+import { filterEnabled, getValue, mergeObjects, sortByOrder } from './extenion-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ExtensionLoaderService {
+    constructor(http) {
+        this.http = http;
+    }
+    load(configPath, pluginsPath, extensions) {
+        return new Promise((resolve) => {
+            this.loadConfig(configPath, 0).then((result) => {
+                if (result) {
+                    let config = result.config;
+                    const override = sessionStorage.getItem('app.extension.config');
+                    if (override) {
+                        config = JSON.parse(override);
+                    }
+                    if (!config.$references || !config.$references.length) {
+                        config.$references = this.filterIgnoredExtensions(extensions || [], config.$ignoreReferenceList);
+                    }
+                    else {
+                        config.$references = this.filterIgnoredExtensions(config.$references, config.$ignoreReferenceList);
+                    }
+                    if (config.$references && config.$references.length > 0) {
+                        const plugins = config.$references.map((name, idx) => this.loadConfig(`${pluginsPath}/${name}`, idx));
+                        Promise.all(plugins).then((results) => {
+                            const configs = results
+                                .filter((entry) => entry)
+                                .sort(sortByOrder)
+                                .map((entry) => entry.config);
+                            if (configs.length > 0) {
+                                config = mergeObjects(config, ...configs);
+                            }
+                            config = Object.assign(Object.assign(Object.assign({}, config), this.getMetadata(result.config)), { $references: configs.map((ext) => this.getMetadata(ext)) });
+                            resolve(config);
+                        });
+                    }
+                    else {
+                        resolve(config);
+                    }
+                }
+            });
+        });
+    }
+    getMetadata(config) {
+        const result = {};
+        Object
+            .keys(config)
+            .filter((key) => key.startsWith('$'))
+            .forEach((key) => {
+            result[key] = config[key];
+        });
+        return result;
+    }
+    loadConfig(url, order) {
+        return new Promise((resolve) => {
+            this.http.get(url).subscribe((config) => {
+                resolve({
+                    order,
+                    config
+                });
+            }, () => {
+                resolve(null);
+            });
+        });
+    }
+    /**
+     * Retrieves configuration elements.
+     * Filters element by **enabled** and **order** attributes.
+     * Example:
+     *  `getElements<ViewerExtensionRef>(config, 'features.viewer.content')`
+     */
+    getElements(config, key, fallback = []) {
+        const values = getValue(config, key) || fallback || [];
+        return values.filter(filterEnabled).sort(sortByOrder);
+    }
+    getContentActions(config, key) {
+        return this.getElements(config, key).map(this.setActionDefaults);
+    }
+    getRules(config) {
+        if (config && config.rules) {
+            return config.rules;
+        }
+        return [];
+    }
+    getRoutes(config) {
+        if (config) {
+            return config.routes || [];
+        }
+        return [];
+    }
+    getActions(config) {
+        if (config) {
+            return config.actions || [];
+        }
+        return [];
+    }
+    getFeatures(config) {
+        if (config) {
+            return config.features || [];
+        }
+        return [];
+    }
+    setActionDefaults(action) {
+        if (action) {
+            action.type = action.type || ContentActionType.default;
+            action.icon = action.icon || 'extension';
+        }
+        return action;
+    }
+    filterIgnoredExtensions(extensions, ignoreReferenceList) {
+        if (!ignoreReferenceList || !ignoreReferenceList.length) {
+            return extensions;
+        }
+        return extensions.map((file) => file.match('(?!.*\/).+')[0]).filter((fileName) => !ignoreReferenceList.includes(fileName));
+    }
+}
+ExtensionLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExtensionLoaderService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+ExtensionLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExtensionLoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExtensionLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extension-loader.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/extension/extension-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { ContentActionType } from './action.extensions';\r\nimport { filterEnabled, getValue, mergeObjects, sortByOrder } from './extenion-utils';\r\n\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class ExtensionLoaderService {\r\n    constructor(private http: HttpClient) {\r\n    }\r\n\r\n    load(configPath: string, pluginsPath: string, extensions?: string[]): Promise<any> {\r\n        return new Promise<any>((resolve) => {\r\n            this.loadConfig(configPath, 0).then((result) => {\r\n                if (result) {\r\n                    let config = result.config;\r\n\r\n                    const override = sessionStorage.getItem('app.extension.config');\r\n                    if (override) {\r\n                        config = JSON.parse(override);\r\n                    }\r\n\r\n                    if (!config.$references || !config.$references.length) {\r\n                        config.$references = this.filterIgnoredExtensions(extensions || [], config.$ignoreReferenceList);\r\n                    } else {\r\n                        config.$references = this.filterIgnoredExtensions(config.$references, config.$ignoreReferenceList);\r\n                    }\r\n\r\n                    if (config.$references && config.$references.length > 0) {\r\n                        const plugins = config.$references.map((name, idx) =>\r\n                            this.loadConfig(`${pluginsPath}/${name}`, idx)\r\n                        );\r\n\r\n                        Promise.all(plugins).then((results) => {\r\n                            const configs = results\r\n                                .filter((entry:any) => entry)\r\n                                .sort(sortByOrder)\r\n                                .map((entry:any) => entry.config);\r\n\r\n                            if (configs.length > 0) {\r\n                                config = mergeObjects(config, ...configs);\r\n                            }\r\n\r\n                            config = {\r\n                                ...config,\r\n                                ...this.getMetadata(result.config),\r\n                                $references: configs.map((ext) => this.getMetadata(ext))\r\n                            };\r\n\r\n                            resolve(config);\r\n                        });\r\n                    } else {\r\n                        resolve(config);\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    protected getMetadata(config: any): any {\r\n        const result: any = {};\r\n\r\n        Object\r\n            .keys(config)\r\n            .filter((key) => key.startsWith('$'))\r\n            .forEach((key) => {\r\n                result[key] = config[key];\r\n            });\r\n\r\n        return result;\r\n    }\r\n\r\n    protected loadConfig(\r\n        url: string,\r\n        order: number\r\n    ): Promise<{ order: number; config: any }> {\r\n        return new Promise((resolve) => {\r\n            this.http.get<any>(url).subscribe(\r\n                (config) => {\r\n                    resolve({\r\n                        order,\r\n                        config\r\n                    });\r\n                },\r\n                () => {\r\n                    resolve(null);\r\n                }\r\n            );\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Retrieves configuration elements.\r\n     * Filters element by **enabled** and **order** attributes.\r\n     * Example:\r\n     *  `getElements<ViewerExtensionRef>(config, 'features.viewer.content')`\r\n     */\r\n    getElements<T extends any>(\r\n        config: any,\r\n        key: string,\r\n        fallback: Array<T> = []\r\n    ): Array<T> {\r\n        const values = getValue(config, key) || fallback || [];\r\n        return values.filter(filterEnabled).sort(sortByOrder);\r\n    }\r\n\r\n    getContentActions(\r\n        config: any,\r\n        key: string\r\n    ): Array<any> {\r\n        return this.getElements(config, key).map(this.setActionDefaults);\r\n    }\r\n\r\n    getRules(config: any): Array<any> {\r\n        if (config && config.rules) {\r\n            return config.rules;\r\n        }\r\n        return [];\r\n    }\r\n\r\n    getRoutes(config: any): Array<any> {\r\n        if (config) {\r\n            return config.routes || [];\r\n        }\r\n        return [];\r\n    }\r\n\r\n    getActions(config: any): Array<any> {\r\n        if (config) {\r\n            return config.actions || [];\r\n        }\r\n        return [];\r\n    }\r\n\r\n    getFeatures(config: any): any {\r\n        if (config) {\r\n            return config.features || [];\r\n        }\r\n        return [];\r\n    }\r\n\r\n    protected setActionDefaults(action: any): any {\r\n        if (action) {\r\n            action.type = action.type || ContentActionType.default;\r\n            action.icon = action.icon || 'extension';\r\n        }\r\n        return action;\r\n    }\r\n\r\n    private filterIgnoredExtensions(extensions: Array<string | any>, ignoreReferenceList: string[]): Array<string | any> {\r\n        if (!ignoreReferenceList || !ignoreReferenceList.length) {\r\n            return extensions;\r\n        }\r\n\r\n        return extensions.map((file: string) => file.match('(?!.*\\/).+')[0]).filter((fileName: string) => !ignoreReferenceList.includes(fileName));\r\n    }\r\n}\r\n"]}

package/esm2015/lib/core/services/extension/extension.service.js

@@ -0,0 +1,151 @@
+import { Injectable, InjectionToken, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./extension-loader.service";
+import * as i2 from "./component-register.service";
+export function extensionJsonsFactory() {
+    return [];
+}
+export const EXTENSION_JSONS = new InjectionToken('extension-jsons', {
+    providedIn: 'root',
+    factory: extensionJsonsFactory
+});
+export function provideExtensionConfig(jsons) {
+    return {
+        provide: EXTENSION_JSONS,
+        useValue: jsons,
+        multi: true
+    };
+}
+export class ExtensionService {
+    constructor(loader, componentRegister, extensionJsons) {
+        this.loader = loader;
+        this.componentRegister = componentRegister;
+        this.extensionJsons = extensionJsons;
+        this.config = null;
+        this.configPath = 'assets/app.extensions.json';
+        this.pluginsPath = 'assets/plugins';
+        this.features = [];
+        this.authGuards = {};
+        this.onSetup$ = new BehaviorSubject(this.config);
+        this.setup$ = this.onSetup$.asObservable();
+    }
+    /**
+     * Gets features by key.
+     * @param key Key string, using dot notation
+     * @returns Features array found by key
+     */
+    getFeature(key) {
+        const properties = Array.isArray(key) ? [key] : key.split('.');
+        return properties.reduce((prev, curr) => prev && prev[curr], this.features) || [];
+    }
+    getElements(key, fallback = []) {
+        return this.loader.getElements(this.config, key, fallback);
+    }
+    /**
+     * Adds one or more new auth guards to the existing set.
+     * @param values The new auth guards to add
+     */
+    setAuthGuards(values) {
+        if (values) {
+            this.authGuards = Object.assign({}, this.authGuards, values);
+        }
+    }
+    /**
+     * Adds one or more new components to the existing set.
+     * @param values The new components to add
+     * @deprecated This method is deprecated for column components and will be removed in a future version.
+     * Use `ColumnRendererRegistryService.register()` instead for registering column components.
+     *
+     * @example
+     * // For columns (deprecated)
+     * this.setComponents({ 'common.components.text': TextComponent, 'number': NumberComponent });
+     *
+     * // For columns (recommended - single)
+     * this.columnRegistry.register({
+     *   name: 'Text Column',
+     *   type: 'common.text',
+     *   category: 'basic',
+     *   component: TextComponent
+     * });
+     *
+     * // For columns (recommended - multiple)
+     * this.columnRegistry.register([
+     *   {
+     *     name: 'Text Column',
+     *     type: 'common.text',
+     *     category: 'basic',
+     *     component: TextComponent
+     *   },
+     *   {
+     *     name: 'Number Column',
+     *     type: 'common.number',
+     *     category: 'basic',
+     *     component: NumberComponent
+     *   }
+     * ]);
+     *
+     * // For viewer components (still supported)
+     * this.setComponents({ 'viewer.components.pdf': PdfViewerComponent });
+     */
+    setComponents(values) {
+        this.componentRegister.setComponents(values);
+    }
+    /**
+     * Retrieves one or more auth guards using an array of ID values.
+     * @param ids Array of ID value to look for
+     * @returns Array of auth guards or empty array if none were found
+     */
+    getAuthGuards(ids) {
+        return (ids || []).map((id) => this.authGuards[id]).filter((guard) => guard);
+    }
+    /**
+     * Retrieves a registered extension component using its ID value.
+     * @param id The ID value to look for
+     * @returns The component or null if not found
+     */
+    getComponentById(id) {
+        return this.componentRegister.getComponentById(id);
+    }
+    /**
+     * Runs a lightweight expression stored in a string.
+     * @param value String containing the expression or literal value
+     * @param context Parameter object for the expression with details of app state
+     * @returns Result of evaluated expression, if found, or the literal value otherwise
+     */
+    runExpression(value, context) {
+        if (typeof value === 'string') {
+            return this.evaluateExpression(value, context);
+        }
+        else {
+            const duplicate = Object.assign({}, value);
+            Object.keys(duplicate).forEach((key) => {
+                duplicate[key] = this.evaluateExpression(duplicate[key], context);
+            });
+            return duplicate;
+        }
+    }
+    evaluateExpression(value, context) {
+        const pattern = new RegExp(/\$\((.*\)?)\)/g);
+        const matches = pattern.exec(value);
+        if (matches && matches.length > 1) {
+            const expression = matches[1];
+            const fn = new Function('context', `return ${expression}`);
+            const result = fn(context);
+            return result;
+        }
+        return value;
+    }
+}
+ExtensionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExtensionService, deps: [{ token: i1.ExtensionLoaderService }, { token: i2.ComponentRegisterService }, { token: EXTENSION_JSONS }], target: i0.ɵɵFactoryTarget.Injectable });
+ExtensionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExtensionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ExtensionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ExtensionLoaderService }, { type: i2.ComponentRegisterService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [EXTENSION_JSONS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extension.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/extension/extension.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Type, InjectionToken, Inject } from '@angular/core';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { ComponentRegisterService } from './component-register.service';\r\nimport { ExtensionLoaderService } from './extension-loader.service';\r\n\r\nexport function extensionJsonsFactory() {\r\n\treturn [];\r\n}\r\n\r\nexport const EXTENSION_JSONS = new InjectionToken<string[][]>('extension-jsons', {\r\n\tprovidedIn: 'root',\r\n\tfactory: extensionJsonsFactory\r\n});\r\n\r\nexport function provideExtensionConfig(jsons: string[]) {\r\n\treturn {\r\n\t\tprovide: EXTENSION_JSONS,\r\n\t\tuseValue: jsons,\r\n\t\tmulti: true\r\n\t};\r\n}\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class ExtensionService {\r\n\tprotected config = null;\r\n\r\n\tconfigPath = 'assets/app.extensions.json';\r\n\tpluginsPath = 'assets/plugins';\r\n\tfeatures: Array<any> = [];\r\n\tauthGuards: { [key: string]: Type<{}> } = {};\r\n\r\n\tprotected onSetup$ = new BehaviorSubject<any>(this.config);\r\n\tsetup$ = this.onSetup$.asObservable();\r\n\r\n\tconstructor(\r\n\t\tprotected loader: ExtensionLoaderService,\r\n\t\tprotected componentRegister: ComponentRegisterService,\r\n\t\t@Inject(EXTENSION_JSONS) protected extensionJsons: string[]\r\n\t) {}\r\n\r\n\t/**\r\n\t * Gets features by key.\r\n\t * @param key Key string, using dot notation\r\n\t * @returns Features array found by key\r\n\t */\r\n\tgetFeature(key: string): any[] {\r\n\t\tconst properties: string[] = Array.isArray(key) ? [key] : key.split('.');\r\n\t\treturn properties.reduce((prev, curr) => prev && prev[curr], this.features) || [];\r\n\t}\r\n\r\n\tgetElements(key: string, fallback: Array<any> = []): Array<any> {\r\n\t\treturn this.loader.getElements(this.config, key, fallback);\r\n\t}\r\n\r\n\t/**\r\n\t * Adds one or more new auth guards to the existing set.\r\n\t * @param values The new auth guards to add\r\n\t */\r\n\tsetAuthGuards(values: { [key: string]: Type<{}> }) {\r\n\t\tif (values) {\r\n\t\t\tthis.authGuards = Object.assign({}, this.authGuards, values);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Adds one or more new components to the existing set.\r\n\t * @param values The new components to add\r\n\t * @deprecated This method is deprecated for column components and will be removed in a future version.\r\n\t * Use `ColumnRendererRegistryService.register()` instead for registering column components.\r\n\t *\r\n\t * @example\r\n\t * // For columns (deprecated)\r\n\t * this.setComponents({ 'common.components.text': TextComponent, 'number': NumberComponent });\r\n\t *\r\n\t * // For columns (recommended - single)\r\n\t * this.columnRegistry.register({\r\n\t *   name: 'Text Column',\r\n\t *   type: 'common.text',\r\n\t *   category: 'basic',\r\n\t *   component: TextComponent\r\n\t * });\r\n\t *\r\n\t * // For columns (recommended - multiple)\r\n\t * this.columnRegistry.register([\r\n\t *   {\r\n\t *     name: 'Text Column',\r\n\t *     type: 'common.text',\r\n\t *     category: 'basic',\r\n\t *     component: TextComponent\r\n\t *   },\r\n\t *   {\r\n\t *     name: 'Number Column',\r\n\t *     type: 'common.number',\r\n\t *     category: 'basic',\r\n\t *     component: NumberComponent\r\n\t *   }\r\n\t * ]);\r\n\t *\r\n\t * // For viewer components (still supported)\r\n\t * this.setComponents({ 'viewer.components.pdf': PdfViewerComponent });\r\n\t */\r\n\tsetComponents(values: { [key: string]: Type<{}> }) {\r\n\t\tthis.componentRegister.setComponents(values);\r\n\t}\r\n\r\n\t/**\r\n\t * Retrieves one or more auth guards using an array of ID values.\r\n\t * @param ids Array of ID value to look for\r\n\t * @returns Array of auth guards or empty array if none were found\r\n\t */\r\n\tgetAuthGuards(ids: string[]): Array<Type<{}>> {\r\n\t\treturn (ids || []).map((id) => this.authGuards[id]).filter((guard) => guard);\r\n\t}\r\n\r\n\t/**\r\n\t * Retrieves a registered extension component using its ID value.\r\n\t * @param id The ID value to look for\r\n\t * @returns The component or null if not found\r\n\t */\r\n\tgetComponentById<T>(id: string) {\r\n\t\treturn this.componentRegister.getComponentById<T>(id);\r\n\t}\r\n\r\n\t/**\r\n\t * Runs a lightweight expression stored in a string.\r\n\t * @param value String containing the expression or literal value\r\n\t * @param context Parameter object for the expression with details of app state\r\n\t * @returns Result of evaluated expression, if found, or the literal value otherwise\r\n\t */\r\n\trunExpression(value: string | {}, context?: any) {\r\n\t\tif (typeof value === 'string') {\r\n\t\t\treturn this.evaluateExpression(value, context);\r\n\t\t} else {\r\n\t\t\tconst duplicate = Object.assign({}, value);\r\n\t\t\tObject.keys(duplicate).forEach((key) => {\r\n\t\t\t\tduplicate[key] = this.evaluateExpression(duplicate[key], context);\r\n\t\t\t});\r\n\t\t\treturn duplicate;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate evaluateExpression(value: string, context?: any): string {\r\n\t\tconst pattern = new RegExp(/\\$\\((.*\\)?)\\)/g);\r\n\t\tconst matches = pattern.exec(value);\r\n\r\n\t\tif (matches && matches.length > 1) {\r\n\t\t\tconst expression = matches[1];\r\n\t\t\tconst fn = new Function('context', `return ${expression}`);\r\n\t\t\tconst result = fn(context);\r\n\r\n\t\t\treturn result;\r\n\t\t}\r\n\t\treturn value;\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/core/services/index.js

@@ -0,0 +1,5 @@
+export * from './ndf-transform.service';
+export * from './nuxeo/nuxeo.service';
+export * from './roles/roles.service';
+export * from './column-renderer';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25kZi10cmFuc2Zvcm0uc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbnV4ZW8vbnV4ZW8uc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcm9sZXMvcm9sZXMuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29sdW1uLXJlbmRlcmVyJztcclxuIl19

package/esm2015/lib/core/services/initialization/initialization.service.js

@@ -0,0 +1,138 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { RoutesRecognized } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "keycloak-angular";
+import * as i2 from "../nuxeo/nuxeo.service";
+import * as i3 from "@angular/router";
+import * as i4 from "ngx-cookie-service";
+import * as i5 from "@angular/common/http";
+import * as i6 from "../localStorag/local-storag.service";
+import * as i7 from "../user/user-preferences.service";
+export class InitializationService {
+    constructor(keycloak, nuxeoService, router, cookieService, httpClient, storage, userPreferences, environment) {
+        this.keycloak = keycloak;
+        this.nuxeoService = nuxeoService;
+        this.router = router;
+        this.cookieService = cookieService;
+        this.httpClient = httpClient;
+        this.storage = storage;
+        this.userPreferences = userPreferences;
+        this.environment = environment;
+    }
+    initializer(loginMethod = 'keyclock') {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (loginMethod === 'keyclock') {
+                    this.initiateKeyClock().then((client) => {
+                        this.userPreferences.setStoragePrefix(client.user.id);
+                        resolve(true);
+                    })
+                        .catch((err) => {
+                        console.error(err);
+                        reject(err);
+                    });
+                }
+                else if (loginMethod === 'nuxeo') {
+                    this.initiateNuxeoLogin(resolve, reject);
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+    }
+    initiateKeyClock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.keycloak.init({
+                config: this.environment.keycloak,
+                loadUserProfileAtStartUp: false,
+                initOptions: {
+                    onLoad: 'login-required',
+                    checkLoginIframe: false
+                },
+                enableBearerInterceptor: true,
+                bearerExcludedUrls: [
+                    '/assets/', '/cts/assets/'
+                ],
+            });
+            const kc = this.keycloak.getKeycloakInstance();
+            return this.nuxeoService.init();
+        });
+    }
+    initiateNuxeoLogin(resolve, reject) {
+        // let cachable = this.storage.getItem('Cachable')
+        let cachable = this.cookieService.get('CMS_CACHABLE');
+        if (cachable && cachable !== 'null') {
+            // there is cachable exist
+            this.initiateClientWithNuxeo(this.decriptFormating(cachable), resolve, reject);
+        }
+        else {
+            // no cachable exist
+            this.routerSubscription = this.router.events.subscribe(val => {
+                if (val instanceof RoutesRecognized) {
+                    console.log(val.state.root.queryParams);
+                    const code = val.state.root.queryParams.code;
+                    if (code && code.length) {
+                        // if there is code exist then get from nuxeo and intite client thenr esolve with true
+                        console.log(`======Auth Code===== ${code}`);
+                        this.getFromNuxeo(code).subscribe((res) => {
+                            console.log(res);
+                            this.cookieService.set('CMS_CACHABLE', this.encriptFormating(res), 1, '/cts');
+                            // this.router.navigate([], {
+                            //   queryParams: {
+                            //     'code': null
+                            //   },
+                            //   queryParamsHandling: 'merge'
+                            // })
+                            this.initiateClientWithNuxeo(res, resolve, reject);
+                        });
+                    }
+                    else {
+                        // no cachable and no code then need to go to login page
+                        this.routerSubscription ? this.routerSubscription.unsubscribe() : null;
+                        this.login();
+                    }
+                }
+            });
+        }
+    }
+    getFromNuxeo(code) {
+        return this.httpClient.post(`${this.environment.nuxeoOptions.baseURL}/oauth2/token?grant_type=authorization_code&code=${code}&client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`, {});
+    }
+    initiateClientWithNuxeo(token, resolve, reject) {
+        this.nuxeoService.initWithNuxeoToken(token).then((client) => {
+            this.userPreferences.setStoragePrefix(client.user.id);
+            this.routerSubscription ? this.routerSubscription.unsubscribe() : null;
+            resolve(true);
+        })
+            .catch((err) => {
+            console.error(err);
+            this.routerSubscription ? this.routerSubscription.unsubscribe() : null;
+            reject(err);
+        });
+    }
+    login() {
+        window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);
+    }
+    encriptFormating(cachable) {
+        let reformatted = btoa(JSON.stringify(cachable));
+        return 'Xnd' + reformatted + 'HsTeT';
+    }
+    decriptFormating(formate) {
+        let newFormate = formate.substring(3, (formate.length - 5));
+        return JSON.parse(atob(newFormate));
+    }
+}
+InitializationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InitializationService, deps: [{ token: i1.KeycloakService }, { token: i2.NuxeoService }, { token: i3.Router }, { token: i4.CookieService }, { token: i5.HttpClient }, { token: i6.LocalStoragService }, { token: i7.UserPreferencesService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+InitializationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InitializationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InitializationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.KeycloakService }, { type: i2.NuxeoService }, { type: i3.Router }, { type: i4.CookieService }, { type: i5.HttpClient }, { type: i6.LocalStoragService }, { type: i7.UserPreferencesService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initialization.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/initialization/initialization.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { KeycloakService } from 'keycloak-angular';\r\nimport { NuxeoService } from '../nuxeo/nuxeo.service';\r\nimport { UserPreferencesService } from '../user/user-preferences.service';\r\nimport { LocalStoragService } from '../localStorag/local-storag.service';\r\nimport { Router, RoutesRecognized } from '@angular/router';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Subscription } from 'rxjs';\r\nimport { CookieService } from 'ngx-cookie-service'\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class InitializationService {\r\nrouterSubscription : Subscription;\r\n  constructor(\r\n    private keycloak: KeycloakService,\r\n    private nuxeoService: NuxeoService,\r\n    private router : Router,\r\n    private cookieService : CookieService,\r\n    private httpClient : HttpClient,\r\n    private storage: LocalStoragService, \r\n    private userPreferences: UserPreferencesService, \r\n    @Inject('environment') private environment\r\n  ) { }\r\n\r\n  initializer(loginMethod = 'keyclock') {\r\n  return new Promise(async (resolve, reject) => {\r\n      try {\r\n        if(loginMethod === 'keyclock'){\r\n          this.initiateKeyClock().then((client) => {\r\n            this.userPreferences.setStoragePrefix(client.user.id);\r\n            resolve(true);\r\n          })\r\n          .catch((err) => {\r\n            console.error(err);\r\n            reject(err);\r\n          });\r\n        }else if(loginMethod === 'nuxeo'){\r\n          this.initiateNuxeoLogin(resolve , reject)\r\n        }\r\n        \r\n      } catch (error) {\r\n        reject(error);\r\n      }\r\n\r\n    });\r\n  }\r\n\r\n  async initiateKeyClock(){\r\n    await this.keycloak.init({\r\n      config: this.environment.keycloak,\r\n      loadUserProfileAtStartUp: false,\r\n      initOptions: {\r\n        onLoad: 'login-required',\r\n        checkLoginIframe: false\r\n      },\r\n      enableBearerInterceptor: true,\r\n      bearerExcludedUrls: [\r\n        '/assets/', '/cts/assets/'\r\n      ],\r\n    });\r\n    const kc = this.keycloak.getKeycloakInstance();\r\n   return this.nuxeoService.init()\r\n    \r\n  }\r\n\r\n  initiateNuxeoLogin(resolve , reject){\r\n    // let cachable = this.storage.getItem('Cachable')\r\n    let cachable = this.cookieService.get('CMS_CACHABLE');\r\n    if(cachable && cachable !== 'null'){\r\n      // there is cachable exist\r\n      this.initiateClientWithNuxeo(this.decriptFormating(cachable), resolve , reject)\r\n\r\n    }else{\r\n      // no cachable exist\r\n    this.routerSubscription =  this.router.events.subscribe(val => {\r\n        if (val instanceof RoutesRecognized) {\r\n          console.log(val.state.root.queryParams);\r\n          const code = val.state.root.queryParams.code;\r\n          if (code && code.length) {\r\n            // if there is code exist then get from nuxeo and intite client thenr esolve with true\r\n            console.log(`======Auth Code===== ${code}`);\r\n             this.getFromNuxeo(code).subscribe((res) => {\r\n              console.log(res);\r\n              this.cookieService.set('CMS_CACHABLE' , this.encriptFormating(res) , 1 , '/cts')\r\n              // this.router.navigate([], {\r\n              //   queryParams: {\r\n              //     'code': null\r\n              //   },\r\n              //   queryParamsHandling: 'merge'\r\n              // })\r\n              this.initiateClientWithNuxeo(res, resolve , reject)\r\n            }); \r\n          }else{\r\n            // no cachable and no code then need to go to login page\r\n            this.routerSubscription ? this.routerSubscription.unsubscribe() : null ;\r\n            this.login()\r\n          }\r\n        }\r\n      })\r\n    }\r\n  }\r\n\r\n  getFromNuxeo(code){\r\n    return this.httpClient.post(\r\n      `${this.environment.nuxeoOptions.baseURL}/oauth2/token?grant_type=authorization_code&code=${code}&client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`,{\r\n      })\r\n  }\r\n\r\n  initiateClientWithNuxeo(token , resolve , reject){\r\n    this.nuxeoService.initWithNuxeoToken(token).then((client : any) => {\r\n      this.userPreferences.setStoragePrefix(client.user.id);\r\n      this.routerSubscription ? this.routerSubscription.unsubscribe() : null ;\r\n      resolve(true);\r\n    })\r\n    .catch((err) => {\r\n      console.error(err);\r\n      this.routerSubscription ? this.routerSubscription.unsubscribe() : null ;\r\n      reject(err);\r\n    });\r\n  }\r\n\r\n  login(){\r\n    window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);\r\n  }\r\n\r\n  encriptFormating(cachable){\r\n  let reformatted =  btoa(JSON.stringify(cachable));\r\n  return 'Xnd' + reformatted + 'HsTeT'\r\n  }\r\n\r\n  decriptFormating(formate : string){\r\n   let newFormate = formate.substring(3,(formate.length-5));\r\n   return JSON.parse(atob(newFormate))\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/lib/core/services/localStorag/local-storag.service.js

@@ -0,0 +1,123 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LocalStoragService {
+    constructor() {
+        this.memoryStore = {};
+        this.useLocalStorage = false;
+        this._prefix = '';
+        this.useLocalStorage = this.storageAvailable('localStorage');
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    set prefix(prefix) {
+        this._prefix = prefix ? prefix + '_' : '';
+    }
+    /**
+     * Gets an item.
+     * @param key Key to identify the item
+     * @returns The item (if any) retrieved by the key
+     */
+    getItem(key) {
+        if (this.useLocalStorage) {
+            return localStorage.getItem(this.prefix + key);
+        }
+        else {
+            return this.memoryStore.hasOwnProperty(this.prefix + key) ? this.memoryStore[this.prefix + key] : null;
+        }
+    }
+    /**
+     * Stores an item
+     * @param key Key to identify the item
+     * @param data Data to store
+     */
+    setItem(key, data) {
+        if (this.useLocalStorage) {
+            localStorage.setItem(this.prefix + key, data);
+        }
+        else {
+            this.memoryStore[this.prefix + key] = data.toString();
+        }
+    }
+    /** Removes all currently stored items. */
+    clear() {
+        if (this.useLocalStorage) {
+            localStorage.clear();
+        }
+        else {
+            this.memoryStore = {};
+        }
+    }
+    /**
+     * Removes a single item.
+     * @param key Key to identify the item
+     */
+    removeItem(key) {
+        if (this.useLocalStorage) {
+            localStorage.removeItem(this.prefix + key);
+        }
+        else {
+            delete this.memoryStore[this.prefix + key];
+        }
+    }
+    /**
+     * Is any item currently stored under `key`?
+     * @param key Key identifying item to check
+     * @returns True if key retrieves an item, false otherwise
+     */
+    hasItem(key) {
+        if (this.useLocalStorage) {
+            return localStorage.getItem(this.prefix + key) ? true : false;
+        }
+        else {
+            return this.memoryStore.hasOwnProperty(key);
+        }
+    }
+    storageAvailable(type) {
+        try {
+            const storage = window[type];
+            const key = '__storage_test__';
+            storage.setItem(key, key);
+            storage.removeItem(key, key);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getLocal(key) {
+        const ijsKey = 'cts' + key;
+        const data = window.localStorage.getItem(ijsKey);
+        if (data) {
+            return JSON.parse(data);
+        }
+        else {
+            return null;
+        }
+    }
+    setLocal(key, value) {
+        const ijsKey = 'cts' + key;
+        const data = value === undefined ? '' : JSON.stringify(value);
+        window.localStorage.setItem(ijsKey, data);
+    }
+    removeLocal(key) {
+        const ijsKey = 'cts' + key;
+        window.localStorage.removeItem(ijsKey);
+    }
+    removeAllLocals() {
+        for (const key in window.localStorage) {
+            if (window.localStorage.hasOwnProperty(key)) {
+                window.localStorage.removeItem(key);
+            }
+        }
+    }
+}
+LocalStoragService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LocalStoragService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LocalStoragService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LocalStoragService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LocalStoragService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-storag.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/localStorag/local-storag.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LocalStoragService {\r\n\r\n  private memoryStore: { [key: string]: any } = {};\r\n  private readonly useLocalStorage: boolean = false;\r\n  private _prefix: string = '';\r\n\r\n  get prefix() {\r\n    return this._prefix;\r\n  }\r\n\r\n  set prefix(prefix: string) {\r\n    this._prefix = prefix ? prefix + '_' : '';\r\n  }\r\n\r\n  constructor() {\r\n    this.useLocalStorage = this.storageAvailable('localStorage');\r\n  }\r\n\r\n\r\n  /**\r\n   * Gets an item.\r\n   * @param key Key to identify the item\r\n   * @returns The item (if any) retrieved by the key\r\n   */\r\n  getItem(key: string): string | null {\r\n    if (this.useLocalStorage) {\r\n      return localStorage.getItem(this.prefix + key);\r\n    } else {\r\n      return this.memoryStore.hasOwnProperty(this.prefix + key) ? this.memoryStore[this.prefix + key] : null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stores an item\r\n   * @param key Key to identify the item\r\n   * @param data Data to store\r\n   */\r\n  setItem(key: string, data: string) {\r\n    if (this.useLocalStorage) {\r\n      localStorage.setItem(this.prefix + key, data);\r\n    } else {\r\n      this.memoryStore[this.prefix + key] = data.toString();\r\n    }\r\n  }\r\n\r\n  /** Removes all currently stored items. */\r\n  clear() {\r\n    if (this.useLocalStorage) {\r\n      localStorage.clear();\r\n    } else {\r\n      this.memoryStore = {};\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Removes a single item.\r\n   * @param key Key to identify the item\r\n   */\r\n  removeItem(key: string) {\r\n    if (this.useLocalStorage) {\r\n      localStorage.removeItem(this.prefix + key);\r\n    } else {\r\n      delete this.memoryStore[this.prefix + key];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Is any item currently stored under `key`?\r\n   * @param key Key identifying item to check\r\n   * @returns True if key retrieves an item, false otherwise\r\n   */\r\n  hasItem(key: string): boolean {\r\n    if (this.useLocalStorage) {\r\n      return localStorage.getItem(this.prefix + key) ? true : false;\r\n    } else {\r\n      return this.memoryStore.hasOwnProperty(key);\r\n    }\r\n  }\r\n\r\n  private storageAvailable(type: string): boolean {\r\n    try {\r\n      const storage = window[type];\r\n      const key = '__storage_test__';\r\n      storage.setItem(key, key);\r\n      storage.removeItem(key, key);\r\n      return true;\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  getLocal(key: string): any {\r\n    const ijsKey = 'cts' + key;\r\n    const data = window.localStorage.getItem(ijsKey);\r\n    if (data) {\r\n      return JSON.parse(data);\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  setLocal(key: string, value: any): void {\r\n    const ijsKey = 'cts' + key;\r\n    const data = value === undefined ? '' : JSON.stringify(value);\r\n    window.localStorage.setItem(ijsKey, data);\r\n  }\r\n\r\n  removeLocal(key: string): void {\r\n    const ijsKey = 'cts' + key;\r\n    window.localStorage.removeItem(ijsKey);\r\n  }\r\n\r\n  removeAllLocals(): void {\r\n    for (const key in window.localStorage) {\r\n      if (window.localStorage.hasOwnProperty(key)) {\r\n        window.localStorage.removeItem(key);\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}