@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/color/instance.ts

@@ -1,162 +0,0 @@
-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 {
-	getColorFromState,
-	getColorState,
-	setHexColor,
-	setHSLColor,
-	setHWBColor,
-	setRGBColor,
-} from './misc/state';
-import type {Color, ColorState, ColorType} from './models';
-
-// #region Types
-
-type SetValue = (
-	color: Color,
-	state: ColorState,
-	subscriptions: Subscriptions<Function>,
-	value: any,
-	alpha: boolean,
-) => void;
-
-type SetValues = Record<ColorType, SetValue>;
-
-// #endregion
-
-// #region Functions
-
-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, {
-		[COLOR_PROPERTY.name]: {
-			enumerable: false,
-			value: true,
-		},
-		alpha: {
-			enumerable: true,
-			get: () => state.alpha.value,
-			set: (value: unknown) => setAlphaValue(state, value),
-		},
-		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(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;
-}
-
-function getProperty(
-	space: keyof typeof setters,
-	color: Color,
-	state: ColorState,
-	subscriptions: Subscriptions<Function>,
-	alpha: boolean,
-): PropertyDescriptor {
-	const setValue = setters[space];
-
-	return {
-		enumerable: true,
-		get: () => getValue(space, state, alpha),
-		set: (value: unknown) => setValue(color, state, subscriptions, value, alpha),
-	};
-}
-
-function getValue(space: keyof typeof setters, state: ColorState, alpha: boolean) {
-	const value = getColorFromState(state, space);
-
-	if (typeof value === 'string') {
-		return alpha ? `${value}${state.alpha.hex}` : value;
-	}
-
-	return alpha
-		? {
-				...value,
-				alpha: state.alpha.value,
-			}
-		: {...value};
-}
-
-function setAlphaValue(state: ColorState, value: unknown): void {
-	if (typeof value === 'number' && !Number.isNaN(value)) {
-		state.alpha = getAlpha(value, false);
-	}
-}
-
-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,
-	hwb: setHWBColor,
-	rgb: setRGBColor,
-};
-
-// #endregion

package/src/color/misc/alpha.ts

@@ -1,56 +0,0 @@
-import {round} from '../../internal/math/misc';
-import {clamp} from '../../internal/number';
-import {COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_MAX} from '../constants';
-import type {Alpha} from '../models';
-
-// #region Functions
-
-export function getAlpha(value: unknown, hex: boolean): Alpha {
-	if (typeof value === 'number') {
-		return getAlphaFromValue(value);
-	}
-
-	if (typeof value !== 'string' || value.toLowerCase() === COLOR_ALPHA.fullHexLong) {
-		return {...COLOR_DEFAULTS.alpha};
-	}
-
-	if (hex && COLOR_EXPRESSION.alphaHex.test(value)) {
-		return {
-			hex: value,
-			value: Number.parseInt(value, 16) / COLOR_MAX.hex,
-		};
-	}
-
-	return getAlphaFromValue(Number.parseFloat(value));
-}
-
-export function getAlphaHexadecimal(value: number): string {
-	if (value === COLOR_ALPHA.noneValue) {
-		return COLOR_ALPHA.noneHex;
-	}
-
-	if (value === COLOR_MAX.percent) {
-		return COLOR_ALPHA.fullHexLong;
-	}
-
-	return round((value / COLOR_MAX.percent) * COLOR_MAX.hex).toString(16);
-}
-
-function getAlphaFromValue(value: number): Alpha {
-	const alpha = getAlphaValue(value);
-
-	return {
-		hex: getAlphaHexadecimal(alpha),
-		value: alpha,
-	};
-}
-
-export function getAlphaValue(original: number): number {
-	if (Number.isNaN(original)) {
-		return COLOR_MAX.percent;
-	}
-
-	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
-}
-
-// #endregion

package/src/color/misc/format.ts

@@ -1,29 +0,0 @@
-import {COLOR_TYPE} from '../constants';
-import type {ColorState} from '../models';
-import {getColorFromState} from './state';
-
-// #region Functions
-
-export function formatHslColor(state: ColorState, alpha?: boolean): string {
-	const {hue, lightness, saturation} = getColorFromState(state, COLOR_TYPE.hsl);
-
-	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(state, alpha)})`;
-}
-
-export function formatHwbColor(state: ColorState, alpha?: boolean): string {
-	const {blackness, hue, whiteness} = getColorFromState(state, COLOR_TYPE.hwb);
-
-	return `hwb(${hue}deg ${whiteness}% ${blackness}%${getSuffix(state, alpha)})`;
-}
-
-export function formatRgbColor(state: ColorState, alpha?: boolean): string {
-	const {blue, green, red} = getColorFromState(state, COLOR_TYPE.rgb);
-
-	return `rgb(${red} ${green} ${blue}${getSuffix(state, alpha)})`;
-}
-
-function getSuffix(state: ColorState, alpha?: boolean): string {
-	return alpha === true ? ` / ${state.alpha.value}%` : '';
-}
-
-// #endregion

package/src/color/misc/get.ts

@@ -1,210 +0,0 @@
-import {round} from '../../internal/math/misc';
-import {clamp} from '../../internal/number';
-import {COLOR_DEFAULTS, COLOR_MAX, COLOR_SRGB, COLOR_TYPE} from '../constants';
-import {color} from '../instance';
-import type {Color, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor} from '../models';
-import {getColorFromState, getColorState} from './state';
-
-// #region Functions
-
-function getClampedValue(
-	value: unknown,
-	minimum: number,
-	maximum: number,
-	rounding?: boolean,
-): number {
-	return typeof value === 'number' && !Number.isNaN(value)
-		? clamp((rounding ?? false) ? round(value) : value, minimum, maximum)
-		: minimum;
-}
-
-/**
- * Get a foreground color _(usually text)_ based on a background color's luminance as an unprefixed hex color string
- *
- * - 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 cannot be parsed, a white foreground color will be returned
- *
- * @param value Original value
- * @returns Foreground color
- */
-export function getForegroundColor(value: unknown, hex: true): string;
-
-/**
- * Get a foreground color _(usually text)_ based on a background color's luminance
- *
- * - 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 cannot be parsed, a white foreground color will be returned
- *
- * @param value Original value
- * @returns Foreground color
- */
-export function getForegroundColor(value: unknown): Color;
-
-export function getForegroundColor(value: unknown, hex?: unknown): string | Color {
-	const rgb = getColorFromState(getColorState(value), COLOR_TYPE.rgb);
-	const {blue, green, red} = rgb;
-
-	const values = [blue / COLOR_MAX.hex, green / COLOR_MAX.hex, red / COLOR_MAX.hex];
-	const {length} = values;
-
-	for (let index = 0; index < length; index += 1) {
-		const color = values[index];
-
-		if (color <= COLOR_SRGB.luminanceMinimum) {
-			values[index] /= COLOR_SRGB.luminanceMultiplier;
-		} else {
-			values[index] =
-				((color + COLOR_SRGB.luminanceOffset) / COLOR_SRGB.luminanceModifier) **
-				COLOR_SRGB.luminanceExponent;
-		}
-	}
-
-	const luminance =
-		COLOR_SRGB.luminanceRed * values[2] +
-		COLOR_SRGB.luminanceGreen * values[1] +
-		COLOR_SRGB.luminanceBlue * values[0];
-
-	// Rudimentary and ureliable?; implement APCA for more reliable results?
-	const foreground =
-		luminance > COLOR_SRGB.luminanceThreshold ? COLOR_DEFAULTS.hexBlack : COLOR_DEFAULTS.hexWhite;
-
-	return hex === true ? foreground : color(foreground);
-}
-
-/**
- * Get the hex color _(with alpha channel, i.e., opacity)_ 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 cannot be parsed, a black hex color will be returned
- *
- * @param value Original value
- * @returns Hex color string
- */
-export function getHexaColor(value: unknown): string {
-	const {alpha, hex} = getColorState(value);
-
-	return `${hex}${alpha.hex}`;
-}
-
-/**
- * Get the hex 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 cannot be parsed, a black hex color will be returned
- *
- * @param value Original value
- * @returns Hex color string
- */
-export function getHexColor(value: unknown): string {
-	return getColorFromState(getColorState(value), COLOR_TYPE.hex);
-}
-
-export function getHexValue(value: unknown): number {
-	return getClampedValue(value, 0, COLOR_MAX.hex, true);
-}
-
-export function getDegrees(value: unknown): number {
-	return getClampedValue(value, 0, COLOR_MAX.degree);
-}
-
-/**
- * Get the _HSLA_ 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 cannot be parsed, a black _HSLA_ color will be returned
- *
- * @param value Original value
- * @returns _HSLA_ color
- */
-export function getHslaColor(value: unknown): HSLAColor {
-	const state = getColorState(value);
-	const hsl = getColorFromState(state, COLOR_TYPE.hsl);
-
-	return {
-		...hsl,
-		alpha: state.alpha.value,
-	};
-}
-
-/**
- * Get the _HWB_ 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 cannot be parsed, a black _HWB_ color will be returned
- *
- * @param value Original value
- * @returns _HWB_ color
- */
-export function getHwbColor(value: unknown): HWBColor {
-	return getColorFromState(getColorState(value), COLOR_TYPE.hwb);
-}
-
-/**
- * Get the _HWBA_ 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 cannot be parsed, a black _HWBA_ color will be returned
- *
- * @param value Original value
- * @returns _HWBA_ color
- */
-export function getHwbaColor(value: unknown): HWBAColor {
-	const state = getColorState(value);
-	const hwb = getColorFromState(state, COLOR_TYPE.hwb);
-
-	return {
-		...hwb,
-		alpha: state.alpha.value,
-	};
-}
-
-/**
- * Get the _HSL_ 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 cannot be parsed, a black _HSL_ color will be returned
- *
- * @param value Original value
- * @returns _HSL_ color
- */
-export function getHslColor(value: unknown): HSLColor {
-	return getColorFromState(getColorState(value), COLOR_TYPE.hsl);
-}
-
-export function getPercentage(value: unknown): number {
-	return getClampedValue(value, 0, COLOR_MAX.percent);
-}
-
-/**
- * Get the _RGBA_ 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 cannot be parsed, a black _RGBA_ color will be returned
- *
- * @param value Original value
- * @returns _RGBA_ color
- */
-export function getRgbaColor(value: unknown): RGBAColor {
-	const state = getColorState(value);
-	const rgb = getColorFromState(state, COLOR_TYPE.rgb);
-
-	return {
-		...rgb,
-		alpha: state.alpha.value,
-	};
-}
-
-/**
- * Get the _RGB_ 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 cannot be parsed, a black _RGB_ color will be returned
- *
- * @param value Original value
- * @returns _RGB_ color
- */
-export function getRgbColor(value: unknown): RGBColor {
-	return getColorFromState(getColorState(value), COLOR_TYPE.rgb);
-}
-
-// #endregion

package/src/color/misc/is.ts

@@ -1,221 +0,0 @@
-import {isPlainObject} from '../../internal/is';
-import {between} from '../../internal/number';
-import type {PlainObject} from '../../models';
-import {
-	COLOR_ALPHA,
-	COLOR_EXPRESSION,
-	COLOR_KEYS,
-	COLOR_LENGTHS,
-	COLOR_MAX,
-	COLOR_PROPERTY,
-} from '../constants';
-import type {Color} from '../index';
-import type {
-	ColorProperty,
-	HSLAColor,
-	HSLColor,
-	HWBAColor,
-	HWBColor,
-	RGBAColor,
-	RGBColor,
-} from '../models';
-
-// ##region Functions
-
-function hasKeys(value: unknown, keys: ColorProperty[]): boolean {
-	return typeof value === 'object' && value !== null && keys.every(key => key in value);
-}
-
-function isAlpha(value: unknown): value is number {
-	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, COLOR_MAX.hex);
-}
-
-/**
- * Is the value a _Color_?
- *
- * @param value Value to check
- * @returns `true` if the value is a _Color_, otherwise `false`
- */
-export function isColor(value: unknown): value is Color {
-	return (
-		isPlainObject(value) && COLOR_PROPERTY.name in value && value[COLOR_PROPERTY.name] === true
-	);
-}
-
-function isColorValue(obj: unknown, properties: ColorProperty[]): boolean {
-	if (typeof obj !== 'object' || obj === null) {
-		return false;
-	}
-
-	const keys = Object.keys(obj);
-	const {length} = keys;
-
-	if (length !== properties.length) {
-		return false;
-	}
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-
-		if (
-			!(
-				properties.includes(key as never) &&
-				validators[key as ColorProperty]((obj as PlainObject)[key])
-			)
-		) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function isDegree(value: unknown): value is number {
-	return typeof value === 'number' && between(value, 0, COLOR_MAX.degree);
-}
-
-/**
- * Is the value a hex color?
- *
- * @param value Value to check
- * @param alpha Allow alpha channel _(opacity)_? _(defaults to `true`)_
- * @returns `true` if the value is a hex color, otherwise `false`
- *
- * @example
- * ```typescript
- * isHexColor('ff0000');  // => true
- * isHexColor('#ff0000'); // => true
- *
- * isHexColor('#ff000050');        // => true
- * isHexColor('#ff000050', false); // => false
- * ```
- */
-export function isHexColor(value: unknown, alpha?: boolean): value is string {
-	if (typeof value !== 'string') {
-		return false;
-	}
-
-	if (!(COLOR_EXPRESSION.hexShort.test(value) || COLOR_EXPRESSION.hexLong.test(value))) {
-		return false;
-	}
-
-	if (alpha === false) {
-		const unprefixed = value.replace(COLOR_EXPRESSION.prefix, '');
-
-		return (
-			unprefixed.length === COLOR_LENGTHS.hexShort || unprefixed.length === COLOR_LENGTHS.hexLong
-		);
-	}
-
-	return true;
-}
-
-/**
- * Is the value an _HSLA_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is an _HSLA_ color, otherwise `false`
- */
-export function isHslaColor(value: unknown): value is HSLAColor {
-	return isColorValue(value, COLOR_KEYS.hsla);
-}
-
-export function isHslaLike(value: unknown): value is Record<keyof HSLAColor, unknown> {
-	return hasKeys(value, COLOR_KEYS.hsla);
-}
-
-/**
- * Is the value an _HSL_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is an _HSL_ color, otherwise `false`
- */
-export function isHslColor(value: unknown): value is HSLColor {
-	return isColorValue(value, COLOR_KEYS.hsla) || isColorValue(value, COLOR_KEYS.hsl);
-}
-
-export function isHslLike(value: unknown): value is Record<keyof HSLColor, unknown> {
-	return hasKeys(value, COLOR_KEYS.hsl);
-}
-
-/**
- * Is the value an _HWBA_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is an _HWBA_ color, otherwise `false`
- */
-export function isHwbaColor(value: unknown): value is HWBAColor {
-	return isColorValue(value, COLOR_KEYS.hwba);
-}
-
-export function isHwbaLike(value: unknown): value is Record<keyof HWBAColor, unknown> {
-	return hasKeys(value, COLOR_KEYS.hwba);
-}
-
-/**
- * Is the value an _HWB_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is an _HWB_ color, otherwise `false`
- */
-export function isHwbColor(value: unknown): value is HWBColor {
-	return isColorValue(value, COLOR_KEYS.hwb) || isColorValue(value, COLOR_KEYS.hwba);
-}
-
-export function isHwbLike(value: unknown): value is Record<keyof HWBColor, unknown> {
-	return hasKeys(value, COLOR_KEYS.hwb);
-}
-
-/**
- * Is the value an _RGBA_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is an _RGBA_ color, otherwise `false`
- */
-export function isRgbaColor(value: unknown): value is RGBAColor {
-	return isColorValue(value, COLOR_KEYS.rgba);
-}
-
-export function isRgbaLike(value: unknown): value is Record<keyof RGBAColor, unknown> {
-	return hasKeys(value, COLOR_KEYS.rgba);
-}
-
-/**
- * Is the value an _RGB_ color?
- *
- * @param value Value to check
- * @returns `true` if the value is an _RGB_ color, otherwise `false`
- */
-export function isRgbColor(value: unknown): value is RGBColor {
-	return isColorValue(value, COLOR_KEYS.rgba) || isColorValue(value, COLOR_KEYS.rgb);
-}
-
-export function isRgbLike(value: unknown): value is Record<keyof RGBColor, unknown> {
-	return hasKeys(value, COLOR_KEYS.rgb);
-}
-
-function isPercentage(value: unknown): value is number {
-	return typeof value === 'number' && between(value, 0, COLOR_MAX.percent);
-}
-
-// #endregion
-
-// #region Variables
-
-const validators: Record<ColorProperty, (value: unknown) => value is number> = {
-	alpha: isAlpha,
-	blackness: isPercentage,
-	blue: isBytey,
-	green: isBytey,
-	hue: isDegree,
-	lightness: isPercentage,
-	saturation: isPercentage,
-	red: isBytey,
-	whiteness: isPercentage,
-};
-
-// #endregion