@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/value/freeze.ts

@@ -1,322 +0,0 @@
-import {noop} from '../function';
-import {isPlainObject} from '../internal/is';
-import type {PlainObject} from '../models';
-
-// #region Types
-
-/**
- * A frozen value with readonly properties _(going as deep as possible)_
- */
-export type Frozen<Value> = Value extends unknown[]
-	? Readonly<Value>
-	: Value extends PlainObject
-		? {
-				readonly [Key in keyof Value]: Frozen<Value[Key]>;
-			}
-		: Value extends Map<infer Key, infer Value>
-			? ReadonlyMap<Key, Frozen<Value>>
-			: Value extends Set<infer Item>
-				? ReadonlySet<Frozen<Item>>
-				: Readonly<Value>;
-
-// #endregion
-
-// #region Functions
-
-function fakeDelete(): boolean {
-	return false;
-}
-
-/**
- * Freeze an array and its indiced values, but not any nested values
- *
- * _Available as `flatFreeze` and `freeze.flat`_
- *
- * @param array Array to freeze
- * @returns Frozen array
- */
-export function flatFreeze<Item>(array: Item[]): ReadonlyArray<Item>;
-
-/**
- * Freeze a map and its values, but not any nested values
- *
- * _Available as `flatFreeze` and `freeze.flat`_
- *
- * @param map Map to freeze
- * @returns Frozen map
- */
-export function flatFreeze<Key, Value>(map: Map<Key, Value>): ReadonlyMap<Key, Value>;
-
-/**
- * Freeze an object and its properties, but not any nested values
- *
- * _Available as `flatFreeze` and `freeze.flat`_
- *
- * @param object Object to freeze
- * @returns Frozen object
- */
-export function flatFreeze<Value extends PlainObject>(object: Value): Readonly<Value>;
-
-/**
- * Freeze a set and its values, but not any nested values
- *
- * _Available as `flatFreeze` and `freeze.flat`_
- *
- * @param set Set to freeze
- * @returns Frozen set
- */
-export function flatFreeze<Item>(set: Set<Item>): ReadonlySet<Item>;
-
-/**
- * Freeze any value, if possible
- *
- * _(Only arrays, maps, plain objects, and sets are freezable)_
- *
- * _Available as `flatFreeze` and `freeze.flat`_
- *
- * @param value Value to freeze
- * @returns Frozen value
- */
-export function flatFreeze<Value>(value: Value): Value;
-
-export function flatFreeze(value: unknown): unknown {
-	return freezeValue(value, new WeakSet(), true);
-}
-
-/**
- * Freeze an array and its values _(but not any nested values)_, preventing modifications
- *
- * @param array Array to freeze
- * @param flat Freeze _only_ the array, not any nested values
- * @returns Frozen array
- */
-export function freeze<Item>(array: Item[], flat: true): ReadonlyArray<Item>;
-
-/**
- * Freeze a map and its values _(but not any nested values)_, preventing modifications
- *
- * @param map Map to freeze
- * @param flat Freeze _only_ the map, not any nested values
- * @returns Frozen map
- */
-export function freeze<Key, Value>(map: Map<Key, Value>, flat: true): ReadonlyMap<Key, Value>;
-
-/**
- * Freeze an object and its properties _(but not any nested values)_, preventing modifications
- *
- * @param object Object to freeze
- * @param flat Freeze _only_ the object, not any nested values
- * @returns Frozen object
- */
-export function freeze<Value extends PlainObject>(object: Value, flat: true): Readonly<Value>;
-
-/**
- * Freeze a set and its values _(but not any nested values)_, preventing modifications
- *
- * @param set Set to freeze
- * @param flat Freeze _only_ the set, not any nested values
- * @returns Frozen set
- */
-export function freeze<Item>(set: Set<Item>, flat: true): ReadonlySet<Item>;
-
-/**
- * Freeze an array and its values recursively, preventing modifications
- *
- * _(If you only want to freeze the array itself, but not any nested values, use `freeze(array, true)`, `freeze.flat(array)`, or `flatFreeze(array)` instead)_
- *
- * @param array Array to freeze
- * @returns Frozen array
- */
-export function freeze<Item>(array: Item[]): Frozen<Item[]>;
-
-/**
- * Freeze a map and its values recursively, preventing modifications
- *
- * _(If you only want to freeze the map itself, but not any nested values, use `freeze(map, true)`, `freeze.flat(map)`, or `flatFreeze(map)` instead)_
- *
- * @param map Map to freeze
- * @returns Frozen map
- */
-export function freeze<Key, Value>(map: Map<Key, Value>): Frozen<Map<Key, Value>>;
-
-/**
- * Freeze an object and all its properties recursively
- *
- * _(If you only want to freeze the object itself, but not any nested values, use `freeze(object, true)`, `freeze.flat(object)`, or `flatFreeze(object)` instead)_
- *
- * @param object Object to freeze
- * @returns Frozen object
- */
-export function freeze<Value extends PlainObject>(object: Value): Frozen<Value>;
-
-/**
- * Freeze a set and its values recursively
- *
- * _(If you only want to freeze the set itself, but not any nested values, use `freeze(set, true)`, `freeze.flat(set)`, or `flatFreeze(set)` instead)_
- *
- * @param set Set to freeze
- * @returns Frozen set
- */
-export function freeze<Item>(set: Set<Item>): Frozen<Set<Item>>;
-
-/**
- * Freeze any value, if possible
- *
- * _(Only arrays, maps, plain objects, and sets are freezable)_
- *
- * @param value Value to freeze
- * @returns Frozen value
- */
-export function freeze<Value>(value: Value): Value;
-
-export function freeze(value: unknown, flat?: unknown): unknown {
-	return freezeValue(value, new WeakSet(), flat === true);
-}
-
-freeze.flat = flatFreeze;
-freeze.is = isFrozen;
-
-function freezeArray(array: unknown[], references: WeakSet<any>, flat: boolean): Frozen<unknown[]> {
-	if (flat) {
-		return Object.freeze(array) as Frozen<unknown[]>;
-	}
-
-	references.add(array);
-
-	const {length} = array;
-
-	for (let index = 0; index < length; index += 1) {
-		const value = array[index];
-
-		if (!references.has(value)) {
-			array[index] = freezeValue(array[index], references, false);
-		}
-	}
-
-	return Object.freeze(array) as Frozen<unknown[]>;
-}
-
-function freezeMap(
-	map: Map<unknown, unknown>,
-	references: WeakSet<any>,
-	flat: boolean,
-): ReadonlyMap<unknown, unknown> {
-	frozenValues.add(map);
-
-	map.clear = noop;
-	map.delete = fakeDelete;
-	map.set = () => map;
-
-	if (flat) {
-		return map as ReadonlyMap<unknown, unknown>;
-	}
-
-	references.add(map);
-
-	const entries = map.entries();
-
-	for (const [key, value] of entries) {
-		if (!references.has(value)) {
-			map.set(key, freezeValue(value, references, false));
-		}
-	}
-
-	return map as ReadonlyMap<unknown, unknown>;
-}
-
-function freezeObject(
-	object: PlainObject,
-	references: WeakSet<any>,
-	flat: boolean,
-): Frozen<PlainObject> {
-	if (flat) {
-		return Object.freeze(object) as Frozen<PlainObject>;
-	}
-
-	references.add(object);
-
-	const keys = Object.keys(object);
-	const {length} = keys;
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-
-		if (!references.has(object[key])) {
-			object[key] = freezeValue(object[key], references, false);
-		}
-	}
-
-	return Object.freeze(object) as Frozen<PlainObject>;
-}
-
-function freezeSet(
-	set: Set<unknown>,
-	references: WeakSet<any>,
-	flat: boolean,
-): ReadonlySet<unknown> {
-	frozenValues.add(set);
-
-	set.clear = noop;
-	set.delete = fakeDelete;
-	set.add = () => set;
-
-	if (flat) {
-		return set as ReadonlySet<unknown>;
-	}
-
-	references.add(set);
-
-	const values = set.values();
-
-	for (const value of values) {
-		if (!references.has(value)) {
-			set.add(freezeValue(value, references, false));
-		}
-	}
-
-	return set as ReadonlySet<unknown>;
-}
-
-function freezeValue(value: unknown, references: WeakSet<any>, flat: boolean): unknown {
-	switch (true) {
-		case isFrozen(value):
-			return value;
-
-		case value instanceof Map:
-			return freezeMap(value, references, flat);
-
-		case value instanceof Set:
-			return freezeSet(value, references, flat);
-
-		case Array.isArray(value):
-			return freezeArray(value, references, flat);
-
-		case isPlainObject(value):
-			return freezeObject(value, references, flat);
-
-		default:
-			return value;
-	}
-}
-
-/**
- * Is the value frozen?
- *
- * @param value Value to check
- * @returns `true` if the value is frozen, otherwise `false`
- */
-export function isFrozen(value: unknown): boolean {
-	if (value instanceof Map || value instanceof Set) {
-		return frozenValues.has(value);
-	}
-
-	return typeof value === 'object' && value !== null && Object.isFrozen(value);
-}
-
-// #endregion
-
-// #region Variables
-
-const frozenValues = new WeakSet();
-
-// #endregion

package/src/value/handle.ts

@@ -1,3 +0,0 @@
-export {getValue} from '../internal/value/get';
-export {hasValue} from '../internal/value/has';
-export {setValue} from '../internal/value/set';

package/src/value/index.ts

@@ -1,5 +0,0 @@
-export {omit} from './omit';
-export {pick} from './pick';
-export {shake, type Shaken} from './shake';
-export {smush, type Smushed} from './smush';
-export {unsmush, type Unsmushed} from './unsmush';

package/src/value/merge.ts

@@ -1,278 +0,0 @@
-import {isArrayOrPlainObject} from '../internal/is';
-import type {ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection} from '../models';
-
-// #region Types
-
-/**
- * Options for assigning values
- */
-export type AssignOptions = Omit<MergeOptions, 'assignValues'>;
-
-/**
- * An assigner function for assigning values from one or more objects to the first one
- */
-export type Assigner = {
-	/**
-	 * Assign values from one or more objects to the first one
-	 *
-	 * @param to Value to assign to
-	 * @param from Values to assign
-	 * @returns Assigned value
-	 */
-	<To extends PlainObject, From extends PlainObject[]>(
-		to: To,
-		from: [...From],
-	): To & UnionToIntersection<From[number]>;
-};
-
-/**
- * Options for merging values
- */
-export type MergeOptions = {
-	/**
-	 * Assign values to the first array or object instead of creating a new one?
-	 */
-	assignValues?: boolean;
-	/**
-	 * Key _(or key epxressions)_ for values that should be replaced
-	 *
-	 * ```ts
-	 * merge([{items: [1, 2, 3]}, {items: [99]}]); // => {items: [99]}
-	 * ```
-	 */
-	replaceableObjects?: string | RegExp | Array<string | RegExp>;
-	/**
-	 * Skip nullable values when merging objects?
-	 *
-	 * ```ts
-	 * merge({a: 1, b: 2}, {b: null, c: 3}, {d: null}); // => {a: 1, b: 2, c: 3}
-	 * ```
-	 */
-	skipNullableAny?: boolean;
-	/**
-	 * Skip nullable values when merging arrays?
-	 *
-	 * ```ts
-	 * merge([1, 2, 3], [null, null, 99]); // => [1, 2, 99]
-	 * ```
-	 */
-	skipNullableInArrays?: boolean;
-};
-
-/**
- * A merger function for merging multiple arrays or objects into a single one
- */
-export type Merger = {
-	/**
-	 * Merge multiple arrays or objects into a single one
-	 *
-	 * @param values Values to merge
-	 * @returns Merged value
-	 */
-	<Values extends ArrayOrPlainObject[]>(
-		values: NestedPartial<Values[number]>[],
-	): UnionToIntersection<Values[number]>;
-};
-
-type Options = {
-	assignValues: boolean;
-	replaceableObjects: ReplaceableObjectsCallback | undefined;
-	skipNullableAny: boolean;
-	skipNullableInArrays: boolean;
-};
-
-type ReplaceableObjectsCallback = (name: string) => boolean;
-
-// #endregion
-
-// #region Functions
-
-/**
- * Assign values from one or more objects to the first one
- *
- * @param to Value to assign to
- * @param from Values to assign
- * @param options Assigning options
- * @returns Assigned value
- */
-export function assign<To extends PlainObject, From extends PlainObject[]>(
-	to: To,
-	from: [...From],
-	options?: AssignOptions,
-): To & UnionToIntersection<From[number]> {
-	const actual = getMergeOptions(options);
-
-	actual.assignValues = true;
-
-	return mergeValues([to, ...from], actual) as To & UnionToIntersection<From[number]>;
-}
-
-assign.initialize = initializeAssigner;
-
-function getMergeOptions(options?: MergeOptions): Options {
-	const actual: Options = {
-		assignValues: false,
-		replaceableObjects: undefined,
-		skipNullableAny: false,
-		skipNullableInArrays: false,
-	};
-
-	if (typeof options !== 'object' || options == null) {
-		return actual;
-	}
-
-	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
-
-	actual.assignValues = options.assignValues === true;
-	actual.skipNullableAny = options.skipNullableAny === true;
-	actual.skipNullableInArrays = options.skipNullableInArrays === true;
-
-	return actual;
-}
-
-function getReplaceableObjects(value: unknown): ReplaceableObjectsCallback | undefined {
-	const items = (Array.isArray(value) ? value : [value]).filter(
-		item => typeof item === 'string' || item instanceof RegExp,
-	);
-
-	if (items.length > 0) {
-		return (name: string) =>
-			items.some(item => (typeof item === 'string' ? item === name : item.test(name)));
-	}
-}
-
-/**
- * Create an assigner with predefined options
- *
- * _Available as `initializeAssigner` and `assign.initialize`_
- *
- * @param options Assigning options
- * @returns Assigner function
- */
-export function initializeAssigner(options?: AssignOptions): Assigner {
-	const actual = getMergeOptions(options);
-
-	actual.assignValues = true;
-
-	return ((to: PlainObject, from: PlainObject[]): PlainObject =>
-		mergeValues([to, ...from], actual) as PlainObject) as Assigner;
-}
-
-/**
- * Create a merger with predefined options
- *
- * _Available as `initializeMerger` and `merge.initialize`_
- *
- * @param options Merging options
- * @returns Merger function
- */
-export function initializeMerger(options?: MergeOptions): Merger {
-	const actual = getMergeOptions(options);
-
-	return ((values: NestedPartial<ArrayOrPlainObject>[]): ArrayOrPlainObject =>
-		mergeValues(values, actual)) as Merger;
-}
-
-/**
- * Merge multiple arrays or objects into a single one
- *
- * @param values Values to merge
- * @param options Merging options
- * @returns Merged value
- */
-export function merge<Values extends ArrayOrPlainObject[]>(
-	values: [...Values],
-	options?: MergeOptions,
-): UnionToIntersection<Values[number]> {
-	return mergeValues(values, getMergeOptions(options)) as UnionToIntersection<Values[number]>;
-}
-
-merge.initialize = initializeMerger;
-
-function mergeObjects(
-	values: ArrayOrPlainObject[],
-	options: Options,
-	destination?: ArrayOrPlainObject,
-	prefix?: string,
-): ArrayOrPlainObject {
-	const {length} = values;
-
-	const isArray = Array.isArray(destination ?? values[0]);
-	const merged = (destination ?? (isArray ? [] : {})) as PlainObject;
-
-	const offset = destination == null ? 0 : 1;
-
-	for (let outerIndex = offset; outerIndex < length; outerIndex += 1) {
-		const item = values[outerIndex] as PlainObject;
-		const keys = Object.keys(item);
-		const size = keys.length;
-
-		for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
-			const key = keys[innerIndex];
-
-			const next = item[key];
-			const previous = merged[key];
-
-			if (next == null && (options.skipNullableAny || (isArray && options.skipNullableInArrays))) {
-				continue;
-			}
-
-			const full =
-				options.replaceableObjects == null ? undefined : prefix == null ? key : `${prefix}.${key}`;
-
-			if (
-				isArrayOrPlainObject(next) &&
-				isArrayOrPlainObject(previous) &&
-				!(options.replaceableObjects?.(full!) ?? false)
-			) {
-				merged[key] = mergeObjects(
-					[previous, next],
-					options,
-					(destination == null ? undefined : merged[key]) as ArrayOrPlainObject,
-					full,
-				);
-			} else {
-				merged[key] = next;
-			}
-		}
-	}
-
-	return merged;
-}
-
-function mergeValues(
-	values: ArrayOrPlainObject[],
-	options: Options,
-	prefix?: string,
-): ArrayOrPlainObject {
-	if (!Array.isArray(values)) {
-		return {};
-	}
-
-	const actual = values.filter(isArrayOrPlainObject);
-
-	if (actual.length === 0) {
-		return {};
-	}
-
-	if (
-		options.assignValues &&
-		actual.length === 2 &&
-		!Array.isArray(actual[0]) &&
-		Object.keys(actual[0]).length === 0
-	) {
-		return Object.assign(actual[0], actual[1]);
-	}
-
-	if (actual.length > 1) {
-		return mergeObjects(actual, options, options.assignValues ? actual[0] : undefined, prefix);
-	}
-
-	return options.assignValues
-		? actual[0]
-		: Array.isArray(actual[0])
-			? actual[0].slice()
-			: {...actual[0]};
-}
-
-// #endregion

package/src/value/omit.ts

@@ -1,20 +0,0 @@
-import {partial} from '../internal/value/partial';
-import type {PlainObject} from '../models';
-
-// #region Functions
-
-/**
- * Create a new object without the specified keys
- *
- * @param value Original object
- * @param keys Keys to omit
- * @returns Partial object without the specified keys
- */
-export function omit<Value extends PlainObject, ValueKey extends keyof Value>(
-	value: Value,
-	keys: ValueKey[],
-): Omit<Value, ValueKey> {
-	return partial(value, keys, true);
-}
-
-// #endregion

package/src/value/pick.ts

@@ -1,20 +0,0 @@
-import {partial} from '../internal/value/partial';
-import type {PlainObject} from '../models';
-
-// #region Functions
-
-/**
- * Create a new object with only the specified keys
- *
- * @param value Original object
- * @param keys Keys to use
- * @returns Partial object with only the specified keys
- */
-export function pick<Value extends PlainObject, ValueKey extends keyof Value>(
-	value: Value,
-	keys: ValueKey[],
-): Pick<Value, ValueKey> {
-	return partial(value, keys, false);
-}
-
-// #endregion

package/src/value/shake.ts

@@ -1,45 +0,0 @@
-import {isNonPlainObject} from '../internal/is';
-import type {PlainObject} from '../models';
-
-// #region Types
-
-/**
- * A shaken object, without any `undefined` values
- */
-export type Shaken<Value extends PlainObject> = {
-	[Key in keyof Value]: Value[Key] extends undefined ? never : Value[Key];
-};
-
-// #endregion
-
-// #region Functions
-
-/**
- * Shake an object, removing all keys with `undefined` values
- *
- * @param value Object to shake
- * @returns Shaken object
- */
-export function shake<Value extends PlainObject>(value: Value): Shaken<Value> {
-	const shaken: PlainObject = {};
-
-	if (isNonPlainObject(value)) {
-		return shaken as Shaken<Value>;
-	}
-
-	const keys = Object.keys(value) as (keyof Value)[];
-	const {length} = keys;
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const val = value[key];
-
-		if (val !== undefined) {
-			shaken[key] = val;
-		}
-	}
-
-	return shaken as Shaken<Value>;
-}
-
-// #endregion