feat: 🎸 Add UNSAFE methods

Author: haozi

README.md

@@ -49,17 +49,19 @@ const restored = jsonWeb3.parse(text)
     headers: Map(1) {...},
     re: /([^\s]+)/g,
     url: URL(...),
-    fn: { "__@json.function__": "function echo(arg) { return arg }" }
+    fn: undefined
   }
 */
 
-const restoredUnsafe = jsonWeb3.parse_UNSAFE(text)
+const textUnsafe = jsonWeb3.stringify_UNSAFE(payload)
+const restoredUnsafe = jsonWeb3.parse_UNSAFE(textUnsafe)
 // restoredUnsafe.fn is a callable function
 ```
 
 ## API (Fully compatible with native globalThis.JSON)
 
 - `stringify(value, replacer?, space?)`
+- `stringify_UNSAFE(value, replacer?, space?)` (serializes `Function` payloads)
 - `parse(text, reviver?)`
 - `parse_UNSAFE(text, reviver?)` (revives `Function` payloads via `new Function(...)`)
 
@@ -71,7 +73,7 @@ const restoredUnsafe = jsonWeb3.parse_UNSAFE(text)
 - `Map` values are encoded as `{"__@json.map__":[[k,v],...]}` and `Set` values as `{"__@json.set__":[...]}`.
 - `RegExp` values are encoded as `{"__@json.regexp__":{"source":"...","flags":"..."}}`.
 - `URL` values are encoded as `{"__@json.url__":"..."}`.
-- `Function` values are encoded as `{"__@json.function__":"<source>"}` and are only revived by `parse_UNSAFE` using `new Function(...)` (only do this with trusted input).
+- `Function` values are encoded as `{"__@json.function__":"<source>"}` by `stringify_UNSAFE` and are only revived by `parse_UNSAFE` using `new Function(...)` (only do this with trusted input).
 - `ArrayBuffer`, Node `Buffer` JSON shapes, and typed arrays are encoded as `{"__@json.typedarray__":{"type":"<Name>","bytes":"0x..."}}` and decoded back to the original typed array (`Uint8Array`, `Uint8ClampedArray`, `Uint16Array`, `Uint32Array`, `Int8Array`, `Int16Array`, `Int32Array`, `Float32Array`, `Float64Array`, `BigInt64Array`, `BigUint64Array`).
 
 Compared to libraries that require eval-based parsing (for example, `serialize-javascript`), this approach is generally safer and more efficient.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-web3",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "BigInt-safe JSON serialization and deserialization for Web3 use cases.",
   "keywords": [
     "json",

src/index.ts

@@ -58,6 +58,22 @@ export const stringify = (value: any, replacer: Replacer = null, space?: string
     space,
   )
 
+export const stringify_UNSAFE = (
+  value: any,
+  replacer: Replacer = null,
+  space?: string | number,
+): string =>
+  RAW_JSON.stringify(
+    value,
+    function replacerFn(key, v) {
+      const holderValue = this && key in Object(this) ? (this as any)[key] : v
+      const candidate = isDate(holderValue) || isURL(holderValue) ? holderValue : v
+      const replaced = applyReplacer(this, key, candidate, replacer)
+      return toSerializable(replaced, { allowFunction: true })
+    },
+    space,
+  )
+
 export const parse = <T = any>(text: string, reviver: Reviver = null): T =>
   RAW_JSON.parse(text, (key, v) => {
     const decoded = fromSerializable(v)
@@ -72,6 +88,7 @@ export const parse_UNSAFE = <T = any>(text: string, reviver: Reviver = null): T
 
 export default {
   stringify,
+  stringify_UNSAFE,
   parse,
   parse_UNSAFE,
 }

src/utils.ts

@@ -90,7 +90,7 @@ export const fromHex = (hex: string): Uint8Array => {
   return out
 }
 
-export const toSerializable = (value: any): any => {
+export const toSerializable = (value: any, options: { allowFunction?: boolean } = {}): any => {
   if (isBigInt(value)) {
     return { [BIGINT_TAG]: value.toString() }
   }
@@ -120,6 +120,9 @@ export const toSerializable = (value: any): any => {
   }
 
   if (isFunction(value)) {
+    if (!options.allowFunction) {
+      return value
+    }
     return { [FUNCTION_TAG]: value.toString() }
   }
 

test/index.test.ts

@@ -1,6 +1,6 @@
 import { Script, createContext } from 'node:vm'
 import { describe, expect, it } from 'vitest'
-import jsonWeb3, { parse, parse_UNSAFE, stringify } from '../src/index'
+import jsonWeb3, { parse, parse_UNSAFE, stringify, stringify_UNSAFE } from '../src/index'
 import { getTypedArrayName, isBuffer } from '../src/utils'
 
 describe('json-web3', () => {
@@ -176,7 +176,7 @@ describe('json-web3', () => {
     expect(output.d.getTime()).toBe(d.getTime())
   })
 
-  it('round-trips Map, Set, RegExp, URL, and Function with parse_UNSAFE', () => {
+  it('round-trips Map, Set, RegExp, URL, and Function with stringify_UNSAFE + parse_UNSAFE', () => {
     function echo(arg: string) {
       return arg
     }
@@ -187,7 +187,7 @@ describe('json-web3', () => {
       url: new URL('https://example.com/'),
       fn: echo,
     }
-    const text = stringify(input)
+    const text = stringify_UNSAFE(input)
     const output = parse_UNSAFE(text)
 
     expect(output.map).toBeInstanceOf(Map)
@@ -236,7 +236,7 @@ describe('json-web3', () => {
       url: new URL('https://example.com/'),
       fn: (arg: string) => arg,
     }
-    const text = stringify(input, ['d', 'inf', 'map', 'set', 're', 'url', 'fn'])
+    const text = stringify_UNSAFE(input, ['d', 'inf', 'map', 'set', 're', 'url', 'fn'])
     const output = parse_UNSAFE(text)
 
     expect(output.d).toBeInstanceOf(Date)
@@ -415,10 +415,10 @@ describe('json-web3', () => {
     expect(output.bytes[256]).toBe(0)
   })
 
-  it('symbol is dropped while function is preserved with parse_UNSAFE', () => {
+  it('symbol is dropped while function is preserved with stringify_UNSAFE + parse_UNSAFE', () => {
     const sym = Symbol('x')
     const input: any = { a: 1, s: sym, f: (arg: string) => arg }
-    const text = stringify(input)
+    const text = stringify_UNSAFE(input)
     const output = parse_UNSAFE(text)
     expect(output.a).toBe(1)
     expect(output.s).toBeUndefined()
@@ -428,12 +428,19 @@ describe('json-web3', () => {
 
   it('parse keeps function payloads as tagged objects', () => {
     const input = { fn: (arg: string) => arg }
-    const text = stringify(input)
+    const text = stringify_UNSAFE(input)
     const output = parse(text)
 
     expect(output.fn).toEqual({ '__@json.function__': expect.any(String) })
   })
 
+  it('stringify drops function by default', () => {
+    const input = { fn: (arg: string) => arg }
+    const text = stringify(input)
+    const output = parse(text)
+    expect(output).toEqual({})
+  })
+
   it('BigInt in array with replacer array filtering works as expected', () => {
     const input = { list: [1n, 2n], other: 3n }
     const text = stringify(input, ['list'])

test/test.ts

@@ -17,5 +17,5 @@ const payload = {
 
 const text = jsonWeb3.stringify(payload, null, 2)
 console.log('text', text)
-const restored = jsonWeb3.parse_UNSAFE(text)
+const restored = jsonWeb3.parse(text)
 console.log('restored', restored)