@oscarpalmer/atoms 0.191.0 → 0.192.0

package/dist/beacon.d.mts

@@ -1,3 +1,4 @@
+import { Subscription } from "./internal/subscription.mjs";
 //#region src/beacon.d.ts
 /**
  * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
@@ -7,10 +8,6 @@ type Beacon<Value> = {
    * Is the beacon active?
    */
   get active(): boolean;
-  /**
-   * Is the beacon closed?
-   */
-  get closed(): boolean;
   /**
    * The observable that can be subscribed to
    */
@@ -20,9 +17,9 @@ type Beacon<Value> = {
    */
   get value(): Value;
   /**
-   * Close the beacon
+   * Deactivate the beacon
    */
-  close(): void;
+  deactivate(): void;
   /**
    * Emit a new value
    *
@@ -42,9 +39,6 @@ type Beacon<Value> = {
    */
   finish(): void;
 };
-/**
- * Options for Beacon
- */
 type BeaconOptions<Value> = {
   /**
    * Method for comparing values for equality
@@ -62,13 +56,9 @@ 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
    *
@@ -86,9 +76,6 @@ type Observable<Value> = {
    */
   subscribe(observer: Observer<Value>): Subscription;
 };
-/**
- * An observer receives notifications from an observable
- */
 type Observer<Value> = {
   /**
    * Callback for when the observable is completed
@@ -103,24 +90,6 @@ type Observer<Value> = {
    */
   next?: (value: Value) => void;
 };
-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;
-};
 /**
  * Create a new beacon
  *
@@ -143,12 +112,5 @@ declare function isBeacon<Value = unknown>(value: unknown): value is Beacon<Valu
  * @returns `true` if the value is an observable, otherwise `false`
  */
 declare function isObservable<Value = unknown>(value: unknown): value is Observable<Value>;
-/**
- * Is the value a subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a subscription, otherwise `false`
- */
-declare function isSubscription(value: unknown): value is Subscription;
 //#endregion
-export { Beacon, BeaconOptions, Observable, Subscription, beacon, isBeacon, isObservable, isSubscription };
+export { Beacon, BeaconOptions, Observable, beacon, isBeacon, isObservable };

package/dist/beacon.mjs

@@ -1,5 +1,6 @@
 import { noop } from "./internal/function/misc.mjs";
 import { isPlainObject } from "./internal/is.mjs";
+import { clearSubscriptions, getSubscription, getSubscriptions } from "./internal/subscription.mjs";
 //#region src/beacon.ts
 /**
 * Create a new beacon
@@ -13,11 +14,11 @@ function beacon(value, options) {
 		value,
 		active: true,
 		observable: void 0,
-		observers: /* @__PURE__ */ new Map(),
-		options: getBeaconOptions(options)
+		options: getBeaconOptions(options),
+		subscriptions: getSubscriptions()
 	};
 	const instance = {
-		close: () => {
+		deactivate: () => {
 			finishBeacon(state, false);
 		},
 		emit: (value, finish) => {
@@ -39,10 +40,6 @@ function beacon(value, options) {
 			enumerable: true,
 			get: () => state.active
 		},
-		closed: {
-			enumerable: true,
-			get: () => !state.active
-		},
 		observable: {
 			enumerable: true,
 			get: () => {
@@ -61,15 +58,9 @@ function beacon(value, options) {
 function finishBeacon(state, emit) {
 	if (!state.active) return;
 	state.active = false;
-	const entries = [...state.observers.entries()];
-	const { length } = entries;
-	for (let index = 0; index < length; index += 1) {
-		const [subscription, observer] = entries[index];
-		if (emit) observer.complete?.();
-		subscription.close();
-	}
-	state.observable?.close();
-	state.observers.clear();
+	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
+	clearSubscriptions(state.subscriptions);
+	state.observable?.deactivate();
 	state.observable = void 0;
 }
 function getBeaconOptions(input) {
@@ -115,29 +106,24 @@ function isBeaconInstance(name, value) {
 function isObservable(value) {
 	return isBeaconInstance(NAME_OBSERVABLE, value);
 }
-/**
-* Is the value a subscription?
-*
-* @param value Value to check
-* @returns `true` if the value is a subscription, otherwise `false`
-*/
-function isSubscription(value) {
-	return isBeaconInstance(NAME_SUBSCRIPTION, value);
-}
 function observe(beacon) {
 	const state = {
 		beacon,
 		active: beacon.active
 	};
 	const instance = {
-		close: () => {
+		deactivate: () => {
 			state.active = false;
 		},
 		subscribe(first, second, third) {
 			if (!beacon.active || !state.active) throw new Error(MESSAGE_OBSERVABLE);
 			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);
 			return subscription;
 		}
@@ -150,42 +136,6 @@ function observe(beacon) {
 		active: {
 			enumerable: true,
 			get: () => beacon.active && state.active
-		},
-		closed: {
-			enumerable: true,
-			get: () => !beacon.active || !state.active
-		}
-	});
-	return Object.freeze(instance);
-}
-function subscribe(observable) {
-	function unsubscribe() {
-		if (active) {
-			active = false;
-			observable.beacon.observers.delete(instance);
-		}
-	}
-	let active = true;
-	const instance = {
-		close: () => {
-			unsubscribe();
-		},
-		unsubscribe: () => {
-			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);
@@ -196,7 +146,7 @@ function update(type, state, value, finish) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.observers) observer[type]?.(value);
+	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
 	if (finish === true) finishBeacon(state, true);
 }
 const KEY_BEACON = "$beacon";
@@ -204,8 +154,11 @@ 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 NAME_SUBSCRIPTION = "subscription";
 const TYPE_ERROR = "error";
 const TYPE_NEXT = "next";
+const beaconSubscription = {
+	key: KEY_BEACON,
+	value: "subscription"
+};
 //#endregion
-export { beacon, isBeacon, isObservable, isSubscription };
+export { beacon, isBeacon, isObservable };

package/dist/color/constants.d.mts

@@ -1,43 +1,84 @@
-import { Alpha, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "./models.mjs";
+import { ColorTypeExtended, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "./models.mjs";
 //#region src/color/constants.d.ts
-declare const ALPHA_FULL_HEX_SHORT = "f";
-declare const ALPHA_FULL_HEX_LONG = "ff";
-declare const ALPHA_NONE_HEX = "00";
-declare const ALPHA_NONE_VALUE = 0;
-declare const DEFAULT_ALPHA: Alpha;
-declare const DEFAULT_HSL: HSLColor;
-declare const DEFAULT_HWB: HWBColor;
-declare const DEFAULT_RGB: RGBColor;
-declare const EXPRESSION_ALPHA_HEX: RegExp;
-declare const EXPRESSION_HEX_LONG: RegExp;
-declare const EXPRESSION_HEX_SHORT: RegExp;
-declare const EXPRESSION_PREFIX: RegExp;
-declare const HEX_BLACK = "000000";
-declare const HEX_WHITE = "ffffff";
-declare const LENGTH_LONG = 6;
-declare const LENGTH_SHORT = 3;
-declare const KEYS_HSL: Array<keyof HSLColor>;
-declare const KEYS_HSLA: Array<keyof HSLAColor>;
-declare const KEYS_HWB: Array<keyof HWBColor>;
-declare const KEYS_HWBA: Array<keyof HWBAColor>;
-declare const KEYS_RGB: Array<keyof RGBColor>;
-declare const KEYS_RGBA: Array<keyof RGBAColor>;
-declare const MAX_DEGREE = 360;
-declare const MAX_HEX = 255;
-declare const MAX_PERCENT = 100;
-declare const PROPERTY_COLOR = "$color";
-declare const TYPE_HEX = "hex";
-declare const TYPE_HSL = "hsl";
-declare const TYPE_HWB = "hwb";
-declare const TYPE_RGB = "rgb";
-declare const SRGB_LUMINANCE_BLUE = 0.0722;
-declare const SRGB_LUMINANCE_EXPONENT = 2.4;
-declare const SRGB_LUMINANCE_GREEN = 0.7152;
-declare const SRGB_LUMINANCE_MINIMUM = 0.03928;
-declare const SRGB_LUMINANCE_MODIFIER = 1.055;
-declare const SRGB_LUMINANCE_MULTIPLIER = 12.92;
-declare const SRGB_LUMINANCE_OFFSET = 0.055;
-declare const SRGB_LUMINANCE_RED = 0.2126;
-declare const SRGB_LUMINANCE_THRESHOLD = 0.625;
+type ColorTypes = {
+  all: Set<'alpha' | ColorTypeExtended>;
+  hex: 'hex';
+  hexa: 'hexa';
+  hsl: 'hsl';
+  hsla: 'hsla';
+  hwb: 'hwb';
+  hwba: 'hwba';
+  rgb: 'rgb';
+  rgba: 'rgba';
+};
+declare const COLOR_ALPHA: {
+  fullHexShort: string;
+  fullHexLong: string;
+  name: string;
+  noneHex: string;
+  noneValue: number;
+};
+declare const COLOR_DEFAULTS: {
+  alpha: {
+    hex: string;
+    value: number;
+  };
+  hexBlack: string;
+  hexWhite: string;
+  hsl: {
+    hue: number;
+    saturation: number;
+    lightness: number;
+  };
+  hwb: {
+    hue: number;
+    whiteness: number;
+    blackness: number;
+  };
+  rgb: {
+    blue: number;
+    green: number;
+    red: number;
+  };
+};
+declare const COLOR_EXPRESSION: {
+  alphaHex: RegExp;
+  hexLong: RegExp;
+  hexShort: RegExp;
+  prefix: RegExp;
+};
+declare const COLOR_LENGTHS: {
+  hexLong: number;
+  hexShort: number;
+};
+declare const COLOR_KEYS: {
+  hsl: Array<keyof HSLColor>;
+  hsla: Array<keyof HSLAColor>;
+  hwb: Array<keyof HWBColor>;
+  hwba: Array<keyof HWBAColor>;
+  rgb: Array<keyof RGBColor>;
+  rgba: Array<keyof RGBAColor>;
+};
+declare const COLOR_MAX: {
+  degree: number;
+  hex: number;
+  percent: number;
+};
+declare const COLOR_PROPERTY: {
+  name: string;
+  subscription: string;
+};
+declare const COLOR_TYPE: ColorTypes;
+declare const COLOR_SRGB: {
+  luminanceBlue: number;
+  luminanceExponent: number;
+  luminanceGreen: number;
+  luminanceMinimum: number;
+  luminanceModifier: number;
+  luminanceMultiplier: number;
+  luminanceOffset: number;
+  luminanceRed: number;
+  luminanceThreshold: number;
+};
 //#endregion
-export { ALPHA_FULL_HEX_LONG, ALPHA_FULL_HEX_SHORT, ALPHA_NONE_HEX, ALPHA_NONE_VALUE, DEFAULT_ALPHA, DEFAULT_HSL, DEFAULT_HWB, DEFAULT_RGB, EXPRESSION_ALPHA_HEX, EXPRESSION_HEX_LONG, EXPRESSION_HEX_SHORT, EXPRESSION_PREFIX, HEX_BLACK, HEX_WHITE, KEYS_HSL, KEYS_HSLA, KEYS_HWB, KEYS_HWBA, KEYS_RGB, KEYS_RGBA, LENGTH_LONG, LENGTH_SHORT, MAX_DEGREE, MAX_HEX, MAX_PERCENT, PROPERTY_COLOR, SRGB_LUMINANCE_BLUE, SRGB_LUMINANCE_EXPONENT, SRGB_LUMINANCE_GREEN, SRGB_LUMINANCE_MINIMUM, SRGB_LUMINANCE_MODIFIER, SRGB_LUMINANCE_MULTIPLIER, SRGB_LUMINANCE_OFFSET, SRGB_LUMINANCE_RED, SRGB_LUMINANCE_THRESHOLD, TYPE_HEX, TYPE_HSL, TYPE_HWB, TYPE_RGB };
+export { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_KEYS, COLOR_LENGTHS, COLOR_MAX, COLOR_PROPERTY, COLOR_SRGB, COLOR_TYPE };

package/dist/color/constants.mjs

@@ -1,69 +1,108 @@
 //#region src/color/constants.ts
-const ALPHA_FULL_HEX_SHORT = "f";
-const ALPHA_FULL_HEX_LONG = `ff`;
-const ALPHA_NONE_HEX = "00";
-const ALPHA_NONE_VALUE = 0;
-const DEFAULT_ALPHA = {
-	hex: ALPHA_FULL_HEX_LONG,
-	value: 100
+const COLOR_ALPHA = {
+	fullHexShort: "f",
+	fullHexLong: "ff",
+	name: "alpha",
+	noneHex: "00",
+	noneValue: 0
 };
-const DEFAULT_HSL = {
-	hue: 0,
-	saturation: 0,
-	lightness: 0
+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
+	}
 };
-const DEFAULT_HWB = {
-	hue: 0,
-	whiteness: 0,
-	blackness: 100
+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: /^#/
 };
-const DEFAULT_RGB = {
-	blue: 0,
-	green: 0,
-	red: 0
+const COLOR_LENGTHS = {
+	hexLong: 6,
+	hexShort: 3
+};
+const COLOR_KEYS = {
+	hsl: [
+		"hue",
+		"saturation",
+		"lightness"
+	],
+	hsla: [],
+	hwb: [
+		"hue",
+		"whiteness",
+		"blackness"
+	],
+	hwba: [],
+	rgb: [
+		"red",
+		"green",
+		"blue"
+	],
+	rgba: []
+};
+COLOR_KEYS.hsla = [...COLOR_KEYS.hsl, COLOR_ALPHA.name];
+COLOR_KEYS.hwba = [...COLOR_KEYS.hwb, COLOR_ALPHA.name];
+COLOR_KEYS.rgba = [...COLOR_KEYS.rgb, COLOR_ALPHA.name];
+const COLOR_MAX = {
+	degree: 360,
+	hex: 255,
+	percent: 100
+};
+const COLOR_PROPERTY = {
+	name: "$color",
+	subscription: "subscription"
+};
+const COLOR_TYPE = {
+	all: void 0,
+	hex: "hex",
+	hexa: "hexa",
+	hsl: "hsl",
+	hsla: "hsla",
+	hwb: "hwb",
+	hwba: "hwba",
+	rgb: "rgb",
+	rgba: "rgba"
+};
+COLOR_TYPE.all = /* @__PURE__ */ new Set([
+	COLOR_ALPHA.name,
+	COLOR_TYPE.hex,
+	COLOR_TYPE.hexa,
+	COLOR_TYPE.hsl,
+	COLOR_TYPE.hsla,
+	COLOR_TYPE.hwb,
+	COLOR_TYPE.hwba,
+	COLOR_TYPE.rgb,
+	COLOR_TYPE.rgba
+]);
+const COLOR_SRGB = {
+	luminanceBlue: .0722,
+	luminanceExponent: 2.4,
+	luminanceGreen: .7152,
+	luminanceMinimum: .03928,
+	luminanceModifier: 1.055,
+	luminanceMultiplier: 12.92,
+	luminanceOffset: .055,
+	luminanceRed: .2126,
+	luminanceThreshold: .625
 };
-const EXPRESSION_ALPHA_HEX = /^([a-f0-9]{1,2})$/i;
-const EXPRESSION_HEX_LONG = /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?$/i;
-const EXPRESSION_HEX_SHORT = /^#?([a-f0-9]{3,4})$/i;
-const EXPRESSION_PREFIX = /^#/;
-const HEX_BLACK = "000000";
-const HEX_WHITE = "ffffff";
-const LENGTH_LONG = 6;
-const LENGTH_SHORT = 3;
-const KEYS_HSL = [
-	"hue",
-	"saturation",
-	"lightness"
-];
-const KEYS_HSLA = [...KEYS_HSL, "alpha"];
-const KEYS_HWB = [
-	"hue",
-	"whiteness",
-	"blackness"
-];
-const KEYS_HWBA = [...KEYS_HWB, "alpha"];
-const KEYS_RGB = [
-	"red",
-	"green",
-	"blue"
-];
-const KEYS_RGBA = [...KEYS_RGB, "alpha"];
-const MAX_DEGREE = 360;
-const MAX_HEX = 255;
-const MAX_PERCENT = 100;
-const PROPERTY_COLOR = "$color";
-const TYPE_HEX = "hex";
-const TYPE_HSL = "hsl";
-const TYPE_HWB = "hwb";
-const TYPE_RGB = "rgb";
-const SRGB_LUMINANCE_BLUE = .0722;
-const SRGB_LUMINANCE_EXPONENT = 2.4;
-const SRGB_LUMINANCE_GREEN = .7152;
-const SRGB_LUMINANCE_MINIMUM = .03928;
-const SRGB_LUMINANCE_MODIFIER = 1.055;
-const SRGB_LUMINANCE_MULTIPLIER = 12.92;
-const SRGB_LUMINANCE_OFFSET = .055;
-const SRGB_LUMINANCE_RED = .2126;
-const SRGB_LUMINANCE_THRESHOLD = .625;
 //#endregion
-export { ALPHA_FULL_HEX_LONG, ALPHA_FULL_HEX_SHORT, ALPHA_NONE_HEX, ALPHA_NONE_VALUE, DEFAULT_ALPHA, DEFAULT_HSL, DEFAULT_HWB, DEFAULT_RGB, EXPRESSION_ALPHA_HEX, EXPRESSION_HEX_LONG, EXPRESSION_HEX_SHORT, EXPRESSION_PREFIX, HEX_BLACK, HEX_WHITE, KEYS_HSL, KEYS_HSLA, KEYS_HWB, KEYS_HWBA, KEYS_RGB, KEYS_RGBA, LENGTH_LONG, LENGTH_SHORT, MAX_DEGREE, MAX_HEX, MAX_PERCENT, PROPERTY_COLOR, SRGB_LUMINANCE_BLUE, SRGB_LUMINANCE_EXPONENT, SRGB_LUMINANCE_GREEN, SRGB_LUMINANCE_MINIMUM, SRGB_LUMINANCE_MODIFIER, SRGB_LUMINANCE_MULTIPLIER, SRGB_LUMINANCE_OFFSET, SRGB_LUMINANCE_RED, SRGB_LUMINANCE_THRESHOLD, TYPE_HEX, TYPE_HSL, TYPE_HWB, TYPE_RGB };
+export { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_KEYS, COLOR_LENGTHS, COLOR_MAX, COLOR_PROPERTY, COLOR_SRGB, COLOR_TYPE };

package/dist/color/instance.mjs

@@ -1,19 +1,23 @@
-import { PROPERTY_COLOR } from "./constants.mjs";
+import { clearSubscriptions, getSubscription, getSubscriptions } from "../internal/subscription.mjs";
+import { COLOR_PROPERTY, COLOR_TYPE } from "./constants.mjs";
 import { getAlpha } from "./misc/alpha.mjs";
 import { getColorFromState, getColorState, setHSLColor, setHWBColor, setHexColor, setRGBColor } from "./misc/state.mjs";
 import { formatHslColor, formatHwbColor, formatRgbColor } from "./misc/format.mjs";
 //#region src/color/instance.ts
 function color(value) {
 	const state = getColorState(value);
+	const subscriptions = getSubscriptions(COLOR_TYPE.all);
 	const instance = {
+		subscribe: (first, second) => subscribeToColor(subscriptions, first, second),
 		toHexString: (alpha) => `#${alpha === true ? instance.hexa : instance.hex}`,
 		toHslString: (alpha) => formatHslColor(state, alpha),
 		toHwbString: (alpha) => formatHwbColor(state, alpha),
 		toRgbString: (alpha) => formatRgbColor(state, alpha),
-		toString: () => instance.toHexString()
+		toString: () => instance.toHexString(),
+		unsubscribe: () => clearSubscriptions(subscriptions)
 	};
 	Object.defineProperties(instance, {
-		[PROPERTY_COLOR]: {
+		[COLOR_PROPERTY.name]: {
 			enumerable: false,
 			value: true
 		},
@@ -22,27 +26,27 @@ function color(value) {
 			get: () => state.alpha.value,
 			set: (value) => setAlphaValue(state, value)
 		},
-		hex: getProperty("hex", state, false),
-		hexa: getProperty("hex", state, true),
-		hsl: getProperty("hsl", state, false),
-		hsla: getProperty("hsl", state, true),
-		hwb: getProperty("hwb", state, false),
-		hwba: getProperty("hwb", state, true),
+		hex: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, false),
+		hexa: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, true),
+		hsl: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, false),
+		hsla: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, true),
+		hwb: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, false),
+		hwba: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, true),
 		origin: {
 			enumerable: true,
 			get: () => state.origin
 		},
-		rgb: getProperty("rgb", state, false),
-		rgba: getProperty("rgb", state, true)
+		rgb: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, false),
+		rgba: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, true)
 	});
 	return Object.freeze(instance);
 }
-function getProperty(space, state, alpha) {
+function getProperty(space, color, state, subscriptions, alpha) {
 	const setValue = setters[space];
 	return {
 		enumerable: true,
 		get: () => getValue(space, state, alpha),
-		set: (value) => setValue(state, value, alpha)
+		set: (value) => setValue(color, state, subscriptions, value, alpha)
 	};
 }
 function getValue(space, state, alpha) {
@@ -56,6 +60,25 @@ function getValue(space, state, alpha) {
 function setAlphaValue(state, value) {
 	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
 }
+function subscribeToColor(subscriptions, first, second) {
+	let key;
+	let value;
+	if (typeof first === "string") {
+		key = first;
+		value = second;
+	} else if (typeof first === "function") value = first;
+	if (typeof value !== "function") throw new Error();
+	return getSubscription({
+		key,
+		subscriptions,
+		value,
+		property: colorSubscription
+	});
+}
+const colorSubscription = {
+	key: COLOR_PROPERTY.name,
+	value: COLOR_PROPERTY.subscription
+};
 const setters = {
 	hex: setHexColor,
 	hsl: setHSLColor,

package/dist/color/misc/alpha.mjs

@@ -1,21 +1,20 @@
 import { clamp } from "../../internal/number.mjs";
-import { ALPHA_FULL_HEX_LONG, DEFAULT_ALPHA, EXPRESSION_ALPHA_HEX } from "../constants.mjs";
+import { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_MAX } from "../constants.mjs";
 import { round } from "../../internal/math/misc.mjs";
-import "../../index.mjs";
 //#region src/color/misc/alpha.ts
 function getAlpha(value, hex) {
 	if (typeof value === "number") return getAlphaFromValue(value);
-	if (typeof value !== "string" || value.toLowerCase() === ALPHA_FULL_HEX_LONG) return { ...DEFAULT_ALPHA };
-	if (hex && EXPRESSION_ALPHA_HEX.test(value)) return {
+	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) / 255
+		value: Number.parseInt(value, 16) / COLOR_MAX.hex
 	};
 	return getAlphaFromValue(Number.parseFloat(value));
 }
 function getAlphaHexadecimal(value) {
-	if (value === 0) return "00";
-	if (value === 100) return ALPHA_FULL_HEX_LONG;
-	return round(value / 100 * 255).toString(16);
+	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) {
 	const alpha = getAlphaValue(value);
@@ -25,8 +24,8 @@ function getAlphaFromValue(value) {
 	};
 }
 function getAlphaValue(original) {
-	if (Number.isNaN(original)) return 100;
-	return clamp(original, 0, 100);
+	if (Number.isNaN(original)) return COLOR_MAX.percent;
+	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
 //#endregion
 export { getAlpha, getAlphaHexadecimal, getAlphaValue };