@alfresco/adf-content-services 8.1.0-15972188736 → 8.1.0-15979090800

package/esm2022/lib/common/services/rendition.service.mjs

@@ -0,0 +1,270 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { ContentApi, RenditionsApi, VersionsApi } from '@alfresco/js-api';
+import { TranslationService, ViewUtilService } from '@alfresco/adf-core';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export class RenditionService {
+    static { this.TARGET = '_new'; }
+    /**
+     * Content groups based on categorization of files that can be viewed in the web browser. This
+     * implementation or grouping is tied to the definition the ng component: ViewerRenderComponent
+     */
+    static { this.ContentGroup = {
+        IMAGE: 'image',
+        MEDIA: 'media',
+        PDF: 'pdf',
+        TEXT: 'text'
+    }; }
+    /**
+     * The name of the rendition with the media subtitles in the supported format
+     */
+    static { this.SUBTITLES_RENDITION_NAME = 'webvtt'; }
+    get renditionsApi() {
+        this._renditionsApi = this._renditionsApi ?? new RenditionsApi(this.apiService.getInstance());
+        return this._renditionsApi;
+    }
+    get contentApi() {
+        this._contentApi = this._contentApi ?? new ContentApi(this.apiService.getInstance());
+        return this._contentApi;
+    }
+    get versionsApi() {
+        this._versionsApi = this._versionsApi ?? new VersionsApi(this.apiService.getInstance());
+        return this._versionsApi;
+    }
+    constructor(apiService, translateService, viewUtilsService) {
+        this.apiService = apiService;
+        this.translateService = translateService;
+        this.viewUtilsService = viewUtilsService;
+        /**
+         * Based on ViewerRenderComponent Implementation, this value is used to determine how many times we try
+         * to get the rendition of a file for preview, or printing.
+         */
+        this.maxRetries = 5;
+        /**
+         * Timeout used for setInterval.
+         */
+        this.TRY_TIMEOUT = 10000;
+        this.DEFAULT_RENDITION = 'imgpreview';
+    }
+    getRenditionUrl(nodeId, type, renditionExists) {
+        return renditionExists && type !== RenditionService.ContentGroup.IMAGE
+            ? this.contentApi.getRenditionUrl(nodeId, RenditionService.ContentGroup.PDF)
+            : this.contentApi.getContentUrl(nodeId, false);
+    }
+    async waitRendition(nodeId, renditionId, retries) {
+        if (this.maxRetries > retries) {
+            const rendition = await this.renditionsApi.getRendition(nodeId, renditionId);
+            const status = rendition.entry.status.toString();
+            if (status === 'CREATED') {
+                return rendition;
+            }
+            else {
+                retries += 1;
+                await this.wait(1000);
+                return this.waitRendition(nodeId, renditionId, retries);
+            }
+        }
+        return Promise.resolve(null);
+    }
+    wait(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async getRendition(nodeId, renditionId) {
+        const renditionPaging = await this.renditionsApi.listRenditions(nodeId);
+        let rendition = renditionPaging.list.entries.find((renditionEntry) => renditionEntry.entry.id.toLowerCase() === renditionId);
+        if (rendition) {
+            const status = rendition.entry.status.toString();
+            if (status === 'NOT_CREATED') {
+                try {
+                    await this.renditionsApi.createRendition(nodeId, { id: renditionId });
+                    rendition = await this.waitRendition(nodeId, renditionId, 0);
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        return new Promise((resolve) => resolve(rendition));
+    }
+    async getNodeRendition(nodeId, versionId) {
+        try {
+            return versionId ? await this.resolveNodeRendition(nodeId, 'pdf', versionId) : await this.resolveNodeRendition(nodeId, 'pdf');
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolveNodeRendition(nodeId, renditionId, versionId) {
+        renditionId = renditionId.toLowerCase();
+        const supportedRendition = versionId
+            ? await this.versionsApi.listVersionRenditions(nodeId, versionId)
+            : await this.renditionsApi.listRenditions(nodeId);
+        let rendition = this.findRenditionById(supportedRendition, renditionId);
+        if (!rendition) {
+            renditionId = this.DEFAULT_RENDITION;
+            rendition = this.findRenditionById(supportedRendition, this.DEFAULT_RENDITION);
+        }
+        if (rendition) {
+            const status = rendition.entry.status.toString();
+            const mimeType = rendition.entry.content.mimeType;
+            if (status === 'NOT_CREATED') {
+                return { url: await this.requestCreateRendition(nodeId, renditionId, versionId), mimeType };
+            }
+            else {
+                return { url: await this.handleNodeRendition(nodeId, renditionId, versionId), mimeType };
+            }
+        }
+        return null;
+    }
+    async requestCreateRendition(nodeId, renditionId, versionId) {
+        try {
+            if (versionId) {
+                await this.versionsApi.createVersionRendition(nodeId, versionId, { id: renditionId });
+            }
+            else {
+                await this.renditionsApi.createRendition(nodeId, { id: renditionId });
+            }
+            try {
+                return versionId ? await this.waitNodeRendition(nodeId, renditionId, versionId) : await this.waitNodeRendition(nodeId, renditionId);
+            }
+            catch (e) {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    findRenditionById(supportedRendition, renditionId) {
+        return supportedRendition.list.entries.find((renditionEntry) => renditionEntry.entry.id.toLowerCase() === renditionId);
+    }
+    async waitNodeRendition(nodeId, renditionId, versionId) {
+        let currentRetry = 0;
+        return new Promise((resolve, reject) => {
+            const intervalId = setInterval(() => {
+                currentRetry++;
+                if (this.maxRetries >= currentRetry) {
+                    if (versionId) {
+                        this.versionsApi.getVersionRendition(nodeId, versionId, renditionId).then((rendition) => {
+                            const status = rendition.entry.status.toString();
+                            if (status === 'CREATED') {
+                                clearInterval(intervalId);
+                                return resolve(this.handleNodeRendition(nodeId, rendition.entry.content.mimeType, versionId));
+                            }
+                        }, () => reject(new Error('Error geting version rendition')));
+                    }
+                    else {
+                        this.renditionsApi.getRendition(nodeId, renditionId).then((rendition) => {
+                            const status = rendition.entry.status.toString();
+                            if (status === 'CREATED') {
+                                clearInterval(intervalId);
+                                return resolve(this.handleNodeRendition(nodeId, renditionId, versionId));
+                            }
+                        }, () => reject(new Error('Error getting rendition')));
+                    }
+                }
+                else {
+                    clearInterval(intervalId);
+                    return reject(new Error('Error getting rendition'));
+                }
+            }, this.TRY_TIMEOUT);
+        });
+    }
+    async handleNodeRendition(nodeId, renditionId, versionId) {
+        return versionId
+            ? this.contentApi.getVersionRenditionUrl(nodeId, versionId, renditionId)
+            : this.contentApi.getRenditionUrl(nodeId, renditionId);
+    }
+    async generateMediaTracksRendition(nodeId) {
+        return this.isRenditionAvailable(nodeId, RenditionService.SUBTITLES_RENDITION_NAME)
+            .then((value) => {
+            const tracks = [];
+            if (value) {
+                tracks.push({
+                    kind: 'subtitles',
+                    src: this.contentApi.getRenditionUrl(nodeId, RenditionService.SUBTITLES_RENDITION_NAME),
+                    label: this.translateService.instant('ADF_VIEWER.SUBTITLES')
+                });
+            }
+            return tracks;
+        })
+            .catch(() => []);
+    }
+    async isRenditionAvailable(nodeId, renditionId) {
+        const renditionPaging = await this.renditionsApi.listRenditions(nodeId);
+        const rendition = renditionPaging.list.entries.find((renditionEntry) => renditionEntry.entry.id.toLowerCase() === renditionId);
+        return rendition?.entry?.status?.toString() === 'CREATED' || false;
+    }
+    /**
+     * This method takes a url to trigger the print dialog against, and the type of artifact that it
+     * is.
+     * This URL should be one that can be rendered in the browser, for example PDF, Image, or Text
+     *
+     * @param url url to print
+     * @param type type of the rendition
+     */
+    printFile(url, type) {
+        const pwa = window.open(url, RenditionService.TARGET);
+        if (pwa) {
+            pwa.onload = () => {
+                pwa.print();
+                if (type === RenditionService.ContentGroup.IMAGE) {
+                    // Because of the way chrome focus and close image window vs. pdf preview window
+                    setTimeout(() => {
+                        pwa.close();
+                    }, 500);
+                }
+            };
+        }
+    }
+    /**
+     * Launch the File Print dialog from anywhere other than the preview service, which resolves the
+     * rendition of the object that can be printed from a web browser.
+     * These are: images, PDF files, or PDF rendition of files.
+     * We also force PDF rendition for TEXT type objects, otherwise the default URL is to download.
+     * TODO there are different TEXT type objects, (HTML, plaintext, xml, etc. we should determine how these are handled)
+     *
+     * @param objectId object it
+     * @param mimeType mime type
+     */
+    printFileGeneric(objectId, mimeType) {
+        const nodeId = objectId;
+        const type = this.viewUtilsService.getViewerTypeByMimeType(mimeType);
+        this.getRendition(nodeId, RenditionService.ContentGroup.PDF)
+            .then((value) => {
+            const url = this.getRenditionUrl(nodeId, type, !!value);
+            const printType = type === RenditionService.ContentGroup.PDF || type === RenditionService.ContentGroup.TEXT
+                ? RenditionService.ContentGroup.PDF
+                : type;
+            this.printFile(url, printType);
+        })
+            .catch(() => { });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenditionService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.TranslationService }, { token: i2.ViewUtilService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenditionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenditionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.TranslationService }, { type: i2.ViewUtilService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rendition.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/rendition.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable } from '@angular/core';\nimport { ContentApi, RenditionEntry, RenditionPaging, RenditionsApi, VersionsApi } from '@alfresco/js-api';\nimport { Track, TranslationService, ViewUtilService } from '@alfresco/adf-core';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class RenditionService {\n    static TARGET = '_new';\n\n    /**\n     * Content groups based on categorization of files that can be viewed in the web browser. This\n     * implementation or grouping is tied to the definition the ng component: ViewerRenderComponent\n     */\n    static ContentGroup = {\n        IMAGE: 'image',\n        MEDIA: 'media',\n        PDF: 'pdf',\n        TEXT: 'text'\n    };\n\n    /**\n     * The name of the rendition with the media subtitles in the supported format\n     */\n    static SUBTITLES_RENDITION_NAME = 'webvtt';\n\n    /**\n     * Based on ViewerRenderComponent Implementation, this value is used to determine how many times we try\n     * to get the rendition of a file for preview, or printing.\n     */\n    maxRetries = 5;\n\n    /**\n     * Timeout used for setInterval.\n     */\n    private TRY_TIMEOUT: number = 10000;\n\n    _renditionsApi: RenditionsApi;\n    get renditionsApi(): RenditionsApi {\n        this._renditionsApi = this._renditionsApi ?? new RenditionsApi(this.apiService.getInstance());\n        return this._renditionsApi;\n    }\n\n    _contentApi: ContentApi;\n    get contentApi(): ContentApi {\n        this._contentApi = this._contentApi ?? new ContentApi(this.apiService.getInstance());\n        return this._contentApi;\n    }\n\n    _versionsApi: VersionsApi;\n    private DEFAULT_RENDITION: string = 'imgpreview';\n\n    get versionsApi(): VersionsApi {\n        this._versionsApi = this._versionsApi ?? new VersionsApi(this.apiService.getInstance());\n        return this._versionsApi;\n    }\n\n    constructor(private apiService: AlfrescoApiService, private translateService: TranslationService, private viewUtilsService: ViewUtilService) {}\n\n    getRenditionUrl(nodeId: string, type: string, renditionExists: boolean): string {\n        return renditionExists && type !== RenditionService.ContentGroup.IMAGE\n            ? this.contentApi.getRenditionUrl(nodeId, RenditionService.ContentGroup.PDF)\n            : this.contentApi.getContentUrl(nodeId, false);\n    }\n\n    private async waitRendition(nodeId: string, renditionId: string, retries: number): Promise<RenditionEntry> {\n        if (this.maxRetries > retries) {\n            const rendition = await this.renditionsApi.getRendition(nodeId, renditionId);\n            const status = rendition.entry.status.toString();\n\n            if (status === 'CREATED') {\n                return rendition;\n            } else {\n                retries += 1;\n                await this.wait(1000);\n                return this.waitRendition(nodeId, renditionId, retries);\n            }\n        }\n\n        return Promise.resolve(null);\n    }\n\n    private wait(ms: number): Promise<any> {\n        return new Promise((resolve) => setTimeout(resolve, ms));\n    }\n\n    async getRendition(nodeId: string, renditionId: string): Promise<RenditionEntry> {\n        const renditionPaging: RenditionPaging = await this.renditionsApi.listRenditions(nodeId);\n        let rendition: RenditionEntry = renditionPaging.list.entries.find(\n            (renditionEntry: RenditionEntry) => renditionEntry.entry.id.toLowerCase() === renditionId\n        );\n\n        if (rendition) {\n            const status = rendition.entry.status.toString();\n\n            if (status === 'NOT_CREATED') {\n                try {\n                    await this.renditionsApi.createRendition(nodeId, { id: renditionId });\n                    rendition = await this.waitRendition(nodeId, renditionId, 0);\n                } catch {\n                    return null;\n                }\n            }\n        }\n        return new Promise<RenditionEntry>((resolve) => resolve(rendition));\n    }\n\n    async getNodeRendition(nodeId: string, versionId?: string): Promise<{ url: string; mimeType: string }> {\n        try {\n            return versionId ? await this.resolveNodeRendition(nodeId, 'pdf', versionId) : await this.resolveNodeRendition(nodeId, 'pdf');\n        } catch {\n            return null;\n        }\n    }\n\n    private async resolveNodeRendition(nodeId: string, renditionId: string, versionId?: string): Promise<{ url: string; mimeType: string }> {\n        renditionId = renditionId.toLowerCase();\n\n        const supportedRendition: RenditionPaging = versionId\n            ? await this.versionsApi.listVersionRenditions(nodeId, versionId)\n            : await this.renditionsApi.listRenditions(nodeId);\n\n        let rendition = this.findRenditionById(supportedRendition, renditionId);\n        if (!rendition) {\n            renditionId = this.DEFAULT_RENDITION;\n            rendition = this.findRenditionById(supportedRendition, this.DEFAULT_RENDITION);\n        }\n\n        if (rendition) {\n            const status: string = rendition.entry.status.toString();\n            const mimeType: string = rendition.entry.content.mimeType;\n\n            if (status === 'NOT_CREATED') {\n                return { url: await this.requestCreateRendition(nodeId, renditionId, versionId), mimeType };\n            } else {\n                return { url: await this.handleNodeRendition(nodeId, renditionId, versionId), mimeType };\n            }\n        }\n\n        return null;\n    }\n\n    private async requestCreateRendition(nodeId: string, renditionId: string, versionId: string): Promise<string> {\n        try {\n            if (versionId) {\n                await this.versionsApi.createVersionRendition(nodeId, versionId, { id: renditionId });\n            } else {\n                await this.renditionsApi.createRendition(nodeId, { id: renditionId });\n            }\n            try {\n                return versionId ? await this.waitNodeRendition(nodeId, renditionId, versionId) : await this.waitNodeRendition(nodeId, renditionId);\n            } catch (e) {\n                return null;\n            }\n        } catch {\n            return null;\n        }\n    }\n\n    private findRenditionById(supportedRendition: RenditionPaging, renditionId: string) {\n        return supportedRendition.list.entries.find((renditionEntry: RenditionEntry) => renditionEntry.entry.id.toLowerCase() === renditionId);\n    }\n\n    private async waitNodeRendition(nodeId: string, renditionId: string, versionId?: string): Promise<string> {\n        let currentRetry: number = 0;\n        return new Promise<string>((resolve, reject) => {\n            const intervalId = setInterval(() => {\n                currentRetry++;\n                if (this.maxRetries >= currentRetry) {\n                    if (versionId) {\n                        this.versionsApi.getVersionRendition(nodeId, versionId, renditionId).then(\n                            (rendition: RenditionEntry) => {\n                                const status: string = rendition.entry.status.toString();\n\n                                if (status === 'CREATED') {\n                                    clearInterval(intervalId);\n                                    return resolve(this.handleNodeRendition(nodeId, rendition.entry.content.mimeType, versionId));\n                                }\n                            },\n                            () => reject(new Error('Error geting version rendition'))\n                        );\n                    } else {\n                        this.renditionsApi.getRendition(nodeId, renditionId).then(\n                            (rendition: RenditionEntry) => {\n                                const status: string = rendition.entry.status.toString();\n\n                                if (status === 'CREATED') {\n                                    clearInterval(intervalId);\n                                    return resolve(this.handleNodeRendition(nodeId, renditionId, versionId));\n                                }\n                            },\n                            () => reject(new Error('Error getting rendition'))\n                        );\n                    }\n                } else {\n                    clearInterval(intervalId);\n                    return reject(new Error('Error getting rendition'));\n                }\n            }, this.TRY_TIMEOUT);\n        });\n    }\n\n    private async handleNodeRendition(nodeId: string, renditionId: string, versionId?: string): Promise<string> {\n        return versionId\n            ? this.contentApi.getVersionRenditionUrl(nodeId, versionId, renditionId)\n            : this.contentApi.getRenditionUrl(nodeId, renditionId);\n    }\n\n    async generateMediaTracksRendition(nodeId: string): Promise<Track[]> {\n        return this.isRenditionAvailable(nodeId, RenditionService.SUBTITLES_RENDITION_NAME)\n            .then((value) => {\n                const tracks = [];\n                if (value) {\n                    tracks.push({\n                        kind: 'subtitles',\n                        src: this.contentApi.getRenditionUrl(nodeId, RenditionService.SUBTITLES_RENDITION_NAME),\n                        label: this.translateService.instant('ADF_VIEWER.SUBTITLES')\n                    });\n                }\n                return tracks;\n            })\n            .catch(() => []);\n    }\n\n    private async isRenditionAvailable(nodeId: string, renditionId: string): Promise<boolean> {\n        const renditionPaging: RenditionPaging = await this.renditionsApi.listRenditions(nodeId);\n        const rendition: RenditionEntry = renditionPaging.list.entries.find(\n            (renditionEntry: RenditionEntry) => renditionEntry.entry.id.toLowerCase() === renditionId\n        );\n\n        return rendition?.entry?.status?.toString() === 'CREATED' || false;\n    }\n\n    /**\n     * This method takes a url to trigger the print dialog against, and the type of artifact that it\n     * is.\n     * This URL should be one that can be rendered in the browser, for example PDF, Image, or Text\n     *\n     * @param url url to print\n     * @param type type of the rendition\n     */\n    printFile(url: string, type: string): void {\n        const pwa = window.open(url, RenditionService.TARGET);\n        if (pwa) {\n            pwa.onload = () => {\n                pwa.print();\n                if (type === RenditionService.ContentGroup.IMAGE) {\n                    // Because of the way chrome focus and close image window vs. pdf preview window\n                    setTimeout(() => {\n                        pwa.close();\n                    }, 500);\n                }\n            };\n        }\n    }\n\n    /**\n     * Launch the File Print dialog from anywhere other than the preview service, which resolves the\n     * rendition of the object that can be printed from a web browser.\n     * These are: images, PDF files, or PDF rendition of files.\n     * We also force PDF rendition for TEXT type objects, otherwise the default URL is to download.\n     * TODO there are different TEXT type objects, (HTML, plaintext, xml, etc. we should determine how these are handled)\n     *\n     * @param objectId object it\n     * @param mimeType mime type\n     */\n    printFileGeneric(objectId: string, mimeType: string): void {\n        const nodeId = objectId;\n        const type: string = this.viewUtilsService.getViewerTypeByMimeType(mimeType);\n\n        this.getRendition(nodeId, RenditionService.ContentGroup.PDF)\n            .then((value) => {\n                const url: string = this.getRenditionUrl(nodeId, type, !!value);\n                const printType =\n                    type === RenditionService.ContentGroup.PDF || type === RenditionService.ContentGroup.TEXT\n                        ? RenditionService.ContentGroup.PDF\n                        : type;\n                this.printFile(url, printType);\n            })\n            .catch(() => {});\n    }\n}\n"]}

package/esm2022/lib/common/services/saved-searches.service.mjs

@@ -0,0 +1,206 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NodesApi, PreferencesApi } from '@alfresco/js-api';
+import { inject, Injectable, InjectionToken } from '@angular/core';
+import { of, from, ReplaySubject, throwError } from 'rxjs';
+import { catchError, concatMap, first, map, switchMap, take, tap } from 'rxjs/operators';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { AuthenticationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+import * as i2 from "@alfresco/adf-core";
+export const SAVED_SEARCHES_SERVICE_PREFERENCES = new InjectionToken('SAVED_SEARCHES_SERVICE_PREFERENCES');
+export class SavedSearchesService {
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    get preferencesApi() {
+        if (this.preferencesService) {
+            this._preferencesApi = this.preferencesService;
+            return this._preferencesApi;
+        }
+        this._preferencesApi = this._preferencesApi ?? new PreferencesApi(this.apiService.getInstance());
+        return this._preferencesApi;
+    }
+    constructor(apiService, authService) {
+        this.apiService = apiService;
+        this.authService = authService;
+        this.preferencesService = inject(SAVED_SEARCHES_SERVICE_PREFERENCES, { optional: true });
+        this.savedSearches$ = new ReplaySubject(1);
+    }
+    init() {
+        this.fetchSavedSearches();
+    }
+    /**
+     * Gets a list of saved searches by user.
+     *
+     * @returns SavedSearch list containing user saved searches
+     */
+    getSavedSearches() {
+        const savedSearchesMigrated = localStorage.getItem(this.getLocalStorageKey()) ?? '';
+        if (savedSearchesMigrated === 'true') {
+            return from(this.preferencesApi.getPreference('-me-', 'saved-searches')).pipe(map((preference) => JSON.parse(preference.entry.value)), catchError(() => of([])));
+        }
+        else {
+            return this.getSavedSearchesNodeId().pipe(take(1), concatMap(() => {
+                if (this.savedSearchFileNodeId !== '') {
+                    return this.migrateSavedSearches();
+                }
+                else {
+                    return from(this.preferencesApi.getPreference('-me-', 'saved-searches')).pipe(map((preference) => JSON.parse(preference.entry.value)), catchError(() => of([])));
+                }
+            }));
+        }
+    }
+    /**
+     * Saves a new search into state and updates state. If there are less than 5 searches,
+     * it will be pushed on first place, if more it will be pushed to 6th place.
+     *
+     * @param newSaveSearch object { name: string, description: string, encodedUrl: string }
+     * @returns NodeEntry
+     */
+    saveSearch(newSaveSearch) {
+        return this.getSavedSearches().pipe(take(1), switchMap((savedSearches) => {
+            let updatedSavedSearches = [];
+            if (savedSearches.length < 5) {
+                updatedSavedSearches = [{ ...newSaveSearch, order: 0 }, ...savedSearches];
+            }
+            else {
+                const firstFiveSearches = savedSearches.slice(0, 5);
+                const restOfSearches = savedSearches.slice(5);
+                updatedSavedSearches = [...firstFiveSearches, { ...newSaveSearch, order: 5 }, ...restOfSearches];
+            }
+            updatedSavedSearches = updatedSavedSearches.map((search, index) => ({
+                ...search,
+                order: index
+            }));
+            return from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSavedSearches))).pipe(map((preference) => JSON.parse(preference.entry.value)), tap(() => this.savedSearches$.next(updatedSavedSearches)));
+        }), catchError((error) => {
+            console.error('Error saving new search:', error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Replace Save Search with new one and also updates the state.
+     *
+     * @param updatedSavedSearch - updated Save Search
+     * @returns NodeEntry
+     */
+    editSavedSearch(updatedSavedSearch) {
+        let previousSavedSearches;
+        return this.savedSearches$.pipe(take(1), map((savedSearches) => {
+            previousSavedSearches = [...savedSearches];
+            return savedSearches.map((search) => (search.order === updatedSavedSearch.order ? updatedSavedSearch : search));
+        }), tap((updatedSearches) => {
+            this.savedSearches$.next(updatedSearches);
+        }), switchMap((updatedSearches) => from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSearches))).pipe(map((preference) => JSON.parse(preference.entry.value)))), catchError((error) => {
+            this.savedSearches$.next(previousSavedSearches);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Deletes Save Search and update state.
+     *
+     * @param deletedSavedSearch - Save Search to delete
+     * @returns NodeEntry
+     */
+    deleteSavedSearch(deletedSavedSearch) {
+        let previousSavedSearchesOrder;
+        return this.savedSearches$.pipe(take(1), map((savedSearches) => {
+            previousSavedSearchesOrder = [...savedSearches];
+            const updatedSearches = savedSearches.filter((search) => search.order !== deletedSavedSearch.order);
+            return updatedSearches.map((search, index) => ({
+                ...search,
+                order: index
+            }));
+        }), tap((updatedSearches) => {
+            this.savedSearches$.next(updatedSearches);
+        }), switchMap((updatedSearches) => from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSearches))).pipe(map((preference) => JSON.parse(preference.entry.value)))), catchError((error) => {
+            this.savedSearches$.next(previousSavedSearchesOrder);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Reorders saved search place
+     *
+     * @param previousIndex - previous index of saved search
+     * @param currentIndex - new index of saved search
+     */
+    changeOrder(previousIndex, currentIndex) {
+        let previousSavedSearchesOrder;
+        this.savedSearches$
+            .pipe(take(1), map((savedSearches) => {
+            previousSavedSearchesOrder = [...savedSearches];
+            const [movedSearch] = savedSearches.splice(previousIndex, 1);
+            savedSearches.splice(currentIndex, 0, movedSearch);
+            return savedSearches.map((search, index) => ({
+                ...search,
+                order: index
+            }));
+        }), tap((savedSearches) => this.savedSearches$.next(savedSearches)), switchMap((updatedSearches) => from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSearches))).pipe(map((preference) => JSON.parse(preference.entry.value)))), catchError((error) => {
+            this.savedSearches$.next(previousSavedSearchesOrder);
+            return throwError(() => error);
+        }))
+            .subscribe();
+    }
+    getSavedSearchesNodeId() {
+        return from(this.nodesApi.getNode('-my-', { relativePath: 'config.json' })).pipe(first(), concatMap((configNode) => {
+            this.savedSearchFileNodeId = configNode.entry.id;
+            return configNode.entry.id;
+        }), catchError((error) => {
+            const errorStatusCode = JSON.parse(error.message).error.statusCode;
+            if (errorStatusCode === 404) {
+                localStorage.setItem(this.getLocalStorageKey(), 'true');
+                return '';
+            }
+            else {
+                return throwError(() => error);
+            }
+        }));
+    }
+    async mapFileContentToSavedSearches(blob) {
+        return blob
+            .text()
+            .then((content) => (content ? JSON.parse(content) : []))
+            .catch(() => []);
+    }
+    getLocalStorageKey() {
+        return `saved-searches-${this.authService.getUsername()}-migrated`;
+    }
+    fetchSavedSearches() {
+        this.getSavedSearches()
+            .pipe(take(1))
+            .subscribe((searches) => this.savedSearches$.next(searches));
+    }
+    migrateSavedSearches() {
+        return from(this.nodesApi.getNodeContent(this.savedSearchFileNodeId).then((content) => this.mapFileContentToSavedSearches(content))).pipe(tap((savedSearches) => {
+            this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(savedSearches));
+            localStorage.setItem(this.getLocalStorageKey(), 'true');
+            this.nodesApi.deleteNode(this.savedSearchFileNodeId, { permanent: true });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SavedSearchesService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.AuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SavedSearchesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SavedSearchesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.AuthenticationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"saved-searches.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/saved-searches.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { NodesApi, NodeEntry, PreferencesApi, ContentFieldsQuery, PreferenceEntry } from '@alfresco/js-api';\nimport { inject, Injectable, InjectionToken } from '@angular/core';\nimport { Observable, of, from, ReplaySubject, throwError } from 'rxjs';\nimport { catchError, concatMap, first, map, switchMap, take, tap } from 'rxjs/operators';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport { SavedSearch } from '../interfaces/saved-search.interface';\nimport { AuthenticationService } from '@alfresco/adf-core';\n\nexport interface SavedSearchesPreferencesApiService {\n    getPreference: (personId: string, preferenceName: string, opts?: ContentFieldsQuery) => Promise<PreferenceEntry> | Observable<PreferenceEntry>;\n    updatePreference: (personId: string, preferenceName: string, preferenceValue: string) => Promise<PreferenceEntry> | Observable<PreferenceEntry>;\n}\n\nexport const SAVED_SEARCHES_SERVICE_PREFERENCES = new InjectionToken<SavedSearchesPreferencesApiService>('SAVED_SEARCHES_SERVICE_PREFERENCES');\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SavedSearchesService {\n    private savedSearchFileNodeId: string;\n    private _nodesApi: NodesApi;\n    private _preferencesApi: SavedSearchesPreferencesApiService;\n    private preferencesService = inject(SAVED_SEARCHES_SERVICE_PREFERENCES, { optional: true });\n\n    get nodesApi(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());\n        return this._nodesApi;\n    }\n\n    get preferencesApi(): SavedSearchesPreferencesApiService {\n        if (this.preferencesService) {\n            this._preferencesApi = this.preferencesService;\n            return this._preferencesApi;\n        }\n\n        this._preferencesApi = this._preferencesApi ?? new PreferencesApi(this.apiService.getInstance());\n        return this._preferencesApi;\n    }\n\n    readonly savedSearches$ = new ReplaySubject<SavedSearch[]>(1);\n\n    constructor(private readonly apiService: AlfrescoApiService, private readonly authService: AuthenticationService) {}\n\n    init(): void {\n        this.fetchSavedSearches();\n    }\n\n    /**\n     * Gets a list of saved searches by user.\n     *\n     * @returns SavedSearch list containing user saved searches\n     */\n    getSavedSearches(): Observable<SavedSearch[]> {\n        const savedSearchesMigrated = localStorage.getItem(this.getLocalStorageKey()) ?? '';\n        if (savedSearchesMigrated === 'true') {\n            return from(this.preferencesApi.getPreference('-me-', 'saved-searches')).pipe(\n                map((preference) => JSON.parse(preference.entry.value)),\n                catchError(() => of([]))\n            );\n        } else {\n            return this.getSavedSearchesNodeId().pipe(\n                take(1),\n                concatMap(() => {\n                    if (this.savedSearchFileNodeId !== '') {\n                        return this.migrateSavedSearches();\n                    } else {\n                        return from(this.preferencesApi.getPreference('-me-', 'saved-searches')).pipe(\n                            map((preference) => JSON.parse(preference.entry.value)),\n                            catchError(() => of([]))\n                        );\n                    }\n                })\n            );\n        }\n    }\n\n    /**\n     * Saves a new search into state and updates state. If there are less than 5 searches,\n     * it will be pushed on first place, if more it will be pushed to 6th place.\n     *\n     * @param newSaveSearch object { name: string, description: string, encodedUrl: string }\n     * @returns NodeEntry\n     */\n    saveSearch(newSaveSearch: Pick<SavedSearch, 'name' | 'description' | 'encodedUrl'>): Observable<NodeEntry> {\n        return this.getSavedSearches().pipe(\n            take(1),\n            switchMap((savedSearches: SavedSearch[]) => {\n                let updatedSavedSearches: SavedSearch[] = [];\n\n                if (savedSearches.length < 5) {\n                    updatedSavedSearches = [{ ...newSaveSearch, order: 0 }, ...savedSearches];\n                } else {\n                    const firstFiveSearches = savedSearches.slice(0, 5);\n                    const restOfSearches = savedSearches.slice(5);\n\n                    updatedSavedSearches = [...firstFiveSearches, { ...newSaveSearch, order: 5 }, ...restOfSearches];\n                }\n\n                updatedSavedSearches = updatedSavedSearches.map((search, index) => ({\n                    ...search,\n                    order: index\n                }));\n\n                return from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSavedSearches))).pipe(\n                    map((preference) => JSON.parse(preference.entry.value)),\n                    tap(() => this.savedSearches$.next(updatedSavedSearches))\n                );\n            }),\n            catchError((error) => {\n                console.error('Error saving new search:', error);\n                return throwError(() => error);\n            })\n        );\n    }\n\n    /**\n     * Replace Save Search with new one and also updates the state.\n     *\n     * @param updatedSavedSearch - updated Save Search\n     * @returns NodeEntry\n     */\n    editSavedSearch(updatedSavedSearch: SavedSearch): Observable<NodeEntry> {\n        let previousSavedSearches: SavedSearch[];\n        return this.savedSearches$.pipe(\n            take(1),\n            map((savedSearches: SavedSearch[]) => {\n                previousSavedSearches = [...savedSearches];\n                return savedSearches.map((search) => (search.order === updatedSavedSearch.order ? updatedSavedSearch : search));\n            }),\n            tap((updatedSearches: SavedSearch[]) => {\n                this.savedSearches$.next(updatedSearches);\n            }),\n            switchMap((updatedSearches: SavedSearch[]) =>\n                from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSearches))).pipe(\n                    map((preference) => JSON.parse(preference.entry.value))\n                )\n            ),\n            catchError((error) => {\n                this.savedSearches$.next(previousSavedSearches);\n                return throwError(() => error);\n            })\n        );\n    }\n\n    /**\n     * Deletes Save Search and update state.\n     *\n     * @param deletedSavedSearch - Save Search to delete\n     * @returns NodeEntry\n     */\n    deleteSavedSearch(deletedSavedSearch: SavedSearch): Observable<NodeEntry> {\n        let previousSavedSearchesOrder: SavedSearch[];\n        return this.savedSearches$.pipe(\n            take(1),\n            map((savedSearches: SavedSearch[]) => {\n                previousSavedSearchesOrder = [...savedSearches];\n                const updatedSearches = savedSearches.filter((search) => search.order !== deletedSavedSearch.order);\n                return updatedSearches.map((search, index) => ({\n                    ...search,\n                    order: index\n                }));\n            }),\n            tap((updatedSearches: SavedSearch[]) => {\n                this.savedSearches$.next(updatedSearches);\n            }),\n            switchMap((updatedSearches: SavedSearch[]) =>\n                from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSearches))).pipe(\n                    map((preference) => JSON.parse(preference.entry.value))\n                )\n            ),\n            catchError((error) => {\n                this.savedSearches$.next(previousSavedSearchesOrder);\n                return throwError(() => error);\n            })\n        );\n    }\n\n    /**\n     * Reorders saved search place\n     *\n     * @param previousIndex - previous index of saved search\n     * @param currentIndex - new index of saved search\n     */\n    changeOrder(previousIndex: number, currentIndex: number): void {\n        let previousSavedSearchesOrder: SavedSearch[];\n        this.savedSearches$\n            .pipe(\n                take(1),\n                map((savedSearches: SavedSearch[]) => {\n                    previousSavedSearchesOrder = [...savedSearches];\n                    const [movedSearch] = savedSearches.splice(previousIndex, 1);\n                    savedSearches.splice(currentIndex, 0, movedSearch);\n                    return savedSearches.map((search, index) => ({\n                        ...search,\n                        order: index\n                    }));\n                }),\n                tap((savedSearches: SavedSearch[]) => this.savedSearches$.next(savedSearches)),\n                switchMap((updatedSearches: SavedSearch[]) =>\n                    from(this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(updatedSearches))).pipe(\n                        map((preference) => JSON.parse(preference.entry.value))\n                    )\n                ),\n                catchError((error) => {\n                    this.savedSearches$.next(previousSavedSearchesOrder);\n                    return throwError(() => error);\n                })\n            )\n            .subscribe();\n    }\n\n    private getSavedSearchesNodeId(): Observable<string> {\n        return from(this.nodesApi.getNode('-my-', { relativePath: 'config.json' })).pipe(\n            first(),\n            concatMap((configNode) => {\n                this.savedSearchFileNodeId = configNode.entry.id;\n                return configNode.entry.id;\n            }),\n            catchError((error) => {\n                const errorStatusCode = JSON.parse(error.message).error.statusCode;\n                if (errorStatusCode === 404) {\n                    localStorage.setItem(this.getLocalStorageKey(), 'true');\n                    return '';\n                } else {\n                    return throwError(() => error);\n                }\n            })\n        );\n    }\n\n    private async mapFileContentToSavedSearches(blob: Blob): Promise<Array<SavedSearch>> {\n        return blob\n            .text()\n            .then((content) => (content ? JSON.parse(content) : []))\n            .catch(() => []);\n    }\n\n    private getLocalStorageKey(): string {\n        return `saved-searches-${this.authService.getUsername()}-migrated`;\n    }\n\n    private fetchSavedSearches(): void {\n        this.getSavedSearches()\n            .pipe(take(1))\n            .subscribe((searches) => this.savedSearches$.next(searches));\n    }\n\n    private migrateSavedSearches(): Observable<SavedSearch[]> {\n        return from(this.nodesApi.getNodeContent(this.savedSearchFileNodeId).then((content) => this.mapFileContentToSavedSearches(content))).pipe(\n            tap((savedSearches) => {\n                this.preferencesApi.updatePreference('-me-', 'saved-searches', JSON.stringify(savedSearches));\n                localStorage.setItem(this.getLocalStorageKey(), 'true');\n                this.nodesApi.deleteNode(this.savedSearchFileNodeId, { permanent: true });\n            })\n        );\n    }\n}\n"]}