@alfresco/aca-shared 5.1.1 → 5.2.0

package/esm2022/lib/services/app.extension.service.mjs

@@ -0,0 +1,481 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { MatIconRegistry } from '@angular/material/icon';
+import { DomSanitizer } from '@angular/platform-browser';
+import { getRuleContext } from '@alfresco/aca-shared/store';
+import { ContentActionType, ExtensionLoaderService, ExtensionService, mergeArrays, mergeObjects, reduceEmptyMenus, reduceSeparators, sortByOrder } from '@alfresco/adf-extensions';
+import { AppConfigService, AuthenticationService, LogService } from '@alfresco/adf-core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { NodePermissionService } from '../services/node-permission.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@alfresco/adf-extensions";
+import * as i4 from "../services/node-permission.service";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/platform-browser";
+class AppExtensionService {
+    auth;
+    store;
+    loader;
+    extensions;
+    permissions;
+    appConfig;
+    matIconRegistry;
+    sanitizer;
+    logger;
+    _references = new BehaviorSubject([]);
+    bulkActionExecuted$ = new Subject();
+    navbar = [];
+    sidebarTabs = [];
+    contentMetadata;
+    search;
+    viewerRules = {};
+    _headerActions = new BehaviorSubject([]);
+    _toolbarActions = new BehaviorSubject([]);
+    _viewerToolbarActions = new BehaviorSubject([]);
+    _sharedLinkViewerToolbarActions = new BehaviorSubject([]);
+    _contextMenuActions = new BehaviorSubject([]);
+    _openWithActions = new BehaviorSubject([]);
+    _createActions = new BehaviorSubject([]);
+    _sidebarActions = new BehaviorSubject([]);
+    _badges = new BehaviorSubject([]);
+    _filesDocumentListPreset = new BehaviorSubject([]);
+    _customMetadataPanels = new BehaviorSubject([]);
+    _bulkActions = new BehaviorSubject([]);
+    documentListPresets = {
+        libraries: [],
+        favoriteLibraries: [],
+        shared: [],
+        recent: [],
+        favorites: [],
+        trashcan: [],
+        searchLibraries: [],
+        searchResults: []
+    };
+    selection;
+    navigation;
+    profile;
+    repository;
+    withCredentials;
+    references$;
+    filesDocumentListPreset$ = this._filesDocumentListPreset.asObservable();
+    config;
+    constructor(auth, store, loader, extensions, permissions, appConfig, matIconRegistry, sanitizer, logger) {
+        this.auth = auth;
+        this.store = store;
+        this.loader = loader;
+        this.extensions = extensions;
+        this.permissions = permissions;
+        this.appConfig = appConfig;
+        this.matIconRegistry = matIconRegistry;
+        this.sanitizer = sanitizer;
+        this.logger = logger;
+        this.references$ = this._references.asObservable();
+        this.store.select(getRuleContext).subscribe((result) => {
+            this.selection = result.selection;
+            this.navigation = result.navigation;
+            this.profile = result.profile;
+            this.repository = result.repository;
+            if (this.config) {
+                this.setup(this.config);
+            }
+        });
+    }
+    async load() {
+        this.config = await this.extensions.load();
+        this.setup(this.config);
+    }
+    setup(config) {
+        if (!config) {
+            this.logger.error('Extension configuration not found');
+            return;
+        }
+        this._headerActions.next(this.loader.getContentActions(config, 'features.header'));
+        this._sidebarActions.next(this.loader.getContentActions(config, 'features.sidebar.toolbar'));
+        this._toolbarActions.next(this.loader.getContentActions(config, 'features.toolbar'));
+        this._viewerToolbarActions.next(this.loader.getContentActions(config, 'features.viewer.toolbarActions'));
+        this._sharedLinkViewerToolbarActions.next(this.loader.getContentActions(config, 'features.viewer.shared.toolbarActions'));
+        this._contextMenuActions.next(this.loader.getContentActions(config, 'features.contextMenu'));
+        this._openWithActions.next(this.loader.getContentActions(config, 'features.viewer.openWith'));
+        this._createActions.next(this.loader.getElements(config, 'features.create'));
+        this._badges.next(this.loader.getElements(config, 'features.badges'));
+        this._filesDocumentListPreset.next(this.getDocumentListPreset(config, 'files'));
+        this._customMetadataPanels.next(this.loader.getElements(config, 'features.customMetadataPanels'));
+        this._bulkActions.next(this.loader.getElements(config, 'features.bulk-actions'));
+        this.navbar = this.loadNavBar(config);
+        this.sidebarTabs = this.loader.getElements(config, 'features.sidebar.tabs');
+        this.contentMetadata = this.loadContentMetadata(config);
+        this.search = this.loadSearchForms(config);
+        this.search?.forEach((searchSet) => {
+            searchSet.categories = searchSet.categories?.filter((category) => this.filterVisible(category));
+        });
+        this.documentListPresets = {
+            libraries: this.getDocumentListPreset(config, 'libraries'),
+            favoriteLibraries: this.getDocumentListPreset(config, 'favoriteLibraries'),
+            shared: this.getDocumentListPreset(config, 'shared'),
+            recent: this.getDocumentListPreset(config, 'recent'),
+            favorites: this.getDocumentListPreset(config, 'favorites'),
+            trashcan: this.getDocumentListPreset(config, 'trashcan'),
+            searchLibraries: this.getDocumentListPreset(config, 'search-libraries'),
+            searchResults: this.getDocumentListPreset(config, 'search-results')
+        };
+        this.withCredentials = this.appConfig.get('auth.withCredentials', false);
+        if (config.features?.viewer) {
+            this.viewerRules = config.features.viewer['rules'] || {};
+        }
+        this.registerIcons(config);
+        const references = (config.$references || []).filter((entry) => typeof entry === 'object').map((entry) => entry);
+        this._references.next(references);
+    }
+    registerIcons(config) {
+        const icons = this.loader.getElements(config, 'features.icons').filter((entry) => !entry.disabled);
+        for (const icon of icons) {
+            const [ns, id] = icon.id.split(':');
+            const value = icon.value;
+            if (!value) {
+                this.logger.warn(`Missing icon value for "${icon.id}".`);
+            }
+            else if (!ns || !id) {
+                this.logger.warn(`Incorrect icon id format.`);
+            }
+            else {
+                this.matIconRegistry.addSvgIconInNamespace(ns, id, this.sanitizer.bypassSecurityTrustResourceUrl(value));
+            }
+        }
+    }
+    loadNavBar(config) {
+        return this.loader.getElements(config, 'features.navbar');
+    }
+    getDocumentListPreset(config, key) {
+        return this.loader
+            .getElements(config, `features.documentList.${key}`)
+            .filter((group) => this.filterVisible(group))
+            .filter((entry) => !entry.disabled)
+            .map((entry) => {
+            entry.resizable = entry.resizable ?? true;
+            return entry;
+        })
+            .sort(sortByOrder);
+    }
+    getApplicationNavigation(elements) {
+        return elements
+            .filter((group) => this.filterVisible(group))
+            .map((group) => ({
+            ...group,
+            items: (group.items || [])
+                .filter((entry) => !entry.disabled)
+                .filter((item) => this.filterVisible(item))
+                .sort(sortByOrder)
+                .map((item) => {
+                if (item.children && item.children.length > 0) {
+                    item.children = item.children
+                        .filter((entry) => !entry.disabled)
+                        .filter((child) => this.filterVisible(child))
+                        .sort(sortByOrder)
+                        .map((child) => {
+                        if (child.component) {
+                            return {
+                                ...child
+                            };
+                        }
+                        if (!child.click) {
+                            const childRouteRef = this.extensions.getRouteById(child.route);
+                            const childUrl = `/${childRouteRef ? childRouteRef.path : child.route}`;
+                            return {
+                                ...child,
+                                url: childUrl
+                            };
+                        }
+                        return {
+                            ...child,
+                            action: child.click
+                        };
+                    });
+                    return {
+                        ...item
+                    };
+                }
+                if (item.component) {
+                    return { ...item };
+                }
+                if (!item.click) {
+                    const routeRef = this.extensions.getRouteById(item.route);
+                    const url = `/${routeRef ? routeRef.path : item.route}`;
+                    return {
+                        ...item,
+                        url
+                    };
+                }
+                return {
+                    ...item,
+                    action: item.click
+                };
+            })
+                .reduce(reduceEmptyMenus, [])
+        }));
+    }
+    loadContentMetadata(config) {
+        const elements = this.loader.getElements(config, 'features.content-metadata-presets');
+        if (!elements.length) {
+            return null;
+        }
+        let presets = {};
+        presets = this.filterDisabled(mergeObjects(presets, ...elements));
+        const metadata = this.appConfig.config['content-metadata'] || {};
+        metadata.presets = presets;
+        this.appConfig.config['content-metadata'] = metadata;
+        return { presets };
+    }
+    loadSearchForms(config) {
+        const elements = this.loader.getElements(config, 'features.search');
+        if (!elements.length) {
+            return null;
+        }
+        const search = mergeArrays([], elements)
+            .filter((entry) => !entry.disabled)
+            .filter((entry) => this.filterVisible(entry))
+            .sort(sortByOrder);
+        this.appConfig.config['search'] = search;
+        return search;
+    }
+    filterDisabled(object) {
+        if (Array.isArray(object)) {
+            return object.filter((item) => !item.disabled).map((item) => this.filterDisabled(item));
+        }
+        else if (typeof object === 'object') {
+            if (!object.disabled) {
+                Object.keys(object).forEach((prop) => {
+                    object[prop] = this.filterDisabled(object[prop]);
+                });
+                return object;
+            }
+        }
+        else {
+            return object;
+        }
+    }
+    getSidebarTabs() {
+        return this.sidebarTabs.filter((action) => this.filterVisible(action));
+    }
+    setActionDisabledFromRule(action) {
+        let disabled = false;
+        if (action?.rules?.enabled) {
+            disabled = !this.extensions.evaluateRule(action.rules.enabled, this);
+        }
+        return {
+            ...action,
+            disabled
+        };
+    }
+    updateSidebarActions() {
+        this._sidebarActions.next(this.loader.getContentActions(this.config, 'features.sidebar.toolbar'));
+    }
+    getCreateActions() {
+        return this._createActions.pipe(map((createActions) => createActions
+            .filter((action) => this.filterVisible(action))
+            .map((action) => this.copyAction(action))
+            .map((action) => this.buildMenu(action))
+            .map((action) => this.setActionDisabledFromRule(action))));
+    }
+    getBadges(node) {
+        return this._badges.pipe(map((badges) => badges.filter((badge) => this.evaluateRule(badge.rules.visible, node))));
+    }
+    getCustomMetadataPanels(node) {
+        return this._customMetadataPanels.pipe(map((panels) => panels.filter((panel) => this.evaluateRule(panel.rules.visible, node))));
+    }
+    buildMenu(actionRef) {
+        if (actionRef.type === ContentActionType.menu && actionRef.children && actionRef.children.length > 0) {
+            const children = actionRef.children.filter((action) => this.filterVisible(action)).map((action) => this.buildMenu(action));
+            actionRef.children = children
+                .map((action) => this.setActionDisabledFromRule(action))
+                .sort(sortByOrder)
+                .reduce(reduceEmptyMenus, [])
+                .reduce(reduceSeparators, []);
+        }
+        return actionRef;
+    }
+    getAllowedActions(actions) {
+        return (actions || [])
+            .filter((action) => this.filterVisible(action))
+            .map((action) => {
+            if (action.type === ContentActionType.menu) {
+                const copy = this.copyAction(action);
+                if (copy.children && copy.children.length > 0) {
+                    copy.children = copy.children
+                        .filter((entry) => !entry.disabled)
+                        .filter((childAction) => this.filterVisible(childAction))
+                        .sort(sortByOrder)
+                        .reduce(reduceSeparators, []);
+                }
+                return copy;
+            }
+            return action;
+        })
+            .map((action) => this.setActionDisabledFromRule(action))
+            .reduce(reduceEmptyMenus, [])
+            .reduce(reduceSeparators, []);
+    }
+    getAllowedSidebarActions() {
+        return this._sidebarActions.pipe(map((sidebarActions) => this.getAllowedActions(sidebarActions)));
+    }
+    getAllowedToolbarActions() {
+        return this._toolbarActions.pipe(map((toolbarActions) => this.getAllowedActions(toolbarActions)));
+    }
+    getViewerToolbarActions() {
+        return this._viewerToolbarActions.pipe(map((viewerToolbarActions) => this.getAllowedActions(viewerToolbarActions)));
+    }
+    getBulkActions() {
+        return this._bulkActions.pipe(map((bulkActions) => this.getAllowedActions(bulkActions)));
+    }
+    getOpenWithActions() {
+        return this._openWithActions.pipe(map((openWithActions) => this.getAllowedActions(openWithActions)));
+    }
+    getSharedLinkViewerToolbarActions() {
+        return this._sharedLinkViewerToolbarActions.pipe(map((sharedLinkViewerToolbarActions) => (!this.selection.isEmpty ? this.getAllowedActions(sharedLinkViewerToolbarActions) : [])));
+    }
+    getHeaderActions() {
+        return this._headerActions.pipe(map((headerActions) => headerActions
+            .filter((action) => this.filterVisible(action))
+            .map((action) => {
+            if (action.type === ContentActionType.menu) {
+                const copy = this.copyAction(action);
+                if (copy.children && copy.children.length > 0) {
+                    copy.children = copy.children
+                        .filter((childAction) => this.filterVisible(childAction))
+                        .sort(sortByOrder)
+                        .reduce(reduceEmptyMenus, [])
+                        .reduce(reduceSeparators, []);
+                }
+                return copy;
+            }
+            return action;
+        })
+            .map((action) => this.setActionDisabledFromRule(action))
+            .sort(sortByOrder)
+            .reduce(reduceEmptyMenus, [])
+            .reduce(reduceSeparators, [])));
+    }
+    getAllowedContextMenuActions() {
+        return this._contextMenuActions.pipe(map((contextMenuActions) => (!this.selection.isEmpty ? this.getAllowedActions(contextMenuActions) : [])));
+    }
+    copyAction(action) {
+        return {
+            ...action,
+            children: (action.children || []).map((child) => this.copyAction(child))
+        };
+    }
+    filterVisible(action) {
+        if (action?.rules?.visible) {
+            if (Array.isArray(action.rules.visible)) {
+                return action.rules.visible.every((rule) => this.extensions.evaluateRule(rule, this));
+            }
+            return this.extensions.evaluateRule(action.rules.visible, this);
+        }
+        return true;
+    }
+    isViewerExtensionDisabled(extension) {
+        if (extension) {
+            if (extension.disabled) {
+                return true;
+            }
+            if (extension.rules?.disabled) {
+                return this.extensions.evaluateRule(extension.rules.disabled, this);
+            }
+        }
+        return false;
+    }
+    runActionById(id, additionalPayload) {
+        const action = this.extensions.getActionById(id);
+        if (action) {
+            const { type, payload } = action;
+            const context = {
+                selection: this.selection
+            };
+            const expression = this.extensions.runExpression(payload, context);
+            this.store.dispatch({
+                type,
+                payload: expression,
+                configuration: additionalPayload
+            });
+        }
+        else {
+            this.store.dispatch({
+                type: id,
+                configuration: additionalPayload
+            });
+        }
+    }
+    // todo: move to ADF/RuleService
+    isRuleDefined(ruleId) {
+        return !!(ruleId && this.getEvaluator(ruleId));
+    }
+    // todo: move to ADF/RuleService
+    evaluateRule(ruleId, ...args) {
+        const evaluator = this.getEvaluator(ruleId);
+        if (evaluator) {
+            return evaluator(this, ...args);
+        }
+        return false;
+    }
+    getEvaluator(key) {
+        return this.extensions.getEvaluator(key);
+    }
+    canPreviewNode(node) {
+        const rules = this.viewerRules;
+        if (this.isRuleDefined(rules.canPreview)) {
+            const canPreview = this.evaluateRule(rules.canPreview, node);
+            if (!canPreview) {
+                return false;
+            }
+        }
+        return true;
+    }
+    canShowViewerNavigation(node) {
+        const rules = this.viewerRules;
+        if (this.isRuleDefined(rules.showNavigation)) {
+            const showNavigation = this.evaluateRule(rules.showNavigation, node);
+            if (!showNavigation) {
+                return false;
+            }
+        }
+        return true;
+    }
+    bulkActionExecuted() {
+        this.bulkActionExecuted$.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppExtensionService, deps: [{ token: i1.AuthenticationService }, { token: i2.Store }, { token: i3.ExtensionLoaderService }, { token: i3.ExtensionService }, { token: i4.NodePermissionService }, { token: i1.AppConfigService }, { token: i5.MatIconRegistry }, { token: i6.DomSanitizer }, { token: i1.LogService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppExtensionService, providedIn: 'root' });
+}
+export { AppExtensionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppExtensionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthenticationService }, { type: i2.Store }, { type: i3.ExtensionLoaderService }, { type: i3.ExtensionService }, { type: i4.NodePermissionService }, { type: i1.AppConfigService }, { type: i5.MatIconRegistry }, { type: i6.DomSanitizer }, { type: i1.LogService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.extension.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/src/lib/services/app.extension.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Injectable } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { MatIconRegistry } from '@angular/material/icon';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { AppStore, getRuleContext } from '@alfresco/aca-shared/store';\nimport {\n  ContentActionRef,\n  ContentActionType,\n  DocumentListPresetRef,\n  ExtensionConfig,\n  ExtensionLoaderService,\n  ExtensionRef,\n  ExtensionService,\n  IconRef,\n  mergeArrays,\n  mergeObjects,\n  NavBarGroupRef,\n  NavigationState,\n  ProfileState,\n  reduceEmptyMenus,\n  reduceSeparators,\n  RuleContext,\n  RuleEvaluator,\n  SelectionState,\n  SidebarTabRef,\n  sortByOrder\n} from '@alfresco/adf-extensions';\nimport { AppConfigService, AuthenticationService, LogService } from '@alfresco/adf-core';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { NodeEntry, RepositoryInfo } from '@alfresco/js-api';\nimport { ViewerRules } from '../models/viewer.rules';\nimport { Badge } from '../models/types';\nimport { NodePermissionService } from '../services/node-permission.service';\nimport { map } from 'rxjs/operators';\nimport { SearchCategory } from '@alfresco/adf-content-services';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AppExtensionService implements RuleContext {\n  private _references = new BehaviorSubject<ExtensionRef[]>([]);\n  bulkActionExecuted$ = new Subject<void>();\n\n  navbar: Array<NavBarGroupRef> = [];\n  sidebarTabs: Array<SidebarTabRef> = [];\n  contentMetadata: any;\n  search: any;\n  viewerRules: ViewerRules = {};\n\n  private _headerActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _toolbarActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _viewerToolbarActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _sharedLinkViewerToolbarActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _contextMenuActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _openWithActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _createActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _sidebarActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _badges = new BehaviorSubject<Array<Badge>>([]);\n  private _filesDocumentListPreset = new BehaviorSubject<Array<DocumentListPresetRef>>([]);\n  private _customMetadataPanels = new BehaviorSubject<Array<ContentActionRef>>([]);\n  private _bulkActions = new BehaviorSubject<Array<ContentActionRef>>([]);\n\n  documentListPresets: {\n    libraries: Array<DocumentListPresetRef>;\n    favoriteLibraries: Array<DocumentListPresetRef>;\n    shared: Array<DocumentListPresetRef>;\n    recent: Array<DocumentListPresetRef>;\n    favorites: Array<DocumentListPresetRef>;\n    trashcan: Array<DocumentListPresetRef>;\n    searchLibraries: Array<DocumentListPresetRef>;\n    searchResults: Array<DocumentListPresetRef>;\n  } = {\n    libraries: [],\n    favoriteLibraries: [],\n    shared: [],\n    recent: [],\n    favorites: [],\n    trashcan: [],\n    searchLibraries: [],\n    searchResults: []\n  };\n\n  selection: SelectionState;\n  navigation: NavigationState;\n  profile: ProfileState;\n  repository: RepositoryInfo;\n  withCredentials: boolean;\n\n  references$: Observable<ExtensionRef[]>;\n  filesDocumentListPreset$: Observable<DocumentListPresetRef[]> = this._filesDocumentListPreset.asObservable();\n\n  config: ExtensionConfig;\n\n  constructor(\n    public auth: AuthenticationService,\n    protected store: Store<AppStore>,\n    protected loader: ExtensionLoaderService,\n    protected extensions: ExtensionService,\n    public permissions: NodePermissionService,\n    public appConfig: AppConfigService,\n    protected matIconRegistry: MatIconRegistry,\n    protected sanitizer: DomSanitizer,\n    protected logger: LogService\n  ) {\n    this.references$ = this._references.asObservable();\n\n    this.store.select(getRuleContext).subscribe((result) => {\n      this.selection = result.selection;\n      this.navigation = result.navigation;\n      this.profile = result.profile;\n      this.repository = result.repository;\n\n      if (this.config) {\n        this.setup(this.config);\n      }\n    });\n  }\n\n  async load() {\n    this.config = await this.extensions.load();\n    this.setup(this.config);\n  }\n\n  setup(config: ExtensionConfig) {\n    if (!config) {\n      this.logger.error('Extension configuration not found');\n      return;\n    }\n\n    this._headerActions.next(this.loader.getContentActions(config, 'features.header'));\n    this._sidebarActions.next(this.loader.getContentActions(config, 'features.sidebar.toolbar'));\n    this._toolbarActions.next(this.loader.getContentActions(config, 'features.toolbar'));\n    this._viewerToolbarActions.next(this.loader.getContentActions(config, 'features.viewer.toolbarActions'));\n    this._sharedLinkViewerToolbarActions.next(this.loader.getContentActions(config, 'features.viewer.shared.toolbarActions'));\n    this._contextMenuActions.next(this.loader.getContentActions(config, 'features.contextMenu'));\n    this._openWithActions.next(this.loader.getContentActions(config, 'features.viewer.openWith'));\n    this._createActions.next(this.loader.getElements<ContentActionRef>(config, 'features.create'));\n    this._badges.next(this.loader.getElements<Badge>(config, 'features.badges'));\n    this._filesDocumentListPreset.next(this.getDocumentListPreset(config, 'files'));\n    this._customMetadataPanels.next(this.loader.getElements<ContentActionRef>(config, 'features.customMetadataPanels'));\n    this._bulkActions.next(this.loader.getElements<ContentActionRef>(config, 'features.bulk-actions'));\n\n    this.navbar = this.loadNavBar(config);\n    this.sidebarTabs = this.loader.getElements<SidebarTabRef>(config, 'features.sidebar.tabs');\n    this.contentMetadata = this.loadContentMetadata(config);\n    this.search = this.loadSearchForms(config);\n    this.search?.forEach((searchSet) => {\n      searchSet.categories = searchSet.categories?.filter((category) => this.filterVisible(category));\n    });\n\n    this.documentListPresets = {\n      libraries: this.getDocumentListPreset(config, 'libraries'),\n      favoriteLibraries: this.getDocumentListPreset(config, 'favoriteLibraries'),\n      shared: this.getDocumentListPreset(config, 'shared'),\n      recent: this.getDocumentListPreset(config, 'recent'),\n      favorites: this.getDocumentListPreset(config, 'favorites'),\n      trashcan: this.getDocumentListPreset(config, 'trashcan'),\n      searchLibraries: this.getDocumentListPreset(config, 'search-libraries'),\n      searchResults: this.getDocumentListPreset(config, 'search-results')\n    };\n\n    this.withCredentials = this.appConfig.get<boolean>('auth.withCredentials', false);\n\n    if (config.features?.viewer) {\n      this.viewerRules = (config.features.viewer['rules'] as ViewerRules) || {};\n    }\n\n    this.registerIcons(config);\n\n    const references = (config.$references || []).filter((entry) => typeof entry === 'object').map((entry) => entry as ExtensionRef);\n    this._references.next(references);\n  }\n\n  protected registerIcons(config: ExtensionConfig) {\n    const icons: Array<IconRef> = this.loader.getElements<IconRef>(config, 'features.icons').filter((entry) => !entry.disabled);\n\n    for (const icon of icons) {\n      const [ns, id] = icon.id.split(':');\n      const value = icon.value;\n\n      if (!value) {\n        this.logger.warn(`Missing icon value for \"${icon.id}\".`);\n      } else if (!ns || !id) {\n        this.logger.warn(`Incorrect icon id format.`);\n      } else {\n        this.matIconRegistry.addSvgIconInNamespace(ns, id, this.sanitizer.bypassSecurityTrustResourceUrl(value));\n      }\n    }\n  }\n\n  protected loadNavBar(config: ExtensionConfig): Array<NavBarGroupRef> {\n    return this.loader.getElements<NavBarGroupRef>(config, 'features.navbar');\n  }\n\n  protected getDocumentListPreset(config: ExtensionConfig, key: string): DocumentListPresetRef[] {\n    return this.loader\n      .getElements<DocumentListPresetRef>(config, `features.documentList.${key}`)\n      .filter((group) => this.filterVisible(group))\n      .filter((entry) => !entry.disabled)\n      .map((entry) => {\n        entry.resizable = entry.resizable ?? true;\n        return entry;\n      })\n      .sort(sortByOrder);\n  }\n\n  getApplicationNavigation(elements): Array<NavBarGroupRef> {\n    return elements\n      .filter((group) => this.filterVisible(group))\n      .map((group) => ({\n        ...group,\n        items: (group.items || [])\n          .filter((entry) => !entry.disabled)\n          .filter((item) => this.filterVisible(item))\n          .sort(sortByOrder)\n          .map((item) => {\n            if (item.children && item.children.length > 0) {\n              item.children = item.children\n                .filter((entry) => !entry.disabled)\n                .filter((child) => this.filterVisible(child))\n                .sort(sortByOrder)\n                .map((child) => {\n                  if (child.component) {\n                    return {\n                      ...child\n                    };\n                  }\n\n                  if (!child.click) {\n                    const childRouteRef = this.extensions.getRouteById(child.route);\n                    const childUrl = `/${childRouteRef ? childRouteRef.path : child.route}`;\n                    return {\n                      ...child,\n                      url: childUrl\n                    };\n                  }\n\n                  return {\n                    ...child,\n                    action: child.click\n                  };\n                });\n\n              return {\n                ...item\n              };\n            }\n\n            if (item.component) {\n              return { ...item };\n            }\n\n            if (!item.click) {\n              const routeRef = this.extensions.getRouteById(item.route);\n              const url = `/${routeRef ? routeRef.path : item.route}`;\n              return {\n                ...item,\n                url\n              };\n            }\n\n            return {\n              ...item,\n              action: item.click\n            };\n          })\n          .reduce(reduceEmptyMenus, [])\n      }));\n  }\n\n  loadContentMetadata(config: ExtensionConfig): any {\n    const elements = this.loader.getElements<any>(config, 'features.content-metadata-presets');\n    if (!elements.length) {\n      return null;\n    }\n\n    let presets = {};\n    presets = this.filterDisabled(mergeObjects(presets, ...elements));\n\n    const metadata = this.appConfig.config['content-metadata'] || {};\n    metadata.presets = presets;\n\n    this.appConfig.config['content-metadata'] = metadata;\n    return { presets };\n  }\n\n  loadSearchForms(config: ExtensionConfig): any {\n    const elements = this.loader.getElements<any>(config, 'features.search');\n    if (!elements.length) {\n      return null;\n    }\n\n    const search = mergeArrays([], elements)\n      .filter((entry) => !entry.disabled)\n      .filter((entry) => this.filterVisible(entry))\n      .sort(sortByOrder);\n\n    this.appConfig.config['search'] = search;\n    return search;\n  }\n\n  filterDisabled(object: Array<{ disabled: boolean }> | { disabled: boolean }) {\n    if (Array.isArray(object)) {\n      return object.filter((item) => !item.disabled).map((item) => this.filterDisabled(item));\n    } else if (typeof object === 'object') {\n      if (!object.disabled) {\n        Object.keys(object).forEach((prop) => {\n          object[prop] = this.filterDisabled(object[prop]);\n        });\n        return object;\n      }\n    } else {\n      return object;\n    }\n  }\n\n  getSidebarTabs(): Array<SidebarTabRef> {\n    return this.sidebarTabs.filter((action) => this.filterVisible(action));\n  }\n\n  private setActionDisabledFromRule(action: ContentActionRef) {\n    let disabled = false;\n\n    if (action?.rules?.enabled) {\n      disabled = !this.extensions.evaluateRule(action.rules.enabled, this);\n    }\n\n    return {\n      ...action,\n      disabled\n    };\n  }\n\n  updateSidebarActions() {\n    this._sidebarActions.next(this.loader.getContentActions(this.config, 'features.sidebar.toolbar'));\n  }\n\n  getCreateActions(): Observable<Array<ContentActionRef>> {\n    return this._createActions.pipe(\n      map((createActions) =>\n        createActions\n          .filter((action) => this.filterVisible(action))\n          .map((action) => this.copyAction(action))\n          .map((action) => this.buildMenu(action))\n          .map((action) => this.setActionDisabledFromRule(action))\n      )\n    );\n  }\n\n  getBadges(node: NodeEntry): Observable<Array<Badge>> {\n    return this._badges.pipe(map((badges) => badges.filter((badge) => this.evaluateRule(badge.rules.visible, node))));\n  }\n\n  getCustomMetadataPanels(node: NodeEntry): Observable<Array<ContentActionRef>> {\n    return this._customMetadataPanels.pipe(map((panels) => panels.filter((panel) => this.evaluateRule(panel.rules.visible, node))));\n  }\n\n  private buildMenu(actionRef: ContentActionRef): ContentActionRef {\n    if (actionRef.type === ContentActionType.menu && actionRef.children && actionRef.children.length > 0) {\n      const children = actionRef.children.filter((action) => this.filterVisible(action)).map((action) => this.buildMenu(action));\n\n      actionRef.children = children\n        .map((action) => this.setActionDisabledFromRule(action))\n        .sort(sortByOrder)\n        .reduce(reduceEmptyMenus, [])\n        .reduce(reduceSeparators, []);\n    }\n\n    return actionRef;\n  }\n\n  private getAllowedActions(actions: ContentActionRef[]): ContentActionRef[] {\n    return (actions || [])\n      .filter((action) => this.filterVisible(action))\n      .map((action) => {\n        if (action.type === ContentActionType.menu) {\n          const copy = this.copyAction(action);\n          if (copy.children && copy.children.length > 0) {\n            copy.children = copy.children\n              .filter((entry) => !entry.disabled)\n              .filter((childAction) => this.filterVisible(childAction))\n              .sort(sortByOrder)\n              .reduce(reduceSeparators, []);\n          }\n          return copy;\n        }\n        return action;\n      })\n      .map((action) => this.setActionDisabledFromRule(action))\n      .reduce(reduceEmptyMenus, [])\n      .reduce(reduceSeparators, []);\n  }\n\n  getAllowedSidebarActions(): Observable<Array<ContentActionRef>> {\n    return this._sidebarActions.pipe(map((sidebarActions) => this.getAllowedActions(sidebarActions)));\n  }\n\n  getAllowedToolbarActions(): Observable<Array<ContentActionRef>> {\n    return this._toolbarActions.pipe(map((toolbarActions) => this.getAllowedActions(toolbarActions)));\n  }\n\n  getViewerToolbarActions(): Observable<Array<ContentActionRef>> {\n    return this._viewerToolbarActions.pipe(map((viewerToolbarActions) => this.getAllowedActions(viewerToolbarActions)));\n  }\n\n  getBulkActions(): Observable<Array<ContentActionRef>> {\n    return this._bulkActions.pipe(map((bulkActions) => this.getAllowedActions(bulkActions)));\n  }\n\n  getOpenWithActions(): Observable<Array<ContentActionRef>> {\n    return this._openWithActions.pipe(map((openWithActions) => this.getAllowedActions(openWithActions)));\n  }\n\n  getSharedLinkViewerToolbarActions(): Observable<Array<ContentActionRef>> {\n    return this._sharedLinkViewerToolbarActions.pipe(\n      map((sharedLinkViewerToolbarActions) => (!this.selection.isEmpty ? this.getAllowedActions(sharedLinkViewerToolbarActions) : []))\n    );\n  }\n\n  getHeaderActions(): Observable<Array<ContentActionRef>> {\n    return this._headerActions.pipe(\n      map((headerActions) =>\n        headerActions\n          .filter((action) => this.filterVisible(action))\n          .map((action) => {\n            if (action.type === ContentActionType.menu) {\n              const copy = this.copyAction(action);\n              if (copy.children && copy.children.length > 0) {\n                copy.children = copy.children\n                  .filter((childAction) => this.filterVisible(childAction))\n                  .sort(sortByOrder)\n                  .reduce(reduceEmptyMenus, [])\n                  .reduce(reduceSeparators, []);\n              }\n              return copy;\n            }\n\n            return action;\n          })\n          .map((action) => this.setActionDisabledFromRule(action))\n          .sort(sortByOrder)\n          .reduce(reduceEmptyMenus, [])\n          .reduce(reduceSeparators, [])\n      )\n    );\n  }\n\n  getAllowedContextMenuActions(): Observable<Array<ContentActionRef>> {\n    return this._contextMenuActions.pipe(map((contextMenuActions) => (!this.selection.isEmpty ? this.getAllowedActions(contextMenuActions) : [])));\n  }\n\n  copyAction(action: ContentActionRef): ContentActionRef {\n    return {\n      ...action,\n      children: (action.children || []).map((child) => this.copyAction(child))\n    };\n  }\n\n  filterVisible(action: ContentActionRef | SidebarTabRef | DocumentListPresetRef | SearchCategory): boolean {\n    if (action?.rules?.visible) {\n      if (Array.isArray(action.rules.visible)) {\n        return action.rules.visible.every((rule) => this.extensions.evaluateRule(rule, this));\n      }\n      return this.extensions.evaluateRule(action.rules.visible, this);\n    }\n    return true;\n  }\n\n  isViewerExtensionDisabled(extension: any): boolean {\n    if (extension) {\n      if (extension.disabled) {\n        return true;\n      }\n\n      if (extension.rules?.disabled) {\n        return this.extensions.evaluateRule(extension.rules.disabled, this);\n      }\n    }\n\n    return false;\n  }\n\n  runActionById(id: string, additionalPayload?: any) {\n    const action = this.extensions.getActionById(id);\n    if (action) {\n      const { type, payload } = action;\n      const context = {\n        selection: this.selection\n      };\n      const expression = this.extensions.runExpression(payload, context);\n\n      this.store.dispatch({\n        type,\n        payload: expression,\n        configuration: additionalPayload\n      });\n    } else {\n      this.store.dispatch({\n        type: id,\n        configuration: additionalPayload\n      });\n    }\n  }\n\n  // todo: move to ADF/RuleService\n  isRuleDefined(ruleId: string): boolean {\n    return !!(ruleId && this.getEvaluator(ruleId));\n  }\n\n  // todo: move to ADF/RuleService\n  evaluateRule(ruleId: string, ...args: any[]): boolean {\n    const evaluator = this.getEvaluator(ruleId);\n\n    if (evaluator) {\n      return evaluator(this, ...args);\n    }\n\n    return false;\n  }\n\n  getEvaluator(key: string): RuleEvaluator {\n    return this.extensions.getEvaluator(key);\n  }\n\n  canPreviewNode(node: NodeEntry) {\n    const rules = this.viewerRules;\n\n    if (this.isRuleDefined(rules.canPreview)) {\n      const canPreview = this.evaluateRule(rules.canPreview, node);\n\n      if (!canPreview) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  canShowViewerNavigation(node: NodeEntry) {\n    const rules = this.viewerRules;\n\n    if (this.isRuleDefined(rules.showNavigation)) {\n      const showNavigation = this.evaluateRule(rules.showNavigation, node);\n      if (!showNavigation) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  bulkActionExecuted(): void {\n    this.bulkActionExecuted$.next();\n  }\n}\n"]}