canvu-react 0.4.71 → 0.4.73

package/dist/{asset-hydration-BeWWxiBq.d.cts → asset-hydration-6swZ6ciN.d.cts}

@@ -1,5 +1,5 @@
 import { V as VectorSceneItem } from './types-fJNwEnHf.cjs';
-import { a as VectorViewportAssetStore } from './raster-image-canvas-Byq087t9.cjs';
+import { a as VectorViewportAssetStore } from './raster-image-canvas-ByaCKEVw.cjs';
 
 declare class IndexedDbImageStore {
     private dbPromise;

package/dist/{asset-hydration-CLoDkZDh.d.ts → asset-hydration-P0M5hn-p.d.ts}

@@ -1,5 +1,5 @@
 import { V as VectorSceneItem } from './types-fJNwEnHf.js';
-import { a as VectorViewportAssetStore } from './raster-image-canvas-BqBgE8C-.js';
+import { a as VectorViewportAssetStore } from './raster-image-canvas-D3ZrySjr.js';
 
 declare class IndexedDbImageStore {
     private dbPromise;

package/dist/chatbot.d.cts

@@ -1,9 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { c as CanvasPlugin } from './types-f8d-2-6N.cjs';
+import { c as CanvasPlugin } from './types-DOUBapS4.cjs';
 import 'react';
 import './types-fJNwEnHf.cjs';
 import './shape-builders-DzhCOuzo.cjs';
-import './raster-image-canvas-Byq087t9.cjs';
+import './raster-image-canvas-ByaCKEVw.cjs';
 import './link-item-BMV3VUCr.cjs';
 import './types-DqsqQQVf.cjs';
 

package/dist/chatbot.d.ts

@@ -1,9 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { c as CanvasPlugin } from './types-D_cQxUug.js';
+import { c as CanvasPlugin } from './types-C5wxwquF.js';
 import 'react';
 import './types-fJNwEnHf.js';
 import './shape-builders-xG3A66sv.js';
-import './raster-image-canvas-BqBgE8C-.js';
+import './raster-image-canvas-D3ZrySjr.js';
 import './link-item-COoNNvCu.js';
 import './types-BXa2CIrc.js';
 

package/dist/index.cjs

@@ -225,7 +225,8 @@ function getPdfJs() {
   }
   return pdfjsPromise;
 }
-async function renderPageToCanvas(page, scale) {
+async function renderPageToCanvas(page, scale, signal) {
+  throwIfAborted(signal);
   const raw = page.getViewport({ scale: 1 });
   const adjustedScale = Math.round(raw.width * scale) / raw.width;
   const viewport = page.getViewport({ scale: adjustedScale });
@@ -238,22 +239,48 @@ async function renderPageToCanvas(page, scale) {
   if (!ctx) throw new Error("Canvas 2D context unavailable");
   ctx.imageSmoothingEnabled = true;
   ctx.imageSmoothingQuality = "high";
-  await page.render({ canvas, viewport }).promise;
+  const renderTask = page.render({ canvas, viewport });
+  if (signal) {
+    const abortRender = () => {
+      renderTask.cancel();
+    };
+    signal.addEventListener("abort", abortRender, { once: true });
+    try {
+      await renderTask.promise;
+    } catch (error) {
+      if (signal.aborted) throw createAbortError();
+      throw error;
+    } finally {
+      signal.removeEventListener("abort", abortRender);
+    }
+  } else {
+    await renderTask.promise;
+  }
+  throwIfAborted(signal);
   return { canvas, width: w, height: h };
 }
+function createAbortError() {
+  return new DOMException("Aborted", "AbortError");
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+}
 function normalizePdfPageNumbers(pageNumbers, pageCount) {
   if (!pageNumbers || pageNumbers.length === 0) {
     return Array.from({ length: pageCount }, (_, index) => index + 1);
   }
   return [...new Set(pageNumbers)].filter((pageNumber) => pageNumber >= 1 && pageNumber <= pageCount).sort((left, right) => left - right);
 }
-async function runWithConcurrency(items, concurrency, execute) {
+async function runWithConcurrency(items, concurrency, execute, signal) {
   const results = new Array(items.length);
   let nextIndex = 0;
   const workerCount = Math.max(1, Math.min(concurrency, items.length));
   await Promise.all(
     Array.from({ length: workerCount }, async () => {
       while (nextIndex < items.length) {
+        throwIfAborted(signal);
         const currentIndex = nextIndex;
         nextIndex += 1;
         const item = items[currentIndex];
@@ -261,6 +288,7 @@ async function runWithConcurrency(items, concurrency, execute) {
           continue;
         }
         results[currentIndex] = await execute(item);
+        throwIfAborted(signal);
       }
     })
   );
@@ -270,9 +298,49 @@ async function loadPdfToStore(file, store, options) {
   const scale = options?.scale ?? 1.5;
   const pageConcurrency = options?.pageConcurrency ?? 2;
   const storeThumbnails = options?.storeThumbnails ?? false;
+  const signal = options?.signal;
+  throwIfAborted(signal);
   const pdfjs = await getPdfJs();
+  throwIfAborted(signal);
   const arrayBuffer = await file.arrayBuffer();
-  const pdf = await pdfjs.getDocument({ data: arrayBuffer }).promise;
+  throwIfAborted(signal);
+  const loadingTask = pdfjs.getDocument({ data: arrayBuffer });
+  if (signal) {
+    const abortLoading = () => {
+      void loadingTask.destroy();
+    };
+    signal.addEventListener("abort", abortLoading, { once: true });
+    try {
+      const pdf2 = await loadingTask.promise;
+      signal.removeEventListener("abort", abortLoading);
+      return await loadPdfDocumentToStore(pdf2, store, {
+        scale,
+        pageNumbers: options?.pageNumbers,
+        pageConcurrency,
+        storeThumbnails,
+        signal,
+        onPageStored: options?.onPageStored
+      });
+    } catch (error) {
+      if (signal.aborted) throw createAbortError();
+      throw error;
+    } finally {
+      signal.removeEventListener("abort", abortLoading);
+    }
+  }
+  const pdf = await loadingTask.promise;
+  return await loadPdfDocumentToStore(pdf, store, {
+    scale,
+    pageNumbers: options?.pageNumbers,
+    pageConcurrency,
+    storeThumbnails,
+    onPageStored: options?.onPageStored
+  });
+}
+async function loadPdfDocumentToStore(pdf, store, options) {
+  const { pageConcurrency, scale, signal } = options;
+  const storeThumbnails = options.storeThumbnails ?? false;
+  throwIfAborted(signal);
   const pageNumbers = normalizePdfPageNumbers(options?.pageNumbers, pdf.numPages);
   const bufferedResults = /* @__PURE__ */ new Map();
   let nextEmitIndex = 0;
@@ -287,7 +355,9 @@ async function loadPdfToStore(file, store, options) {
         if (!bufferedResult) break;
         bufferedResults.delete(nextPageNumber);
         nextEmitIndex += 1;
+        throwIfAborted(signal);
         await options?.onPageStored?.(bufferedResult);
+        throwIfAborted(signal);
       }
     };
     const nextChain = emitChain.then(run, run);
@@ -299,11 +369,20 @@ async function loadPdfToStore(file, store, options) {
     pageNumbers,
     pageConcurrency,
     async (pageNumber) => {
+      throwIfAborted(signal);
       const page = await pdf.getPage(pageNumber);
-      const { canvas, width, height } = await renderPageToCanvas(page, scale);
+      throwIfAborted(signal);
+      const { canvas, width, height } = await renderPageToCanvas(
+        page,
+        scale,
+        signal
+      );
+      throwIfAborted(signal);
       const mime = "image/png";
       const pageBlob = await encodeCanvasToBlob(canvas, { mimeType: mime });
+      throwIfAborted(signal);
       const blobId = await store.storeOriginal(pageBlob);
+      throwIfAborted(signal);
       const thumbnailBlobId = storeThumbnails ? await (async () => {
         const thumbScale = Math.min(1, 256 / Math.max(width, height));
         const tw = Math.max(1, Math.round(width * thumbScale));
@@ -320,6 +399,7 @@ async function loadPdfToStore(file, store, options) {
         const thumbBlob = await encodeCanvasToBlob(thumbCanvas, {
           mimeType: mime
         });
+        throwIfAborted(signal);
         return await store.storeThumbnail(thumbBlob);
       })() : "";
       const pageResult = {
@@ -331,7 +411,8 @@ async function loadPdfToStore(file, store, options) {
       };
       await queuePageEmission(pageResult);
       return pageResult;
-    }
+    },
+    signal
   );
 }