canvu-react 0.3.11 → 0.3.13

package/dist/index.js

@@ -1706,7 +1706,8 @@ function collectEraserTargetsAtWorldPoint(items, worldX, worldY, options) {
 var HYDRATION_CACHE_NAME = "canvu-asset-hydration-v1";
 var DEFAULT_PDF_SCALE = 1.15;
 var DEFAULT_PDF_PAGE_CONCURRENCY = 2;
-var hydrationBlobPromises = /* @__PURE__ */ new Map();
+var hydrationSourcePromises = /* @__PURE__ */ new Map();
+var pdfSourceBlobPromises = /* @__PURE__ */ new Map();
 function buildImageHydrationKey(assetId) {
   return `image:${assetId}`;
 }
@@ -1754,23 +1755,38 @@ async function fetchBlob(url) {
     return null;
   }
 }
-async function getHydrationBlob(key, preferCachedRasters, loader) {
+async function getHydrationSource(key, preferCachedRasters, loader) {
   const cached = preferCachedRasters ? await readCachedHydrationBlob(key) : null;
-  if (cached) return cached;
-  const inFlight = hydrationBlobPromises.get(key);
+  if (cached) {
+    return {
+      blob: cached
+    };
+  }
+  const inFlight = hydrationSourcePromises.get(key);
   if (inFlight) return await inFlight;
   const nextPromise = (async () => {
-    const blob = await loader();
-    if (blob) {
-      await writeCachedHydrationBlob(key, blob);
+    const source = await loader();
+    if (source?.blob) {
+      await writeCachedHydrationBlob(key, source.blob);
     }
-    return blob;
+    return source;
   })();
-  hydrationBlobPromises.set(key, nextPromise);
+  hydrationSourcePromises.set(key, nextPromise);
   try {
     return await nextPromise;
   } finally {
-    hydrationBlobPromises.delete(key);
+    hydrationSourcePromises.delete(key);
+  }
+}
+async function getPdfSourceBlob(url) {
+  const inFlight = pdfSourceBlobPromises.get(url);
+  if (inFlight) return await inFlight;
+  const nextPromise = fetchBlob(url);
+  pdfSourceBlobPromises.set(url, nextPromise);
+  try {
+    return await nextPromise;
+  } finally {
+    pdfSourceBlobPromises.delete(url);
   }
 }
 function registerObjectUrl(objectUrls, blob) {
@@ -1824,18 +1840,22 @@ async function hydrateImageAssets(requests, resolvedAssetUrls, objectUrls, prefe
       if (!resolvedAsset?.url) {
         return [assetId, null];
       }
-      const blob = await getHydrationBlob(
+      const source = await getHydrationSource(
         buildImageHydrationKey(assetId),
         preferCachedRasters,
-        async () => await fetchBlob(resolvedAsset.url)
+        async () => {
+          const blob = await fetchBlob(resolvedAsset.url);
+          if (!blob) return null;
+          return { blob };
+        }
       );
-      if (!blob) {
+      if (!source?.blob) {
         return [assetId, null];
       }
       return [
         assetId,
         {
-          href: registerObjectUrl(objectUrls, blob)
+          href: registerObjectUrl(objectUrls, source.blob)
         }
       ];
     })
@@ -1850,45 +1870,69 @@ async function hydratePdfAssets(requests, resolvedAssetUrls, objectUrls, options
     if (!resolvedAsset?.url) {
       continue;
     }
-    const missingPages = [];
-    for (const pageNumber of group.pageNumbers) {
-      const cacheKey = buildPdfHydrationKey(group.assetId, pageNumber, group.scale);
-      const cachedBlob = await readCachedHydrationBlob(cacheKey);
-      if (!cachedBlob) {
-        missingPages.push(pageNumber);
+    const pageKeys = group.pageNumbers.map((pageNumber) => ({
+      pageNumber,
+      cacheKey: buildPdfHydrationKey(group.assetId, pageNumber, group.scale)
+    }));
+    const pagesToRender = [];
+    for (const { pageNumber, cacheKey } of pageKeys) {
+      const cachedBlob = options.preferCachedRasters ? await readCachedHydrationBlob(cacheKey) : null;
+      if (cachedBlob) {
+        hydratedPages.set(cacheKey, {
+          href: registerObjectUrl(objectUrls, cachedBlob)
+        });
         continue;
       }
-      hydratedPages.set(cacheKey, {
-        href: registerObjectUrl(objectUrls, cachedBlob)
-      });
-    }
-    if (missingPages.length === 0) {
-      continue;
+      if (!hydrationSourcePromises.has(cacheKey)) {
+        pagesToRender.push({ pageNumber, cacheKey });
+      }
     }
-    const pdfBlob = await fetchBlob(resolvedAsset.url);
-    if (!pdfBlob) {
-      continue;
+    if (pagesToRender.length > 0) {
+      const renderPromise = (async () => {
+        const pdfBlob = await getPdfSourceBlob(resolvedAsset.url);
+        if (!pdfBlob) {
+          return /* @__PURE__ */ new Map();
+        }
+        const renderedPages = await loadPdfToStore(pdfBlob, options.imageStore, {
+          scale: group.scale,
+          pageNumbers: pagesToRender.map(({ pageNumber }) => pageNumber),
+          pageConcurrency: options.pdfPageConcurrency
+        });
+        const renderedByPage = /* @__PURE__ */ new Map();
+        for (const renderedPage of renderedPages) {
+          const pageBlob = await options.imageStore.getOriginal(renderedPage.blobId);
+          renderedByPage.set(
+            renderedPage.pageNumber,
+            pageBlob ? {
+              blob: pageBlob,
+              width: renderedPage.width,
+              height: renderedPage.height
+            } : null
+          );
+        }
+        return renderedByPage;
+      })();
+      for (const { pageNumber, cacheKey } of pagesToRender) {
+        const pagePromise = getHydrationSource(
+          cacheKey,
+          options.preferCachedRasters,
+          async () => (await renderPromise).get(pageNumber) ?? null
+        );
+        hydrationSourcePromises.set(cacheKey, pagePromise);
+      }
     }
-    const renderedPages = await loadPdfToStore(pdfBlob, options.imageStore, {
-      scale: group.scale,
-      pageNumbers: missingPages,
-      pageConcurrency: options.pdfPageConcurrency
-    });
-    for (const renderedPage of renderedPages) {
-      const cacheKey = buildPdfHydrationKey(
-        group.assetId,
-        renderedPage.pageNumber,
-        group.scale
+    for (const { cacheKey } of pageKeys) {
+      if (hydratedPages.has(cacheKey)) continue;
+      const source = await getHydrationSource(
+        cacheKey,
+        options.preferCachedRasters,
+        async () => null
       );
-      const pageBlob = await options.imageStore.getOriginal(renderedPage.blobId);
-      if (!pageBlob) {
-        continue;
-      }
-      await writeCachedHydrationBlob(cacheKey, pageBlob);
+      if (!source?.blob) continue;
       hydratedPages.set(cacheKey, {
-        href: registerObjectUrl(objectUrls, pageBlob),
-        width: renderedPage.width,
-        height: renderedPage.height
+        href: registerObjectUrl(objectUrls, source.blob),
+        width: source.width,
+        height: source.height
       });
     }
   }
@@ -1929,7 +1973,9 @@ async function hydrateSceneItemsWithAssets(items, assetStore, options = {}) {
     objectUrls,
     {
       imageStore,
-      pdfPageConcurrency}
+      pdfPageConcurrency,
+      preferCachedRasters
+    }
   );
   return {
     items: items.map((item) => {