@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/array/update.ts

@@ -1,75 +0,0 @@
-import {updateInArray} from '../internal/array/update';
-import type {PlainObject} from '../models';
-
-/**
- * Update an item in an array
- *
- * If the item exists, it will be updated; if it doesn't, it will be added
- *
- * @param destination Array to update within
- * @param updated Updated items
- * @param callback Callback to find existing item
- * @returns Original array
- *
- * @example
- * ```typescript
- * update(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2, name: 'Updated'}, {id: 4, name: 'New'}],
- *   item => item.id,
- * ); // => [{id: 1}, {id: 2, name: 'Updated'}, {id: 3}, {id: 4, name: 'New'}]
- * ```
- */
-export function update<Item>(
-	destination: Item[],
-	updated: Item[],
-	callback: (item: Item, index: number, array: Item[]) => unknown,
-): Item[];
-
-/**
- * Update an item in an array
- *
- * If the item exists, it will be updated; if it doesn't, it will be added
- *
- * @param destination Array to update within
- * @param updated Updated items
- * @param key Key to find existing item
- * @returns Original array
- *
- * @example
- * ```typescript
- * update(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2, name: 'Updated'}, {id: 4, name: 'New'}],
- *   'id',
- * ); // => [{id: 1}, {id: 2, name: 'Updated'}, {id: 3}, {id: 4, name: 'New'}]
- * ```
- */
-export function update<Item extends PlainObject, ItemKey extends keyof Item>(
-	destination: Item[],
-	updated: Item[],
-	key: ItemKey,
-): Item[];
-
-/**
- * Update an item in an array
- *
- * If the item exists, it will be updated; if it doesn't, it will be added
- *
- * @param destination Array to update within
- * @param updated Updated items
- * @returns Original array
- *
- * @example
- * ```typescript
- * update(
- *   [1, 2, 3],
- *   [2, 4],
- * ); // => [1, 2, 3, 4]
- * ```
- */
-export function update<Item>(destination: Item[], updated: Item[]): Item[];
-
-export function update(array: unknown[], values: unknown[], key?: unknown): unknown[] {
-	return updateInArray(array, values, key, true);
-}

package/src/beacon.ts

@@ -1,378 +0,0 @@
-import {noop} from './internal/function/misc';
-import {isPlainObject} from './internal/is';
-import {
-	clearSubscriptions,
-	getSubscription,
-	getSubscriptions,
-	type Subscription,
-	type SubscriptionProperty,
-	type Subscriptions,
-} from './internal/subscription';
-import type {PlainObject} from './models';
-
-// #region Types
-
-/**
- * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
- */
-export type Beacon<Value> = {
-	/**
-	 * Is the beacon active?
-	 */
-	get active(): boolean;
-
-	/**
-	 * The observable that can be subscribed to
-	 */
-	get observable(): Observable<Value>;
-
-	/**
-	 * The current value
-	 */
-	get value(): Value;
-
-	/**
-	 * Deactivate the beacon
-	 */
-	deactivate(): void;
-
-	/**
-	 * Emit a new value
-	 *
-	 * @param value Value to set and emit
-	 * @param finish Finish the beacon after emitting? _(defaults to `false`)_
-	 */
-	emit(value: Value, finish?: boolean): void;
-
-	/**
-	 * Emit an error
-	 *
-	 * @param value Error to emit
-	 * @param finish Finish the beacon after emitting? _(defaults to `false`)_
-	 */
-	error(value: Error, finish?: boolean): void;
-
-	/**
-	 * Finish the beacon
-	 */
-	finish(): void;
-};
-
-export type BeaconOptions<Value> = {
-	/**
-	 * Method for comparing values for equality
-	 *
-	 * @param first First value
-	 * @param second Second value
-	 * @returns `true` if the values are equal, otherwise `false`
-	 * @default Object.is
-	 */
-	equal?: (first: Value, second: Value) => boolean;
-};
-
-type BeaconState<Value> = {
-	active: boolean;
-	observable: Observable<Value>;
-	options: Required<BeaconOptions<Value>>;
-	subscriptions: Subscriptions<Observer<unknown>>;
-	value: Value;
-};
-
-export type Observable<Value> = {
-	/**
-	 * Is the observable active?
-	 */
-	get active(): boolean;
-
-	/**
-	 * Deactivate the observable
-	 */
-	deactivate(): void;
-
-	/**
-	 * Subscribe to value changes
-	 *
-	 * @param onNext Callback for when the observable receives a new value
-	 * @param onError Callback for when the observable receives an error
-	 * @param onComplete Callback for when the observable is completed
-	 * @returns Subscription to the observable
-	 */
-	subscribe(
-		onNext: (value: Value) => void,
-		onError?: (error: Error) => void,
-		onComplete?: () => void,
-	): Subscription;
-
-	/**
-	 * Subscribe to value changes
-	 *
-	 * @param observer Observer for changes
-	 * @returns Subscription to the observable
-	 */
-	subscribe(observer: Observer<Value>): Subscription;
-};
-
-type ObservableState<Value> = {
-	active: boolean;
-	beacon: BeaconState<Value>;
-};
-
-type Observer<Value> = {
-	/**
-	 * Callback for when the observable is completed
-	 */
-	complete?: () => void;
-	/**
-	 * Callback for when the observable receives an error
-	 */
-	error?: (error: Error) => void;
-	/**
-	 * Callback for when the observable receives a new value
-	 */
-	next?: (value: Value) => void;
-};
-
-// #endregion
-
-// #region Functions
-
-/**
- * Create a new beacon
- *
- * @param value Initial value
- * @param options Beacon options
- * @returns Beacon instance
- */
-export function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value> {
-	const state: BeaconState<Value> = {
-		value,
-		active: true,
-		observable: undefined as never,
-		options: getBeaconOptions(options),
-		subscriptions: getSubscriptions(),
-	};
-
-	const instance = {
-		deactivate: (): void => {
-			finishBeacon(state, false);
-		},
-		emit: (value: Value, finish?: boolean): void => {
-			update(TYPE_NEXT, state, value, finish);
-		},
-		error: (value: Error, finish?: boolean): void => {
-			update(TYPE_ERROR, state, value, finish);
-		},
-		finish: (): void => {
-			finishBeacon(state, true);
-		},
-	};
-
-	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_BEACON,
-		},
-		active: {
-			enumerable: true,
-			get: () => state.active,
-		},
-		observable: {
-			enumerable: true,
-			get: () => {
-				if (!state.active) {
-					throw new Error(MESSAGE_BEACON);
-				}
-
-				state.observable ??= observe(state);
-
-				return state.observable;
-			},
-		},
-		value: {
-			enumerable: true,
-			get: () => state.value,
-		},
-	});
-
-	return Object.freeze(instance) as Beacon<Value>;
-}
-
-function finishBeacon<Value>(state: BeaconState<Value>, emit: boolean): void {
-	if (!state.active) {
-		return;
-	}
-
-	state.active = false;
-
-	for (const [, observer] of state.subscriptions.values.to.any) {
-		if (emit) {
-			observer.complete?.();
-		}
-	}
-
-	clearSubscriptions(state.subscriptions);
-
-	state.observable?.deactivate();
-
-	state.observable = undefined as never;
-}
-
-function getBeaconOptions<Value>(input?: BeaconOptions<Value>): Required<BeaconOptions<Value>> {
-	const options: BeaconOptions<Value> = isPlainObject(input) ? (input as PlainObject) : {};
-
-	options.equal = typeof options.equal === 'function' ? options.equal : Object.is;
-
-	return options as Required<BeaconOptions<Value>>;
-}
-
-function getObservableCallback<Callback>(value: Callback): Callback {
-	return typeof value === 'function' ? value : (noop as Callback);
-}
-
-function getObserver<Value>(
-	first: Observer<Value> | ((value: Value) => void),
-	second?: (error: Error) => void,
-	third?: () => void,
-): Observer<Value> {
-	let observer: Observer<Value> = {
-		next: noop,
-	};
-
-	if (typeof first === 'function') {
-		observer = {
-			error: getObservableCallback(second),
-			next: getObservableCallback(first),
-			complete: getObservableCallback(third),
-		};
-	} else if (typeof first === 'object') {
-		observer.complete = getObservableCallback(first?.complete);
-		observer.error = getObservableCallback(first?.error);
-		observer.next = getObservableCallback(first?.next);
-	}
-
-	return observer;
-}
-
-/**
- * Is the value a beacon?
- *
- * @param value Value to check
- * @returns `true` if the value is a beacon, otherwise `false`
- */
-export function isBeacon<Value = unknown>(value: unknown): value is Beacon<Value> {
-	return isBeaconInstance<Beacon<Value>>(NAME_BEACON, value);
-}
-
-function isBeaconInstance<Instance>(name: string, value: unknown): value is Instance {
-	return isPlainObject(value) && (value as PlainObject)[KEY_BEACON] === name;
-}
-
-/**
- * Is the value an observable?
- *
- * @param value Value to check
- * @returns `true` if the value is an observable, otherwise `false`
- */
-export function isObservable<Value = unknown>(value: unknown): value is Observable<Value> {
-	return isBeaconInstance<Observable<Value>>(NAME_OBSERVABLE, value);
-}
-
-function observe<Value>(beacon: BeaconState<Value>): Observable<Value> {
-	const state: ObservableState<Value> = {
-		beacon,
-		active: beacon.active,
-	};
-
-	const instance = {
-		deactivate: (): void => {
-			state.active = false;
-		},
-		subscribe(
-			first: Observer<Value> | ((value: Value) => void),
-			second?: (error: Error) => void,
-			third?: () => void,
-		): Subscription {
-			if (!beacon.active || !state.active) {
-				throw new Error(MESSAGE_OBSERVABLE);
-			}
-
-			const observer = getObserver(first, second, third);
-
-			const subscription = getSubscription({
-				isActive: () => beacon.active && state.active,
-				property: beaconSubscription,
-				subscriptions: beacon.subscriptions,
-				value: observer,
-			});
-
-			observer.next?.(beacon.value);
-
-			return subscription;
-		},
-	};
-
-	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_OBSERVABLE,
-		},
-		active: {
-			enumerable: true,
-			get: () => beacon.active && state.active,
-		},
-	});
-
-	return Object.freeze(instance) as Observable<Value>;
-}
-
-function update<Value>(
-	type: keyof Observer<never>,
-	state: BeaconState<Value>,
-	value: Error | Value,
-	finish?: boolean,
-): void {
-	if (!state.active) {
-		return;
-	}
-
-	if (type === TYPE_NEXT) {
-		if (state.options.equal(state.value, value as Value)) {
-			return;
-		}
-
-		state.value = value as Value;
-	}
-
-	for (const [, observer] of state.subscriptions.values.to.any) {
-		observer[type]?.(value as never);
-	}
-
-	if (finish === true) {
-		finishBeacon(state, true);
-	}
-}
-
-// #endregion
-
-// #region Variables
-
-const KEY_BEACON = '$beacon';
-
-const MESSAGE_BEACON = 'Cannot retrieve observable from a closed beacon';
-
-const MESSAGE_OBSERVABLE = 'Cannot subscribe to a closed observable';
-
-const NAME_BEACON = 'beacon';
-
-const NAME_OBSERVABLE = 'observable';
-
-const TYPE_ERROR = 'error';
-
-const TYPE_NEXT = 'next';
-
-const beaconSubscription: SubscriptionProperty = {
-	key: KEY_BEACON,
-	value: 'subscription',
-};
-
-// #endregion

package/src/color/constants.ts

@@ -1,137 +0,0 @@
-import type {
-	Alpha,
-	ColorTypeExtended,
-	HSLAColor,
-	HSLColor,
-	HWBAColor,
-	HWBColor,
-	RGBAColor,
-	RGBColor,
-} from './models';
-
-// #region Types
-
-type ColorTypes = {
-	all: Set<'alpha' | ColorTypeExtended>;
-	hex: 'hex';
-	hexa: 'hexa';
-	hsl: 'hsl';
-	hsla: 'hsla';
-	hwb: 'hwb';
-	hwba: 'hwba';
-	rgb: 'rgb';
-	rgba: 'rgba';
-};
-
-// #endregion
-
-// #region Variables
-
-export const COLOR_ALPHA = {
-	fullHexShort: 'f',
-	fullHexLong: 'ff',
-	name: 'alpha',
-	noneHex: '00',
-	noneValue: 0,
-};
-
-export const COLOR_DEFAULTS = {
-	alpha: {
-		hex: COLOR_ALPHA.fullHexLong,
-		value: 100,
-	},
-	hexBlack: '000000',
-	hexWhite: 'ffffff',
-	hsl: {
-		hue: 0,
-		saturation: 0,
-		lightness: 0,
-	},
-	hwb: {
-		hue: 0,
-		whiteness: 0,
-		blackness: 100,
-	},
-	rgb: {
-		blue: 0,
-		green: 0,
-		red: 0,
-	},
-};
-
-export const COLOR_EXPRESSION = {
-	alphaHex: /^([a-f0-9]{1,2})$/i,
-	hexLong: /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?$/i,
-	hexShort: /^#?([a-f0-9]{3,4})$/i,
-	prefix: /^#/,
-};
-
-export const COLOR_LENGTHS = {
-	hexLong: 6,
-	hexShort: 3,
-};
-
-export const COLOR_KEYS = {
-	hsl: ['hue', 'saturation', 'lightness'] as Array<keyof HSLColor>,
-	hsla: [] as Array<keyof HSLAColor>,
-	hwb: ['hue', 'whiteness', 'blackness'] as Array<keyof HWBColor>,
-	hwba: [] as Array<keyof HWBAColor>,
-	rgb: ['red', 'green', 'blue'] as Array<keyof RGBColor>,
-	rgba: [] as Array<keyof RGBAColor>,
-};
-
-COLOR_KEYS.hsla = [...COLOR_KEYS.hsl, COLOR_ALPHA.name as keyof Alpha] as Array<keyof HSLAColor>;
-
-COLOR_KEYS.hwba = [...COLOR_KEYS.hwb, COLOR_ALPHA.name as keyof Alpha] as Array<keyof HWBAColor>;
-
-COLOR_KEYS.rgba = [...COLOR_KEYS.rgb, COLOR_ALPHA.name as keyof Alpha] as Array<keyof RGBAColor>;
-
-export const COLOR_MAX = {
-	degree: 360,
-	hex: 255,
-	percent: 100,
-};
-
-export const COLOR_PROPERTY = {
-	name: '$color',
-	subscription: 'subscription',
-};
-
-export const COLOR_TYPE: ColorTypes = {
-	all: undefined as unknown as Set<'alpha' | ColorTypeExtended>,
-	hex: 'hex',
-	hexa: 'hexa',
-	hsl: 'hsl',
-	hsla: 'hsla',
-	hwb: 'hwb',
-	hwba: 'hwba',
-	rgb: 'rgb',
-	rgba: 'rgba',
-};
-
-COLOR_TYPE.all = new Set([
-	COLOR_ALPHA.name as 'alpha',
-	COLOR_TYPE.hex,
-	COLOR_TYPE.hexa,
-	COLOR_TYPE.hsl,
-	COLOR_TYPE.hsla,
-	COLOR_TYPE.hwb,
-	COLOR_TYPE.hwba,
-	COLOR_TYPE.rgb,
-	COLOR_TYPE.rgba,
-] as Array<'alpha' | ColorTypeExtended>);
-
-// https://www.w3.org/TR/WCAG20/#relativeluminancedef
-export const COLOR_SRGB = {
-	luminanceBlue: 0.0722,
-	luminanceExponent: 2.4,
-	luminanceGreen: 0.7152,
-	luminanceMinimum: 0.03928,
-	luminanceModifier: 1.055,
-	luminanceMultiplier: 12.92,
-	luminanceOffset: 0.055,
-	luminanceRed: 0.2126,
-	luminanceThreshold: 0.625,
-};
-
-// #endregion

package/src/color/index.ts

@@ -1,83 +0,0 @@
-import {color} from './instance';
-import {isColor} from './misc/is';
-import type {
-	Color,
-	ColorType,
-	ColorTypeExtended,
-	ColorValue,
-	ColorValueExtended,
-	HSLAColor,
-	HSLColor,
-	HWBAColor,
-	HWBColor,
-	RGBAColor,
-	RGBColor,
-} from './models';
-
-// #region Functions
-
-/**
- * Get a _Color_ from any kind of value
- *
- * - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
- * - If the value is unable to be parsed, a black _Color_ will be returned
- *
- * @param value Original value
- * @returns _Color_ instance
- */
-export function getColor(value: unknown): Color {
-	return isColor(value) ? value : color(value);
-}
-
-// #endregion
-
-// #region Exports
-
-export {
-	getForegroundColor,
-	getHexaColor,
-	getHexColor,
-	getHslaColor,
-	getHslColor,
-	getHwbaColor,
-	getHwbColor,
-	getRgbaColor,
-	getRgbColor,
-} from './misc/get';
-export {
-	isColor,
-	isHexColor,
-	isHslaColor,
-	isHslColor,
-	isHwbaColor,
-	isHwbColor,
-	isRgbaColor,
-	isRgbColor,
-} from './misc/is';
-export {
-	getNormalizedHex,
-	hexToHsl,
-	hexToHsla,
-	hexToHwb,
-	hexToHwba,
-	hexToRgb,
-	hexToRgba,
-} from './space/hex';
-export {hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba} from './space/hsl';
-export {hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba} from './space/hwb';
-export {rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba} from './space/rgb';
-export type {
-	Color,
-	ColorType,
-	ColorTypeExtended,
-	ColorValue,
-	ColorValueExtended,
-	HSLAColor,
-	HSLColor,
-	HWBAColor,
-	HWBColor,
-	RGBAColor,
-	RGBColor,
-};
-
-// #endregion