@brillout/json-serializer 0.5.8 → 0.5.10

package/dist/cjs/parse.d.ts

@@ -1,2 +1,4 @@
 export { parse };
+export { parseTransform };
 declare function parse(str: string): unknown;
+declare function parseTransform(value: unknown): unknown;

package/dist/cjs/parse.js

@@ -1,25 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
+exports.parseTransform = exports.parse = void 0;
 const types_1 = require("./types");
 function parse(str) {
     // We don't use the reviver option in `JSON.parse(str, reviver)` because it doesn't support `undefined` values
     const value = JSON.parse(str);
-    return modifier(value);
+    return parseTransform(value);
 }
 exports.parse = parse;
-function modifier(value) {
+function parseTransform(value) {
     if (typeof value === 'string') {
         return reviver(value);
     }
-    if (typeof value === 'object' && value !== null) {
+    if (
+    // Also matches arrays
+    typeof value === 'object' &&
+        value !== null) {
         Object.entries(value).forEach(([key, val]) => {
             ;
-            value[key] = modifier(val);
+            value[key] = parseTransform(val);
         });
     }
     return value;
 }
+exports.parseTransform = parseTransform;
 function reviver(value) {
     for (const { match, deserialize } of types_1.types) {
         if (match(value)) {

package/dist/cjs/stringify.d.ts

@@ -1,10 +1,14 @@
 export { stringify };
 export { isJsonSerializerError };
-declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys }?: {
+import { type Iterable } from './utils/replacerWithPath';
+declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, }?: {
     forbidReactElements?: boolean;
     space?: number;
     valueName?: string;
     sortObjectKeys?: boolean;
+    replacer?: (this: Iterable, key: string, value: unknown, path: string) => void | {
+        replacement: unknown;
+    };
 }): string;
 type JsonSerializerError = Error & {
     messageCore: string;

package/dist/cjs/stringify.js

@@ -6,7 +6,7 @@ const isReactElement_1 = require("./utils/isReactElement");
 const isCallable_1 = require("./utils/isCallable");
 const isObject_1 = require("./utils/isObject");
 const replacerWithPath_1 = require("./utils/replacerWithPath");
-function stringify(value, { forbidReactElements, space, valueName, sortObjectKeys } = {}) {
+function stringify(value, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, } = {}) {
     // The only error `JSON.stringify()` can throw is `TypeError "cyclic object value"`.
     // - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#exceptions
     // - This means we have total of 3 possible errors while serializing:
@@ -16,6 +16,11 @@ function stringify(value, { forbidReactElements, space, valueName, sortObjectKey
     const serializer = (val) => JSON.stringify(val, (0, replacerWithPath_1.replacerWithPath)(replacer, !valueName), space);
     return serializer(value);
     function replacer(key, value, path) {
+        {
+            const ret = replacerUserProvided === null || replacerUserProvided === void 0 ? void 0 : replacerUserProvided.call(this, key, value, path);
+            if (ret)
+                return ret.replacement;
+        }
         if (forbidReactElements && (0, isReactElement_1.isReactElement)(value)) {
             throw genErr(genErrMsg('React element', path, valueName));
         }
@@ -48,7 +53,7 @@ function genErr(errMsg) {
     const err = new Error(`[@brillout/json-serializer](https://github.com/brillout/json-serializer) ${errMsg}.`);
     Object.assign(err, {
         messageCore: errMsg,
-        [stamp]: true
+        [stamp]: true,
     });
     return err;
 }

package/dist/cjs/types.d.ts

@@ -1,8 +1,8 @@
 export { types };
-declare const types: readonly [Type<undefined, unknown>, Type<number, unknown>, Type<number, unknown>, Type<number, unknown>, Type<Date, any>, Type<BigInt, any>, Type<RegExp, any>, Type<Map<any, any>, any[]>, Type<Set<unknown>, unknown[]>, Type<string, any>];
-type Type<T, IntermediateType> = {
-    is: (val: unknown) => asserts val is T;
+declare const types: readonly Type<any, any>[];
+type Type<ValueType, IntermediateType> = {
+    is: (val: unknown) => asserts val is ValueType;
     match: (str: string) => boolean;
-    serialize: (val: T, serializer: (val: IntermediateType) => string) => string;
-    deserialize: (str: string, deserializer: (str: string) => IntermediateType) => T;
+    serialize: (val: ValueType, serializer: (val: IntermediateType) => string) => string;
+    deserialize: (str: string, deserializer: (str: string) => IntermediateType) => ValueType;
 };

package/dist/cjs/types.js

@@ -6,31 +6,31 @@ const types = [
         is: (val) => val === undefined,
         match: (str) => str === '!undefined',
         serialize: () => '!undefined',
-        deserialize: () => undefined
+        deserialize: () => undefined,
     }),
     ts({
         is: (val) => val === Infinity,
         match: (str) => str === '!Infinity',
         serialize: () => '!Infinity',
-        deserialize: () => Infinity
+        deserialize: () => Infinity,
     }),
     ts({
         is: (val) => val === -Infinity,
         match: (str) => str === '!-Infinity',
         serialize: () => '!-Infinity',
-        deserialize: () => -Infinity
+        deserialize: () => -Infinity,
     }),
     ts({
         is: (val) => typeof val === 'number' && isNaN(val),
         match: (str) => str === '!NaN',
         serialize: () => '!NaN',
-        deserialize: () => NaN
+        deserialize: () => NaN,
     }),
     ts({
         is: (val) => val instanceof Date,
         match: (str) => str.startsWith('!Date:'),
         serialize: (val) => '!Date:' + val.toISOString(),
-        deserialize: (str) => new Date(str.slice('!Date:'.length))
+        deserialize: (str) => new Date(str.slice('!Date:'.length)),
     }),
     ts({
         is: (val) => typeof val === 'bigint',
@@ -41,7 +41,7 @@ const types = [
                 throw new Error('Your JavaScript environement does not support BigInt. Consider adding a polyfill.');
             }
             return BigInt(str.slice('!BigInt:'.length));
-        }
+        },
     }),
     ts({
         is: (val) => val instanceof RegExp,
@@ -54,27 +54,27 @@ const types = [
             const pattern = args[1];
             const flags = args[2];
             return new RegExp(pattern, flags);
-        }
+        },
     }),
     ts({
         is: (val) => val instanceof Map,
         match: (str) => str.startsWith('!Map:'),
         serialize: (val, serializer) => '!Map:' + serializer(Array.from(val.entries())),
-        deserialize: (str, deserializer) => new Map(deserializer(str.slice('!Map:'.length)))
+        deserialize: (str, deserializer) => new Map(deserializer(str.slice('!Map:'.length))),
     }),
     ts({
         is: (val) => val instanceof Set,
         match: (str) => str.startsWith('!Set:'),
         serialize: (val, serializer) => '!Set:' + serializer(Array.from(val.values())),
-        deserialize: (str, deserializer) => new Set(deserializer(str.slice('!Set:'.length)))
+        deserialize: (str, deserializer) => new Set(deserializer(str.slice('!Set:'.length))),
     }),
     // Avoid collisions with the special strings defined above
     ts({
         is: (val) => typeof val === 'string' && val.startsWith('!'),
         match: (str) => str.startsWith('!'),
         serialize: (val) => '!' + val,
-        deserialize: (str) => str.slice(1)
-    })
+        deserialize: (str) => str.slice(1),
+    }),
 ];
 exports.types = types;
 // Type check

package/dist/cjs/utils/replacerWithPath.d.ts

@@ -1,3 +1,5 @@
 export { replacerWithPath };
+export type { Iterable };
 type Iterable = Record<string, unknown>;
-declare function replacerWithPath(replacer: (this: Iterable, key: string, value: unknown, path: string) => unknown, canBeFirstKey: boolean): (this: Iterable, key: string, value: unknown) => unknown;
+type Replacer = (this: Iterable, key: string, value: unknown, path: string) => unknown;
+declare function replacerWithPath(replacer: Replacer, canBeFirstKey: boolean): (this: Iterable, key: string, value: unknown) => unknown;

package/dist/esm/parse.d.ts

@@ -1,2 +1,4 @@
 export { parse };
+export { parseTransform };
 declare function parse(str: string): unknown;
+declare function parseTransform(value: unknown): unknown;

package/dist/esm/parse.js

@@ -1,18 +1,22 @@
 export { parse };
+export { parseTransform };
 import { types } from './types';
 function parse(str) {
     // We don't use the reviver option in `JSON.parse(str, reviver)` because it doesn't support `undefined` values
     const value = JSON.parse(str);
-    return modifier(value);
+    return parseTransform(value);
 }
-function modifier(value) {
+function parseTransform(value) {
     if (typeof value === 'string') {
         return reviver(value);
     }
-    if (typeof value === 'object' && value !== null) {
+    if (
+    // Also matches arrays
+    typeof value === 'object' &&
+        value !== null) {
         Object.entries(value).forEach(([key, val]) => {
             ;
-            value[key] = modifier(val);
+            value[key] = parseTransform(val);
         });
     }
     return value;

package/dist/esm/stringify.d.ts

@@ -1,10 +1,14 @@
 export { stringify };
 export { isJsonSerializerError };
-declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys }?: {
+import { type Iterable } from './utils/replacerWithPath';
+declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, }?: {
     forbidReactElements?: boolean;
     space?: number;
     valueName?: string;
     sortObjectKeys?: boolean;
+    replacer?: (this: Iterable, key: string, value: unknown, path: string) => void | {
+        replacement: unknown;
+    };
 }): string;
 type JsonSerializerError = Error & {
     messageCore: string;

package/dist/esm/stringify.js

@@ -5,7 +5,7 @@ import { isReactElement } from './utils/isReactElement';
 import { isCallable } from './utils/isCallable';
 import { isObject } from './utils/isObject';
 import { replacerWithPath } from './utils/replacerWithPath';
-function stringify(value, { forbidReactElements, space, valueName, sortObjectKeys } = {}) {
+function stringify(value, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, } = {}) {
     // The only error `JSON.stringify()` can throw is `TypeError "cyclic object value"`.
     // - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#exceptions
     // - This means we have total of 3 possible errors while serializing:
@@ -15,6 +15,11 @@ function stringify(value, { forbidReactElements, space, valueName, sortObjectKey
     const serializer = (val) => JSON.stringify(val, replacerWithPath(replacer, !valueName), space);
     return serializer(value);
     function replacer(key, value, path) {
+        {
+            const ret = replacerUserProvided?.call(this, key, value, path);
+            if (ret)
+                return ret.replacement;
+        }
         if (forbidReactElements && isReactElement(value)) {
             throw genErr(genErrMsg('React element', path, valueName));
         }
@@ -46,7 +51,7 @@ function genErr(errMsg) {
     const err = new Error(`[@brillout/json-serializer](https://github.com/brillout/json-serializer) ${errMsg}.`);
     Object.assign(err, {
         messageCore: errMsg,
-        [stamp]: true
+        [stamp]: true,
     });
     return err;
 }

package/dist/esm/types.d.ts

@@ -1,8 +1,8 @@
 export { types };
-declare const types: readonly [Type<undefined, unknown>, Type<number, unknown>, Type<number, unknown>, Type<number, unknown>, Type<Date, any>, Type<BigInt, any>, Type<RegExp, any>, Type<Map<any, any>, any[]>, Type<Set<unknown>, unknown[]>, Type<string, any>];
-type Type<T, IntermediateType> = {
-    is: (val: unknown) => asserts val is T;
+declare const types: readonly Type<any, any>[];
+type Type<ValueType, IntermediateType> = {
+    is: (val: unknown) => asserts val is ValueType;
     match: (str: string) => boolean;
-    serialize: (val: T, serializer: (val: IntermediateType) => string) => string;
-    deserialize: (str: string, deserializer: (str: string) => IntermediateType) => T;
+    serialize: (val: ValueType, serializer: (val: IntermediateType) => string) => string;
+    deserialize: (str: string, deserializer: (str: string) => IntermediateType) => ValueType;
 };

package/dist/esm/types.js

@@ -4,31 +4,31 @@ const types = [
         is: (val) => val === undefined,
         match: (str) => str === '!undefined',
         serialize: () => '!undefined',
-        deserialize: () => undefined
+        deserialize: () => undefined,
     }),
     ts({
         is: (val) => val === Infinity,
         match: (str) => str === '!Infinity',
         serialize: () => '!Infinity',
-        deserialize: () => Infinity
+        deserialize: () => Infinity,
     }),
     ts({
         is: (val) => val === -Infinity,
         match: (str) => str === '!-Infinity',
         serialize: () => '!-Infinity',
-        deserialize: () => -Infinity
+        deserialize: () => -Infinity,
     }),
     ts({
         is: (val) => typeof val === 'number' && isNaN(val),
         match: (str) => str === '!NaN',
         serialize: () => '!NaN',
-        deserialize: () => NaN
+        deserialize: () => NaN,
     }),
     ts({
         is: (val) => val instanceof Date,
         match: (str) => str.startsWith('!Date:'),
         serialize: (val) => '!Date:' + val.toISOString(),
-        deserialize: (str) => new Date(str.slice('!Date:'.length))
+        deserialize: (str) => new Date(str.slice('!Date:'.length)),
     }),
     ts({
         is: (val) => typeof val === 'bigint',
@@ -39,7 +39,7 @@ const types = [
                 throw new Error('Your JavaScript environement does not support BigInt. Consider adding a polyfill.');
             }
             return BigInt(str.slice('!BigInt:'.length));
-        }
+        },
     }),
     ts({
         is: (val) => val instanceof RegExp,
@@ -52,27 +52,27 @@ const types = [
             const pattern = args[1];
             const flags = args[2];
             return new RegExp(pattern, flags);
-        }
+        },
     }),
     ts({
         is: (val) => val instanceof Map,
         match: (str) => str.startsWith('!Map:'),
         serialize: (val, serializer) => '!Map:' + serializer(Array.from(val.entries())),
-        deserialize: (str, deserializer) => new Map(deserializer(str.slice('!Map:'.length)))
+        deserialize: (str, deserializer) => new Map(deserializer(str.slice('!Map:'.length))),
     }),
     ts({
         is: (val) => val instanceof Set,
         match: (str) => str.startsWith('!Set:'),
         serialize: (val, serializer) => '!Set:' + serializer(Array.from(val.values())),
-        deserialize: (str, deserializer) => new Set(deserializer(str.slice('!Set:'.length)))
+        deserialize: (str, deserializer) => new Set(deserializer(str.slice('!Set:'.length))),
     }),
     // Avoid collisions with the special strings defined above
     ts({
         is: (val) => typeof val === 'string' && val.startsWith('!'),
         match: (str) => str.startsWith('!'),
         serialize: (val) => '!' + val,
-        deserialize: (str) => str.slice(1)
-    })
+        deserialize: (str) => str.slice(1),
+    }),
 ];
 // Type check
 function ts(t) {

package/dist/esm/utils/replacerWithPath.d.ts

@@ -1,3 +1,5 @@
 export { replacerWithPath };
+export type { Iterable };
 type Iterable = Record<string, unknown>;
-declare function replacerWithPath(replacer: (this: Iterable, key: string, value: unknown, path: string) => unknown, canBeFirstKey: boolean): (this: Iterable, key: string, value: unknown) => unknown;
+type Replacer = (this: Iterable, key: string, value: unknown, path: string) => unknown;
+declare function replacerWithPath(replacer: Replacer, canBeFirstKey: boolean): (this: Iterable, key: string, value: unknown) => unknown;

package/index.mjs

@@ -4,4 +4,6 @@
 //    @brillout/json-s doesn't appear to be written in CJS, but also doesn't appear to be a valid ES module (i.e. it doesn't have "type": "module" or an .mjs extension for the entry point). Please contact the package author to fix.
 //    ```
 //  - Reproduction: https://github.com/brillout/sveltekit-telefunc-repro
-throw new Error("Module `@brillout/json-serializer` doesn't exist anymore: load `@brillout/json-serializer/parse` and `@brillout/json-serializer/stringify` instead.")
+throw new Error(
+  "Module `@brillout/json-serializer` doesn't exist anymore: load `@brillout/json-serializer/parse` and `@brillout/json-serializer/stringify` instead.",
+)

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@brillout/json-serializer",
-  "version": "0.5.8",
-  "dependencies": {},
+  "version": "0.5.10",
   "description": "Same as JSON but with added support for `Date`, `undefined`, `Map`, `Set`, and more.",
   "main": "./index.mjs",
   "exports": {
@@ -18,24 +17,38 @@
     }
   },
   "scripts": {
+    "========= Dev": "",
     "dev": "pnpm run tsc:watch:cjs",
-    "build": "pnpm run clean && pnpm run tsc:esm && pnpm run tsc:cjs",
-    "test": "vitest",
-    "docs": "mdocs",
+    "========= Build": "",
+    "build": "rm -rf dist/ && pnpm run tsc:esm && pnpm run tsc:cjs",
     "tsc:esm": "tsc",
     "tsc:cjs": "tsc --project ./tsconfig.cjs.json",
     "tsc:watch:esm": "tsc --incremental --watch",
     "tsc:watch:cjs": "tsc --incremental --watch --project ./tsconfig.cjs.json",
-    "clean": "rm -rf dist/",
-    "reset": "git clean -Xdf && pnpm install && pnpm build",
+    "========= Test": "",
+    "test": "vitest",
+    "========= Build readme.md": "",
+    "docs": "mdocs",
+    "========= Clean": "",
+    "// Remove all generated files": "",
+    "clean": "git clean -Xdf",
+    "reset": "pnpm run clean && pnpm install && pnpm run build",
+    "========= Formatting": "",
+    "format": "pnpm run format:biome",
+    "format:prettier": "git ls-files | egrep '\\.(json|js|jsx|css|ts|tsx|vue|mjs|cjs)$' | grep --invert-match package.json | xargs pnpm exec prettier --write",
+    "format:biome": "biome format --write .",
+    "format:check": "biome format . || echo Fix formatting by running: $ pnpm -w run format",
+    "========= Release": "",
     "release": "release-me patch"
   },
   "devDependencies": {
+    "@biomejs/biome": "^1.7.2",
     "@brillout/mdocs": "^0.1.30",
-    "@brillout/release-me": "^0.0.5",
+    "@brillout/release-me": "^0.3.7",
     "@types/node": "^20.5.6",
     "@types/react": "^18.2.21",
     "lodash.isequal": "^4.5.0",
+    "prettier": "^3.2.5",
     "react": "^17.0.2",
     "typescript": "^5.2.2",
     "vitest": "^0.34.3"

package/parse.js

@@ -3,6 +3,9 @@
 //  - Expo/Metro
 //  - ESLint
 // prettier-ignore
+// biome-ignore format:
 'use strict';
 // prettier-ignore
+// biome-ignore format:
 exports.parse = require('./dist/cjs/parse.js').parse;
+exports.parseTransform = require('./dist/cjs/parse.js').parseTransform;

package/stringify.js

@@ -3,6 +3,8 @@
 //  - Expo/Metro
 //  - ESLint
 // prettier-ignore
+// biome-ignore format:
 'use strict';
 // prettier-ignore
+// biome-ignore format:
 exports.stringify = require('./dist/cjs/stringify.js').stringify;