@toolpath/viewer 2.3.0 → 2.3.3

package/dist/{chunk-N54FHMTG.js → chunk-M2B3CQPQ.js}

@@ -1,5 +1,5 @@
 // src/engine/engine-part.tsx
-import { useEffect as useEffect8, useMemo as useMemo8 } from "react";
+import { useEffect as useEffect8 } from "react";
 
 // src/part-mesh.tsx
 import { useThree as useThree8 } from "@react-three/fiber";
@@ -4183,6 +4183,8 @@ function createEngineGeometryCache(loadGeometry = async (part) => {
   return geometry;
 }, maximumEntries = 8) {
   const resources = /* @__PURE__ */ new Map();
+  const requests = /* @__PURE__ */ new WeakMap();
+  let failures = /* @__PURE__ */ new WeakMap();
   let accessSequence = 0;
   const touch = (resource) => {
     resource.lastAccess = ++accessSequence;
@@ -4202,11 +4204,31 @@ function createEngineGeometryCache(loadGeometry = async (part) => {
       oldest[1].geometry?.dispose();
     }
   };
+  const rememberFailure = (part, requestKey, resource) => {
+    const attempts = failures;
+    void resource.promise.then(() => {
+      if (resource.status === "rejected" && requests.get(resource) === requestKey) {
+        attempts.set(part, resource);
+      }
+    });
+  };
   return {
     get(part) {
       const key = engineGeometryResourceKey(part.mesh);
       const existing = resources.get(key);
+      if (existing?.status === "fulfilled") {
+        failures.delete(part);
+        touch(existing);
+        return existing;
+      }
+      const requestKey = JSON.stringify([part.mesh.glbUrl, part.mesh.stlUrl]);
+      const failed = failures.get(part);
+      if (failed && requests.get(failed) === requestKey) {
+        touch(failed);
+        return failed;
+      }
       if (existing) {
+        rememberFailure(part, requestKey, existing);
         touch(existing);
         return existing;
       }
@@ -4216,6 +4238,7 @@ function createEngineGeometryCache(loadGeometry = async (part) => {
         references: 0,
         lastAccess: ++accessSequence
       };
+      requests.set(resource, requestKey);
       resource.promise = loadGeometry(part).then(
         (geometry) => {
           resource.status = "fulfilled";
@@ -4228,6 +4251,7 @@ function createEngineGeometryCache(loadGeometry = async (part) => {
         }
       );
       resources.set(key, resource);
+      rememberFailure(part, requestKey, resource);
       return resource;
     },
     retain(resource) {
@@ -4242,6 +4266,7 @@ function createEngineGeometryCache(loadGeometry = async (part) => {
     clear() {
       for (const resource of resources.values()) resource.geometry?.dispose();
       resources.clear();
+      failures = /* @__PURE__ */ new WeakMap();
     }
   };
 }
@@ -4594,8 +4619,21 @@ function compareVersions(a, b) {
 
 // src/engine/engine-part.tsx
 import { jsx as jsx7 } from "react/jsx-runtime";
+var models = /* @__PURE__ */ new WeakMap();
+var modelForReport = (report) => {
+  if (typeof report !== "object" || report === null) {
+    return normalizePartReport(report);
+  }
+  const existing = models.get(report);
+  if (existing) {
+    return existing;
+  }
+  const model = normalizePartReport(report);
+  models.set(report, model);
+  return model;
+};
 var EnginePart = ({ report, ...props }) => {
-  const model = useMemo8(() => normalizePartReport(report), [report]);
+  const model = modelForReport(report);
   const resource = useGeometryResource(model);
   useEffect8(() => {
     engineGeometryCache.retain(resource);

package/dist/engine/index.js

@@ -12,7 +12,7 @@ import {
   parsePartGeometry,
   partMeshAssets,
   smoothRegionNormals
-} from "../chunk-N54FHMTG.js";
+} from "../chunk-M2B3CQPQ.js";
 export {
   EnginePart,
   MIN_KERNEL_VERSION,