canvu-react 0.4.74 → 0.4.75

package/dist/index.js

@@ -203,6 +203,342 @@ var IndexedDbImageStore = class {
   }
 };
 
+// src/image/pdf-worker-renderer.ts
+var PDF_WORKER_SOURCE = `
+let pdfjsPromise = null;
+
+const loadPdfJs = async (pdfjsModuleCandidates) => {
+	if (!pdfjsPromise) {
+		pdfjsPromise = (async () => {
+			let lastError;
+			for (const candidate of pdfjsModuleCandidates) {
+				try {
+					const pdfjs = await import(candidate.moduleUrl);
+					if (pdfjs.GlobalWorkerOptions) {
+						pdfjs.GlobalWorkerOptions.workerSrc = candidate.workerUrl;
+					}
+					return pdfjs;
+				} catch (error) {
+					lastError = error;
+				}
+			}
+			throw lastError ?? new Error("Unable to load pdfjs-dist");
+		})();
+	}
+	return await pdfjsPromise;
+};
+
+const createErrorPayload = (error) => ({
+	message: error instanceof Error ? error.message : String(error),
+	name: error instanceof Error ? error.name : "Error",
+	stack: error instanceof Error ? error.stack : undefined,
+});
+
+const normalizePdfPageNumbers = (pageNumbers, pageCount) => {
+	if (!Array.isArray(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);
+};
+
+const runWithConcurrency = async (items, concurrency, execute) => {
+	const results = new Array(items.length);
+	let nextIndex = 0;
+	const safeConcurrency = Number.isFinite(concurrency) && concurrency > 0
+		? Math.round(concurrency)
+		: 1;
+	const workerCount = Math.max(1, Math.min(safeConcurrency, items.length));
+	await Promise.all(
+		Array.from({ length: workerCount }, async () => {
+			while (nextIndex < items.length) {
+				const currentIndex = nextIndex;
+				nextIndex += 1;
+				const item = items[currentIndex];
+				if (item === undefined) {
+					continue;
+				}
+				results[currentIndex] = await execute(item);
+			}
+		}),
+	);
+	return results;
+};
+
+const renderPageToBlob = async (page, scale, storeThumbnails) => {
+	const raw = page.getViewport({ scale: 1 });
+	const adjustedScale = Math.round(raw.width * scale) / raw.width;
+	const viewport = page.getViewport({ scale: adjustedScale });
+	const width = Math.round(viewport.width);
+	const height = Math.round(viewport.height);
+	const canvas = new OffscreenCanvas(width, height);
+	const canvasContext = canvas.getContext("2d");
+	if (!canvasContext) {
+		throw new Error("OffscreenCanvas 2D context unavailable");
+	}
+	canvasContext.imageSmoothingEnabled = true;
+	canvasContext.imageSmoothingQuality = "high";
+	await page.render({ canvasContext, viewport }).promise;
+	const blob = await canvas.convertToBlob({ type: "image/png" });
+	let thumbnailBlob;
+	if (storeThumbnails) {
+		const thumbScale = Math.min(1, 256 / Math.max(width, height));
+		const thumbnailWidth = Math.max(1, Math.round(width * thumbScale));
+		const thumbnailHeight = Math.max(1, Math.round(height * thumbScale));
+		const thumbnailCanvas = new OffscreenCanvas(thumbnailWidth, thumbnailHeight);
+		const thumbnailContext = thumbnailCanvas.getContext("2d");
+		if (thumbnailContext) {
+			thumbnailContext.imageSmoothingEnabled = true;
+			thumbnailContext.imageSmoothingQuality = "high";
+			thumbnailContext.drawImage(canvas, 0, 0, thumbnailWidth, thumbnailHeight);
+		}
+		thumbnailBlob = await thumbnailCanvas.convertToBlob({ type: "image/png" });
+	}
+	return { blob, height, thumbnailBlob, width };
+};
+
+self.onmessage = async (event) => {
+	const message = event.data;
+	if (!message || message.type !== "render") {
+		return;
+	}
+	try {
+		const pdfjs = await loadPdfJs(message.pdfjsModuleCandidates);
+		const pdf = await pdfjs.getDocument({
+			data: new Uint8Array(message.pdfData),
+			disableWorker: true,
+		}).promise;
+		try {
+			const pageNumbers = normalizePdfPageNumbers(message.pageNumbers, pdf.numPages);
+			const bufferedPages = new Map();
+			let nextEmitIndex = 0;
+			let emitChain = Promise.resolve();
+			const emitPageInOrder = async (pageNumber, renderedPage) => {
+				bufferedPages.set(pageNumber, renderedPage);
+				const flush = () => {
+					while (nextEmitIndex < pageNumbers.length) {
+						const nextPageNumber = pageNumbers[nextEmitIndex];
+						if (nextPageNumber == null) break;
+						const nextPage = bufferedPages.get(nextPageNumber);
+						if (!nextPage) break;
+						bufferedPages.delete(nextPageNumber);
+						nextEmitIndex += 1;
+						self.postMessage({
+							type: "page",
+							page: {
+								...nextPage,
+								pageNumber: nextPageNumber,
+							},
+						});
+					}
+				};
+				const nextChain = emitChain.then(flush, flush);
+				emitChain = nextChain.catch(() => {});
+				await nextChain;
+			};
+			await runWithConcurrency(
+				pageNumbers,
+				message.pageConcurrency,
+				async (pageNumber) => {
+					const page = await pdf.getPage(pageNumber);
+					try {
+						const renderedPage = await renderPageToBlob(
+							page,
+							message.scale,
+							message.storeThumbnails,
+						);
+						await emitPageInOrder(pageNumber, renderedPage);
+					} finally {
+						page.cleanup();
+					}
+				},
+			);
+			await emitChain;
+		} finally {
+			await pdf.destroy();
+		}
+		self.postMessage({ type: "done" });
+	} catch (error) {
+		self.postMessage({ type: "error", error: createErrorPayload(error) });
+	}
+};
+`;
+var isRecord = (value) => typeof value === "object" && value !== null;
+var hasObjectMembers = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var isOffscreenCanvasCandidate = (value) => typeof value === "function";
+var getEnvironmentRecord = (environment) => isRecord(environment) ? environment : null;
+var canUsePdfWorkerRenderer = (environment = globalThis) => {
+  const candidateEnvironment = getEnvironmentRecord(environment);
+  if (!candidateEnvironment) return false;
+  if (typeof candidateEnvironment.Worker !== "function") return false;
+  if (typeof candidateEnvironment.Blob !== "function") return false;
+  if (!isOffscreenCanvasCandidate(candidateEnvironment.OffscreenCanvas)) {
+    return false;
+  }
+  const urlCandidate = candidateEnvironment.URL;
+  if (!hasObjectMembers(urlCandidate)) return false;
+  if (typeof urlCandidate.createObjectURL !== "function") return false;
+  if (typeof urlCandidate.revokeObjectURL !== "function") return false;
+  try {
+    const canvas = new candidateEnvironment.OffscreenCanvas(1, 1);
+    return typeof canvas.getContext === "function" && typeof canvas.convertToBlob === "function";
+  } catch {
+    return false;
+  }
+};
+var createAbortError = () => new DOMException("Aborted", "AbortError");
+var throwIfAborted = (signal) => {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+};
+var createPdfWorker = () => {
+  const workerBlob = new Blob([PDF_WORKER_SOURCE], {
+    type: "text/javascript"
+  });
+  const workerUrl = URL.createObjectURL(workerBlob);
+  try {
+    const worker = new Worker(workerUrl, {
+      name: "canvu-pdf-renderer",
+      type: "module"
+    });
+    return {
+      release: () => URL.revokeObjectURL(workerUrl),
+      worker
+    };
+  } catch (error) {
+    URL.revokeObjectURL(workerUrl);
+    throw error;
+  }
+};
+var createWorkerError = (message) => {
+  const error = new Error(message.error.message);
+  error.name = message.error.name;
+  error.stack = message.error.stack;
+  return error;
+};
+var PACKAGED_PDFJS_MODULE_FILE = "./pdf.mjs";
+var PACKAGED_PDFJS_WORKER_FILE = "./pdf.worker.mjs";
+var resolveRelativeAssetUrl = (path, baseUrl) => new URL(path, baseUrl).toString();
+var resolvePackagedPdfJsModuleCandidate = (baseUrl = import.meta.url) => ({
+  moduleUrl: resolveRelativeAssetUrl(PACKAGED_PDFJS_MODULE_FILE, baseUrl),
+  workerUrl: resolveRelativeAssetUrl(PACKAGED_PDFJS_WORKER_FILE, baseUrl)
+});
+var resolveBundledPdfJsModuleCandidate = () => ({
+  moduleUrl: new URL("pdfjs-dist/build/pdf.min.mjs", import.meta.url).toString(),
+  workerUrl: new URL(
+    "pdfjs-dist/build/pdf.worker.min.mjs",
+    import.meta.url
+  ).toString()
+});
+var resolvePdfJsModuleCandidates = () => [
+  resolvePackagedPdfJsModuleCandidate(),
+  resolveBundledPdfJsModuleCandidate()
+];
+var loadPdfToStoreWithWorker = async (file, store, options) => {
+  throwIfAborted(options.signal);
+  const arrayBuffer = await file.arrayBuffer();
+  throwIfAborted(options.signal);
+  return await new Promise((resolve, reject) => {
+    const { release, worker } = createPdfWorker();
+    const pageResults = [];
+    let storeChain = Promise.resolve();
+    let cleanedUp = false;
+    let settled = false;
+    const cleanup = () => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      options.signal?.removeEventListener("abort", abortWorker);
+      worker.onmessage = null;
+      worker.onerror = null;
+      worker.terminate();
+      release();
+    };
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const rejectAfterQueuedStores = (error) => {
+      if (settled) return;
+      cleanup();
+      storeChain.then(() => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      }).catch(rejectOnce);
+    };
+    function abortWorker() {
+      rejectOnce(createAbortError());
+    }
+    const storePage = (message) => {
+      try {
+        options.onPageReceived?.({ pageNumber: message.page.pageNumber });
+      } catch (error) {
+        rejectOnce(error);
+        return;
+      }
+      storeChain = storeChain.then(async () => {
+        throwIfAborted(options.signal);
+        const blobId = await store.storeOriginal(message.page.blob);
+        throwIfAborted(options.signal);
+        const thumbnailBlobId = options.storeThumbnails && message.page.thumbnailBlob ? await store.storeThumbnail(message.page.thumbnailBlob) : "";
+        throwIfAborted(options.signal);
+        const pageResult = {
+          blobId,
+          height: message.page.height,
+          pageNumber: message.page.pageNumber,
+          thumbnailBlobId,
+          width: message.page.width
+        };
+        pageResults.push(pageResult);
+        await options.onPageStored?.(pageResult);
+        throwIfAborted(options.signal);
+      });
+      void storeChain.catch(rejectOnce);
+    };
+    worker.onmessage = (event) => {
+      const message = event.data;
+      if (message.type === "page") {
+        storePage(message);
+        return;
+      }
+      if (message.type === "error") {
+        rejectAfterQueuedStores(createWorkerError(message));
+        return;
+      }
+      storeChain.then(() => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(pageResults);
+      }).catch(rejectOnce);
+    };
+    worker.onerror = (event) => {
+      rejectAfterQueuedStores(event.error ?? new Error(event.message));
+    };
+    options.signal?.addEventListener("abort", abortWorker, { once: true });
+    try {
+      worker.postMessage(
+        {
+          pdfData: arrayBuffer,
+          pdfjsModuleCandidates: resolvePdfJsModuleCandidates(),
+          pageNumbers: options.pageNumbers ? [...options.pageNumbers] : void 0,
+          pageConcurrency: options.pageConcurrency,
+          scale: options.scale,
+          storeThumbnails: options.storeThumbnails,
+          type: "render"
+        },
+        [arrayBuffer]
+      );
+    } catch (error) {
+      rejectOnce(error);
+    }
+  });
+};
+
 // src/image/pdf-loader.ts
 var pdfjsPromise = null;
 function getPdfJs() {
@@ -219,7 +555,7 @@ function getPdfJs() {
   return pdfjsPromise;
 }
 async function renderPageToCanvas(page, scale, signal) {
-  throwIfAborted(signal);
+  throwIfAborted2(signal);
   const raw = page.getViewport({ scale: 1 });
   const adjustedScale = Math.round(raw.width * scale) / raw.width;
   const viewport = page.getViewport({ scale: adjustedScale });
@@ -241,7 +577,7 @@ async function renderPageToCanvas(page, scale, signal) {
     try {
       await renderTask.promise;
     } catch (error) {
-      if (signal.aborted) throw createAbortError();
+      if (signal.aborted) throw createAbortError2();
       throw error;
     } finally {
       signal.removeEventListener("abort", abortRender);
@@ -249,15 +585,15 @@ async function renderPageToCanvas(page, scale, signal) {
   } else {
     await renderTask.promise;
   }
-  throwIfAborted(signal);
+  throwIfAborted2(signal);
   return { canvas, width: w, height: h };
 }
-function createAbortError() {
+function createAbortError2() {
   return new DOMException("Aborted", "AbortError");
 }
-function throwIfAborted(signal) {
+function throwIfAborted2(signal) {
   if (signal?.aborted) {
-    throw createAbortError();
+    throw createAbortError2();
   }
 }
 function normalizePdfPageNumbers(pageNumbers, pageCount) {
@@ -273,7 +609,7 @@ async function runWithConcurrency(items, concurrency, execute, signal) {
   await Promise.all(
     Array.from({ length: workerCount }, async () => {
       while (nextIndex < items.length) {
-        throwIfAborted(signal);
+        throwIfAborted2(signal);
         const currentIndex = nextIndex;
         nextIndex += 1;
         const item = items[currentIndex];
@@ -281,7 +617,7 @@ async function runWithConcurrency(items, concurrency, execute, signal) {
           continue;
         }
         results[currentIndex] = await execute(item);
-        throwIfAborted(signal);
+        throwIfAborted2(signal);
       }
     })
   );
@@ -292,11 +628,52 @@ async function loadPdfToStore(file, store, options) {
   const pageConcurrency = options?.pageConcurrency ?? 2;
   const storeThumbnails = options?.storeThumbnails ?? false;
   const signal = options?.signal;
-  throwIfAborted(signal);
+  throwIfAborted2(signal);
+  if (canUsePdfWorkerRenderer()) {
+    let workerPageCount = 0;
+    try {
+      return await loadPdfToStoreWithWorker(file, store, {
+        scale,
+        pageNumbers: options?.pageNumbers,
+        pageConcurrency,
+        storeThumbnails,
+        signal,
+        onPageReceived: () => {
+          workerPageCount += 1;
+        },
+        onPageStored: async (page) => {
+          await options?.onPageStored?.(page);
+        }
+      });
+    } catch (error) {
+      if (signal?.aborted || workerPageCount > 0) {
+        throw error;
+      }
+    }
+  }
+  return await loadPdfToStoreOnMainThread(file, store, {
+    scale,
+    pageNumbers: options?.pageNumbers,
+    pageConcurrency,
+    storeThumbnails,
+    signal,
+    onPageStored: options?.onPageStored
+  });
+}
+async function loadPdfToStoreOnMainThread(file, store, options) {
+  const {
+    pageConcurrency,
+    scale,
+    signal,
+    storeThumbnails,
+    onPageStored,
+    pageNumbers
+  } = options;
+  throwIfAborted2(signal);
   const pdfjs = await getPdfJs();
-  throwIfAborted(signal);
+  throwIfAborted2(signal);
   const arrayBuffer = await file.arrayBuffer();
-  throwIfAborted(signal);
+  throwIfAborted2(signal);
   const loadingTask = pdfjs.getDocument({ data: arrayBuffer });
   if (signal) {
     const abortLoading = () => {
@@ -308,14 +685,14 @@ async function loadPdfToStore(file, store, options) {
       signal.removeEventListener("abort", abortLoading);
       return await loadPdfDocumentToStore(pdf2, store, {
         scale,
-        pageNumbers: options?.pageNumbers,
+        pageNumbers,
         pageConcurrency,
         storeThumbnails,
         signal,
-        onPageStored: options?.onPageStored
+        onPageStored
       });
     } catch (error) {
-      if (signal.aborted) throw createAbortError();
+      if (signal.aborted) throw createAbortError2();
       throw error;
     } finally {
       signal.removeEventListener("abort", abortLoading);
@@ -324,16 +701,16 @@ async function loadPdfToStore(file, store, options) {
   const pdf = await loadingTask.promise;
   return await loadPdfDocumentToStore(pdf, store, {
     scale,
-    pageNumbers: options?.pageNumbers,
+    pageNumbers,
     pageConcurrency,
     storeThumbnails,
-    onPageStored: options?.onPageStored
+    onPageStored
   });
 }
 async function loadPdfDocumentToStore(pdf, store, options) {
   const { pageConcurrency, scale, signal } = options;
   const storeThumbnails = options.storeThumbnails ?? false;
-  throwIfAborted(signal);
+  throwIfAborted2(signal);
   const pageNumbers = normalizePdfPageNumbers(options?.pageNumbers, pdf.numPages);
   const bufferedResults = /* @__PURE__ */ new Map();
   let nextEmitIndex = 0;
@@ -348,9 +725,9 @@ async function loadPdfDocumentToStore(pdf, store, options) {
         if (!bufferedResult) break;
         bufferedResults.delete(nextPageNumber);
         nextEmitIndex += 1;
-        throwIfAborted(signal);
+        throwIfAborted2(signal);
         await options?.onPageStored?.(bufferedResult);
-        throwIfAborted(signal);
+        throwIfAborted2(signal);
       }
     };
     const nextChain = emitChain.then(run, run);
@@ -362,20 +739,20 @@ async function loadPdfDocumentToStore(pdf, store, options) {
     pageNumbers,
     pageConcurrency,
     async (pageNumber) => {
-      throwIfAborted(signal);
+      throwIfAborted2(signal);
       const page = await pdf.getPage(pageNumber);
-      throwIfAborted(signal);
+      throwIfAborted2(signal);
       const { canvas, width, height } = await renderPageToCanvas(
         page,
         scale,
         signal
       );
-      throwIfAborted(signal);
+      throwIfAborted2(signal);
       const mime = "image/png";
       const pageBlob = await encodeCanvasToBlob(canvas, { mimeType: mime });
-      throwIfAborted(signal);
+      throwIfAborted2(signal);
       const blobId = await store.storeOriginal(pageBlob);
-      throwIfAborted(signal);
+      throwIfAborted2(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));
@@ -392,7 +769,7 @@ async function loadPdfDocumentToStore(pdf, store, options) {
         const thumbBlob = await encodeCanvasToBlob(thumbCanvas, {
           mimeType: mime
         });
-        throwIfAborted(signal);
+        throwIfAborted2(signal);
         return await store.storeThumbnail(thumbBlob);
       })() : "";
       const pageResult = {