convert-buddy-js 0.3.0 → 0.5.0

package/README.md

@@ -44,8 +44,10 @@ console.log(buddy.stats());
 
 ### Node.js Transform stream
 
+Use the Node-specific entrypoint so bundlers keep `node:stream` out of the browser bundle.
+
 ```ts
-import { createNodeTransform } from "convert-buddy-js";
+import { createNodeTransform } from "convert-buddy-js/node";
 import { createReadStream, createWriteStream } from "node:fs";
 
 const transform = await createNodeTransform({
@@ -74,6 +76,28 @@ const response = await fetch("/data.csv");
 const outputStream = response.body?.pipeThrough(transform);
 ```
 
+### Detect format and CSV fields/delimiter
+
+Use streaming inputs to keep detection fast on large files.
+
+```ts
+import {
+  detectFormat,
+  detectCsvFieldsAndDelimiter,
+} from "convert-buddy-js";
+
+const fileStream = (await fetch("/data")).body!;
+
+const format = await detectFormat(fileStream, { maxBytes: 256 * 1024 });
+console.log(format); // "csv" | "json" | "ndjson" | "xml" | "unknown"
+
+const csvInfo = await detectCsvFieldsAndDelimiter(fileStream);
+if (csvInfo) {
+  console.log(csvInfo.delimiter);
+  console.log(csvInfo.fields);
+}
+```
+
 ## Configuration
 
 ### Formats

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

@@ -55,58 +55,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 +181,10 @@ async function convertToString(input, opts = {}) {
 
 export {
   ConvertBuddy,
-  createNodeTransform,
+  detectFormat,
+  detectCsvFieldsAndDelimiter,
   ConvertBuddyTransformStream,
   convert,
   convertToString
 };
-//# sourceMappingURL=chunk-27H3T556.js.map
+//# sourceMappingURL=chunk-IOVM4CIO.js.map

package/dist/chunk-XKIJB7Y4.js

@@ -0,0 +1,63 @@
+import {
+  ConvertBuddy
+} from "./chunk-IOVM4CIO.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-XKIJB7Y4.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;
@@ -44,11 +51,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-IOVM4CIO.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-XKIJB7Y4.js";
+import {
+  ConvertBuddy,
+  ConvertBuddyTransformStream,
+  convert,
+  convertToString,
+  detectCsvFieldsAndDelimiter,
+  detectFormat
+} from "../chunk-IOVM4CIO.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.3.0",
+  "version": "0.5.0",
   "description": "TypeScript wrapper for convert-buddy (Rust/WASM core)",
   "license": "MIT",
   "type": "module",
@@ -10,11 +10,17 @@
     ".": {
       "types": "./dist/src/index.d.ts",
       "default": "./dist/src/index.js"
+    },
+    "./node": {
+      "types": "./dist/src/node.d.ts",
+      "default": "./dist/src/node.js"
     }
   },
   "files": [
     "dist/src/index.js",
     "dist/src/index.d.ts",
+    "dist/src/node.js",
+    "dist/src/node.d.ts",
     "dist/chunk-*.js",
     "dist/chunk-*.d.ts",
     "dist/*.js",