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

package/dist/pcd/pcd-loader.cjs

@@ -20,45 +20,35 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/pcd/pcd-loader.ts
 var pcd_loader_exports = {};
 __export(pcd_loader_exports, {
+  PCDColumnLoader: () => PCDColumnLoader,
   PCDLoaderWithParser: () => PCDLoaderWithParser
 });
 module.exports = __toCommonJS(pcd_loader_exports);
-var import_loader_utils = require("@loaders.gl/core/loader-utils");
-var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
 var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_arrow_worker_transport = require("@loaders.gl/core/arrow-worker-transport");
+var import_schema_utils2 = require("@loaders.gl/core/schema-utils");
 var import_parse_pcd = require("./lib/parse-pcd.cjs");
 var import_pcd_loader_types = require("./pcd-loader-types.cjs");
 var { preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload } = import_pcd_loader_types.PCDLoader;
 function convertPCDMesh(mesh, options) {
-  const table = (0, import_schema_utils.convertMeshToTable)(mesh, "arrow-table");
+  const table = (0, import_schema_utils2.convertMeshToArrowTableWrapper)(mesh);
   return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, mesh) : { ...table, loader: mesh.loader, loaderData: mesh.loaderData };
 }
-var PCDLoaderWithParser = {
+var PCDColumnLoader = {
   ...PCDLoaderMetadataWithoutPreload,
+  dataType: null,
+  batchType: null,
   parse: async (arrayBuffer, options) => convertPCDMesh((0, import_parse_pcd.parsePCD)(arrayBuffer, options), options),
   parseSync: (arrayBuffer, options) => convertPCDMesh((0, import_parse_pcd.parsePCD)(arrayBuffer, options), options),
-  parseInBatches: async function* (arrayBuffer, options) {
-    const batchSize = getNumericBatchSize(options);
-    const data = await (0, import_loader_utils.concatenateArrayBuffersAsync)(arrayBuffer);
-    const textData = new TextDecoder().decode(data);
-    const pcdHeader = (0, import_parse_pcd.parsePCDHeader)(textData);
-    if (pcdHeader.data === "ascii") {
-      yield* parsePCDASCIIInBatches(data, options, batchSize);
-      return;
-    }
-    if (pcdHeader.data === "binary") {
-      yield* parsePCDBinaryInBatches(data, options, batchSize);
-      return;
-    }
-    yield makePCDBatch((0, import_parse_pcd.parsePCD)(data, options), options);
-  },
-  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
+  parseInBatches: (input, options) => (0, import_schema_utils.refineArrowTableBatches)(parsePCDWithMetadataInBatches(input, options)),
+  serializeWorkerResult: import_arrow_worker_transport.serializeArrowWorkerTable,
   deserializeWorkerResult: deserializePCDWorkerResult,
-  serializeWorkerBatch: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerBatch: import_arrow_worker_transport.serializeArrowWorkerTable,
   deserializeWorkerBatch: deserializePCDWorkerBatch
 };
 function getNumericBatchSize(options) {
-  const batchSize = options?.batchSize ?? options?.core?.batchSize;
+  const batchSize = options?.core?.batchSize;
   return typeof batchSize === "number" ? batchSize : void 0;
 }
 function* parsePCDASCIIInBatches(data, options, batchSize) {
@@ -93,7 +83,7 @@ function* parsePCDBinaryInBatches(data, options, batchSize) {
   }
 }
 function makePCDBatch(mesh, options) {
-  const table = (0, import_schema_utils.convertMeshToTable)(mesh, "arrow-table");
+  const table = (0, import_schema_utils2.convertMeshToArrowTableWrapper)(mesh);
   if (options?.pcd?.shape === "mesh") {
     return convertPCDTableToMesh(table, mesh);
   }
@@ -105,7 +95,7 @@ function makePCDBatch(mesh, options) {
 }
 function convertPCDTableToMesh(table, sourceMesh) {
   return {
-    ...(0, import_schema_utils.convertTableToMesh)(table),
+    ...(0, import_schema_utils2.convertTableToMesh)(table),
     loader: sourceMesh.loader,
     loaderData: sourceMesh.loaderData
   };
@@ -131,14 +121,81 @@ function makePCDHeaderText(pcdHeader, pointCount) {
 `;
 }
 function deserializePCDWorkerResult(result, options) {
-  const table = (0, import_arrow_transport.deserializeArrowWorkerTable)(result);
+  const table = (0, import_arrow_worker_transport.deserializeArrowWorkerTable)(result);
   return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, table) : table;
 }
 function deserializePCDWorkerBatch(result, options) {
   return deserializePCDWorkerResult(result, options);
 }
+async function* parsePCDWithMetadataInBatches(arrayBuffer, options) {
+  const batchSize = getNumericBatchSize(options);
+  const data = await (0, import_loader_utils.concatenateArrayBuffersAsync)(arrayBuffer);
+  const textData = new TextDecoder().decode(data);
+  const pcdHeader = (0, import_parse_pcd.parsePCDHeader)(textData);
+  if (pcdHeader.data === "ascii") {
+    yield* parsePCDASCIIInBatches(data, options, batchSize);
+    return;
+  }
+  if (pcdHeader.data === "binary") {
+    yield* parsePCDBinaryInBatches(data, options, batchSize);
+    return;
+  }
+  yield makePCDBatch((0, import_parse_pcd.parsePCD)(data, options), options);
+}
+var PCDLoaderWithParser = {
+  ...PCDColumnLoader,
+  dataType: import_pcd_loader_types.PCDLoader.dataType,
+  batchType: import_pcd_loader_types.PCDLoader.batchType,
+  parse: async (input, options) => unwrapPCDTable(await PCDColumnLoader.parse(input, options)),
+  parseSync: (input, options) => unwrapPCDTable(PCDColumnLoader.parseSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const batch of PCDColumnLoader.parseInBatches(input, options)) {
+      if (isColumnBatch(batch)) {
+        batch.data.schema.metadata.set(
+          "loaders.gl.pcd.header",
+          JSON.stringify(batch.loaderData)
+        );
+        for (const recordBatch of batch.data.batches) {
+          recordBatch.schema.metadata.set(
+            "loaders.gl.pcd.header",
+            batch.data.schema.metadata.get("loaders.gl.pcd.header")
+          );
+        }
+        if (batch.data.batches.length) yield* batch.data.batches;
+        else yield (0, import_schema_utils.makeArrowMetadataBatch)(batch.data.schema);
+      } else yield batch;
+    }
+  },
+  deserializeWorkerResult: (result, options) => unwrapPCDTable(PCDColumnLoader.deserializeWorkerResult(result, options)),
+  deserializeWorkerBatch(result, options) {
+    const batch = PCDColumnLoader.deserializeWorkerBatch(result, options);
+    if (isColumnBatch(batch)) {
+      const recordBatch = batch.data.batches[0] ?? (0, import_schema_utils.makeArrowMetadataBatch)(batch.data.schema);
+      recordBatch.schema.metadata.set(
+        "loaders.gl.pcd.header",
+        JSON.stringify(batch.loaderData)
+      );
+      return recordBatch;
+    }
+    return batch;
+  }
+};
+function unwrapPCDTable(result) {
+  if ("shape" in result && result.shape === "arrow-table") {
+    result.data.schema.metadata.set(
+      "loaders.gl.pcd.header",
+      JSON.stringify(result.loaderData)
+    );
+    return result.data;
+  }
+  return result;
+}
+function isColumnBatch(batch) {
+  return "shape" in batch && batch.shape === "arrow-table";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PCDColumnLoader,
   PCDLoaderWithParser
 });
 //# sourceMappingURL=pcd-loader.cjs.map

package/dist/pcd/pcd-loader.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/pcd/pcd-loader.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {PCDLoaderOptions} from './pcd-loader-types';\n\nimport {\n  concatenateArrayBuffersAsync,\n  makeTableScanBatch,\n  type LoaderWithParser\n} from '@loaders.gl/core/loader-utils';\nimport type {ArrowTableBatch, MeshArrowTable} from '@loaders.gl/core/schema';\nimport {\n  deserializeArrowWorkerTable,\n  serializeArrowWorkerTable\n} from '@loaders.gl/core/schema-utils/arrow-transport';\nimport {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {parsePCD, parsePCDHeader} from './lib/parse-pcd';\nimport {PCDLoader as PCDLoaderMetadata} from './pcd-loader-types';\n\nconst {preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload} = PCDLoaderMetadata;\n\ntype PCDParsedBatch = PCDMesh | ArrowTableBatch;\n\nfunction convertPCDMesh(mesh: PCDMesh, options?: PCDLoaderOptions): PCDMesh | MeshArrowTable {\n  const table = convertMeshToTable(mesh, 'arrow-table');\n  return options?.pcd?.shape === 'mesh'\n    ? convertPCDTableToMesh(table, mesh)\n    : {...table, loader: mesh.loader, loaderData: mesh.loaderData};\n}\n\n/**\n * Loader for PCD - Point Cloud Data\n */\nexport const PCDLoaderWithParser = {\n  ...PCDLoaderMetadataWithoutPreload,\n  parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseInBatches: async function* (\n    arrayBuffer:\n      | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n      | Iterable<ArrayBufferLike | ArrayBufferView>,\n    options\n  ): AsyncIterable<PCDParsedBatch> {\n    const batchSize = getNumericBatchSize(options);\n    const data = await concatenateArrayBuffersAsync(arrayBuffer);\n    const textData = new TextDecoder().decode(data);\n    const pcdHeader = parsePCDHeader(textData);\n\n    if (pcdHeader.data === 'ascii') {\n      yield* parsePCDASCIIInBatches(data, options, batchSize);\n      return;\n    }\n\n    if (pcdHeader.data === 'binary') {\n      yield* parsePCDBinaryInBatches(data, options, batchSize);\n      return;\n    }\n\n    yield makePCDBatch(parsePCD(data, options), options);\n  },\n  serializeWorkerResult: serializeArrowWorkerTable,\n  deserializeWorkerResult: deserializePCDWorkerResult,\n  serializeWorkerBatch: serializeArrowWorkerTable,\n  deserializeWorkerBatch: deserializePCDWorkerBatch\n} as const satisfies LoaderWithParser<PCDMesh | MeshArrowTable, PCDParsedBatch, PCDLoaderOptions>;\n\n/** Returns a numeric batch size when batching has an explicit row count. */\nfunction getNumericBatchSize(options?: PCDLoaderOptions): number | undefined {\n  const batchSize = options?.batchSize ?? options?.core?.batchSize;\n  return typeof batchSize === 'number' ? batchSize : undefined;\n}\n\nfunction* parsePCDASCIIInBatches(\n  data: ArrayBuffer,\n  options?: PCDLoaderOptions,\n  batchSize?: number\n): Iterable<PCDParsedBatch> {\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n  const lines = textData\n    .slice(pcdHeader.headerLen)\n    .split(/\\r?\\n/)\n    .filter(line => line.trim().length > 0);\n  const normalizedBatchSize = batchSize || lines.length || 1;\n\n  for (let rowIndex = 0; rowIndex < lines.length; rowIndex += normalizedBatchSize) {\n    const batchLines = lines.slice(rowIndex, rowIndex + normalizedBatchSize);\n    const batchText = `${makePCDHeaderText(pcdHeader, batchLines.length)}${batchLines.join('\\n')}\\n`;\n    yield makePCDBatch(parsePCD(new TextEncoder().encode(batchText).buffer, options), options);\n  }\n}\n\nfunction* parsePCDBinaryInBatches(\n  data: ArrayBuffer,\n  options?: PCDLoaderOptions,\n  batchSize?: number\n): Iterable<PCDParsedBatch> {\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n  const normalizedBatchSize = batchSize || pcdHeader.points || 1;\n  const dataBytes = new Uint8Array(data);\n\n  for (let pointIndex = 0; pointIndex < pcdHeader.points; pointIndex += normalizedBatchSize) {\n    const pointCount = Math.min(normalizedBatchSize, pcdHeader.points - pointIndex);\n    const headerBytes = new TextEncoder().encode(makePCDHeaderText(pcdHeader, pointCount));\n    const rowByteOffset = pcdHeader.headerLen + pointIndex * pcdHeader.rowSize;\n    const rowByteLength = pointCount * pcdHeader.rowSize;\n    const batchBytes = new Uint8Array(headerBytes.length + rowByteLength);\n    batchBytes.set(headerBytes, 0);\n    batchBytes.set(\n      dataBytes.subarray(rowByteOffset, rowByteOffset + rowByteLength),\n      headerBytes.length\n    );\n    yield makePCDBatch(parsePCD(batchBytes.buffer, options), options);\n  }\n}\n\nfunction makePCDBatch(mesh: PCDMesh, options?: PCDLoaderOptions): PCDParsedBatch {\n  const table = convertMeshToTable(mesh, 'arrow-table');\n  if (options?.pcd?.shape === 'mesh') {\n    return convertPCDTableToMesh(table, mesh);\n  }\n\n  return makeTableScanBatch({\n    ...table,\n    loader: mesh.loader,\n    loaderData: mesh.loaderData\n  } as MeshArrowTable);\n}\n\n/** Convert the parser's Arrow table to legacy PCD mesh output. */\nfunction convertPCDTableToMesh(table: MeshArrowTable, sourceMesh: PCDMesh): PCDMesh {\n  return {\n    ...(convertTableToMesh(table) as PCDMesh),\n    loader: sourceMesh.loader,\n    loaderData: sourceMesh.loaderData\n  };\n}\n\nfunction makePCDHeaderText(pcdHeader: any, pointCount: number): string {\n  const lines = pcdHeader.str\n    .split(/\\r?\\n/)\n    .filter(line => line.trim().length > 0)\n    .map(line => {\n      if (/^WIDTH\\s+/i.test(line)) {\n        return `WIDTH ${pointCount}`;\n      }\n      if (/^HEIGHT\\s+/i.test(line)) {\n        return 'HEIGHT 1';\n      }\n      if (/^POINTS\\s+/i.test(line)) {\n        return `POINTS ${pointCount}`;\n      }\n      return line;\n    });\n\n  if (!lines.some(line => /^POINTS\\s+/i.test(line))) {\n    const dataLineIndex = lines.findIndex(line => /^DATA\\s+/i.test(line));\n    lines.splice(dataLineIndex >= 0 ? dataLineIndex : lines.length, 0, `POINTS ${pointCount}`);\n  }\n\n  return `${lines.join('\\n')}\\n`;\n}\n\n/** Hydrates worker columns before reconstructing legacy PCD meshes on the caller. */\nfunction deserializePCDWorkerResult(\n  result: unknown,\n  options?: PCDLoaderOptions\n): PCDMesh | MeshArrowTable {\n  const table = deserializeArrowWorkerTable(result);\n  return options?.pcd?.shape === 'mesh' ? convertPCDTableToMesh(table, table) : table;\n}\n\n/** Restores the existing PCD batch shape after caller-side hydration. */\nfunction deserializePCDWorkerBatch(result: unknown, options?: PCDLoaderOptions): PCDParsedBatch {\n  return deserializePCDWorkerResult(result, options) as PCDParsedBatch;\n}\n"],
-  "mappings": "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",
-  "names": ["PCDLoaderMetadata"]
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {refineArrowTableBatches, makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport type {PCDLoaderOptions} from './pcd-loader-types';\n\nimport {\n  concatenateArrayBuffersAsync,\n  makeTableScanBatch,\n  type LoaderWithParser\n} from '@loaders.gl/core/loader-utils';\nimport type {ArrowTableBatch, MeshArrowTable} from '@loaders.gl/core/schema';\nimport {\n  deserializeArrowWorkerTable,\n  serializeArrowWorkerTable\n} from '@loaders.gl/core/arrow-worker-transport';\nimport {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {parsePCD, parsePCDHeader} from './lib/parse-pcd';\nimport {PCDLoader as PCDLoaderMetadata} from './pcd-loader-types';\n\nconst {preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload} = PCDLoaderMetadata;\n\ntype PCDParsedBatch = PCDMesh | ArrowTableBatch;\n\nfunction convertPCDMesh(mesh: PCDMesh, options?: PCDLoaderOptions): PCDMesh | MeshArrowTable {\n  const table = convertMeshToArrowTableWrapper(mesh);\n  return options?.pcd?.shape === 'mesh'\n    ? convertPCDTableToMesh(table, mesh)\n    : {...table, loader: mesh.loader, loaderData: mesh.loaderData};\n}\n\n/**\n * Loader for PCD - Point Cloud Data\n */\nexport const PCDColumnLoader = {\n  ...PCDLoaderMetadataWithoutPreload,\n  dataType: null as unknown as PCDMesh | MeshArrowTable,\n  batchType: null as unknown as PCDMesh | ArrowTableBatch,\n  parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),\n  parseInBatches: (input, options) =>\n    refineArrowTableBatches(parsePCDWithMetadataInBatches(input, options)),\n  serializeWorkerResult: serializeArrowWorkerTable,\n  deserializeWorkerResult: deserializePCDWorkerResult,\n  serializeWorkerBatch: serializeArrowWorkerTable,\n  deserializeWorkerBatch: deserializePCDWorkerBatch\n} as const satisfies LoaderWithParser<PCDMesh | MeshArrowTable, PCDParsedBatch, PCDLoaderOptions>;\n\n/** Returns a numeric batch size when batching has an explicit row count. */\nfunction getNumericBatchSize(options?: PCDLoaderOptions): number | undefined {\n  const batchSize = options?.core?.batchSize;\n  return typeof batchSize === 'number' ? batchSize : undefined;\n}\n\nfunction* parsePCDASCIIInBatches(\n  data: ArrayBuffer,\n  options?: PCDLoaderOptions,\n  batchSize?: number\n): Iterable<PCDParsedBatch> {\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n  const lines = textData\n    .slice(pcdHeader.headerLen)\n    .split(/\\r?\\n/)\n    .filter(line => line.trim().length > 0);\n  const normalizedBatchSize = batchSize || lines.length || 1;\n\n  for (let rowIndex = 0; rowIndex < lines.length; rowIndex += normalizedBatchSize) {\n    const batchLines = lines.slice(rowIndex, rowIndex + normalizedBatchSize);\n    const batchText = `${makePCDHeaderText(pcdHeader, batchLines.length)}${batchLines.join('\\n')}\\n`;\n    yield makePCDBatch(parsePCD(new TextEncoder().encode(batchText).buffer, options), options);\n  }\n}\n\nfunction* parsePCDBinaryInBatches(\n  data: ArrayBuffer,\n  options?: PCDLoaderOptions,\n  batchSize?: number\n): Iterable<PCDParsedBatch> {\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n  const normalizedBatchSize = batchSize || pcdHeader.points || 1;\n  const dataBytes = new Uint8Array(data);\n\n  for (let pointIndex = 0; pointIndex < pcdHeader.points; pointIndex += normalizedBatchSize) {\n    const pointCount = Math.min(normalizedBatchSize, pcdHeader.points - pointIndex);\n    const headerBytes = new TextEncoder().encode(makePCDHeaderText(pcdHeader, pointCount));\n    const rowByteOffset = pcdHeader.headerLen + pointIndex * pcdHeader.rowSize;\n    const rowByteLength = pointCount * pcdHeader.rowSize;\n    const batchBytes = new Uint8Array(headerBytes.length + rowByteLength);\n    batchBytes.set(headerBytes, 0);\n    batchBytes.set(\n      dataBytes.subarray(rowByteOffset, rowByteOffset + rowByteLength),\n      headerBytes.length\n    );\n    yield makePCDBatch(parsePCD(batchBytes.buffer, options), options);\n  }\n}\n\nfunction makePCDBatch(mesh: PCDMesh, options?: PCDLoaderOptions): PCDParsedBatch {\n  const table = convertMeshToArrowTableWrapper(mesh);\n  if (options?.pcd?.shape === 'mesh') {\n    return convertPCDTableToMesh(table, mesh);\n  }\n\n  return makeTableScanBatch({\n    ...table,\n    loader: mesh.loader,\n    loaderData: mesh.loaderData\n  } as MeshArrowTable);\n}\n\n/** Convert the parser's Arrow table to legacy PCD mesh output. */\nfunction convertPCDTableToMesh(table: MeshArrowTable, sourceMesh: PCDMesh): PCDMesh {\n  return {\n    ...(convertTableToMesh(table) as PCDMesh),\n    loader: sourceMesh.loader,\n    loaderData: sourceMesh.loaderData\n  };\n}\n\nfunction makePCDHeaderText(pcdHeader: any, pointCount: number): string {\n  const lines = pcdHeader.str\n    .split(/\\r?\\n/)\n    .filter(line => line.trim().length > 0)\n    .map(line => {\n      if (/^WIDTH\\s+/i.test(line)) {\n        return `WIDTH ${pointCount}`;\n      }\n      if (/^HEIGHT\\s+/i.test(line)) {\n        return 'HEIGHT 1';\n      }\n      if (/^POINTS\\s+/i.test(line)) {\n        return `POINTS ${pointCount}`;\n      }\n      return line;\n    });\n\n  if (!lines.some(line => /^POINTS\\s+/i.test(line))) {\n    const dataLineIndex = lines.findIndex(line => /^DATA\\s+/i.test(line));\n    lines.splice(dataLineIndex >= 0 ? dataLineIndex : lines.length, 0, `POINTS ${pointCount}`);\n  }\n\n  return `${lines.join('\\n')}\\n`;\n}\n\n/** Hydrates worker columns before reconstructing legacy PCD meshes on the caller. */\nfunction deserializePCDWorkerResult(\n  result: unknown,\n  options?: PCDLoaderOptions\n): PCDMesh | MeshArrowTable {\n  const table = deserializeArrowWorkerTable(result);\n  return options?.pcd?.shape === 'mesh' ? convertPCDTableToMesh(table, table) : table;\n}\n\n/** Restores the existing PCD batch shape after caller-side hydration. */\nfunction deserializePCDWorkerBatch(result: unknown, options?: PCDLoaderOptions): PCDParsedBatch {\n  return deserializePCDWorkerResult(result, options) as PCDParsedBatch;\n}\n\n/** Parses PCD batches before shared cumulative metadata refinement. */\nasync function* parsePCDWithMetadataInBatches(\n  arrayBuffer:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>,\n  options?: PCDLoaderOptions\n): AsyncIterable<PCDParsedBatch> {\n  const batchSize = getNumericBatchSize(options);\n  const data = await concatenateArrayBuffersAsync(arrayBuffer);\n  const textData = new TextDecoder().decode(data);\n  const pcdHeader = parsePCDHeader(textData);\n\n  if (pcdHeader.data === 'ascii') {\n    yield* parsePCDASCIIInBatches(data, options, batchSize);\n    return;\n  }\n\n  if (pcdHeader.data === 'binary') {\n    yield* parsePCDBinaryInBatches(data, options, batchSize);\n    return;\n  }\n\n  yield makePCDBatch(parsePCD(data, options), options);\n}\n\n/** Exposes native Arrow output while retaining the worker's column protocol. */\nexport const PCDLoaderWithParser = {\n  ...PCDColumnLoader,\n  dataType: PCDLoaderMetadata.dataType,\n  batchType: PCDLoaderMetadata.batchType,\n  parse: async (input: ArrayBuffer, options?: PCDLoaderOptions) =>\n    unwrapPCDTable(await PCDColumnLoader.parse(input, options)),\n  parseSync: (input: ArrayBuffer, options?: PCDLoaderOptions) =>\n    unwrapPCDTable(PCDColumnLoader.parseSync(input, options)),\n  async *parseInBatches(input, options) {\n    for await (const batch of PCDColumnLoader.parseInBatches(input, options)) {\n      if (isColumnBatch(batch)) {\n        batch.data.schema.metadata.set(\n          'loaders.gl.pcd.header',\n          JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)\n        );\n        for (const recordBatch of batch.data.batches) {\n          recordBatch.schema.metadata.set(\n            'loaders.gl.pcd.header',\n            batch.data.schema.metadata.get('loaders.gl.pcd.header')!\n          );\n        }\n        if (batch.data.batches.length) yield* batch.data.batches;\n        else yield makeArrowMetadataBatch(batch.data.schema);\n      } else yield batch;\n    }\n  },\n  deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) =>\n    unwrapPCDTable(PCDColumnLoader.deserializeWorkerResult(result, options)),\n  deserializeWorkerBatch(result: unknown, options?: PCDLoaderOptions) {\n    const batch = PCDColumnLoader.deserializeWorkerBatch(result, options);\n    if (isColumnBatch(batch)) {\n      const recordBatch = batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema);\n      recordBatch.schema.metadata.set(\n        'loaders.gl.pcd.header',\n        JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)\n      );\n      return recordBatch;\n    }\n    return batch;\n  }\n} as const satisfies LoaderWithParser<PCDMesh | Table, PCDMesh | RecordBatch, PCDLoaderOptions>;\n\n/** Returns the Arrow table with its file metadata or the requested mesh. */\nfunction unwrapPCDTable(result: PCDMesh | MeshArrowTable): PCDMesh | Table {\n  if ('shape' in result && result.shape === 'arrow-table') {\n    result.data.schema.metadata.set(\n      'loaders.gl.pcd.header',\n      JSON.stringify((result as MeshArrowTable & {loaderData?: unknown}).loaderData)\n    );\n    return result.data;\n  }\n  return result as PCDMesh;\n}\n\n/** Identifies the private Arrow batch envelope. */\nfunction isColumnBatch(batch: PCDMesh | ArrowTableBatch): batch is ArrowTableBatch {\n  return 'shape' in batch && batch.shape === 'arrow-table';\n}\n"],
+  "mappings": "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",
+  "names": ["import_schema_utils", "PCDLoaderMetadata"]
 }

package/dist/pcd/pcd-loader.d.ts

@@ -1,27 +1,28 @@
+import type { Table, RecordBatch } from 'apache-arrow';
 import type { PCDLoaderOptions } from "./pcd-loader-types.js";
 import type { ArrowTableBatch, MeshArrowTable } from '@loaders.gl/core/schema';
-import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 import type { PCDMesh } from "./lib/pcd-types.js";
 type PCDParsedBatch = PCDMesh | ArrowTableBatch;
 /**
  * Loader for PCD - Point Cloud Data
  */
-export declare const PCDLoaderWithParser: {
+export declare const PCDColumnLoader: {
+    readonly dataType: PCDMesh | MeshArrowTable;
+    readonly batchType: PCDMesh | ArrowTableBatch;
     readonly parse: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => Promise<MeshArrowTable | PCDMesh>;
     readonly parseSync: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => MeshArrowTable | PCDMesh;
-    readonly parseInBatches: (arrayBuffer: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options: PCDLoaderOptions | undefined) => AsyncIterable<PCDParsedBatch>;
+    readonly parseInBatches: (input: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options: PCDLoaderOptions | undefined) => AsyncIterable<PCDParsedBatch>;
     readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
     readonly deserializeWorkerResult: typeof deserializePCDWorkerResult;
     readonly serializeWorkerBatch: typeof serializeArrowWorkerTable;
     readonly deserializeWorkerBatch: typeof deserializePCDWorkerBatch;
-    readonly dataType: PCDMesh | MeshArrowTable;
-    readonly batchType: PCDMesh | ArrowTableBatch;
     readonly version: any;
     readonly worker: true;
     readonly workerInBatches: true;
     readonly options: {
         readonly pcd: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
             readonly colorFormat: "uint8norm";
         };
     };
@@ -35,10 +36,45 @@ export declare const PCDLoaderWithParser: {
     readonly category: "pointcloud";
     readonly text: true;
     readonly binary: true;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
 };
 /** Hydrates worker columns before reconstructing legacy PCD meshes on the caller. */
 declare function deserializePCDWorkerResult(result: unknown, options?: PCDLoaderOptions): PCDMesh | MeshArrowTable;
 /** Restores the existing PCD batch shape after caller-side hydration. */
 declare function deserializePCDWorkerBatch(result: unknown, options?: PCDLoaderOptions): PCDParsedBatch;
+/** Exposes native Arrow output while retaining the worker's column protocol. */
+export declare const PCDLoaderWithParser: {
+    readonly dataType: Table<any> | PCDMesh;
+    readonly batchType: RecordBatch<any> | PCDMesh;
+    readonly parse: (input: ArrayBuffer, options?: PCDLoaderOptions) => Promise<Table<any> | PCDMesh>;
+    readonly parseSync: (input: ArrayBuffer, options?: PCDLoaderOptions) => Table<any> | PCDMesh;
+    readonly parseInBatches: (input: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options: PCDLoaderOptions | undefined) => AsyncGenerator<RecordBatch<any> | PCDMesh, void, unknown>;
+    readonly deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) => Table<any> | PCDMesh;
+    readonly deserializeWorkerBatch: (result: unknown, options?: PCDLoaderOptions) => RecordBatch<any> | PCDMesh;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
+    readonly serializeWorkerBatch: typeof serializeArrowWorkerTable;
+    readonly version: any;
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly options: {
+        readonly pcd: {
+            readonly shape: "arrow";
+            readonly colorFormat: "uint8norm";
+        };
+    };
+    readonly name: "PCD (Point Cloud Data)";
+    readonly id: "pcd";
+    readonly module: "pointclouds";
+    readonly encoding: "text";
+    readonly format: "pcd";
+    readonly extensions: ["pcd"];
+    readonly mimeTypes: ["text/plain"];
+    readonly category: "pointcloud";
+    readonly text: true;
+    readonly binary: true;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
+};
 export {};
 //# sourceMappingURL=pcd-loader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,gBAAgB,EAAC,8BAA2B;AAOzD,OAAO,KAAK,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAEL,yBAAyB,EAC1B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAM7C,KAAK,cAAc,GAAG,OAAO,GAAG,eAAe,CAAC;AAShD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;2CAMxB,aAAa,CAAC,eAAe,GAAG,eAAe,CAAC,GAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,4CAE9C,aAAa,CAAC,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB+D,CAAC;AAoGlG,qFAAqF;AACrF,iBAAS,0BAA0B,CACjC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,GAAG,cAAc,CAG1B;AAED,yEAAyE;AACzE,iBAAS,yBAAyB,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAE9F"}
+{"version":3,"file":"pcd-loader.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,KAAK,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAC,gBAAgB,EAAC,8BAA2B;AAOzD,OAAO,KAAK,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAEL,yBAAyB,EAC1B,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAM7C,KAAK,cAAc,GAAG,OAAO,GAAG,eAAe,CAAC;AAShD;;GAEG;AACH,eAAO,MAAM,eAAe;uBAEG,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASwC,CAAC;AAoGlG,qFAAqF;AACrF,iBAAS,0BAA0B,CACjC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,GAAG,cAAc,CAG1B;AAED,yEAAyE;AACzE,iBAAS,yBAAyB,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAE9F;AA2BD,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;4BAIT,WAAW,YAAY,gBAAgB;gCAEzC,WAAW,YAAY,gBAAgB;;+CAoBxB,OAAO,YAAY,gBAAgB;8CAEtC,OAAO,YAAY,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAY2B,CAAC"}

package/dist/pcd/pcd-loader.js

@@ -1,14 +1,15 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+import { refineArrowTableBatches, makeArrowMetadataBatch } from '@loaders.gl/core/schema-utils';
 import { concatenateArrayBuffersAsync, makeTableScanBatch } from '@loaders.gl/core/loader-utils';
-import { deserializeArrowWorkerTable, serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
-import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { deserializeArrowWorkerTable, serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
+import { convertMeshToArrowTableWrapper, convertTableToMesh } from '@loaders.gl/core/schema-utils';
 import { parsePCD, parsePCDHeader } from "./lib/parse-pcd.js";
 import { PCDLoader as PCDLoaderMetadata } from "./pcd-loader-types.js";
 const { preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload } = PCDLoaderMetadata;
 function convertPCDMesh(mesh, options) {
-    const table = convertMeshToTable(mesh, 'arrow-table');
+    const table = convertMeshToArrowTableWrapper(mesh);
     return options?.pcd?.shape === 'mesh'
         ? convertPCDTableToMesh(table, mesh)
         : { ...table, loader: mesh.loader, loaderData: mesh.loaderData };
@@ -16,25 +17,13 @@ function convertPCDMesh(mesh, options) {
 /**
  * Loader for PCD - Point Cloud Data
  */
-export const PCDLoaderWithParser = {
+export const PCDColumnLoader = {
     ...PCDLoaderMetadataWithoutPreload,
+    dataType: null,
+    batchType: null,
     parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),
     parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),
-    parseInBatches: async function* (arrayBuffer, options) {
-        const batchSize = getNumericBatchSize(options);
-        const data = await concatenateArrayBuffersAsync(arrayBuffer);
-        const textData = new TextDecoder().decode(data);
-        const pcdHeader = parsePCDHeader(textData);
-        if (pcdHeader.data === 'ascii') {
-            yield* parsePCDASCIIInBatches(data, options, batchSize);
-            return;
-        }
-        if (pcdHeader.data === 'binary') {
-            yield* parsePCDBinaryInBatches(data, options, batchSize);
-            return;
-        }
-        yield makePCDBatch(parsePCD(data, options), options);
-    },
+    parseInBatches: (input, options) => refineArrowTableBatches(parsePCDWithMetadataInBatches(input, options)),
     serializeWorkerResult: serializeArrowWorkerTable,
     deserializeWorkerResult: deserializePCDWorkerResult,
     serializeWorkerBatch: serializeArrowWorkerTable,
@@ -42,7 +31,7 @@ export const PCDLoaderWithParser = {
 };
 /** Returns a numeric batch size when batching has an explicit row count. */
 function getNumericBatchSize(options) {
-    const batchSize = options?.batchSize ?? options?.core?.batchSize;
+    const batchSize = options?.core?.batchSize;
     return typeof batchSize === 'number' ? batchSize : undefined;
 }
 function* parsePCDASCIIInBatches(data, options, batchSize) {
@@ -76,7 +65,7 @@ function* parsePCDBinaryInBatches(data, options, batchSize) {
     }
 }
 function makePCDBatch(mesh, options) {
-    const table = convertMeshToTable(mesh, 'arrow-table');
+    const table = convertMeshToArrowTableWrapper(mesh);
     if (options?.pcd?.shape === 'mesh') {
         return convertPCDTableToMesh(table, mesh);
     }
@@ -125,4 +114,66 @@ function deserializePCDWorkerResult(result, options) {
 function deserializePCDWorkerBatch(result, options) {
     return deserializePCDWorkerResult(result, options);
 }
+/** Parses PCD batches before shared cumulative metadata refinement. */
+async function* parsePCDWithMetadataInBatches(arrayBuffer, options) {
+    const batchSize = getNumericBatchSize(options);
+    const data = await concatenateArrayBuffersAsync(arrayBuffer);
+    const textData = new TextDecoder().decode(data);
+    const pcdHeader = parsePCDHeader(textData);
+    if (pcdHeader.data === 'ascii') {
+        yield* parsePCDASCIIInBatches(data, options, batchSize);
+        return;
+    }
+    if (pcdHeader.data === 'binary') {
+        yield* parsePCDBinaryInBatches(data, options, batchSize);
+        return;
+    }
+    yield makePCDBatch(parsePCD(data, options), options);
+}
+/** Exposes native Arrow output while retaining the worker's column protocol. */
+export const PCDLoaderWithParser = {
+    ...PCDColumnLoader,
+    dataType: PCDLoaderMetadata.dataType,
+    batchType: PCDLoaderMetadata.batchType,
+    parse: async (input, options) => unwrapPCDTable(await PCDColumnLoader.parse(input, options)),
+    parseSync: (input, options) => unwrapPCDTable(PCDColumnLoader.parseSync(input, options)),
+    async *parseInBatches(input, options) {
+        for await (const batch of PCDColumnLoader.parseInBatches(input, options)) {
+            if (isColumnBatch(batch)) {
+                batch.data.schema.metadata.set('loaders.gl.pcd.header', JSON.stringify(batch.loaderData));
+                for (const recordBatch of batch.data.batches) {
+                    recordBatch.schema.metadata.set('loaders.gl.pcd.header', batch.data.schema.metadata.get('loaders.gl.pcd.header'));
+                }
+                if (batch.data.batches.length)
+                    yield* batch.data.batches;
+                else
+                    yield makeArrowMetadataBatch(batch.data.schema);
+            }
+            else
+                yield batch;
+        }
+    },
+    deserializeWorkerResult: (result, options) => unwrapPCDTable(PCDColumnLoader.deserializeWorkerResult(result, options)),
+    deserializeWorkerBatch(result, options) {
+        const batch = PCDColumnLoader.deserializeWorkerBatch(result, options);
+        if (isColumnBatch(batch)) {
+            const recordBatch = batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema);
+            recordBatch.schema.metadata.set('loaders.gl.pcd.header', JSON.stringify(batch.loaderData));
+            return recordBatch;
+        }
+        return batch;
+    }
+};
+/** Returns the Arrow table with its file metadata or the requested mesh. */
+function unwrapPCDTable(result) {
+    if ('shape' in result && result.shape === 'arrow-table') {
+        result.data.schema.metadata.set('loaders.gl.pcd.header', JSON.stringify(result.loaderData));
+        return result.data;
+    }
+    return result;
+}
+/** Identifies the private Arrow batch envelope. */
+function isColumnBatch(batch) {
+    return 'shape' in batch && batch.shape === 'arrow-table';
+}
 //# sourceMappingURL=pcd-loader.js.map

package/dist/pcd/pcd-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pcd-loader.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader.ts"],"names":[],"mappings":"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"}

package/dist/pcd/pcd-writer.cjs

@@ -25,7 +25,7 @@ __export(pcd_writer_exports, {
 module.exports = __toCommonJS(pcd_writer_exports);
 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.1" : "latest";
+var VERSION = true ? "5.0.0-beta.10" : "latest";
 var PCDWriter = {
   ...import_pcd_format.PCDFormat,
   dataType: null,
@@ -100,10 +100,10 @@ function encodePCD(data, options) {
 `;
 }
 function normalizeMeshArrowTable(data) {
-  if ("shape" in data && data.shape === "arrow-table") {
+  if (!("attributes" in data)) {
     return data;
   }
-  return (0, import_schema_utils.convertMeshToTable)(data, "arrow-table");
+  return (0, import_schema_utils.convertMeshToArrowTableWrapper)(data);
 }
 function getRequiredAttribute(mesh, attributeName) {
   const attribute = mesh.attributes[attributeName];

package/dist/pcd/pcd-writer.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/pcd/pcd-writer.ts"],
-  "sourcesContent": ["// 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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",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Table} from 'apache-arrow';\nimport type {WriterOptions, WriterWithEncoder} from '@loaders.gl/core/loader-utils';\nimport type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';\nimport {convertMeshToArrowTableWrapper, 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 | Table,\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 | Table, never, PCDWriterOptions>;\n\n/** Encode mesh category data as PCD bytes. */\nfunction encodePCDSync(\n  data: Mesh | MeshArrowTable | Table,\n  options?: PCDWriterOptions\n): 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 | Table, 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 | Table): MeshArrowTable | Table {\n  if (!('attributes' in data)) {\n    return data;\n  }\n  return convertMeshToArrowTableWrapper(data as Mesh);\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/pcd-writer.d.ts

@@ -1,3 +1,4 @@
+import type { Table } from 'apache-arrow';
 import type { WriterOptions } from '@loaders.gl/core/loader-utils';
 import type { Mesh, MeshArrowTable } from '@loaders.gl/core/schema';
 /** Options for `PCDWriter`. */
@@ -9,14 +10,14 @@ export type PCDWriterOptions = WriterOptions & {
  * Writer for the PCD point cloud format.
  */
 export declare const PCDWriter: {
-    readonly dataType: Mesh | MeshArrowTable;
+    readonly dataType: Mesh | MeshArrowTable | Table;
     readonly batchType: never;
     readonly version: any;
     readonly options: {
         readonly pcd: {};
     };
     readonly text: true;
-    readonly encode: (data: Mesh | MeshArrowTable, options: PCDWriterOptions | undefined) => Promise<ArrayBuffer>;
+    readonly encode: (data: Mesh | Table<any> | MeshArrowTable, options: PCDWriterOptions | undefined) => Promise<ArrayBuffer>;
     readonly encodeSync: typeof encodePCDSync;
     readonly encodeTextSync: typeof encodePCD;
     readonly name: "PCD (Point Cloud Data)";
@@ -30,8 +31,8 @@ export declare const PCDWriter: {
     readonly binary: true;
 };
 /** Encode mesh category data as PCD bytes. */
-declare function encodePCDSync(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): ArrayBuffer;
+declare function encodePCDSync(data: Mesh | MeshArrowTable | Table, options?: PCDWriterOptions): ArrayBuffer;
 /** Encode mesh category data as ASCII PCD text. */
-declare function encodePCD(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): string;
+declare function encodePCD(data: Mesh | MeshArrowTable | Table, options?: PCDWriterOptions): string;
 export {};
 //# sourceMappingURL=pcd-writer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pcd-writer.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-writer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAoB,MAAM,+BAA+B,CAAC;AACpF,OAAO,KAAK,EAAC,IAAI,EAAE,cAAc,EAAgB,MAAM,yBAAyB,CAAC;AAQjF,+BAA+B;AAC/B,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS;uBAES,IAAI,GAAG,cAAc;wBAC/B,KAAK;;;;;;;;;;;;;;;;;;CAS4D,CAAC;AAEvF,8CAA8C;AAC9C,iBAAS,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,WAAW,CAG3F;AAED,mDAAmD;AACnD,iBAAS,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CA8DlF"}
+{"version":3,"file":"pcd-writer.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-writer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAAC,aAAa,EAAoB,MAAM,+BAA+B,CAAC;AACpF,OAAO,KAAK,EAAC,IAAI,EAAE,cAAc,EAAgB,MAAM,yBAAyB,CAAC;AAQjF,+BAA+B;AAC/B,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS;uBAES,IAAI,GAAG,cAAc,GAAG,KAAK;wBACvC,KAAK;;;;;;;;;;;;;;;;;;CASoE,CAAC;AAE/F,8CAA8C;AAC9C,iBAAS,aAAa,CACpB,IAAI,EAAE,IAAI,GAAG,cAAc,GAAG,KAAK,EACnC,OAAO,CAAC,EAAE,gBAAgB,GACzB,WAAW,CAGb;AAED,mDAAmD;AACnD,iBAAS,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CA8D1F"}

package/dist/pcd/pcd-writer.js

@@ -1,11 +1,11 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { convertMeshToArrowTableWrapper, convertTableToMesh } from '@loaders.gl/core/schema-utils';
 import { PCDFormat } from "./pcd-format.js";
 // __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.10" !== 'undefined' ? "5.0.0-beta.10" : 'latest';
 /**
  * Writer for the PCD point cloud format.
  */
@@ -81,10 +81,10 @@ function encodePCD(data, options) {
 }
 /** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */
 function normalizeMeshArrowTable(data) {
-    if ('shape' in data && data.shape === 'arrow-table') {
+    if (!('attributes' in data)) {
         return data;
     }
-    return convertMeshToTable(data, 'arrow-table');
+    return convertMeshToArrowTableWrapper(data);
 }
 /** Return a required mesh attribute or throw a format-specific error. */
 function getRequiredAttribute(mesh, attributeName) {