@oscarpalmer/atoms 0.197.0 → 0.199.0

package/dist/value/clone.mjs

@@ -1,35 +1,24 @@
 import { isArrayOrPlainObject, isTypedArray } from "../internal/is.mjs";
-import { getSelfHandlers } from "../internal/value/handlers.mjs";
+import { createSelfHandlers } from "../internal/value/handlers.mjs";
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
 function clone(value, options) {
+	return cloneAny(value, { copy: false }, 0, options);
+}
+function cloneAny(value, parameters, depth, options) {
 	switch (true) {
-		case value === null:
-		case value === void 0:
-		case typeof value === "bigint":
-		case typeof value === "boolean":
-		case typeof value === "number":
-		case typeof value === "string": return value;
+		case value === null || CLONE_PRIMITIVES[typeof value]: return value;
 		case value instanceof Date: return new Date(value.getTime());
-		default: return cloneAny(value, getCloneParameters(options), 0);
+		case typeof value === "function":
+			parameters.options ??= createCloneOptions(options);
+			return parameters.options.copyFunctions ? value : void 0;
+		case typeof value === "symbol":
+			parameters.options ??= createCloneOptions(options);
+			return parameters.options.copySymbols ? value : Symbol(value.description);
 	}
-}
-clone.handlers = getSelfHandlers(clone, {
-	callback: tryStructuredClone,
-	method: CLONE_NAME
-});
-clone.deregister = deregisterCloner;
-clone.register = registerCloner;
-function cloneAny(value, parameters, depth) {
+	parameters.options ??= createCloneOptions(options);
+	parameters.references ??= /* @__PURE__ */ new WeakMap();
 	switch (true) {
-		case value == null:
-		case typeof value === "bigint":
-		case typeof value === "boolean":
-		case typeof value === "number":
-		case typeof value === "string": return value;
-		case value instanceof Date: return new Date(value.getTime());
-		case typeof value === "function": return parameters.options?.copyFunctions ? value : void 0;
-		case typeof value === "symbol": return parameters.options?.copySymbols ? value : Symbol(value.description);
 		case parameters.references.has(value): return parameters.references.get(value);
 		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, parameters, depth);
 		case value instanceof DataView: return cloneDataView(value, parameters, depth);
@@ -39,18 +28,18 @@ function cloneAny(value, parameters, depth) {
 		case value instanceof Set: return cloneSet(value, parameters, depth);
 		case isArrayOrPlainObject(value): return cloneObject(value, parameters, depth);
 		case isTypedArray(value): return cloneTypedArray(value, parameters, depth);
-		default: return clone.handlers.handle(value, parameters, depth);
+		default: return parameters.copy ? value : clone.handlers.handle(value, parameters, depth);
 	}
 }
 function cloneArrayBuffer(value, parameters, depth) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
 	parameters.references.set(value, cloned);
 	return cloned;
 }
 function cloneDataView(value, parameters, depth) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const buffer = cloneArrayBuffer(value.buffer, parameters, depth);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
 	parameters.references.set(value, cloned);
@@ -58,22 +47,22 @@ function cloneDataView(value, parameters, depth) {
 }
 function cloneMap(map, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return map;
-	const flat = parameters.options?.flat;
+	if (parameters.copy) return new Map(map);
 	const cloned = /* @__PURE__ */ new Map();
-	const entries = map.entries();
-	for (const entry of entries) cloned.set(flat ? entry[0] : cloneAny(entry[0], parameters, depth + 1), flat ? entry[1] : cloneAny(entry[1], parameters, depth + 1));
+	for (const [key, value] of map.entries()) cloned.set(cloneAny(key, parameters, depth + 1), cloneAny(value, parameters, depth + 1));
 	parameters.references.set(map, cloned);
 	return cloned;
 }
 function cloneNode(node, parameters, depth) {
-	if (depth >= CLONE_MAX_DEPTH) return node;
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
 	parameters.references.set(node, cloned);
 	return cloned;
 }
 function cloneObject(value, parameters, depth) {
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const isArray = Array.isArray(value);
-	if (parameters.options?.flat || depth >= CLONE_MAX_DEPTH) return isArray ? value.slice() : { ...value };
+	if (parameters.copy) return isArray ? value.slice() : { ...value };
 	const cloned = isArray ? [] : {};
 	const keys = isArray ? void 0 : Object.keys(value);
 	const { length } = keys ?? value;
@@ -85,7 +74,7 @@ function cloneObject(value, parameters, depth) {
 	return cloned;
 }
 function cloneRegularExpression(value, parameters, depth) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
 	parameters.references.set(value, cloned);
@@ -93,30 +82,31 @@ function cloneRegularExpression(value, parameters, depth) {
 }
 function cloneSet(set, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return set;
+	if (parameters.copy) return new Set(set);
 	const cloned = /* @__PURE__ */ new Set();
-	const values = [...set.values()];
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) cloned.add(parameters.options?.flat ? values[index] : cloneAny(values[index], parameters, depth + 1));
+	for (const value of set.values()) cloned.add(cloneAny(value, parameters, depth + 1));
 	parameters.references.set(set, cloned);
 	return cloned;
 }
 function cloneTypedArray(value, parameters, depth) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
 	parameters.references.set(value, cloned);
 	return cloned;
 }
-/**
-* Copy any kind of value
-*
-* - Clones the value shallowly, without cloning nested values
-* - To copy a value deeply, use `clone` instead
-*
-* @param value Value to copy
-* @returns Copied value
-*/
 function copy(value) {
-	return clone(value, CLONE_COPY_OPTIONS);
+	return cloneAny(value, {
+		copy: true,
+		options: CLONE_COPY_OPTIONS,
+		references: void 0
+	}, 0);
+}
+function createCloneOptions(input) {
+	if (typeof input !== "object" || input === null) return CLONE_DEFAULT_OPTIONS;
+	return {
+		copyFunctions: input.copyFunctions === true,
+		copySymbols: input.copySymbols === true
+	};
 }
 /**
 * Deregister a clone handler for a specific class
@@ -128,24 +118,29 @@ function copy(value) {
 function deregisterCloner(constructor) {
 	clone.handlers.deregister(constructor);
 }
-function getCloneOptions(input) {
-	if (typeof input === "boolean") return {
-		copyFunctions: false,
-		copySymbols: false,
-		flat: input === true
-	};
-	if (typeof input !== "object" || input === null) return CLONE_DEFAULT_OPTIONS;
-	return {
-		copyFunctions: input.copyFunctions === true,
-		copySymbols: input.copySymbols === true,
-		flat: input.flat === true
-	};
-}
-function getCloneParameters(input) {
-	return {
-		options: getCloneOptions(input),
-		references: /* @__PURE__ */ new WeakMap()
-	};
+/**
+* Create a cloner with predefined options
+*
+* _Available as `initializeCloner` and `clone.initialize`_
+*
+* @param options Clone options
+* @returns Cloner function
+*/
+function initializeCloner(options) {
+	const opts = createCloneOptions(options);
+	function cloner(value) {
+		return cloneAny(value, {
+			copy: false,
+			options: opts
+		}, 0);
+	}
+	cloner.deregister = deregisterCloner;
+	cloner.register = registerCloner;
+	Object.defineProperties(cloner, {
+		deregister: { value: deregisterCloner },
+		register: { value: registerCloner }
+	});
+	return cloner;
 }
 /**
 * Register a clone handler for a specific class
@@ -162,23 +157,45 @@ function tryStructuredClone(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
-		parameters.references?.set(value, cloned);
+		parameters.references.set(value, cloned);
 		return cloned;
 	} catch {
-		parameters.references?.set(value, value);
+		parameters.references.set(value, value);
 		return value;
 	}
 }
 const CLONE_COPY_OPTIONS = {
 	copyFunctions: true,
-	copySymbols: true,
-	flat: true
+	copySymbols: true
 };
 const CLONE_DEFAULT_OPTIONS = {
 	copyFunctions: false,
-	copySymbols: false,
-	flat: false
+	copySymbols: false
 };
 const CLONE_MAX_DEPTH = 100;
+const cloneHandlers = createSelfHandlers(clone, {
+	callback: tryStructuredClone,
+	method: CLONE_NAME
+});
+const CLONE_PRIMITIVES = {
+	bigint: true,
+	boolean: true,
+	function: false,
+	number: true,
+	object: false,
+	string: true,
+	symbol: false,
+	undefined: true
+};
+clone.deregister = deregisterCloner;
+clone.handlers = cloneHandlers;
+clone.initialize = initializeCloner;
+clone.register = registerCloner;
+Object.defineProperties(clone, {
+	deregister: { value: deregisterCloner },
+	handlers: { value: cloneHandlers },
+	initialize: { value: initializeCloner },
+	register: { value: registerCloner }
+});
 //#endregion
-export { clone, copy, deregisterCloner, registerCloner };
+export { clone, copy, deregisterCloner, initializeCloner, registerCloner };

package/dist/value/merge.mjs

@@ -9,11 +9,11 @@ import { isArrayOrPlainObject } from "../internal/is.mjs";
 * @returns Assigned value
 */
 function assign(to, from, options) {
-	const actual = getMergeOptions(options);
+	const actual = createMergeOptions(options);
 	actual.assignValues = true;
 	return mergeValues([to, ...from], actual);
 }
-function getMergeOptions(options) {
+function createMergeOptions(options) {
 	const actual = {
 		assignValues: false,
 		replaceableObjects: void 0,
@@ -40,7 +40,7 @@ function getReplaceableObjects(value) {
 * @returns Assigner function
 */
 function initializeAssigner(options) {
-	const actual = getMergeOptions(options);
+	const actual = createMergeOptions(options);
 	actual.assignValues = true;
 	return ((to, from) => mergeValues([to, ...from], actual));
 }
@@ -53,7 +53,7 @@ function initializeAssigner(options) {
 * @returns Merger function
 */
 function initializeMerger(options) {
-	const actual = getMergeOptions(options);
+	const actual = createMergeOptions(options);
 	return ((values) => mergeValues(values, actual));
 }
 /**
@@ -64,7 +64,7 @@ function initializeMerger(options) {
 * @returns Merged value
 */
 function merge(values, options) {
-	return mergeValues(values, getMergeOptions(options));
+	return mergeValues(values, createMergeOptions(options));
 }
 function mergeObjects(values, options, destination, prefix) {
 	const { length } = values;

package/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.197.0",
+	"version": "0.199.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
+		"clone",
 		"color",
 		"helper",
 		"observable",
@@ -282,7 +283,7 @@
 		"@vitest/coverage-istanbul": "^4.1",
 		"eslint": "^10.9",
 		"jsdom": "^30",
-		"tsdown": "^0.22",
+		"tsdown": "^0.23",
 		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
 		"vite-plus": "latest",