@oscarpalmer/atoms 0.193.0 → 0.193.1

package/src/internal/value/equal.ts

@@ -1,465 +0,0 @@
-import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../../models';
-import {isNonPlainObject, isPlainObject, isPrimitive, isTypedArray} from '../is';
-import {getCompareHandlers} from './handlers';
-
-// #region Types
-
-/**
- * Options for value equality comparison
- */
-export type EqualOptions = {
-	/**
-	 * When `true`, strings are compared case-insensitively
-	 */
-	ignoreCase?: boolean;
-	/**
-	 * Keys _(or key expressions)_ to ignore when comparing objects
-	 */
-	ignoreKeys?: string | RegExp | Array<string | RegExp>;
-	/**
-	 * Should `null` and `undefined` be considered equal?
-	 */
-	relaxedNullish?: boolean;
-};
-
-/**
- * An equalizer function for comparing values for equality, with predefined options
- *
- * Can be used to compare values, and register or deregister equality comparison handlers for specific classes
- */
-type Equalizer = {
-	/**
-	 * Are two strings equal?
-	 *
-	 * @param first First string
-	 * @param second Second string
-	 * @param ignoreCase If `true`, comparison will be case-insensitive
-	 * @returns `true` if the strings are equal, otherwise `false`
-	 */
-	(first: string, second: string, ignoreCase?: boolean): boolean;
-
-	/**
-	 * Are two values equal?
-	 *
-	 * @param first First value
-	 * @param second Second value
-	 * @returns `true` if the values are equal, otherwise `false`
-	 */
-	(first: unknown, second: unknown): boolean;
-
-	/**
-	 * Deregister a equality comparison handler for a specific class
-	 *
-	 * @param constructor Class constructor
-	 */
-	deregister: <Instance>(constructor: Constructor<Instance>) => void;
-
-	/**
-	 * Register a equality comparison function for a specific class
-	 *
-	 * @param constructor Class constructor
-	 * @param handler Comparison function
-	 */
-	register: <Instance>(
-		constructor: Constructor<Instance>,
-		handler: (first: Instance, second: Instance) => boolean,
-	) => void;
-};
-
-type Options = {
-	ignoreCase: boolean;
-	ignoreExpressions: OptionsKeys<RegExp[]>;
-	ignoreKeys: OptionsKeys<Set<string>>;
-	relaxedNullish: boolean;
-};
-
-type OptionsKeys<Values> = {
-	enabled: boolean;
-	values: Values;
-};
-
-// #endregion
-
-// #region Functions
-
-/**
- * Deregister a equality comparison handler for a specific class
- *
- * _Available as `deregisterEqualizer` and `equal.deregister`_
- *
- * @param constructor Class constructor
- */
-export function deregisterEqualizer<Instance>(constructor: Constructor<Instance>): void {
-	equal.handlers.deregister(constructor);
-}
-
-function filterKey(key: string | symbol, options: Options): boolean {
-	if (typeof key !== 'string') {
-		return true;
-	}
-
-	if (
-		options.ignoreExpressions.enabled &&
-		options.ignoreExpressions.values.some(expression => expression.test(key))
-	) {
-		return false;
-	}
-
-	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) {
-		return false;
-	}
-
-	return true;
-}
-
-/**
- * Are two strings equal?
- *
- * @param first First string
- * @param second Second string
- * @param ignoreCase If `true`, comparison will be case-insensitive
- * @returns `true` if the strings are equal, otherwise `false`
- */
-export function equal(first: string, second: string, ignoreCase?: boolean): boolean;
-
-/**
- * Are two values equal?
- *
- * @param first First value
- * @param second Second value
- * @param options Comparison options
- * @returns `true` if the values are equal, otherwise `false`
- */
-export function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
-
-export function equal(first: unknown, second: unknown, options?: boolean | EqualOptions): boolean {
-	return equalValue(first, second, getEqualOptions(options));
-}
-
-equal.handlers = getCompareHandlers<boolean>(equal, {
-	callback: Object.is,
-});
-
-equal.deregister = deregisterEqualizer;
-equal.initialize = initializeEqualizer;
-equal.register = registerEqualizer;
-
-function equalArray(first: unknown[], second: unknown[], options: Options): boolean {
-	const {length} = first;
-
-	if (length !== second.length) {
-		return false;
-	}
-
-	let offset = 0;
-
-	if (length >= EQUAL_ARRAY_THRESHOLD) {
-		offset = Math.round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
-		offset = offset > EQUAL_ARRAY_THRESHOLD ? EQUAL_ARRAY_THRESHOLD : offset;
-
-		for (let index = 0; index < offset; index += 1) {
-			if (
-				!(
-					equalValue(first[index], second[index], options) &&
-					equalValue(first[length - index - 1], second[length - index - 1], options)
-				)
-			) {
-				return false;
-			}
-		}
-	}
-
-	const end = length - offset;
-
-	for (let index = offset; index < end; index += 1) {
-		if (!equalValue(first[index], second[index], options)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function equalArrayBuffer(first: ArrayBuffer, second: ArrayBuffer, options: Options): boolean {
-	return first.byteLength === second.byteLength
-		? equalArray(new Uint8Array(first) as never, new Uint8Array(second) as never, options)
-		: false;
-}
-
-function equalDataView(first: DataView, second: DataView, options: Options): boolean {
-	return first.byteOffset === second.byteOffset
-		? equalArrayBuffer(first.buffer as ArrayBuffer, second.buffer as ArrayBuffer, options)
-		: false;
-}
-
-function equalMap(
-	first: Map<unknown, unknown>,
-	second: Map<unknown, unknown>,
-	options: Options,
-): boolean {
-	const {size} = first;
-
-	if (size !== second.size) {
-		return false;
-	}
-
-	const firstKeys = [...first.keys()];
-
-	for (let index = 0; index < size; index += 1) {
-		const key = firstKeys[index];
-
-		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function equalPlainObject(
-	first: ArrayOrPlainObject,
-	second: ArrayOrPlainObject,
-	options: Options,
-): boolean {
-	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
-	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
-
-	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
-		firstKeys = firstKeys.filter(key => filterKey(key, options));
-		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) {
-		return false;
-	}
-
-	for (let index = 0; index < length; index += 1) {
-		const key = firstKeys[index];
-
-		if (
-			!(secondSet?.has(key) ?? secondKeys.includes(key)) ||
-			!equalValue(first[key as never], second[key as never], options)
-		) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function equalProperties(
-	first: object,
-	second: object,
-	properties: string[],
-	options: Options,
-): boolean {
-	const {length} = properties;
-
-	for (let index = 0; index < length; index += 1) {
-		const property = properties[index];
-
-		if (!equalValue((first as PlainObject)[property], (second as PlainObject)[property], options)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function equalSet(first: Set<unknown>, second: Set<unknown>, options: Options): boolean {
-	const {size} = first;
-
-	if (size !== second.size) {
-		return false;
-	}
-
-	const firstValues = [...first];
-	const secondValues = [...second];
-
-	for (let index = 0; index < size; index += 1) {
-		const firstValue = firstValues[index];
-
-		if (
-			isPrimitive(firstValue)
-				? !second.has(firstValue)
-				: !secondValues.some(secondValue => equalValue(firstValue, secondValue, options))
-		) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function equalTypedArray(first: TypedArray, second: TypedArray): boolean {
-	if (first.constructor !== second.constructor) {
-		return false;
-	}
-
-	if (first.byteLength !== second.byteLength) {
-		return false;
-	}
-
-	const {length} = first;
-
-	for (let index = 0; index < length; index += 1) {
-		if (first[index] !== second[index]) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function equalValue(first: unknown, second: unknown, options: Options): boolean {
-	if (options.relaxedNullish && first == null && second == null) {
-		return true;
-	}
-
-	switch (true) {
-		case Object.is(first, second):
-			return true;
-
-		case first == null || second == null:
-			return first === second;
-
-		case typeof first !== typeof second:
-			return false;
-
-		case typeof first === 'string' && options.ignoreCase === true:
-			return Object.is(first.toLocaleLowerCase(), (second as string).toLocaleLowerCase());
-
-		case first instanceof ArrayBuffer && second instanceof ArrayBuffer:
-			return equalArrayBuffer(first, second, options);
-
-		case first instanceof Date && second instanceof Date:
-			return Object.is(first.getTime(), (second as Date).getTime());
-
-		case first instanceof DataView && second instanceof DataView:
-			return equalDataView(first, second, options);
-
-		case first instanceof Error && second instanceof Error:
-			return equalProperties(first, second, ERROR_PROPERTIES, options);
-
-		case first instanceof Map && second instanceof Map:
-			return equalMap(first, second, options);
-
-		case first instanceof RegExp && second instanceof RegExp:
-			return equalProperties(first, second, EXPRESSION_PROPERTIES, options);
-
-		case first instanceof Set && second instanceof Set:
-			return equalSet(first, second, options);
-
-		case Array.isArray(first) && Array.isArray(second):
-			return equalArray(first, second, options);
-
-		case isPlainObject(first) && isPlainObject(second):
-			return equalPlainObject(first, second, options);
-
-		case isTypedArray(first) && isTypedArray(second):
-			return equalTypedArray(first as TypedArray, second as TypedArray);
-
-		default:
-			return equal.handlers.handle(first, second, options);
-	}
-}
-
-function getEqualOptions(input?: boolean | EqualOptions): Options {
-	const options: Options = {
-		ignoreCase: false,
-		ignoreExpressions: {
-			enabled: false,
-			values: [],
-		},
-		ignoreKeys: {
-			enabled: false,
-			values: new Set(),
-		},
-		relaxedNullish: false,
-	};
-
-	if (typeof input === 'boolean') {
-		options.ignoreCase = input;
-
-		return options;
-	}
-
-	if (isNonPlainObject(input)) {
-		return options;
-	}
-
-	options.ignoreCase = typeof input.ignoreCase === 'boolean' ? input.ignoreCase : false;
-
-	options.ignoreExpressions.values = (
-		Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]
-	).filter(key => key instanceof RegExp);
-
-	options.ignoreKeys.values = new Set(
-		(Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter(
-			key => typeof key === 'string',
-		),
-	);
-
-	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
-
-	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
-
-	options.relaxedNullish = input.relaxedNullish === true;
-
-	return options;
-}
-
-/**
- * Create an equalizer with predefined options
- *
- * _Available as `initializeEqualizer` and `equal.initialize`_
- *
- * @param options Comparison options
- * @returns Equalizer function
- */
-export function initializeEqualizer(options?: EqualOptions): Equalizer {
-	const actual = getEqualOptions(options);
-
-	const equalizer = (first: unknown, second: unknown): boolean => equalValue(first, second, actual);
-
-	equalizer.deregister = deregisterEqualizer;
-	equalizer.register = registerEqualizer;
-
-	return equalizer;
-}
-
-/**
- * Register a equality comparison function for a specific class
- *
- * _Available as `registerEqualizer` and `equal.register`_
- *
- * @param constructor Class constructor
- * @param handler Comparison function
- */
-export function registerEqualizer<Instance>(
-	constructor: Constructor<Instance>,
-	handler: (first: Instance, second: Instance) => boolean,
-): void {
-	equal.handlers.register(constructor, handler);
-}
-
-// #endregion
-
-// #region Variables
-
-const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
-
-const EQUAL_ARRAY_THRESHOLD = 100;
-
-const ERROR_PROPERTIES: string[] = ['name', 'message'];
-
-const EXPRESSION_PROPERTIES: string[] = ['source', 'flags'];
-
-const MINIMUM_LENGTH_FOR_SET = 16;
-
-// #endregion

package/src/internal/value/get.ts

@@ -1,57 +0,0 @@
-import type {NestedKeys, NestedValue, PlainObject} from '../../models';
-import type {Ok} from '../../result/models';
-import {getNestedValue} from './misc';
-
-// #region Functions
-
-/**
- * Get the value from an object using a known path
- *
- * @param data Object to get value from
- * @param path Path for value
- * @returns Found value, or `undefined`
- *
- * @example
- * ```typescript
- * const data = {foo: {bar: {baz: 42}}};
- *
- * getValue(data, 'foo');         // => {bar: {baz: 42}}
- * getValue(data, 'foo.bar');     // => {baz: 42}
- * getValue(data, 'foo.bar.baz'); // => 42
- * getValue(data, 'foo.nope');    // => undefined
- * ```
- */
-export function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(
-	data: Data,
-	path: Path,
-): NestedValue<Data, Path>;
-
-/**
- * Get the value from an object using an unknown path
- *
- * @param data Object to get value from
- * @param path Path for value
- * @param ignoreCase If `true`, path matching is case-insensitive
- * @returns Found value, or `undefined`
- *
- * @example
- * ```typescript
- * const data = {foo: {bar: {baz: 42}}};
- *
- * getValue(data, 'foo');               // => {bar: {baz: 42}}
- * getValue(data, 'foo.bar');           // => {baz: 42}
- * getValue(data, 'Foo.Bar.Baz', true); // => 42
- * getValue(data, 'foo.nope');          // => undefined
- * ```
- */
-export function getValue<Data extends PlainObject>(
-	data: Data,
-	path: string,
-	ignoreCase?: boolean,
-): unknown;
-
-export function getValue(data: PlainObject, path: string, ignoreCase?: boolean): unknown {
-	return (getNestedValue(data, path, ignoreCase === true) as Ok<unknown>).value;
-}
-
-// #endregion

package/src/internal/value/handlers.ts

@@ -1,95 +0,0 @@
-import type {Constructor, GenericCallback} from '../../models';
-import {isNonConstructor} from '../is';
-
-type Options = {
-	callback: GenericCallback;
-	method?: string;
-};
-
-export function getCompareHandlers<Value>(owner: GenericCallback, options: Options) {
-	const handlers = getHandlers(owner, options);
-
-	return {
-		deregister(constructor: Constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(first: unknown, second: unknown, ...parameters: unknown[]): Value {
-			const handler = handlers.get(first, second);
-
-			if (handler == null) {
-				return options.callback(first, second, ...parameters);
-			}
-
-			return typeof handler === 'function'
-				? handler(first, second)
-				: (first as any)[handler](second);
-		},
-		register(constructor: Constructor, handler?: string | GenericCallback) {
-			handlers.register(constructor, handler);
-		},
-	};
-}
-
-function getHandlers(owner: GenericCallback, options: Options) {
-	const handlers = new WeakMap<Constructor, string | GenericCallback>();
-
-	return {
-		deregister(constructor: Constructor) {
-			handlers.delete(constructor);
-		},
-		get(first: unknown, second: unknown): string | GenericCallback | undefined {
-			if (
-				isConstructable(first) &&
-				isConstructable(second) &&
-				(first as object).constructor === (second as object).constructor
-			) {
-				return handlers.get((first as object).constructor as Constructor);
-			}
-		},
-		register(constructor: Constructor, handler?: string | GenericCallback) {
-			if (isNonConstructor(constructor) || handler === owner) {
-				return;
-			}
-
-			let actual: string | GenericCallback | undefined = handler ?? options.method;
-
-			if (typeof actual !== 'function' && typeof actual !== 'string') {
-				return;
-			}
-
-			if (typeof actual === 'string') {
-				actual = typeof constructor.prototype[actual] === 'function' ? actual : undefined;
-			}
-
-			if (actual != null) {
-				handlers.set(constructor, actual);
-			}
-		},
-	};
-}
-
-export function getSelfHandlers(owner: GenericCallback, options: Options) {
-	const handlers = getHandlers(owner, options);
-
-	return {
-		deregister(constructor: Constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(value: unknown, ...parameters: unknown[]) {
-			const handler = handlers.get(value, value);
-
-			if (handler == null) {
-				return options.callback(value, ...parameters);
-			}
-
-			return typeof handler === 'function' ? handler(value) : (value as any)[handler]();
-		},
-		register(constructor: Constructor, handler?: string | GenericCallback) {
-			handlers.register(constructor, handler);
-		},
-	};
-}
-
-function isConstructable(value: unknown): boolean {
-	return typeof value === 'object' && value !== null;
-}