@oscarpalmer/atoms 0.191.0 → 0.193.0

package/src/beacon.ts

@@ -1,5 +1,13 @@
 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
@@ -13,11 +21,6 @@ export type Beacon<Value> = {
 	 */
 	get active(): boolean;
 
-	/**
-	 * Is the beacon closed?
-	 */
-	get closed(): boolean;
-
 	/**
 	 * The observable that can be subscribed to
 	 */
@@ -29,9 +32,9 @@ export type Beacon<Value> = {
 	get value(): Value;
 
 	/**
-	 * Close the beacon
+	 * Deactivate the beacon
 	 */
-	close(): void;
+	deactivate(): void;
 
 	/**
 	 * Emit a new value
@@ -55,9 +58,6 @@ export type Beacon<Value> = {
 	finish(): void;
 };
 
-/**
- * Options for Beacon
- */
 export type BeaconOptions<Value> = {
 	/**
 	 * Method for comparing values for equality
@@ -73,8 +73,8 @@ export type BeaconOptions<Value> = {
 type BeaconState<Value> = {
 	active: boolean;
 	observable: Observable<Value>;
-	observers: Map<Subscription, Observer<Value>>;
 	options: Required<BeaconOptions<Value>>;
+	subscriptions: Subscriptions<Observer<unknown>>;
 	value: Value;
 };
 
@@ -85,14 +85,9 @@ export type Observable<Value> = {
 	get active(): boolean;
 
 	/**
-	 * Is the observable closed?
-	 */
-	get closed(): boolean;
-
-	/**
-	 * Close the observable
+	 * Deactivate the observable
 	 */
-	close(): void;
+	deactivate(): void;
 
 	/**
 	 * Subscribe to value changes
@@ -122,9 +117,6 @@ type ObservableState<Value> = {
 	beacon: BeaconState<Value>;
 };
 
-/**
- * An observer receives notifications from an observable
- */
 type Observer<Value> = {
 	/**
 	 * Callback for when the observable is completed
@@ -140,28 +132,6 @@ type Observer<Value> = {
 	next?: (value: Value) => void;
 };
 
-export type Subscription = {
-	/**
-	 * Is the subscription active?
-	 */
-	get active(): boolean;
-
-	/**
-	 * Is the subscription closed?
-	 */
-	get closed(): boolean;
-
-	/**
-	 * Close the subscription
-	 */
-	close(): void;
-
-	/**
-	 * Unsubscribe from its observable
-	 */
-	unsubscribe(): void;
-};
-
 // #endregion
 
 // #region Functions
@@ -178,12 +148,12 @@ export function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Bea
 		value,
 		active: true,
 		observable: undefined as never,
-		observers: new Map(),
 		options: getBeaconOptions(options),
+		subscriptions: getSubscriptions(),
 	};
 
 	const instance = {
-		close: (): void => {
+		deactivate: (): void => {
 			finishBeacon(state, false);
 		},
 		emit: (value: Value, finish?: boolean): void => {
@@ -206,10 +176,6 @@ export function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Bea
 			enumerable: true,
 			get: () => state.active,
 		},
-		closed: {
-			enumerable: true,
-			get: () => !state.active,
-		},
 		observable: {
 			enumerable: true,
 			get: () => {
@@ -238,21 +204,15 @@ function finishBeacon<Value>(state: BeaconState<Value>, emit: boolean): void {
 
 	state.active = false;
 
-	const entries = [...state.observers.entries()];
-	const {length} = entries;
-
-	for (let index = 0; index < length; index += 1) {
-		const [subscription, observer] = entries[index];
-
+	for (const [, observer] of state.subscriptions.values.to.any) {
 		if (emit) {
 			observer.complete?.();
 		}
-
-		subscription.close();
 	}
 
-	state.observable?.close();
-	state.observers.clear();
+	clearSubscriptions(state.subscriptions);
+
+	state.observable?.deactivate();
 
 	state.observable = undefined as never;
 }
@@ -317,16 +277,6 @@ export function isObservable<Value = unknown>(value: unknown): value is Observab
 	return isBeaconInstance<Observable<Value>>(NAME_OBSERVABLE, value);
 }
 
-/**
- * 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 isBeaconInstance<Subscription>(NAME_SUBSCRIPTION, value);
-}
-
 function observe<Value>(beacon: BeaconState<Value>): Observable<Value> {
 	const state: ObservableState<Value> = {
 		beacon,
@@ -334,7 +284,7 @@ function observe<Value>(beacon: BeaconState<Value>): Observable<Value> {
 	};
 
 	const instance = {
-		close: (): void => {
+		deactivate: (): void => {
 			state.active = false;
 		},
 		subscribe(
@@ -347,9 +297,13 @@ function observe<Value>(beacon: BeaconState<Value>): Observable<Value> {
 			}
 
 			const observer = getObserver(first, second, third);
-			const subscription = subscribe(state);
 
-			beacon.observers.set(subscription, observer);
+			const subscription = getSubscription({
+				isActive: () => beacon.active && state.active,
+				property: beaconSubscription,
+				subscriptions: beacon.subscriptions,
+				value: observer,
+			});
 
 			observer.next?.(beacon.value);
 
@@ -366,53 +320,11 @@ function observe<Value>(beacon: BeaconState<Value>): Observable<Value> {
 			enumerable: true,
 			get: () => beacon.active && state.active,
 		},
-		closed: {
-			enumerable: true,
-			get: () => !beacon.active || !state.active,
-		},
 	});
 
 	return Object.freeze(instance) as Observable<Value>;
 }
 
-function subscribe<Value>(observable: ObservableState<Value>): Subscription {
-	function unsubscribe(): void {
-		if (active) {
-			active = false;
-
-			observable.beacon.observers.delete(instance as Subscription);
-		}
-	}
-
-	let active = true;
-
-	const instance = {
-		close: (): void => {
-			unsubscribe();
-		},
-		unsubscribe: (): void => {
-			unsubscribe();
-		},
-	};
-
-	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_SUBSCRIPTION,
-		},
-		active: {
-			enumerable: true,
-			get: () => observable.beacon.active && observable.active && active,
-		},
-		closed: {
-			enumerable: true,
-			get: () => !observable.beacon.active || !observable.active || !active,
-		},
-	});
-
-	return Object.freeze(instance) as Subscription;
-}
-
 function update<Value>(
 	type: keyof Observer<never>,
 	state: BeaconState<Value>,
@@ -431,7 +343,7 @@ function update<Value>(
 		state.value = value as Value;
 	}
 
-	for (const [, observer] of state.observers) {
+	for (const [, observer] of state.subscriptions.values.to.any) {
 		observer[type]?.(value as never);
 	}
 
@@ -454,10 +366,13 @@ const NAME_BEACON = 'beacon';
 
 const NAME_OBSERVABLE = 'observable';
 
-const NAME_SUBSCRIPTION = 'subscription';
-
 const TYPE_ERROR = 'error';
 
 const TYPE_NEXT = 'next';
 
+const beaconSubscription: SubscriptionProperty = {
+	key: KEY_BEACON,
+	value: 'subscription',
+};
+
 // #endregion

package/src/color/constants.ts

@@ -1,100 +1,137 @@
-import type {Alpha, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor} from './models';
-
-// #region Variables
-
-export const ALPHA_FULL_HEX_SHORT = 'f';
-
-export const ALPHA_FULL_HEX_LONG = `${ALPHA_FULL_HEX_SHORT}${ALPHA_FULL_HEX_SHORT}`;
+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';
+};
 
-export const ALPHA_NONE_HEX = '00';
+// #endregion
 
-export const ALPHA_NONE_VALUE = 0;
+// #region Variables
 
-export const DEFAULT_ALPHA: Alpha = {
-	hex: ALPHA_FULL_HEX_LONG,
-	value: 100,
+export const COLOR_ALPHA = {
+	fullHexShort: 'f',
+	fullHexLong: 'ff',
+	name: 'alpha',
+	noneHex: '00',
+	noneValue: 0,
 };
 
-export const DEFAULT_HSL: HSLColor = {
-	hue: 0,
-	saturation: 0,
-	lightness: 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 DEFAULT_HWB: HWBColor = {
-	hue: 0,
-	whiteness: 0,
-	blackness: 100,
+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 DEFAULT_RGB: RGBColor = {
-	blue: 0,
-	green: 0,
-	red: 0,
+export const COLOR_LENGTHS = {
+	hexLong: 6,
+	hexShort: 3,
 };
 
-export const EXPRESSION_ALPHA_HEX = /^([a-f0-9]{1,2})$/i;
-
-export const EXPRESSION_HEX_LONG = /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?$/i;
-
-export const EXPRESSION_HEX_SHORT = /^#?([a-f0-9]{3,4})$/i;
-
-export const EXPRESSION_PREFIX = /^#/;
-
-export const HEX_BLACK = '000000';
-
-export const HEX_WHITE = 'ffffff';
-
-export const LENGTH_LONG = 6;
-
-export const LENGTH_SHORT = 3;
-
-export const KEYS_HSL: Array<keyof HSLColor> = ['hue', 'saturation', 'lightness'];
-
-export const KEYS_HSLA: Array<keyof HSLAColor> = [...KEYS_HSL, 'alpha'];
-
-export const KEYS_HWB: Array<keyof HWBColor> = ['hue', 'whiteness', 'blackness'];
-
-export const KEYS_HWBA: Array<keyof HWBAColor> = [...KEYS_HWB, 'alpha'];
-
-export const KEYS_RGB: Array<keyof RGBColor> = ['red', 'green', 'blue'];
-
-export const KEYS_RGBA: Array<keyof RGBAColor> = [...KEYS_RGB, 'alpha'];
-
-export const MAX_DEGREE = 360;
+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>,
+};
 
-export const MAX_HEX = 255;
+COLOR_KEYS.hsla = [...COLOR_KEYS.hsl, COLOR_ALPHA.name as keyof Alpha] as Array<keyof HSLAColor>;
 
-export const MAX_PERCENT = 100;
+COLOR_KEYS.hwba = [...COLOR_KEYS.hwb, COLOR_ALPHA.name as keyof Alpha] as Array<keyof HWBAColor>;
 
-export const PROPERTY_COLOR = '$color';
+COLOR_KEYS.rgba = [...COLOR_KEYS.rgb, COLOR_ALPHA.name as keyof Alpha] as Array<keyof RGBAColor>;
 
-export const TYPE_HEX = 'hex';
+export const COLOR_MAX = {
+	degree: 360,
+	hex: 255,
+	percent: 100,
+};
 
-export const TYPE_HSL = 'hsl';
+export const COLOR_PROPERTY = {
+	name: '$color',
+	subscription: 'subscription',
+};
 
-export const TYPE_HWB = 'hwb';
+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',
+};
 
-export const TYPE_RGB = 'rgb';
+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 SRGB_LUMINANCE_BLUE = 0.0722;
-
-export const SRGB_LUMINANCE_EXPONENT = 2.4;
-
-export const SRGB_LUMINANCE_GREEN = 0.7152;
-
-export const SRGB_LUMINANCE_MINIMUM = 0.03928;
-
-export const SRGB_LUMINANCE_MODIFIER = 1.055;
-
-export const SRGB_LUMINANCE_MULTIPLIER = 12.92;
-
-export const SRGB_LUMINANCE_OFFSET = 0.055;
-
-export const SRGB_LUMINANCE_RED = 0.2126;
-
-export const SRGB_LUMINANCE_THRESHOLD = 0.625;
+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/instance.ts

@@ -1,4 +1,12 @@
-import {PROPERTY_COLOR, TYPE_HEX, TYPE_HSL, TYPE_HWB, TYPE_RGB} from './constants';
+import {
+	clearSubscriptions,
+	getSubscription,
+	getSubscriptions,
+	type Subscription,
+	type SubscriptionProperty,
+	type Subscriptions,
+} from '../internal/subscription';
+import {COLOR_PROPERTY, COLOR_TYPE} from './constants';
 import {getAlpha} from './misc/alpha';
 import {formatHslColor, formatHwbColor, formatRgbColor} from './misc/format';
 import {
@@ -13,7 +21,13 @@ import type {Color, ColorState, ColorType} from './models';
 
 // #region Types
 
-type SetValue = (state: ColorState, value: any, alpha: boolean) => void;
+type SetValue = (
+	color: Color,
+	state: ColorState,
+	subscriptions: Subscriptions<Function>,
+	value: any,
+	alpha: boolean,
+) => void;
 
 type SetValues = Record<ColorType, SetValue>;
 
@@ -24,17 +38,22 @@ type SetValues = Record<ColorType, SetValue>;
 export function color(value: unknown): Color {
 	const state = getColorState(value);
 
+	const subscriptions = getSubscriptions<Function>(COLOR_TYPE.all);
+
 	const instance = {
+		subscribe: (first?: unknown, second?: unknown) =>
+			subscribeToColor(subscriptions, first, second),
 		toHexString: (alpha?: boolean) =>
 			`#${alpha === true ? (instance as Color).hexa : (instance as Color).hex}`,
 		toHslString: (alpha?: boolean) => formatHslColor(state, alpha),
 		toHwbString: (alpha?: boolean) => formatHwbColor(state, alpha),
 		toRgbString: (alpha?: boolean) => formatRgbColor(state, alpha),
 		toString: () => (instance as Color).toHexString(),
+		unsubscribe: () => clearSubscriptions(subscriptions),
 	};
 
 	Object.defineProperties(instance, {
-		[PROPERTY_COLOR]: {
+		[COLOR_PROPERTY.name]: {
 			enumerable: false,
 			value: true,
 		},
@@ -43,18 +62,18 @@ export function color(value: unknown): Color {
 			get: () => state.alpha.value,
 			set: (value: unknown) => setAlphaValue(state, value),
 		},
-		hex: getProperty(TYPE_HEX, state, false),
-		hexa: getProperty(TYPE_HEX, state, true),
-		hsl: getProperty(TYPE_HSL, state, false),
-		hsla: getProperty(TYPE_HSL, state, true),
-		hwb: getProperty(TYPE_HWB, state, false),
-		hwba: getProperty(TYPE_HWB, state, true),
+		hex: getProperty(COLOR_TYPE.hex, instance as Color, state, subscriptions, false),
+		hexa: getProperty(COLOR_TYPE.hex, instance as Color, state, subscriptions, true),
+		hsl: getProperty(COLOR_TYPE.hsl, instance as Color, state, subscriptions, false),
+		hsla: getProperty(COLOR_TYPE.hsl, instance as Color, state, subscriptions, true),
+		hwb: getProperty(COLOR_TYPE.hwb, instance as Color, state, subscriptions, false),
+		hwba: getProperty(COLOR_TYPE.hwb, instance as Color, state, subscriptions, true),
 		origin: {
 			enumerable: true,
 			get: () => state.origin,
 		},
-		rgb: getProperty(TYPE_RGB, state, false),
-		rgba: getProperty(TYPE_RGB, state, true),
+		rgb: getProperty(COLOR_TYPE.rgb, instance as Color, state, subscriptions, false),
+		rgba: getProperty(COLOR_TYPE.rgb, instance as Color, state, subscriptions, true),
 	});
 
 	return Object.freeze(instance) as Color;
@@ -62,7 +81,9 @@ export function color(value: unknown): Color {
 
 function getProperty(
 	space: keyof typeof setters,
+	color: Color,
 	state: ColorState,
+	subscriptions: Subscriptions<Function>,
 	alpha: boolean,
 ): PropertyDescriptor {
 	const setValue = setters[space];
@@ -70,7 +91,7 @@ function getProperty(
 	return {
 		enumerable: true,
 		get: () => getValue(space, state, alpha),
-		set: (value: unknown) => setValue(state, value, alpha),
+		set: (value: unknown) => setValue(color, state, subscriptions, value, alpha),
 	};
 }
 
@@ -95,10 +116,42 @@ function setAlphaValue(state: ColorState, value: unknown): void {
 	}
 }
 
+function subscribeToColor(
+	subscriptions: Subscriptions,
+	first: unknown,
+	second?: unknown,
+): Subscription {
+	let key: string | undefined;
+	let value: Function | undefined;
+
+	if (typeof first === 'string') {
+		key = first;
+		value = second as Function;
+	} else if (typeof first === 'function') {
+		value = first;
+	}
+
+	if (typeof value !== 'function') {
+		throw new Error();
+	}
+
+	return getSubscription({
+		key,
+		subscriptions,
+		value,
+		property: colorSubscription,
+	});
+}
+
 // #endregion
 
 // #region Variables
 
+const colorSubscription: SubscriptionProperty = {
+	key: COLOR_PROPERTY.name,
+	value: COLOR_PROPERTY.subscription,
+};
+
 const setters: SetValues = {
 	hex: setHexColor,
 	hsl: setHSLColor,

package/src/color/misc/alpha.ts

@@ -1,14 +1,6 @@
-import {clamp} from '../..';
 import {round} from '../../internal/math/misc';
-import {
-	ALPHA_FULL_HEX_LONG,
-	ALPHA_NONE_HEX,
-	ALPHA_NONE_VALUE,
-	DEFAULT_ALPHA,
-	EXPRESSION_ALPHA_HEX,
-	MAX_HEX,
-	MAX_PERCENT,
-} from '../constants';
+import {clamp} from '../../internal/number';
+import {COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_MAX} from '../constants';
 import type {Alpha} from '../models';
 
 // #region Functions
@@ -18,14 +10,14 @@ export function getAlpha(value: unknown, hex: boolean): Alpha {
 		return getAlphaFromValue(value);
 	}
 
-	if (typeof value !== 'string' || value.toLowerCase() === ALPHA_FULL_HEX_LONG) {
-		return {...DEFAULT_ALPHA};
+	if (typeof value !== 'string' || value.toLowerCase() === COLOR_ALPHA.fullHexLong) {
+		return {...COLOR_DEFAULTS.alpha};
 	}
 
-	if (hex && EXPRESSION_ALPHA_HEX.test(value)) {
+	if (hex && COLOR_EXPRESSION.alphaHex.test(value)) {
 		return {
 			hex: value,
-			value: Number.parseInt(value, 16) / MAX_HEX,
+			value: Number.parseInt(value, 16) / COLOR_MAX.hex,
 		};
 	}
 
@@ -33,15 +25,15 @@ export function getAlpha(value: unknown, hex: boolean): Alpha {
 }
 
 export function getAlphaHexadecimal(value: number): string {
-	if (value === ALPHA_NONE_VALUE) {
-		return ALPHA_NONE_HEX;
+	if (value === COLOR_ALPHA.noneValue) {
+		return COLOR_ALPHA.noneHex;
 	}
 
-	if (value === MAX_PERCENT) {
-		return ALPHA_FULL_HEX_LONG;
+	if (value === COLOR_MAX.percent) {
+		return COLOR_ALPHA.fullHexLong;
 	}
 
-	return round((value / MAX_PERCENT) * MAX_HEX).toString(16);
+	return round((value / COLOR_MAX.percent) * COLOR_MAX.hex).toString(16);
 }
 
 function getAlphaFromValue(value: number): Alpha {
@@ -55,10 +47,10 @@ function getAlphaFromValue(value: number): Alpha {
 
 export function getAlphaValue(original: number): number {
 	if (Number.isNaN(original)) {
-		return MAX_PERCENT;
+		return COLOR_MAX.percent;
 	}
 
-	return clamp(original, ALPHA_NONE_VALUE, MAX_PERCENT);
+	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
 
 // #endregion