fat-json 0.0.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "fat-json",
+  "version": "0.0.1",
+  "main": "./src/index.mjs",
+  "type": "module",
+  "types": "./src/index.d.mts",
+  "author": {
+    "name": "Jonathan Perry for Sequence Media Limited",
+    "email": "sequencemedia@sequencemedia.net",
+    "url": "https://sequencemedia.net"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sequencemedia/fat-json.git"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix"
+  },
+  "devDependencies": {
+    "@sequencemedia/eslint-config-standard": "^0.2.82",
+    "@sequencemedia/eslint-config-typescript": "^0.1.141",
+    "@sequencemedia/sinon-chai": "^0.0.186",
+    "@types/chai": "^5.2.2",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.5.0",
+    "@types/sinon": "^17.0.4",
+    "chai": "^6.0.1",
+    "eslint": "^9.35.0",
+    "globals": "^16.4.0",
+    "mocha": "^11.7.2",
+    "sinon": "^21.0.0"
+  },
+  "imports": {
+    "#fat-json": "./src/index.mjs",
+    "#common": "./src/common/index.mjs",
+    "#transformers": "./src/transformers/index.mjs"
+  }
+}

package/src/common/index.d.mts

@@ -0,0 +1,11 @@
+type ValueType = FatJsonTypes.ValueType
+
+declare const BIG_INT: RegExp
+
+export {
+  BIG_INT
+}
+
+export function iArray (v: ValueType | ValueType[]): v is any[]
+
+export function isObject (v: ValueType | ValueType[]): v is object

package/src/common/index.mjs

@@ -0,0 +1,21 @@
+/**
+ *  @typedef {FatJsonTypes.ValueType} ValueType
+ */
+
+export const BIG_INT = /^(\d+)n$/
+
+/**
+ *  @param {ValueType | ValueType[]} v
+ *  @returns {v is any[]}
+ */
+export function isArray (v) {
+  return Array.isArray(v)
+}
+
+/**
+ *  @param {ValueType | ValueType[]} v
+ *  @returns {v is object}
+ */
+export function isObject (v) {
+  return (v || false) instanceof Object && !Array.isArray(v)
+}

package/src/index.d.mts

@@ -0,0 +1,9 @@
+declare global {
+  namespace FatJsonTypes {
+    export type ArrayLiteralType = unknown[] | never[]
+    export type ObjectLiteralType = Record<PropertyKey, unknown> | Record<PropertyKey, never>
+    export type ValueType = string | number | boolean | null | bigint | ArrayLiteralType | ObjectLiteralType | Buffer | undefined | object
+  }
+}
+
+export {}

package/src/index.mjs

@@ -0,0 +1,151 @@
+/**
+ *  @typedef {FatJsonTypes.ValueType} ValueType
+ */
+import {
+  BIG_INT
+} from './common/index.mjs'
+import getPath from './replacer/index.mjs'
+import genPath from './reviver/index.mjs'
+
+/**
+ *  @param {(key: PropertyKey, value: ValueType, type?: string) => ValueType} replacer
+ *  @returns {(key: PropertyKey, value: ValueType) => ValueType}
+ */
+export function useReplacerWithType (replacer) {
+  /**
+   *  @this {any | any[]}
+   *  @param {PropertyKey} key
+   *  @param {ValueType} value
+   *  @returns {ValueType}
+   */
+  return function withType (key, value) {
+    return replacer.call(this, key, value, typeof value)
+  }
+}
+
+/**
+ *  @param {(key: PropertyKey, value: ValueType, type?: string) => ValueType} reviver
+ *  @returns {(key: PropertyKey, value: ValueType) => ValueType}
+ */
+export function useReviverWithType (reviver) {
+  /**
+   *  @this {any | any[]}
+   *  @param {PropertyKey} key
+   *  @param {ValueType} value
+   *  @returns {ValueType}
+   */
+  // @ts-ignore
+  return function withType (key, value) {
+    return this[key] = reviver.call(this, key, value, typeof value)
+  }
+}
+
+/**
+ *  @param {(key: PropertyKey, value: ValueType, path?: string) => ValueType} replacer
+ *  @returns {(key: PropertyKey, value: ValueType) => ValueType}
+ */
+export function useReplacerWithPath (replacer) {
+  /**
+   *  @this {any | any[]}
+   *  @param {PropertyKey} key
+   *  @param {ValueType} value
+   *  @returns {ValueType}
+   */
+  return function withPath (key, value) {
+    return replacer.call(this, key, value, getPath(key, value, this))
+  }
+}
+
+/**
+ *  @param {(key: PropertyKey, value: ValueType, path?: string) => ValueType} reviver
+ *  @returns {(key: PropertyKey, value: ValueType) => ValueType}
+ */
+export function useReviverWithPath (reviver) {
+  /**
+   *  @this {any | any[]}
+   *
+   *  @param {PropertyKey} key
+   *  @param {ValueType} value
+   *  @returns {ValueType}
+   */
+  // @ts-ignore
+  return function withPath (key, value) {
+    if (!key) {
+      for (const { path, ...args } of genPath(key, value, this)) {
+        if (path !== '$') {
+          const {
+            context,
+            key,
+            value
+          } = args
+          // @ts-ignore
+          context[key] = reviver.call(context, key, value, path)
+        }
+      }
+
+      return this[key] = reviver.call(this, key, value, '$')
+    }
+
+    return value
+  }
+}
+
+/**
+ *  @param {PropertyKey} key
+ *  @param {ValueType} value
+ *  @returns {ValueType}
+ */
+export function replacer (key, value) {
+  if (typeof value === 'bigint') return String(value) + 'n'
+
+  return value
+}
+
+/**
+ *  @param {PropertyKey} key
+ *  @param {ValueType} value
+ *  @returns {ValueType}
+ */
+export function reviver (key, value) {
+  if (typeof value === 'string' && BIG_INT.test(value)) return BigInt (value.replace(BIG_INT, '$1'))
+
+  return value
+}
+
+/**
+ *  @param {Set<PropertyKey>} [set]
+ *  @returns {(key: PropertyKey, value: ValueType) => ValueType}
+ */
+export function getReplacerFor (set = new Set()) {
+  /**
+   *  @param {PropertyKey} key
+   *  @param {ValueType} value
+   *  @returns {ValueType}
+   */
+  return function replacer (key, value) {
+    if (set.has(key)) {
+      if (typeof value === 'bigint') return String(value)
+    }
+
+    return value
+  }
+}
+
+/**
+ *  @param {Set<PropertyKey>} [set]
+ *  @returns {(key: PropertyKey, value: ValueType) => ValueType}
+ */
+export function getReviverFor (set = new Set()) {
+  /**
+   *  @param {PropertyKey} key
+   *  @param {ValueType} value
+   *  @returns {ValueType}
+   */
+  return function reviver (key, value) {
+    if (set.has(key)) {
+      if (typeof value === 'string') return BigInt(value)
+    }
+
+    return value
+  }
+}

package/src/replacer/index.d.mts

@@ -0,0 +1,5 @@
+type ArrayLiteralType = FatJsonTypes.ArrayLiteralType
+type ObjectLiteralType = FatJsonTypes.ObjectLiteralType
+type ValueType = FatJsonTypes.ValueType
+
+export default function getPath (key: PropertyKey, value: ValueType, context: ArrayLiteralType | ObjectLiteralType): string

package/src/replacer/index.mjs

@@ -0,0 +1,39 @@
+import {
+  isArray,
+  isObject
+} from '#common'
+
+const MAP = new WeakMap()
+
+/**
+ *  @param {PropertyKey} key
+ *  @param {unknown} value
+ *  @param {any} context
+ *  @returns {string}
+ */
+export default function getPath (key, value, context) {
+  let valuePath = String(key) || '$'
+
+  if (MAP.has(context)) {
+    const contextPath = MAP.get(context)
+
+    valuePath = (
+      contextPath + (
+        Array.isArray(context)
+          ? `[${key}]`
+          : ( // valuePath.includes(SP) || valuePath.includes(ST)
+              /[ .]/.test(key)
+                ? `.['${key}']`
+                : `.${key}`
+            )
+      )
+    )
+  }
+
+  if (
+    isArray(value) ||
+    isObject(value)
+  ) MAP.set(value, valuePath)
+
+  return valuePath
+}

package/src/reviver/index.d.mts

@@ -0,0 +1,5 @@
+type ArrayLiteralType = FatJsonTypes.ArrayLiteralType
+type ObjectLiteralType = FatJsonTypes.ObjectLiteralType
+type ValueType = FatJsonTypes.ValueType
+
+export default function genPath (key: PropertyKey, value: ValueType, context: ArrayLiteralType | ObjectLiteralType): IterableIterator<{ key: PropertyKey; value: ValueType; path: string; context: ArrayLiteralType | ObjectLiteralType }>

package/src/reviver/index.mjs

@@ -0,0 +1,90 @@
+/**
+ *  @typedef {FatJsonTypes.ArrayLiteralType} ArrayLiteralType
+ *  @typedef {FatJsonTypes.ObjectLiteralType} ObjectLiteralType
+ *  @typedef {FatJsonTypes.ValueType} ValueType
+ *  @typedef {FatJsonTypes.WeakMapType} WeakMapType
+ */
+
+import {
+  isArray,
+  isObject
+} from '#common'
+
+/**
+ *  @param {any[]} context
+ *  @param {string} contextPath
+ *  @returns {IterableIterator<{ key: PropertyKey; value: unknown; path: string; context: any }>}
+ */
+function * genPathForArray (context, contextPath) {
+  for (const [index, value] of context.entries()) {
+    const valuePath = contextPath + `[${index}]`
+
+    if (isArray(value)) yield * genPathForArray(value, valuePath)
+
+    if (isObject(value)) yield * genPathForObject(value, valuePath)
+
+    yield {
+      key: String(index),
+      value,
+      path: valuePath,
+      context
+    }
+  }
+}
+
+/**
+ *  @param {any} context
+ *  @param {string} contextPath
+ *  @returns {IterableIterator<{ key: PropertyKey; value: unknown; path: string; context: any }>}
+ */
+function * genPathForObject (context, contextPath) {
+  for (const [key, value] of Object.entries(context)) {
+    const valuePath = (
+      contextPath + (
+        /[ .]/.test(key)
+          ? `.['${key}']`
+          : `.${key}`
+      )
+    )
+
+    if (isArray(value)) yield * genPathForArray(value, valuePath)
+
+    if (isObject(value)) yield * genPathForObject(value, valuePath)
+
+    yield {
+      key: String(key), // should already be a string but
+      value,
+      path: valuePath,
+      context
+    }
+  }
+}
+
+/**
+ *  @param {PropertyKey} key
+ *  @param {unknown} value
+ *  @param {any | any[]} context
+ *  @returns {IterableIterator<{ key: PropertyKey; value: unknown; path: string; context: any }>}
+ */
+export default function * genPath (key, value, context) {
+  const valuePath = key
+    ? typeof key === 'number'
+      ? `[${key}]`
+      : (
+          /[ .]/.test(key)
+            ? `.['${key}']`
+            : `.${key}`
+        )
+    : '$'
+
+  if (isArray(value)) yield * genPathForArray(value, valuePath)
+
+  if (isObject(value)) yield * genPathForObject(value, valuePath)
+
+  yield {
+    key: String(key),
+    value,
+    path: valuePath,
+    context
+  }
+}

package/src/transformers/index.mjs

@@ -0,0 +1,46 @@
+/**
+ *  @param {BigInt} value
+ *  @returns {string}
+ */
+export function fromBigIntToString (value) {
+  return String(value)
+}
+
+/**
+ *  @param {string} value
+ *  @returns {BigInt}
+ */
+export function fromStringToBigInt (value) {
+  return BigInt(value)
+}
+
+/**
+ * @param {string} b
+ * @returns {number}
+ */
+function toCodePoint (b) {
+  const c = b.codePointAt(0)
+
+  return Number(c)
+}
+
+/**
+ *  ```javascript
+ *  Buffer.from(Uint8Array.fromBase64(base64))
+ *  ```
+ *  @param {string} base64
+ *  @returns {Buffer}
+ */
+export function fromBase64ToBuffer (base64) {
+  const binary = atob(base64) // base64 string to binary string
+  const uint8Array = Uint8Array.from(binary, toCodePoint) // binary string to code point integer
+  return Buffer.from(uint8Array)
+}
+
+/**
+ *  @param {Buffer} buffer
+ *  @returns {string}
+ */
+export function fromBufferToBase64 (buffer) {
+  return buffer.toString('base64')
+}