@loaders.gl/draco 4.4.0-alpha.2 → 4.4.0

package/dist/draco-worker.js

@@ -9,8 +9,9 @@
           "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
         );
         globalThis._loadersgl_.version = NPM_TAG;
+        warningIssued = true;
       } else {
-        globalThis._loadersgl_.version = "4.4.0-alpha.1";
+        globalThis._loadersgl_.version = "4.4.0";
       }
     }
     return globalThis._loadersgl_.version;
@@ -164,6 +165,16 @@
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
   var loadLibraryPromises = {};
+  function extractLoadLibraryOptions(options = {}) {
+    const useLocalLibraries = options.useLocalLibraries ?? options.core?.useLocalLibraries;
+    const CDN = options.CDN ?? options.core?.CDN;
+    const modules = options.modules;
+    return {
+      ...useLocalLibraries !== void 0 ? { useLocalLibraries } : {},
+      ...CDN !== void 0 ? { CDN } : {},
+      ...modules !== void 0 ? { modules } : {}
+    };
+  }
   async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
       libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
@@ -173,6 +184,9 @@
     return await loadLibraryPromises[libraryUrl];
   }
   function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (options?.core) {
+      throw new Error("loadLibrary: options.core must be pre-normalized");
+    }
     if (!options.useLocalLibraries && library.startsWith("http")) {
       return library;
     }
@@ -198,10 +212,20 @@
       return await loadAsArrayBuffer(libraryUrl);
     }
     if (!isBrowser) {
+      const { requireFromFile } = globalThis.loaders || {};
       try {
-        const { requireFromFile } = globalThis.loaders || {};
-        return await requireFromFile?.(libraryUrl);
+        const result = await requireFromFile?.(libraryUrl);
+        if (result || !libraryUrl.includes("/dist/libs/")) {
+          return result;
+        }
+        return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
       } catch (error) {
+        if (libraryUrl.includes("/dist/libs/")) {
+          try {
+            return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
+          } catch {
+          }
+        }
         console.error(error);
         return null;
       }
@@ -237,7 +261,14 @@
       const response = await fetch(url);
       return await response.arrayBuffer();
     }
-    return await readFileAsArrayBuffer(url);
+    try {
+      return await readFileAsArrayBuffer(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsArrayBuffer(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load ArrayBuffer from ${url}`);
+    }
   }
   async function loadAsText(url) {
     const { readFileAsText } = globalThis.loaders || {};
@@ -245,7 +276,14 @@
       const response = await fetch(url);
       return await response.text();
     }
-    return await readFileAsText(url);
+    try {
+      return await readFileAsText(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsText(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load text from ${url}`);
+    }
   }
 
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
@@ -324,7 +362,10 @@
     options = {
       ...options,
       modules: loader && loader.options && loader.options.modules || {},
-      worker: false
+      core: {
+        ...options.core,
+        worker: false
+      }
     };
     return await parser(data, { ...options }, context, loader);
   }
@@ -350,21 +391,32 @@
     [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
   };
   var loadDecoderPromise;
-  async function loadDracoDecoderModule(options) {
+  async function loadDracoDecoderModule(options = {}, type) {
     const modules = options.modules || {};
     if (modules.draco3d) {
       loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
         return { draco };
       });
     } else {
-      loadDecoderPromise ||= loadDracoDecoder(options);
+      loadDecoderPromise ||= loadDracoDecoder(options, type);
     }
     return await loadDecoderPromise;
   }
-  async function loadDracoDecoder(options) {
+  function getLibraryExport(library, exportName) {
+    if (library && typeof library === "object") {
+      if (library.default) {
+        return library.default;
+      }
+      if (library[exportName]) {
+        return library[exportName];
+      }
+    }
+    return library;
+  }
+  async function loadDracoDecoder(options, type) {
     let DracoDecoderModule;
     let wasmBinary;
-    switch (options.draco && options.draco.decoderType) {
+    switch (type) {
       case "js":
         DracoDecoderModule = await loadLibrary(
           DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
@@ -375,25 +427,52 @@
         break;
       case "wasm":
       default:
-        [DracoDecoderModule, wasmBinary] = await Promise.all([
-          await loadLibrary(
-            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
-            "draco",
-            options,
-            DRACO_EXTERNAL_LIBRARIES.DECODER
-          ),
-          await loadLibrary(
-            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
-            "draco",
-            options,
-            DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
-          )
-        ]);
+        try {
+          [DracoDecoderModule, wasmBinary] = await Promise.all([
+            await loadLibrary(
+              DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+              "draco",
+              options,
+              DRACO_EXTERNAL_LIBRARIES.DECODER
+            ),
+            await loadLibrary(
+              DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+              "draco",
+              options,
+              DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+            )
+          ]);
+        } catch {
+          DracoDecoderModule = null;
+          wasmBinary = null;
+        }
     }
+    DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
     DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    if (!DracoDecoderModule && !isBrowser) {
+      [DracoDecoderModule, wasmBinary] = await Promise.all([
+        await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+          "draco",
+          { ...options, useLocalLibraries: true },
+          DRACO_EXTERNAL_LIBRARIES.DECODER
+        ),
+        await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+          "draco",
+          { ...options, useLocalLibraries: true },
+          DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+        )
+      ]);
+      DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
+      DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    }
     return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
   }
   function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+    if (typeof DracoDecoderModule !== "function") {
+      throw new Error("DracoDecoderModule could not be loaded");
+    }
     const options = {};
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
@@ -408,7 +487,7 @@
   }
 
   // src/lib/utils/version.ts
-  var VERSION2 = true ? "4.4.0-alpha.1" : "latest";
+  var VERSION2 = true ? "4.4.0" : "latest";
 
   // ../schema-utils/src/lib/schema/data-type.ts
   function getDataTypeFromTypedArray(array) {
@@ -1002,7 +1081,6 @@
       draco: {
         decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
         // 'js' for IE11
-        libraryPath: "libs/",
         extraAttributes: {},
         attributeNameEntry: void 0
       }
@@ -1013,7 +1091,10 @@
     parse
   };
   async function parse(arrayBuffer, options) {
-    const { draco } = await loadDracoDecoderModule(options);
+    const { draco } = await loadDracoDecoderModule(
+      extractLoadLibraryOptions(options),
+      options?.draco?.decoderType || "wasm"
+    );
     const dracoParser = new DracoParser(draco);
     try {
       return dracoParser.parseSync(arrayBuffer, options?.draco);