@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/pcd-worker.js

@@ -15,29 +15,41 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
   var parentPort;
   var init_worker_threads_browser = __esm({
-    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js"() {
       parentPort = null;
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
-    if (!object) {
-    } else if (isTransferable(object)) {
-      transfersSet.add(object);
-    } else if (isTransferable(object.buffer)) {
-      transfersSet.add(object.buffer);
-    } else if (ArrayBuffer.isView(object)) {
-    } else if (recursive && typeof object === "object") {
-      for (const key in object) {
-        getTransferList(object[key], recursive, transfersSet);
+    const seen = /* @__PURE__ */ new Set();
+    function visit(value) {
+      if (!value || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      if (isTransferable(value))
+        transfersSet.add(value);
+      else if (ArrayBuffer.isView(value)) {
+        if (isTransferable(value.buffer))
+          transfersSet.add(value.buffer);
+      } else if (recursive && value instanceof Map) {
+        for (const [key, item] of value) {
+          visit(key);
+          visit(item);
+        }
+      } else if (recursive && value instanceof Set) {
+        for (const item of value)
+          visit(item);
+      } else if (recursive) {
+        for (const key of Object.keys(value))
+          visit(value[key]);
       }
     }
+    visit(object);
     return transfers === void 0 ? Array.from(transfersSet) : [];
   }
   function isTransferable(object) {
@@ -59,12 +71,11 @@
     return false;
   }
   var init_get_transfer_list = __esm({
-    "../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-farm/worker-body.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
   async function getParentPort() {
     return parentPort;
   }
@@ -77,15 +88,15 @@
   }
   var onMessageWrapperMap, WorkerBody;
   var init_worker_body = __esm({
-    "../core/src/worker-utils/lib/worker-farm/worker-body.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js"() {
       init_get_transfer_list();
       init_worker_threads_browser();
       onMessageWrapperMap = /* @__PURE__ */ new Map();
       WorkerBody = class {
         /** Check that we are actually in a worker thread */
         static async inWorkerThread() {
-          return typeof self !== "undefined" || Boolean(await getParentPort());
+          const workerGlobalScope = globalThis.WorkerGlobalScope;
+          return typeof workerGlobalScope === "function" && globalThis instanceof workerGlobalScope || Boolean(await getParentPort());
         }
         /*
          * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
@@ -158,15 +169,11 @@
     }
   });
 
-  // ../core/src/worker-utils/lib/async-queue/async-queue.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
   var AsyncQueue;
   var init_async_queue = __esm({
-    "../core/src/worker-utils/lib/async-queue/async-queue.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js"() {
       AsyncQueue = class {
-        _values;
-        _settlers;
-        _closed;
         constructor() {
           this._values = [];
           this._settlers = [];
@@ -234,7 +241,51 @@
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+  var SharedWorkerState;
+  var init_shared_state = __esm({
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js"() {
+      SharedWorkerState = class {
+        constructor(buffer) {
+          if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
+            throw new Error("Expected a 16-byte shared worker control buffer");
+          this.buffer = buffer;
+          this.values = new Int32Array(buffer);
+        }
+        get snapshot() {
+          return {
+            cancelled: Atomics.load(this.values, 0) !== 0,
+            completed: Atomics.load(this.values, 1),
+            total: Atomics.load(this.values, 2),
+            revision: Atomics.load(this.values, 3)
+          };
+        }
+        cancel() {
+          Atomics.store(this.values, 0, 1);
+          Atomics.add(this.values, 3, 1);
+          Atomics.notify(this.values, 0);
+        }
+        throwIfCancelled() {
+          if (Atomics.load(this.values, 0) !== 0) {
+            const error = new Error("Shared worker task was cancelled");
+            error.name = "AbortError";
+            throw error;
+          }
+        }
+        /** Integer counters for application-defined work; messages still carry phase names and units. */
+        setProgress(completed, total = -1) {
+          if (!Number.isInteger(completed) || completed < 0 || completed > 2147483647 || !Number.isInteger(total) || total < -1 || total > 2147483647) {
+            throw new RangeError("Shared progress requires nonnegative int32 counts (or total -1)");
+          }
+          Atomics.store(this.values, 1, completed);
+          Atomics.store(this.values, 2, total);
+          Atomics.add(this.values, 3, 1);
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
   async function createWorker(process, processInBatches) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
@@ -243,27 +294,56 @@
       process: processOnMainThread
     };
     WorkerBody.onmessage = async (type, payload) => {
+      if (type === "cancel") {
+        activeController?.abort();
+        activeInputBatches?.close();
+        activeOutputAcknowledgements?.close();
+        return;
+      }
+      const controller = type === "process" || type === "process-in-batches" ? new AbortController() : void 0;
+      if (controller)
+        activeController = controller;
+      const startedAt = performance.now();
       const reporter = type === "process" || type === "process-in-batches" ? createProgressReporter() : void 0;
-      const jobContext = { ...context, reportProgress: reporter?.report };
+      let sharedState;
+      const throwIfAborted = () => {
+        controller?.signal.throwIfAborted();
+        sharedState?.throwIfCancelled();
+      };
+      const jobContext = {
+        ...context,
+        signal: controller?.signal,
+        sharedState,
+        throwIfAborted,
+        reportProgress: (progress) => {
+          if (!controller?.signal.aborted && !sharedState?.snapshot.cancelled)
+            reporter?.report(progress);
+        }
+      };
       try {
+        if (controller && payload.options?.["sharedState"]) {
+          sharedState = new SharedWorkerState(payload.options["sharedState"]);
+          jobContext.sharedState = sharedState;
+        }
         switch (type) {
           case "preload":
             WorkerBody.postMessage("done", {});
             break;
           case "process":
+            throwIfAborted();
             if (!process) {
               throw new Error("Worker does not support atomic processing");
             }
-            const result = await process(
-              payload.input,
-              payload.options || {},
-              jobContext,
-              payload.context || {}
-            );
+            const result = await process(payload.input, payload.options || {}, jobContext, payload.context || {});
+            throwIfAborted();
             reporter?.finish();
-            WorkerBody.postMessage("done", { result });
+            await WorkerBody.postMessage("done", {
+              result,
+              executionMs: performance.now() - startedAt
+            });
             break;
           case "process-in-batches":
+            throwIfAborted();
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
@@ -272,18 +352,15 @@
             activeInputBatches = inputBatches;
             activeOutputAcknowledgements = outputAcknowledgements;
             try {
-              const resultIterator = processInBatches(
-                createDemandDrivenIterator(inputBatches),
-                payload.options || {},
-                jobContext,
-                payload.context || {}
-              );
+              const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
               for await (const batch of resultIterator) {
+                throwIfAborted();
                 await WorkerBody.postMessage("output-batch", { result: batch });
                 await outputAcknowledgements.next();
               }
+              throwIfAborted();
               reporter?.finish();
-              await WorkerBody.postMessage("done", {});
+              await WorkerBody.postMessage("done", { executionMs: performance.now() - startedAt });
             } finally {
               activeInputBatches = null;
               activeOutputAcknowledgements = null;
@@ -310,11 +387,18 @@
           default:
         }
       } catch (error) {
-        reporter?.finish();
+        reporter?.finish(controller?.signal.aborted || sharedState?.snapshot.cancelled);
         const message = error instanceof Error ? error.message : "";
-        WorkerBody.postMessage("error", { error: message });
+        await WorkerBody.postMessage("error", {
+          error: message,
+          errorName: error instanceof Error ? error.name : "Error"
+        });
+      } finally {
+        if (controller && activeController === controller)
+          activeController = null;
       }
     };
+    await WorkerBody.postMessage("ready", {});
   }
   async function* createDemandDrivenIterator(inputBatches) {
     while (true) {
@@ -327,27 +411,45 @@
     }
   }
   function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
+    const signal = activeController?.signal;
+    signal?.throwIfAborted();
     return new Promise((resolve, reject) => {
       const id = requestId++;
-      const onMessage = (type, payload2) => {
-        if (payload2.id !== id) {
+      const cleanup = () => {
+        signal?.removeEventListener("abort", abort);
+        void WorkerBody.removeEventListener(onMessage);
+      };
+      const abort = () => {
+        cleanup();
+        reject(signal?.reason);
+      };
+      const onMessage = (type, payload) => {
+        if (payload.id !== id)
           return;
-        }
-        switch (type) {
-          case "done":
-            WorkerBody.removeEventListener(onMessage);
-            resolve(payload2.result);
-            break;
-          case "error":
-            WorkerBody.removeEventListener(onMessage);
-            reject(payload2.error);
-            break;
-          default:
+        if (type === "done") {
+          cleanup();
+          resolve(payload.result);
+        } else if (type === "error") {
+          cleanup();
+          reject(payload.error);
         }
       };
-      WorkerBody.addEventListener(onMessage);
-      const payload = { id, input: arrayBuffer, options, context: jobContext };
-      WorkerBody.postMessage("process", payload);
+      void WorkerBody.addEventListener(onMessage).then(async () => {
+        if (signal?.aborted) {
+          abort();
+          return;
+        }
+        signal?.addEventListener("abort", abort, { once: true });
+        await WorkerBody.postMessage("process", {
+          id,
+          input: arrayBuffer,
+          options,
+          context: jobContext
+        });
+      }).catch((error) => {
+        cleanup();
+        reject(error);
+      });
     });
   }
   function createProgressReporter() {
@@ -364,8 +466,10 @@
     return {
       /** Records progress while retaining phase transitions. */
       report(progress) {
-        if (finished) return;
-        if (pending && pending.phase !== progress.phase) flush();
+        if (finished)
+          return;
+        if (pending && pending.phase !== progress.phase)
+          flush();
         pending = { ...progress };
         if (!scheduled) {
           scheduled = true;
@@ -373,29 +477,58 @@
         }
       },
       /** Flushes final progress and suppresses reports from stale callbacks. */
-      finish() {
+      finish(discard = false) {
+        if (discard)
+          pending = void 0;
         flush();
         finished = true;
       }
     };
   }
-  var requestId, activeInputBatches, activeOutputAcknowledgements;
+  var requestId, activeController, activeInputBatches, activeOutputAcknowledgements;
   var init_create_worker = __esm({
-    "../core/src/worker-utils/lib/worker-api/create-worker.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js"() {
+      init_shared_state();
       init_async_queue();
       init_worker_body();
       requestId = 0;
+      activeController = null;
       activeInputBatches = null;
       activeOutputAcknowledgements = null;
     }
   });
 
-  // ../core/src/worker-utils/index.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  var import_meta, path, moduleUrl;
   var init_worker_utils = __esm({
+    "../../node_modules/@math.gl/core/dist/worker-utils/index.js"() {
+      init_create_worker();
+      import_meta = {};
+      path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
+      moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/tasks/index.js
+  var init_tasks = __esm({
+    "../../node_modules/@math.gl/core/dist/tasks/index.js"() {
+      init_worker_utils();
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  var init_create_worker2 = __esm({
+    "../core/src/worker-utils/lib/worker-api/create-worker.ts"() {
+      "use strict";
+      init_tasks();
+    }
+  });
+
+  // ../core/src/worker-utils/index.ts
+  var init_worker_utils2 = __esm({
     "../core/src/worker-utils/index.ts"() {
       "use strict";
-      init_create_worker();
+      init_create_worker2();
     }
   });
 
@@ -539,7 +672,7 @@
   var init_create_loader_worker = __esm({
     "../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts"() {
       "use strict";
-      init_worker_utils();
+      init_worker_utils2();
     }
   });
 
@@ -13413,8 +13546,8 @@ return true;`);
   });
 
   // ../../node_modules/apache-arrow/ipc/reader.mjs
-  function shouldAutoDestroy(self2, options) {
-    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
+  function shouldAutoDestroy(self, options) {
+    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self["autoDestroy"];
   }
   function* readAllSync(source) {
     const reader = RecordBatchReader.from(source);
@@ -17348,7 +17481,7 @@ return true;`);
       "use strict";
       init_pcd_format();
       init_arrow_transport();
-      VERSION = true ? "5.0.0-beta.1" : "latest";
+      VERSION = true ? "5.0.0-beta.2" : "latest";
       PCDLoader = {
         ...PCDFormat,
         dataType: null,

package/dist/pcd-writer.cjs

@@ -0,0 +1,136 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  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/pcd-writer.ts
+var pcd_writer_exports = {};
+__export(pcd_writer_exports, {
+  PCDWriter: () => PCDWriter
+});
+module.exports = __toCommonJS(pcd_writer_exports);
+
+// src/pcd/pcd-writer.ts
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_pcd_format = require("./pcd-format.cjs");
+var VERSION = true ? "5.0.0-beta.2" : "latest";
+var PCDWriter = {
+  ...import_pcd_format.PCDFormat,
+  dataType: null,
+  batchType: null,
+  version: VERSION,
+  options: {
+    pcd: {}
+  },
+  text: true,
+  encode: async (data, options) => encodePCDSync(data, options),
+  encodeSync: encodePCDSync,
+  encodeTextSync: encodePCD
+};
+function encodePCDSync(data, options) {
+  const text = encodePCD(data, options);
+  return new TextEncoder().encode(text).buffer;
+}
+function encodePCD(data, options) {
+  const mesh = (0, import_schema_utils.convertTableToMesh)(normalizeMeshArrowTable(data));
+  const positionAttribute = getRequiredAttribute(mesh, "POSITION");
+  const normalAttribute = mesh.attributes.NORMAL;
+  const colorAttribute = mesh.attributes.COLOR_0;
+  const vertexCount = positionAttribute.value.length / positionAttribute.size;
+  const fieldNames = ["x", "y", "z"];
+  const fieldSizes = ["4", "4", "4"];
+  const fieldTypes = ["F", "F", "F"];
+  const fieldCounts = ["1", "1", "1"];
+  if (normalAttribute) {
+    fieldNames.push("normal_x", "normal_y", "normal_z");
+    fieldSizes.push("4", "4", "4");
+    fieldTypes.push("F", "F", "F");
+    fieldCounts.push("1", "1", "1");
+  }
+  if (colorAttribute) {
+    fieldNames.push("rgb");
+    fieldSizes.push("4");
+    fieldTypes.push("F");
+    fieldCounts.push("1");
+  }
+  const lines = [
+    "# .PCD v0.7 - Point Cloud Data file generated by loaders.gl",
+    "VERSION 0.7",
+    `FIELDS ${fieldNames.join(" ")}`,
+    `SIZE ${fieldSizes.join(" ")}`,
+    `TYPE ${fieldTypes.join(" ")}`,
+    `COUNT ${fieldCounts.join(" ")}`,
+    `WIDTH ${vertexCount}`,
+    "HEIGHT 1",
+    "VIEWPOINT 0 0 0 1 0 0 0",
+    `POINTS ${vertexCount}`,
+    "DATA ascii"
+  ];
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const row = [
+      getComponent(positionAttribute, vertexIndex, 0),
+      getComponent(positionAttribute, vertexIndex, 1),
+      getComponent(positionAttribute, vertexIndex, 2)
+    ];
+    if (normalAttribute) {
+      row.push(
+        getComponent(normalAttribute, vertexIndex, 0),
+        getComponent(normalAttribute, vertexIndex, 1),
+        getComponent(normalAttribute, vertexIndex, 2)
+      );
+    }
+    if (colorAttribute) {
+      row.push(getPackedRGB(colorAttribute, vertexIndex));
+    }
+    lines.push(row.join(" "));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function normalizeMeshArrowTable(data) {
+  if ("shape" in data && data.shape === "arrow-table") {
+    return data;
+  }
+  return (0, import_schema_utils.convertMeshToTable)(data, "arrow-table");
+}
+function getRequiredAttribute(mesh, attributeName) {
+  const attribute = mesh.attributes[attributeName];
+  if (!attribute) {
+    throw new Error(`PCDWriter: ${attributeName} attribute is required`);
+  }
+  return attribute;
+}
+function getComponent(attribute, vertexIndex, componentIndex) {
+  return attribute.value[vertexIndex * attribute.size + componentIndex] || 0;
+}
+function getPackedRGB(attribute, vertexIndex) {
+  const bytes = new Uint8Array(4);
+  bytes[0] = getColorByte(attribute, vertexIndex, 0);
+  bytes[1] = getColorByte(attribute, vertexIndex, 1);
+  bytes[2] = getColorByte(attribute, vertexIndex, 2);
+  return new DataView(bytes.buffer).getFloat32(0, true);
+}
+function getColorByte(attribute, vertexIndex, componentIndex) {
+  const value = getComponent(attribute, vertexIndex, componentIndex);
+  const byteValue = attribute.normalized || value <= 1 ? value * 255 : value;
+  return Math.max(0, Math.min(255, Math.round(byteValue)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PCDWriter
+});
+//# sourceMappingURL=pcd-writer.cjs.map

package/dist/pcd-writer.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/pcd-writer.ts", "../src/pcd/pcd-writer.ts"],
+  "sourcesContent": ["export * from './pcd/pcd-writer.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {WriterOptions, WriterWithEncoder} from '@loaders.gl/core/loader-utils';\nimport type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';\nimport {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport {PCDFormat} from './pcd-format';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/** Options for `PCDWriter`. */\nexport type PCDWriterOptions = WriterOptions & {\n  /** Reserved for future PCD writer options. */\n  pcd?: Record<string, never>;\n};\n\n/**\n * Writer for the PCD point cloud format.\n */\nexport const PCDWriter = {\n  ...PCDFormat,\n  dataType: null as unknown as Mesh | MeshArrowTable,\n  batchType: null as never,\n  version: VERSION,\n  options: {\n    pcd: {}\n  },\n  text: true,\n  encode: async (data, options) => encodePCDSync(data, options),\n  encodeSync: encodePCDSync,\n  encodeTextSync: encodePCD\n} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable, never, PCDWriterOptions>;\n\n/** Encode mesh category data as PCD bytes. */\nfunction encodePCDSync(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): ArrayBuffer {\n  const text = encodePCD(data, options);\n  return new TextEncoder().encode(text).buffer;\n}\n\n/** Encode mesh category data as ASCII PCD text. */\nfunction encodePCD(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): string {\n  const mesh = convertTableToMesh(normalizeMeshArrowTable(data));\n  const positionAttribute = getRequiredAttribute(mesh, 'POSITION');\n  const normalAttribute = mesh.attributes.NORMAL;\n  const colorAttribute = mesh.attributes.COLOR_0;\n  const vertexCount = positionAttribute.value.length / positionAttribute.size;\n  const fieldNames = ['x', 'y', 'z'];\n  const fieldSizes = ['4', '4', '4'];\n  const fieldTypes = ['F', 'F', 'F'];\n  const fieldCounts = ['1', '1', '1'];\n\n  if (normalAttribute) {\n    fieldNames.push('normal_x', 'normal_y', 'normal_z');\n    fieldSizes.push('4', '4', '4');\n    fieldTypes.push('F', 'F', 'F');\n    fieldCounts.push('1', '1', '1');\n  }\n\n  if (colorAttribute) {\n    fieldNames.push('rgb');\n    fieldSizes.push('4');\n    fieldTypes.push('F');\n    fieldCounts.push('1');\n  }\n\n  const lines = [\n    '# .PCD v0.7 - Point Cloud Data file generated by loaders.gl',\n    'VERSION 0.7',\n    `FIELDS ${fieldNames.join(' ')}`,\n    `SIZE ${fieldSizes.join(' ')}`,\n    `TYPE ${fieldTypes.join(' ')}`,\n    `COUNT ${fieldCounts.join(' ')}`,\n    `WIDTH ${vertexCount}`,\n    'HEIGHT 1',\n    'VIEWPOINT 0 0 0 1 0 0 0',\n    `POINTS ${vertexCount}`,\n    'DATA ascii'\n  ];\n\n  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {\n    const row = [\n      getComponent(positionAttribute, vertexIndex, 0),\n      getComponent(positionAttribute, vertexIndex, 1),\n      getComponent(positionAttribute, vertexIndex, 2)\n    ];\n\n    if (normalAttribute) {\n      row.push(\n        getComponent(normalAttribute, vertexIndex, 0),\n        getComponent(normalAttribute, vertexIndex, 1),\n        getComponent(normalAttribute, vertexIndex, 2)\n      );\n    }\n\n    if (colorAttribute) {\n      row.push(getPackedRGB(colorAttribute, vertexIndex));\n    }\n\n    lines.push(row.join(' '));\n  }\n\n  return `${lines.join('\\n')}\\n`;\n}\n\n/** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */\nfunction normalizeMeshArrowTable(data: Mesh | MeshArrowTable): MeshArrowTable {\n  if ('shape' in data && data.shape === 'arrow-table') {\n    return data;\n  }\n  return convertMeshToTable(data as Mesh, 'arrow-table');\n}\n\n/** Return a required mesh attribute or throw a format-specific error. */\nfunction getRequiredAttribute(mesh: Mesh, attributeName: string): MeshAttribute {\n  const attribute = mesh.attributes[attributeName];\n  if (!attribute) {\n    throw new Error(`PCDWriter: ${attributeName} attribute is required`);\n  }\n  return attribute;\n}\n\n/** Return a single attribute component with 0 as the missing component fallback. */\nfunction getComponent(\n  attribute: MeshAttribute,\n  vertexIndex: number,\n  componentIndex: number\n): number {\n  return attribute.value[vertexIndex * attribute.size + componentIndex] || 0;\n}\n\n/** Return an RGB value packed into the PCD float convention. */\nfunction getPackedRGB(attribute: MeshAttribute, vertexIndex: number): number {\n  const bytes = new Uint8Array(4);\n  bytes[0] = getColorByte(attribute, vertexIndex, 0);\n  bytes[1] = getColorByte(attribute, vertexIndex, 1);\n  bytes[2] = getColorByte(attribute, vertexIndex, 2);\n  return new DataView(bytes.buffer).getFloat32(0, true);\n}\n\n/** Return one color component as an unsigned byte. */\nfunction getColorByte(\n  attribute: MeshAttribute,\n  vertexIndex: number,\n  componentIndex: number\n): number {\n  const value = getComponent(attribute, vertexIndex, componentIndex);\n  const byteValue = attribute.normalized || value <= 1 ? value * 255 : value;\n  return Math.max(0, Math.min(255, Math.round(byteValue)));\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/pcd-writer.d.ts

@@ -0,0 +1,2 @@
+export * from './pcd/pcd-writer.js';
+//# sourceMappingURL=pcd-writer.d.ts.map

package/dist/pcd-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-writer.d.ts","sourceRoot":"","sources":["../src/pcd-writer.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/pcd-writer.js

@@ -0,0 +1,2 @@
+export * from './pcd/pcd-writer.js';
+//# sourceMappingURL=pcd-writer.js.map

package/dist/pcd-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcd-writer.js","sourceRoot":"","sources":["../src/pcd-writer.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/ply/ply-loader-types.cjs

@@ -36,9 +36,9 @@ __export(ply_loader_types_exports, {
 module.exports = __toCommonJS(ply_loader_types_exports);
 var import_ply_format = require("./ply-format.cjs");
 var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
-var VERSION = true ? "5.0.0-beta.1" : "latest";
+var VERSION = true ? "5.0.0-beta.2" : "latest";
 async function preload() {
-  const { PLYLoaderWithParser } = await import("@loaders.gl/pointclouds/ply/ply-loader");
+  const { PLYLoaderWithParser } = await import("@loaders.gl/pointclouds/ply-loader");
   return PLYLoaderWithParser;
 }
 var PLYLoader = {

package/dist/ply/ply-loader-types.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/ply/ply-loader-types.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// PLY Loader\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';\nimport type {PLYMesh} from './lib/ply-types';\nimport type {ParsePLYOptions} from './lib/parse-ply';\nimport {PLYFormat} from './ply-format';\nimport {serializeArrowWorkerTable} from '@loaders.gl/core/schema-utils/arrow-transport';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type PLYLoaderOptions = LoaderOptions & {\n  ply?: ParsePLYOptions & {\n    /** Output shape. Defaults to a Mesh Arrow table. */\n    shape?: 'mesh' | 'arrow-table';\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Treat PLY data as a point cloud by reading only the leading vertex element. */\n    pointCloud?: boolean;\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/**\n * Preloads the parser-bearing PLY loader implementation.\n */\nasync function preload() {\n  const {PLYLoaderWithParser} = await import('@loaders.gl/pointclouds/ply/ply-loader');\n  return PLYLoaderWithParser;\n}\n\n/**\n * Metadata-only worker loader for PLY - Polygon File Format (aka Stanford Triangle Format)'\n * links: ['http://paulbourke.net/dataformats/ply/',\n * 'https://en.wikipedia.org/wiki/PLY_(file_format)']\n */\nexport const PLYLoader = {\n  dataType: null as unknown as PLYMesh | MeshArrowTable,\n  batchType: null as unknown as PLYMesh | ArrowTableBatch,\n\n  ...PLYFormat,\n  // shapes: ['mesh', 'gltf', 'columnar-table'],\n  version: VERSION,\n  worker: true,\n  /** Enables the stateful input/output batch protocol on the built-in worker. */\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  options: {\n    ply: {shape: 'arrow-table', colorFormat: 'uint8norm'}\n  },\n  preload\n} as const satisfies Loader<PLYMesh | MeshArrowTable, PLYMesh | ArrowTableBatch, LoaderOptions>;\n\n/** @deprecated Use PLYLoader. */\nexport const PLYWorkerLoader = PLYLoader;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,wBAAwB;AACxB,6BAAwC;AAIxC,IAAM,UAAU,OAAqC,iBAAc;AAkBnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,wCAAwC;AACnF,SAAO;AACT;AAOO,IAAM,YAAY;AAAA,EACvB,UAAU;AAAA,EACV,WAAW;AAAA,EAEX,GAAG;AAAA;AAAA,EAEH,SAAS;AAAA,EACT,QAAQ;AAAA;AAAA,EAER,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,SAAS;AAAA,IACP,KAAK,EAAC,OAAO,eAAe,aAAa,YAAW;AAAA,EACtD;AAAA,EACA;AACF;AAGO,IAAM,kBAAkB;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// PLY Loader\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';\nimport type {PLYMesh} from './lib/ply-types';\nimport type {ParsePLYOptions} from './lib/parse-ply';\nimport {PLYFormat} from './ply-format';\nimport {serializeArrowWorkerTable} from '@loaders.gl/core/schema-utils/arrow-transport';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type PLYLoaderOptions = LoaderOptions & {\n  ply?: ParsePLYOptions & {\n    /** Output shape. Defaults to a Mesh Arrow table. */\n    shape?: 'mesh' | 'arrow-table';\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Treat PLY data as a point cloud by reading only the leading vertex element. */\n    pointCloud?: boolean;\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/**\n * Preloads the parser-bearing PLY loader implementation.\n */\nasync function preload() {\n  const {PLYLoaderWithParser} = await import('@loaders.gl/pointclouds/ply-loader');\n  return PLYLoaderWithParser;\n}\n\n/**\n * Metadata-only worker loader for PLY - Polygon File Format (aka Stanford Triangle Format)'\n * links: ['http://paulbourke.net/dataformats/ply/',\n * 'https://en.wikipedia.org/wiki/PLY_(file_format)']\n */\nexport const PLYLoader = {\n  dataType: null as unknown as PLYMesh | MeshArrowTable,\n  batchType: null as unknown as PLYMesh | ArrowTableBatch,\n\n  ...PLYFormat,\n  // shapes: ['mesh', 'gltf', 'columnar-table'],\n  version: VERSION,\n  worker: true,\n  /** Enables the stateful input/output batch protocol on the built-in worker. */\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  options: {\n    ply: {shape: 'arrow-table', colorFormat: 'uint8norm'}\n  },\n  preload\n} as const satisfies Loader<PLYMesh | MeshArrowTable, PLYMesh | ArrowTableBatch, LoaderOptions>;\n\n/** @deprecated Use PLYLoader. */\nexport const PLYWorkerLoader = PLYLoader;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,wBAAwB;AACxB,6BAAwC;AAIxC,IAAM,UAAU,OAAqC,iBAAc;AAkBnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAOO,IAAM,YAAY;AAAA,EACvB,UAAU;AAAA,EACV,WAAW;AAAA,EAEX,GAAG;AAAA;AAAA,EAEH,SAAS;AAAA,EACT,QAAQ;AAAA;AAAA,EAER,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,SAAS;AAAA,IACP,KAAK,EAAC,OAAO,eAAe,aAAa,YAAW;AAAA,EACtD;AAAA,EACA;AACF;AAGO,IAAM,kBAAkB;",
   "names": []
 }

package/dist/ply/ply-loader-types.js

@@ -5,12 +5,12 @@ import { PLYFormat } from "./ply-format.js";
 import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+const VERSION = typeof "5.0.0-beta.2" !== 'undefined' ? "5.0.0-beta.2" : 'latest';
 /**
  * Preloads the parser-bearing PLY loader implementation.
  */
 async function preload() {
-    const { PLYLoaderWithParser } = await import('@loaders.gl/pointclouds/ply/ply-loader');
+    const { PLYLoaderWithParser } = await import('@loaders.gl/pointclouds/ply-loader');
     return PLYLoaderWithParser;
 }
 /**