@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/internal/sized.ts

@@ -1,25 +0,0 @@
-// #region Functions
-
-import {clamp} from './number';
-
-export function getSizedMaximum(first?: unknown, second?: unknown): number {
-	let actual: number;
-
-	if (typeof first === 'number') {
-		actual = first;
-	} else {
-		actual = typeof second === 'number' ? second : MAXIMUM_DEFAULT;
-	}
-
-	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
-}
-
-// #endregion
-
-// #region Variables
-
-const MAXIMUM_ABSOLUTE = 16_777_216; // 2^24
-
-const MAXIMUM_DEFAULT = 1_048_576; // 2^20
-
-// #endregion

package/src/internal/string.ts

@@ -1,128 +0,0 @@
-// #region Functions
-
-/**
- * Get the string value from any value
- *
- * @param value Original value
- * @returns String representation of the value
- *
- * @example
- * ```typescript
- * getString(null)       // => ''
- * getString('foo')      // => 'foo'
- * getString(123)        // => '123'
- * getString(true)       // => 'true'
- * getString([1, 2, 3])  // => '1,2,3'
- * getString({a: 1})     // => '{"a":1}'
- * getString(() => 123)  // => '123'
- * ```
- */
-export function getString(value: unknown): string {
-	if (typeof value === 'string') {
-		return value;
-	}
-
-	if (value == null) {
-		return '';
-	}
-
-	if (typeof value === 'function') {
-		return getString(value());
-	}
-
-	if (typeof value !== 'object') {
-		return String(value);
-	}
-
-	const asString = String(value.valueOf?.() ?? value);
-
-	return asString.startsWith('[object ') ? JSON.stringify(value) : asString;
-}
-
-export function ignoreKey(key: string): boolean {
-	return EXPRESSION_IGNORED.test(key);
-}
-
-export function interpolate(strings: TemplateStringsArray, values: unknown[]): string {
-	const {length} = strings;
-
-	let interpolated = '';
-
-	for (let index = 0; index < length; index += 1) {
-		const value = values[index];
-
-		interpolated += `${strings[index]}${Array.isArray(value) ? join(value.map(getString)) : getString(value)}`;
-	}
-
-	return interpolated;
-}
-
-/**
- * Join an array of values into a string _(while ignoring empty values)_
- *
- * _(`null`, `undefined`, and any values that become whitespace-only strings are considered empty)_
- *
- * @param array Array of values
- * @param delimiter Delimiter to use between values
- * @returns Joined string
- */
-export function join(array: unknown[], delimiter?: string): string {
-	if (!Array.isArray(array)) {
-		return '';
-	}
-
-	const {length} = array;
-
-	if (length === 0) {
-		return '';
-	}
-
-	const values: string[] = [];
-
-	for (let index = 0; index < length; index += 1) {
-		const item = getString(array[index]);
-
-		if (item.length > 0) {
-			values.push(item);
-		}
-	}
-
-	return values.join(typeof delimiter === 'string' ? delimiter : '');
-}
-
-function tryCallback<T, U>(value: T, callback: (value: T) => U): U {
-	try {
-		return callback(value);
-	} catch {
-		return value as never;
-	}
-}
-
-export function tryDecode(value: string): string {
-	return tryCallback(value, decodeURIComponent);
-}
-
-export function tryEncode(value: boolean | number | string): unknown {
-	return tryCallback(value, encodeURIComponent);
-}
-
-/**
- * Split a string into words _(and other readable parts)_
- *
- * @param value Original string
- * @returns Array of words found in the string
- */
-export function words(value: string): string[] {
-	return typeof value === 'string' ? (value.match(EXPRESSION_WORDS) ?? []) : [];
-}
-
-// #endregion
-
-// #region Variables
-
-const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-
-// oxlint-disable-next-line no-control-regex: Lodash uses it, so it's fine ;-)
-const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
-
-// #endregion

package/src/internal/subscription.ts

@@ -1,264 +0,0 @@
-import type {Key} from '../models';
-import {isPlainObject} from './is';
-
-// #region Types
-
-export type Subscription = {
-	/**
-	 * Is the subscription active?
-	 */
-	get active(): boolean;
-
-	/**
-	 * Unsubscribe from changes
-	 */
-	unsubscribe(): void;
-};
-
-export type SubscriptionParameters = {
-	isActive?: () => boolean;
-	key?: Key;
-	property: SubscriptionProperty;
-	subscriptions: Subscriptions;
-	value: unknown;
-};
-
-export type SubscriptionProperty = {
-	key: string;
-	value: unknown;
-};
-
-type SubscriptionState = {
-	active: boolean;
-	parameters: SubscriptionParameters;
-};
-
-export type Subscriptions<Value = unknown> = {
-	items: SubscriptionsItems;
-	keys?: Set<Key>;
-	values: SubscriptionsValues<Value>;
-};
-
-type SubscriptionsItems = {
-	any: Set<Subscription>;
-	keyed?: Map<Key, Set<Subscription>>;
-};
-
-type SubscriptionsValues<Value = unknown> = {
-	from: SubscriptionsValuesItem<Value, Subscription>;
-	to: SubscriptionsValuesItem<Subscription, Value>;
-};
-
-type SubscriptionsValuesItem<MapKey, MapValue> = {
-	any: Map<MapKey, MapValue>;
-	keyed?: Map<Key, Map<MapKey, MapValue>>;
-};
-
-// #endregion
-
-// #region Functions
-
-function addSubscription(subscription: Subscription, state: SubscriptionState): void {
-	const {key, subscriptions, value} = state.parameters;
-	const {items, values} = subscriptions;
-
-	if (key == null) {
-		items.any.add(subscription);
-		values.from.any.set(value, subscription);
-		values.to.any.set(subscription, value);
-
-		return;
-	}
-
-	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null) {
-		// TODO: fix tests or document
-		// istanbul ignore next
-		return;
-	}
-
-	let keyedItems = items.keyed.get(key);
-
-	if (keyedItems == null) {
-		keyedItems = new Set();
-
-		items.keyed.set(key, keyedItems);
-	}
-
-	keyedItems.add(subscription);
-
-	let keyedFrom = values.from.keyed.get(key);
-
-	if (keyedFrom == null) {
-		keyedFrom = new Map();
-
-		values.from.keyed.set(key, keyedFrom);
-	}
-
-	keyedFrom.set(value, subscription);
-
-	let keyedTo = values.to.keyed.get(key);
-
-	if (keyedTo == null) {
-		keyedTo = new Map();
-
-		values.to.keyed.set(key, keyedTo);
-	}
-
-	keyedTo.set(subscription, value);
-}
-
-export function clearSubscriptions(store: Subscriptions): void {
-	for (const susbcription of store.values.to.any.keys()) {
-		susbcription.unsubscribe();
-	}
-
-	if (store.values.to.keyed != null) {
-		for (const values of store.values.to.keyed.values()) {
-			for (const susbcription of values.keys()) {
-				susbcription.unsubscribe();
-			}
-		}
-	}
-}
-
-function getExistingSubscription(state: SubscriptionState): Subscription | undefined {
-	const {parameters} = state;
-	const {values} = parameters.subscriptions;
-
-	return parameters.key == null
-		? values.from.any.get(parameters.value)
-		: values.from.keyed?.get(parameters.key)?.get(parameters.value);
-}
-
-export function getSubscription(parameters: SubscriptionParameters): Subscription {
-	const state: SubscriptionState = {
-		parameters,
-		active: true,
-	};
-
-	const existing = getExistingSubscription(state);
-
-	if (existing != null) {
-		return existing;
-	}
-
-	if (
-		parameters.subscriptions.keys != null &&
-		parameters.key != null &&
-		!parameters.subscriptions.keys.has(parameters.key)
-	) {
-		throw new Error();
-	}
-
-	const instance = {
-		unsubscribe: () => {
-			removeSubscription(instance as Subscription, state);
-		},
-	};
-
-	Object.defineProperties(instance, {
-		[PROPERTY]: {
-			enumerable: false,
-			value: true,
-		},
-		[parameters.property.key]: {
-			enumerable: false,
-			value: parameters.property.value,
-		},
-		active: {
-			enumerable: true,
-			get: () => (parameters.isActive?.() ?? true) && state.active,
-		},
-	});
-
-	addSubscription(instance as Subscription, state);
-
-	return Object.freeze(instance) as Subscription;
-}
-
-export function getSubscriptions<Value = unknown>(keys?: Set<Key>): Subscriptions<Value> {
-	return {
-		keys,
-		items: {
-			any: new Set(),
-			keyed: keys == null ? undefined : new Map(),
-		},
-		values: {
-			from: {
-				any: new Map(),
-				keyed: keys == null ? undefined : new Map(),
-			},
-			to: {
-				any: new Map(),
-				keyed: keys == null ? undefined : new Map(),
-			},
-		},
-	};
-}
-
-/**
- * Is the value a subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a subscription, otherwise `false`
- */
-export function isSubscription(value: unknown): value is Subscription {
-	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
-}
-
-function removeFromStore(
-	items: Set<Subscription>,
-	values: SubscriptionsValues,
-	subscription: Subscription,
-	value: unknown,
-	key?: Key,
-): void {
-	items.delete(subscription);
-
-	if (key == null) {
-		values.from.any.delete(value);
-		values.to.any.delete(subscription);
-	} else {
-		values.from.keyed?.get(key)?.delete(value);
-		values.to.keyed?.get(key)?.delete(subscription);
-	}
-}
-
-function removeSubscription(subscription: Subscription, state: SubscriptionState): void {
-	if (!state.active) {
-		return;
-	}
-
-	state.active = false;
-
-	const {key, subscriptions, value} = state.parameters;
-	const {items, values} = subscriptions;
-
-	if (key == null) {
-		removeFromStore(items.any, values, subscription, value);
-
-		return;
-	}
-
-	const keyed = items.keyed?.get(key);
-
-	if (items.keyed == null || keyed == null) {
-		// TODO, fix tests or document
-		// istanbul ignore next
-		return;
-	}
-
-	removeFromStore(keyed, values, subscription, value, key);
-
-	if (keyed.size === 0) {
-		items.keyed.delete(key);
-	}
-}
-
-// #endregion
-
-// #region Variables
-
-const PROPERTY = '$subscription';
-
-// #endregion

package/src/internal/value/compare.ts

@@ -1,170 +0,0 @@
-import type {Constructor} from '../../models';
-import {max} from '../math/aggregate';
-import {getString, words} from '../string';
-import {getCompareHandlers} from './handlers';
-
-// #region Types
-
-type Comparator<Value = any> = (first: Value, second: Value) => number;
-
-// #endregion
-
-// #region Special variables
-
-const COMPARE_NAME: string = 'compare';
-
-// #endregion
-
-// #region Functions
-
-/**
- * Compare two values _(for sorting purposes)_
- *
- * @param first First value
- * @param second Second value
- * @returns `0` if equal; `-1` first comes before second; `1` first comes after second
- */
-export function compare(first: unknown, second: unknown): number {
-	if (Object.is(first, second)) {
-		return 0;
-	}
-
-	if (first == null) {
-		return -1;
-	}
-
-	if (second == null) {
-		return 1;
-	}
-
-	let comparison = compareValue(first, second, false);
-
-	if (comparison != null) {
-		return comparison;
-	}
-
-	const firstParts = getComparisonParts(first);
-	const secondParts = getComparisonParts(second);
-	const length = max([firstParts.length, secondParts.length]);
-
-	const lastIndex = length - 1;
-
-	for (let index = 0; index < length; index += 1) {
-		const firstPart = firstParts[index];
-		const secondPart = secondParts[index];
-
-		comparison = compareValue(firstPart, secondPart, true);
-
-		if (comparison === 0) {
-			if (index === lastIndex) {
-				break;
-			}
-
-			continue;
-		}
-
-		return comparison as number;
-	}
-
-	return 0;
-}
-
-compare.handlers = getCompareHandlers<number>(compare, {
-	callback: (first, second, compareStrings) => {
-		if (compareStrings) {
-			return getString(first).localeCompare(getString(second));
-		}
-	},
-	method: COMPARE_NAME,
-});
-
-compare.deregister = deregisterComparator;
-compare.register = registerComparator;
-
-function compareNumbers(first: bigint | number, second: bigint | number): number {
-	if (Object.is(first, second)) {
-		return 0;
-	}
-
-	if (Number.isNaN(first)) {
-		return -1;
-	}
-
-	if (Number.isNaN(second)) {
-		return 1;
-	}
-
-	return first > second ? 1 : -1;
-}
-
-function compareSymbols(first: symbol, second: symbol): number {
-	return getString(first.description ?? first).localeCompare(
-		getString(second.description ?? second),
-	);
-}
-
-function compareValue(
-	first: unknown,
-	second: unknown,
-	compareStrings: boolean,
-): number | undefined {
-	const firstType = typeof first;
-	const secondType = typeof second;
-
-	if (firstType === secondType && firstType in comparators) {
-		return comparators[firstType as keyof typeof comparators](first as never, second as never);
-	}
-
-	if (first instanceof Date && second instanceof Date) {
-		return compareNumbers(first.getTime(), second.getTime());
-	}
-
-	return compare.handlers.handle(first, second, compareStrings);
-}
-
-/**
- * Deregister a custom comparison handler for a class
- *
- * _Available as `deregisterComparator` and `compare.deregister`_
- *
- * @param constructor Class constructor
- */
-export function deregisterComparator<Instance>(constructor: Constructor<Instance>): void {
-	compare.handlers.deregister(constructor);
-}
-
-function getComparisonParts(value: unknown): unknown[] {
-	if (Array.isArray(value)) {
-		return value;
-	}
-
-	return typeof value === 'object' ? [value] : words(getString(value));
-}
-
-/**
- * Register a custom comparison handler for a class
- *
- * _Available as `registerComparator` and `compare.register`_
- *
- * @param constructor Class constructor
- * @param handler Method name or comparison function _(defaults to `compare`)_
- */
-export function registerComparator<Instance>(
-	constructor: Constructor<Instance>,
-	handler?: string | Comparator<Instance>,
-): void {
-	compare.handlers.register(constructor, handler);
-}
-
-// #endregion
-
-// #region Variables
-
-const comparators: Record<string, Comparator> = {
-	bigint: compareNumbers,
-	boolean: (first, second) => compareNumbers(first ? 1 : 0, second ? 1 : 0),
-	number: compareNumbers,
-	symbol: compareSymbols,
-};
-
-// #endregion