@brillout/json-serializer 0.5.15 → 0.5.17

package/dist/cjs/parse.d.ts

@@ -1,4 +1,10 @@
 export { parse };
 export { parseTransform };
-declare function parse(str: string): unknown;
-declare function parseTransform(value: unknown): unknown;
+type Options = {
+    reviver?: (key: undefined | string, value: string, parser: (str: string) => unknown) => {
+        replacement: unknown;
+        resolved?: boolean;
+    } | undefined;
+};
+declare function parse(str: string, options?: Options): unknown;
+declare function parseTransform(value: unknown, options?: Options): unknown;

package/dist/cjs/parse.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTransform = exports.parse = void 0;
+exports.parse = parse;
+exports.parseTransform = parseTransform;
 const types_1 = require("./types");
-function parse(str) {
+function parse(str, options = {}) {
     // 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 parseTransform(value);
+    return parseTransform(value, options);
 }
-exports.parse = parse;
-function parseTransform(value) {
+function parseTransform(value, options = {}) {
     if (typeof value === 'string') {
-        return reviver(value);
+        return reviver(value, options);
     }
     if (
     // Also matches arrays
@@ -18,16 +18,32 @@ function parseTransform(value) {
         value !== null) {
         Object.entries(value).forEach(([key, val]) => {
             ;
-            value[key] = parseTransform(val);
+            value[key] = parseTransform(val, options);
         });
     }
     return value;
 }
-exports.parseTransform = parseTransform;
-function reviver(value) {
+function reviver(value, options) {
+    var _a;
+    const parser = (str) => parse(str, options);
+    {
+        const res = (_a = options.reviver) === null || _a === void 0 ? void 0 : _a.call(options, 
+        // TO-DO/eventually: provide key if some user needs it
+        undefined, value, parser);
+        if (res) {
+            if (typeof res.replacement !== 'string') {
+                return res.replacement;
+            }
+            else {
+                value = res.replacement;
+                if (res.resolved)
+                    return value;
+            }
+        }
+    }
     for (const { match, deserialize } of types_1.types) {
         if (match(value)) {
-            return deserialize(value, parse);
+            return deserialize(value, parser);
         }
     }
     return value;

package/dist/cjs/stringify.d.ts

@@ -6,9 +6,10 @@ declare function stringify(value: unknown, { forbidReactElements, space, valueNa
     space?: number;
     valueName?: string;
     sortObjectKeys?: boolean;
-    replacer?: (this: Iterable, key: string, value: unknown) => void | {
+    replacer?: (this: Iterable, key: string, value: unknown, serializer: (value: unknown) => string) => {
         replacement: unknown;
-    };
+        resolved?: boolean;
+    } | undefined;
 }): string;
 type ErrAddendum = {
     messageCore: `cannot serialize ${string} because it's a function` | `cannot serialize ${string} because it's a React element`;

package/dist/cjs/stringify.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJsonSerializerError = exports.stringify = void 0;
+exports.stringify = stringify;
+exports.isJsonSerializerError = isJsonSerializerError;
 const types_1 = require("./types");
 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, 
-// Used by Vike: https://github.com/vikejs/vike/blob/b4ba6b70e6bdc2e1f460c0d2e4c3faae5d0a733c/vike/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.ts#L78
-replacer: replacerUserProvided, } = {}) {
+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:
@@ -17,11 +16,16 @@ replacer: replacerUserProvided, } = {}) {
     //    - React elements
     const serializer = (val) => JSON.stringify(val, (0, replacerWithPath_1.replacerWithPath)(replacer), space);
     return serializer(value);
-    function replacer(key, value, path) {
+    function replacer(key, valueAfterJSON, path) {
+        const valueOriginal = this[key];
+        let value = valueOriginal;
         {
-            const ret = replacerUserProvided === null || replacerUserProvided === void 0 ? void 0 : replacerUserProvided.call(this, key, value);
-            if (ret)
-                return ret.replacement;
+            const ret = replacerUserProvided === null || replacerUserProvided === void 0 ? void 0 : replacerUserProvided.call(this, key, valueAfterJSON, serializer);
+            if (ret) {
+                value = ret.replacement;
+                if (ret.resolved !== false)
+                    return value;
+            }
         }
         if (forbidReactElements && (0, isReactElement_1.isReactElement)(value)) {
             throw genErr({
@@ -41,11 +45,10 @@ replacer: replacerUserProvided, } = {}) {
                 problematicValueName: path.length === 0 ? functionName : undefined,
             });
         }
-        const valueOriginal = this[key];
         for (const { is, serialize } of types_1.types.slice().reverse()) {
-            if (is(valueOriginal)) {
+            if (is(value)) {
                 //@ts-ignore
-                return serialize(valueOriginal, serializer);
+                return serialize(value, serializer);
             }
         }
         if (sortObjectKeys && (0, isObject_1.isObject)(value)) {
@@ -60,7 +63,6 @@ replacer: replacerUserProvided, } = {}) {
         return value;
     }
 }
-exports.stringify = stringify;
 function genErr({ value, valueType, path, rootValueName, problematicValueName, }) {
     const subjectName = getSubjectName({ path, rootValueName, problematicValueName });
     const messageCore = `cannot serialize ${subjectName} because it's a ${valueType}`;
@@ -81,7 +83,6 @@ const stamp = '_isJsonSerializerError';
 function isJsonSerializerError(thing) {
     return (0, isObject_1.isObject)(thing) && thing[stamp] === true;
 }
-exports.isJsonSerializerError = isJsonSerializerError;
 function getSubjectName({ path, rootValueName, problematicValueName, }) {
     const pathString = getPathString(path, !rootValueName);
     let subjectName;

package/dist/cjs/types.d.ts

@@ -4,5 +4,5 @@ type Type<ValueType, IntermediateType> = {
     is: (val: unknown) => asserts val is ValueType;
     match: (str: string) => boolean;
     serialize: (val: ValueType, serializer: (val: IntermediateType) => string) => string;
-    deserialize: (str: string, deserializer: (str: string) => IntermediateType) => ValueType;
+    deserialize: (str: string, parser: (str: string) => IntermediateType) => ValueType;
 };

package/dist/cjs/types.js

@@ -60,13 +60,13 @@ const types = [
         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, parser) => new Map(parser(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, parser) => new Set(parser(str.slice('!Set:'.length))),
     }),
     // Avoid collisions with the special strings defined above
     ts({

package/dist/cjs/utils/isCallable.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCallable = void 0;
+exports.isCallable = isCallable;
 function isCallable(thing) {
     return thing instanceof Function || typeof thing === 'function';
 }
-exports.isCallable = isCallable;

package/dist/cjs/utils/isObject.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = void 0;
+exports.isObject = isObject;
 function isObject(value) {
     if (typeof value !== 'object' || value === null) {
         return false;
@@ -10,4 +10,3 @@ function isObject(value) {
     }
     return true;
 }
-exports.isObject = isObject;

package/dist/cjs/utils/isReactElement.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReactElement = void 0;
+exports.isReactElement = isReactElement;
 function isReactElement(value) {
     return (typeof value === 'object' &&
         value !== null &&
         String(value['$$typeof']) === 'Symbol(react.element)');
 }
-exports.isReactElement = isReactElement;

package/dist/cjs/utils/replacerWithPath.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replacerWithPath = void 0;
+exports.replacerWithPath = replacerWithPath;
 function replacerWithPath(replacer) {
     const pathMap = new WeakMap();
     return function (key, value) {
@@ -16,7 +16,6 @@ function replacerWithPath(replacer) {
         return replacer.call(this, key, value, path);
     };
 }
-exports.replacerWithPath = replacerWithPath;
 function isIterable(value) {
     return value === Object(value);
 }

package/dist/esm/parse.d.ts

@@ -1,4 +1,10 @@
 export { parse };
 export { parseTransform };
-declare function parse(str: string): unknown;
-declare function parseTransform(value: unknown): unknown;
+type Options = {
+    reviver?: (key: undefined | string, value: string, parser: (str: string) => unknown) => {
+        replacement: unknown;
+        resolved?: boolean;
+    } | undefined;
+};
+declare function parse(str: string, options?: Options): unknown;
+declare function parseTransform(value: unknown, options?: Options): unknown;

package/dist/esm/parse.js

@@ -2,14 +2,14 @@ export { parse };
 // Used by Vike: https://github.com/vikejs/vike/blob/b4ba6b70e6bdc2e1f460c0d2e4c3faae5d0a733c/vike/shared/page-configs/serialize/parseConfigValuesSerialized.ts#L13
 export { parseTransform };
 import { types } from './types';
-function parse(str) {
+function parse(str, options = {}) {
     // 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 parseTransform(value);
+    return parseTransform(value, options);
 }
-function parseTransform(value) {
+function parseTransform(value, options = {}) {
     if (typeof value === 'string') {
-        return reviver(value);
+        return reviver(value, options);
     }
     if (
     // Also matches arrays
@@ -17,15 +17,31 @@ function parseTransform(value) {
         value !== null) {
         Object.entries(value).forEach(([key, val]) => {
             ;
-            value[key] = parseTransform(val);
+            value[key] = parseTransform(val, options);
         });
     }
     return value;
 }
-function reviver(value) {
+function reviver(value, options) {
+    const parser = (str) => parse(str, options);
+    {
+        const res = options.reviver?.(
+        // TO-DO/eventually: provide key if some user needs it
+        undefined, value, parser);
+        if (res) {
+            if (typeof res.replacement !== 'string') {
+                return res.replacement;
+            }
+            else {
+                value = res.replacement;
+                if (res.resolved)
+                    return value;
+            }
+        }
+    }
     for (const { match, deserialize } of types) {
         if (match(value)) {
-            return deserialize(value, parse);
+            return deserialize(value, parser);
         }
     }
     return value;

package/dist/esm/stringify.d.ts

@@ -6,9 +6,10 @@ declare function stringify(value: unknown, { forbidReactElements, space, valueNa
     space?: number;
     valueName?: string;
     sortObjectKeys?: boolean;
-    replacer?: (this: Iterable, key: string, value: unknown) => void | {
+    replacer?: (this: Iterable, key: string, value: unknown, serializer: (value: unknown) => string) => {
         replacement: unknown;
-    };
+        resolved?: boolean;
+    } | undefined;
 }): string;
 type ErrAddendum = {
     messageCore: `cannot serialize ${string} because it's a function` | `cannot serialize ${string} because it's a React element`;

package/dist/esm/stringify.js

@@ -5,9 +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, 
-// Used by Vike: https://github.com/vikejs/vike/blob/b4ba6b70e6bdc2e1f460c0d2e4c3faae5d0a733c/vike/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.ts#L78
-replacer: replacerUserProvided, } = {}) {
+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,11 +14,16 @@ replacer: replacerUserProvided, } = {}) {
     //    - React elements
     const serializer = (val) => JSON.stringify(val, replacerWithPath(replacer), space);
     return serializer(value);
-    function replacer(key, value, path) {
+    function replacer(key, valueAfterJSON, path) {
+        const valueOriginal = this[key];
+        let value = valueOriginal;
         {
-            const ret = replacerUserProvided?.call(this, key, value);
-            if (ret)
-                return ret.replacement;
+            const ret = replacerUserProvided?.call(this, key, valueAfterJSON, serializer);
+            if (ret) {
+                value = ret.replacement;
+                if (ret.resolved !== false)
+                    return value;
+            }
         }
         if (forbidReactElements && isReactElement(value)) {
             throw genErr({
@@ -40,11 +43,10 @@ replacer: replacerUserProvided, } = {}) {
                 problematicValueName: path.length === 0 ? functionName : undefined,
             });
         }
-        const valueOriginal = this[key];
         for (const { is, serialize } of types.slice().reverse()) {
-            if (is(valueOriginal)) {
+            if (is(value)) {
                 //@ts-ignore
-                return serialize(valueOriginal, serializer);
+                return serialize(value, serializer);
             }
         }
         if (sortObjectKeys && isObject(value)) {

package/dist/esm/types.d.ts

@@ -4,5 +4,5 @@ type Type<ValueType, IntermediateType> = {
     is: (val: unknown) => asserts val is ValueType;
     match: (str: string) => boolean;
     serialize: (val: ValueType, serializer: (val: IntermediateType) => string) => string;
-    deserialize: (str: string, deserializer: (str: string) => IntermediateType) => ValueType;
+    deserialize: (str: string, parser: (str: string) => IntermediateType) => ValueType;
 };

package/dist/esm/types.js

@@ -58,13 +58,13 @@ const types = [
         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, parser) => new Map(parser(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, parser) => new Set(parser(str.slice('!Set:'.length))),
     }),
     // Avoid collisions with the special strings defined above
     ts({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brillout/json-serializer",
-  "version": "0.5.15",
+  "version": "0.5.17",
   "description": "Same as JSON but with added support for `Date`, `undefined`, `Map`, `Set`, and more.",
   "main": "./index.mjs",
   "exports": {
@@ -16,47 +16,19 @@
       "default": "./dist/esm/stringify.js"
     }
   },
-  "scripts": {
-    "========= Dev": "",
-    "dev": "pnpm run tsc:watch:cjs",
-    "========= 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",
-    "========= Test": "",
-    "test": "vitest",
-    "========= Build readme.md": "",
-    "docs": "mdocs",
-    "========= 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",
-    "========= Reset": "",
-    "reset": "git clean -Xdf && pnpm install && pnpm run build"
-  },
   "devDependencies": {
     "@biomejs/biome": "^1.7.2",
     "@brillout/mdocs": "^0.1.30",
-    "@brillout/release-me": "^0.3.8",
-    "@types/node": "^20.5.6",
+    "@brillout/release-me": "^0.4.7",
+    "@types/node": "^24.0.10",
     "@types/react": "^18.2.21",
     "lodash.isequal": "^4.5.0",
     "prettier": "^3.2.5",
     "react": "^17.0.2",
-    "typescript": "^5.2.2",
+    "typescript": "^5.8.3",
     "vitest": "^0.34.3"
   },
   "// Use @vitest/snapshot PR https://github.com/vitest-dev/vitest/pull/3961": "",
-  "pnpm": {
-    "overrides": {
-      "vitest>@vitest/snapshot": "npm:@brillout/vitest-snapshot@0.35.0-prerelease"
-    }
-  },
   "files": [
     "dist/",
     "*.d.ts",
@@ -67,5 +39,31 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "========= Dev": "",
+    "dev": "pnpm run tsc:watch:cjs",
+    "========= 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",
+    "========= Test": "",
+    "test": "vitest",
+    "========= Build readme.md": "",
+    "docs": "mdocs",
+    "========= 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",
+    "========= Reset": "",
+    "reset": "git clean -Xdf && pnpm install && pnpm run build",
+    "========= Release": "",
+    "release": "release-me patch",
+    "release:minor": "release-me minor",
+    "release:major": "release-me major",
+    "release:commit": "release-me commit"
   }
-}
+}