@oscarpalmer/atoms 0.167.0 → 0.169.0

package/src/internal/value/equal.ts

@@ -1,5 +1,5 @@
+import {isPrimitive} from '../is';
 import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../../models';
-import {chunk} from '../array/chunk';
 import {isPlainObject, isTypedArray} from '../is';
 import {getCompareHandlers} from './handlers';
 
@@ -122,21 +122,11 @@ function equalArray(first: unknown[], second: unknown[], options: Options): bool
 		}
 	}
 
-	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const end = length - offset;
 
-	const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
-
-	const chunksLength = firstChunks.length;
-
-	for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
-		const firstChunk = firstChunks[chunkIndex];
-		const secondChunk = secondChunks[chunkIndex];
-		const chunkLength = firstChunk.length;
-
-		for (let index = 0; index < chunkLength; index += 1) {
-			if (!equalValue(firstChunk[index], secondChunk[index], options)) {
-				return false;
-			}
+	for (let index = offset; index < end; index += 1) {
+		if (!equalValue(first[index], second[index], options)) {
+			return false;
 		}
 	}
 
@@ -167,16 +157,11 @@ function equalMap(
 	}
 
 	const firstKeys = [...first.keys()];
-	const secondKeys = [...second.keys()];
-
-	if (firstKeys.some(key => !secondKeys.includes(key))) {
-		return false;
-	}
 
 	for (let index = 0; index < size; index += 1) {
 		const key = firstKeys[index];
 
-		if (!equalValue(first.get(key), second.get(key), options)) {
+		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) {
 			return false;
 		}
 	}
@@ -197,16 +182,22 @@ function equalPlainObject(
 		secondKeys = secondKeys.filter(key => filterKey(key, options));
 	}
 
+	const useSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET;
+	const secondSet = useSet ? new Set(secondKeys) : undefined;
+
 	const {length} = firstKeys;
 
-	if (length !== secondKeys.length || firstKeys.some(key => !secondKeys.includes(key))) {
+	if (length !== secondKeys.length) {
 		return false;
 	}
 
 	for (let index = 0; index < length; index += 1) {
 		const key = firstKeys[index];
 
-		if (!equalValue(first[key as never], second[key as never], options)) {
+		if (
+			!(secondSet?.has(key) ?? secondKeys.includes(key)) ||
+			!equalValue(first[key as never], second[key as never], options)
+		) {
 			return false;
 		}
 	}
@@ -246,7 +237,11 @@ function equalSet(first: Set<unknown>, second: Set<unknown>, options: Options):
 	for (let index = 0; index < size; index += 1) {
 		const firstValue = firstValues[index];
 
-		if (!secondValues.some(secondValue => equalValue(firstValue, secondValue, options))) {
+		if (
+			isPrimitive(firstValue)
+				? !second.has(firstValue)
+				: !secondValues.some(secondValue => equalValue(firstValue, secondValue, options))
+		) {
 			return false;
 		}
 	}
@@ -439,4 +434,6 @@ const ERROR_PROPERTIES: string[] = ['name', 'message'];
 
 const EXPRESSION_PROPERTIES: string[] = ['source', 'flags'];
 
+const MINIMUM_LENGTH_FOR_SET = 16;
+
 // #endregion

package/src/is.ts

@@ -88,21 +88,10 @@ export function isObject(value: unknown): value is object {
 	return (typeof value === 'object' && value !== null) || typeof value === 'function';
 }
 
-/**
- * - Is the value a primitive value?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
-export function isPrimitive(value: unknown): value is Primitive {
-	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
-}
-
 // #endregion
 
 // #region Variables
 
-const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
-
 const EXPRESSION_WHITESPACE = /^\s*$/;
 
 // #endregion
@@ -116,6 +105,7 @@ export {
 	isKey,
 	isNumber,
 	isPlainObject,
+	isPrimitive,
 	isTypedArray,
 } from './internal/is';
 

package/src/sized/map.ts

@@ -17,7 +17,7 @@ export class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<Size
 	 * Is the Map full?
 	 */
 	get full(): boolean {
-		return this.size >= this.#maximumSize;
+		return super.size >= this.#maximumSize;
 	}
 
 	get maximum(): number {
@@ -75,26 +75,32 @@ export class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<Size
 	 * @inheritdoc
 	 */
 	override get(key: SizedKey): SizedValue | undefined {
-		const value = super.get(key);
+		if (super.has(key)) {
+			const value = super.get(key) as SizedValue;
 
-		if (value !== undefined || this.has(key)) {
-			this.set(key, value as SizedValue);
-		}
+			this.#setValue(key, value, true);
 
-		return value;
+			return value;
+		}
 	}
 
 	/**
 	 * @inheritdoc
 	 */
 	override set(key: SizedKey, value: SizedValue): this {
-		if (this.has(key)) {
-			this.delete(key);
-		} else if (this.size >= this.#maximumSize) {
-			this.delete(this.keys().next().value as SizedKey);
+		return this.#setValue(key, value, super.has(key));
+	}
+
+	#setValue(key: SizedKey, value: SizedValue, has: boolean): this {
+		if (has) {
+			super.delete(key);
+		} else if (super.size >= this.#maximumSize) {
+			super.delete(super.keys().next().value as SizedKey);
 		}
 
-		return super.set(key, value);
+		super.set(key, value);
+
+		return this;
 	}
 }
 

package/src/sized/set.ts

@@ -71,10 +71,10 @@ export class SizedSet<Value = unknown> extends Set<Value> {
 	 * @inheritdoc
 	 */
 	override add(value: Value): this {
-		if (this.has(value)) {
-			this.delete(value);
+		if (super.has(value)) {
+			super.delete(value);
 		} else if (this.size >= this.#maximumSize) {
-			this.delete(this.values().next().value as Value);
+			super.delete(this.values().next().value as Value);
 		}
 
 		return super.add(value);
@@ -87,9 +87,10 @@ export class SizedSet<Value = unknown> extends Set<Value> {
 	 * @returns Found value if it exists, otherwise `undefined`
 	 */
 	get(value: Value, update?: boolean): Value | undefined {
-		if (this.has(value)) {
+		if (super.has(value)) {
 			if (update ?? false) {
-				this.delete(value);
+				super.delete(value);
+
 				this.add(value);
 			}
 

package/src/value/clone.ts

@@ -86,36 +86,28 @@ function cloneDataView(
 	return cloned;
 }
 
-function cloneMapOrSet<Value extends Map<unknown, unknown> | Set<unknown>>(
-	value: Value,
+function cloneMap(
+	map: Map<unknown, unknown>,
 	depth: number,
 	references: WeakMap<WeakKey, unknown>,
-): Value {
+): Map<unknown, unknown> {
 	if (depth >= MAX_CLONE_DEPTH) {
-		return value;
+		return map;
 	}
 
-	const isMap = value instanceof Map;
-	const cloned = isMap ? new Map<unknown, unknown>() : new Set<unknown>();
-	const entries = [...value.entries()];
-	const {length} = entries;
+	const cloned = new Map<unknown, unknown>();
+	const entries = map.entries();
 
-	for (let index = 0; index < length; index += 1) {
-		const entry = entries[index];
-
-		if (isMap) {
-			(cloned as Map<unknown, unknown>).set(
-				cloneValue(entry[0], depth + 1, references),
-				cloneValue(entry[1], depth + 1, references),
-			);
-		} else {
-			(cloned as Set<unknown>).add(cloneValue(entry[0], depth + 1, references));
-		}
+	for (const entry of entries) {
+		cloned.set(
+			cloneValue(entry[0], depth + 1, references),
+			cloneValue(entry[1], depth + 1, references),
+		);
 	}
 
-	references.set(value, cloned);
+	references.set(map, cloned);
 
-	return cloned as Value;
+	return cloned;
 }
 
 function cloneNode(node: Node, depth: number, references: WeakMap<WeakKey, unknown>): Node {
@@ -172,6 +164,28 @@ function cloneRegularExpression(
 	return cloned;
 }
 
+function cloneSet(
+	set: Set<unknown>,
+	depth: number,
+	references: WeakMap<WeakKey, unknown>,
+): 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(cloneValue(values[index], depth + 1, references));
+	}
+
+	references.set(set, cloned);
+
+	return cloned;
+}
+
 function cloneTypedArray(
 	value: TypedArray,
 	depth: number,
@@ -227,12 +241,14 @@ function cloneValue(value: unknown, depth: number, references: WeakMap<WeakKey,
 			return cloneRegularExpression(value, depth, references);
 
 		case value instanceof Map:
-		case value instanceof Set:
-			return cloneMapOrSet(value, depth, references);
+			return cloneMap(value, depth, references);
 
 		case value instanceof Node:
 			return cloneNode(value, depth, references);
 
+		case value instanceof Set:
+			return cloneSet(value, depth, references);
+
 		case isArrayOrPlainObject(value):
 			return clonePlainObject(value, depth, references);
 

package/src/value/diff.ts

@@ -57,8 +57,8 @@ type KeyedDiffValue = {
 type Parameters = {
 	changes: KeyedDiffValue[];
 	key: PropertyKey;
+	options: Required<DiffOptions>;
 	values: {first: unknown; second: unknown};
-	relaxedNullish: boolean;
 	prefix?: string;
 };
 
@@ -106,7 +106,7 @@ export function diff<First, Second = First>(
 		return diffResult;
 	}
 
-	const diffs = getDiffs(first, second, relaxedNullish);
+	const diffs = getDiffs(first, second, {relaxedNullish});
 
 	const {length} = diffs;
 
@@ -127,7 +127,7 @@ function getChanges(
 	changes: KeyedDiffValue[],
 	first: unknown,
 	second: unknown,
-	relaxedNullish: boolean,
+	options: Required<DiffOptions>,
 	prefix?: string,
 ): KeyedDiffValue[] {
 	const checked = new Set<PropertyKey>();
@@ -151,7 +151,7 @@ function getChanges(
 			setChanges({
 				changes,
 				key,
-				relaxedNullish,
+				options,
 				prefix,
 				values: {first, second},
 			});
@@ -164,7 +164,7 @@ function getChanges(
 function getDiffs(
 	first: unknown,
 	second: unknown,
-	relaxedNullish: boolean,
+	options: Required<DiffOptions>,
 	prefix?: string,
 ): KeyedDiffValue[] {
 	const changes: KeyedDiffValue[] = [];
@@ -184,31 +184,30 @@ function getDiffs(
 		}
 	}
 
-	return getChanges(changes, first, second, relaxedNullish, prefix);
+	return getChanges(changes, first, second, options, prefix);
 }
 
 function setChanges(parameters: Parameters): void {
-	const {changes, key, prefix, relaxedNullish, values} = parameters;
+	const {changes, key, prefix, options, values} = parameters;
 
-	const from = values.first?.[key as never];
-	const to = values.second?.[key as never];
+	const prefixed = join([prefix, key], '.');
+
+	const from: unknown = values.first?.[key as never];
+	const to: unknown = values.second?.[key as never];
 
-	if (equal(from, to, {relaxedNullish})) {
+	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 prefixed = join([prefix, key], '.');
-
 	const change = {
 		from,
 		to,
 		key: prefixed,
 	};
 
-	const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
-
-	const diffs = nested ? getDiffs(from, to, relaxedNullish, prefixed) : [];
-
 	changes.push(change);
 
 	const diffsLength = diffs.length;