@loaders.gl/gltf 4.4.0-alpha.1 → 4.4.0-alpha.11

package/dist/dist.dev.js

@@ -105,6 +105,9 @@ var __exports__ = (() => {
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
+  // ../loader-utils/src/lib/javascript-utils/is-type.ts
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
   // ../loader-utils/src/lib/module-utils/js-module-utils.ts
   function registerJSModules(modules) {
     globalThis.loaders ||= {};
@@ -120,14 +123,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__;
       }
@@ -174,6 +179,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;
     }
@@ -199,10 +207,20 @@ var __exports__ = (() => {
       return await loadAsArrayBuffer(libraryUrl);
     }
     if (!isBrowser2) {
+      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;
       }
@@ -238,7 +256,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 || {};
@@ -246,7 +271,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}`);
+    }
   }
 
   // ../loader-utils/src/lib/binary-utils/get-first-characters.ts
@@ -334,6 +366,27 @@ var __exports__ = (() => {
     return byteOffset;
   }
 
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function ensureArrayBuffer(bufferSource) {
+    if (bufferSource instanceof ArrayBuffer) {
+      return bufferSource;
+    }
+    if (isSharedArrayBuffer(bufferSource)) {
+      return copyToArrayBuffer(bufferSource);
+    }
+    const { buffer, byteOffset, byteLength } = bufferSource;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
+    }
+    return copyToArrayBuffer(buffer, byteOffset, byteLength);
+  }
+  function copyToArrayBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
+  }
+
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
   var IMAGE_SUPPORTED = typeof Image !== "undefined";
@@ -470,7 +523,6 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  var EMPTY_OBJECT = {};
   var imagebitmapOptionsSupported = true;
   async function parseToImageBitmap(arrayBuffer, options, url) {
     let blob;
@@ -498,8 +550,13 @@ var __exports__ = (() => {
     return await createImageBitmap(blob);
   }
   function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
+    if (!object) {
+      return true;
+    }
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        return false;
+      }
     }
     return true;
   }
@@ -1520,7 +1577,7 @@ var __exports__ = (() => {
       buffer = bufferArray.slice(offset, offset + byteLength).buffer;
       offset = 0;
     }
-    return new ArrayType(buffer, offset, length);
+    return new ArrayType(ensureArrayBuffer(buffer), offset, length);
   }
   function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
     const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
@@ -2278,7 +2335,7 @@ var __exports__ = (() => {
   }
   function createBufferView(typedArray, scenegraph) {
     scenegraph.gltf.buffers.push({
-      arrayBuffer: typedArray.buffer,
+      arrayBuffer: ensureArrayBuffer(typedArray.buffer),
       byteOffset: typedArray.byteOffset,
       byteLength: typedArray.byteLength
     });
@@ -2801,18 +2858,18 @@ var __exports__ = (() => {
     bgr565: { basisFormat: 15, compressed: false },
     rgba4444: { basisFormat: 16, compressed: false }
   };
-  async function parseBasis(data, options) {
-    if (options.basis.containerFormat === "auto") {
+  async function parseBasis(data, options = {}) {
+    if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
       if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options);
+        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
         return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-      const { BasisFile } = await loadBasisTranscoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options?.core || {});
       return parseBasisFile(BasisFile, data, options);
     }
     switch (options.basis.module) {
       case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options);
+        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
         switch (options.basis.containerFormat) {
           case "ktx2":
             return parseKTX2File(fileConstructors.KTX2File, data, options);
@@ -2822,7 +2879,7 @@ var __exports__ = (() => {
         }
       case "transcoder":
       default:
-        const { BasisFile } = await loadBasisTranscoderModule(options);
+        const { BasisFile } = await loadBasisTranscoderModule(options.core || {});
         return parseBasisFile(BasisFile, data, options);
     }
   }
@@ -2925,7 +2982,7 @@ var __exports__ = (() => {
     };
   }
   function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
+    let format = options.basis?.format;
     if (format === "auto") {
       format = selectSupportedBasisFormat();
     }
@@ -3100,7 +3157,7 @@ var __exports__ = (() => {
     if (absolute) {
       return url;
     }
-    const baseUrl = options.baseUri || options.uri;
+    const baseUrl = options?.core?.baseUri || options.baseUri || options.uri;
     if (!baseUrl) {
       throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
     }
@@ -3439,21 +3496,32 @@ var __exports__ = (() => {
     [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],
@@ -3464,25 +3532,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 && !isBrowser2) {
+      [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;
@@ -4102,7 +4197,10 @@ var __exports__ = (() => {
     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);
@@ -5566,7 +5664,7 @@ var __exports__ = (() => {
     const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
     if (Number.isFinite(texCoordAccessor)) {
       const accessor = gltfData.json.accessors?.[texCoordAccessor];
-      if (accessor && accessor.bufferView) {
+      if (accessor && accessor.bufferView !== void 0) {
         const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
         if (bufferView) {
           const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
@@ -5583,7 +5681,7 @@ var __exports__ = (() => {
             result.set([scratchVector[0], scratchVector[1]], i * components);
           }
           if (originalTexCoord === texCoord) {
-            updateGltf(accessor, bufferView, gltfData.buffers, result);
+            updateGltf(accessor, gltfData, result, accessor.bufferView);
           } else {
             createAttribute(texCoord, accessor, primitive, gltfData, result);
           }
@@ -5591,28 +5689,49 @@ var __exports__ = (() => {
       }
     }
   }
-  function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
+  function updateGltf(accessor, gltfData, newTexCoordArray, originalBufferViewIndex) {
     accessor.componentType = 5126;
-    buffers.push({
-      arrayBuffer: newTexCoordArray.buffer,
+    accessor.byteOffset = 0;
+    const accessors = gltfData.json.accessors || [];
+    const bufferViewReferenceCount = accessors.reduce((count, currentAccessor) => {
+      return currentAccessor.bufferView === originalBufferViewIndex ? count + 1 : count;
+    }, 0);
+    const shouldCreateNewBufferView = bufferViewReferenceCount > 1;
+    gltfData.buffers.push({
+      arrayBuffer: ensureArrayBuffer(newTexCoordArray.buffer),
       byteOffset: 0,
       byteLength: newTexCoordArray.buffer.byteLength
     });
-    bufferView.buffer = buffers.length - 1;
-    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    const newBufferIndex = gltfData.buffers.length - 1;
+    gltfData.json.bufferViews = gltfData.json.bufferViews || [];
+    if (shouldCreateNewBufferView) {
+      gltfData.json.bufferViews.push({
+        buffer: newBufferIndex,
+        byteLength: newTexCoordArray.buffer.byteLength,
+        byteOffset: 0
+      });
+      accessor.bufferView = gltfData.json.bufferViews.length - 1;
+      return;
+    }
+    const bufferView = gltfData.json.bufferViews[originalBufferViewIndex];
+    if (!bufferView) {
+      return;
+    }
+    bufferView.buffer = newBufferIndex;
     bufferView.byteOffset = 0;
-    delete bufferView.byteStride;
+    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    if (bufferView.byteStride !== void 0) {
+      delete bufferView.byteStride;
+    }
   }
   function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
     gltfData.buffers.push({
-      arrayBuffer: newTexCoordArray.buffer,
+      arrayBuffer: ensureArrayBuffer(newTexCoordArray.buffer),
       byteOffset: 0,
       byteLength: newTexCoordArray.buffer.byteLength
     });
+    gltfData.json.bufferViews = gltfData.json.bufferViews || [];
     const bufferViews = gltfData.json.bufferViews;
-    if (!bufferViews) {
-      return;
-    }
     bufferViews.push({
       buffer: gltfData.buffers.length - 1,
       byteLength: newTexCoordArray.buffer.byteLength,
@@ -6088,10 +6207,10 @@ var __exports__ = (() => {
     return gltf;
   }
   function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-    if (options.uri) {
-      gltf.baseUri = options.uri;
+    if (options.core?.baseUri) {
+      gltf.baseUri = options.core?.baseUri;
     }
-    if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {
+    if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options.glb)) {
       const textDecoder = new TextDecoder();
       data = textDecoder.decode(data);
     }
@@ -6179,14 +6298,16 @@ var __exports__ = (() => {
       arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
     }
     assert3(arrayBuffer, "glTF image has no data");
+    const strictOptions = options;
+    const gltfOptions = {
+      ...strictOptions,
+      core: { ...strictOptions?.core, mimeType: image.mimeType },
+      basis: strictOptions.basis || { format: selectSupportedBasisFormat() }
+    };
     let parsedImage = await parseFromContext(
       arrayBuffer,
       [ImageLoader, BasisLoader],
-      {
-        ...options,
-        mimeType: image.mimeType,
-        basis: options.basis || { format: selectSupportedBasisFormat() }
-      },
+      gltfOptions,
       context
     );
     if (parsedImage && parsedImage[0]) {
@@ -6227,18 +6348,15 @@ var __exports__ = (() => {
         // Create image objects
         decompressMeshes: true
         // Decompress Draco encoded meshes
-      },
-      // common?
-      log: console
-      // eslint-disable-line
+      }
     }
   };
   async function parse2(arrayBuffer, options = {}, context) {
-    options = { ...GLTFLoader.options, ...options };
-    options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
-    const { byteOffset = 0 } = options;
+    const mergedOptions = { ...GLTFLoader.options, ...options };
+    mergedOptions.gltf = { ...GLTFLoader.options.gltf, ...mergedOptions.gltf };
+    const byteOffset = options?.glb?.byteOffset || 0;
     const gltf = {};
-    return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
+    return await parseGLTF(gltf, arrayBuffer, byteOffset, mergedOptions, context);
   }
 
   // src/lib/encoders/encode-glb.ts
@@ -6352,9 +6470,8 @@ var __exports__ = (() => {
     return parseSync(arrayBuffer, options);
   }
   function parseSync(arrayBuffer, options) {
-    const { byteOffset = 0 } = options || {};
     const glb = {};
-    parseGLBSync(glb, arrayBuffer, byteOffset, options?.glb);
+    parseGLBSync(glb, arrayBuffer, options?.glb?.byteOffset || 0, options?.glb);
     return glb;
   }
 
@@ -6685,7 +6802,7 @@ var __exports__ = (() => {
         const buffer = accessor.bufferView.buffer;
         const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
         const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-        let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+        let cutBuffer = copyToArrayBuffer(buffer.arrayBuffer, byteOffset, byteLength);
         if (accessor.bufferView.byteStride) {
           cutBuffer = this._getValueFromInterleavedBuffer(
             buffer,