@nullix/zod-mongoose-studio 3.3.1 → 3.3.3

package/.output/server/node_modules/devalue/src/stringify.js

@@ -1,13 +1,4 @@
-import {
-	DevalueError,
-	enumerable_symbols,
-	get_type,
-	is_plain_object,
-	is_primitive,
-	stringify_key,
-	stringify_string,
-	valid_array_indices
-} from './utils.js';
+import { DevalueError, stringify_key, stringify_string } from './utils.js';
 import {
 	HOLE,
 	NAN,
@@ -18,13 +9,67 @@ import {
 	UNDEFINED
 } from './constants.js';
 import { encode64 } from './base64.js';
+import { default_stringify_operations, merge_operations } from './operations.js';
 
 /**
  * Turn a value into a JSON string that can be parsed with `devalue.parse`
  * @param {any} value
  * @param {Record<string, (value: any) => any>} [reducers]
+ * @param {import('./types.js').StringifyOptions} [options]
  */
-export function stringify(value, reducers) {
+export function stringify(value, reducers, options) {
+	const stringified = run(false, value, reducers, options);
+	return typeof stringified === 'string' ? stringified : `[${stringified.join(',')}]`;
+}
+
+/**
+ * Turn a value into a JSON string that can be parsed with `devalue.parse`
+ * @param {any} value
+ * @param {Record<string, (value: any) => any>} [reducers]
+ * @param {import('./types.js').StringifyOptions} [options]
+ */
+export async function stringifyAsync(value, reducers, options) {
+	const stringified = run(true, value, reducers, options);
+
+	if (typeof stringified === 'string') {
+		return stringified;
+	}
+
+	let out = '[';
+
+	for (let i = 0; i < stringified.length; i += 1) {
+		let value = stringified[i];
+
+		if (typeof value !== 'string') {
+			await value;
+			value = stringified[i];
+
+			if (i === 0 && value < 0) {
+				return `${value}`;
+			}
+		}
+
+		out += value;
+
+		if (i < stringified.length - 1) {
+			out += ',';
+		}
+	}
+
+	out += ']';
+
+	return out;
+}
+
+/**
+ * @param {boolean} async
+ * @param {any} value
+ * @param {Record<string, (value: any) => any>} [reducers]
+ * @param {import('./types.js').StringifyOptions} [options]
+ */
+function run(async, value, reducers, options) {
+	const ops = merge_operations(default_stringify_operations, options?.operations);
+
 	/** @type {any[]} */
 	const stringified = [];
 
@@ -44,18 +89,35 @@ export function stringify(value, reducers) {
 
 	let p = 0;
 
-	/** @param {any} thing */
-	function flatten(thing) {
-		if (thing === undefined) return UNDEFINED;
-		if (Number.isNaN(thing)) return NAN;
-		if (thing === Infinity) return POSITIVE_INFINITY;
-		if (thing === -Infinity) return NEGATIVE_INFINITY;
-		if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
+	/**
+	 * @param {any} thing
+	 * @param {number} [index]
+	 */
+	function flatten(thing, index) {
+		const type = ops.typeOf(thing);
+
+		if (type === 'undefined') return UNDEFINED;
+
+		/** @type {number | undefined} */
+		let number;
+
+		// `ops.toPrimitive` is the boundary between the value being serialized and
+		// plain host JavaScript: everything below operates on the extracted host
+		// primitive, so native comparisons and arithmetic are correct there.
+		if (type === 'number') {
+			number = /** @type {number} */ (ops.toPrimitive(thing));
+			if (Number.isNaN(number)) return NAN;
+			if (number === Infinity) return POSITIVE_INFINITY;
+			if (number === -Infinity) return NEGATIVE_INFINITY;
+			if (number === 0 && 1 / number < 0) return NEGATIVE_ZERO;
+		}
+
+		const id = ops.identify(thing);
 
-		if (indexes.has(thing)) return indexes.get(thing);
+		if (indexes.has(id)) return /** @type {number} */ (indexes.get(id));
 
-		const index = p++;
-		indexes.set(thing, index);
+		index ??= p++;
+		indexes.set(id, index);
 
 		for (const { key, fn } of custom) {
 			const value = fn(thing);
@@ -65,43 +127,61 @@ export function stringify(value, reducers) {
 			}
 		}
 
-		if (typeof thing === 'function') {
+		if (type === 'function') {
 			throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		} else if (type === 'symbol') {
+			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
 		}
 
+		/** @type {string | Promise<any>} */
 		let str = '';
 
-		if (is_primitive(thing)) {
-			str = stringify_primitive(thing);
+		if (type !== 'object') {
+			str = stringify_primitive(type === 'number' ? number : ops.toPrimitive(thing));
+		} else if (ops.isThenable(thing)) {
+			if (!async) {
+				throw new DevalueError(
+					`Cannot stringify a Promise or thenable — use stringifyAsync instead`,
+					keys,
+					thing,
+					value
+				);
+			}
+
+			str = ops.toPromise(thing).then((value) => {
+				const i = flatten(value, index);
+				if (i < 0) stringified[index] = i;
+			});
+
+			// Promises are awaited sequentially, and traversal may throw before
+			// reaching them. Handle rejections immediately, but keep the original
+			// promise so awaiting it still propagates the error to the caller.
+			str.catch(() => {});
 		} else {
-			const type = get_type(thing);
+			const tag = ops.tagOf(thing);
 
-			switch (type) {
+			switch (tag) {
 				case 'Number':
 				case 'String':
 				case 'Boolean':
-					str = `["Object",${stringify_primitive(thing)}]`;
-					break;
-
 				case 'BigInt':
-					str = `["BigInt",${thing}]`;
+					str = `["Object",${flatten(ops.unbox(thing))}]`;
 					break;
 
 				case 'Date':
-					const valid = !isNaN(thing.getDate());
-					str = `["Date","${valid ? thing.toISOString() : ''}"]`;
+					str = `["Date","${ops.toISOString(thing)}"]`;
 					break;
 
 				case 'URL':
-					str = `["URL",${stringify_string(thing.toString())}]`;
+					str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
 					break;
 
 				case 'URLSearchParams':
-					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
 					break;
 
 				case 'RegExp':
-					const { source, flags } = thing;
+					const { source, flags } = ops.regExpInfo(thing);
 					str = flags
 						? `["RegExp",${stringify_string(source)},"${flags}"]`
 						: `["RegExp",${stringify_string(source)}]`;
@@ -117,14 +197,16 @@ export function stringify(value, reducers) {
 					// is what protects against the DoS of e.g. `arr[1000000] = 1`.
 					let mostly_dense = false;
 
+					const length = ops.lengthOf(thing);
+
 					str = '[';
 
-					for (let i = 0; i < thing.length; i += 1) {
+					for (let i = 0; i < length; i += 1) {
 						if (i > 0) str += ',';
 
-						if (Object.hasOwn(thing, i)) {
+						if (ops.hasOwn(thing, i)) {
 							keys.push(`[${i}]`);
-							str += flatten(thing[i]);
+							str += flatten(ops.get(thing, i));
 							keys.pop();
 						} else if (mostly_dense) {
 							// Use dense encoding. The heuristic guarantees the
@@ -163,19 +245,19 @@ export function stringify(value, reducers) {
 							//
 							// Sparse encoding is cheaper when:
 							//   (4 + d) + P * (d + 1) < (L - P) * 3
-							const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
+							const populated_keys = ops.indicesOf(thing);
 							const population = populated_keys.length;
-							const d = String(thing.length).length;
+							const d = String(length).length;
 
-							const hole_cost = (thing.length - population) * 3;
+							const hole_cost = (length - population) * 3;
 							const sparse_cost = 4 + d + population * (d + 1);
 
 							if (hole_cost > sparse_cost) {
-								str = '[' + SPARSE + ',' + thing.length;
+								str = '[' + SPARSE + ',' + length;
 								for (let j = 0; j < populated_keys.length; j++) {
 									const key = populated_keys[j];
 									keys.push(`[${key}]`);
-									str += ',' + key + ',' + flatten(thing[key]);
+									str += ',' + key + ',' + flatten(ops.get(thing, key));
 									keys.pop();
 								}
 								break;
@@ -194,7 +276,7 @@ export function stringify(value, reducers) {
 				case 'Set':
 					str = '["Set"';
 
-					for (const value of thing) {
+					for (const value of ops.valuesOf(thing)) {
 						str += `,${flatten(value)}`;
 					}
 
@@ -204,9 +286,12 @@ export function stringify(value, reducers) {
 				case 'Map':
 					str = '["Map"';
 
-					for (const [key, value] of thing) {
+					for (const [key, value] of ops.entriesOf(thing)) {
+						const key_type = ops.typeOf(key);
+						const key_is_primitive =
+							key_type !== 'object' && key_type !== 'function' && key_type !== 'symbol';
 						keys.push(
-							`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`
+							`.get(${key_is_primitive ? stringify_primitive(ops.toPrimitive(key)) : '...'})`
 						);
 						str += `,${flatten(key)},${flatten(value)}`;
 						keys.pop();
@@ -220,23 +305,31 @@ export function stringify(value, reducers) {
 				case 'Uint8ClampedArray':
 				case 'Int16Array':
 				case 'Uint16Array':
+				case 'Float16Array':
 				case 'Int32Array':
 				case 'Uint32Array':
 				case 'Float32Array':
 				case 'Float64Array':
 				case 'BigInt64Array':
 				case 'BigUint64Array': {
-					/** @type {import("./types.js").TypedArray} */
-					const typedArray = thing;
-					str = '["' + type + '",' + flatten(typedArray.buffer);
-
-					const a = thing.byteOffset;
-					const b = a + thing.byteLength;
+					const info = ops.viewInfo(thing);
+					str = '["' + tag + '",' + flatten(info.buffer);
 
 					// handle subarrays
-					if (a > 0 || b !== typedArray.buffer.byteLength) {
-						const m = +/(\d+)/.exec(type)[1] / 8;
-						str += `,${a / m},${b / m}`;
+					if (info.byteLength !== info.bufferByteLength) {
+						str += `,${info.byteOffset},${info.length}`;
+					}
+
+					str += ']';
+					break;
+				}
+
+				case 'DataView': {
+					const info = ops.viewInfo(thing);
+					str = '["' + tag + '",' + flatten(info.buffer);
+
+					if (info.byteLength !== info.bufferByteLength) {
+						str += `,${info.byteOffset},${info.byteLength}`;
 					}
 
 					str += ']';
@@ -244,9 +337,7 @@ export function stringify(value, reducers) {
 				}
 
 				case 'ArrayBuffer': {
-					/** @type {ArrayBuffer} */
-					const arraybuffer = thing;
-					const base64 = encode64(arraybuffer);
+					const base64 = encode64(ops.toArrayBuffer(thing));
 
 					str = `["ArrayBuffer","${base64}"]`;
 					break;
@@ -260,31 +351,23 @@ export function stringify(value, reducers) {
 				case 'Temporal.PlainMonthDay':
 				case 'Temporal.PlainYearMonth':
 				case 'Temporal.ZonedDateTime':
-					str = `["${type}",${stringify_string(thing.toString())}]`;
+					str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
 					break;
 
-				default:
-					if (!is_plain_object(thing)) {
-						throw new DevalueError(
-							`Cannot stringify arbitrary non-POJOs`,
-							keys,
-							thing,
-							value
-						);
+				default: {
+					const shape = ops.shapeOf(thing);
+
+					if (shape.kind === 'not-plain') {
+						throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
 					}
 
-					if (enumerable_symbols(thing).length > 0) {
-						throw new DevalueError(
-							`Cannot stringify POJOs with symbolic keys`,
-							keys,
-							thing,
-							value
-						);
+					if (shape.kind === 'symbol-keys') {
+						throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
 					}
 
-					if (Object.getPrototypeOf(thing) === null) {
+					if (shape.kind === 'null-proto') {
 						str = '["null"';
-						for (const key of Object.keys(thing)) {
+						for (const key of shape.keys) {
 							if (key === '__proto__') {
 								throw new DevalueError(
 									`Cannot stringify objects with __proto__ keys`,
@@ -295,14 +378,14 @@ export function stringify(value, reducers) {
 							}
 
 							keys.push(stringify_key(key));
-							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
 							keys.pop();
 						}
 						str += ']';
 					} else {
 						str = '{';
 						let started = false;
-						for (const key of Object.keys(thing)) {
+						for (const key of shape.keys) {
 							if (key === '__proto__') {
 								throw new DevalueError(
 									`Cannot stringify objects with __proto__ keys`,
@@ -315,11 +398,12 @@ export function stringify(value, reducers) {
 							if (started) str += ',';
 							started = true;
 							keys.push(stringify_key(key));
-							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
 							keys.pop();
 						}
 						str += '}';
 					}
+				}
 			}
 		}
 
@@ -332,7 +416,7 @@ export function stringify(value, reducers) {
 	// special case — value is represented as a negative index
 	if (index < 0) return `${index}`;
 
-	return `[${stringified.join(',')}]`;
+	return stringified;
 }
 
 /**
@@ -342,7 +426,6 @@ export function stringify(value, reducers) {
 function stringify_primitive(thing) {
 	const type = typeof thing;
 	if (type === 'string') return stringify_string(thing);
-	if (thing instanceof String) return stringify_string(thing.toString());
 	if (thing === void 0) return UNDEFINED.toString();
 	if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
 	if (type === 'bigint') return `["BigInt","${thing}"]`;