canvu-react 0.4.70 → 0.4.72

package/dist/{asset-hydration-D2xaUoAT.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-nK9kM9UJ.cjs';
+import { a as VectorViewportAssetStore } from './raster-image-canvas-ByaCKEVw.cjs';
 
 declare class IndexedDbImageStore {
     private dbPromise;

package/dist/{asset-hydration-D9eThWse.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-CCOmB4NY.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-D402X18k.cjs';
+import { c as CanvasPlugin } from './types-DOUBapS4.cjs';
 import 'react';
 import './types-fJNwEnHf.cjs';
 import './shape-builders-DzhCOuzo.cjs';
-import './raster-image-canvas-nK9kM9UJ.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-CMuEaiM7.js';
+import { c as CanvasPlugin } from './types-C5wxwquF.js';
 import 'react';
 import './types-fJNwEnHf.js';
 import './shape-builders-xG3A66sv.js';
-import './raster-image-canvas-CCOmB4NY.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
   );
 }
 
@@ -2588,6 +2669,7 @@ function resolveRasterImageCanvasRenderingOptions(options) {
   return {
     resolveSourceSize: options.resolveSourceSize,
     resolveRenderTarget: options.resolveRenderTarget,
+    resolveCanvasSource: options.resolveCanvasSource,
     devicePixelRatio: toPositiveFiniteNumber(
       options.devicePixelRatio,
       fallbackDevicePixelRatio
@@ -2852,6 +2934,36 @@ function loadImageElement(href, signal) {
     image.src = href;
   });
 }
+function normalizeDecodedRasterImageSource(source) {
+  if (!source) return null;
+  const width = Math.max(1, Math.round(source.width));
+  const height = Math.max(1, Math.round(source.height));
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  return {
+    width,
+    height,
+    draw: source.draw,
+    close: source.close ?? (() => {
+    })
+  };
+}
+async function resolveDecodedRasterImageSource({
+  options,
+  request,
+  width,
+  height,
+  signal
+}) {
+  if (options?.resolveCanvasSource) {
+    const source = await options.resolveCanvasSource({
+      ...request,
+      signal
+    });
+    const decoded = normalizeDecodedRasterImageSource(source);
+    if (decoded) return decoded;
+  }
+  return decodeRasterImage(request.targetHref, width, height, signal);
+}
 var SvgVectorRenderer = class {
   container;
   scene;
@@ -3084,7 +3196,20 @@ var SvgVectorRenderer = class {
     }
     const request = {
       itemHref: item.imageRasterHref,
-      target
+      target,
+      sourceRequest: {
+        item,
+        href: item.imageRasterHref,
+        intrinsicSize: item.imageIntrinsicSize,
+        sourceSize,
+        contentRect: target.contentRect,
+        targetSize: target.targetSize,
+        viewportSize,
+        cameraZoom: this.camera.zoom,
+        devicePixelRatio: options.devicePixelRatio,
+        targetHref: target.href,
+        sourceKey: target.sourceKey
+      }
     };
     if (rasterCanvas.abortController) {
       if (rasterCanvas.loadingItemHref !== item.imageRasterHref) {
@@ -3174,7 +3299,13 @@ var SvgVectorRenderer = class {
     rasterCanvas.loadingWidth = width;
     rasterCanvas.loadingHeight = height;
     rasterCanvas.queuedTarget = null;
-    decodeRasterImage(target.href, width, height, abortController.signal).then((decoded) => {
+    resolveDecodedRasterImageSource({
+      options: this.rasterImageCanvasRendering,
+      request: request.sourceRequest,
+      width,
+      height,
+      signal: abortController.signal
+    }).then((decoded) => {
       if (abortController.signal.aborted || rasterCanvas.loadSequence !== sequence) {
         decoded.close();
         return;