tiny-parquet 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nktrchk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,338 @@
+```
+  ╔═════════════════════════════════════════════════════════════════╗
+  ║                                                                 ║
+  ║   ████████╗██╗███╗   ██╗██╗   ██╗                               ║
+  ║   ╚══██╔══╝██║████╗  ██║╚██╗ ██╔╝                               ║
+  ║      ██║   ██║██╔██╗ ██║ ╚████╔╝                                ║
+  ║      ██║   ██║██║╚██╗██║  ╚██╔╝                                 ║
+  ║      ██║   ██║██║ ╚████║   ██║                                  ║
+  ║      ╚═╝   ╚═╝╚═╝  ╚═══╝   ╚═╝                                  ║
+  ║                                                                 ║
+  ║   ██████╗  █████╗ ██████╗  ██████╗ ██╗   ██╗███████╗████████╗   ║
+  ║   ██╔══██╗██╔══██╗██╔══██╗██╔═══██╗██║   ██║██╔════╝╚══██╔══╝   ║
+  ║   ██████╔╝███████║██████╔╝██║   ██║██║   ██║█████╗     ██║      ║
+  ║   ██╔═══╝ ██╔══██║██╔══██╗██║▄▄ ██║██║   ██║██╔══╝     ██║      ║
+  ║   ██║     ██║  ██║██║  ██║╚██████╔╝╚██████╔╝███████╗   ██║      ║
+  ║   ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝ ╚══▀▀═╝  ╚═════╝ ╚══════╝   ╚═╝      ║
+  ║                                                                 ║
+  ║   Read & write Apache Parquet in 319KB of WASM.                 ║
+  ║   Two functions. Zero dependencies.                             ║
+  ║                                                                 ║
+  ╚═════════════════════════════════════════════════════════════════╝
+```
+
+<p align="center">
+  <strong>The only Parquet library that fits on Cloudflare Workers free tier and Vercel Edge.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/tiny-parquet"><img src="https://img.shields.io/npm/v/tiny-parquet.svg?style=flat-square&color=cb3837" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/tiny-parquet"><img src="https://img.shields.io/npm/dm/tiny-parquet.svg?style=flat-square&color=blue" alt="npm downloads"></a>
+  <a href="https://github.com/nktrchk/tiny-parquet/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg?style=flat-square" alt="license"></a>
+  <a href="https://github.com/nktrchk/tiny-parquet"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square" alt="PRs Welcome"></a>
+</p>
+
+---
+
+## Why
+
+You're building on the edge. You need Parquet. But:
+
+```
+  parquet-wasm    3,500 KB  ❌  Too fat for Vercel Edge & CF free tier
+  duckdb-wasm    8,000 KB   ❌  Way too fat
+  parquetjs        500 KB   ❌  Node.js only
+
+  tiny-parquet     319 KB   ✅  Runs everywhere
+```
+
+**tiny-parquet** gives you `readParquet` and `writeParquet` — two async functions backed by Rust + WASM via the [`parquet2`](https://crates.io/crates/parquet2) crate. That's it.
+
+---
+
+## Install
+
+```bash
+npm install tiny-parquet
+```
+
+---
+
+## Quick Start
+
+```js
+import { writeParquet, readParquet } from 'tiny-parquet';
+
+// ── Write ────────────────────────────────────────────────────────
+const bytes = await writeParquet(
+  [
+    { name: 'url',    type: 'string' },
+    { name: 'ts',     type: 'int64' },
+    { name: 'score',  type: 'float64' },
+    { name: 'active', type: 'boolean' },
+  ],
+  {
+    url:    ['https://example.com', 'https://test.dev'],
+    ts:     [1708000000, 1708100000],
+    score:  [98.5, 76.3],
+    active: [true, false],
+  },
+  { compression: 'snappy' }
+);
+
+// ── Read ─────────────────────────────────────────────────────────
+const { schema, data, numRows } = await readParquet(bytes);
+
+console.log(schema);   // [{ name: 'url', type: 'string' }, ...]
+console.log(data.url); // ['https://example.com', 'https://test.dev']
+console.log(numRows);  // 2
+```
+
+### Subpath Imports
+
+```js
+// Import only what you need — smaller bundles
+import { readParquet }  from 'tiny-parquet/reader';
+import { writeParquet } from 'tiny-parquet/writer';
+```
+
+---
+
+## Runs Everywhere
+
+```
+  ┌─────────────────────────────────┬────────┐
+  │ Runtime                         │ Status │
+  ├─────────────────────────────────┼────────┤
+  │ Cloudflare Workers              │   ✅   │
+  │ Vercel Edge Functions           │   ✅   │
+  │ Deno / Deno Deploy              │   ✅   │
+  │ Bun                             │   ✅   │
+  │ Node.js (≥18)                   │   ✅   │
+  │ Browser (Chrome/FF/Safari)      │   ✅   │
+  │ AWS Lambda                      │   ✅   │
+  │ Google Cloud Functions          │   ✅   │
+  │ Fastly Compute                  │   ✅   │
+  │ Electron                        │   ✅   │
+  └─────────────────────────────────┴────────┘
+```
+
+---
+
+## Size Comparison
+
+```
+  ┌──────────────────┬─────────┬──────────────────────────────────┬───────────────────────────┐
+  │ Package          │ Size    │ CF Workers free (1MB) │ Vercel Edge (1MB soft)               │
+  ├──────────────────┼─────────┼──────────────────────────────────┼───────────────────────────┤
+  │ parquet-wasm     │ 3.5 MB  │        ❌ No                      │        ❌ No              │
+  │ duckdb-wasm      │ 8.0 MB  │        ❌ No                      │        ❌ No              │
+  │ parquetjs        │ 500 KB  │        ❌ Node only               │        ❌ Node only       │
+  │ tiny-parquet     │ 319 KB  │        ✅ Yes                     │        ✅ Yes             │
+  └──────────────────┴─────────┴──────────────────────────────────┴───────────────────────────┘
+```
+
+---
+
+## Anatomy
+
+```
+  ┌───────────────────────────────────────────────┐
+  │              tiny-parquet                     │
+  │                                               │
+  │   ┌─────────────┐      ┌──────────────┐       │
+  │   │ writer.wasm │      │ reader.wasm  │       │
+  │   │   179 KB    │      │   140 KB     │       │
+  │   │             │      │              │       │
+  │   │  Rust +     │      │  Rust +      │       │
+  │   │  parquet2   │      │  parquet2    │       │
+  │   │  + snappy   │      │  + snappy    │       │
+  │   └──────┬──────┘      └──────┬───────┘       │
+  │          │                    │               │
+  │   ┌──────▼──────┐      ┌──────▼───────┐       │
+  │   │ writer.js   │      │ reader.js    │       │
+  │   │  JS glue    │      │  JS glue     │       │
+  │   │  ~120 LOC   │      │  ~100 LOC    │       │
+  │   └─────────────┘      └──────────────┘       │
+  │                                               │
+  │          Total: 319 KB  ·  337 LOC            │
+  └───────────────────────────────────────────────┘
+```
+
+---
+
+## API
+
+### `writeParquet(schema, data, config?)`
+
+Creates a Parquet file from columnar data.
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `schema` | `Array<{ name: string, type: string }>` | Column definitions |
+| `data` | `Record<string, any[]>` | Columnar data keyed by column name |
+| `config` | `{ compression?: 'snappy' \| 'none' }` | Options (default: `snappy`) |
+| **Returns** | `Promise<Uint8Array>` | Raw Parquet file bytes |
+
+#### Supported Types
+
+| Type | Parquet Physical | Notes |
+|------|-----------------|-------|
+| `string` | `BYTE_ARRAY` (UTF-8) | Default if unrecognized |
+| `int32` | `INT32` | |
+| `int64` | `INT64` | |
+| `float32` | `FLOAT` | Alias: `float` |
+| `float64` | `DOUBLE` | Alias: `double` |
+| `boolean` | `BOOLEAN` | Alias: `bool` |
+| `timestamp` | `INT64` (millis, UTC) | Alias: `timestamp_millis` |
+
+### `readParquet(bytes, maxRows?)`
+
+Reads a Parquet file into columnar data.
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `bytes` | `Uint8Array` | Raw Parquet file bytes |
+| `maxRows` | `number` | Max rows to decode (default: `500`) |
+| **Returns** | `Promise<{ schema, data, numRows }>` | Parsed result |
+
+---
+
+## Examples
+
+### Cloudflare Worker
+
+```js
+import { writeParquet } from 'tiny-parquet/writer';
+
+export default {
+  async fetch(request, env) {
+    const bytes = await writeParquet(
+      [{ name: 'path', type: 'string' }, { name: 'ts', type: 'timestamp' }],
+      { path: [new URL(request.url).pathname], ts: [Date.now()] },
+    );
+
+    await env.R2_BUCKET.put(`logs/${Date.now()}.parquet`, bytes);
+    return new Response('OK');
+  }
+};
+```
+
+### Next.js Edge Route
+
+```js
+import { readParquet } from 'tiny-parquet/reader';
+
+export const runtime = 'edge';
+
+export async function GET() {
+  const res = await fetch('https://data.example.com/events.parquet');
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  const { data, numRows } = await readParquet(bytes);
+
+  return Response.json({ numRows, sample: data });
+}
+```
+
+### Node.js
+
+```js
+import { readFileSync, writeFileSync } from 'node:fs';
+import { writeParquet, readParquet } from 'tiny-parquet';
+
+// Write
+const bytes = await writeParquet(
+  [{ name: 'city', type: 'string' }, { name: 'pop', type: 'int64' }],
+  { city: ['Berlin', 'London', 'Tokyo'], pop: [3748148, 8982000, 13960000] },
+);
+writeFileSync('cities.parquet', bytes);
+
+// Read
+const { schema, data, numRows } = await readParquet(readFileSync('cities.parquet'));
+console.log(`${numRows} rows:`, data);
+```
+
+### Deno
+
+```ts
+import { writeParquet, readParquet } from 'npm:tiny-parquet';
+
+const bytes = await writeParquet(
+  [{ name: 'msg', type: 'string' }],
+  { msg: ['Hello from Deno!'] },
+);
+
+const result = await readParquet(bytes);
+console.log(result.data.msg); // ['Hello from Deno!']
+```
+
+---
+
+## Rust Source
+
+The WASM binaries are compiled from Rust using [`parquet2`](https://crates.io/crates/parquet2) — a lightweight, zero-copy Parquet implementation.
+
+```
+  rust/
+  ├── parquet-reader/       140KB WASM
+  │   ├── Cargo.toml
+  │   └── src/lib.rs        180 lines
+  └── parquet-writer/       179KB WASM
+      ├── Cargo.toml
+      └── src/lib.rs        258 lines
+```
+
+### Build from Source
+
+```bash
+# Writer
+cd parquet-writer
+cargo build --target wasm32-unknown-unknown --release
+wasm-bindgen target/wasm32-unknown-unknown/release/parquet_flake.wasm \
+  --out-dir pkg --target web
+wasm-opt pkg/parquet_flake_bg.wasm -o ../wasm/writer.wasm -Oz
+
+# Reader
+cd ../parquet-reader
+cargo build --target wasm32-unknown-unknown --release
+wasm-bindgen target/wasm32-unknown-unknown/release/parquet_reader.wasm \
+  --out-dir pkg --target web
+wasm-opt pkg/parquet_reader_bg.wasm -o ../wasm/reader.wasm -Oz
+```
+
+---
+
+## Roadmap
+
+- [ ] **Dictionary encoding** — 60-80% size reduction on low-cardinality columns
+- [ ] **Column pruning** — Read only the columns you need
+- [ ] **Row group control** — Multiple row groups per file
+- [ ] **Zstd compression** — Better ratio than Snappy
+
+---
+
+## FAQ
+
+**Q: How does this compare to `parquet-wasm`?**
+A: `parquet-wasm` is a full-featured Parquet library at 3.5MB. `tiny-parquet` is 10x smaller by supporting only flat schemas and essential types — perfect for edge runtimes where size limits apply.
+
+**Q: Can I read files written by DuckDB / Spark / PyArrow?**
+A: Yes — the reader handles standard Parquet files with flat schemas. Nested types (structs, lists, maps) are not supported yet.
+
+**Q: Is Snappy compression supported?**
+A: Yes, on both read and write. It's the default compression.
+
+**Q: What about TypeScript?**
+A: Full type declarations are included (`*.d.ts`). Just import and go.
+
+---
+
+## License
+
+[MIT](./LICENSE) © [nktrchk](https://github.com/nktrchk)
+
+---
+
+<p align="center">
+  <sub>Built by <a href="https://github.com/nktrchk">nktrchk</a> / <a href="https://enrich.sh">enrich.sh</a> — used in production processing millions of events.</sub>
+</p>

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "tiny-parquet",
+  "version": "0.1.0",
+  "description": "Read and write Parquet files in 319KB of WASM. Two functions. Zero dependencies. Runs on Vercel Edge, Cloudflare Workers, Deno, Bun, Node.js, and browsers.",
+  "author": "nktrchk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nktrchk/tiny-parquet.git"
+  },
+  "homepage": "https://github.com/nktrchk/tiny-parquet#readme",
+  "bugs": {
+    "url": "https://github.com/nktrchk/tiny-parquet/issues"
+  },
+  "keywords": [
+    "parquet",
+    "wasm",
+    "webassembly",
+    "edge",
+    "cloudflare-workers",
+    "vercel-edge",
+    "deno",
+    "bun",
+    "serverless",
+    "columnar",
+    "data",
+    "apache-parquet",
+    "rust",
+    "tiny",
+    "parquet-reader",
+    "parquet-writer"
+  ],
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    },
+    "./reader": {
+      "import": "./src/reader.js",
+      "types": "./src/reader.d.ts"
+    },
+    "./writer": {
+      "import": "./src/writer.js",
+      "types": "./src/writer.d.ts"
+    }
+  },
+  "files": [
+    "src/",
+    "wasm/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export { readParquet } from './reader.js';
+export { writeParquet } from './writer.js';

package/src/index.js

@@ -0,0 +1,8 @@
+/**
+ * tiny-parquet — WASM Parquet reader/writer for edge runtimes & browsers
+ *
+ * @module tiny-parquet
+ */
+
+export { readParquet } from './reader.js';
+export { writeParquet } from './writer.js';

package/src/reader.d.ts

@@ -0,0 +1,18 @@
+export interface ColumnSchema {
+    name: string;
+    type: 'string' | 'int32' | 'int64' | 'float32' | 'float64' | 'boolean' | 'timestamp';
+}
+
+export interface ReadResult {
+    schema: ColumnSchema[];
+    data: Record<string, any[]>;
+    numRows: number;
+}
+
+/**
+ * Read a Parquet file and return columnar data.
+ *
+ * @param fileBytes - Raw Parquet file bytes.
+ * @param maxRows - Maximum rows to decode. Default: 500.
+ */
+export function readParquet(fileBytes: Uint8Array, maxRows?: number): Promise<ReadResult>;

package/src/reader.js

@@ -0,0 +1,163 @@
+/**
+ * tiny-parquet/reader — WASM Parquet Reader
+ * Supports: Node.js, Browser, Cloudflare Workers, Vercel Edge, Deno, Bun
+ * WASM size: ~140KB
+ */
+
+let wasm;
+let initPromise = null;
+
+// ── Heap / object table ──────────────────────────────────────────────────────
+const heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+let heap_next = heap.length;
+let stack_pointer = 128;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+    heap[idx] = obj;
+    return idx;
+}
+function addBorrowedObject(obj) {
+    if (stack_pointer === 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+function getObject(idx) { return heap[idx]; }
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+// ── Memory helpers ───────────────────────────────────────────────────────────
+let cachedUint8 = null;
+function getUint8() {
+    if (cachedUint8 === null || cachedUint8.byteLength === 0)
+        cachedUint8 = new Uint8Array(wasm.memory.buffer);
+    return cachedUint8;
+}
+let cachedDV = null;
+function getDV() {
+    if (cachedDV === null || cachedDV.buffer.detached === true ||
+        (cachedDV.buffer.detached === undefined && cachedDV.buffer !== wasm.memory.buffer))
+        cachedDV = new DataView(wasm.memory.buffer);
+    return cachedDV;
+}
+
+const decoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+decoder.decode(); // warm up
+
+function getStringFromWasm(ptr, len) {
+    ptr = ptr >>> 0;
+    return decoder.decode(getUint8().subarray(ptr, ptr + len));
+}
+function getArrayU8(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8().subarray(ptr, ptr + len);
+}
+function isLikeNone(x) { return x === undefined || x === null; }
+function handleError(f, args) {
+    try { return f.apply(this, args); }
+    catch (e) { wasm.__wbindgen_export(addHeapObject(e)); }
+}
+
+// ── WASM imports ─────────────────────────────────────────────────────────────
+function getImports() {
+    const wbg = { __proto__: null };
+
+    wbg.__wbg___wbindgen_throw_be289d5034ed271b = (a, b) => {
+        throw new Error(getStringFromWasm(a, b));
+    };
+    wbg.__wbg_length_32ed9a279acd054c = (a) => getObject(a).length;
+    wbg.__wbg_new_361308b2356cecd0 = () => addHeapObject(new Object());
+    wbg.__wbg_new_3eb36ae241fe6f44 = () => addHeapObject(new Array());
+    wbg.__wbg_prototypesetcall_bdcdcc5842e4d77d = (arg0, arg1, arg2) => {
+        Uint8Array.prototype.set.call(getArrayU8(arg0, arg1), getObject(arg2));
+    };
+    wbg.__wbg_push_8ffdcb2063340ba5 = (a, b) => getObject(a).push(getObject(b));
+    wbg.__wbg_set_6cb8631f80447a67 = (...args) => handleError((a, b, c) => {
+        return Reflect.set(getObject(a), getObject(b), getObject(c));
+    }, args);
+    wbg.__wbindgen_cast_0000000000000001 = (a) => addHeapObject(a);
+    wbg.__wbindgen_cast_0000000000000002 = (a, b) => addHeapObject(getStringFromWasm(a, b));
+    wbg.__wbindgen_object_drop_ref = (a) => takeObject(a);
+
+    return { './parquet_reader_bg.js': wbg };
+}
+
+// ── WASM loader (universal) ──────────────────────────────────────────────────
+async function loadWasm() {
+    const imports = getImports();
+
+    // Node.js
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        const { readFileSync } = await import('node:fs');
+        const { dirname, join } = await import('node:path');
+        const { fileURLToPath } = await import('node:url');
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const bytes = readFileSync(join(__dirname, '..', 'wasm', 'reader.wasm'));
+        const { instance } = await WebAssembly.instantiate(bytes, imports);
+        return instance.exports;
+    }
+
+    // Edge / Browser — resolve relative to this module
+    const wasmUrl = new URL('../wasm/reader.wasm', import.meta.url);
+    const response = await fetch(wasmUrl);
+    const bytes = await response.arrayBuffer();
+    const { instance } = await WebAssembly.instantiate(bytes, imports);
+    return instance.exports;
+}
+
+// ── Init (lazy singleton) ────────────────────────────────────────────────────
+async function init() {
+    if (initPromise) return initPromise;
+    initPromise = loadWasm().then(exports => {
+        wasm = exports;
+        cachedUint8 = null;
+        cachedDV = null;
+        return wasm;
+    });
+    return initPromise;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Read a Parquet file and return columnar data.
+ *
+ * @param {Uint8Array} fileBytes - Raw Parquet file bytes.
+ * @param {number} [maxRows=500] - Maximum rows to decode.
+ * @returns {Promise<{schema: Array<{name: string, type: string}>, data: Record<string, any[]>, numRows: number}>}
+ *
+ * @example
+ * const { schema, data, numRows } = await readParquet(bytes);
+ * // schema: [{ name: 'url', type: 'string' }, ...]
+ * // data: { url: ['https://example.com'], ts: [1708000000] }
+ * // numRows: 1
+ */
+export async function readParquet(fileBytes, maxRows = 500) {
+    await init();
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    try {
+        wasm.readParquet(
+            retptr,
+            addBorrowedObject(fileBytes),
+            isLikeNone(maxRows) ? 0x100000001 : (maxRows) >>> 0,
+        );
+        const r0 = getDV().getInt32(retptr + 0, true);
+        const r1 = getDV().getInt32(retptr + 4, true);
+        const r2 = getDV().getInt32(retptr + 8, true);
+        if (r2) throw takeObject(r1);
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}

package/src/writer.d.ts

@@ -0,0 +1,22 @@
+export interface ColumnSchema {
+    name: string;
+    type: 'string' | 'int32' | 'int64' | 'float32' | 'float64' | 'boolean' | 'timestamp';
+}
+
+export interface WriteConfig {
+    compression?: 'snappy' | 'none';
+}
+
+/**
+ * Write a Parquet file from columnar data.
+ *
+ * @param schema - Column definitions with name and type.
+ * @param data - Columnar data keyed by column name.
+ * @param config - Optional configuration (compression, etc).
+ * @returns The Parquet file as a Uint8Array.
+ */
+export function writeParquet(
+    schema: ColumnSchema[],
+    data: Record<string, any[]>,
+    config?: WriteConfig,
+): Promise<Uint8Array>;

package/src/writer.js

@@ -0,0 +1,210 @@
+/**
+ * tiny-parquet/writer — WASM Parquet Writer
+ * Supports: Node.js, Browser, Cloudflare Workers, Vercel Edge, Deno, Bun
+ * WASM size: ~179KB
+ */
+
+let wasm;
+let initPromise = null;
+
+// ── Heap / object table ──────────────────────────────────────────────────────
+const heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+let heap_next = heap.length;
+let stack_pointer = 128;
+
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function addBorrowedObject(obj) {
+  if (stack_pointer === 1) throw new Error('out of js stack');
+  heap[--stack_pointer] = obj;
+  return stack_pointer;
+}
+function getObject(idx) { return heap[idx]; }
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+
+// ── Memory helpers ───────────────────────────────────────────────────────────
+let cachedUint8 = null;
+function getUint8() {
+  if (cachedUint8 === null || cachedUint8.byteLength === 0)
+    cachedUint8 = new Uint8Array(wasm.memory.buffer);
+  return cachedUint8;
+}
+let cachedDV = null;
+function getDV() {
+  if (cachedDV === null || cachedDV.buffer.detached === true ||
+    (cachedDV.buffer.detached === undefined && cachedDV.buffer !== wasm.memory.buffer))
+    cachedDV = new DataView(wasm.memory.buffer);
+  return cachedDV;
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+decoder.decode(); // warm up
+let WASM_VECTOR_LEN = 0;
+
+function passStringToWasm(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = encoder.encode(arg);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8().subarray(ptr, ptr + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 0x7F) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) arg = arg.slice(offset);
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8().subarray(ptr + offset, ptr + len);
+    const ret = encoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function getStringFromWasm(ptr, len) {
+  return decoder.decode(getUint8().subarray(ptr >>> 0, (ptr >>> 0) + len));
+}
+function getArrayU8(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8().subarray(ptr, ptr + len);
+}
+function isLikeNone(x) { return x === undefined || x === null; }
+function handleError(f, args) {
+  try { return f.apply(this, args); }
+  catch (e) { wasm.__wbindgen_export3(addHeapObject(e)); }
+}
+
+// ── WASM imports ─────────────────────────────────────────────────────────────
+function getImports() {
+  const wbg = { __proto__: null };
+  wbg.__wbg___wbindgen_is_falsy_e623e5b815413d00 = (a) => !getObject(a);
+  wbg.__wbg___wbindgen_number_get_8ff4255516ccad3e = (arg0, arg1) => {
+    const obj = getObject(arg1);
+    const ret = typeof obj === 'number' ? obj : undefined;
+    getDV().setFloat64(arg0 + 8, isLikeNone(ret) ? 0 : ret, true);
+    getDV().setInt32(arg0, !isLikeNone(ret), true);
+  };
+  wbg.__wbg___wbindgen_string_get_72fb696202c56729 = (arg0, arg1) => {
+    const obj = getObject(arg1);
+    const ret = typeof obj === 'string' ? obj : undefined;
+    const ptr1 = isLikeNone(ret) ? 0 : passStringToWasm(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDV().setInt32(arg0 + 4, len1, true);
+    getDV().setInt32(arg0, ptr1, true);
+  };
+  wbg.__wbg___wbindgen_throw_be289d5034ed271b = (a, b) => {
+    throw new Error(getStringFromWasm(a, b));
+  };
+  wbg.__wbg_get_9b94d73e6221f75c = (a, i) => addHeapObject(getObject(a)[i >>> 0]);
+  wbg.__wbg_get_b3ed3ad4be2bc8ac = (...args) => handleError((a, b) => {
+    return addHeapObject(Reflect.get(getObject(a), getObject(b)));
+  }, args);
+  wbg.__wbg_isArray_d314bb98fcf08331 = (a) => Array.isArray(getObject(a));
+  wbg.__wbg_length_32ed9a279acd054c = (a) => getObject(a).length;
+  wbg.__wbg_length_35a7bace40f36eac = (a) => getObject(a).length;
+  wbg.__wbg_new_with_length_a2c39cbe88fd8ff1 = (a) => addHeapObject(new Uint8Array(a >>> 0));
+  wbg.__wbg_set_cc56eefd2dd91957 = (a, b, c) => getObject(a).set(getArrayU8(b, c));
+  wbg.__wbindgen_cast_0000000000000001 = (a, b) => addHeapObject(getStringFromWasm(a, b));
+  wbg.__wbindgen_object_drop_ref = (a) => takeObject(a);
+  return { './parquet_flake_bg.js': wbg };
+}
+
+// ── WASM loader (universal) ──────────────────────────────────────────────────
+async function loadWasm() {
+  const imports = getImports();
+
+  // Node.js
+  if (typeof process !== 'undefined' && process.versions?.node) {
+    const { readFileSync } = await import('node:fs');
+    const { dirname, join } = await import('node:path');
+    const { fileURLToPath } = await import('node:url');
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const bytes = readFileSync(join(__dirname, '..', 'wasm', 'writer.wasm'));
+    const { instance } = await WebAssembly.instantiate(bytes, imports);
+    return instance.exports;
+  }
+
+  // Edge / Browser — resolve relative to this module
+  const wasmUrl = new URL('../wasm/writer.wasm', import.meta.url);
+  const response = await fetch(wasmUrl);
+  const bytes = await response.arrayBuffer();
+  const { instance } = await WebAssembly.instantiate(bytes, imports);
+  return instance.exports;
+}
+
+// ── Init (lazy singleton) ────────────────────────────────────────────────────
+async function init() {
+  if (initPromise) return initPromise;
+  initPromise = loadWasm().then(exports => {
+    wasm = exports;
+    cachedUint8 = null;
+    cachedDV = null;
+    return wasm;
+  });
+  return initPromise;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Write a Parquet file from columnar data.
+ *
+ * @param {Array<{name: string, type: string}>} schema - Column definitions.
+ *   Supported types: 'string', 'int32', 'int64', 'float32', 'float64', 'boolean', 'timestamp'
+ * @param {Record<string, any[]>} data - Columnar data keyed by column name.
+ * @param {Object} [config] - Optional configuration.
+ * @param {string} [config.compression='snappy'] - 'snappy' | 'none'
+ * @returns {Promise<Uint8Array>} The Parquet file bytes.
+ *
+ * @example
+ * const bytes = await writeParquet(
+ *   [{ name: 'url', type: 'string' }, { name: 'ts', type: 'int64' }],
+ *   { url: ['https://example.com'], ts: [1708000000] },
+ *   { compression: 'snappy' }
+ * );
+ */
+export async function writeParquet(schema, data, config = {}) {
+  await init();
+  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+  try {
+    wasm.writeParquet(
+      retptr,
+      addBorrowedObject(schema),
+      addBorrowedObject(data),
+      addBorrowedObject(config),
+    );
+    const r0 = getDV().getInt32(retptr + 0, true);
+    const r1 = getDV().getInt32(retptr + 4, true);
+    const r2 = getDV().getInt32(retptr + 8, true);
+    if (r2) throw takeObject(r1);
+    return takeObject(r0);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    heap[stack_pointer++] = undefined;
+    heap[stack_pointer++] = undefined;
+    heap[stack_pointer++] = undefined;
+  }
+}