@design.estate/dees-catalog 6.12.1 → 7.0.1

package/dist_ts_web/elements/00group-media/dees-pdf-shared/PdfManager.js

@@ -1,27 +1,189 @@
-import { domtools } from '@design.estate/dees-element';
+import { getDocument, PDFWorker, } from 'pdfjs-dist';
+const normalizeError = (errorArg) => (errorArg instanceof Error ? errorArg : new Error(String(errorArg)));
+const createAbortError = () => {
+    const error = new Error('PDF load aborted');
+    error.name = 'AbortError';
+    return error;
+};
+const workerTerminationGraceMs = 2_000;
 export class PdfManager {
-    static pdfjsLib;
-    static initialized = false;
+    static resourcesByDocument = new WeakMap();
+    static releasedDocuments = new WeakSet();
     static async initialize() {
-        if (this.initialized)
-            return;
-        // @ts-ignore
-        this.pdfjsLib = await import('https://cdn.jsdelivr.net/npm/pdfjs-dist@4.0.379/+esm');
-        this.pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdn.jsdelivr.net/npm/pdfjs-dist@4.0.379/build/pdf.worker.mjs';
-        this.initialized = true;
+        // PDF.js is loaded statically; retained for existing callers.
+    }
+    static async loadDocument(urlArg, signalArg) {
+        const workerPort = new Worker(new URL('pdfjs-dist/build/pdf.worker.mjs', import.meta.url), { type: 'module' });
+        let resolveInterruption;
+        const interruptionPromise = new Promise((resolve) => {
+            resolveInterruption = resolve;
+        });
+        let resolveWorkerFailure;
+        const workerFailurePromise = new Promise((resolve) => {
+            resolveWorkerFailure = resolve;
+        });
+        const resources = {
+            workerPort,
+            networkAbortController: new AbortController(),
+            workerFailed: false,
+            interruptionPromise,
+            resolveInterruption,
+            workerFailurePromise,
+            resolveWorkerFailure,
+        };
+        const recordInterruption = (errorArg) => {
+            if (!resources.firstError) {
+                resources.firstError = errorArg;
+                resources.resolveInterruption(errorArg);
+            }
+        };
+        resources.workerErrorListener = (eventArg) => {
+            if (!resources.workerFailed) {
+                resources.workerFailed = true;
+                resources.resolveWorkerFailure();
+            }
+            const message = eventArg instanceof ErrorEvent && eventArg.message
+                ? eventArg.message
+                : 'PDF worker failed';
+            recordInterruption(new Error(message));
+            void this.releaseResources(resources).catch(() => { });
+        };
+        workerPort.addEventListener('error', resources.workerErrorListener);
+        try {
+            if (signalArg) {
+                resources.abortSignal = signalArg;
+                resources.abortListener = () => {
+                    recordInterruption(createAbortError());
+                    void this.releaseResources(resources).catch(() => { });
+                };
+                signalArg.addEventListener('abort', resources.abortListener, { once: true });
+                if (signalArg.aborted) {
+                    resources.abortListener();
+                    throw resources.firstError || createAbortError();
+                }
+            }
+            resources.pdfWorker = PDFWorker.fromPort({ port: workerPort });
+            const response = await Promise.race([
+                fetch(urlArg, {
+                    signal: resources.networkAbortController.signal,
+                }),
+                resources.interruptionPromise.then((errorArg) => {
+                    throw errorArg;
+                }),
+            ]);
+            if (!response.ok) {
+                throw new Error(`Failed to load PDF (${response.status} ${response.statusText})`);
+            }
+            const data = new Uint8Array(await Promise.race([
+                response.arrayBuffer(),
+                resources.interruptionPromise.then((errorArg) => {
+                    throw errorArg;
+                }),
+            ]));
+            resources.loadingTask = getDocument({
+                data,
+                docBaseUrl: response.url || urlArg,
+                worker: resources.pdfWorker,
+            });
+            const document = await Promise.race([
+                resources.loadingTask.promise,
+                resources.interruptionPromise.then((errorArg) => {
+                    throw errorArg;
+                }),
+            ]);
+            if (signalArg?.aborted) {
+                resources.abortListener?.();
+                throw resources.firstError || createAbortError();
+            }
+            if (resources.abortSignal && resources.abortListener) {
+                resources.abortSignal.removeEventListener('abort', resources.abortListener);
+                resources.abortSignal = undefined;
+                resources.abortListener = undefined;
+            }
+            resources.document = document;
+            this.resourcesByDocument.set(document, resources);
+            return document;
+        }
+        catch (error) {
+            recordInterruption(normalizeError(error));
+            try {
+                await this.releaseResources(resources);
+            }
+            catch {
+                // Preserve the load, abort, or worker error that initiated cleanup.
+            }
+            throw resources.firstError;
+        }
     }
-    static async loadDocument(url) {
-        await this.initialize();
-        // IMPORTANT: Disabled caching to ensure component isolation
-        // Each viewer instance gets its own document to prevent state sharing
-        // This fixes issues where multiple viewers interfere with each other
-        const loadingTask = this.pdfjsLib.getDocument(url);
-        const document = await loadingTask.promise;
-        return document;
+    static async releaseDocument(documentArg) {
+        if (!documentArg)
+            return;
+        if (this.releasedDocuments.has(documentArg))
+            return;
+        const resources = this.resourcesByDocument.get(documentArg);
+        if (!resources) {
+            await documentArg.destroy();
+            this.releasedDocuments.add(documentArg);
+            return;
+        }
+        await this.releaseResources(resources);
     }
-    static releaseDocument(_url) {
-        // No-op since we're not caching documents anymore
-        // Each viewer manages its own document lifecycle
+    static releaseResources(resourcesArg) {
+        if (!resourcesArg.releasePromise) {
+            let resolveRelease;
+            let rejectRelease;
+            resourcesArg.releasePromise = new Promise((resolve, reject) => {
+                resolveRelease = resolve;
+                rejectRelease = reject;
+            });
+            void (async () => {
+                resourcesArg.networkAbortController.abort();
+                try {
+                    if (resourcesArg.loadingTask) {
+                        const loadingTaskDestroyPromise = resourcesArg.loadingTask.destroy();
+                        void loadingTaskDestroyPromise.catch(() => { });
+                        let timeout;
+                        const timeoutPromise = new Promise((resolve) => {
+                            timeout = setTimeout(resolve, workerTerminationGraceMs);
+                        });
+                        try {
+                            await Promise.race([
+                                loadingTaskDestroyPromise,
+                                resourcesArg.workerFailurePromise,
+                                timeoutPromise,
+                            ]);
+                        }
+                        finally {
+                            if (timeout) {
+                                clearTimeout(timeout);
+                            }
+                        }
+                    }
+                }
+                finally {
+                    try {
+                        resourcesArg.pdfWorker?.destroy();
+                    }
+                    finally {
+                        if (resourcesArg.abortSignal && resourcesArg.abortListener) {
+                            resourcesArg.abortSignal.removeEventListener('abort', resourcesArg.abortListener);
+                        }
+                        if (resourcesArg.workerErrorListener) {
+                            resourcesArg.workerPort.removeEventListener('error', resourcesArg.workerErrorListener);
+                        }
+                        resourcesArg.workerPort.terminate();
+                        if (resourcesArg.document) {
+                            this.releasedDocuments.add(resourcesArg.document);
+                            this.resourcesByDocument.delete(resourcesArg.document);
+                        }
+                        resourcesArg.document = undefined;
+                        resourcesArg.loadingTask = undefined;
+                        resourcesArg.pdfWorker = undefined;
+                    }
+                }
+            })().then(resolveRelease, rejectRelease);
+        }
+        return resourcesArg.releasePromise;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGRmTWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzX3dlYi9lbGVtZW50cy8wMGdyb3VwLW1lZGlhL2RlZXMtcGRmLXNoYXJlZC9QZGZNYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUV2RCxNQUFNLE9BQU8sVUFBVTtJQUNiLE1BQU0sQ0FBQyxRQUFRLENBQU07SUFDckIsTUFBTSxDQUFDLFdBQVcsR0FBRyxLQUFLLENBQUM7SUFFNUIsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVO1FBQzVCLElBQUksSUFBSSxDQUFDLFdBQVc7WUFBRSxPQUFPO1FBRTdCLGFBQWE7UUFDYixJQUFJLENBQUMsUUFBUSxHQUFHLE1BQU0sTUFBTSxDQUFDLHNEQUFzRCxDQUFDLENBQUM7UUFDckYsSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FBQyxTQUFTLEdBQUcsc0VBQXNFLENBQUM7UUFFckgsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUM7SUFDMUIsQ0FBQztJQUVNLE1BQU0sQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLEdBQVc7UUFDMUMsTUFBTSxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFFeEIsNERBQTREO1FBQzVELHNFQUFzRTtRQUN0RSxxRUFBcUU7UUFDckUsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDbkQsTUFBTSxRQUFRLEdBQUcsTUFBTSxXQUFXLENBQUMsT0FBTyxDQUFDO1FBRTNDLE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7SUFFTSxNQUFNLENBQUMsZUFBZSxDQUFDLElBQVk7UUFDeEMsa0RBQWtEO1FBQ2xELGlEQUFpRDtJQUNuRCxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PdfManager.js","sourceRoot":"","sources":["../../../../ts_web/elements/00group-media/dees-pdf-shared/PdfManager.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/elements/00group-media/dees-pdf-shared/utils.d.ts

@@ -1,6 +1,9 @@
 export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
 export declare function throttle<T extends (...args: any[]) => any>(func: T, limit: number): (...args: Parameters<T>) => void;
 export declare function formatFileSize(bytes: number): string;
+export declare function settlePromisesWithin(promisesArg: readonly Promise<unknown>[], timeoutMsArg: number): Promise<boolean>;
+export declare function raceWithAbort<T>(promiseArg: Promise<T>, signalArg: AbortSignal): Promise<T>;
+export declare const waitForAnimationFrame: (signalArg?: AbortSignal) => Promise<void>;
 export declare function isInViewport(element: Element, margin?: number): boolean;
 export declare class PerformanceMonitor {
     private static marks;

package/dist_ts_web/elements/00group-media/dees-pdf-shared/utils.js

@@ -27,6 +27,72 @@ export function formatFileSize(bytes) {
     const i = Math.floor(Math.log(bytes) / Math.log(k));
     return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
 }
+export async function settlePromisesWithin(promisesArg, timeoutMsArg) {
+    if (promisesArg.length === 0)
+        return true;
+    let timeout;
+    try {
+        return await Promise.race([
+            Promise.allSettled(promisesArg).then(() => true),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(false), timeoutMsArg);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+export function raceWithAbort(promiseArg, signalArg) {
+    const abortError = () => {
+        const error = new Error('Operation aborted');
+        error.name = 'AbortError';
+        return error;
+    };
+    if (signalArg.aborted) {
+        void promiseArg.catch(() => { });
+        return Promise.reject(abortError());
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callbackArg) => {
+            if (settled)
+                return;
+            settled = true;
+            signalArg.removeEventListener('abort', handleAbort);
+            callbackArg();
+        };
+        const handleAbort = () => {
+            finish(() => reject(abortError()));
+        };
+        signalArg.addEventListener('abort', handleAbort, { once: true });
+        void promiseArg.then((valueArg) => finish(() => resolve(valueArg)), (errorArg) => finish(() => reject(errorArg)));
+        if (signalArg.aborted)
+            handleAbort();
+    });
+}
+export const waitForAnimationFrame = (signalArg) => new Promise((resolve) => {
+    if (signalArg?.aborted) {
+        resolve();
+        return;
+    }
+    let settled = false;
+    let frame = 0;
+    let timeout = 0;
+    const finish = () => {
+        if (settled)
+            return;
+        settled = true;
+        cancelAnimationFrame(frame);
+        window.clearTimeout(timeout);
+        signalArg?.removeEventListener('abort', finish);
+        resolve();
+    };
+    frame = requestAnimationFrame(finish);
+    timeout = window.setTimeout(finish, 100);
+    signalArg?.addEventListener('abort', finish, { once: true });
+});
 export function isInViewport(element, margin = 0) {
     const rect = element.getBoundingClientRect();
     return (rect.top >= -margin &&
@@ -73,4 +139,4 @@ export class PerformanceMonitor {
         this.measures = [];
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_web/elements/00group-media/dees-pdf-viewer/component.d.ts

@@ -33,6 +33,13 @@ export declare class DeesPdfViewer extends DeesElement {
     }>;
     accessor pdfFileSize: number;
     private pdfDocument;
+    private pdfLoadPromise;
+    private loadOperation;
+    private loadGeneration;
+    private connectionEpoch;
+    private cleanupPromise;
+    private renderAdmissionOpen;
+    private renderGeneration;
     private renderState;
     private renderAbortController;
     private pageRendering;
@@ -40,11 +47,23 @@ export declare class DeesPdfViewer extends DeesElement {
     private currentRenderTask;
     private currentRenderPromise;
     private thumbnailRenderTasks;
+    private thumbnailRenderPromise;
+    private thumbnailRenderGeneration;
+    private thumbnailRenderQueued;
+    private thumbnailRenderQueueEpoch;
     private pageRenderTasks;
+    private pageRenderPipelines;
+    private documentUsePipelines;
+    private rerenderPromise;
+    private rerenderQueued;
+    private rerenderQueueEpoch;
+    private rerenderRecoveryTimeout?;
     private textLayerRenderTasks;
+    private textSelectionCleanupFunctions;
     private canvas;
     private ctx;
     private viewerMain;
+    private wheelEventTarget;
     private resizeObserver?;
     private intersectionObserver?;
     private scrollThrottleTimeout?;
@@ -62,7 +81,9 @@ export declare class DeesPdfViewer extends DeesElement {
     disconnectedCallback(): Promise<void>;
     updated(changedProperties: Map<PropertyKey, unknown>): Promise<void>;
     private formatFileSize;
-    private loadPdf;
+    private schedulePdfLoad;
+    private isCurrentLoad;
+    private performPdfLoad;
     private setupIntersectionObserver;
     private renderVisiblePages;
     private renderPageIfNeeded;
@@ -72,6 +93,7 @@ export declare class DeesPdfViewer extends DeesElement {
     private scrollThumbnailIntoView;
     private scrollToPage;
     private renderThumbnails;
+    private performRenderThumbnails;
     private previousPage;
     private nextPage;
     private handleThumbnailClick;
@@ -90,10 +112,12 @@ export declare class DeesPdfViewer extends DeesElement {
     getContextMenuItems(): any[];
     private get canZoomIn();
     private get canZoomOut();
+    private readonly handleViewerWheel;
     private ensureViewerRefs;
     private measureViewportDimensions;
     private resolveInitialViewportMode;
     private computeViewport;
     private normalizeZoom;
     private cleanupDocument;
+    private performDocumentCleanup;
 }