@brillout/json-serializer 0.5.18 → 0.5.19-commit-8a9605c

package/dist/{esm/parse.js → parse.js}

@@ -1,7 +1,7 @@
 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';
+import { types } from './types.js';
 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);

package/dist/{esm/stringify.d.ts → stringify.d.ts}

@@ -1,6 +1,6 @@
 export { stringify };
 export { isJsonSerializerError };
-import { type Iterable, type Path } from './utils/replacerWithPath';
+import { type Iterable, type Path } from './utils/replacerWithPath.js';
 declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, }?: {
     forbidReactElements?: boolean;
     space?: number;

package/dist/{esm/stringify.js → stringify.js}

@@ -1,10 +1,10 @@
 export { stringify };
 export { isJsonSerializerError };
-import { types } from './types';
-import { isReactElement } from './utils/isReactElement';
-import { isCallable } from './utils/isCallable';
-import { isObject } from './utils/isObject';
-import { replacerWithPath } from './utils/replacerWithPath';
+import { types } from './types.js';
+import { isReactElement } from './utils/isReactElement.js';
+import { isCallable } from './utils/isCallable.js';
+import { isObject } from './utils/isObject.js';
+import { replacerWithPath } from './utils/replacerWithPath.js';
 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

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@brillout/json-serializer",
-  "version": "0.5.18",
+  "version": "0.5.19-commit-8a9605c",
   "description": "Same as JSON but with added support for `Date`, `undefined`, `Map`, `Set`, and more.",
   "main": "./index.mjs",
+  "type": "module",
   "exports": {
     ".": "./index.mjs",
     "./parse": {
-      "import": "./dist/esm/parse.js",
-      "require": "./dist/cjs/parse.js",
-      "types": "./dist/esm/parse.d.ts",
-      "default": "./dist/esm/parse.js"
+      "import": "./dist/parse.js",
+      "types": "./dist/parse.d.ts",
+      "default": "./dist/parse.js"
     },
     "./stringify": {
-      "import": "./dist/esm/stringify.js",
-      "require": "./dist/cjs/stringify.js",
-      "types": "./dist/esm/stringify.d.ts",
-      "default": "./dist/esm/stringify.js"
+      "import": "./dist/stringify.js",
+      "types": "./dist/stringify.d.ts",
+      "default": "./dist/stringify.js"
     }
   },
   "devDependencies": {
@@ -44,13 +43,9 @@
   },
   "scripts": {
     "========= Dev": "",
-    "dev": "pnpm run tsc:watch:cjs",
+    "dev": "npm tsc --watch",
     "========= 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",
+    "build": "rm -rf dist/ && tsc",
     "========= Test": "",
     "test": "vitest",
     "========= Build readme.md": "",

package/parse.d.ts

@@ -1,2 +1,2 @@
 // Help TS's resolver until it supports `package.json#exports`
-export * from './dist/esm/parse'
+export * from './dist/parse'

package/parse.js

@@ -1,11 +1,3 @@
-// Some tools don't support `package.json#exports`, such as:
-//  - Nuxt v2
-//  - 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
+// Some tools still need this as of January 2025
+export * from './dist/parse.js'
+export { default } from './dist/parse.js'

package/stringify.d.ts

@@ -1,2 +1,2 @@
 // Help TS's resolver until it supports `package.json#exports`
-export * from './dist/esm/stringify'
+export * from './dist/stringify'

package/stringify.js

@@ -1,10 +1,3 @@
-// Some tools don't support `package.json#exports`, such as:
-//  - Nuxt v2
-//  - Expo/Metro
-//  - ESLint
-// prettier-ignore
-// biome-ignore format:
-'use strict';
-// prettier-ignore
-// biome-ignore format:
-exports.stringify = require('./dist/cjs/stringify.js').stringify;
+// Some tools still need this as of January 2025
+export * from './dist/stringify.js'
+export { default } from './dist/stringify.js'

package/dist/cjs/parse.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = parse;
-exports.parseTransform = parseTransform;
-const types_1 = require("./types");
-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, options);
-}
-function parseTransform(value, options = {}) {
-    if (typeof value === 'string') {
-        return reviver(value, options);
-    }
-    if (
-    // Also matches arrays
-    typeof value === 'object' &&
-        value !== null) {
-        Object.entries(value).forEach(([key, val]) => {
-            ;
-            value[key] = parseTransform(val, options);
-        });
-    }
-    return 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, parser);
-        }
-    }
-    return value;
-}

package/dist/cjs/stringify.d.ts

@@ -1,21 +0,0 @@
-export { stringify };
-export { isJsonSerializerError };
-import { type Iterable, type Path } 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, 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`;
-    value: unknown;
-    path: Path;
-    pathString: string;
-    subjectName: string;
-};
-declare function isJsonSerializerError(thing: unknown): thing is Error & ErrAddendum;

package/dist/cjs/stringify.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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, 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:
-    //    - Cyclic references
-    //    - Functions
-    //    - React elements
-    const serializer = (val) => JSON.stringify(val, (0, replacerWithPath_1.replacerWithPath)(replacer), space);
-    return serializer(value);
-    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, valueAfterJSON, serializer);
-            if (ret) {
-                value = ret.replacement;
-                if (ret.resolved !== false)
-                    return value;
-            }
-        }
-        if (forbidReactElements && (0, isReactElement_1.isReactElement)(value)) {
-            throw genErr({
-                value,
-                valueType: 'React element',
-                path,
-                rootValueName: valueName,
-            });
-        }
-        if ((0, isCallable_1.isCallable)(value)) {
-            const functionName = value.name;
-            throw genErr({
-                value,
-                valueType: 'function',
-                path,
-                rootValueName: valueName,
-                problematicValueName: path.length === 0 ? functionName : undefined,
-            });
-        }
-        for (const { is, serialize } of types_1.types.slice().reverse()) {
-            if (is(value)) {
-                //@ts-ignore
-                return serialize(value, serializer);
-            }
-        }
-        if (sortObjectKeys && (0, isObject_1.isObject)(value)) {
-            const copy = {};
-            Object.keys(value)
-                .sort()
-                .forEach((key) => {
-                copy[key] = value[key];
-            });
-            value = copy;
-        }
-        return value;
-    }
-}
-function genErr({ value, valueType, path, rootValueName, problematicValueName, }) {
-    const subjectName = getSubjectName({ path, rootValueName, problematicValueName });
-    const messageCore = `cannot serialize ${subjectName} because it's a ${valueType}`;
-    const err = new Error(`[@brillout/json-serializer](https://github.com/brillout/json-serializer) ${messageCore}.`);
-    const pathString = getPathString(path, true);
-    const errAddendum = {
-        [stamp]: true,
-        messageCore,
-        value,
-        path,
-        pathString,
-        subjectName,
-    };
-    Object.assign(err, errAddendum);
-    return err;
-}
-const stamp = '_isJsonSerializerError';
-function isJsonSerializerError(thing) {
-    return (0, isObject_1.isObject)(thing) && thing[stamp] === true;
-}
-function getSubjectName({ path, rootValueName, problematicValueName, }) {
-    const pathString = getPathString(path, !rootValueName);
-    let subjectName;
-    if (!pathString) {
-        subjectName = rootValueName || problematicValueName || 'value';
-    }
-    else {
-        if (problematicValueName) {
-            subjectName = problematicValueName + ' at ';
-        }
-        else {
-            subjectName = '';
-        }
-        subjectName = subjectName + (rootValueName || '') + pathString;
-    }
-    return subjectName;
-}
-function getPathString(path, canBeFirstKey) {
-    const pathString = path
-        .map((key, i) => {
-        if (typeof key === 'number') {
-            return `[${key}]`;
-        }
-        if (i === 0 && canBeFirstKey && isKeyDotNotationCompatible(key)) {
-            return key;
-        }
-        return getPropAccessNotation(key);
-    })
-        .join('');
-    return pathString;
-}
-function getPropAccessNotation(key) {
-    return typeof key === 'string' && isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
-}
-function isKeyDotNotationCompatible(key) {
-    return /^[a-z0-9\$_]+$/i.test(key);
-}

package/dist/cjs/types.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.types = void 0;
-const types = [
-    ts({
-        is: (val) => val === undefined,
-        match: (str) => str === '!undefined',
-        serialize: () => '!undefined',
-        deserialize: () => undefined,
-    }),
-    ts({
-        is: (val) => val === Infinity,
-        match: (str) => str === '!Infinity',
-        serialize: () => '!Infinity',
-        deserialize: () => Infinity,
-    }),
-    ts({
-        is: (val) => val === -Infinity,
-        match: (str) => str === '!-Infinity',
-        serialize: () => '!-Infinity',
-        deserialize: () => -Infinity,
-    }),
-    ts({
-        is: (val) => typeof val === 'number' && isNaN(val),
-        match: (str) => str === '!NaN',
-        serialize: () => '!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)),
-    }),
-    ts({
-        is: (val) => typeof val === 'bigint',
-        match: (str) => str.startsWith('!BigInt:'),
-        serialize: (val) => '!BigInt:' + val.toString(),
-        deserialize: (str) => {
-            if (typeof BigInt === 'undefined') {
-                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,
-        match: (str) => str.startsWith('!RegExp:'),
-        serialize: (val) => '!RegExp:' + val.toString(),
-        deserialize: (str) => {
-            str = str.slice('!RegExp:'.length);
-            // const args: string[] = str.match(/\/(.*?)\/([gimy])?$/)!
-            const args = str.match(/\/(.*)\/(.*)?/);
-            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, 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, parser) => new Set(parser(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),
-    }),
-];
-exports.types = types;
-// Type check
-function ts(t) {
-    return t;
-}

package/dist/cjs/utils/isCallable.js

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

package/dist/cjs/utils/isObject.js

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

package/dist/cjs/utils/isReactElement.js

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

package/dist/cjs/utils/replacerWithPath.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replacerWithPath = replacerWithPath;
-function replacerWithPath(replacer) {
-    const pathMap = new WeakMap();
-    return function (key, value) {
-        var _a;
-        const pathPrevious = (_a = pathMap.get(this)) !== null && _a !== void 0 ? _a : [];
-        const path = [...pathPrevious];
-        if (key !== '') {
-            const pathEntry = !Array.isArray(this) ? key : parseInt(key, 10);
-            path.push(pathEntry);
-        }
-        if (isIterable(value))
-            pathMap.set(value, path);
-        return replacer.call(this, key, value, path);
-    };
-}
-function isIterable(value) {
-    return value === Object(value);
-}

package/dist/esm/parse.d.ts

@@ -1,10 +0,0 @@
-export { parse };
-export { parseTransform };
-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/types.d.ts

@@ -1,8 +0,0 @@
-export { types };
-declare const types: readonly Type<any, any>[];
-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, parser: (str: string) => IntermediateType) => ValueType;
-};

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

@@ -1 +0,0 @@
-export declare function isCallable<T extends (...args: unknown[]) => unknown>(thing: T | unknown): thing is T;

package/dist/esm/utils/isKeyDotNotationCompatible.js

@@ -1 +0,0 @@
-"use strict";

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

@@ -1,3 +0,0 @@
-export { isObject };
-type Object = Record<string, unknown>;
-declare function isObject(value: unknown): value is Object;

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

@@ -1 +0,0 @@
-export declare function isReactElement(value: unknown): boolean;

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

@@ -1,7 +0,0 @@
-export { replacerWithPath };
-export type { Iterable };
-export type { Path };
-type Path = (string | number)[];
-type Iterable = Record<string, unknown>;
-type Replacer = (this: Iterable, key: string, value: unknown, path: Path) => unknown;
-declare function replacerWithPath(replacer: Replacer): (this: Iterable, key: string, value: unknown) => unknown;