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

package/dist/dist.dev.js

@@ -62,14 +62,16 @@ var __exports__ = (() => {
   var NPM_TAG = "beta";
 
   // ../worker-utils/src/lib/env-utils/version.ts
+  var warningIssued = false;
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (typeof __VERSION__ === "undefined") {
+      if (typeof __VERSION__ === "undefined" && !warningIssued) {
         console.warn(
           "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 = __VERSION__;
       }
@@ -116,6 +118,9 @@ var __exports__ = (() => {
     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;
     }
@@ -141,10 +146,20 @@ var __exports__ = (() => {
       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;
       }
@@ -180,7 +195,14 @@ var __exports__ = (() => {
       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 || {};
@@ -188,7 +210,14 @@ var __exports__ = (() => {
       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}`);
+    }
   }
 
   // src/lib/draco-module-loader.ts
@@ -213,14 +242,14 @@ var __exports__ = (() => {
   };
   var loadDecoderPromise;
   var loadEncoderPromise;
-  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;
   }
@@ -235,10 +264,21 @@ var __exports__ = (() => {
     }
     return await loadEncoderPromise;
   }
-  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],
@@ -249,25 +289,52 @@ var __exports__ = (() => {
         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;
@@ -287,7 +354,21 @@ var __exports__ = (() => {
       options,
       DRACO_EXTERNAL_LIBRARIES.ENCODER
     );
+    DracoEncoderModule = getLibraryExport(DracoEncoderModule, "DracoEncoderModule");
     DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
+    if (!DracoEncoderModule && !isBrowser) {
+      DracoEncoderModule = await loadLibrary(
+        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.ENCODER],
+        "draco",
+        { ...options, useLocalLibraries: true },
+        DRACO_EXTERNAL_LIBRARIES.ENCODER
+      );
+      DracoEncoderModule = getLibraryExport(DracoEncoderModule, "DracoEncoderModule");
+      DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
+    }
+    if (typeof DracoEncoderModule !== "function") {
+      throw new Error("DracoEncoderModule could not be loaded");
+    }
     return new Promise((resolve) => {
       DracoEncoderModule({
         onModuleLoaded: (draco) => resolve({ draco })
@@ -663,7 +744,7 @@ var __exports__ = (() => {
     encode
   };
   async function encode(data, options = {}) {
-    const { draco } = await loadDracoEncoderModule(options);
+    const { draco } = await loadDracoEncoderModule(options.core || {});
     const dracoBuilder = new DracoBuilder(draco);
     try {
       return dracoBuilder.encodeSync(data, options.draco);
@@ -13212,7 +13293,10 @@ return true;`);
     parse
   };
   async function parse(arrayBuffer, options) {
-    const { draco } = await loadDracoDecoderModule(options);
+    const { draco } = await loadDracoDecoderModule(
+      options?.core,
+      options?.draco?.decoderType || "wasm"
+    );
     const dracoParser = new DracoParser(draco);
     try {
       return dracoParser.parseSync(arrayBuffer, options?.draco);