ngx-edu-sharing-ui 0.7.0 → 9.0.1

package/esm2022/lib/services/abstract/keyboard-shortcuts.service.mjs

@@ -0,0 +1,10 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class KeyboardShortcutsService {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: KeyboardShortcutsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: KeyboardShortcutsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: KeyboardShortcutsService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Ym9hcmQtc2hvcnRjdXRzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lZHUtc2hhcmluZy11aS9zcmMvbGliL3NlcnZpY2VzL2Fic3RyYWN0L2tleWJvYXJkLXNob3J0Y3V0cy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBZ0Isd0JBQXdCOzhHQUF4Qix3QkFBd0I7a0hBQXhCLHdCQUF3Qjs7MkZBQXhCLHdCQUF3QjtrQkFEN0MsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEtleWJvYXJkU2hvcnRjdXQgfSBmcm9tICcuLi8uLi90eXBlcy9rZXlib2FyZC1zaG9ydGN1dHMnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgS2V5Ym9hcmRTaG9ydGN1dHNTZXJ2aWNlIHtcbiAgICBhYnN0cmFjdCByZWdpc3RlcihzaG9ydGN1dHM6IEtleWJvYXJkU2hvcnRjdXRbXSwgeyB1bnRpbCB9OiB7IHVudGlsOiBPYnNlcnZhYmxlPHZvaWQ+IH0pOiB2b2lkO1xuXG4gICAgYWJzdHJhY3Qgc2hvdWxkSWdub3JlU2hvcnRjdXQoZXZlbnQ6IEtleWJvYXJkRXZlbnQpOiBib29sZWFuO1xufVxuIl19

package/esm2022/lib/services/abstract/options-helper.service.mjs

@@ -0,0 +1,3 @@
+export class OptionsHelperService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy1oZWxwZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VkdS1zaGFyaW5nLXVpL3NyYy9saWIvc2VydmljZXMvYWJzdHJhY3Qvb3B0aW9ucy1oZWxwZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQWdCLG9CQUFvQjtDQXdCekMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPcHRpb25EYXRhLCBPcHRpb25zSGVscGVyQ29tcG9uZW50cyB9IGZyb20gJy4uL29wdGlvbnMtaGVscGVyLWRhdGEuc2VydmljZSc7XG5pbXBvcnQgeyBPcHRpb25JdGVtLCBUYXJnZXQgfSBmcm9tICcuLi8uLi90eXBlcy9vcHRpb24taXRlbSc7XG5pbXBvcnQgeyBOb2RlIH0gZnJvbSAnbmd4LWVkdS1zaGFyaW5nLWFwaSc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBPcHRpb25zSGVscGVyU2VydmljZSB7XG4gICAgYWJzdHJhY3Qgd3JhcE9wdGlvbkNhbGxiYWNrcyhkYXRhOiBPcHRpb25EYXRhKTogT3B0aW9uRGF0YTtcblxuICAgIGFic3RyYWN0IHJlZnJlc2hDb21wb25lbnRzKFxuICAgICAgICBjb21wb25lbnRzOiBPcHRpb25zSGVscGVyQ29tcG9uZW50cyxcbiAgICAgICAgZGF0YTogT3B0aW9uRGF0YSxcbiAgICAgICAgcmVmcmVzaExpc3RPcHRpb25zOiBib29sZWFuLFxuICAgICk6IHZvaWQ7XG5cbiAgICBhYnN0cmFjdCBnZXRBdmFpbGFibGVPcHRpb25zKFxuICAgICAgICB0YXJnZXQ6IFRhcmdldCxcbiAgICAgICAgb2JqZWN0czogTm9kZVtdLFxuICAgICAgICBjb21wb25lbnRzOiBPcHRpb25zSGVscGVyQ29tcG9uZW50cyxcbiAgICAgICAgZGF0YTogT3B0aW9uRGF0YSxcbiAgICApOiBPcHRpb25JdGVtW107XG5cbiAgICBhYnN0cmFjdCBwYXN0ZU5vZGUoY29tcG9uZW50czogT3B0aW9uc0hlbHBlckNvbXBvbmVudHMsIGRhdGE6IE9wdGlvbkRhdGEsIG5vZGVzOiBOb2RlW10pOiB2b2lkO1xuXG4gICAgYWJzdHJhY3QgZmlsdGVyT3B0aW9ucyhcbiAgICAgICAgb3B0aW9uczogT3B0aW9uSXRlbVtdLFxuICAgICAgICB0YXJnZXQ6IFRhcmdldCxcbiAgICAgICAgZGF0YTogT3B0aW9uRGF0YSxcbiAgICAgICAgb2JqZWN0czogTm9kZVtdIHwgYW55LFxuICAgICk6IE9wdGlvbkl0ZW1bXTtcbn1cbiJdfQ==

package/esm2022/lib/services/abstract/toast.service.mjs

@@ -0,0 +1,3 @@
+export class Toast {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3Quc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VkdS1zaGFyaW5nLXVpL3NyYy9saWIvc2VydmljZXMvYWJzdHJhY3QvdG9hc3Quc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQWdCLEtBQUs7Q0FJMUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgYWJzdHJhY3QgY2xhc3MgVG9hc3Qge1xuICAgIGFic3RyYWN0IHRvYXN0KG1lc3NhZ2U6IHN0cmluZywgdHJhbnNsYXRpb25QYXJhbWV0ZXJzPzogYW55KTogdm9pZDtcblxuICAgIGFic3RyYWN0IGVycm9yKGVycm9yT2JqZWN0OiBhbnksIG1lc3NhZ2U/OiBzdHJpbmcpOiB2b2lkO1xufVxuIl19

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

@@ -0,0 +1,73 @@
+import { Injectable } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { first, map } from 'rxjs/operators';
+import { AccessibilitySettings } from '../types/accessibillity';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-edu-sharing-api";
+export class AccessibilityService {
+    static { this.STORAGE_PREFIX = 'accessibility_'; }
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async set(accessibilitySettings) {
+        const currentValues = await this.observeAll().pipe(first()).toPromise();
+        const values = Object.entries(accessibilitySettings)
+            .filter(([key, value]) => 
+        // check if value has been modified
+        currentValues[key] !== value)
+            .reduce((acc, [key, value]) => {
+            acc[AccessibilityService.STORAGE_PREFIX + key] = value;
+            return acc;
+        }, {});
+        if (Object.keys(values).length > 0) {
+            return this.storage.setValues(values);
+        }
+    }
+    observe(keyOrKeys) {
+        if (typeof keyOrKeys === 'string') {
+            return this.observeSingle(keyOrKeys);
+        }
+        else if (Array.isArray(keyOrKeys)) {
+            return this.observeMultiple(keyOrKeys);
+        }
+        else {
+            return this.observeAll();
+        }
+    }
+    observeSingle(key) {
+        const defaultValues = new AccessibilitySettings();
+        return this.storage.observe(AccessibilityService.STORAGE_PREFIX + key, defaultValues[key]);
+    }
+    observeMultiple(keys) {
+        const defaultValues = new AccessibilitySettings();
+        return combineLatest(keys.reduce((acc, key) => {
+            acc[key] = this.storage.observe(AccessibilityService.STORAGE_PREFIX + key, defaultValues[key]);
+            return acc;
+        }, {}));
+    }
+    observeAll() {
+        return this.observeMultiple(Object.keys(new AccessibilitySettings()));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: AccessibilityService, deps: [{ token: i1.SessionStorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: AccessibilityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: AccessibilityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SessionStorageService }]; } });
+/**
+ * Rxjs.combineLatest on objects instead of arrays.
+ *
+ * This is a standard function in Rxjs 7, but we wrap it here for Rxjs 6.
+ */
+function combineLatest(sources) {
+    return rxjs
+        .combineLatest(Object.entries(sources).map(([key, source]) => source.pipe(map((result) => ({ key, result })))))
+        .pipe(map((results) => results.reduce((acc, { key, result }) => {
+        acc[key] = result;
+        return acc;
+    }, {})));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accessibility.service.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/services/accessibility.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport * as rxjs from 'rxjs';\nimport { Observable } from 'rxjs';\nimport { first, map } from 'rxjs/operators';\nimport { AccessibilitySettings } from '../types/accessibillity';\nimport { SessionStorageService } from 'ngx-edu-sharing-api';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class AccessibilityService {\n    private static readonly STORAGE_PREFIX = 'accessibility_';\n\n    constructor(private storage: SessionStorageService) {}\n\n    async set(accessibilitySettings: Partial<AccessibilitySettings>): Promise<void> {\n        const currentValues = await this.observeAll().pipe(first()).toPromise();\n        const values = Object.entries(accessibilitySettings)\n            .filter(\n                ([key, value]) =>\n                    // check if value has been modified\n                    (currentValues as any)[key] !== value,\n            )\n            .reduce((acc, [key, value]) => {\n                acc[AccessibilityService.STORAGE_PREFIX + key] = value;\n                return acc;\n            }, {} as { [key: string]: any });\n        if (Object.keys(values).length > 0) {\n            return this.storage.setValues(values);\n        }\n    }\n\n    observe<K extends keyof AccessibilitySettings>(key: K): Observable<AccessibilitySettings[K]>;\n    observe<K extends keyof AccessibilitySettings>(\n        keys: K[],\n    ): Observable<Pick<AccessibilitySettings, K>>;\n    observe(): Observable<AccessibilitySettings>;\n    observe<K extends keyof AccessibilitySettings>(\n        keyOrKeys?: K | K[],\n    ): Observable<AccessibilitySettings[K] | Pick<AccessibilitySettings, K>> {\n        if (typeof keyOrKeys === 'string') {\n            return this.observeSingle(keyOrKeys);\n        } else if (Array.isArray(keyOrKeys)) {\n            return this.observeMultiple(keyOrKeys);\n        } else {\n            return this.observeAll();\n        }\n    }\n\n    private observeSingle<K extends keyof AccessibilitySettings>(\n        key: K,\n    ): Observable<AccessibilitySettings[K]> {\n        const defaultValues = new AccessibilitySettings();\n        return this.storage.observe(AccessibilityService.STORAGE_PREFIX + key, defaultValues[key]);\n    }\n\n    private observeMultiple<K extends keyof AccessibilitySettings>(\n        keys: K[],\n    ): Observable<Pick<AccessibilitySettings, K>> {\n        const defaultValues = new AccessibilitySettings();\n        return combineLatest(\n            keys.reduce((acc, key) => {\n                acc[key] = this.storage.observe(\n                    AccessibilityService.STORAGE_PREFIX + key,\n                    defaultValues[key],\n                );\n                return acc;\n            }, {} as { [key in keyof AccessibilitySettings]: Observable<AccessibilitySettings[key]> }),\n        );\n    }\n\n    private observeAll(): Observable<AccessibilitySettings> {\n        return this.observeMultiple(\n            Object.keys(new AccessibilitySettings()) as Array<keyof AccessibilitySettings>,\n        );\n    }\n}\n\n/**\n * Rxjs.combineLatest on objects instead of arrays.\n *\n * This is a standard function in Rxjs 7, but we wrap it here for Rxjs 6.\n */\nfunction combineLatest<T, K extends keyof T>(sources: {\n    [key in K]: Observable<T[key]>;\n}): Observable<T> {\n    return rxjs\n        .combineLatest(\n            Object.entries(sources).map(([key, source]) =>\n                (source as Observable<T[K]>).pipe(map((result) => ({ key, result }))),\n            ),\n        )\n        .pipe(\n            map((results) =>\n                results.reduce((acc, { key, result }) => {\n                    acc[key as K] = result;\n                    return acc;\n                }, {} as T),\n            ),\n        );\n}\n"]}

package/esm2022/lib/services/local-events.service.mjs

@@ -0,0 +1,36 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * An application-wide event broker.
+ */
+export class LocalEventsService {
+    constructor() {
+        /**
+         * The metadata of one or more nodes have been updated.
+         *
+         * The emitted value is the array of updated nodes.
+         *
+         * The emitter should not be triggered with an empty array or null.
+         */
+        this.nodesChanged = new EventEmitter();
+        /**
+         * One or more nodes have been moved to the recycle bin.
+         *
+         * The emitted value is the array of former nodes.
+         *
+         * The emitter should not be triggered with an empty array or null.
+         */
+        // FIXME: Maybe a `nodesMoved` emitter would make for sense for updating lists that used to
+        // include a node and lists that the node was moved to.
+        this.nodesDeleted = new EventEmitter();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: LocalEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: LocalEventsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: LocalEventsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtZXZlbnRzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lZHUtc2hhcmluZy11aS9zcmMvbGliL3NlcnZpY2VzL2xvY2FsLWV2ZW50cy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUd6RDs7R0FFRztBQUlILE1BQU0sT0FBTyxrQkFBa0I7SUFIL0I7UUFJSTs7Ozs7O1dBTUc7UUFDTSxpQkFBWSxHQUFHLElBQUksWUFBWSxFQUFVLENBQUM7UUFDbkQ7Ozs7OztXQU1HO1FBQ0gsMkZBQTJGO1FBQzNGLHVEQUF1RDtRQUM5QyxpQkFBWSxHQUFHLElBQUksWUFBWSxFQUFVLENBQUM7S0FDdEQ7OEdBbkJZLGtCQUFrQjtrSEFBbEIsa0JBQWtCLGNBRmYsTUFBTTs7MkZBRVQsa0JBQWtCO2tCQUg5QixVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV2ZW50RW1pdHRlciwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTm9kZSB9IGZyb20gJ25neC1lZHUtc2hhcmluZy1hcGknO1xuXG4vKipcbiAqIEFuIGFwcGxpY2F0aW9uLXdpZGUgZXZlbnQgYnJva2VyLlxuICovXG5ASW5qZWN0YWJsZSh7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBMb2NhbEV2ZW50c1NlcnZpY2Uge1xuICAgIC8qKlxuICAgICAqIFRoZSBtZXRhZGF0YSBvZiBvbmUgb3IgbW9yZSBub2RlcyBoYXZlIGJlZW4gdXBkYXRlZC5cbiAgICAgKlxuICAgICAqIFRoZSBlbWl0dGVkIHZhbHVlIGlzIHRoZSBhcnJheSBvZiB1cGRhdGVkIG5vZGVzLlxuICAgICAqXG4gICAgICogVGhlIGVtaXR0ZXIgc2hvdWxkIG5vdCBiZSB0cmlnZ2VyZWQgd2l0aCBhbiBlbXB0eSBhcnJheSBvciBudWxsLlxuICAgICAqL1xuICAgIHJlYWRvbmx5IG5vZGVzQ2hhbmdlZCA9IG5ldyBFdmVudEVtaXR0ZXI8Tm9kZVtdPigpO1xuICAgIC8qKlxuICAgICAqIE9uZSBvciBtb3JlIG5vZGVzIGhhdmUgYmVlbiBtb3ZlZCB0byB0aGUgcmVjeWNsZSBiaW4uXG4gICAgICpcbiAgICAgKiBUaGUgZW1pdHRlZCB2YWx1ZSBpcyB0aGUgYXJyYXkgb2YgZm9ybWVyIG5vZGVzLlxuICAgICAqXG4gICAgICogVGhlIGVtaXR0ZXIgc2hvdWxkIG5vdCBiZSB0cmlnZ2VyZWQgd2l0aCBhbiBlbXB0eSBhcnJheSBvciBudWxsLlxuICAgICAqL1xuICAgIC8vIEZJWE1FOiBNYXliZSBhIGBub2Rlc01vdmVkYCBlbWl0dGVyIHdvdWxkIG1ha2UgZm9yIHNlbnNlIGZvciB1cGRhdGluZyBsaXN0cyB0aGF0IHVzZWQgdG9cbiAgICAvLyBpbmNsdWRlIGEgbm9kZSBhbmQgbGlzdHMgdGhhdCB0aGUgbm9kZSB3YXMgbW92ZWQgdG8uXG4gICAgcmVhZG9ubHkgbm9kZXNEZWxldGVkID0gbmV3IEV2ZW50RW1pdHRlcjxOb2RlW10+KCk7XG59XG4iXX0=

package/esm2022/lib/services/node-entries.service.mjs

@@ -0,0 +1,137 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { NodeDataSourceRemote } from '../node-entries/node-data-source-remote';
+import * as i0 from "@angular/core";
+import * as i1 from "./ui.service";
+import * as i2 from "../node-entries/node-entries-global.service";
+export class NodeEntriesService {
+    get dataSource() {
+        return this.dataSource$.value;
+    }
+    set dataSource(value) {
+        this.dataSource$.next(value);
+    }
+    get paginationStrategy() {
+        return this.entriesGlobal.getPaginationStrategy(this.scope);
+    }
+    get columns() {
+        return this.columnsSubject.value;
+    }
+    set columns(value) {
+        this.columnsSubject.next(value);
+    }
+    get options() {
+        return this.options$.value;
+    }
+    set options(options) {
+        this.options$.next(options);
+    }
+    get sort() {
+        return this.sortSubject.value;
+    }
+    set sort(value) {
+        this.sortSubject.next(value);
+    }
+    get gridConfig() {
+        return this.gridConfig$.value;
+    }
+    set gridConfig(value) {
+        this.gridConfig$.next(value);
+    }
+    constructor(uiService, entriesGlobal) {
+        this.uiService = uiService;
+        this.entriesGlobal = entriesGlobal;
+        this.dataSource$ = new BehaviorSubject(null);
+        /**
+         * Subject that reflects the current columns configuration.
+         *
+         * Updated when loading configuration and through user interaction.
+         */
+        this.columnsSubject = new BehaviorSubject(null);
+        this.selection = new SelectionModel(true, []);
+        this.options$ = new BehaviorSubject(null);
+        this.sortSubject = new BehaviorSubject(void 0);
+        this.gridConfig$ = new BehaviorSubject(null);
+    }
+    onClicked({ event, ...data }) {
+        if (event.ctrlKey || event.metaKey) {
+            this.selection.toggle(data.element);
+        }
+        else if (event.shiftKey) {
+            this.expandSelectionTo(data.element);
+        }
+        else {
+            this.clickItem.emit(data);
+        }
+    }
+    onCheckboxChanged(node, checked) {
+        console.log(node, checked, this.uiService.shiftKeyPressed);
+        if (this.uiService.shiftKeyPressed) {
+            this.expandSelectionTo(node);
+        }
+        if (checked !== this.selection.isSelected(node)) {
+            this.selection.toggle(node);
+        }
+    }
+    toggleSelectAll() {
+        if (this.isAllSelected()) {
+            this.selection.clear();
+        }
+        else {
+            this.selectAll();
+        }
+    }
+    loadMore(source) {
+        if (this.paginationStrategy !== 'infinite-scroll') {
+            return false;
+        }
+        if (source === 'scroll' && this.disableInfiniteScroll) {
+            return false;
+        }
+        // TODO: focus next item when triggered via button.
+        if (this.dataSource instanceof NodeDataSourceRemote) {
+            return this.dataSource.loadMore();
+        }
+        else {
+            if (this.dataSource.hasMore()) {
+                this.fetchData.emit({
+                    offset: this.dataSource.getData().length,
+                    reset: false,
+                });
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    selectAll() {
+        this.selection.select(...this.dataSource.getData());
+    }
+    isAllSelected() {
+        return this.dataSource.getData().every((node) => this.selection.isSelected(node));
+    }
+    expandSelectionTo(node) {
+        const nodeIndex = this.dataSource.getData().indexOf(node);
+        const selectionIndexes = this.selection.selected
+            .map((node) => this.dataSource.getData().indexOf(node))
+            .filter((index) => index >= 0);
+        if (Math.min(...selectionIndexes) < nodeIndex) {
+            for (let i = Math.min(...selectionIndexes) + 1; i <= nodeIndex; i++) {
+                this.selection.select(this.dataSource.getData()[i]);
+            }
+        }
+        else if (Math.max(...selectionIndexes) > nodeIndex) {
+            for (let i = nodeIndex; i < Math.max(...selectionIndexes); i++) {
+                this.selection.select(this.dataSource.getData()[i]);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodeEntriesService, deps: [{ token: i1.UIService }, { token: i2.NodeEntriesGlobalService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodeEntriesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodeEntriesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.UIService }, { type: i2.NodeEntriesGlobalService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-entries.service.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/services/node-entries.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { SelectionModel } from '@angular/cdk/collections';\nimport { EventEmitter, Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport {\n    FetchEvent,\n    GridConfig,\n    InteractionType,\n    ListDragGropConfig,\n    ListEventInterface,\n    ListOptions,\n    ListSortConfig,\n    NodeClickEvent,\n    NodeEntriesDataType,\n    NodeEntriesDisplayType,\n} from '../node-entries/entries-model';\nimport { NodeDataSource } from '../node-entries/node-data-source';\nimport {\n    NodeEntriesGlobalService,\n    PaginationStrategy,\n} from '../node-entries/node-entries-global.service';\n\nimport { OptionItem, Scope } from '../types/option-item';\nimport { ListItem } from '../types/list-item';\nimport { UIService } from './ui.service';\nimport { NodeDataSourceRemote } from '../node-entries/node-data-source-remote';\n\n@Injectable()\nexport class NodeEntriesService<T extends NodeEntriesDataType> {\n    list: ListEventInterface<T>;\n    readonly dataSource$ = new BehaviorSubject<NodeDataSource<T> | null>(null);\n    /**\n     * scope the current list is in, e.g. workspace\n     * This is used for additional config injection based on the scope\n     */\n    scope: Scope;\n    get dataSource(): NodeDataSource<T> {\n        return this.dataSource$.value;\n    }\n    set dataSource(value: NodeDataSource<T>) {\n        this.dataSource$.next(value);\n    }\n    get paginationStrategy(): PaginationStrategy {\n        return this.entriesGlobal.getPaginationStrategy(this.scope);\n    }\n    /**\n     * Subject that reflects the current columns configuration.\n     *\n     * Updated when loading configuration and through user interaction.\n     */\n    columnsSubject = new BehaviorSubject<ListItem[]>(null);\n    get columns(): ListItem[] {\n        return this.columnsSubject.value;\n    }\n    set columns(value: ListItem[]) {\n        this.columnsSubject.next(value);\n    }\n    configureColumns: boolean;\n    /** Emits when the columns configuration changes through user interaction. */\n    columnsChange: EventEmitter<ListItem[]>;\n    displayType: NodeEntriesDisplayType;\n    selection = new SelectionModel<T>(true, []);\n    elementInteractionType: InteractionType;\n    options$ = new BehaviorSubject<ListOptions>(null);\n    get options() {\n        return this.options$.value;\n    }\n    set options(options: ListOptions) {\n        this.options$.next(options);\n    }\n    checkbox: boolean;\n    globalOptions: OptionItem[];\n    sortSubject = new BehaviorSubject<ListSortConfig>(void 0);\n    get sort(): ListSortConfig {\n        return this.sortSubject.value;\n    }\n    set sort(value: ListSortConfig) {\n        this.sortSubject.next(value);\n    }\n    sortChange: EventEmitter<ListSortConfig>;\n    dragDrop: ListDragGropConfig<T>;\n    clickItem: EventEmitter<NodeClickEvent<T>>;\n    dblClickItem: EventEmitter<NodeClickEvent<T>>;\n    fetchData: EventEmitter<FetchEvent>;\n    readonly gridConfig$ = new BehaviorSubject<GridConfig | null>(null);\n    get gridConfig(): GridConfig {\n        return this.gridConfig$.value;\n    }\n    set gridConfig(value: GridConfig) {\n        this.gridConfig$.next(value);\n    }\n    primaryInstance: boolean;\n    singleClickHint: 'dynamic' | 'static';\n    disableInfiniteScroll: boolean;\n\n    constructor(private uiService: UIService, private entriesGlobal: NodeEntriesGlobalService) {}\n\n    onClicked({ event, ...data }: NodeClickEvent<T> & { event: MouseEvent }) {\n        if (event.ctrlKey || event.metaKey) {\n            this.selection.toggle(data.element);\n        } else if (event.shiftKey) {\n            this.expandSelectionTo(data.element);\n        } else {\n            this.clickItem.emit(data);\n        }\n    }\n\n    onCheckboxChanged(node: T, checked: boolean) {\n        console.log(node, checked, this.uiService.shiftKeyPressed);\n        if (this.uiService.shiftKeyPressed) {\n            this.expandSelectionTo(node);\n        }\n\n        if (checked !== this.selection.isSelected(node)) {\n            this.selection.toggle(node);\n        }\n    }\n\n    toggleSelectAll() {\n        if (this.isAllSelected()) {\n            this.selection.clear();\n        } else {\n            this.selectAll();\n        }\n    }\n\n    loadMore(source: 'button' | 'scroll'): boolean {\n        if (this.paginationStrategy !== 'infinite-scroll') {\n            return false;\n        }\n        if (source === 'scroll' && this.disableInfiniteScroll) {\n            return false;\n        }\n        // TODO: focus next item when triggered via button.\n        if (this.dataSource instanceof NodeDataSourceRemote) {\n            return (this.dataSource as NodeDataSourceRemote).loadMore();\n        } else {\n            if (this.dataSource.hasMore()) {\n                this.fetchData.emit({\n                    offset: this.dataSource.getData().length,\n                    reset: false,\n                });\n                return true;\n            } else {\n                return false;\n            }\n        }\n    }\n\n    private selectAll() {\n        this.selection.select(...this.dataSource.getData());\n    }\n\n    private isAllSelected(): boolean {\n        return this.dataSource.getData().every((node) => this.selection.isSelected(node));\n    }\n\n    private expandSelectionTo(node: T) {\n        const nodeIndex = this.dataSource.getData().indexOf(node);\n        const selectionIndexes = this.selection.selected\n            .map((node) => this.dataSource.getData().indexOf(node))\n            .filter((index) => index >= 0);\n        if (Math.min(...selectionIndexes) < nodeIndex) {\n            for (let i = Math.min(...selectionIndexes) + 1; i <= nodeIndex; i++) {\n                this.selection.select(this.dataSource.getData()[i]);\n            }\n        } else if (Math.max(...selectionIndexes) > nodeIndex) {\n            for (let i = nodeIndex; i < Math.max(...selectionIndexes); i++) {\n                this.selection.select(this.dataSource.getData()[i]);\n            }\n        }\n    }\n}\n"]}

package/esm2022/lib/services/node-helper.service.mjs

@@ -0,0 +1,234 @@
+import { Injectable } from '@angular/core';
+import { RestConstants, } from 'ngx-edu-sharing-api';
+import * as Workflow from '../types/workflow';
+import { UIConstants } from '../util/ui-constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "ngx-edu-sharing-api";
+import * as i3 from "./repo-url.service";
+export class NodeHelperService {
+    constructor(translate, apiHelpersService, networkService, configService, repoUrlService) {
+        this.translate = translate;
+        this.apiHelpersService = apiHelpersService;
+        this.networkService = networkService;
+        this.configService = configService;
+        this.repoUrlService = repoUrlService;
+    }
+    getCollectionScopeInfo(node) {
+        const scope = node.collection ? node.collection.scope : null;
+        let icon = 'help';
+        let scopeName = 'UNKNOWN';
+        if (scope === RestConstants.COLLECTIONSCOPE_MY) {
+            icon = 'lock';
+            scopeName = 'MY';
+        }
+        if (scope === RestConstants.COLLECTIONSCOPE_ORGA ||
+            scope === RestConstants.COLLECTIONSCOPE_CUSTOM) {
+            icon = 'group';
+            scopeName = 'SHARED';
+        }
+        if (scope === RestConstants.COLLECTIONSCOPE_ALL ||
+            scope === RestConstants.COLLECTIONSCOPE_CUSTOM_PUBLIC) {
+            icon = 'language';
+            scopeName = 'PUBLIC';
+        }
+        if (node.collection?.type === RestConstants.COLLECTIONTYPE_EDITORIAL) {
+            icon = 'star';
+            scopeName = 'TYPE_EDITORIAL';
+        }
+        if (node.collection?.type === RestConstants.COLLECTIONTYPE_MEDIA_CENTER) {
+            icon = 'business';
+            scopeName = 'TYPE_MEDIA_CENTER';
+        }
+        return { icon, scopeName };
+    }
+    /**
+     * Return the license icon of a node
+     */
+    async getLicenseIcon(node) {
+        // prefer manual mapping instead of backend data to support custom states from local edits
+        const license = node.properties?.[RestConstants.CCM_PROP_LICENSE]?.[0];
+        if (license) {
+            return this.getLicenseIconByString(license);
+        }
+        return node.license ? this.repoUrlService.getRepoUrl(node.license.icon, node) : null;
+    }
+    /**
+     * Get a license icon by using the property value string
+     */
+    getLicenseIconByString(string, useNoneAsFallback = true) {
+        let icon = string.replace(/_/g, '-').toLowerCase();
+        if (icon == '')
+            icon = 'none';
+        const LICENSE_ICONS = [
+            'cc-0',
+            'cc-by-nc',
+            'cc-by-nc-nd',
+            'cc-by-nc-sa',
+            'cc-by-nd',
+            'cc-by-sa',
+            'cc-by',
+            'copyright-free',
+            'copyright-license',
+            'custom',
+            'edu-nc-nd-noDo',
+            'edu-nc-nd',
+            'edu-p-nr-nd-noDo',
+            'edu-p-nr-nd',
+            'none',
+            'pdm',
+            'schulfunk',
+            'unterrichts-und-lehrmedien',
+        ];
+        if (LICENSE_ICONS.indexOf(icon) == -1 && !useNoneAsFallback)
+            return null; // icon='none';
+        if (icon == 'none' && !useNoneAsFallback)
+            return null;
+        const result = this.apiHelpersService.getServerUrl() + '/../ccimages/licenses/' + icon + '.svg';
+        return this.repoUrlService.withCurrentOrigin(result);
+    }
+    /**
+     * Return a translated name of a license name for a node
+     * @param node
+     * @param translate
+     * @returns {string|any|string|any|string|any|string|any|string|any|string}
+     */
+    getLicenseName(node) {
+        let prop = node.properties[RestConstants.CCM_PROP_LICENSE]?.[0];
+        if (!prop)
+            prop = '';
+        return this.getLicenseNameByString(prop);
+    }
+    /**
+     * Return a translated name for a license string
+     * @param string
+     * @param translate
+     * @returns {any}
+     */
+    getLicenseNameByString(name) {
+        if (name == '') {
+            name = 'NONE';
+        }
+        return this.translate.instant('LICENSE.NAMES.' + name);
+        // return name.replace(/_/g,"-");
+    }
+    /**
+     * return the License URL (e.g. for CC_BY licenses) for a license string and version
+     * @param licenseProperty
+     * @param licenseVersion
+     */
+    getLicenseUrlByString(licenseProperty, licenseVersion) {
+        const url = RestConstants.LICENSE_URLS[licenseProperty];
+        if (!url)
+            return null;
+        return url.replace('#version', licenseVersion);
+    }
+    getWorkflowStatusById(id) {
+        const workflows = this.getWorkflows();
+        return workflows.filter((w) => w.id === id)?.[0];
+    }
+    getWorkflowStatus(node, useFromConfig = false) {
+        let value = node.properties[RestConstants.CCM_PROP_WF_STATUS]?.[0];
+        if (!value) {
+            return this.getDefaultWorkflowStatus(useFromConfig);
+        }
+        return {
+            current: this.getWorkflowStatusById(value),
+            initial: this.getWorkflowStatusById(value),
+        };
+    }
+    getDefaultWorkflowStatus(useFromConfig = false) {
+        const result = {
+            current: null,
+            initial: null,
+        };
+        result.initial = this.getWorkflows()[0];
+        let defaultStatus = null;
+        if (useFromConfig) {
+            defaultStatus = this.configService.instant('workflow.defaultStatus');
+        }
+        if (defaultStatus) {
+            result.current = this.getWorkflows().find((w) => w.id === defaultStatus);
+        }
+        else {
+            result.current = result.initial;
+        }
+        return result;
+    }
+    getWorkflows() {
+        return this.configService.instant('workflow.workflows', [
+            Workflow.WORKFLOW_STATUS_UNCHECKED,
+            Workflow.WORKFLOW_STATUS_TO_CHECK,
+            Workflow.WORKFLOW_STATUS_HASFLAWS,
+            Workflow.WORKFLOW_STATUS_CHECKED,
+        ]);
+    }
+    copyDataToNode(target, source) {
+        target.properties = source.properties;
+        target.name = source.name;
+        target.title = source.title;
+    }
+    isNodeCollection(node) {
+        return node.aspects?.includes(RestConstants.CCM_ASPECT_COLLECTION) || !!node.collection;
+    }
+    getSourceIconPath(src) {
+        return 'assets/images/sources/' + src.toLowerCase() + '.png';
+    }
+    getNodeLink(mode, node) {
+        if (!node?.ref) {
+            return null;
+        }
+        let data = null;
+        if (this.isNodeCollection(node)) {
+            data = {
+                routerLink: UIConstants.ROUTER_PREFIX + 'collections',
+                queryParams: { id: node.ref.id },
+            };
+        }
+        else {
+            if (node.isDirectory) {
+                let path;
+                if (node.properties?.[RestConstants.CCM_PROP_EDUSCOPENAME]?.[0] ===
+                    RestConstants.SAFE_SCOPE) {
+                    path = UIConstants.ROUTER_PREFIX + 'workspace/safe';
+                }
+                else {
+                    path = UIConstants.ROUTER_PREFIX + 'workspace';
+                }
+                data = {
+                    routerLink: path,
+                    queryParams: { id: node.ref.id },
+                };
+            }
+            else if (node.ref) {
+                const fromHome = this.networkService.isFromHomeRepository(node);
+                data = {
+                    routerLink: UIConstants.ROUTER_PREFIX + 'render/' + node.ref.id,
+                    queryParams: {
+                        repository: fromHome ? null : node.ref.repo,
+                        proposal: node.proposal?.ref.id,
+                        proposalCollection: node.proposalCollection?.ref.id,
+                    },
+                };
+            }
+        }
+        if (data === null) {
+            return '';
+        }
+        if (mode === 'routerLink') {
+            return '/' + data.routerLink;
+        }
+        // enforce clearing of parameters which should only be consumed once
+        data.queryParams.redirectFromSSO = null;
+        return data.queryParams;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodeHelperService, deps: [{ token: i1.TranslateService }, { token: i2.ApiHelpersService }, { token: i2.NetworkService }, { token: i2.ConfigService }, { token: i3.RepoUrlService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodeHelperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodeHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.ApiHelpersService }, { type: i2.NetworkService }, { type: i2.ConfigService }, { type: i3.RepoUrlService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-helper.service.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/services/node-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n    ApiHelpersService,\n    ConfigService,\n    NetworkService,\n    Node,\n    ProposalNode,\n    RestConstants,\n} from 'ngx-edu-sharing-api';\nimport { TranslateService } from '@ngx-translate/core';\nimport * as Workflow from '../types/workflow';\nimport { RepoUrlService } from './repo-url.service';\nimport { Params } from '@angular/router';\nimport { UIConstants } from '../util/ui-constants';\n@Injectable({\n    providedIn: 'root',\n})\nexport class NodeHelperService {\n    constructor(\n        protected translate: TranslateService,\n        protected apiHelpersService: ApiHelpersService,\n        protected networkService: NetworkService,\n        protected configService: ConfigService,\n        protected repoUrlService: RepoUrlService,\n    ) {}\n\n    public getCollectionScopeInfo(node: Node): { icon: string; scopeName: string } {\n        const scope = node.collection ? node.collection.scope : null;\n        let icon = 'help';\n        let scopeName = 'UNKNOWN';\n        if (scope === RestConstants.COLLECTIONSCOPE_MY) {\n            icon = 'lock';\n            scopeName = 'MY';\n        }\n        if (\n            scope === RestConstants.COLLECTIONSCOPE_ORGA ||\n            scope === RestConstants.COLLECTIONSCOPE_CUSTOM\n        ) {\n            icon = 'group';\n            scopeName = 'SHARED';\n        }\n        if (\n            scope === RestConstants.COLLECTIONSCOPE_ALL ||\n            scope === RestConstants.COLLECTIONSCOPE_CUSTOM_PUBLIC\n        ) {\n            icon = 'language';\n            scopeName = 'PUBLIC';\n        }\n        if (node.collection?.type === RestConstants.COLLECTIONTYPE_EDITORIAL) {\n            icon = 'star';\n            scopeName = 'TYPE_EDITORIAL';\n        }\n        if (node.collection?.type === RestConstants.COLLECTIONTYPE_MEDIA_CENTER) {\n            icon = 'business';\n            scopeName = 'TYPE_MEDIA_CENTER';\n        }\n        return { icon, scopeName };\n    }\n    /**\n     * Return the license icon of a node\n     */\n    async getLicenseIcon(node: Node): Promise<string> {\n        // prefer manual mapping instead of backend data to support custom states from local edits\n        const license = node.properties?.[RestConstants.CCM_PROP_LICENSE]?.[0];\n        if (license) {\n            return this.getLicenseIconByString(license);\n        }\n        return node.license ? this.repoUrlService.getRepoUrl(node.license.icon, node) : null;\n    }\n\n    /**\n     * Get a license icon by using the property value string\n     */\n    public getLicenseIconByString(string: String, useNoneAsFallback = true): string {\n        let icon = string.replace(/_/g, '-').toLowerCase();\n        if (icon == '') icon = 'none';\n\n        const LICENSE_ICONS = [\n            'cc-0',\n            'cc-by-nc',\n            'cc-by-nc-nd',\n            'cc-by-nc-sa',\n            'cc-by-nd',\n            'cc-by-sa',\n            'cc-by',\n            'copyright-free',\n            'copyright-license',\n            'custom',\n            'edu-nc-nd-noDo',\n            'edu-nc-nd',\n            'edu-p-nr-nd-noDo',\n            'edu-p-nr-nd',\n            'none',\n            'pdm',\n            'schulfunk',\n            'unterrichts-und-lehrmedien',\n        ];\n        if (LICENSE_ICONS.indexOf(icon) == -1 && !useNoneAsFallback) return null; // icon='none';\n        if (icon == 'none' && !useNoneAsFallback) return null;\n        const result =\n            this.apiHelpersService.getServerUrl() + '/../ccimages/licenses/' + icon + '.svg';\n        return this.repoUrlService.withCurrentOrigin(result);\n    }\n    /**\n     * Return a translated name of a license name for a node\n     * @param node\n     * @param translate\n     * @returns {string|any|string|any|string|any|string|any|string|any|string}\n     */\n    public getLicenseName(node: Node) {\n        let prop = node.properties[RestConstants.CCM_PROP_LICENSE]?.[0];\n        if (!prop) prop = '';\n        return this.getLicenseNameByString(prop);\n    }\n\n    /**\n     * Return a translated name for a license string\n     * @param string\n     * @param translate\n     * @returns {any}\n     */\n    public getLicenseNameByString(name: string) {\n        if (name == '') {\n            name = 'NONE';\n        }\n        return this.translate.instant('LICENSE.NAMES.' + name);\n        // return name.replace(/_/g,\"-\");\n    }\n\n    /**\n     * return the License URL (e.g. for CC_BY licenses) for a license string and version\n     * @param licenseProperty\n     * @param licenseVersion\n     */\n    public getLicenseUrlByString(licenseProperty: string, licenseVersion: string) {\n        const url = (RestConstants.LICENSE_URLS as any)[licenseProperty];\n        if (!url) return null;\n        return url.replace('#version', licenseVersion);\n    }\n\n    public getWorkflowStatusById(id: string) {\n        const workflows = this.getWorkflows();\n        return workflows.filter((w) => w.id === id)?.[0];\n    }\n    public getWorkflowStatus(node: Node, useFromConfig = false): Workflow.WorkflowDefinitionStatus {\n        let value = node.properties[RestConstants.CCM_PROP_WF_STATUS]?.[0];\n        if (!value) {\n            return this.getDefaultWorkflowStatus(useFromConfig);\n        }\n        return {\n            current: this.getWorkflowStatusById(value),\n            initial: this.getWorkflowStatusById(value),\n        };\n    }\n    getDefaultWorkflowStatus(useFromConfig = false): Workflow.WorkflowDefinitionStatus {\n        const result = {\n            current: null as Workflow.WorkflowDefinition,\n            initial: null as Workflow.WorkflowDefinition,\n        };\n        result.initial = this.getWorkflows()[0];\n        let defaultStatus: string = null;\n        if (useFromConfig) {\n            defaultStatus = this.configService.instant('workflow.defaultStatus');\n        }\n        if (defaultStatus) {\n            result.current = this.getWorkflows().find((w) => w.id === defaultStatus);\n        } else {\n            result.current = result.initial;\n        }\n        return result;\n    }\n    getWorkflows(): Workflow.WorkflowDefinition[] {\n        return this.configService.instant('workflow.workflows', [\n            Workflow.WORKFLOW_STATUS_UNCHECKED,\n            Workflow.WORKFLOW_STATUS_TO_CHECK,\n            Workflow.WORKFLOW_STATUS_HASFLAWS,\n            Workflow.WORKFLOW_STATUS_CHECKED,\n        ]);\n    }\n    copyDataToNode<T extends Node>(target: T, source: T) {\n        target.properties = source.properties;\n        target.name = source.name;\n        target.title = source.title;\n    }\n    isNodeCollection(node: Node): boolean {\n        return node.aspects?.includes(RestConstants.CCM_ASPECT_COLLECTION) || !!node.collection;\n    }\n    public getSourceIconPath(src: string) {\n        return 'assets/images/sources/' + src.toLowerCase() + '.png';\n    }\n\n    getNodeLink(mode: 'routerLink' | 'queryParams', node: Node) {\n        if (!node?.ref) {\n            return null;\n        }\n        let data: { routerLink: string; queryParams: Params } = null;\n        if (this.isNodeCollection(node)) {\n            data = {\n                routerLink: UIConstants.ROUTER_PREFIX + 'collections',\n                queryParams: { id: node.ref.id },\n            };\n        } else {\n            if (node.isDirectory) {\n                let path;\n                if (\n                    node.properties?.[RestConstants.CCM_PROP_EDUSCOPENAME]?.[0] ===\n                    RestConstants.SAFE_SCOPE\n                ) {\n                    path = UIConstants.ROUTER_PREFIX + 'workspace/safe';\n                } else {\n                    path = UIConstants.ROUTER_PREFIX + 'workspace';\n                }\n                data = {\n                    routerLink: path,\n                    queryParams: { id: node.ref.id },\n                };\n            } else if (node.ref) {\n                const fromHome = this.networkService.isFromHomeRepository(node);\n                data = {\n                    routerLink: UIConstants.ROUTER_PREFIX + 'render/' + node.ref.id,\n                    queryParams: {\n                        repository: fromHome ? null : node.ref.repo,\n                        proposal: (node as ProposalNode).proposal?.ref.id,\n                        proposalCollection: (node as ProposalNode).proposalCollection?.ref.id,\n                    },\n                };\n            }\n        }\n        if (data === null) {\n            return '';\n        }\n        if (mode === 'routerLink') {\n            return '/' + data.routerLink;\n        }\n        // enforce clearing of parameters which should only be consumed once\n        data.queryParams.redirectFromSSO = null;\n        return data.queryParams;\n    }\n}\n"]}