@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/value/clone.ts

@@ -1,319 +0,0 @@
-import {isArrayOrPlainObject, isTypedArray} from '../internal/is';
-import {getSelfHandlers} from '../internal/value/handlers';
-import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../models';
-
-// #region Special variables
-
-const CLONE_NAME = 'clone';
-
-// #endregion
-
-// #region Functions
-
-/**
- * Clone any kind of value _(shallowly)_
- *
- * @param value Value to clone
- * @param flat Clone only the value itself, without cloning nested values
- * @returns Cloned value
- */
-export function clone<Value>(value: Value, flat: true): Value;
-
-/**
- * Clone any kind of value _(deeply, if needed)_
- *
- * @param value Value to clone
- * @returns Cloned value
- */
-export function clone<Value>(value: Value): Value;
-
-export function clone(value: unknown, flat?: boolean): unknown {
-	return flat === true ? copy(value) : cloneValue(value, 0, new WeakMap(), false);
-}
-
-clone.handlers = getSelfHandlers(clone, {
-	callback: tryStructuredClone,
-	method: CLONE_NAME,
-});
-
-clone.deregister = deregisterCloner;
-clone.register = registerCloner;
-
-function cloneArrayBuffer(
-	value: ArrayBuffer,
-	depth?: number,
-	references?: WeakMap<WeakKey, unknown>,
-): ArrayBuffer {
-	if (typeof depth === 'number' && depth >= MAX_CLONE_DEPTH) {
-		return value;
-	}
-
-	const cloned = new ArrayBuffer(value.byteLength);
-
-	new Uint8Array(cloned).set(new Uint8Array(value));
-
-	references?.set(value, cloned);
-
-	return cloned;
-}
-
-function cloneDataView(
-	value: DataView,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-): DataView {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return value;
-	}
-
-	const buffer = cloneArrayBuffer(value.buffer as ArrayBuffer);
-
-	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
-
-	references.set(value, cloned);
-
-	return cloned;
-}
-
-function cloneMap(
-	map: Map<unknown, unknown>,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-	flat: boolean,
-): Map<unknown, unknown> {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return map;
-	}
-
-	const cloned = new Map<unknown, unknown>();
-	const entries = map.entries();
-
-	for (const entry of entries) {
-		cloned.set(
-			flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false),
-			flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false),
-		);
-	}
-
-	references.set(map, cloned);
-
-	return cloned;
-}
-
-function cloneNode(node: Node, depth: number, references: WeakMap<WeakKey, unknown>): Node {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return node;
-	}
-
-	const cloned = node.cloneNode(true);
-
-	references.set(node, cloned);
-
-	return cloned;
-}
-
-function cloneObject(
-	value: ArrayOrPlainObject,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-	flat: boolean,
-): ArrayOrPlainObject {
-	if (flat || depth >= MAX_CLONE_DEPTH) {
-		return Array.isArray(value) ? value.slice() : {...value};
-	}
-
-	const cloned = (Array.isArray(value) ? [] : {}) as PlainObject;
-	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-	const {length} = keys;
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-
-		cloned[key] = cloneValue((value as PlainObject)[key], depth + 1, references, false);
-	}
-
-	references.set(value, cloned);
-
-	return cloned;
-}
-
-function cloneRegularExpression(
-	value: RegExp,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-): RegExp {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return value;
-	}
-
-	const cloned = new RegExp(value.source, value.flags);
-
-	cloned.lastIndex = value.lastIndex;
-
-	references.set(value, cloned);
-
-	return cloned;
-}
-
-function cloneSet(
-	set: Set<unknown>,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-	flat: boolean,
-): Set<unknown> {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return set;
-	}
-
-	const cloned = new Set<unknown>();
-	const values = [...set.values()];
-	const {length} = values;
-
-	for (let index = 0; index < length; index += 1) {
-		cloned.add(flat ? values[index] : cloneValue(values[index], depth + 1, references, false));
-	}
-
-	references.set(set, cloned);
-
-	return cloned;
-}
-
-function cloneTypedArray(
-	value: TypedArray,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-): TypedArray {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return value;
-	}
-
-	const cloned = new (value.constructor as new (...args: unknown[]) => TypedArray)(value);
-
-	references.set(value, cloned);
-
-	return cloned as TypedArray;
-}
-
-function cloneValue(
-	value: unknown,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-	flat: boolean,
-): unknown {
-	switch (true) {
-		case value == null:
-		case typeof value === 'bigint':
-		case typeof value === 'boolean':
-		case typeof value === 'number':
-		case typeof value === 'string':
-			return value;
-
-		case typeof value === 'function':
-			return;
-
-		case typeof value === 'symbol':
-			return Symbol(value.description);
-
-		case references.has(value as object):
-			return references.get(value);
-
-		case value instanceof ArrayBuffer:
-			return cloneArrayBuffer(value, depth, references);
-
-		case value instanceof DataView:
-			return cloneDataView(value, depth, references);
-
-		case value instanceof Date:
-			return new Date(value.getTime());
-
-		case value instanceof RegExp:
-			return cloneRegularExpression(value, depth, references);
-
-		case value instanceof Map:
-			return cloneMap(value, depth, references, flat);
-
-		case typeof Node !== 'undefined' && value instanceof Node:
-			return cloneNode(value, depth, references);
-
-		case value instanceof Set:
-			return cloneSet(value, depth, references, flat);
-
-		case isArrayOrPlainObject(value):
-			return cloneObject(value, depth, references, flat);
-
-		case isTypedArray(value):
-			return cloneTypedArray(value, depth, references);
-
-		default:
-			return clone.handlers.handle(value, depth, references);
-	}
-}
-
-/**
- * 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
- */
-export function copy<Value>(value: Value): Value {
-	return cloneValue(value, 0, new WeakMap(), true) as Value;
-}
-
-/**
- * Deregister a clone handler for a specific class
- *
- * _Available as `deregisterCloner` and `template.deregister`_
- *
- * @param constructor Class constructor
- */
-export function deregisterCloner<Instance>(constructor: Constructor<Instance>): void {
-	clone.handlers.deregister(constructor);
-}
-
-/**
- * Register a clone handler for a specific class
- *
- * _Available as `registerCloner` and `template.register`_
- *
- * @param constructor Class constructor
- * @param handler Method name or clone function _(defaults to method name `clone`)_
- */
-export function registerCloner<Instance>(
-	constructor: Constructor<Instance>,
-	handler?: string | ((value: Instance) => Instance),
-): void {
-	clone.handlers.register(constructor, handler);
-}
-
-function tryStructuredClone(
-	value: object,
-	depth: number,
-	references: WeakMap<WeakKey, unknown>,
-): unknown {
-	if (depth >= MAX_CLONE_DEPTH) {
-		return value;
-	}
-
-	try {
-		const cloned = structuredClone(value);
-
-		references.set(value, cloned);
-
-		return cloned;
-	} catch {
-		references.set(value, value);
-
-		return value;
-	}
-}
-
-// #endregion
-
-// #region Variables
-
-const MAX_CLONE_DEPTH = 100;
-
-// #endregion

package/src/value/collection.ts

@@ -1,63 +0,0 @@
-import {equal} from '../internal/value/equal';
-
-/**
- * Does the value exist for a key in a _Map_?
- *
- * @param map _Map_ to check in
- * @param value Value to check for
- * @returns `true` if the value exists, otherwise `false`
- */
-export function inMap<Value>(map: Map<unknown, Value>, value: Value): boolean;
-
-/**
- * Does the value exist for a key in a _Map_?
- *
- * @param map _Map_ to check in
- * @param value Value to check for
- * @param key To return the key for the value
- * @returns The key for the value if it exists, otherwise `undefined`
- */
-export function inMap<Key, Value>(map: Map<Key, Value>, value: Value, key: true): Key;
-
-export function inMap<Key, Value>(map: Map<Key, Value>, value: Value, key?: unknown): unknown {
-	const getKey = key === true;
-
-	if (!(map instanceof Map)) {
-		return getKey ? undefined : false;
-	}
-
-	if (!getKey) {
-		return inSet(new Set(map.values()), value);
-	}
-
-	for (const [key, item] of map) {
-		if (equal(item, value)) {
-			return key;
-		}
-	}
-}
-
-/**
- * Does the value exist in a _Set_?
- *
- * @param set _Set_ to check in
- * @param value Value to check for
- * @returns `true` if the value exists, otherwise `false`
- */
-export function inSet<Value>(set: Set<Value>, value: Value): boolean {
-	if (!(set instanceof Set)) {
-		return false;
-	}
-
-	if (set.has(value)) {
-		return true;
-	}
-
-	for (const item of set) {
-		if (equal(item, value)) {
-			return true;
-		}
-	}
-
-	return false;
-}

package/src/value/diff.ts

@@ -1,232 +0,0 @@
-import {isArrayOrPlainObject} from '../internal/is';
-import {join} from '../internal/string';
-import {equal} from '../internal/value/equal';
-
-// #region Types
-
-/**
- * Options for value comparison
- */
-export type DiffOptions = {
-	/**
-	 * Should `null` and `undefined` be considered equal and ignored in results?
-	 */
-	relaxedNullish?: boolean;
-};
-
-/**
- * The result of a comparison beteen two values
- */
-export type DiffResult<First, Second = First> = {
-	/**
-	 * The original values that were compared
-	 */
-	original: DiffValue<First, Second>;
-	/**
-	 * The type of difference between the two values
-	 */
-	type: DiffType;
-	/**
-	 * The differences between the two values
-	 *
-	 * - Keys are in dot notation
-	 * - Values are objects with `from` and `to` properties
-	 */
-	values: Record<string, DiffValue>;
-};
-
-type DiffType = 'full' | 'none' | 'partial';
-
-/**
- * The difference between two values
- */
-export type DiffValue<First = unknown, Second = First> = {
-	/**
-	 * The value from the first value
-	 */
-	from: First;
-	/**
-	 * The value from the second value
-	 */
-	to: Second;
-};
-
-type KeyedDiffValue = {
-	key: string;
-} & DiffValue;
-
-type Parameters = {
-	changes: KeyedDiffValue[];
-	key: PropertyKey;
-	options: Required<DiffOptions>;
-	values: {first: unknown; second: unknown};
-	prefix?: string;
-};
-
-// #endregion
-
-// #region Functions
-
-/**
- * Find the differences between two values
- *
- * @param first First value
- * @param second Second value
- * @param options Comparison options
- * @returns Difference result
- */
-export function diff<First, Second = First>(
-	first: First,
-	second: Second,
-	options?: DiffOptions,
-): DiffResult<First, Second> {
-	const relaxedNullish = typeof options === 'object' && options?.relaxedNullish === true;
-
-	const diffResult: DiffResult<First, Second> = {
-		original: {
-			from: first,
-			to: second,
-		},
-		type: DIFF_PARTIAL,
-		values: {},
-	};
-
-	const same = (relaxedNullish && first == null && second == null) || Object.is(first, second);
-
-	const firstIsArrayOrObject = isArrayOrPlainObject(first);
-	const secondIsArrayOrObject = isArrayOrPlainObject(second);
-
-	if (same || !(firstIsArrayOrObject || secondIsArrayOrObject)) {
-		diffResult.type = same ? DIFF_NONE : DIFF_FULL;
-
-		return diffResult;
-	}
-
-	if (firstIsArrayOrObject !== secondIsArrayOrObject) {
-		diffResult.type = DIFF_FULL;
-
-		return diffResult;
-	}
-
-	const diffs = getDiffs(first, second, {relaxedNullish});
-
-	const {length} = diffs;
-
-	if (length === 0) {
-		diffResult.type = DIFF_NONE;
-	}
-
-	for (let index = 0; index < length; index += 1) {
-		const differences = diffs[index];
-
-		diffResult.values[differences.key] = {from: differences.from, to: differences.to};
-	}
-
-	return diffResult;
-}
-
-function getChanges(
-	changes: KeyedDiffValue[],
-	first: unknown,
-	second: unknown,
-	options: Required<DiffOptions>,
-	prefix?: string,
-): KeyedDiffValue[] {
-	const checked = new Set<PropertyKey>();
-
-	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
-		const value = (outerIndex === 0 ? first : second) ?? {};
-
-		const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-
-		const {length} = keys;
-
-		for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
-			const key = keys[innerIndex];
-
-			if (checked.has(key)) {
-				continue;
-			}
-
-			checked.add(key);
-
-			setChanges({
-				changes,
-				key,
-				options,
-				prefix,
-				values: {first, second},
-			});
-		}
-	}
-
-	return changes;
-}
-
-function getDiffs(
-	first: unknown,
-	second: unknown,
-	options: Required<DiffOptions>,
-	prefix?: string,
-): KeyedDiffValue[] {
-	const changes: KeyedDiffValue[] = [];
-
-	if (Array.isArray(first) && Array.isArray(second)) {
-		const maximumLength = Math.max(first.length, second.length);
-		const minimumLength = Math.min(first.length, second.length);
-
-		for (let index = minimumLength; index < maximumLength; index += 1) {
-			const key = join([prefix, index], '.');
-
-			changes.push({
-				key,
-				from: index >= first.length ? undefined : first[index],
-				to: index >= first.length ? second[index] : undefined,
-			});
-		}
-	}
-
-	return getChanges(changes, first, second, options, prefix);
-}
-
-function setChanges(parameters: Parameters): void {
-	const {changes, key, prefix, options, values} = parameters;
-
-	const prefixed = join([prefix, key], '.');
-
-	const from: unknown = values.first?.[key as never];
-	const to: unknown = values.second?.[key as never];
-
-	const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
-	const diffs = nested ? getDiffs(from, to, options, prefixed) : [];
-
-	if (nested ? diffs.length === 0 : equal(from, to, options)) {
-		return;
-	}
-
-	const change = {
-		from,
-		to,
-		key: prefixed,
-	};
-
-	changes.push(change);
-
-	const diffsLength = diffs.length;
-
-	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) {
-		changes.push(diffs[diffIndex]);
-	}
-}
-
-// #endregion
-
-// #region Variables
-
-const DIFF_FULL: DiffType = 'full';
-
-const DIFF_NONE: DiffType = 'none';
-
-const DIFF_PARTIAL: DiffType = 'partial';
-
-// #endregion