es-toolkit 1.52.0-dev.2094 → 1.52.0-dev.2096

package/dist/util/serialize/serializeObject.js

@@ -0,0 +1,85 @@
+const require_isTypedArray = require("../../predicate/isTypedArray.js");
+const require_isPlainObject = require("../../predicate/isPlainObject.js");
+const require_isArrayBuffer = require("../../predicate/isArrayBuffer.js");
+const require_isDate = require("../../predicate/isDate.js");
+const require_isError = require("../../predicate/isError.js");
+const require_isMap = require("../../predicate/isMap.js");
+const require_isRegExp = require("../../predicate/isRegExp.js");
+const require_isSet = require("../../predicate/isSet.js");
+const require_compareValues = require("./compareValues.js");
+const require_serializeString = require("./serializeString.js");
+const require_serializePlainObject = require("./serializePlainObject.js");
+const require_serialize = require("./serialize.js");
+//#region src/util/serialize/serializeObject.ts
+/**
+* Serializes an object, handling circular references and repeated references.
+*
+* The first time an object is visited, it is registered as `#ref{n}` where `n`
+* is the visit order; if the object is reached again while it is still being
+* serialized, the back-reference is emitted instead. Once completed, the
+* serialized string is memoized so that repeated references serialize
+* in constant time.
+*
+* @param value - The object to serialize, or `null`.
+* @param refs - The circular reference context shared across one serialization.
+* @returns The serialized string.
+* @throws {TypeError} If the object cannot be serialized.
+*/
+function serializeObject(value, refs) {
+	if (value === null) return "null";
+	const cached = refs.get(value);
+	if (cached !== void 0) return cached;
+	refs.set(value, `#ref${refs.size}`);
+	const result = serializeObjectImpl(value, refs);
+	refs.set(value, result);
+	return result;
+}
+function serializeObjectImpl(value, refs) {
+	if (Array.isArray(value)) return serializeArray(value, refs);
+	if (require_isPlainObject.isPlainObject(value)) return require_serializePlainObject.serializePlainObject(value, refs);
+	if (require_isDate.isDate(value)) return Number.isNaN(value.getTime()) ? "Date(null)" : `Date(${require_serializeString.serializeString(value.toISOString())})`;
+	if (require_isRegExp.isRegExp(value)) return `RegExp(${value.toString()})`;
+	if (require_isSet.isSet(value)) return `Set${serializeArray(Array.from(value).sort((a, b) => require_compareValues.compareValues(a, b, refs)), refs)}`;
+	if (require_isMap.isMap(value)) return serializeEntries("Map", value.entries(), refs);
+	if (require_isTypedArray.isTypedArray(value)) {
+		const name = value[Symbol.toStringTag];
+		if (name === "BigInt64Array" || name === "BigUint64Array") return `${name}[${value.join("n,")}${value.length > 0 ? "n" : ""}]`;
+		return `${name}[${value.join(",")}]`;
+	}
+	if (require_isArrayBuffer.isArrayBuffer(value)) return `ArrayBuffer[${new Uint8Array(value).join(",")}]`;
+	if (require_isError.isError(value)) return `Error(${value.name}: ${require_serializeString.serializeString(value.message)})`;
+	const tag = Object.prototype.toString.call(value).slice(8, -1);
+	if (tag === "Object") return serializeClassInstance(value, refs);
+	if (typeof value.entries === "function") return serializeEntries(tag, value.entries(), refs);
+	throw new TypeError(`Cannot serialize ${tag}`);
+}
+function serializeArray(array, refs) {
+	let result = "[";
+	for (let i = 0; i < array.length; i++) {
+		if (i > 0) result += ",";
+		result += require_serialize.serializeValue(array[i], refs);
+	}
+	return result + "]";
+}
+function serializeEntries(tag, entries, refs) {
+	const sortedEntries = Array.from(entries).sort((a, b) => require_compareValues.compareValues(a[0], b[0], refs));
+	let result = `${tag}{`;
+	for (let i = 0; i < sortedEntries.length; i++) {
+		const [key, value] = sortedEntries[i];
+		if (i > 0) result += ",";
+		result += `${require_serialize.serializeValue(key, refs)}:${require_serialize.serializeValue(value, refs)}`;
+	}
+	return result + "}";
+}
+function serializeClassInstance(value, refs) {
+	const constructor = value.constructor;
+	const name = constructor === Object || constructor === void 0 ? "" : constructor.name;
+	if ("toJSON" in value && typeof value.toJSON === "function") {
+		const json = value.toJSON();
+		if (json !== null && typeof json === "object") return name + serializeObject(json, refs);
+		return `${name}(${require_serialize.serializeValue(json, refs)})`;
+	}
+	return name + require_serializePlainObject.serializePlainObject(value, refs);
+}
+//#endregion
+exports.serializeObject = serializeObject;

package/dist/util/serialize/serializeObject.mjs

@@ -0,0 +1,85 @@
+import { isTypedArray } from "../../predicate/isTypedArray.mjs";
+import { isPlainObject } from "../../predicate/isPlainObject.mjs";
+import { isArrayBuffer } from "../../predicate/isArrayBuffer.mjs";
+import { isDate } from "../../predicate/isDate.mjs";
+import { isError } from "../../predicate/isError.mjs";
+import { isMap } from "../../predicate/isMap.mjs";
+import { isRegExp } from "../../predicate/isRegExp.mjs";
+import { isSet } from "../../predicate/isSet.mjs";
+import { compareValues } from "./compareValues.mjs";
+import { serializeString } from "./serializeString.mjs";
+import { serializePlainObject } from "./serializePlainObject.mjs";
+import { serializeValue } from "./serialize.mjs";
+//#region src/util/serialize/serializeObject.ts
+/**
+* Serializes an object, handling circular references and repeated references.
+*
+* The first time an object is visited, it is registered as `#ref{n}` where `n`
+* is the visit order; if the object is reached again while it is still being
+* serialized, the back-reference is emitted instead. Once completed, the
+* serialized string is memoized so that repeated references serialize
+* in constant time.
+*
+* @param value - The object to serialize, or `null`.
+* @param refs - The circular reference context shared across one serialization.
+* @returns The serialized string.
+* @throws {TypeError} If the object cannot be serialized.
+*/
+function serializeObject(value, refs) {
+	if (value === null) return "null";
+	const cached = refs.get(value);
+	if (cached !== void 0) return cached;
+	refs.set(value, `#ref${refs.size}`);
+	const result = serializeObjectImpl(value, refs);
+	refs.set(value, result);
+	return result;
+}
+function serializeObjectImpl(value, refs) {
+	if (Array.isArray(value)) return serializeArray(value, refs);
+	if (isPlainObject(value)) return serializePlainObject(value, refs);
+	if (isDate(value)) return Number.isNaN(value.getTime()) ? "Date(null)" : `Date(${serializeString(value.toISOString())})`;
+	if (isRegExp(value)) return `RegExp(${value.toString()})`;
+	if (isSet(value)) return `Set${serializeArray(Array.from(value).sort((a, b) => compareValues(a, b, refs)), refs)}`;
+	if (isMap(value)) return serializeEntries("Map", value.entries(), refs);
+	if (isTypedArray(value)) {
+		const name = value[Symbol.toStringTag];
+		if (name === "BigInt64Array" || name === "BigUint64Array") return `${name}[${value.join("n,")}${value.length > 0 ? "n" : ""}]`;
+		return `${name}[${value.join(",")}]`;
+	}
+	if (isArrayBuffer(value)) return `ArrayBuffer[${new Uint8Array(value).join(",")}]`;
+	if (isError(value)) return `Error(${value.name}: ${serializeString(value.message)})`;
+	const tag = Object.prototype.toString.call(value).slice(8, -1);
+	if (tag === "Object") return serializeClassInstance(value, refs);
+	if (typeof value.entries === "function") return serializeEntries(tag, value.entries(), refs);
+	throw new TypeError(`Cannot serialize ${tag}`);
+}
+function serializeArray(array, refs) {
+	let result = "[";
+	for (let i = 0; i < array.length; i++) {
+		if (i > 0) result += ",";
+		result += serializeValue(array[i], refs);
+	}
+	return result + "]";
+}
+function serializeEntries(tag, entries, refs) {
+	const sortedEntries = Array.from(entries).sort((a, b) => compareValues(a[0], b[0], refs));
+	let result = `${tag}{`;
+	for (let i = 0; i < sortedEntries.length; i++) {
+		const [key, value] = sortedEntries[i];
+		if (i > 0) result += ",";
+		result += `${serializeValue(key, refs)}:${serializeValue(value, refs)}`;
+	}
+	return result + "}";
+}
+function serializeClassInstance(value, refs) {
+	const constructor = value.constructor;
+	const name = constructor === Object || constructor === void 0 ? "" : constructor.name;
+	if ("toJSON" in value && typeof value.toJSON === "function") {
+		const json = value.toJSON();
+		if (json !== null && typeof json === "object") return name + serializeObject(json, refs);
+		return `${name}(${serializeValue(json, refs)})`;
+	}
+	return name + serializePlainObject(value, refs);
+}
+//#endregion
+export { serializeObject };

package/dist/util/serialize/serializePlainObject.js

@@ -0,0 +1,31 @@
+const require_serializeString = require("./serializeString.js");
+const require_serialize = require("./serialize.js");
+//#region src/util/serialize/serializePlainObject.ts
+/**
+* Serializes the own enumerable string-keyed properties of an object
+* into a `{'key':value}` string.
+*
+* Keys are sorted by code unit so that the output does not depend on
+* property insertion order, and always quoted so that a key containing
+* `:` or `,` cannot be confused with the surrounding structure. Symbol
+* keys and non-enumerable properties are ignored.
+*
+* @param object - The object to serialize.
+* @param refs - The circular reference context shared with the surrounding serialization.
+* @returns The serialized string.
+*
+* @example
+* serializePlainObject({ b: 2, a: 1 }, new Map()); // "{'a':1,'b':2}"
+*/
+function serializePlainObject(object, refs) {
+	const keys = Object.keys(object).sort();
+	let result = "{";
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (i > 0) result += ",";
+		result += `${require_serializeString.serializeString(key)}:${require_serialize.serializeValue(object[key], refs)}`;
+	}
+	return result + "}";
+}
+//#endregion
+exports.serializePlainObject = serializePlainObject;

package/dist/util/serialize/serializePlainObject.mjs

@@ -0,0 +1,31 @@
+import { serializeString } from "./serializeString.mjs";
+import { serializeValue } from "./serialize.mjs";
+//#region src/util/serialize/serializePlainObject.ts
+/**
+* Serializes the own enumerable string-keyed properties of an object
+* into a `{'key':value}` string.
+*
+* Keys are sorted by code unit so that the output does not depend on
+* property insertion order, and always quoted so that a key containing
+* `:` or `,` cannot be confused with the surrounding structure. Symbol
+* keys and non-enumerable properties are ignored.
+*
+* @param object - The object to serialize.
+* @param refs - The circular reference context shared with the surrounding serialization.
+* @returns The serialized string.
+*
+* @example
+* serializePlainObject({ b: 2, a: 1 }, new Map()); // "{'a':1,'b':2}"
+*/
+function serializePlainObject(object, refs) {
+	const keys = Object.keys(object).sort();
+	let result = "{";
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (i > 0) result += ",";
+		result += `${serializeString(key)}:${serializeValue(object[key], refs)}`;
+	}
+	return result + "}";
+}
+//#endregion
+export { serializePlainObject };

package/dist/util/serialize/serializeString.js

@@ -0,0 +1,18 @@
+//#region src/util/serialize/serializeString.ts
+/**
+* Serializes a string into a single-quoted string literal.
+*
+* The string is not escaped; the output is intended for hashing and
+* change detection, not for parsing or re-evaluation.
+*
+* @param value - The string to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeString('abc'); // "'abc'"
+*/
+function serializeString(value) {
+	return `'${value}'`;
+}
+//#endregion
+exports.serializeString = serializeString;

package/dist/util/serialize/serializeString.mjs

@@ -0,0 +1,18 @@
+//#region src/util/serialize/serializeString.ts
+/**
+* Serializes a string into a single-quoted string literal.
+*
+* The string is not escaped; the output is intended for hashing and
+* change detection, not for parsing or re-evaluation.
+*
+* @param value - The string to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeString('abc'); // "'abc'"
+*/
+function serializeString(value) {
+	return `'${value}'`;
+}
+//#endregion
+export { serializeString };

package/dist/util/serialize/serializeSymbol.js

@@ -0,0 +1,23 @@
+const require_serializeString = require("./serializeString.js");
+//#region src/util/serialize/serializeSymbol.ts
+/**
+* Serializes a symbol into a string using its description.
+*
+* The description is quoted like any other string, so a symbol without a
+* description (`Symbol()`) is distinguishable from one with an empty
+* description (`Symbol('')`). Note that two different symbols with the same
+* description still serialize to the same string, since a symbol's identity
+* cannot be captured in a string.
+*
+* @param value - The symbol to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeSymbol(Symbol('test')); // "Symbol('test')"
+* serializeSymbol(Symbol()); // "Symbol()"
+*/
+function serializeSymbol(value) {
+	return value.description === void 0 ? "Symbol()" : `Symbol(${require_serializeString.serializeString(value.description)})`;
+}
+//#endregion
+exports.serializeSymbol = serializeSymbol;

package/dist/util/serialize/serializeSymbol.mjs

@@ -0,0 +1,23 @@
+import { serializeString } from "./serializeString.mjs";
+//#region src/util/serialize/serializeSymbol.ts
+/**
+* Serializes a symbol into a string using its description.
+*
+* The description is quoted like any other string, so a symbol without a
+* description (`Symbol()`) is distinguishable from one with an empty
+* description (`Symbol('')`). Note that two different symbols with the same
+* description still serialize to the same string, since a symbol's identity
+* cannot be captured in a string.
+*
+* @param value - The symbol to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeSymbol(Symbol('test')); // "Symbol('test')"
+* serializeSymbol(Symbol()); // "Symbol()"
+*/
+function serializeSymbol(value) {
+	return value.description === void 0 ? "Symbol()" : `Symbol(${serializeString(value.description)})`;
+}
+//#endregion
+export { serializeSymbol };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.52.0-dev.2094+ff2aa64a",
+  "version": "1.52.0-dev.2096+6380c75e",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",
@@ -212,6 +212,28 @@
         "default": "./dist/util/index.js"
       }
     },
+    "./util/hash": {
+      "node": {
+        "import": {
+          "types": "./dist/util/hash/node.d.mts",
+          "default": "./dist/util/hash/node.mjs"
+        },
+        "require": {
+          "types": "./dist/util/hash/node.d.ts",
+          "default": "./dist/util/hash/node.js"
+        }
+      },
+      "default": {
+        "import": {
+          "types": "./dist/util/hash/browser.d.mts",
+          "default": "./dist/util/hash/browser.mjs"
+        },
+        "require": {
+          "types": "./dist/util/hash/browser.d.ts",
+          "default": "./dist/util/hash/browser.js"
+        }
+      }
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -226,6 +248,8 @@
     "fp.js",
     "fp/iterator.js",
     "fp/iterator.d.ts",
+    "util/hash.js",
+    "util/hash.d.ts",
     "function.js",
     "iterator.js",
     "map.js",
@@ -499,6 +523,28 @@
           "default": "./dist/util/index.js"
         }
       },
+      "./util/hash": {
+        "node": {
+          "import": {
+            "types": "./dist/util/hash/node.d.mts",
+            "default": "./dist/util/hash/node.mjs"
+          },
+          "require": {
+            "types": "./dist/util/hash/node.d.ts",
+            "default": "./dist/util/hash/node.js"
+          }
+        },
+        "default": {
+          "import": {
+            "types": "./dist/util/hash/browser.d.mts",
+            "default": "./dist/util/hash/browser.mjs"
+          },
+          "require": {
+            "types": "./dist/util/hash/browser.d.ts",
+            "default": "./dist/util/hash/browser.js"
+          }
+        }
+      },
       "./package.json": "./package.json"
     },
     "types": "./dist/index.d.ts"

package/util/hash.d.ts

@@ -0,0 +1 @@
+export * from '../dist/util/hash/node';

package/util/hash.js

@@ -0,0 +1 @@
+module.exports = require('../dist/util/hash/node');