@playcanvas/splat-transform 1.3.0 → 1.4.1

package/dist/cli.mjs

@@ -11029,42 +11029,38 @@ class DataTable {
      * After calling, row `i` will contain the data that was previously at row `indices[i]`.
      *
      * This is a memory-efficient alternative to `permuteRows` that modifies the table
-     * in-place rather than creating a copy.
+     * in-place rather than creating a copy. It reuses ArrayBuffers between columns to
+     * minimize memory allocations.
      *
      * @param indices - Array of indices defining the permutation. Must have the same
      * length as the number of rows, and must be a valid permutation
      * (each index 0 to n-1 appears exactly once).
      */
     permuteRowsInPlace(indices) {
-        const n = this.numRows;
-        const numCols = this.columns.length;
-        const visited = new Uint8Array(n);
-        const temps = new Array(numCols);
-        for (let i = 0; i < n; i++) {
-            if (visited[i] || indices[i] === i)
-                continue;
-            // Save values at position i
-            for (let c = 0; c < numCols; c++) {
-                temps[c] = this.columns[c].data[i];
+        // Cache for reusing ArrayBuffers by size
+        const cache = new Map();
+        const getBuffer = (size) => {
+            const cached = cache.get(size);
+            if (cached) {
+                cache.delete(size);
+                return cached;
             }
-            // Walk the cycle
-            let j = i;
-            while (true) {
-                const next = indices[j];
-                visited[j] = 1;
-                if (next === i) {
-                    // End of cycle - place saved values
-                    for (let c = 0; c < numCols; c++) {
-                        this.columns[c].data[j] = temps[c];
-                    }
-                    break;
-                }
-                // Move values from next to j
-                for (let c = 0; c < numCols; c++) {
-                    this.columns[c].data[j] = this.columns[c].data[next];
-                }
-                j = next;
+            return new ArrayBuffer(size);
+        };
+        const returnBuffer = (buffer) => {
+            cache.set(buffer.byteLength, buffer);
+        };
+        const n = this.numRows;
+        for (const column of this.columns) {
+            const src = column.data;
+            const constructor = src.constructor;
+            const dst = new constructor(getBuffer(src.byteLength));
+            // Sequential writes are cache-friendly
+            for (let i = 0; i < n; i++) {
+                dst[i] = src[indices[i]];
             }
+            returnBuffer(src.buffer);
+            column.data = dst;
         }
     }
 }
@@ -12388,6 +12384,81 @@ const readKsplat = async (source) => {
     return new DataTable(columns);
 };
 
+/**
+ * ReadStream wrapper that adds read-ahead buffering to reduce async overhead.
+ * Reads larger chunks from the inner stream and buffers excess data for
+ * subsequent small reads. Useful for sources with high per-call overhead.
+ *
+ * @example
+ * // Wrap a stream with 4MB read-ahead buffering
+ * const buffered = new BufferedReadStream(rawStream, 4 * 1024 * 1024);
+ * const data = await buffered.readAll();
+ */
+class BufferedReadStream extends ReadStream {
+    inner;
+    chunkSize;
+    // Buffer state
+    buffer = null;
+    bufferOffset = 0;
+    /**
+     * Create a caching wrapper around a stream.
+     * @param inner - The underlying stream to read from
+     * @param chunkSize - Minimum bytes to read at once from inner stream (default 64KB)
+     */
+    constructor(inner, chunkSize = 65536) {
+        super(inner.expectedSize);
+        this.inner = inner;
+        this.chunkSize = chunkSize;
+    }
+    async pull(target) {
+        // Early return for zero-length requests (e.g., EOF check from readAll)
+        if (target.length === 0) {
+            return 0;
+        }
+        let written = 0;
+        // Serve from buffer first
+        if (this.buffer && this.bufferOffset < this.buffer.length) {
+            const available = this.buffer.length - this.bufferOffset;
+            const toCopy = Math.min(available, target.length);
+            target.set(this.buffer.subarray(this.bufferOffset, this.bufferOffset + toCopy));
+            this.bufferOffset += toCopy;
+            written += toCopy;
+            this.bytesRead += toCopy;
+            // Clear exhausted buffer
+            if (this.bufferOffset >= this.buffer.length) {
+                this.buffer = null;
+                this.bufferOffset = 0;
+            }
+            if (written >= target.length) {
+                return written;
+            }
+        }
+        // Read a chunk from inner stream
+        const remaining = target.length - written;
+        const readSize = Math.max(this.chunkSize, remaining);
+        const chunk = new Uint8Array(readSize);
+        const n = await this.inner.pull(chunk);
+        if (n === 0) {
+            return written;
+        }
+        // Copy what we need to target
+        const toCopy = Math.min(n, remaining);
+        target.set(chunk.subarray(0, toCopy), written);
+        written += toCopy;
+        this.bytesRead += toCopy;
+        // Cache the excess
+        if (toCopy < n) {
+            this.buffer = chunk.subarray(0, n);
+            this.bufferOffset = toCopy;
+        }
+        return written;
+    }
+    close() {
+        this.inner.close();
+        this.buffer = null;
+    }
+}
+
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   if (!input) {
@@ -14224,7 +14295,7 @@ class CompressedChunk {
     }
 }
 
-var version = "1.3.0";
+var version = "1.4.1";
 
 const generatedByString = `Generated by splat-transform ${version}`;
 const chunkProps = [
@@ -16344,7 +16415,9 @@ class NodeReadSource {
         // Clamp range to valid bounds
         const clampedStart = Math.max(0, Math.min(start, this.size));
         const clampedEnd = Math.max(clampedStart, Math.min(end, this.size));
-        return new NodeReadStream(this.fileHandle, clampedStart, clampedEnd);
+        // Wrap with BufferedReadStream to reduce async overhead from file reads
+        const raw = new NodeReadStream(this.fileHandle, clampedStart, clampedEnd);
+        return new BufferedReadStream(raw, 4 * 1024 * 1024); // 4MB chunks
     }
     close() {
         this.closed = true;