@alfresco/adf-core 8.1.0-16295066092 → 8.1.0-16320806191

package/esm2022/lib/viewer/directives/viewer-extension.directive.mjs

@@ -0,0 +1,67 @@
+/*!
+ * @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 { ContentChild, DestroyRef, Directive, inject, Input, TemplateRef } from '@angular/core';
+import { ViewerRenderComponent } from '../components/viewer-render/viewer-render.component';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../components/viewer-render/viewer-render.component";
+export class ViewerExtensionDirective {
+    constructor(viewerComponent) {
+        this.viewerComponent = viewerComponent;
+        this.destroyRef = inject(DestroyRef);
+    }
+    ngAfterContentInit() {
+        this.templateModel = { template: this.template, isVisible: false };
+        this.viewerComponent.extensionsSupportedByTemplates.push(...this.supportedExtensions);
+        this.viewerComponent.extensionTemplates.push(this.templateModel);
+        this.viewerComponent.extensionChange.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((fileExtension) => {
+            this.templateModel.isVisible = this.isVisible(fileExtension);
+        });
+    }
+    /**
+     * Check if the current extension in the viewer is compatible with this extension checking against `supportedExtensions`
+     *
+     * @param fileExtension file extension to check
+     * @returns `true` if file extension is compatible, otherwise `false`
+     */
+    isVisible(fileExtension) {
+        let supportedExtension;
+        if (this.supportedExtensions && this.supportedExtensions instanceof Array) {
+            supportedExtension = this.supportedExtensions.find((extension) => extension.toLowerCase() === fileExtension);
+        }
+        return !!supportedExtension;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ViewerExtensionDirective, deps: [{ token: i1.ViewerRenderComponent }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ViewerExtensionDirective, isStandalone: true, selector: "adf-viewer-extension", inputs: { urlFileContent: "urlFileContent", extension: "extension", supportedExtensions: "supportedExtensions" }, queries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ViewerExtensionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'adf-viewer-extension',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.ViewerRenderComponent }], propDecorators: { template: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }], urlFileContent: [{
+                type: Input
+            }], extension: [{
+                type: Input
+            }], supportedExtensions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/viewer/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL3ZpZXdlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/viewer/models/download-prompt.actions.mjs

@@ -0,0 +1,23 @@
+/*!
+ * @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.
+ */
+/* Enum listing the allowed actions that can be emitted from the NonResponsivePreview dialog component */
+export var DownloadPromptActions;
+(function (DownloadPromptActions) {
+    DownloadPromptActions[DownloadPromptActions["WAIT"] = 0] = "WAIT";
+    DownloadPromptActions[DownloadPromptActions["DOWNLOAD"] = 1] = "DOWNLOAD";
+})(DownloadPromptActions || (DownloadPromptActions = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG93bmxvYWQtcHJvbXB0LmFjdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL3ZpZXdlci9tb2RlbHMvZG93bmxvYWQtcHJvbXB0LmFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgseUdBQXlHO0FBQ3pHLE1BQU0sQ0FBTixJQUFZLHFCQUdYO0FBSEQsV0FBWSxxQkFBcUI7SUFDN0IsaUVBQU0sQ0FBQTtJQUNOLHlFQUFVLENBQUE7QUFDZCxDQUFDLEVBSFcscUJBQXFCLEtBQXJCLHFCQUFxQixRQUdoQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLyogRW51bSBsaXN0aW5nIHRoZSBhbGxvd2VkIGFjdGlvbnMgdGhhdCBjYW4gYmUgZW1pdHRlZCBmcm9tIHRoZSBOb25SZXNwb25zaXZlUHJldmlldyBkaWFsb2cgY29tcG9uZW50ICovXG5leHBvcnQgZW51bSBEb3dubG9hZFByb21wdEFjdGlvbnMge1xuICAgICdXQUlUJyxcbiAgICAnRE9XTkxPQUQnXG59XG4iXX0=

package/esm2022/lib/viewer/models/viewer.model.mjs

@@ -0,0 +1,22 @@
+/*!
+ * @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.
+ */
+export var CloseButtonPosition;
+(function (CloseButtonPosition) {
+    CloseButtonPosition["Right"] = "right";
+    CloseButtonPosition["Left"] = "left";
+})(CloseButtonPosition || (CloseButtonPosition = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlld2VyLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvcmUvc3JjL2xpYi92aWV3ZXIvbW9kZWxzL3ZpZXdlci5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxNQUFNLENBQU4sSUFBWSxtQkFHWDtBQUhELFdBQVksbUJBQW1CO0lBQzNCLHNDQUFlLENBQUE7SUFDZixvQ0FBYSxDQUFBO0FBQ2pCLENBQUMsRUFIVyxtQkFBbUIsS0FBbkIsbUJBQW1CLFFBRzlCIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgZW51bSBDbG9zZUJ1dHRvblBvc2l0aW9uIHtcbiAgICBSaWdodCA9ICdyaWdodCcsXG4gICAgTGVmdCA9ICdsZWZ0J1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRyYWNrIHtcbiAgICBzcmM6IHN0cmluZztcbiAgICBsYWJlbD86IHN0cmluZztcbiAgICBraW5kPzogc3RyaW5nO1xuICAgIHNyY2xhbmc/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/viewer/public-api.mjs

@@ -0,0 +1,40 @@
+/*!
+ * @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.
+ */
+export * from './services/view-util.service';
+export * from './components/img-viewer/img-viewer.component';
+export * from './components/media-player/media-player.component';
+export * from './components/pdf-viewer-password-dialog/pdf-viewer-password-dialog';
+export * from './components/pdf-viewer/pdf-viewer.component';
+export * from './components/pdf-viewer-thumbnails/pdf-viewer-thumbnails.component';
+export * from './components/pdf-viewer-thumb/pdf-viewer-thumb.component';
+export * from './components/pdf-viewer-thumbnails/pdf-viewer-thumbnails.component';
+export * from './components/txt-viewer/txt-viewer.component';
+export * from './components/unknown-format/unknown-format.component';
+export * from './components/viewer-more-actions.component';
+export * from './components/viewer-open-with.component';
+export * from './components/viewer-sidebar.component';
+export * from './components/viewer-toolbar.component';
+export * from './components/viewer-toolbar-actions.component';
+export * from './components/viewer-toolbar-custom-actions.component';
+export * from './components/viewer-render/viewer-render.component';
+export * from './components/viewer.component';
+export * from './components/download-prompt-dialog/download-prompt-dialog.component';
+export * from './directives/viewer-extension.directive';
+export * from './viewer.module';
+export * from './models/viewer.model';
+export * from './models/download-prompt.actions';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/viewer/services/rendering-queue.services.mjs

@@ -0,0 +1,179 @@
+/*!
+ * @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 * as i0 from "@angular/core";
+/**
+ *
+ * RenderingQueueServices rendering of the views for pages and thumbnails.
+ *
+ */
+export class RenderingQueueServices {
+    constructor() {
+        this.renderingStates = {
+            INITIAL: 0,
+            RUNNING: 1,
+            PAUSED: 2,
+            FINISHED: 3
+        };
+        this.CLEANUP_TIMEOUT = 30000;
+        this.pdfViewer = null;
+        this.pdfThumbnailViewer = null;
+        this.onIdle = null;
+        this.highestPriorityPage = null;
+        this.idleTimeout = null;
+        this.printing = false;
+        this.isThumbnailViewEnabled = false;
+    }
+    /**
+     * Set the instance of the PDF Viewer
+     *
+     * @param pdfViewer viewer instance
+     */
+    setViewer(pdfViewer) {
+        this.pdfViewer = pdfViewer;
+    }
+    /**
+     * Sets the instance of the PDF Thumbnail Viewer
+     *
+     * @param pdfThumbnailViewer viewer instance
+     */
+    setThumbnailViewer(pdfThumbnailViewer) {
+        this.pdfThumbnailViewer = pdfThumbnailViewer;
+    }
+    /**
+     * Check if the view has highest rendering priority
+     *
+     * @param view view to render
+     * @returns `true` if the view has higher priority, otherwise `false`
+     */
+    isHighestPriority(view) {
+        return this.highestPriorityPage === view.renderingId;
+    }
+    renderHighestPriority(currentlyVisiblePages) {
+        if (this.idleTimeout) {
+            clearTimeout(this.idleTimeout);
+            this.idleTimeout = null;
+        }
+        // Pages have a higher priority than thumbnails, so check them first.
+        if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
+            return;
+        }
+        // No pages needed rendering so check thumbnails.
+        if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
+            if (this.pdfThumbnailViewer.forceRendering()) {
+                return;
+            }
+        }
+        if (this.printing) {
+            // If printing is currently ongoing do not reschedule cleanup.
+            return;
+        }
+        if (this.onIdle) {
+            this.idleTimeout = setTimeout(this.onIdle.bind(this), this.CLEANUP_TIMEOUT);
+        }
+    }
+    getHighestPriority(visible, views, scrolledDown) {
+        // The state has changed figure out which page has the highest priority to
+        // render next (if any).
+        // Priority:
+        // 1 visible pages
+        // 2 if last scrolled down page after the visible pages
+        // 2 if last scrolled up page before the visible pages
+        const visibleViews = visible.views;
+        const numVisible = visibleViews.length;
+        if (numVisible === 0) {
+            return false;
+        }
+        for (let i = 0; i < numVisible; ++i) {
+            const view = visibleViews[i].view;
+            if (!this.isViewFinished(view)) {
+                return view;
+            }
+        }
+        // All the visible views have rendered, try to render next/previous pages.
+        if (scrolledDown) {
+            const nextPageIndex = visible.last.id;
+            // ID's start at 1 so no need to add 1.
+            if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
+                return views[nextPageIndex];
+            }
+        }
+        else {
+            const previousPageIndex = visible.first.id - 2;
+            if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
+                return views[previousPageIndex];
+            }
+        }
+        // Everything that needs to be rendered has been.
+        return null;
+    }
+    hasViewer() {
+        return !!this.pdfViewer;
+    }
+    /**
+     * Checks if the view rendering is finished
+     *
+     * @param view the View instance to check
+     * @returns `true` if rendering is finished, otherwise `false`
+     */
+    isViewFinished(view) {
+        return view.renderingState === this.renderingStates.FINISHED;
+    }
+    /**
+     * Render a page or thumbnail view. This calls the appropriate function
+     * based on the views state. If the view is already rendered it will return
+     * false.
+     *
+     * @param view View instance to render
+     * @returns the rendered state of the view
+     */
+    renderView(view) {
+        const state = view.renderingState;
+        switch (state) {
+            case this.renderingStates.FINISHED: {
+                return false;
+            }
+            case this.renderingStates.PAUSED: {
+                this.highestPriorityPage = view.renderingId;
+                view.resume();
+                break;
+            }
+            case this.renderingStates.RUNNING: {
+                this.highestPriorityPage = view.renderingId;
+                break;
+            }
+            case this.renderingStates.INITIAL: {
+                this.highestPriorityPage = view.renderingId;
+                // eslint-disable-next-line space-before-function-paren
+                const continueRendering = function () {
+                    this.renderHighestPriority();
+                }.bind(this);
+                view.draw().then(continueRendering, continueRendering);
+                break;
+            }
+            default:
+                break;
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenderingQueueServices, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenderingQueueServices }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenderingQueueServices, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rendering-queue.services.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/viewer/services/rendering-queue.services.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAE3C;;;;GAIG;AAEH,MAAM,OAAO,sBAAsB;IADnC;QAEI,oBAAe,GAAG;YACd,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;YACV,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,CAAC;SACd,CAAC;QAEF,oBAAe,GAAW,KAAK,CAAC;QAEhC,cAAS,GAAQ,IAAI,CAAC;QACtB,uBAAkB,GAAQ,IAAI,CAAC;QAC/B,WAAM,GAAQ,IAAI,CAAC;QAEnB,wBAAmB,GAAQ,IAAI,CAAC;QAChC,gBAAW,GAAQ,IAAI,CAAC;QACxB,aAAQ,GAAQ,KAAK,CAAC;QACtB,2BAAsB,GAAQ,KAAK,CAAC;KAiJvC;IA/IG;;;;OAIG;IACH,SAAS,CAAC,SAAS;QACf,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,kBAAkB;QACjC,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,IAAS;QACvB,OAAO,IAAI,CAAC,mBAAmB,KAAK,IAAI,CAAC,WAAW,CAAC;IACzD,CAAC;IAED,qBAAqB,CAAC,qBAAqB;QACvC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC/B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QAC5B,CAAC;QAED,qEAAqE;QACrE,IAAI,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,qBAAqB,CAAC,EAAE,CAAC;YACvD,OAAO;QACX,CAAC;QACD,iDAAiD;QACjD,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACzD,IAAI,IAAI,CAAC,kBAAkB,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC3C,OAAO;YACX,CAAC;QACL,CAAC;QAED,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,8DAA8D;YAC9D,OAAO;QACX,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAChF,CAAC;IACL,CAAC;IAED,kBAAkB,CAAC,OAAO,EAAE,KAAK,EAAE,YAAY;QAC3C,0EAA0E;QAC1E,wBAAwB;QACxB,YAAY;QACZ,kBAAkB;QAClB,uDAAuD;QACvD,sDAAsD;QACtD,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC;QAEnC,MAAM,UAAU,GAAG,YAAY,CAAC,MAAM,CAAC;QACvC,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACnB,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,EAAE,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAClC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,OAAO,IAAI,CAAC;YAChB,CAAC;QACL,CAAC;QAED,0EAA0E;QAC1E,IAAI,YAAY,EAAE,CAAC;YACf,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACtC,uCAAuC;YACvC,IAAI,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBACrE,OAAO,KAAK,CAAC,aAAa,CAAC,CAAC;YAChC,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,MAAM,iBAAiB,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC;YAC/C,IAAI,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC;gBAC7E,OAAO,KAAK,CAAC,iBAAiB,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;QACD,iDAAiD;QACjD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,SAAS;QACL,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAI;QACf,OAAO,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC;IACjE,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,IAAS;QAChB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC;QAClC,QAAQ,KAAK,EAAE,CAAC;YACZ,KAAK,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACjC,OAAO,KAAK,CAAC;YACjB,CAAC;YACD,KAAK,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC/B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC;gBAC5C,IAAI,CAAC,MAAM,EAAE,CAAC;gBACd,MAAM;YACV,CAAC;YACD,KAAK,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;gBAChC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC;gBAC5C,MAAM;YACV,CAAC;YACD,KAAK,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;gBAChC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC;gBAC5C,uDAAuD;gBACvD,MAAM,iBAAiB,GAAG;oBACtB,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBACjC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACb,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC;gBACvD,MAAM;YACV,CAAC;YACD;gBACI,MAAM;QACd,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;+GAjKQ,sBAAsB;mHAAtB,sBAAsB;;4FAAtB,sBAAsB;kBADlC,UAAU","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';\n\n/**\n *\n * RenderingQueueServices rendering of the views for pages and thumbnails.\n *\n */\n@Injectable()\nexport class RenderingQueueServices {\n    renderingStates = {\n        INITIAL: 0,\n        RUNNING: 1,\n        PAUSED: 2,\n        FINISHED: 3\n    };\n\n    CLEANUP_TIMEOUT: number = 30000;\n\n    pdfViewer: any = null;\n    pdfThumbnailViewer: any = null;\n    onIdle: any = null;\n\n    highestPriorityPage: any = null;\n    idleTimeout: any = null;\n    printing: any = false;\n    isThumbnailViewEnabled: any = false;\n\n    /**\n     * Set the instance of the PDF Viewer\n     *\n     * @param pdfViewer viewer instance\n     */\n    setViewer(pdfViewer): void {\n        this.pdfViewer = pdfViewer;\n    }\n\n    /**\n     * Sets the instance of the PDF Thumbnail Viewer\n     *\n     * @param pdfThumbnailViewer viewer instance\n     */\n    setThumbnailViewer(pdfThumbnailViewer): void {\n        this.pdfThumbnailViewer = pdfThumbnailViewer;\n    }\n\n    /**\n     * Check if the view has highest rendering priority\n     *\n     * @param view view to render\n     * @returns `true` if the view has higher priority, otherwise `false`\n     */\n    isHighestPriority(view: any): boolean {\n        return this.highestPriorityPage === view.renderingId;\n    }\n\n    renderHighestPriority(currentlyVisiblePages) {\n        if (this.idleTimeout) {\n            clearTimeout(this.idleTimeout);\n            this.idleTimeout = null;\n        }\n\n        // Pages have a higher priority than thumbnails, so check them first.\n        if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {\n            return;\n        }\n        // No pages needed rendering so check thumbnails.\n        if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {\n            if (this.pdfThumbnailViewer.forceRendering()) {\n                return;\n            }\n        }\n\n        if (this.printing) {\n            // If printing is currently ongoing do not reschedule cleanup.\n            return;\n        }\n\n        if (this.onIdle) {\n            this.idleTimeout = setTimeout(this.onIdle.bind(this), this.CLEANUP_TIMEOUT);\n        }\n    }\n\n    getHighestPriority(visible, views, scrolledDown) {\n        // The state has changed figure out which page has the highest priority to\n        // render next (if any).\n        // Priority:\n        // 1 visible pages\n        // 2 if last scrolled down page after the visible pages\n        // 2 if last scrolled up page before the visible pages\n        const visibleViews = visible.views;\n\n        const numVisible = visibleViews.length;\n        if (numVisible === 0) {\n            return false;\n        }\n        for (let i = 0; i < numVisible; ++i) {\n            const view = visibleViews[i].view;\n            if (!this.isViewFinished(view)) {\n                return view;\n            }\n        }\n\n        // All the visible views have rendered, try to render next/previous pages.\n        if (scrolledDown) {\n            const nextPageIndex = visible.last.id;\n            // ID's start at 1 so no need to add 1.\n            if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {\n                return views[nextPageIndex];\n            }\n        } else {\n            const previousPageIndex = visible.first.id - 2;\n            if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {\n                return views[previousPageIndex];\n            }\n        }\n        // Everything that needs to be rendered has been.\n        return null;\n    }\n\n    hasViewer(): boolean {\n        return !!this.pdfViewer;\n    }\n\n    /**\n     * Checks if the view rendering is finished\n     *\n     * @param view the View instance to check\n     * @returns `true` if rendering is finished, otherwise `false`\n     */\n    isViewFinished(view): boolean {\n        return view.renderingState === this.renderingStates.FINISHED;\n    }\n\n    /**\n     * Render a page or thumbnail view. This calls the appropriate function\n     * based on the views state. If the view is already rendered it will return\n     * false.\n     *\n     * @param view View instance to render\n     * @returns the rendered state of the view\n     */\n    renderView(view: any): boolean {\n        const state = view.renderingState;\n        switch (state) {\n            case this.renderingStates.FINISHED: {\n                return false;\n            }\n            case this.renderingStates.PAUSED: {\n                this.highestPriorityPage = view.renderingId;\n                view.resume();\n                break;\n            }\n            case this.renderingStates.RUNNING: {\n                this.highestPriorityPage = view.renderingId;\n                break;\n            }\n            case this.renderingStates.INITIAL: {\n                this.highestPriorityPage = view.renderingId;\n                // eslint-disable-next-line space-before-function-paren\n                const continueRendering = function () {\n                    this.renderHighestPriority();\n                }.bind(this);\n                view.draw().then(continueRendering, continueRendering);\n                break;\n            }\n            default:\n                break;\n        }\n        return true;\n    }\n}\n"]}

package/esm2022/lib/viewer/services/view-util.service.mjs

@@ -0,0 +1,149 @@
+/*!
+ * @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 { AppExtensionService } from '@alfresco/adf-extensions';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-extensions";
+export class ViewUtilService {
+    /**
+     * Returns a list of the active Viewer content extensions.
+     *
+     * @returns list of extension references
+     */
+    get viewerExtensions() {
+        return this.extensionService.getViewerExtensions();
+    }
+    /**
+     * Provides a list of file extensions supported by external plugins.
+     *
+     * @returns list of extensions
+     */
+    get externalExtensions() {
+        return this.viewerExtensions.map((ext) => ext.fileExtension);
+    }
+    constructor(extensionService) {
+        this.extensionService = extensionService;
+        // Extensions that are supported by the Viewer without conversion
+        this.extensions = {
+            image: ['png', 'jpg', 'jpeg', 'gif', 'bpm', 'svg'],
+            media: ['wav', 'mp4', 'mp3', 'webm', 'ogg'],
+            text: ['txt', 'xml', 'html', 'json', 'ts', 'css', 'md'],
+            pdf: ['pdf']
+        };
+        // Mime types that are supported by the Viewer without conversion
+        this.mimeTypes = {
+            text: ['text/plain', 'text/csv', 'text/xml', 'text/html', 'application/x-javascript'],
+            pdf: ['application/pdf'],
+            image: ['image/png', 'image/jpeg', 'image/gif', 'image/bmp', 'image/svg+xml'],
+            media: ['video/mp4', 'video/webm', 'video/ogg', 'audio/mpeg', 'audio/mp3', 'audio/ogg', 'audio/wav']
+        };
+    }
+    /**
+     * get File name from url
+     *
+     * @param  url - url file
+     * @returns file name portion of the url
+     */
+    getFilenameFromUrl(url) {
+        const anchor = url.indexOf('#');
+        const query = url.indexOf('?');
+        const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
+        return url.substring(url.lastIndexOf('/', end) + 1, end);
+    }
+    /**
+     * Get file extension from the string.
+     * Supports the URL formats like:
+     * http://localhost/test.jpg?cache=1000
+     * http://localhost/test.jpg#cache=1000
+     *
+     * @param fileName - file name
+     * @returns file extension
+     */
+    getFileExtension(fileName) {
+        if (fileName) {
+            const match = fileName.match(/\.([^./?#]+)($|\?|#)/);
+            return match ? match[1] : null;
+        }
+        return null;
+    }
+    getViewerType(extension, mimeType, extensionsSupportedByTemplates) {
+        let viewerType = this.getViewerTypeByExtension(extension, extensionsSupportedByTemplates);
+        if (viewerType === 'unknown') {
+            viewerType = this.getViewerTypeByMimeType(mimeType);
+        }
+        return viewerType;
+    }
+    getViewerTypeByMimeType(mimeType) {
+        if (mimeType) {
+            mimeType = mimeType.toLowerCase();
+            const editorTypes = Object.keys(this.mimeTypes);
+            for (const type of editorTypes) {
+                if (this.mimeTypes[type].indexOf(mimeType) >= 0) {
+                    return type;
+                }
+            }
+        }
+        return 'unknown';
+    }
+    getViewerTypeByExtension(extension, extensionsSupportedByTemplates) {
+        if (extension) {
+            extension = extension.toLowerCase();
+        }
+        if (this.isExternalViewer()) {
+            return 'external';
+        }
+        if (this.isCustomViewerExtension(extension, extensionsSupportedByTemplates)) {
+            return 'custom';
+        }
+        if (this.extensions.image.indexOf(extension) >= 0) {
+            return 'image';
+        }
+        if (this.extensions.media.indexOf(extension) >= 0) {
+            return 'media';
+        }
+        if (this.extensions.text.indexOf(extension) >= 0) {
+            return 'text';
+        }
+        if (this.extensions.pdf.indexOf(extension) >= 0) {
+            return 'pdf';
+        }
+        return 'unknown';
+    }
+    isExternalViewer() {
+        return !!this.viewerExtensions.find((ext) => ext.fileExtension === '*');
+    }
+    isCustomViewerExtension(extension, extensionsSupportedByTemplates) {
+        const extensions = this.externalExtensions || [];
+        if (extensionsSupportedByTemplates) {
+            extensions.push(...extensionsSupportedByTemplates);
+        }
+        if (extension && extensions.length > 0) {
+            extension = extension.toLowerCase();
+            return extensions.flat().indexOf(extension) >= 0;
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ViewUtilService, deps: [{ token: i1.AppExtensionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ViewUtilService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ViewUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppExtensionService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view-util.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/viewer/services/view-util.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 { AppExtensionService, ViewerExtensionRef } from '@alfresco/adf-extensions';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ViewUtilService {\n    // Extensions that are supported by the Viewer without conversion\n    private extensions = {\n        image: ['png', 'jpg', 'jpeg', 'gif', 'bpm', 'svg'],\n        media: ['wav', 'mp4', 'mp3', 'webm', 'ogg'],\n        text: ['txt', 'xml', 'html', 'json', 'ts', 'css', 'md'],\n        pdf: ['pdf']\n    };\n\n    // Mime types that are supported by the Viewer without conversion\n    private mimeTypes = {\n        text: ['text/plain', 'text/csv', 'text/xml', 'text/html', 'application/x-javascript'],\n        pdf: ['application/pdf'],\n        image: ['image/png', 'image/jpeg', 'image/gif', 'image/bmp', 'image/svg+xml'],\n        media: ['video/mp4', 'video/webm', 'video/ogg', 'audio/mpeg', 'audio/mp3', 'audio/ogg', 'audio/wav']\n    };\n\n    /**\n     * Returns a list of the active Viewer content extensions.\n     *\n     * @returns list of extension references\n     */\n    get viewerExtensions(): ViewerExtensionRef[] {\n        return this.extensionService.getViewerExtensions();\n    }\n\n    /**\n     * Provides a list of file extensions supported by external plugins.\n     *\n     * @returns list of extensions\n     */\n    get externalExtensions(): string[] {\n        return this.viewerExtensions.map((ext) => ext.fileExtension);\n    }\n\n    constructor(private extensionService: AppExtensionService) {}\n\n    /**\n     * get File name from url\n     *\n     * @param  url - url file\n     * @returns file name portion of the url\n     */\n    getFilenameFromUrl(url: string): string {\n        const anchor = url.indexOf('#');\n        const query = url.indexOf('?');\n        const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);\n        return url.substring(url.lastIndexOf('/', end) + 1, end);\n    }\n\n    /**\n     * Get file extension from the string.\n     * Supports the URL formats like:\n     * http://localhost/test.jpg?cache=1000\n     * http://localhost/test.jpg#cache=1000\n     *\n     * @param fileName - file name\n     * @returns file extension\n     */\n    getFileExtension(fileName: string): string {\n        if (fileName) {\n            const match = fileName.match(/\\.([^./?#]+)($|\\?|#)/);\n            return match ? match[1] : null;\n        }\n        return null;\n    }\n\n    getViewerType(extension: string, mimeType: string, extensionsSupportedByTemplates?: string[]): string {\n        let viewerType = this.getViewerTypeByExtension(extension, extensionsSupportedByTemplates);\n\n        if (viewerType === 'unknown') {\n            viewerType = this.getViewerTypeByMimeType(mimeType);\n        }\n\n        return viewerType;\n    }\n\n    getViewerTypeByMimeType(mimeType: string) {\n        if (mimeType) {\n            mimeType = mimeType.toLowerCase();\n\n            const editorTypes = Object.keys(this.mimeTypes);\n            for (const type of editorTypes) {\n                if (this.mimeTypes[type].indexOf(mimeType) >= 0) {\n                    return type;\n                }\n            }\n        }\n        return 'unknown';\n    }\n\n    private getViewerTypeByExtension(extension: string, extensionsSupportedByTemplates?: string[]): string {\n        if (extension) {\n            extension = extension.toLowerCase();\n        }\n\n        if (this.isExternalViewer()) {\n            return 'external';\n        }\n\n        if (this.isCustomViewerExtension(extension, extensionsSupportedByTemplates)) {\n            return 'custom';\n        }\n\n        if (this.extensions.image.indexOf(extension) >= 0) {\n            return 'image';\n        }\n\n        if (this.extensions.media.indexOf(extension) >= 0) {\n            return 'media';\n        }\n\n        if (this.extensions.text.indexOf(extension) >= 0) {\n            return 'text';\n        }\n\n        if (this.extensions.pdf.indexOf(extension) >= 0) {\n            return 'pdf';\n        }\n\n        return 'unknown';\n    }\n\n    private isExternalViewer(): boolean {\n        return !!this.viewerExtensions.find((ext) => ext.fileExtension === '*');\n    }\n\n    isCustomViewerExtension(extension: string, extensionsSupportedByTemplates?: string[]): boolean {\n        const extensions = this.externalExtensions || [];\n        if (extensionsSupportedByTemplates) {\n            extensions.push(...extensionsSupportedByTemplates);\n        }\n\n        if (extension && extensions.length > 0) {\n            extension = extension.toLowerCase();\n            return extensions.flat().indexOf(extension) >= 0;\n        }\n\n        return false;\n    }\n}\n"]}