convert-buddy-js 0.4.0 → 0.6.0

package/README.md

@@ -146,11 +146,22 @@ if (csvInfo) {
 ## How it works
 
 - **Rust core** (`crates/convert-buddy`) implements streaming parsers and stats tracking.
-- **WASM bindings** are generated via `wasm-bindgen` and bundled into this package.
+- **WASM bindings** are generated via `wasm-bindgen` and bundled into this package as prebuilt binaries.
 - **TypeScript wrapper** (`src/index.ts`) exposes the `ConvertBuddy` class and stream adapters.
 
+## Package contents (what ships)
+
+The published npm package includes only the runtime artifacts needed to use Convert Buddy:
+
+- Prebuilt WASM binaries (in `wasm/` plus `wasm-node.cjs` for Node.js).
+- Compiled TypeScript output (in `dist/`).
+
+The monorepo demo app, Rust sources, and build/benchmark tooling live in this repository but are **not** published with the npm package.
+
 ### Build (repository)
 
+These steps are **only** for contributors working in this monorepo. If you install `convert-buddy-js` from npm, you do **not** need to run them.
+
 ```bash
 npm install
 npm -w convert-buddy-js run build

package/dist/chunk-C3RSVYQF.js

@@ -0,0 +1,63 @@
+import {
+  ConvertBuddy
+} from "./chunk-WBKHAQCT.js";
+
+// src/node.ts
+async function loadNodeTransform() {
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  if (!isNode) {
+    throw new Error("createNodeTransform is only available in Node.js runtimes.");
+  }
+  const streamModule = await import("stream");
+  return streamModule.Transform;
+}
+async function createNodeTransform(opts = {}) {
+  let buddy = null;
+  let initPromise = null;
+  const Transform = await loadNodeTransform();
+  const transform = new Transform({
+    async transform(chunk, encoding, callback) {
+      try {
+        if (!buddy) {
+          if (!initPromise) {
+            initPromise = ConvertBuddy.create(opts).then((b) => {
+              buddy = b;
+            });
+          }
+          await initPromise;
+        }
+        const input = new Uint8Array(chunk);
+        const output = buddy.push(input);
+        if (output.length > 0) {
+          this.push(Buffer.from(output));
+        }
+        callback();
+      } catch (err) {
+        callback(err);
+      }
+    },
+    async flush(callback) {
+      try {
+        if (buddy) {
+          const output = buddy.finish();
+          if (output.length > 0) {
+            this.push(Buffer.from(output));
+          }
+          if (opts.profile) {
+            const stats = buddy.stats();
+            console.log("[convert-buddy] Performance Stats:", stats);
+          }
+        }
+        callback();
+      } catch (err) {
+        callback(err);
+      }
+    }
+  });
+  return transform;
+}
+
+export {
+  createNodeTransform
+};
+//# sourceMappingURL=chunk-C3RSVYQF.js.map

package/dist/{chunk-27H3T556.js → chunk-WBKHAQCT.js}

@@ -35,7 +35,9 @@ var ConvertBuddy = class _ConvertBuddy {
         opts.inputFormat,
         opts.outputFormat,
         opts.chunkTargetBytes || 1024 * 1024,
-        profile
+        profile,
+        opts.csvConfig,
+        opts.xmlConfig
       );
     } else {
       converter = new wasmModule.Converter(debug);
@@ -55,58 +57,78 @@ var ConvertBuddy = class _ConvertBuddy {
     return this.converter.getStats();
   }
 };
-async function loadNodeTransform() {
-  const isNode = typeof process !== "undefined" && !!process.versions?.node;
-  if (!isNode) {
-    throw new Error("createNodeTransform is only available in Node.js runtimes.");
+async function readSample(input, maxBytes = 256 * 1024) {
+  if (typeof input === "string") {
+    const encoded = new TextEncoder().encode(input);
+    return encoded.length > maxBytes ? encoded.slice(0, maxBytes) : encoded;
   }
-  const streamModule = await import("stream");
-  return streamModule.Transform;
-}
-async function createNodeTransform(opts = {}) {
-  let buddy = null;
-  let initPromise = null;
-  const Transform = await loadNodeTransform();
-  const transform = new Transform({
-    async transform(chunk, encoding, callback) {
-      try {
-        if (!buddy) {
-          if (!initPromise) {
-            initPromise = ConvertBuddy.create(opts).then((b) => {
-              buddy = b;
-            });
-          }
-          await initPromise;
-        }
-        const input = new Uint8Array(chunk);
-        const output = buddy.push(input);
-        if (output.length > 0) {
-          this.push(Buffer.from(output));
-        }
-        callback();
-      } catch (err) {
-        callback(err);
-      }
-    },
-    async flush(callback) {
-      try {
-        if (buddy) {
-          const output = buddy.finish();
-          if (output.length > 0) {
-            this.push(Buffer.from(output));
-          }
-          if (opts.profile) {
-            const stats = buddy.stats();
-            console.log("[convert-buddy] Performance Stats:", stats);
-          }
-        }
-        callback();
-      } catch (err) {
-        callback(err);
-      }
+  if (input instanceof Uint8Array) {
+    return input.length > maxBytes ? input.slice(0, maxBytes) : input;
+  }
+  if (input instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(input);
+    return bytes.length > maxBytes ? bytes.slice(0, maxBytes) : bytes;
+  }
+  if (isReadableStream(input)) {
+    const reader = input.getReader();
+    const chunks2 = [];
+    let total2 = 0;
+    while (total2 < maxBytes) {
+      const { value, done } = await reader.read();
+      if (done || !value) break;
+      const slice = total2 + value.length > maxBytes ? value.slice(0, maxBytes - total2) : value;
+      chunks2.push(slice);
+      total2 += slice.length;
+    }
+    if (total2 >= maxBytes) {
+      await reader.cancel();
     }
-  });
-  return transform;
+    return concatChunks(chunks2, total2);
+  }
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of input) {
+    if (total >= maxBytes) {
+      break;
+    }
+    const data = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+    const slice = total + data.length > maxBytes ? data.slice(0, maxBytes - total) : data;
+    chunks.push(slice);
+    total += slice.length;
+  }
+  return concatChunks(chunks, total);
+}
+function concatChunks(chunks, total) {
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function isReadableStream(input) {
+  return typeof input?.getReader === "function";
+}
+async function loadDetectionWasm(debug) {
+  const wasmModule = await loadWasmModule();
+  if (typeof wasmModule.default === "function") {
+    await wasmModule.default();
+  }
+  wasmModule.init(debug);
+  return wasmModule;
+}
+async function detectFormat(input, opts = {}) {
+  const wasmModule = await loadDetectionWasm(!!opts.debug);
+  const sample = await readSample(input, opts.maxBytes);
+  const format = wasmModule.detectFormat?.(sample);
+  return format ?? "unknown";
+}
+async function detectCsvFieldsAndDelimiter(input, opts = {}) {
+  const wasmModule = await loadDetectionWasm(!!opts.debug);
+  const sample = await readSample(input, opts.maxBytes);
+  const result = wasmModule.detectCsvFields?.(sample);
+  return result ?? null;
 }
 var ConvertBuddyTransformStream = class extends TransformStream {
   constructor(opts = {}) {
@@ -161,9 +183,10 @@ async function convertToString(input, opts = {}) {
 
 export {
   ConvertBuddy,
-  createNodeTransform,
+  detectFormat,
+  detectCsvFieldsAndDelimiter,
   ConvertBuddyTransformStream,
   convert,
   convertToString
 };
-//# sourceMappingURL=chunk-27H3T556.js.map
+//# sourceMappingURL=chunk-WBKHAQCT.js.map

package/dist/src/index.d.ts

@@ -1,6 +1,13 @@
-import { Transform } from 'node:stream';
-
 type Format = "csv" | "ndjson" | "json" | "xml";
+type DetectInput = Uint8Array | ArrayBuffer | string | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+type CsvDetection = {
+    delimiter: string;
+    fields: string[];
+};
+type DetectOptions = {
+    maxBytes?: number;
+    debug?: boolean;
+};
 type ConvertBuddyOptions = {
     debug?: boolean;
     profile?: boolean;
@@ -21,6 +28,7 @@ type XmlConfig = {
     recordElement?: string;
     trimText?: boolean;
     includeAttributes?: boolean;
+    expandEntities?: boolean;
 };
 type Stats = {
     bytesIn: number;
@@ -44,11 +52,12 @@ declare class ConvertBuddy {
     finish(): Uint8Array;
     stats(): Stats;
 }
-declare function createNodeTransform(opts?: ConvertBuddyOptions): Promise<Transform>;
+declare function detectFormat(input: DetectInput, opts?: DetectOptions): Promise<Format | "unknown">;
+declare function detectCsvFieldsAndDelimiter(input: DetectInput, opts?: DetectOptions): Promise<CsvDetection | null>;
 declare class ConvertBuddyTransformStream extends TransformStream<Uint8Array, Uint8Array> {
     constructor(opts?: ConvertBuddyOptions);
 }
 declare function convert(input: Uint8Array | string, opts?: ConvertBuddyOptions): Promise<Uint8Array>;
 declare function convertToString(input: Uint8Array | string, opts?: ConvertBuddyOptions): Promise<string>;
 
-export { ConvertBuddy, type ConvertBuddyOptions, ConvertBuddyTransformStream, type CsvConfig, type Format, type Stats, type XmlConfig, convert, convertToString, createNodeTransform };
+export { ConvertBuddy, type ConvertBuddyOptions, ConvertBuddyTransformStream, type CsvConfig, type CsvDetection, type DetectInput, type DetectOptions, type Format, type Stats, type XmlConfig, convert, convertToString, detectCsvFieldsAndDelimiter, detectFormat };

package/dist/src/index.js

@@ -3,13 +3,15 @@ import {
   ConvertBuddyTransformStream,
   convert,
   convertToString,
-  createNodeTransform
-} from "../chunk-27H3T556.js";
+  detectCsvFieldsAndDelimiter,
+  detectFormat
+} from "../chunk-WBKHAQCT.js";
 export {
   ConvertBuddy,
   ConvertBuddyTransformStream,
   convert,
   convertToString,
-  createNodeTransform
+  detectCsvFieldsAndDelimiter,
+  detectFormat
 };
 //# sourceMappingURL=index.js.map

package/dist/src/node.d.ts

@@ -0,0 +1,7 @@
+import { Transform } from 'node:stream';
+import { ConvertBuddyOptions } from './index.js';
+export { ConvertBuddy, ConvertBuddyTransformStream, CsvConfig, CsvDetection, DetectInput, DetectOptions, Format, Stats, XmlConfig, convert, convertToString, detectCsvFieldsAndDelimiter, detectFormat } from './index.js';
+
+declare function createNodeTransform(opts?: ConvertBuddyOptions): Promise<Transform>;
+
+export { ConvertBuddyOptions, createNodeTransform };

package/dist/src/node.js

@@ -0,0 +1,21 @@
+import {
+  createNodeTransform
+} from "../chunk-C3RSVYQF.js";
+import {
+  ConvertBuddy,
+  ConvertBuddyTransformStream,
+  convert,
+  convertToString,
+  detectCsvFieldsAndDelimiter,
+  detectFormat
+} from "../chunk-WBKHAQCT.js";
+export {
+  ConvertBuddy,
+  ConvertBuddyTransformStream,
+  convert,
+  convertToString,
+  createNodeTransform,
+  detectCsvFieldsAndDelimiter,
+  detectFormat
+};
+//# sourceMappingURL=node.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "convert-buddy-js",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "TypeScript wrapper for convert-buddy (Rust/WASM core)",
   "license": "MIT",
   "type": "module",