@design.estate/dees-catalog 6.12.1 → 7.0.1

package/ts_web/elements/00group-media/dees-pdf-shared/PdfManager.ts

@@ -1,36 +1,226 @@
-import { domtools } from '@design.estate/dees-element';
+import {
+  getDocument,
+  PDFWorker,
+  type PDFDocumentLoadingTask,
+  type PDFDocumentProxy,
+} from 'pdfjs-dist';
 
-export class PdfManager {
-  private static pdfjsLib: any;
-  private static initialized = false;
+interface IPdfDocumentResources {
+  workerPort: Worker;
+  networkAbortController: AbortController;
+  pdfWorker?: PDFWorker;
+  loadingTask?: PDFDocumentLoadingTask;
+  document?: PDFDocumentProxy;
+  abortSignal?: AbortSignal;
+  abortListener?: () => void;
+  workerErrorListener?: (eventArg: Event) => void;
+  firstError?: Error;
+  workerFailed: boolean;
+  interruptionPromise: Promise<Error>;
+  resolveInterruption: (errorArg: Error) => void;
+  workerFailurePromise: Promise<void>;
+  resolveWorkerFailure: () => void;
+  releasePromise?: Promise<void>;
+}
 
-  public static async initialize() {
-    if (this.initialized) return;
+const normalizeError = (errorArg: unknown): Error => (
+  errorArg instanceof Error ? errorArg : new Error(String(errorArg))
+);
 
-    // @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';
+const createAbortError = (): Error => {
+  const error = new Error('PDF load aborted');
+  error.name = 'AbortError';
+  return error;
+};
 
-    this.initialized = true;
-  }
+const workerTerminationGraceMs = 2_000;
 
-  public static async loadDocument(url: string): Promise<any> {
-    await this.initialize();
+export class PdfManager {
+  private static readonly resourcesByDocument = new WeakMap<
+    PDFDocumentProxy,
+    IPdfDocumentResources
+  >();
+  private static readonly releasedDocuments = new WeakSet<PDFDocumentProxy>();
 
-    // 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;
+  public static async initialize(): Promise<void> {
+    // PDF.js is loaded statically; retained for existing callers.
+  }
+
+  public static async loadDocument(
+    urlArg: string,
+    signalArg?: AbortSignal,
+  ): Promise<PDFDocumentProxy> {
+    const workerPort = new Worker(
+      new URL('pdfjs-dist/build/pdf.worker.mjs', import.meta.url),
+      { type: 'module' },
+    );
+    let resolveInterruption!: (errorArg: Error) => void;
+    const interruptionPromise = new Promise<Error>((resolve) => {
+      resolveInterruption = resolve;
+    });
+    let resolveWorkerFailure!: () => void;
+    const workerFailurePromise = new Promise<void>((resolve) => {
+      resolveWorkerFailure = resolve;
+    });
+    const resources: IPdfDocumentResources = {
+      workerPort,
+      networkAbortController: new AbortController(),
+      workerFailed: false,
+      interruptionPromise,
+      resolveInterruption,
+      workerFailurePromise,
+      resolveWorkerFailure,
+    };
+    const recordInterruption = (errorArg: Error): void => {
+      if (!resources.firstError) {
+        resources.firstError = errorArg;
+        resources.resolveInterruption(errorArg);
+      }
+    };
+    resources.workerErrorListener = (eventArg: Event): void => {
+      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);
 
-    return document;
+    try {
+      if (signalArg) {
+        resources.abortSignal = signalArg;
+        resources.abortListener = (): void => {
+          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 }) as PDFWorker;
+      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: unknown) {
+      recordInterruption(normalizeError(error));
+      try {
+        await this.releaseResources(resources);
+      } catch {
+        // Preserve the load, abort, or worker error that initiated cleanup.
+      }
+      throw resources.firstError;
+    }
   }
 
-  public static releaseDocument(_url: string) {
-    // No-op since we're not caching documents anymore
-    // Each viewer manages its own document lifecycle
+  public static async releaseDocument(
+    documentArg: PDFDocumentProxy | null | undefined,
+  ): Promise<void> {
+    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);
   }
 
-  // Cache methods removed to ensure component isolation
-  // Each viewer now manages its own document lifecycle
+  private static releaseResources(resourcesArg: IPdfDocumentResources): Promise<void> {
+    if (!resourcesArg.releasePromise) {
+      let resolveRelease!: () => void;
+      let rejectRelease!: (errorArg: unknown) => void;
+      resourcesArg.releasePromise = new Promise<void>((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: ReturnType<typeof setTimeout> | undefined;
+            const timeoutPromise = new Promise<void>((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;
+  }
 }

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

@@ -40,6 +40,82 @@ export function formatFileSize(bytes: number): string {
   return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
 }
 
+export async function settlePromisesWithin(
+  promisesArg: readonly Promise<unknown>[],
+  timeoutMsArg: number,
+): Promise<boolean> {
+  if (promisesArg.length === 0) return true;
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      Promise.allSettled(promisesArg).then(() => true),
+      new Promise<boolean>((resolve) => {
+        timeout = setTimeout(() => resolve(false), timeoutMsArg);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+export function raceWithAbort<T>(
+  promiseArg: Promise<T>,
+  signalArg: AbortSignal,
+): Promise<T> {
+  const abortError = (): Error => {
+    const error = new Error('Operation aborted');
+    error.name = 'AbortError';
+    return error;
+  };
+  if (signalArg.aborted) {
+    void promiseArg.catch(() => {});
+    return Promise.reject(abortError());
+  }
+
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const finish = (callbackArg: () => void): void => {
+      if (settled) return;
+      settled = true;
+      signalArg.removeEventListener('abort', handleAbort);
+      callbackArg();
+    };
+    const handleAbort = (): void => {
+      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?: AbortSignal): Promise<void> => 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: Element, margin = 0): boolean {
   const rect = element.getBoundingClientRect();
   return (
@@ -95,4 +171,4 @@ export class PerformanceMonitor {
     this.marks.clear();
     this.measures = [];
   }
-}
+}