convert-buddy-js 0.1.0

package/dist/chunk-B44HYXEP.js

@@ -0,0 +1,161 @@
+// src/index.ts
+import { Transform } from "stream";
+async function loadWasmModule() {
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  if (isNode) {
+    const { createRequire } = await import("module");
+    const require2 = createRequire(import.meta.url);
+    const mod2 = require2("../wasm-node.cjs");
+    return mod2;
+  }
+  const mod = await import("../wasm/web/convert_buddy.js");
+  return mod;
+}
+var ConvertBuddy = class _ConvertBuddy {
+  converter;
+  debug;
+  profile;
+  constructor(converter, debug, profile) {
+    this.converter = converter;
+    this.debug = debug;
+    this.profile = profile;
+  }
+  static async create(opts = {}) {
+    const debug = !!opts.debug;
+    const profile = !!opts.profile;
+    const wasmModule = await loadWasmModule();
+    if (typeof wasmModule.default === "function") {
+      await wasmModule.default();
+    }
+    wasmModule.init(debug);
+    let converter;
+    if (opts.inputFormat && opts.outputFormat) {
+      const Converter = wasmModule.Converter;
+      converter = Converter.withConfig(
+        debug,
+        opts.inputFormat,
+        opts.outputFormat,
+        opts.chunkTargetBytes || 1024 * 1024,
+        profile
+      );
+    } else {
+      converter = new wasmModule.Converter(debug);
+    }
+    if (debug) console.log("[convert-buddy-js] initialized", opts);
+    return new _ConvertBuddy(converter, debug, profile);
+  }
+  push(chunk) {
+    if (this.debug) console.log("[convert-buddy-js] push", chunk.byteLength);
+    return this.converter.push(chunk);
+  }
+  finish() {
+    if (this.debug) console.log("[convert-buddy-js] finish");
+    return this.converter.finish();
+  }
+  stats() {
+    return this.converter.getStats();
+  }
+};
+function createNodeTransform(opts = {}) {
+  let buddy = null;
+  let initPromise = null;
+  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;
+}
+var ConvertBuddyTransformStream = class extends TransformStream {
+  constructor(opts = {}) {
+    let buddy = null;
+    super({
+      async start(controller) {
+        buddy = await ConvertBuddy.create(opts);
+      },
+      transform(chunk, controller) {
+        if (!buddy) {
+          throw new Error("ConvertBuddy not initialized");
+        }
+        const output = buddy.push(chunk);
+        if (output.length > 0) {
+          controller.enqueue(output);
+        }
+      },
+      flush(controller) {
+        if (!buddy) {
+          return;
+        }
+        const output = buddy.finish();
+        if (output.length > 0) {
+          controller.enqueue(output);
+        }
+        if (opts.profile) {
+          const stats = buddy.stats();
+          console.log("[convert-buddy] Performance Stats:", stats);
+        }
+      }
+    });
+  }
+};
+async function convert(input, opts = {}) {
+  const buddy = await ConvertBuddy.create(opts);
+  const inputBytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const output = buddy.push(inputBytes);
+  const final = buddy.finish();
+  const result = new Uint8Array(output.length + final.length);
+  result.set(output, 0);
+  result.set(final, output.length);
+  if (opts.profile) {
+    const stats = buddy.stats();
+    console.log("[convert-buddy] Performance Stats:", stats);
+  }
+  return result;
+}
+async function convertToString(input, opts = {}) {
+  const result = await convert(input, opts);
+  return new TextDecoder().decode(result);
+}
+
+export {
+  ConvertBuddy,
+  createNodeTransform,
+  ConvertBuddyTransformStream,
+  convert,
+  convertToString
+};
+//# sourceMappingURL=chunk-B44HYXEP.js.map

package/dist/chunk-DESHN2IK.js

@@ -0,0 +1,151 @@
+// bench/datasets.ts
+function generateCsvDataset(rows, cols) {
+  const encoder = new TextEncoder();
+  let csv = "";
+  const headers = Array.from({ length: cols }, (_, i) => `column_${i}`);
+  csv += headers.join(",") + "\n";
+  for (let i = 0; i < rows; i++) {
+    const row = Array.from({ length: cols }, (_, j) => {
+      if (j % 4 === 0) {
+        return `"text_${i}_${j}"`;
+      } else if (j % 4 === 1) {
+        return i * j;
+      } else if (j % 4 === 2) {
+        return `value_${i}`;
+      } else {
+        return `"quoted, with comma ${i}"`;
+      }
+    });
+    csv += row.join(",") + "\n";
+  }
+  return encoder.encode(csv);
+}
+function generateNdjsonDataset(records, fields) {
+  const encoder = new TextEncoder();
+  let ndjson = "";
+  for (let i = 0; i < records; i++) {
+    const obj = {};
+    for (let j = 0; j < fields; j++) {
+      const key = `field_${j}`;
+      if (j % 5 === 0) {
+        obj[key] = `string_value_${i}_${j}`;
+      } else if (j % 5 === 1) {
+        obj[key] = i * j;
+      } else if (j % 5 === 2) {
+        obj[key] = i % 2 === 0;
+      } else if (j % 5 === 3) {
+        obj[key] = null;
+      } else {
+        obj[key] = { nested: `value_${i}`, count: j };
+      }
+    }
+    ndjson += JSON.stringify(obj) + "\n";
+  }
+  return encoder.encode(ndjson);
+}
+function generateXmlDataset(records, fields) {
+  const encoder = new TextEncoder();
+  let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<root>\n';
+  for (let i = 0; i < records; i++) {
+    xml += `  <record id="${i}">
+`;
+    for (let j = 0; j < fields; j++) {
+      const value = `value_${i}_${j}`;
+      xml += `    <field_${j}>${value}</field_${j}>
+`;
+    }
+    xml += `  </record>
+`;
+  }
+  xml += "</root>\n";
+  return encoder.encode(xml);
+}
+function generateJsonDataset(records, fields) {
+  const encoder = new TextEncoder();
+  const array = [];
+  for (let i = 0; i < records; i++) {
+    const obj = {};
+    for (let j = 0; j < fields; j++) {
+      const key = `field_${j}`;
+      if (j % 4 === 0) {
+        obj[key] = `string_value_${i}_${j}`;
+      } else if (j % 4 === 1) {
+        obj[key] = i * j;
+      } else if (j % 4 === 2) {
+        obj[key] = i % 2 === 0;
+      } else {
+        obj[key] = { nested: `value_${i}` };
+      }
+    }
+    array.push(obj);
+  }
+  return encoder.encode(JSON.stringify(array));
+}
+function generateRealisticCsv(rows) {
+  const encoder = new TextEncoder();
+  let csv = "id,name,email,age,city,description\n";
+  const cities = ["New York", "London", "Tokyo", "Paris", "Berlin"];
+  const names = ["Alice", "Bob", "Charlie", "Diana", "Eve"];
+  for (let i = 0; i < rows; i++) {
+    const name = names[i % names.length];
+    const email = `${name.toLowerCase()}${i}@example.com`;
+    const age = 20 + i % 50;
+    const city = cities[i % cities.length];
+    const description = `"This is a longer description with, commas and ""quotes"" for record ${i}"`;
+    csv += `${i},${name},${email},${age},${city},${description}
+`;
+  }
+  return encoder.encode(csv);
+}
+function generateWideCsv(rows, cols = 100) {
+  const encoder = new TextEncoder();
+  const headers = Array.from({ length: cols }, (_, i) => `col_${i}`);
+  let csv = headers.join(",") + "\n";
+  for (let i = 0; i < rows; i++) {
+    const row = Array.from({ length: cols }, (_, j) => i * cols + j);
+    csv += row.join(",") + "\n";
+  }
+  return encoder.encode(csv);
+}
+function generateLargeObjectNdjson(records) {
+  const encoder = new TextEncoder();
+  let ndjson = "";
+  for (let i = 0; i < records; i++) {
+    const obj = {
+      id: i,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      user: {
+        name: `User ${i}`,
+        email: `user${i}@example.com`,
+        profile: {
+          age: 20 + i % 50,
+          city: "City",
+          bio: "A".repeat(100)
+          // Large string
+        }
+      },
+      data: Array.from({ length: 10 }, (_, j) => ({
+        key: `key_${j}`,
+        value: i * j
+      })),
+      metadata: {
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        updated: (/* @__PURE__ */ new Date()).toISOString(),
+        tags: ["tag1", "tag2", "tag3"]
+      }
+    };
+    ndjson += JSON.stringify(obj) + "\n";
+  }
+  return encoder.encode(ndjson);
+}
+
+export {
+  generateCsvDataset,
+  generateNdjsonDataset,
+  generateXmlDataset,
+  generateJsonDataset,
+  generateRealisticCsv,
+  generateWideCsv,
+  generateLargeObjectNdjson
+};
+//# sourceMappingURL=chunk-DESHN2IK.js.map

package/dist/chunk-HFHFJO2R.js

@@ -0,0 +1,44 @@
+// src/index.ts
+async function loadWasmModule() {
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  if (isNode) {
+    const { createRequire } = await import("module");
+    const require2 = createRequire(import.meta.url);
+    const mod2 = require2("../wasm-node.cjs");
+    return mod2;
+  }
+  const mod = await import("../wasm/web/convert_buddy.js");
+  return mod;
+}
+var ConvertBuddy = class _ConvertBuddy {
+  converter;
+  debug;
+  constructor(converter, debug) {
+    this.converter = converter;
+    this.debug = debug;
+  }
+  static async create(opts = {}) {
+    const debug = !!opts.debug;
+    const wasmModule = await loadWasmModule();
+    if (typeof wasmModule.default === "function") {
+      await wasmModule.default();
+    }
+    wasmModule.init(debug);
+    const converter = new wasmModule.Converter(debug);
+    if (debug) console.log("[convert-buddy-js] initialized with debug logging");
+    return new _ConvertBuddy(converter, debug);
+  }
+  push(chunk) {
+    if (this.debug) console.log("[convert-buddy-js] push", chunk.byteLength);
+    return this.converter.push(chunk);
+  }
+  finish() {
+    if (this.debug) console.log("[convert-buddy-js] finish");
+    return this.converter.finish();
+  }
+};
+
+export {
+  ConvertBuddy
+};
+//# sourceMappingURL=chunk-HFHFJO2R.js.map

package/dist/chunk-VUNV25KB.js

@@ -0,0 +1,16 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};
+//# sourceMappingURL=chunk-VUNV25KB.js.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+type ConvertBuddyOptions = {
+    debug?: boolean;
+};
+declare class ConvertBuddy {
+    private converter;
+    private debug;
+    private constructor();
+    static create(opts?: ConvertBuddyOptions): Promise<ConvertBuddy>;
+    push(chunk: Uint8Array): Uint8Array;
+    finish(): Uint8Array;
+}
+
+export { ConvertBuddy, type ConvertBuddyOptions };

package/dist/index.js

@@ -0,0 +1,7 @@
+import {
+  ConvertBuddy
+} from "./chunk-HFHFJO2R.js";
+export {
+  ConvertBuddy
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "convert-buddy-js",
+  "version": "0.1.0",
+  "description": "TypeScript wrapper for convert-buddy (Rust/WASM core)",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/chunk-*.js",
+    "dist/chunk-*.d.ts",
+    "wasm",
+    "wasm-node.cjs",
+    "!dist/smoke-test.*",
+    "!dist/bench"
+  ],
+  "scripts": {
+    "clean": "node ./scripts/clean.mjs",
+    "build:wasm:web": "set CONVERT_BUDDY_WASM_TARGET=web&& node ./scripts/build-wasm.mjs",
+    "build:wasm:node": "set CONVERT_BUDDY_WASM_TARGET=nodejs&& node ./scripts/build-wasm.mjs",
+    "build:wasm": "npm run build:wasm:web && npm run build:wasm:node",
+    "build": "npm run build:wasm && tsup",
+    "test": "npm run build && node ./dist/smoke-test.js",
+    "test:edge-cases": "npm run build && node --test ./dist/tests/edge-cases/*.test.js",
+    "test:all": "npm run test && npm run test:edge-cases",
+    "bench": "npm run build && node ./dist/bench/runner.js",
+    "bench:single-thread": "npm run build && UV_THREADPOOL_SIZE=1 node ./dist/bench/single-thread.js",
+    "bench:multi-thread": "npm run build && node ./dist/bench/multi-thread.js",
+    "bench:compare": "npm run build && node ./dist/bench/compare-threads.js",
+    "bench:competitors": "npm run build && node ./dist/bench/runner-with-competitors.js",
+    "bench:competitors-comprehensive": "npm run build && node ./dist/bench/runner-competitors-comprehensive.js",
+    "bench:all": "npm run bench:single-thread && npm run bench:multi-thread && npm run bench:compare && npm run bench:competitors-comprehensive",
+    "lint": "node ./scripts/lint-placeholder.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@types/papaparse": "^5.3.15",
+    "csv-parse": "^5.6.0",
+    "fast-csv": "^5.0.1",
+    "papaparse": "^5.4.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/wasm-node.cjs

@@ -0,0 +1 @@
+module.exports = require("./wasm/nodejs/convert_buddy.js");