@loaders.gl/ply 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/{dist.min.js → dist.dev.js}

@@ -1,40 +1,54 @@
-(() => {
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['loader'] = factory();
+  else root['loader'] = factory();})(globalThis, function () {
+"use strict";
+var __exports__ = (() => {
   var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    PLYLoader: () => PLYLoader2,
+    PLYWorkerLoader: () => PLYLoader
+  });
 
   // src/ply-loader.ts
-  var VERSION, PLYLoader;
-  var init_ply_loader = __esm({
-    "src/ply-loader.ts"() {
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      PLYLoader = {
-        name: "PLY",
-        id: "ply",
-        module: "ply",
-        version: VERSION,
-        worker: true,
-        extensions: ["ply"],
-        mimeTypes: ["text/plain", "application/octet-stream"],
-        text: true,
-        binary: true,
-        tests: ["ply"],
-        options: {
-          ply: {}
-        }
-      };
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var PLYLoader = {
+    name: "PLY",
+    id: "ply",
+    module: "ply",
+    // shapes: ['mesh', 'gltf', 'columnar-table'],
+    version: VERSION,
+    worker: true,
+    extensions: ["ply"],
+    mimeTypes: ["text/plain", "application/octet-stream"],
+    text: true,
+    binary: true,
+    tests: ["ply"],
+    options: {
+      ply: {}
     }
-  });
+  };
 
   // ../schema/src/lib/table/simple-table/data-type.ts
   function getDataTypeFromTypedArray(array) {
@@ -60,10 +74,6 @@
         return "null";
     }
   }
-  var init_data_type = __esm({
-    "../schema/src/lib/table/simple-table/data-type.ts"() {
-    }
-  });
 
   // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
@@ -86,27 +96,30 @@
       maxY = y > maxY ? y : maxY;
       maxZ = z > maxZ ? z : maxZ;
     }
-    return [
-      [minX, minY, minZ],
-      [maxX, maxY, maxZ]
-    ];
+    return [[minX, minY, minZ], [maxX, maxY, maxZ]];
   }
-  var init_mesh_utils = __esm({
-    "../schema/src/lib/mesh/mesh-utils.ts"() {
-    }
-  });
 
   // ../schema/src/lib/mesh/deduce-mesh-schema.ts
   function deduceMeshSchema(attributes, metadata = {}) {
     const fields = deduceMeshFields(attributes);
-    return { fields, metadata };
+    return {
+      fields,
+      metadata
+    };
   }
   function deduceMeshField(name, attribute, optionalMetadata) {
     const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
     return {
       name,
-      type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
+      type: {
+        type: "fixed-size-list",
+        listSize: attribute.size,
+        children: [{
+          name: "value",
+          type
+        }]
+      },
       nullable: false,
       metadata
     };
@@ -132,19 +145,6 @@
     }
     return result;
   }
-  var init_deduce_mesh_schema = __esm({
-    "../schema/src/lib/mesh/deduce-mesh-schema.ts"() {
-      init_data_type();
-    }
-  });
-
-  // ../schema/src/index.ts
-  var init_src = __esm({
-    "../schema/src/index.ts"() {
-      init_mesh_utils();
-      init_deduce_mesh_schema();
-    }
-  });
 
   // src/lib/get-ply-schema.ts
   function getPLYSchema(plyHeader, attributes) {
@@ -167,11 +167,6 @@
     }
     return metadata;
   }
-  var init_get_ply_schema = __esm({
-    "src/lib/get-ply-schema.ts"() {
-      init_src();
-    }
-  });
 
   // src/lib/normalize-ply.ts
   function normalizePLY(plyHeader, plyAttributes, options) {
@@ -191,12 +186,18 @@
       },
       schema,
       attributes,
-      indices: { value: new Uint32Array(0), size: 0 },
+      indices: {
+        value: new Uint32Array(0),
+        size: 0
+      },
       mode,
       topology
     };
     if (plyAttributes.indices.length > 0) {
-      plyMesh.indices = { value: new Uint32Array(plyAttributes.indices), size: 1 };
+      plyMesh.indices = {
+        value: new Uint32Array(plyAttributes.indices),
+        size: 1
+      };
     }
     return plyMesh;
   }
@@ -206,41 +207,51 @@
       switch (attributeName) {
         case "vertices":
           if (attributes.vertices.length > 0) {
-            accessors.POSITION = { value: new Float32Array(attributes.vertices), size: 3 };
+            accessors.POSITION = {
+              value: new Float32Array(attributes.vertices),
+              size: 3
+            };
           }
           break;
         case "normals":
           if (attributes.normals.length > 0) {
-            accessors.NORMAL = { value: new Float32Array(attributes.normals), size: 3 };
+            accessors.NORMAL = {
+              value: new Float32Array(attributes.normals),
+              size: 3
+            };
           }
           break;
         case "uvs":
           if (attributes.uvs.length > 0) {
-            accessors.TEXCOORD_0 = { value: new Float32Array(attributes.uvs), size: 2 };
+            accessors.TEXCOORD_0 = {
+              value: new Float32Array(attributes.uvs),
+              size: 2
+            };
           }
           break;
         case "colors":
           if (attributes.colors.length > 0) {
-            accessors.COLOR_0 = { value: new Uint8Array(attributes.colors), size: 3, normalized: true };
+            accessors.COLOR_0 = {
+              value: new Uint8Array(attributes.colors),
+              size: 3,
+              normalized: true
+            };
           }
           break;
         case "indices":
           break;
         default:
           if (attributes[attributeName].length > 0) {
-            accessors[attributeName] = { value: new Float32Array(attributes[attributeName]), size: 1 };
+            accessors[attributeName] = {
+              value: new Float32Array(attributes[attributeName]),
+              size: 1
+            };
           }
           break;
       }
     }
     return accessors;
   }
-  var init_normalize_ply = __esm({
-    "src/lib/normalize-ply.ts"() {
-      init_src();
-      init_get_ply_schema();
-    }
-  });
 
   // src/lib/parse-ply.ts
   function parsePLY(data, options = {}) {
@@ -558,17 +569,14 @@
     }
     return attributes;
   }
-  var init_parse_ply = __esm({
-    "src/lib/parse-ply.ts"() {
-      init_normalize_ply();
-    }
-  });
 
   // ../loader-utils/src/lib/iterators/text-iterators.ts
   async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
     const textDecoder = new TextDecoder(void 0, options);
     for await (const arrayBuffer of arrayBufferIterator) {
-      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
+      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, {
+        stream: true
+      });
     }
   }
   async function* makeLineIterator(textIterator) {
@@ -586,15 +594,14 @@
       yield previous;
     }
   }
-  var init_text_iterators = __esm({
-    "../loader-utils/src/lib/iterators/text-iterators.ts"() {
-    }
-  });
 
   // ../loader-utils/src/lib/iterators/async-iteration.ts
   async function forEach(iterator, visitor) {
     while (true) {
-      const { done, value } = await iterator.next();
+      const {
+        done,
+        value
+      } = await iterator.next();
       if (done) {
         iterator.return();
         return;
@@ -605,20 +612,9 @@
       }
     }
   }
-  var init_async_iteration = __esm({
-    "../loader-utils/src/lib/iterators/async-iteration.ts"() {
-    }
-  });
-
-  // ../loader-utils/src/index.ts
-  var init_src2 = __esm({
-    "../loader-utils/src/index.ts"() {
-      init_text_iterators();
-      init_async_iteration();
-    }
-  });
 
   // src/lib/parse-ply-in-batches.ts
+  var currentElement;
   async function* parsePLYInBatches(iterator, options) {
     const lineIterator = makeLineIterator(makeTextDecoderIterator(iterator));
     const header = await parsePLYHeader(lineIterator, options);
@@ -636,6 +632,7 @@
     const header = {
       comments: [],
       elements: []
+      // headerLength
     };
     await forEach(lineIterator, (line) => {
       line = line.trim();
@@ -791,43 +788,18 @@
         break;
     }
   }
-  var currentElement;
-  var init_parse_ply_in_batches = __esm({
-    "src/lib/parse-ply-in-batches.ts"() {
-      init_src2();
-      init_normalize_ply();
-    }
-  });
 
   // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    PLYLoader: () => PLYLoader2,
-    PLYWorkerLoader: () => PLYLoader
-  });
-  var PLYLoader2;
-  var init_src3 = __esm({
-    "src/index.ts"() {
-      init_ply_loader();
-      init_parse_ply();
-      init_parse_ply_in_batches();
-      PLYLoader2 = {
-        ...PLYLoader,
-        parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
-        parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
-        parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
-        parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options?.ply)
-      };
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src3(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
+  var PLYLoader2 = {
+    ...PLYLoader,
+    // Note: parsePLY supports both text and binary
+    parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+    // TODO - this may not detect text correctly?
+    parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+    parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+    parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options?.ply)
+  };
+  return __toCommonJS(src_exports);
 })();
+      return __exports__;
+      });