@happyvertical/json 0.74.8

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2025> <Happy Vertical Corporation>
+
+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,184 @@
+# @happyvertical/json
+
+High-performance JSON parsing and serialization with Rust SIMD acceleration and automatic fallback.
+
+## Features
+
+- **Drop-in replacements** for `JSON.parse()` and `JSON.stringify()`
+- **2-3x faster** parsing with SIMD acceleration on supported platforms
+- **Automatic fallback** to native JavaScript when Rust bindings unavailable
+- **Deep clone** function optimized for the `JSON.parse(JSON.stringify())` pattern
+- **Safe variants** that don't throw on errors
+- **TypeScript first** with full type definitions
+
+## Installation
+
+```bash
+npm install @happyvertical/json
+# or
+pnpm add @happyvertical/json
+```
+
+## Quick Start
+
+```typescript
+import { parse, stringify, clone } from '@happyvertical/json';
+
+// Drop-in replacements for JSON.parse/stringify
+const data = parse<User>('{"name": "Alice", "age": 30}');
+const json = stringify(data);
+
+// Deep clone (optimized)
+const copy = clone(data);
+copy.age = 31; // Original unchanged
+```
+
+## API
+
+### Drop-in Replacements
+
+```typescript
+// Parse JSON string to value
+function parse<T = unknown>(text: string, reviver?: Reviver): T;
+
+// Stringify value to JSON
+function stringify(value: unknown, replacer?: Replacer, space?: number | string): string;
+
+// Deep clone via JSON round-trip (optimized)
+function clone<T>(value: T): T;
+```
+
+### Safe Variants (Non-throwing)
+
+```typescript
+import { safeParse, safeStringify } from '@happyvertical/json';
+
+// Returns { success: true, value: T } or { success: false, error: ParseError }
+const result = safeParse<User>(maybeInvalidJson);
+if (result.success) {
+  console.log(result.value.name);
+} else {
+  console.error(`Line ${result.error.line}: ${result.error.message}`);
+}
+
+// Returns { success: true, value: string } or { success: false, error: StringifyError }
+const stringifyResult = safeStringify(data);
+```
+
+### Validation
+
+```typescript
+import { isValid } from '@happyvertical/json';
+
+if (isValid(userInput)) {
+  const data = parse(userInput);
+}
+```
+
+### Adapter Control
+
+```typescript
+import { JSONFactory, getAdapterInfo, isSIMDAvailable } from '@happyvertical/json';
+
+// Check if SIMD acceleration is available
+console.log(isSIMDAvailable()); // true on supported platforms
+
+// Get detailed adapter info
+const info = getAdapterInfo();
+console.log(info.name);        // 'sonic' or 'native'
+console.log(info.simdEnabled); // true if using SIMD
+
+// Create adapter with specific options
+const json = JSONFactory.create({
+  adapter: 'sonic',    // 'sonic' | 'native' | 'auto'
+  fallback: true,      // Fall back to native if sonic unavailable
+});
+
+// Use adapter directly
+const data = json.parse('{"key": "value"}');
+const text = json.stringify(data);
+```
+
+## Performance
+
+On a 680KB manifest file (typical SMRT manifest):
+
+| Operation | Native JSON | @happyvertical/json | Speedup |
+|-----------|-------------|---------------------|---------|
+| Parse | ~50ms | ~18ms | **2.8x** |
+| Stringify | ~45ms | ~16ms | **2.8x** |
+| Clone | ~95ms | ~34ms | **2.8x** |
+
+Results measured on Apple M2 Pro. Performance varies by platform and data structure.
+
+## Platform Support
+
+SIMD-accelerated parsing is available on:
+
+- ✅ macOS ARM64 (Apple Silicon)
+- ✅ macOS x64 (Intel)
+- ✅ Linux x64 (GNU)
+- ✅ Linux ARM64 (GNU)
+- ✅ Linux x64 (musl)
+- ✅ Linux ARM64 (musl)
+- ✅ Windows x64
+
+When the native binary isn't available, the package automatically falls back to JavaScript's built-in `JSON` object with zero overhead.
+
+## How It Works
+
+This package uses [sonic-rs](https://github.com/cloudwego/sonic-rs) - a Rust JSON library that uses SIMD instructions (AVX2, SSE4.2, NEON) for vectorized parsing and serialization.
+
+The adapter pattern allows:
+1. Automatic selection of the fastest available implementation
+2. Graceful fallback when native bindings can't be loaded
+3. Consistent API regardless of the underlying implementation
+
+## TypeScript Support
+
+Full TypeScript definitions included:
+
+```typescript
+interface User {
+  name: string;
+  age: number;
+}
+
+// Type-safe parsing
+const user = parse<User>('{"name": "Alice", "age": 30}');
+user.name; // string
+user.age;  // number
+
+// Safe variant preserves types
+const result = safeParse<User>(json);
+if (result.success) {
+  result.value.name; // string
+}
+```
+
+## Reviver and Replacer
+
+Standard reviver and replacer functions work as expected:
+
+```typescript
+// Reviver for custom transformations
+const data = parse<{ date: Date }>(
+  '{"date": "2024-01-15"}',
+  (key, value) => (key === 'date' ? new Date(value) : value)
+);
+console.log(data.date instanceof Date); // true
+
+// Replacer for filtering
+const json = stringify(data, ['name', 'email']); // Only include these keys
+
+// Pretty printing
+const pretty = stringify(data, null, 2);
+```
+
+## Environment Variables
+
+- `HAPPYVERTICAL_JSON_ADAPTER`: Force adapter selection ('sonic' | 'native')
+
+## License
+
+MIT

package/dist/adapters/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * JSON Adapters
+ *
+ * Export all adapter implementations
+ */
+export { NativeAdapter, nativeAdapter } from './native.js';
+export { createSonicAdapter, isSonicAvailable, SonicAdapter } from './sonic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,9 @@
+import { N, S, c, i, n } from "../chunks/sonic-BVfKq74R.js";
+export {
+  N as NativeAdapter,
+  S as SonicAdapter,
+  c as createSonicAdapter,
+  i as isSonicAvailable,
+  n as nativeAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/adapters/native.d.ts

@@ -0,0 +1,45 @@
+import { AdapterInfo, JSONAdapter, ParseError, Replacer, Result, Reviver, StringifyError } from '../types.js';
+/**
+ * Native JavaScript JSON adapter implementation
+ *
+ * Provides the same interface as the Rust adapter but uses
+ * the built-in JSON object. Useful as a fallback and for
+ * environments where native bindings can't be loaded.
+ */
+export declare class NativeAdapter implements JSONAdapter {
+    readonly name: "native";
+    readonly isNative = true;
+    /**
+     * Parse a JSON string using native JSON.parse
+     */
+    parse<T = unknown>(text: string, reviver?: Reviver): T;
+    /**
+     * Stringify a value using native JSON.stringify
+     */
+    stringify(value: unknown, replacer?: Replacer, space?: number | string): string;
+    /**
+     * Deep clone via JSON round-trip
+     */
+    clone<T>(value: T): T;
+    /**
+     * Parse without throwing
+     */
+    safeParse<T = unknown>(text: string): Result<T, ParseError>;
+    /**
+     * Stringify without throwing
+     */
+    safeStringify(value: unknown): Result<string, StringifyError>;
+    /**
+     * Validate JSON string
+     */
+    isValid(text: string): boolean;
+    /**
+     * Get adapter information
+     */
+    getInfo(): AdapterInfo;
+}
+/**
+ * Singleton instance of the native adapter
+ */
+export declare const nativeAdapter: NativeAdapter;
+//# sourceMappingURL=native.d.ts.map

package/dist/adapters/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../src/adapters/native.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,QAAQ,EACR,MAAM,EACN,OAAO,EACP,cAAc,EACf,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,qBAAa,aAAc,YAAW,WAAW;IAC/C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAClC,QAAQ,CAAC,QAAQ,QAAQ;IAEzB;;OAEG;IACH,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC;IAItD;;OAEG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,QAAQ,EACnB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM;IAoBT;;OAEG;IACH,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAIrB;;OAEG;IACH,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC;IAiC3D;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;IAmB7D;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS9B;;OAEG;IACH,OAAO,IAAI,WAAW;CAQvB;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,eAAsB,CAAC"}

package/dist/adapters/sonic.d.ts

@@ -0,0 +1,63 @@
+import { AdapterInfo, JSONAdapter, NativeBindings, ParseError, Replacer, Result, Reviver, StringifyError } from '../types.js';
+/**
+ * Sonic (Rust SIMD) JSON adapter implementation
+ *
+ * Uses sonic-rs for SIMD-accelerated parsing and serialization.
+ * On supported platforms, this can be 2-3x faster than native JSON.
+ */
+export declare class SonicAdapter implements JSONAdapter {
+    readonly name: "sonic";
+    readonly isNative = false;
+    private native;
+    constructor(native: NativeBindings);
+    /**
+     * Parse a JSON string using sonic-rs
+     */
+    parse<T = unknown>(text: string, reviver?: Reviver): T;
+    /**
+     * Stringify a value using sonic-rs
+     */
+    stringify(value: unknown, replacer?: Replacer, space?: number | string): string;
+    /**
+     * Deep clone via sonic-rs round-trip
+     */
+    clone<T>(value: T): T;
+    /**
+     * Parse without throwing
+     */
+    safeParse<T = unknown>(text: string): Result<T, ParseError>;
+    /**
+     * Stringify without throwing
+     */
+    safeStringify(value: unknown): Result<string, StringifyError>;
+    /**
+     * Validate JSON string using sonic-rs
+     */
+    isValid(text: string): boolean;
+    /**
+     * Get adapter information
+     */
+    getInfo(): AdapterInfo;
+    /**
+     * Apply reviver function to parsed value
+     * @internal
+     */
+    private applyReviver;
+    private walkReviver;
+    /**
+     * Apply replacer to value before stringifying
+     * @internal
+     */
+    private applyReplacer;
+    private walkReplacer;
+}
+/**
+ * Try to create a SonicAdapter instance
+ * Returns null if native bindings are not available
+ */
+export declare function createSonicAdapter(): SonicAdapter | null;
+/**
+ * Check if sonic (Rust) adapter is available on this platform
+ */
+export declare function isSonicAvailable(): boolean;
+//# sourceMappingURL=sonic.d.ts.map

package/dist/adapters/sonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sonic.d.ts","sourceRoot":"","sources":["../../src/adapters/sonic.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,UAAU,EACV,QAAQ,EACR,MAAM,EACN,OAAO,EACP,cAAc,EACf,MAAM,aAAa,CAAC;AAiCrB;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,WAAW;IAC9C,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IACjC,QAAQ,CAAC,QAAQ,SAAS;IAE1B,OAAO,CAAC,MAAM,CAAiB;gBAEnB,MAAM,EAAE,cAAc;IAIlC;;OAEG;IACH,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC;IAWtD;;OAEG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,QAAQ,EACnB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM;IAmBT;;OAEG;IACH,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAIrB;;OAEG;IACH,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC;IAmB3D;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;IAa7D;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9B;;OAEG;IACH,OAAO,IAAI,WAAW;IAUtB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,WAAW;IAyCnB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAwBrB,OAAO,CAAC,YAAY;CAsCrB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,GAAG,IAAI,CAMxD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}

package/dist/chunks/sonic-BVfKq74R.js

@@ -0,0 +1,332 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+class NativeAdapter {
+  name = "native";
+  isNative = true;
+  /**
+   * Parse a JSON string using native JSON.parse
+   */
+  parse(text, reviver) {
+    return JSON.parse(text, reviver);
+  }
+  /**
+   * Stringify a value using native JSON.stringify
+   */
+  stringify(value, replacer, space) {
+    let result;
+    if (typeof replacer === "function") {
+      result = JSON.stringify(value, replacer, space);
+    } else if (Array.isArray(replacer)) {
+      result = JSON.stringify(value, replacer, space);
+    } else {
+      result = JSON.stringify(value, null, space);
+    }
+    if (result === void 0) {
+      throw new TypeError("Unable to stringify value");
+    }
+    return result;
+  }
+  /**
+   * Deep clone via JSON round-trip
+   */
+  clone(value) {
+    return JSON.parse(JSON.stringify(value));
+  }
+  /**
+   * Parse without throwing
+   */
+  safeParse(text) {
+    try {
+      const value = JSON.parse(text);
+      return { success: true, value };
+    } catch (e) {
+      const error = e;
+      const parseError = {
+        message: error.message
+      };
+      const posMatch = error.message.match(/position (\d+)/i);
+      if (posMatch) {
+        const position = parseInt(posMatch[1], 10);
+        let line = 1;
+        let column = 1;
+        for (let i = 0; i < position && i < text.length; i++) {
+          if (text[i] === "\n") {
+            line++;
+            column = 1;
+          } else {
+            column++;
+          }
+        }
+        parseError.line = line;
+        parseError.column = column;
+      }
+      return { success: false, error: parseError };
+    }
+  }
+  /**
+   * Stringify without throwing
+   */
+  safeStringify(value) {
+    try {
+      const result = JSON.stringify(value);
+      if (result === void 0) {
+        return {
+          success: false,
+          error: { message: "Unable to stringify value" }
+        };
+      }
+      return { success: true, value: result };
+    } catch (e) {
+      const error = e;
+      return {
+        success: false,
+        error: { message: error.message }
+      };
+    }
+  }
+  /**
+   * Validate JSON string
+   */
+  isValid(text) {
+    try {
+      JSON.parse(text);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get adapter information
+   */
+  getInfo() {
+    return {
+      name: "native",
+      isNative: true,
+      version: typeof process !== "undefined" ? process.version : "unknown",
+      simdEnabled: false
+    };
+  }
+}
+const nativeAdapter = new NativeAdapter();
+const require$1 = createRequire(import.meta.url);
+function tryLoadNative() {
+  const Filename = fileURLToPath(import.meta.url);
+  const Dirname = dirname(Filename);
+  const paths = [
+    join(Dirname, "..", "..", "json-native.node"),
+    // dist/../json-native.node
+    join(Dirname, "..", "json-native.node"),
+    // dist/json-native.node
+    join(Dirname, "json-native.node")
+    // In same directory
+  ];
+  for (const modulePath of paths) {
+    try {
+      const native = require$1(modulePath);
+      return native;
+    } catch {
+    }
+  }
+  return null;
+}
+class SonicAdapter {
+  name = "sonic";
+  isNative = false;
+  native;
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Parse a JSON string using sonic-rs
+   */
+  parse(text, reviver) {
+    const result = this.native.parse(text);
+    if (reviver) {
+      return this.applyReviver(result, reviver);
+    }
+    return result;
+  }
+  /**
+   * Stringify a value using sonic-rs
+   */
+  stringify(value, replacer, space) {
+    let processedValue = value;
+    if (replacer) {
+      processedValue = this.applyReplacer(value, replacer);
+    }
+    if (space !== void 0 && space !== null && space !== 0 && space !== "") {
+      const indent = typeof space === "string" ? Math.min(space.length, 10) : Math.min(Math.max(0, space), 10);
+      return this.native.stringifyPretty(processedValue, indent);
+    }
+    return this.native.stringify(processedValue);
+  }
+  /**
+   * Deep clone via sonic-rs round-trip
+   */
+  clone(value) {
+    return this.native.clone(value);
+  }
+  /**
+   * Parse without throwing
+   */
+  safeParse(text) {
+    const result = this.native.parseSafe(text);
+    if (result.success) {
+      return { success: true, value: result.value };
+    }
+    const parseError = {
+      message: result.error || "Unknown parse error"
+    };
+    if (result.errorPosition) {
+      parseError.line = result.errorPosition.line;
+      parseError.column = result.errorPosition.column;
+    }
+    return { success: false, error: parseError };
+  }
+  /**
+   * Stringify without throwing
+   */
+  safeStringify(value) {
+    const result = this.native.stringifySafe(value);
+    if (result.success && result.value !== void 0) {
+      return { success: true, value: result.value };
+    }
+    return {
+      success: false,
+      error: { message: result.error || "Unknown stringify error" }
+    };
+  }
+  /**
+   * Validate JSON string using sonic-rs
+   */
+  isValid(text) {
+    return this.native.isValid(text);
+  }
+  /**
+   * Get adapter information
+   */
+  getInfo() {
+    const info = this.native.getAdapterInfo();
+    return {
+      name: "sonic",
+      isNative: false,
+      version: info.version,
+      simdEnabled: info.simdEnabled
+    };
+  }
+  /**
+   * Apply reviver function to parsed value
+   * @internal
+   */
+  applyReviver(value, reviver) {
+    return this.walkReviver({ "": value }, "", reviver);
+  }
+  walkReviver(holder, key, reviver) {
+    const value = holder[key];
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+          const newValue = this.walkReviver(
+            value,
+            String(i),
+            reviver
+          );
+          if (newValue === void 0) {
+            value.splice(i, 1);
+            i--;
+          } else {
+            value[i] = newValue;
+          }
+        }
+      } else {
+        for (const k of Object.keys(value)) {
+          const newValue = this.walkReviver(
+            value,
+            k,
+            reviver
+          );
+          if (newValue === void 0) {
+            delete value[k];
+          } else {
+            value[k] = newValue;
+          }
+        }
+      }
+    }
+    return reviver.call(holder, key, value);
+  }
+  /**
+   * Apply replacer to value before stringifying
+   * @internal
+   */
+  applyReplacer(value, replacer) {
+    if (Array.isArray(replacer)) {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const filtered = {};
+        for (const key of replacer) {
+          const k = String(key);
+          if (k in value) {
+            filtered[k] = value[k];
+          }
+        }
+        return filtered;
+      }
+      return value;
+    }
+    if (typeof replacer === "function") {
+      return this.walkReplacer({ "": value }, "", replacer);
+    }
+    return value;
+  }
+  walkReplacer(holder, key, replacer) {
+    let value = holder[key];
+    value = replacer.call(holder, key, value);
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        const arr = [];
+        for (let i = 0; i < value.length; i++) {
+          const item = this.walkReplacer(
+            value,
+            String(i),
+            replacer
+          );
+          arr.push(item);
+        }
+        return arr;
+      } else {
+        const obj = {};
+        for (const k of Object.keys(value)) {
+          const item = this.walkReplacer(
+            value,
+            k,
+            replacer
+          );
+          if (item !== void 0) {
+            obj[k] = item;
+          }
+        }
+        return obj;
+      }
+    }
+    return value;
+  }
+}
+function createSonicAdapter() {
+  const native = tryLoadNative();
+  if (native) {
+    return new SonicAdapter(native);
+  }
+  return null;
+}
+function isSonicAvailable() {
+  return tryLoadNative() !== null;
+}
+export {
+  NativeAdapter as N,
+  SonicAdapter as S,
+  createSonicAdapter as c,
+  isSonicAvailable as i,
+  nativeAdapter as n
+};
+//# sourceMappingURL=sonic-BVfKq74R.js.map