@alfresco/aca-shared 5.1.1 → 5.2.0

package/esm2022/lib/services/content-api.service.mjs

@@ -0,0 +1,281 @@
+/*!
+ * 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 { UserPreferencesService } from '@alfresco/adf-core';
+import { AlfrescoApiService } from '@alfresco/adf-content-services';
+import { from } from 'rxjs';
+import { NodesApi, TrashcanApi, SharedlinksApi, DiscoveryApi, FavoritesApi, ContentApi, SitesApi, SearchApi, PeopleApi, VersionsApi } from '@alfresco/js-api';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-content-services";
+import * as i2 from "@alfresco/adf-core";
+class ContentApiService {
+    api;
+    preferences;
+    _nodesApi;
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.api.getInstance());
+        return this._nodesApi;
+    }
+    _trashcanApi;
+    get trashcanApi() {
+        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.api.getInstance());
+        return this._trashcanApi;
+    }
+    _sharedLinksApi;
+    get sharedLinksApi() {
+        this._sharedLinksApi = this._sharedLinksApi ?? new SharedlinksApi(this.api.getInstance());
+        return this._sharedLinksApi;
+    }
+    _discoveryApi;
+    get discoveryApi() {
+        this._discoveryApi = this._discoveryApi ?? new DiscoveryApi(this.api.getInstance());
+        return this._discoveryApi;
+    }
+    _favoritesApi;
+    get favoritesApi() {
+        this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.api.getInstance());
+        return this._favoritesApi;
+    }
+    _contentApi;
+    get contentApi() {
+        this._contentApi = this._contentApi ?? new ContentApi(this.api.getInstance());
+        return this._contentApi;
+    }
+    _sitesApi;
+    get sitesApi() {
+        this._sitesApi = this._sitesApi ?? new SitesApi(this.api.getInstance());
+        return this._sitesApi;
+    }
+    _searchApi;
+    get searchApi() {
+        this._searchApi = this._searchApi ?? new SearchApi(this.api.getInstance());
+        return this._searchApi;
+    }
+    _peopleApi;
+    get peopleApi() {
+        this._peopleApi = this._peopleApi ?? new PeopleApi(this.api.getInstance());
+        return this._peopleApi;
+    }
+    _versionsApi;
+    get versionsApi() {
+        this._versionsApi = this._versionsApi ?? new VersionsApi(this.api.getInstance());
+        return this._versionsApi;
+    }
+    constructor(api, preferences) {
+        this.api = api;
+        this.preferences = preferences;
+    }
+    /**
+     * Moves a node to the trashcan.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @returns Empty result that notifies when the deletion is complete
+     */
+    deleteNode(nodeId, options = {}) {
+        return from(this.nodesApi.deleteNode(nodeId, options));
+    }
+    /**
+     * Gets the stored information about a node.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @returns Node information
+     */
+    getNode(nodeId, options = {}) {
+        const defaults = {
+            include: ['path', 'properties', 'allowableOperations', 'permissions', 'definition']
+        };
+        const queryOptions = Object.assign(defaults, options);
+        return from(this.nodesApi.getNode(nodeId, queryOptions));
+    }
+    getNodeInfo(nodeId, options) {
+        const defaults = {
+            include: ['isFavorite', 'allowableOperations', 'path', 'definition']
+        };
+        const queryOptions = Object.assign(defaults, options || {});
+        return from(new Promise((resolve, reject) => {
+            this.nodesApi.getNode(nodeId, queryOptions).then((nodeEntry) => {
+                resolve(nodeEntry.entry);
+            }, (error) => {
+                reject(error);
+            });
+        }));
+    }
+    /**
+     * Gets the items contained in a folder node.
+     *
+     * @param nodeId ID of the target node
+     * @param options Optional parameters supported by JS-API
+     * @returns List of child items from the folder
+     */
+    getNodeChildren(nodeId, options = {}) {
+        const defaults = {
+            maxItems: this.preferences.paginationSize,
+            skipCount: 0,
+            include: ['isLocked', 'path', 'properties', 'allowableOperations', 'permissions']
+        };
+        const queryOptions = Object.assign(defaults, options);
+        return from(this.nodesApi.listNodeChildren(nodeId, queryOptions));
+    }
+    deleteSharedLink(linkId) {
+        return from(this.sharedLinksApi.deleteSharedLink(linkId));
+    }
+    getDeletedNodes(options = {}) {
+        const defaults = {
+            include: ['path']
+        };
+        const queryOptions = Object.assign(defaults, options);
+        return from(this.trashcanApi.listDeletedNodes(queryOptions));
+    }
+    restoreNode(nodeId) {
+        return from(this.trashcanApi.restoreDeletedNode(nodeId));
+    }
+    purgeDeletedNode(nodeId) {
+        return from(this.trashcanApi.deleteDeletedNode(nodeId));
+    }
+    /**
+     * Gets information about a user identified by their username.
+     *
+     * @param personId ID of the target user
+     * @param options Api options
+     * @returns User information
+     */
+    getPerson(personId, options) {
+        return from(this.peopleApi.getPerson(personId, options));
+    }
+    /**
+     * Copy a node to destination node
+     *
+     * @param nodeId The id of the node to be copied
+     * @param targetParentId The id of the folder-node where the node have to be copied to
+     * @param name The new name for the copy that would be added on the destination folder
+     * @param opts Api options
+     */
+    copyNode(nodeId, targetParentId, name, opts) {
+        return from(this.nodesApi.copyNode(nodeId, { targetParentId, name }, opts));
+    }
+    /**
+     * Gets product information for Content Services.
+     *
+     * @returns ProductVersionModel containing product details
+     */
+    getRepositoryInformation() {
+        return from(this.discoveryApi.getRepositoryInformation());
+    }
+    getFavorites(personId, opts) {
+        return from(this.favoritesApi.listFavorites(personId, opts));
+    }
+    getFavoriteLibraries(personId = '-me-', opts) {
+        return this.getFavorites(personId, {
+            ...opts,
+            where: '(EXISTS(target/site))'
+        }).pipe(map((response) => ({
+            list: {
+                entries: response.list.entries.map(({ entry }) => {
+                    entry.target.site.createdAt = entry.createdAt;
+                    return {
+                        entry: entry.target.site
+                    };
+                }),
+                pagination: response.list.pagination
+            }
+        })));
+    }
+    findSharedLinks(opts) {
+        return from(this.sharedLinksApi.listSharedLinks(opts));
+    }
+    getSharedLinkContent(sharedId, attachment) {
+        return this.contentApi.getSharedLinkContentUrl(sharedId, attachment);
+    }
+    search(request) {
+        return from(this.searchApi.search(request));
+    }
+    getContentUrl(nodeId, attachment) {
+        return this.contentApi.getContentUrl(nodeId, attachment);
+    }
+    getVersionContentUrl(nodeId, versionId, attachment) {
+        return this.contentApi.getVersionContentUrl(nodeId, versionId, attachment);
+    }
+    deleteSite(siteId, opts) {
+        return from(this.sitesApi.deleteSite(siteId, opts));
+    }
+    leaveSite(siteId) {
+        return from(this.sitesApi.deleteSiteMembership(siteId, '-me-'));
+    }
+    createSite(siteBody, opts) {
+        return from(this.sitesApi.createSite(siteBody, opts));
+    }
+    getSite(siteId, opts) {
+        return from(this.sitesApi.getSite(siteId, opts));
+    }
+    updateLibrary(siteId, siteBody) {
+        return from(this.sitesApi.updateSite(siteId, siteBody));
+    }
+    addFavorite(nodes) {
+        const payload = nodes.map((node) => {
+            const { isFolder, nodeId, id } = node.entry;
+            const siteId = node.entry['guid'];
+            const type = siteId ? 'site' : isFolder ? 'folder' : 'file';
+            const guid = siteId || nodeId || id;
+            return {
+                target: {
+                    [type]: {
+                        guid
+                    }
+                }
+            };
+        });
+        return from(this.favoritesApi.createFavorite('-me-', payload));
+    }
+    removeFavorite(nodes) {
+        return from(Promise.all(nodes.map((node) => {
+            const id = node.entry.nodeId || node.entry.id;
+            return this.favoritesApi.deleteFavorite('-me-', id);
+        })));
+    }
+    unlockNode(nodeId, opts) {
+        return this.nodesApi.unlockNode(nodeId, opts);
+    }
+    getNodeVersions(nodeId, opts) {
+        return from(this.versionsApi.listVersionHistory(nodeId, opts));
+    }
+    requestNodeDirectAccessUrl(nodeId) {
+        return from(this.nodesApi.requestDirectAccessUrl(nodeId));
+    }
+    requestVersionDirectAccessUrl(nodeId, versionId) {
+        return from(this.versionsApi.requestDirectAccessUrl(nodeId, versionId));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentApiService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentApiService, providedIn: 'root' });
+}
+export { ContentApiService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AlfrescoApiService }, { type: i2.UserPreferencesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-api.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/src/lib/services/content-api.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 { UserPreferencesService } from '@alfresco/adf-core';\nimport { AlfrescoApiService } from '@alfresco/adf-content-services';\nimport { Observable, from } from 'rxjs';\nimport {\n  NodePaging,\n  Node,\n  DeletedNodesPaging,\n  PersonEntry,\n  NodeEntry,\n  DiscoveryEntry,\n  FavoritePaging,\n  SharedLinkPaging,\n  SearchRequest,\n  ResultSetPaging,\n  SiteBodyCreate,\n  SiteEntry,\n  FavoriteBodyCreate,\n  FavoriteEntry,\n  NodesApi,\n  TrashcanApi,\n  SharedlinksApi,\n  DiscoveryApi,\n  FavoritesApi,\n  ContentApi,\n  SitesApi,\n  SearchApi,\n  PeopleApi,\n  VersionsApi,\n  DirectAccessUrlEntry,\n  VersionPaging\n} from '@alfresco/js-api';\nimport { map } from 'rxjs/operators';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ContentApiService {\n  private _nodesApi: NodesApi;\n  get nodesApi(): NodesApi {\n    this._nodesApi = this._nodesApi ?? new NodesApi(this.api.getInstance());\n    return this._nodesApi;\n  }\n\n  private _trashcanApi: TrashcanApi;\n  get trashcanApi(): TrashcanApi {\n    this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.api.getInstance());\n    return this._trashcanApi;\n  }\n\n  private _sharedLinksApi: SharedlinksApi;\n  get sharedLinksApi(): SharedlinksApi {\n    this._sharedLinksApi = this._sharedLinksApi ?? new SharedlinksApi(this.api.getInstance());\n    return this._sharedLinksApi;\n  }\n\n  private _discoveryApi: DiscoveryApi;\n  get discoveryApi(): DiscoveryApi {\n    this._discoveryApi = this._discoveryApi ?? new DiscoveryApi(this.api.getInstance());\n    return this._discoveryApi;\n  }\n\n  private _favoritesApi: FavoritesApi;\n  get favoritesApi(): FavoritesApi {\n    this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.api.getInstance());\n    return this._favoritesApi;\n  }\n\n  private _contentApi: ContentApi;\n  get contentApi(): ContentApi {\n    this._contentApi = this._contentApi ?? new ContentApi(this.api.getInstance());\n    return this._contentApi;\n  }\n\n  private _sitesApi: SitesApi;\n  get sitesApi(): SitesApi {\n    this._sitesApi = this._sitesApi ?? new SitesApi(this.api.getInstance());\n    return this._sitesApi;\n  }\n\n  private _searchApi: SearchApi;\n  get searchApi(): SearchApi {\n    this._searchApi = this._searchApi ?? new SearchApi(this.api.getInstance());\n    return this._searchApi;\n  }\n\n  private _peopleApi: PeopleApi;\n  get peopleApi(): PeopleApi {\n    this._peopleApi = this._peopleApi ?? new PeopleApi(this.api.getInstance());\n    return this._peopleApi;\n  }\n\n  private _versionsApi: VersionsApi;\n  get versionsApi(): VersionsApi {\n    this._versionsApi = this._versionsApi ?? new VersionsApi(this.api.getInstance());\n    return this._versionsApi;\n  }\n  constructor(private api: AlfrescoApiService, private preferences: UserPreferencesService) {}\n\n  /**\n   * Moves a node to the trashcan.\n   *\n   * @param nodeId ID of the target node\n   * @param options Optional parameters supported by JS-API\n   * @returns Empty result that notifies when the deletion is complete\n   */\n  deleteNode(nodeId: string, options: { permanent?: boolean } = {}): Observable<void> {\n    return from(this.nodesApi.deleteNode(nodeId, options));\n  }\n\n  /**\n   * Gets the stored information about a node.\n   *\n   * @param nodeId ID of the target node\n   * @param options Optional parameters supported by JS-API\n   * @returns Node information\n   */\n  getNode(nodeId: string, options: any = {}): Observable<NodeEntry> {\n    const defaults = {\n      include: ['path', 'properties', 'allowableOperations', 'permissions', 'definition']\n    };\n    const queryOptions = Object.assign(defaults, options);\n\n    return from(this.nodesApi.getNode(nodeId, queryOptions));\n  }\n\n  getNodeInfo(nodeId: string, options?: any): Observable<Node> {\n    const defaults = {\n      include: ['isFavorite', 'allowableOperations', 'path', 'definition']\n    };\n    const queryOptions = Object.assign(defaults, options || {});\n\n    return from(\n      new Promise<Node>((resolve, reject) => {\n        this.nodesApi.getNode(nodeId, queryOptions).then(\n          (nodeEntry: NodeEntry) => {\n            resolve(nodeEntry.entry);\n          },\n          (error) => {\n            reject(error);\n          }\n        );\n      })\n    );\n  }\n\n  /**\n   * Gets the items contained in a folder node.\n   *\n   * @param nodeId ID of the target node\n   * @param options Optional parameters supported by JS-API\n   * @returns List of child items from the folder\n   */\n  getNodeChildren(nodeId: string, options: any = {}): Observable<NodePaging> {\n    const defaults = {\n      maxItems: this.preferences.paginationSize,\n      skipCount: 0,\n      include: ['isLocked', 'path', 'properties', 'allowableOperations', 'permissions']\n    };\n    const queryOptions = Object.assign(defaults, options);\n\n    return from(this.nodesApi.listNodeChildren(nodeId, queryOptions));\n  }\n\n  deleteSharedLink(linkId: string): Observable<any> {\n    return from(this.sharedLinksApi.deleteSharedLink(linkId));\n  }\n\n  getDeletedNodes(options: any = {}): Observable<DeletedNodesPaging> {\n    const defaults = {\n      include: ['path']\n    };\n    const queryOptions = Object.assign(defaults, options);\n\n    return from(this.trashcanApi.listDeletedNodes(queryOptions));\n  }\n\n  restoreNode(nodeId: string): Observable<NodeEntry> {\n    return from(this.trashcanApi.restoreDeletedNode(nodeId));\n  }\n\n  purgeDeletedNode(nodeId: string): Observable<any> {\n    return from(this.trashcanApi.deleteDeletedNode(nodeId));\n  }\n\n  /**\n   * Gets information about a user identified by their username.\n   *\n   * @param personId ID of the target user\n   * @param options Api options\n   * @returns User information\n   */\n  getPerson(personId: string, options?: { fields?: Array<string> }): Observable<PersonEntry> {\n    return from(this.peopleApi.getPerson(personId, options));\n  }\n\n  /**\n   * Copy a node to destination node\n   *\n   * @param nodeId The id of the node to be copied\n   * @param targetParentId The id of the folder-node where the node have to be copied to\n   * @param name The new name for the copy that would be added on the destination folder\n   * @param opts Api options\n   */\n  copyNode(nodeId: string, targetParentId: string, name?: string, opts?: { include?: Array<string>; fields?: Array<string> }): Observable<NodeEntry> {\n    return from(this.nodesApi.copyNode(nodeId, { targetParentId, name }, opts));\n  }\n\n  /**\n   * Gets product information for Content Services.\n   *\n   * @returns ProductVersionModel containing product details\n   */\n  getRepositoryInformation(): Observable<DiscoveryEntry> {\n    return from(this.discoveryApi.getRepositoryInformation());\n  }\n\n  getFavorites(\n    personId: string,\n    opts?: {\n      skipCount?: number;\n      maxItems?: number;\n      where?: string;\n      fields?: Array<string>;\n    }\n  ): Observable<FavoritePaging> {\n    return from(this.favoritesApi.listFavorites(personId, opts));\n  }\n\n  getFavoriteLibraries(personId: string = '-me-', opts?: any): Observable<FavoritePaging> {\n    return this.getFavorites(personId, {\n      ...opts,\n      where: '(EXISTS(target/site))'\n    }).pipe(\n      map((response: FavoritePaging) => ({\n        list: {\n          entries: response.list.entries.map(({ entry }: any) => {\n            entry.target.site.createdAt = entry.createdAt;\n            return {\n              entry: entry.target.site\n            };\n          }),\n          pagination: response.list.pagination\n        }\n      }))\n    );\n  }\n\n  findSharedLinks(opts?: any): Observable<SharedLinkPaging> {\n    return from(this.sharedLinksApi.listSharedLinks(opts));\n  }\n\n  getSharedLinkContent(sharedId: string, attachment?: boolean): string {\n    return this.contentApi.getSharedLinkContentUrl(sharedId, attachment);\n  }\n\n  search(request: SearchRequest): Observable<ResultSetPaging> {\n    return from(this.searchApi.search(request));\n  }\n\n  getContentUrl(nodeId: string, attachment?: boolean): string {\n    return this.contentApi.getContentUrl(nodeId, attachment);\n  }\n\n  getVersionContentUrl(nodeId: string, versionId: string, attachment?: boolean): string {\n    return this.contentApi.getVersionContentUrl(nodeId, versionId, attachment);\n  }\n\n  deleteSite(siteId?: string, opts?: { permanent?: boolean }): Observable<any> {\n    return from(this.sitesApi.deleteSite(siteId, opts));\n  }\n\n  leaveSite(siteId?: string): Observable<any> {\n    return from(this.sitesApi.deleteSiteMembership(siteId, '-me-'));\n  }\n\n  createSite(\n    siteBody: SiteBodyCreate,\n    opts?: {\n      fields?: Array<string>;\n      skipConfiguration?: boolean;\n      skipAddToFavorites?: boolean;\n    }\n  ): Observable<SiteEntry> {\n    return from(this.sitesApi.createSite(siteBody, opts));\n  }\n\n  getSite(siteId?: string, opts?: { relations?: Array<string>; fields?: Array<string> }): Observable<SiteEntry> {\n    return from(this.sitesApi.getSite(siteId, opts));\n  }\n\n  updateLibrary(siteId: string, siteBody: SiteBodyCreate): Observable<SiteEntry> {\n    return from(this.sitesApi.updateSite(siteId, siteBody));\n  }\n\n  addFavorite(nodes: Array<NodeEntry>): Observable<FavoriteEntry> {\n    const payload: FavoriteBodyCreate[] = nodes.map((node) => {\n      const { isFolder, nodeId, id } = node.entry as any;\n      const siteId = node.entry['guid'];\n      const type = siteId ? 'site' : isFolder ? 'folder' : 'file';\n      const guid = siteId || nodeId || id;\n\n      return {\n        target: {\n          [type]: {\n            guid\n          }\n        }\n      };\n    });\n\n    return from(this.favoritesApi.createFavorite('-me-', payload as any));\n  }\n\n  removeFavorite(nodes: Array<NodeEntry>): Observable<any> {\n    return from(\n      Promise.all(\n        nodes.map((node: any) => {\n          const id = node.entry.nodeId || node.entry.id;\n          return this.favoritesApi.deleteFavorite('-me-', id);\n        })\n      )\n    );\n  }\n\n  unlockNode(nodeId: string, opts?: any): Promise<NodeEntry> {\n    return this.nodesApi.unlockNode(nodeId, opts);\n  }\n\n  getNodeVersions(nodeId: string, opts?: any): Observable<VersionPaging> {\n    return from(this.versionsApi.listVersionHistory(nodeId, opts));\n  }\n\n  requestNodeDirectAccessUrl(nodeId: string): Observable<DirectAccessUrlEntry> {\n    return from(this.nodesApi.requestDirectAccessUrl(nodeId));\n  }\n\n  requestVersionDirectAccessUrl(nodeId: string, versionId: string): Observable<DirectAccessUrlEntry> {\n    return from(this.versionsApi.requestDirectAccessUrl(nodeId, versionId));\n  }\n}\n"]}

package/esm2022/lib/services/navigation-history.service.mjs

@@ -0,0 +1,55 @@
+/*!
+ * 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 { NavigationEnd, Router } from '@angular/router';
+import { filter, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+class NavigationHistoryService {
+    router;
+    history = [];
+    constructor(router) {
+        this.router = router;
+    }
+    listenToRouteChanges() {
+        return this.router.events.pipe(startWith(new NavigationEnd(0, this.router.url, this.router.url)), filter((event) => event instanceof NavigationEnd));
+    }
+    shouldReturnLastSelection(url) {
+        return this.history.length > 2 && this.history[1].startsWith(url) && this.history[0] === this.history[2];
+    }
+    setHistory(event, maxHistoryLength) {
+        this.history.push(event.urlAfterRedirects);
+        if (maxHistoryLength > 0 && this.history.length > maxHistoryLength) {
+            this.history.shift();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NavigationHistoryService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NavigationHistoryService, providedIn: 'root' });
+}
+export { NavigationHistoryService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NavigationHistoryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,88 @@
+/*!
+ * 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 * as i0 from "@angular/core";
+class NodePermissionService {
+    static DEFAULT_OPERATION = 'OR';
+    defaultOptions = {
+        operation: NodePermissionService.DEFAULT_OPERATION,
+        target: null
+    };
+    check(source, permissions, options) {
+        const opts = Object.assign({}, this.defaultOptions, options || {});
+        if (!source) {
+            return false;
+        }
+        if (Array.isArray(source)) {
+            source = source.filter((item) => item);
+            if (source.length > 0) {
+                return source.every((node) => this.isOperationAllowed(node, permissions, opts));
+            }
+            return false;
+        }
+        else {
+            return this.isOperationAllowed(source, permissions, opts);
+        }
+    }
+    isOperationAllowed(node, permissions, options) {
+        const allowableOperations = this.getAllowableOperations(node, options.target);
+        if (allowableOperations.length) {
+            if (options.operation === NodePermissionService.DEFAULT_OPERATION) {
+                return permissions.some((permission) => allowableOperations.includes(permission));
+            }
+            else {
+                return permissions.every((permission) => allowableOperations.includes(permission));
+            }
+        }
+        return false;
+    }
+    getAllowableOperations(node, property) {
+        let entry;
+        if ('entry' in node) {
+            entry = node.entry;
+        }
+        else {
+            entry = node;
+        }
+        if (property) {
+            return entry[property] || [];
+        }
+        if ('allowableOperationsOnTarget' in entry) {
+            return entry.allowableOperationsOnTarget || [];
+        }
+        else {
+            return entry.allowableOperations || [];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodePermissionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodePermissionService, providedIn: 'root' });
+}
+export { NodePermissionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: NodePermissionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,108 @@
+/*!
+ * 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 { ExtensionService } from '@alfresco/adf-extensions';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@alfresco/adf-extensions";
+class RouterExtensionService {
+    router;
+    extensions;
+    defaults = {
+        layout: 'app.layout.main',
+        auth: ['app.auth']
+    };
+    constructor(router, extensions) {
+        this.router = router;
+        this.extensions = extensions;
+    }
+    mapExtensionRoutes() {
+        const routesWithoutParent = [];
+        this.getApplicationRoutes().forEach((extensionRoute) => {
+            if (this.extensionRouteHasChild(extensionRoute)) {
+                const parentRoute = this.findRoute(extensionRoute.parentRoute);
+                if (parentRoute) {
+                    this.convertExtensionRouteToRoute(extensionRoute);
+                    parentRoute.children.unshift(extensionRoute);
+                }
+            }
+            else {
+                routesWithoutParent.push(extensionRoute);
+            }
+        });
+        this.router.config.unshift(...routesWithoutParent);
+    }
+    getApplicationRoutes() {
+        return this.extensions.routes.map((route) => {
+            const guards = this.extensions.getAuthGuards(route.auth && route.auth.length > 0 ? route.auth : this.defaults.auth);
+            return {
+                path: route.path,
+                component: this.getComponentById(route.layout ?? this.defaults.layout),
+                canActivateChild: guards,
+                canActivate: guards,
+                parentRoute: route.parentRoute,
+                children: [
+                    ...(route['children']
+                        ? route['children'].map(({ path, component, outlet, data }) => ({
+                            path,
+                            outlet,
+                            data,
+                            component: this.getComponentById(component)
+                        }))
+                        : []),
+                    {
+                        path: '',
+                        component: this.getComponentById(route.component),
+                        data: route.data
+                    }
+                ]
+            };
+        });
+    }
+    getComponentById(id) {
+        return this.extensions.getComponentById(id);
+    }
+    extensionRouteHasChild(route) {
+        return route.parentRoute !== undefined;
+    }
+    convertExtensionRouteToRoute(extensionRoute) {
+        delete extensionRoute.parentRoute;
+        delete extensionRoute.component;
+    }
+    findRoute(parentRoute) {
+        const routeIndex = this.router.config.findIndex((route) => route.path === parentRoute);
+        return this.router.config[routeIndex];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: RouterExtensionService, deps: [{ token: i1.Router }, { token: i2.ExtensionService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: RouterExtensionService, providedIn: 'root' });
+}
+export { RouterExtensionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: RouterExtensionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.ExtensionService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.extension.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/src/lib/services/router.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, Type } from '@angular/core';\nimport { ExtensionService } from '@alfresco/adf-extensions';\nimport { ExtensionRoute } from '../models/types';\nimport { Router } from '@angular/router';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class RouterExtensionService {\n  defaults = {\n    layout: 'app.layout.main',\n    auth: ['app.auth']\n  };\n\n  constructor(private router: Router, protected extensions: ExtensionService) {}\n\n  mapExtensionRoutes() {\n    const routesWithoutParent = [];\n    this.getApplicationRoutes().forEach((extensionRoute: ExtensionRoute) => {\n      if (this.extensionRouteHasChild(extensionRoute)) {\n        const parentRoute = this.findRoute(extensionRoute.parentRoute);\n        if (parentRoute) {\n          this.convertExtensionRouteToRoute(extensionRoute);\n          parentRoute.children.unshift(extensionRoute);\n        }\n      } else {\n        routesWithoutParent.push(extensionRoute);\n      }\n    });\n\n    this.router.config.unshift(...routesWithoutParent);\n  }\n\n  public getApplicationRoutes(): Array<ExtensionRoute> {\n    return this.extensions.routes.map((route) => {\n      const guards = this.extensions.getAuthGuards(route.auth && route.auth.length > 0 ? route.auth : this.defaults.auth);\n\n      return {\n        path: route.path,\n        component: this.getComponentById(route.layout ?? this.defaults.layout),\n        canActivateChild: guards,\n        canActivate: guards,\n        parentRoute: route.parentRoute,\n        children: [\n          ...(route['children']\n            ? route['children'].map(({ path, component, outlet, data }) => ({\n                path,\n                outlet,\n                data,\n                component: this.getComponentById(component)\n              }))\n            : []),\n          {\n            path: '',\n            component: this.getComponentById(route.component),\n            data: route.data\n          }\n        ]\n      };\n    });\n  }\n\n  private getComponentById(id: string): Type<unknown> {\n    return this.extensions.getComponentById(id);\n  }\n\n  private extensionRouteHasChild(route: ExtensionRoute): boolean {\n    return route.parentRoute !== undefined;\n  }\n\n  private convertExtensionRouteToRoute(extensionRoute: ExtensionRoute) {\n    delete extensionRoute.parentRoute;\n    delete extensionRoute.component;\n  }\n\n  private findRoute(parentRoute) {\n    const routeIndex = this.router.config.findIndex((route) => route.path === parentRoute);\n\n    return this.router.config[routeIndex];\n  }\n}\n"]}