@oscarpalmer/atoms 0.190.0 → 0.192.0

package/src/color/misc/is.ts

@@ -1,21 +1,13 @@
+import {isPlainObject} from '../../internal/is';
 import {between} from '../../internal/number';
 import type {PlainObject} from '../../models';
 import {
-	ALPHA_NONE_VALUE,
-	EXPRESSION_HEX_LONG,
-	EXPRESSION_HEX_SHORT,
-	EXPRESSION_PREFIX,
-	KEYS_HSL,
-	KEYS_HSLA,
-	KEYS_HWB,
-	KEYS_HWBA,
-	KEYS_RGB,
-	KEYS_RGBA,
-	LENGTH_LONG,
-	LENGTH_SHORT,
-	MAX_DEGREE,
-	MAX_HEX,
-	MAX_PERCENT,
+	COLOR_ALPHA,
+	COLOR_EXPRESSION,
+	COLOR_KEYS,
+	COLOR_LENGTHS,
+	COLOR_MAX,
+	COLOR_PROPERTY,
 } from '../constants';
 import type {Color} from '../index';
 import type {
@@ -35,11 +27,11 @@ function hasKeys(value: unknown, keys: ColorProperty[]): boolean {
 }
 
 function isAlpha(value: unknown): value is number {
-	return typeof value === 'number' && between(value, ALPHA_NONE_VALUE, MAX_PERCENT);
+	return typeof value === 'number' && between(value, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
 
 function isBytey(value: unknown): value is number {
-	return typeof value === 'number' && between(value, 0, MAX_HEX);
+	return typeof value === 'number' && between(value, 0, COLOR_MAX.hex);
 }
 
 /**
@@ -49,7 +41,9 @@ function isBytey(value: unknown): value is number {
  * @returns `true` if the value is a _Color_, otherwise `false`
  */
 export function isColor(value: unknown): value is Color {
-	return typeof value === 'object' && value !== null && '$color' in value && value.$color === true;
+	return (
+		isPlainObject(value) && COLOR_PROPERTY.name in value && value[COLOR_PROPERTY.name] === true
+	);
 }
 
 function isColorValue(obj: unknown, properties: ColorProperty[]): boolean {
@@ -81,7 +75,7 @@ function isColorValue(obj: unknown, properties: ColorProperty[]): boolean {
 }
 
 function isDegree(value: unknown): value is number {
-	return typeof value === 'number' && between(value, 0, MAX_DEGREE);
+	return typeof value === 'number' && between(value, 0, COLOR_MAX.degree);
 }
 
 /**
@@ -105,14 +99,16 @@ export function isHexColor(value: unknown, alpha?: boolean): value is string {
 		return false;
 	}
 
-	if (!(EXPRESSION_HEX_SHORT.test(value) || EXPRESSION_HEX_LONG.test(value))) {
+	if (!(COLOR_EXPRESSION.hexShort.test(value) || COLOR_EXPRESSION.hexLong.test(value))) {
 		return false;
 	}
 
 	if (alpha === false) {
-		const unprefixed = value.replace(EXPRESSION_PREFIX, '');
+		const unprefixed = value.replace(COLOR_EXPRESSION.prefix, '');
 
-		return unprefixed.length === LENGTH_SHORT || unprefixed.length === LENGTH_LONG;
+		return (
+			unprefixed.length === COLOR_LENGTHS.hexShort || unprefixed.length === COLOR_LENGTHS.hexLong
+		);
 	}
 
 	return true;
@@ -125,17 +121,11 @@ export function isHexColor(value: unknown, alpha?: boolean): value is string {
  * @returns `true` if the value is an _HSLA_ color, otherwise `false`
  */
 export function isHslaColor(value: unknown): value is HSLAColor {
-	return isColorValue(value, KEYS_HSLA);
+	return isColorValue(value, COLOR_KEYS.hsla);
 }
 
-/**
- * Is the value like an _HSLA_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is like an _HSLA_ color, otherwise `false`
- */
 export function isHslaLike(value: unknown): value is Record<keyof HSLAColor, unknown> {
-	return hasKeys(value, KEYS_HSLA);
+	return hasKeys(value, COLOR_KEYS.hsla);
 }
 
 /**
@@ -145,17 +135,11 @@ export function isHslaLike(value: unknown): value is Record<keyof HSLAColor, unk
  * @returns `true` if the value is an _HSL_ color, otherwise `false`
  */
 export function isHslColor(value: unknown): value is HSLColor {
-	return isColorValue(value, KEYS_HSLA) || isColorValue(value, KEYS_HSL);
+	return isColorValue(value, COLOR_KEYS.hsla) || isColorValue(value, COLOR_KEYS.hsl);
 }
 
-/**
- * Is the value like an _HSL_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is like an _HSL_ color, otherwise `false`
- */
 export function isHslLike(value: unknown): value is Record<keyof HSLColor, unknown> {
-	return hasKeys(value, KEYS_HSL);
+	return hasKeys(value, COLOR_KEYS.hsl);
 }
 
 /**
@@ -165,17 +149,11 @@ export function isHslLike(value: unknown): value is Record<keyof HSLColor, unkno
  * @returns `true` if the value is an _HWBA_ color, otherwise `false`
  */
 export function isHwbaColor(value: unknown): value is HWBAColor {
-	return isColorValue(value, KEYS_HWBA);
+	return isColorValue(value, COLOR_KEYS.hwba);
 }
 
-/**
- * Is the value like an _HWBA_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is like an _HWBA_ color, otherwise `false`
- */
 export function isHwbaLike(value: unknown): value is Record<keyof HWBAColor, unknown> {
-	return hasKeys(value, KEYS_HWBA);
+	return hasKeys(value, COLOR_KEYS.hwba);
 }
 
 /**
@@ -185,17 +163,11 @@ export function isHwbaLike(value: unknown): value is Record<keyof HWBAColor, unk
  * @returns `true` if the value is an _HWB_ color, otherwise `false`
  */
 export function isHwbColor(value: unknown): value is HWBColor {
-	return isColorValue(value, KEYS_HWB) || isColorValue(value, KEYS_HWBA);
+	return isColorValue(value, COLOR_KEYS.hwb) || isColorValue(value, COLOR_KEYS.hwba);
 }
 
-/**
- * Is the value like an _HWB_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is like an _HWB_ color, otherwise `false`
- */
 export function isHwbLike(value: unknown): value is Record<keyof HWBColor, unknown> {
-	return hasKeys(value, KEYS_HWB);
+	return hasKeys(value, COLOR_KEYS.hwb);
 }
 
 /**
@@ -205,17 +177,11 @@ export function isHwbLike(value: unknown): value is Record<keyof HWBColor, unkno
  * @returns `true` if the value is an _RGBA_ color, otherwise `false`
  */
 export function isRgbaColor(value: unknown): value is RGBAColor {
-	return isColorValue(value, KEYS_RGBA);
+	return isColorValue(value, COLOR_KEYS.rgba);
 }
 
-/**
- * Is the value like an _RGBA_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is like an _RGBA_ color, otherwise `false`
- */
 export function isRgbaLike(value: unknown): value is Record<keyof RGBAColor, unknown> {
-	return hasKeys(value, KEYS_RGBA);
+	return hasKeys(value, COLOR_KEYS.rgba);
 }
 
 /**
@@ -225,21 +191,15 @@ export function isRgbaLike(value: unknown): value is Record<keyof RGBAColor, unk
  * @returns `true` if the value is an _RGB_ color, otherwise `false`
  */
 export function isRgbColor(value: unknown): value is RGBColor {
-	return isColorValue(value, KEYS_RGBA) || isColorValue(value, KEYS_RGB);
+	return isColorValue(value, COLOR_KEYS.rgba) || isColorValue(value, COLOR_KEYS.rgb);
 }
 
-/**
- * Is the value like an _RGB_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is like an _RGB_ color, otherwise `false`
- */
 export function isRgbLike(value: unknown): value is Record<keyof RGBColor, unknown> {
-	return hasKeys(value, KEYS_RGB);
+	return hasKeys(value, COLOR_KEYS.rgb);
 }
 
 function isPercentage(value: unknown): value is number {
-	return typeof value === 'number' && between(value, 0, MAX_PERCENT);
+	return typeof value === 'number' && between(value, 0, COLOR_MAX.percent);
 }
 
 // #endregion

package/src/color/misc/state.ts

@@ -1,16 +1,9 @@
-import {
-	DEFAULT_HSL,
-	DEFAULT_HWB,
-	DEFAULT_RGB,
-	HEX_BLACK,
-	KEYS_HSL,
-	KEYS_HWB,
-	KEYS_RGB,
-	LENGTH_LONG,
-	MAX_PERCENT,
-} from '../constants';
+import type {Subscriptions} from '../../internal/subscription';
+import {COLOR_DEFAULTS, COLOR_KEYS, COLOR_LENGTHS, COLOR_MAX, COLOR_TYPE} from '../constants';
 import type {
+	Color,
 	ColorState,
+	ColorType,
 	HSLAColor,
 	HSLColor,
 	HWBAColor,
@@ -18,202 +11,233 @@ import type {
 	RGBAColor,
 	RGBColor,
 } from '../models';
-import {getNormalizedHex, hexToHsl, hexToRgb} from '../space/hex';
-import {getHslValue, hslToHex, hslToHwb, hslToRgb} from '../space/hsl';
-import {getHwbValue, hwbToHex, hwbToHsl, hwbToRgb} from '../space/hwb';
-import {getRgbValue, rgbToHex, rgbToHsl, rgbToHwb} from '../space/rgb';
+import {getColorFromHex, getNormalizedHex} from '../space/hex';
+import {getColorFromHsl, getHslValue} from '../space/hsl';
+import {getColorFromHwb, getHwbValue} from '../space/hwb';
+import {getColorFromRgb, getRgbValue} from '../space/rgb';
 import {getAlpha} from './alpha';
 import {getDegrees, getHexValue, getPercentage} from './get';
 import {isColor, isHexColor, isHslLike, isHwbLike, isRgbLike} from './is';
 
 // #region Functions
 
+export function getColorFromState<Type extends ColorType>(
+	state: ColorState,
+	type: Type,
+): NonNullable<ColorState[Type]> {
+	const {origin} = state;
+
+	if (type === origin) {
+		return state[origin] as NonNullable<ColorState[Type]>;
+	}
+
+	return state[type] ?? (getters[origin](state, type) as NonNullable<ColorState[Type]>);
+}
+
 export function getColorState(value: unknown): ColorState {
 	if (typeof value === 'string') {
 		return getColorStateForHex(value);
 	}
 
 	if (isColor(value)) {
+		const {origin} = value;
+
 		return {
-			hex: value.hex,
-			hsl: value.hsl,
-			hwb: value.hwb,
-			rgb: value.rgb,
-			alpha: getAlpha(value.alpha),
+			origin,
+			[origin]: value[origin],
+			alpha: getAlpha(value.alpha, false),
 		};
 	}
 
-	const state: Partial<ColorState> = {};
-
 	if (typeof value === 'object' && value !== null) {
-		state.alpha = getAlpha((value as HSLAColor).alpha);
-
-		if (KEYS_HSL.every(key => key in value)) {
-			return getColorStateForHsl(state, value as Record<keyof HSLColor, unknown>);
-		}
+		const state: ColorState = {
+			alpha: getAlpha((value as HSLAColor).alpha, false),
+			origin: undefined as never,
+		};
 
-		if (KEYS_HWB.every(key => key in value)) {
-			return getColorStateForHwb(state, value as Record<keyof HWBColor, unknown>);
+		if (COLOR_KEYS.hsl.every(key => key in value)) {
+			state.hsl = getHslValue(value as Record<keyof HSLColor, unknown>);
+			state.origin = COLOR_TYPE.hsl;
+		} else if (COLOR_KEYS.hwb.every(key => key in value)) {
+			state.hwb = getHwbValue(value as Record<keyof HWBColor, unknown>);
+			state.origin = COLOR_TYPE.hwb;
+		} else if (COLOR_KEYS.rgb.every(key => key in value)) {
+			state.rgb = getRgbValue(value as Record<keyof RGBColor, unknown>);
+			state.origin = COLOR_TYPE.rgb;
 		}
 
-		if (KEYS_RGB.every(key => key in value)) {
-			return getColorStateForRgb(state, value as Record<keyof RGBColor, unknown>);
+		if (state.origin != null) {
+			return state;
 		}
 	}
 
-	return getDefaultColorState(state);
+	return getDefaultColorState();
 }
 
 function getColorStateForHex(value: string): ColorState {
 	const normalized = getNormalizedHex(value, true);
-	const hex = normalized.slice(0, LENGTH_LONG);
-
-	const hsl = hexToHsl(hex);
+	const hex = normalized.slice(0, COLOR_LENGTHS.hexLong);
 
 	return {
 		hex,
-		hsl,
-		alpha: getAlpha(normalized.slice(LENGTH_LONG)),
-		hwb: hslToHwb(hsl),
-		rgb: hslToRgb(hsl),
+		alpha: getAlpha(normalized.slice(COLOR_LENGTHS.hexLong), true),
+		origin: COLOR_TYPE.hex,
 	};
 }
 
-function getColorStateForHsl(
-	state: Partial<ColorState>,
-	value: Record<keyof HSLColor, unknown>,
-): ColorState {
-	state.hsl = getHslValue(value);
-
-	state.rgb = hslToRgb(state.hsl);
-	state.hex = hslToHex(state.hsl);
-	state.hwb = hslToHwb(state.hsl);
-
-	return state as ColorState;
-}
-
-function getColorStateForHwb(
-	state: Partial<ColorState>,
-	value: Record<keyof HWBColor, unknown>,
-): ColorState {
-	state.hwb = getHwbValue(value);
-
-	state.hsl = hwbToHsl(state.hwb);
-	state.rgb = hwbToRgb(state.hwb);
-	state.hex = hwbToHex(state.hwb);
-
-	return state as ColorState;
+function getDefaultColorState(): ColorState {
+	return {
+		alpha: getAlpha(COLOR_MAX.percent, false),
+		hex: COLOR_DEFAULTS.hexBlack,
+		hsl: {...COLOR_DEFAULTS.hsl},
+		hwb: {...COLOR_DEFAULTS.hwb},
+		rgb: {...COLOR_DEFAULTS.rgb},
+		origin: COLOR_TYPE.hex,
+	};
 }
 
-function getColorStateForRgb(
-	state: Partial<ColorState>,
-	value: Record<keyof RGBColor, unknown>,
-): ColorState {
-	state.rgb = getRgbValue(value);
-
-	state.hex = rgbToHex(state.rgb);
-	state.hsl = rgbToHsl(state.rgb);
-	state.hwb = rgbToHwb(state.rgb);
+function setColorValue<Type extends ColorType>(
+	color: Color,
+	state: ColorState,
+	subscriptions: Subscriptions<Function>,
+	type: Type,
+	value: ColorState[Type],
+	alpha?: number | string,
+): void {
+	state.hex = undefined;
+	state.hsl = undefined;
+	state.hwb = undefined;
+	state.rgb = undefined;
+
+	state.origin = type;
+	state[type] = value;
+
+	if (alpha != null) {
+		state.alpha = getAlpha(alpha, type === COLOR_TYPE.hex);
+	}
 
-	return state as ColorState;
-}
+	for (const type of COLOR_TYPE.all) {
+		const callbacks = subscriptions.values.to.keyed?.get(type);
 
-function getDefaultColorState(state: Partial<ColorState>): ColorState {
-	state.alpha = getAlpha(MAX_PERCENT);
-	state.hex = HEX_BLACK;
-	state.hsl = {...DEFAULT_HSL};
-	state.hwb = {...DEFAULT_HWB};
-	state.rgb = {...DEFAULT_RGB};
+		if (callbacks != null) {
+			for (const callback of callbacks.values()) {
+				callback(color[type]);
+			}
+		}
+	}
 
-	return state as ColorState;
+	for (const callback of subscriptions.values.to.any.values()) {
+		callback(color);
+	}
 }
 
-export function setHexColor(state: ColorState, value: string, alpha: boolean): void {
+export function setHexColor(
+	color: Color,
+	state: ColorState,
+	subscriptions: Subscriptions<Function>,
+	value: string,
+	alpha: boolean,
+): void {
 	if (!isHexColor(value) || (!alpha && value === state.hex)) {
 		return;
 	}
 
 	const normalized = getNormalizedHex(value, true);
-	const hex = normalized.slice(0, LENGTH_LONG);
-	const hsl = hexToHsl(hex);
 
-	state.hex = hex;
-	state.hsl = hsl;
-
-	state.rgb = hslToRgb(hsl);
-	state.hwb = hslToHwb(hsl);
-
-	if (alpha) {
-		state.alpha = getAlpha(normalized.slice(LENGTH_LONG));
-	}
+	setColorValue(
+		color,
+		state,
+		subscriptions,
+		COLOR_TYPE.hex,
+		normalized.slice(0, COLOR_LENGTHS.hexLong),
+		alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : undefined,
+	);
 }
 
-export function setHSLColor(state: ColorState, value: unknown, alpha: boolean): void {
+export function setHSLColor(
+	color: Color,
+	state: ColorState,
+	subscriptions: Subscriptions<Function>,
+	value: unknown,
+	alpha: boolean,
+): void {
 	if (!isHslLike(value)) {
 		return;
 	}
 
-	const hsl = {
-		hue: getDegrees((value as HSLColor).hue),
-		saturation: getPercentage((value as HSLColor).saturation),
-		lightness: getPercentage((value as HSLColor).lightness),
-	};
-
-	state.hsl = hsl;
-
-	state.hex = hslToHex(hsl);
-	state.hwb = hslToHwb(hsl);
-	state.rgb = hslToRgb(hsl);
-
-	if (alpha) {
-		state.alpha = getAlpha((value as HSLAColor).alpha);
-	}
+	setColorValue(
+		color,
+		state,
+		subscriptions,
+		COLOR_TYPE.hsl,
+		{
+			hue: getDegrees((value as HSLColor).hue),
+			saturation: getPercentage((value as HSLColor).saturation),
+			lightness: getPercentage((value as HSLColor).lightness),
+		},
+		alpha ? (value as HSLAColor).alpha : undefined,
+	);
 }
 
-export function setHWBColor(state: ColorState, value: unknown, alpha: boolean): void {
+export function setHWBColor(
+	color: Color,
+	state: ColorState,
+	subscriptions: Subscriptions<Function>,
+	value: unknown,
+	alpha: boolean,
+): void {
 	if (!isHwbLike(value)) {
 		return;
 	}
 
-	const hwb = {
-		hue: getDegrees((value as HWBColor).hue),
-		whiteness: getPercentage((value as HWBColor).whiteness),
-		blackness: getPercentage((value as HWBColor).blackness),
-	};
-
-	state.hwb = hwb;
-
-	state.hex = hwbToHex(hwb);
-	state.hsl = hwbToHsl(hwb);
-	state.rgb = hwbToRgb(hwb);
-
-	if (alpha) {
-		state.alpha = getAlpha((value as HWBAColor).alpha);
-	}
+	setColorValue(
+		color,
+		state,
+		subscriptions,
+		COLOR_TYPE.hwb,
+		{
+			hue: getDegrees((value as HWBColor).hue),
+			whiteness: getPercentage((value as HWBColor).whiteness),
+			blackness: getPercentage((value as HWBColor).blackness),
+		},
+		alpha ? (value as HWBAColor).alpha : undefined,
+	);
 }
 
-export function setRGBColor(state: ColorState, value: unknown, alpha: boolean): void {
+export function setRGBColor(
+	color: Color,
+	state: ColorState,
+	subscriptions: Subscriptions<Function>,
+	value: unknown,
+	alpha: boolean,
+): void {
 	if (!isRgbLike(value)) {
 		return;
 	}
 
-	const rgb = {
-		blue: getHexValue((value as RGBColor).blue),
-		green: getHexValue((value as RGBColor).green),
-		red: getHexValue((value as RGBColor).red),
-	};
-
-	const hsl = rgbToHsl(rgb);
+	setColorValue(
+		color,
+		state,
+		subscriptions,
+		COLOR_TYPE.rgb,
+		{
+			red: getHexValue((value as RGBColor).red),
+			green: getHexValue((value as RGBColor).green),
+			blue: getHexValue((value as RGBColor).blue),
+		},
+		alpha ? (value as RGBAColor).alpha : undefined,
+	);
+}
 
-	state.hsl = hsl;
-	state.rgb = rgb;
+// #endregion
 
-	state.hex = hslToHex(hsl);
-	state.hwb = hslToHwb(hsl);
+// #region Variables
 
-	if (alpha) {
-		state.alpha = getAlpha((value as RGBAColor).alpha);
-	}
-}
+const getters: Record<ColorType, (state: ColorState, type: ColorType) => any> = {
+	hex: getColorFromHex,
+	hsl: getColorFromHsl,
+	hwb: getColorFromHwb,
+	rgb: getColorFromRgb,
+};
 
 // #endregion