@loaders.gl/gltf 4.2.0-alpha.5 → 4.2.0-beta.1

package/dist/dist.dev.js

@@ -45,13 +45,6 @@ var __exports__ = (() => {
     }
   });
 
-  // (disabled):../worker-utils/src/lib/node/require-utils.node
-  var require_require_utils = __commonJS({
-    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
-      "use strict";
-    }
-  });
-
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
@@ -108,6 +101,17 @@ 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/module-utils/js-module-utils.ts
+  function registerJSModules(modules) {
+    globalThis.loaders ||= {};
+    globalThis.loaders.modules ||= {};
+    Object.assign(globalThis.loaders.modules, modules);
+  }
+  function getJSModuleOrNull(name12) {
+    const module = globalThis.loaders?.modules?.[name12];
+    return module || null;
+  }
+
   // ../worker-utils/src/lib/env-utils/version.ts
   var NPM_TAG = "latest";
   function getVersion() {
@@ -154,7 +158,6 @@ var __exports__ = (() => {
   var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
-  var node = __toESM(require_require_utils(), 1);
   var loadLibraryPromises = {};
   async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
@@ -191,7 +194,8 @@ var __exports__ = (() => {
     }
     if (!isBrowser2) {
       try {
-        return node && void 0 && await (void 0)(libraryUrl);
+        const { requireFromFile } = globalThis.loaders || {};
+        return await requireFromFile?.(libraryUrl);
       } catch (error) {
         console.error(error);
         return null;
@@ -205,7 +209,8 @@ var __exports__ = (() => {
   }
   function loadLibraryFromString(scriptSource, id) {
     if (!isBrowser2) {
-      return void 0 && (void 0)(scriptSource, id);
+      const { requireFromString } = globalThis.loaders || {};
+      return requireFromString?.(scriptSource, id);
     }
     if (isWorker) {
       eval.call(globalThis, scriptSource);
@@ -222,18 +227,20 @@ var __exports__ = (() => {
     return null;
   }
   async function loadAsArrayBuffer(url) {
-    if (isBrowser2 || !void 0 || url.startsWith("http")) {
+    const { readFileAsArrayBuffer } = globalThis.loaders || {};
+    if (isBrowser2 || !readFileAsArrayBuffer || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.arrayBuffer();
     }
-    return await (void 0)(url);
+    return await readFileAsArrayBuffer(url);
   }
   async function loadAsText(url) {
-    if (isBrowser2 || !void 0 || url.startsWith("http")) {
+    const { readFileAsText } = globalThis.loaders || {};
+    if (isBrowser2 || !readFileAsText || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.text();
     }
-    return await (void 0)(url);
+    return await readFileAsText(url);
   }
 
   // ../loader-utils/src/lib/binary-utils/get-first-characters.ts
@@ -712,6 +719,8 @@ var __exports__ = (() => {
     // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
   };
   var ImageLoader = {
+    dataType: null,
+    batchType: null,
     id: "image",
     module: "images",
     name: "Images",
@@ -920,6 +929,10 @@ var __exports__ = (() => {
     };
   }
   var GLTFScenegraph = class {
+    // internal
+    gltf;
+    sourceBuffers;
+    byteLength;
     // TODO - why is this not GLTFWithBuffers - what happens to images?
     constructor(gltf) {
       this.gltf = {
@@ -1167,8 +1180,8 @@ var __exports__ = (() => {
      *   `name`, `extensions`, `extras`, `camera`, `children`, `skin`, `rotation`, `scale`, `translation`, `weights`
      *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#node
      */
-    addNode(node2) {
-      const { meshIndex, matrix } = node2;
+    addNode(node) {
+      const { meshIndex, matrix } = node;
       this.json.nodes = this.json.nodes || [];
       const nodeData = { mesh: meshIndex };
       if (matrix) {
@@ -2290,11 +2303,12 @@ var __exports__ = (() => {
   };
   var loadBasisTranscoderPromise;
   async function loadBasisTranscoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basis) {
-      return modules.basis;
+    registerJSModules(options.modules);
+    const basis = getJSModuleOrNull("basis");
+    if (basis) {
+      return basis;
     }
-    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
+    loadBasisTranscoderPromise ||= loadBasisTranscoder(options);
     return await loadBasisTranscoderPromise;
   }
   async function loadBasisTranscoder(options) {
@@ -2726,6 +2740,8 @@ var __exports__ = (() => {
 
   // ../textures/src/basis-loader.ts
   var BasisWorkerLoader = {
+    dataType: null,
+    batchType: null,
     name: "Basis",
     id: "basis",
     module: "textures",
@@ -2738,12 +2754,9 @@ var __exports__ = (() => {
     options: {
       basis: {
         format: "auto",
-        // gl context doesn't exist on a worker thread
         libraryPath: "libs/",
         containerFormat: "auto",
-        // 'basis' || 'ktx2' || 'auto'
         module: "transcoder"
-        // 'transcoder' || 'encoder'
       }
     }
   };
@@ -3191,6 +3204,8 @@ var __exports__ = (() => {
 
   // ../draco/src/draco-loader.ts
   var DracoLoader = {
+    dataType: null,
+    batchType: null,
     name: "Draco",
     id: "draco",
     module: "draco",
@@ -3345,10 +3360,17 @@ var __exports__ = (() => {
     4: Uint16Array,
     5: Int32Array,
     6: Uint32Array,
+    // 7: BigInt64Array,
+    // 8: BigUint64Array,
     9: Float32Array
+    // 10: Float64Array
+    // 11: BOOL - What array type do we use for this?
   };
   var INDEX_ITEM_SIZE = 4;
   var DracoParser = class {
+    draco;
+    decoder;
+    metadataQuerier;
     // draco - the draco decoder, either import `draco3d` or load dynamically
     constructor(draco) {
       this.draco = draco;
@@ -3515,14 +3537,17 @@ var __exports__ = (() => {
       for (const loaderAttribute of Object.values(loaderData.attributes)) {
         const attributeName = this._deduceAttributeName(loaderAttribute, options);
         loaderAttribute.name = attributeName;
-        const { value, size } = this._getAttributeValues(dracoGeometry, loaderAttribute);
-        attributes[attributeName] = {
-          value,
-          size,
-          byteOffset: loaderAttribute.byte_offset,
-          byteStride: loaderAttribute.byte_stride,
-          normalized: loaderAttribute.normalized
-        };
+        const values = this._getAttributeValues(dracoGeometry, loaderAttribute);
+        if (values) {
+          const { value, size } = values;
+          attributes[attributeName] = {
+            value,
+            size,
+            byteOffset: loaderAttribute.byte_offset,
+            byteStride: loaderAttribute.byte_stride,
+            normalized: loaderAttribute.normalized
+          };
+        }
       }
       return attributes;
     }
@@ -3564,6 +3589,10 @@ var __exports__ = (() => {
      */
     _getAttributeValues(dracoGeometry, attribute) {
       const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
+      if (!TypedArrayCtor) {
+        console.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`);
+        return null;
+      }
       const numComponents = attribute.num_components;
       const numPoints = dracoGeometry.num_points();
       const numValues = numPoints * numComponents;
@@ -3794,11 +3823,11 @@ var __exports__ = (() => {
   async function loadDracoDecoderModule(options) {
     const modules = options.modules || {};
     if (modules.draco3d) {
-      loadDecoderPromise = loadDecoderPromise || modules.draco3d.createDecoderModule({}).then((draco) => {
+      loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
         return { draco };
       });
     } else {
-      loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);
+      loadDecoderPromise ||= loadDracoDecoder(options);
     }
     return await loadDecoderPromise;
   }
@@ -5186,14 +5215,14 @@ var __exports__ = (() => {
   }
 
   // src/lib/extensions/KHR_texture_transform.ts
-  var EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
-  var name8 = EXT_MESHOPT_TRANSFORM;
+  var KHR_TEXTURE_TRANSFORM = "KHR_texture_transform";
+  var name8 = KHR_TEXTURE_TRANSFORM;
   var scratchVector = new Vector3();
   var scratchRotationMatrix = new Matrix3();
   var scratchScaleMatrix = new Matrix3();
   async function decode7(gltfData, options) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const hasExtension = gltfScenegraph.hasExtension(EXT_MESHOPT_TRANSFORM);
+    const hasExtension = gltfScenegraph.hasExtension(KHR_TEXTURE_TRANSFORM);
     if (!hasExtension || !options.gltf?.loadBuffers) {
       return;
     }
@@ -5203,27 +5232,19 @@ var __exports__ = (() => {
     }
   }
   function transformTexCoords(materialIndex, gltfData) {
-    const processedTexCoords = [];
     const material = gltfData.json.materials?.[materialIndex];
-    const baseColorTexture = material?.pbrMetallicRoughness?.baseColorTexture;
-    if (baseColorTexture) {
-      transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);
-    }
-    const emisiveTexture = material?.emissiveTexture;
-    if (emisiveTexture) {
-      transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);
-    }
-    const normalTexture = material?.normalTexture;
-    if (normalTexture) {
-      transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);
-    }
-    const occlusionTexture = material?.occlusionTexture;
-    if (occlusionTexture) {
-      transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);
-    }
-    const metallicRoughnessTexture = material?.pbrMetallicRoughness?.metallicRoughnessTexture;
-    if (metallicRoughnessTexture) {
-      transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);
+    const materialTextures = [
+      material?.pbrMetallicRoughness?.baseColorTexture,
+      material?.emissiveTexture,
+      material?.normalTexture,
+      material?.occlusionTexture,
+      material?.pbrMetallicRoughness?.metallicRoughnessTexture
+    ];
+    const processedTexCoords = [];
+    for (const textureInfo of materialTextures) {
+      if (textureInfo && textureInfo?.extensions?.[KHR_TEXTURE_TRANSFORM]) {
+        transformPrimitives(gltfData, materialIndex, textureInfo, processedTexCoords);
+      }
     }
   }
   function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
@@ -5242,7 +5263,7 @@ var __exports__ = (() => {
     }
   }
   function getTransformParameters(texture, processedTexCoords) {
-    const textureInfo = texture.extensions?.[EXT_MESHOPT_TRANSFORM];
+    const textureInfo = texture.extensions?.[KHR_TEXTURE_TRANSFORM];
     const { texCoord: originalTexCoord = 0 } = texture;
     const { texCoord = originalTexCoord } = textureInfo;
     const isProcessed = processedTexCoords.findIndex(
@@ -5363,12 +5384,12 @@ var __exports__ = (() => {
       gltfScenegraph.json.lights = extension.lights;
       gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);
     }
-    for (const node2 of json.nodes || []) {
-      const nodeExtension = gltfScenegraph.getObjectExtension(node2, KHR_LIGHTS_PUNCTUAL);
+    for (const node of json.nodes || []) {
+      const nodeExtension = gltfScenegraph.getObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
       if (nodeExtension) {
-        node2.light = nodeExtension.light;
+        node.light = nodeExtension.light;
       }
-      gltfScenegraph.removeObjectExtension(node2, KHR_LIGHTS_PUNCTUAL);
+      gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
     }
   }
   async function encode2(gltfData) {
@@ -5382,8 +5403,8 @@ var __exports__ = (() => {
     }
     if (gltfScenegraph.json.lights) {
       for (const light of gltfScenegraph.json.lights) {
-        const node2 = light.node;
-        gltfScenegraph.addObjectExtension(node2, KHR_LIGHTS_PUNCTUAL, light);
+        const node = light.node;
+        gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);
       }
       delete gltfScenegraph.json.lights;
     }
@@ -5581,22 +5602,21 @@ var __exports__ = (() => {
     texture: "textures"
   };
   var GLTFV1Normalizer = class {
-    constructor() {
-      this.idToIndexMap = {
-        animations: {},
-        accessors: {},
-        buffers: {},
-        bufferViews: {},
-        images: {},
-        materials: {},
-        meshes: {},
-        nodes: {},
-        samplers: {},
-        scenes: {},
-        skins: {},
-        textures: {}
-      };
-    }
+    idToIndexMap = {
+      animations: {},
+      accessors: {},
+      buffers: {},
+      bufferViews: {},
+      images: {},
+      materials: {},
+      meshes: {},
+      nodes: {},
+      samplers: {},
+      scenes: {},
+      skins: {},
+      textures: {}
+    };
+    json;
     // constructor() {}
     /**
      * Convert (normalize) glTF < 2.0 to glTF 2.0
@@ -5668,11 +5688,11 @@ var __exports__ = (() => {
       for (const mesh of json.meshes) {
         this._convertMeshIds(mesh);
       }
-      for (const node2 of json.nodes) {
-        this._convertNodeIds(node2);
+      for (const node of json.nodes) {
+        this._convertNodeIds(node);
       }
-      for (const node2 of json.scenes) {
-        this._convertSceneIds(node2);
+      for (const node of json.scenes) {
+        this._convertSceneIds(node);
       }
     }
     _convertTextureIds(texture) {
@@ -5694,17 +5714,17 @@ var __exports__ = (() => {
         }
       }
     }
-    _convertNodeIds(node2) {
-      if (node2.children) {
-        node2.children = node2.children.map((child) => this._convertIdToIndex(child, "node"));
+    _convertNodeIds(node) {
+      if (node.children) {
+        node.children = node.children.map((child) => this._convertIdToIndex(child, "node"));
       }
-      if (node2.meshes) {
-        node2.meshes = node2.meshes.map((mesh) => this._convertIdToIndex(mesh, "mesh"));
+      if (node.meshes) {
+        node.meshes = node.meshes.map((mesh) => this._convertIdToIndex(mesh, "mesh"));
       }
     }
     _convertSceneIds(scene) {
       if (scene.nodes) {
-        scene.nodes = scene.nodes.map((node2) => this._convertIdToIndex(node2, "node"));
+        scene.nodes = scene.nodes.map((node) => this._convertIdToIndex(node, "node"));
       }
     }
     /** Go through all objects in a top-level array and replace ids with indices */
@@ -5896,6 +5916,8 @@ var __exports__ = (() => {
 
   // src/gltf-loader.ts
   var GLTFLoader = {
+    dataType: null,
+    batchType: null,
     name: "glTF",
     id: "gltf",
     module: "gltf",
@@ -5990,6 +6012,8 @@ var __exports__ = (() => {
 
   // src/gltf-writer.ts
   var GLTFWriter = {
+    dataType: null,
+    batchType: null,
     name: "glTF",
     id: "gltf",
     module: "gltf",
@@ -6016,6 +6040,8 @@ var __exports__ = (() => {
 
   // src/glb-loader.ts
   var GLBLoader = {
+    dataType: null,
+    batchType: null,
     name: "GLB",
     id: "glb",
     module: "gltf",
@@ -6126,11 +6152,13 @@ var __exports__ = (() => {
     return COMPONENTS2[type];
   }
   var GLTFPostProcessor = class {
-    constructor() {
-      this.baseUri = "";
-      this.buffers = [];
-      this.images = [];
-    }
+    baseUri = "";
+    // @ts-expect-error
+    jsonUnprocessed;
+    // @ts-expect-error
+    json;
+    buffers = [];
+    images = [];
     postProcess(gltf, options = {}) {
       const { json, buffers = [], images = [] } = gltf;
       const { baseUri = "" } = gltf;
@@ -6170,8 +6198,8 @@ var __exports__ = (() => {
         json.meshes = gltf.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
       }
       if (gltf.nodes) {
-        json.nodes = gltf.nodes.map((node2, i2) => this._resolveNode(node2, i2));
-        json.nodes = json.nodes.map((node2, i2) => this._resolveNodeChildren(node2));
+        json.nodes = gltf.nodes.map((node, i2) => this._resolveNode(node, i2));
+        json.nodes = json.nodes.map((node, i2) => this._resolveNodeChildren(node));
       }
       if (gltf.skins) {
         json.skins = gltf.skins.map((skin, i2) => this._resolveSkin(skin, i2));
@@ -6236,26 +6264,26 @@ var __exports__ = (() => {
         ...scene,
         // @ts-ignore
         id: scene.id || `scene-${index}`,
-        nodes: (scene.nodes || []).map((node2) => this.getNode(node2))
+        nodes: (scene.nodes || []).map((node) => this.getNode(node))
       };
     }
     _resolveNode(gltfNode, index) {
-      const node2 = {
+      const node = {
         ...gltfNode,
         // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: gltfNode?.id || `node-${index}`
       };
       if (gltfNode.mesh !== void 0) {
-        node2.mesh = this.getMesh(gltfNode.mesh);
+        node.mesh = this.getMesh(gltfNode.mesh);
       }
       if (gltfNode.camera !== void 0) {
-        node2.camera = this.getCamera(gltfNode.camera);
+        node.camera = this.getCamera(gltfNode.camera);
       }
       if (gltfNode.skin !== void 0) {
-        node2.skin = this.getSkin(gltfNode.skin);
+        node.skin = this.getSkin(gltfNode.skin);
       }
       if (gltfNode.meshes !== void 0 && gltfNode.meshes.length) {
-        node2.mesh = gltfNode.meshes.reduce(
+        node.mesh = gltfNode.meshes.reduce(
           (accum, meshIndex) => {
             const mesh = this.getMesh(meshIndex);
             accum.id = mesh.id;
@@ -6265,13 +6293,13 @@ var __exports__ = (() => {
           { primitives: [] }
         );
       }
-      return node2;
+      return node;
     }
-    _resolveNodeChildren(node2) {
-      if (node2.children) {
-        node2.children = node2.children.map((child) => this.getNode(child));
+    _resolveNodeChildren(node) {
+      if (node.children) {
+        node.children = node.children.map((child) => this.getNode(child));
       }
-      return node2;
+      return node;
     }
     _resolveSkin(gltfSkin, index) {
       const inverseBindMatrices = typeof gltfSkin.inverseBindMatrices === "number" ? this.getAccessor(gltfSkin.inverseBindMatrices) : void 0;