@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/array/to-record.d.mts

@@ -1,13 +1,13 @@
-import { Key, KeyedValue, PlainObject, Simplify } from "../models.mjs";
+import { Key, KeyOrCallback, KeyOrCallbackKey, KeyOrCallbackValue, Simplify } from "../models.mjs";
 //#region src/array/to-record.d.ts
 /**
- * Create a record from an array of items using callbacks
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -19,74 +19,14 @@ import { Key, KeyedValue, PlainObject, Simplify } from "../models.mjs";
  * ); // => { 10: 3, 20: 2 }
  * ```
  */
-declare function toRecord<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>;
+export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>>;
 /**
- * Create a record from an array of items using a callback and value
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record with keys
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-declare function toRecord<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue]>;
-/**
- * Create a record from an array of items using a key and callback
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param callback Callback to get an item's value
- * @returns Record with keys
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item.id,
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>>>;
-/**
- * Create a record from an array of items using a key and value
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
-/**
- * Create a record from an array of items using a callback
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed values
  *
  * @example
@@ -97,25 +37,7 @@ declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item,
  * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
  * ```
  */
-declare function toRecord<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
-/**
- * Create a record from an array of items using a key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
- * ```
- */
-declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
  *
@@ -129,38 +51,18 @@ declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(
  * ); // => { 0: {id: 1, value: 10}, 1: {id: 2, value: 20}, 2: {id: 3, value: 10} }
  * ```
  */
-declare function toRecord<Item>(array: Item[]): Record<number, Item>;
-declare namespace toRecord {
+export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
+export declare namespace toRecord {
   var arrays: typeof toRecordArrays;
 }
 /**
- * Create a record from an array of items using callbacks, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item.id,
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a callback and value, grouping values into arrays
+ * Create a record from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `toRecordArrays` and `toRecord.arrays`_
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
- * @param value Key to use for value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed arrays of values
  *
  * @example
@@ -168,58 +70,18 @@ declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: nu
  * toRecordArrays(
  *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
  *   item => item.value,
- *   'id',
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
-/**
- * Create a record from an array of items using a key and callback, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param callback Callback to get an item's value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
  *   item => item.id,
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<Callback>>>>;
+export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>>;
 /**
- * Create a record from an array of items using a key and value, grouping values into arrays
+ * Create a record from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `toRecordArrays` and `toRecord.arrays`_
  *
  * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
-/**
- * Create a record from an array of items using a callback, grouping items into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed arrays of items
  *
  * @example
@@ -230,24 +92,5 @@ declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof
  * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
  * ```
  */
-declare function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
-/**
- * Create a record from an array of items using a key, grouping items into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns Record of keyed arrays of items
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
- * ```
- */
-declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
-//#endregion
-export { toRecord, toRecordArrays };
+export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
+//#endregion

package/dist/array/to-set.d.mts

@@ -15,7 +15,7 @@ import { PlainObject } from "../models.mjs";
  * ); // => Set { 1, 2, 3 }
  * ```
  */
-declare function toSet<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback): Set<ReturnType<Callback>>;
+export declare function toSet<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback): Set<ReturnType<Callback>>;
 /**
  * Create a _Set_ from an array of items using a key
  *
@@ -31,7 +31,7 @@ declare function toSet<Item, Callback extends (item: Item, index: number, array:
  * ); // => Set { 1, 2, 3 }
  * ```
  */
-declare function toSet<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Set<Item[ItemKey]>;
+export declare function toSet<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Set<Item[ItemKey]>;
 /**
  * Create a _Set_ from an array of items
  *
@@ -43,6 +43,5 @@ declare function toSet<Item extends PlainObject, ItemKey extends keyof Item>(arr
  * toSet([1, 2, 3]); // => Set { 1, 2, 3 }
  * ```
  */
-declare function toSet<Item>(array: Item[]): Set<Item>;
-//#endregion
-export { toSet };
+export declare function toSet<Item>(array: Item[]): Set<Item>;
+//#endregion

package/dist/array/toggle.d.mts

@@ -19,7 +19,7 @@ import { PlainObject } from "../models.mjs";
  * ); // => [{id: 1}, {id: 3}, {id: 4}]
  * ```
  */
-declare function toggle<Item>(destination: Item[], toggled: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+export declare function toggle<Item>(destination: Item[], toggled: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Toggle an item in an array
  *
@@ -39,7 +39,7 @@ declare function toggle<Item>(destination: Item[], toggled: Item[], callback: (i
  * ); // => [{id: 1}, {id: 3}, {id: 4}]
  * ```
  */
-declare function toggle<Item extends PlainObject, ItemKey extends keyof Item>(destination: Item[], toggled: Item[], key: ItemKey): Item[];
+export declare function toggle<Item extends PlainObject, ItemKey extends keyof Item>(destination: Item[], toggled: Item[], key: ItemKey): Item[];
 /**
  * Toggle an item in an array
  *
@@ -57,6 +57,5 @@ declare function toggle<Item extends PlainObject, ItemKey extends keyof Item>(de
  * ); // => [1, 3, 4]
  * ```
  */
-declare function toggle<Item>(destination: Item[], toggled: Item[]): Item[];
-//#endregion
-export { toggle };
+export declare function toggle<Item>(destination: Item[], toggled: Item[]): Item[];
+//#endregion

package/dist/array/union.d.mts

@@ -16,7 +16,7 @@
  * ); // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
  * ```
  */
-declare function union<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): (First | Second)[];
+export declare function union<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): (First | Second)[];
 /**
  * Get the combined, unique values from two arrays
  *
@@ -34,7 +34,7 @@ declare function union<First, Second>(first: First[], second: Second[], callback
  * ); // => [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
  * ```
  */
-declare function union<First extends Record<string, unknown>, Second extends Record<string, unknown>, SharedKey extends keyof First & keyof Second>(first: First[], second: Second[], key: SharedKey): (First | Second)[];
+export declare function union<First extends Record<string, unknown>, Second extends Record<string, unknown>, SharedKey extends keyof First & keyof Second>(first: First[], second: Second[], key: SharedKey): (First | Second)[];
 /**
  * Get the combined, unique values from two arrays
  *
@@ -50,6 +50,5 @@ declare function union<First extends Record<string, unknown>, Second extends Rec
  * ); // => [1, 2, 3, 4]
  * ```
  */
-declare function union<First, Second>(first: First[], second: Second[]): (First | Second)[];
-//#endregion
-export { union };
+export declare function union<First, Second>(first: First[], second: Second[]): (First | Second)[];
+//#endregion

package/dist/array/unique.d.mts

@@ -15,7 +15,7 @@ import { PlainObject } from "../models.mjs";
  * ); // => [{id: 1}, {id: 2}, {id: 3}]
  * ```
  */
-declare function unique<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+export declare function unique<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Get an array of unique items
  *
@@ -31,7 +31,7 @@ declare function unique<Item>(array: Item[], callback: (item: Item, index: numbe
  * ); // => [{id: 1}, {id: 2}, {id: 3}]
  * ```
  */
-declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Item[];
+export declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Item[];
 /**
  * Get an array of unique items
  *
@@ -43,6 +43,5 @@ declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(ar
  * unique([1, 2, 3, 2]); // => [1, 2, 3]
  * ```
  */
-declare function unique<Item>(array: Item[]): Item[];
-//#endregion
-export { unique };
+export declare function unique<Item>(array: Item[]): Item[];
+//#endregion

package/dist/array/update.d.mts

@@ -19,7 +19,7 @@ import { PlainObject } from "../models.mjs";
  * ); // => [{id: 1}, {id: 2, name: 'Updated'}, {id: 3}, {id: 4, name: 'New'}]
  * ```
  */
-declare function update<Item>(destination: Item[], updated: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+export declare function update<Item>(destination: Item[], updated: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Update an item in an array
  *
@@ -39,7 +39,7 @@ declare function update<Item>(destination: Item[], updated: Item[], callback: (i
  * ); // => [{id: 1}, {id: 2, name: 'Updated'}, {id: 3}, {id: 4, name: 'New'}]
  * ```
  */
-declare function update<Item extends PlainObject, ItemKey extends keyof Item>(destination: Item[], updated: Item[], key: ItemKey): Item[];
+export declare function update<Item extends PlainObject, ItemKey extends keyof Item>(destination: Item[], updated: Item[], key: ItemKey): Item[];
 /**
  * Update an item in an array
  *
@@ -57,6 +57,5 @@ declare function update<Item extends PlainObject, ItemKey extends keyof Item>(de
  * ); // => [1, 2, 3, 4]
  * ```
  */
-declare function update<Item>(destination: Item[], updated: Item[]): Item[];
-//#endregion
-export { update };
+export declare function update<Item>(destination: Item[], updated: Item[]): Item[];
+//#endregion

package/dist/beacon.d.mts

@@ -3,7 +3,7 @@ import { Subscription } from "./internal/subscription.mjs";
 /**
  * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
  */
-type Beacon<Value> = {
+export type Beacon<Value> = {
   /**
    * Is the beacon active?
    */
@@ -39,7 +39,7 @@ type Beacon<Value> = {
    */
   finish(): void;
 };
-type BeaconOptions<Value> = {
+export type BeaconOptions<Value> = {
   /**
    * Method for comparing values for equality
    *
@@ -50,7 +50,7 @@ type BeaconOptions<Value> = {
    */
   equal?: (first: Value, second: Value) => boolean;
 };
-type Observable<Value> = {
+export type Observable<Value> = {
   /**
    * Is the observable active?
    */
@@ -97,27 +97,26 @@ type Observer<Value> = {
  * @param options Beacon options
  * @returns Beacon instance
  */
-declare function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value>;
+export declare function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value>;
 /**
  * Is the value a beacon?
  *
  * @param value Value to check
  * @returns `true` if the value is a beacon, otherwise `false`
  */
-declare function isBeacon<Value = unknown>(value: unknown): value is Beacon<Value>;
+export declare function isBeacon<Value = unknown>(value: unknown): value is Beacon<Value>;
 /**
  * Is the value a beacon subscription?
  *
  * @param value Value to check
  * @returns `true` if the value is a beacon subscription, otherwise `false`
  */
-declare function isBeaconSubscription(value: unknown): value is Subscription;
+export declare function isBeaconSubscription(value: unknown): value is Subscription;
 /**
  * Is the value an observable?
  *
  * @param value Value to check
  * @returns `true` if the value is an observable, otherwise `false`
  */
-declare function isObservable<Value = unknown>(value: unknown): value is Observable<Value>;
-//#endregion
-export { Beacon, BeaconOptions, Observable, beacon, isBeacon, isBeaconSubscription, isObservable };
+export declare function isObservable<Value = unknown>(value: unknown): value is Observable<Value>;
+//#endregion

package/dist/beacon.mjs

@@ -2,6 +2,59 @@ import { noop } from "./internal/function/misc.mjs";
 import { isPlainObject } from "./internal/is.mjs";
 import { SUBSCRIPTION_NAME, isSubscription, subscriptions } from "./internal/subscription.mjs";
 //#region src/beacon.ts
+const BEACON_PROPERTY = "$beacon";
+const BEACON_NAME = "beacon";
+const BEACON_OBSERVABLE = "observable";
+function Beacon(value, options) {
+	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+		value,
+		active: true,
+		options: createBeaconOptions(options)
+	} });
+}
+Object.defineProperties(Beacon.prototype, {
+	[BEACON_PROPERTY]: { value: BEACON_NAME },
+	active: {
+		enumerable: true,
+		get() {
+			return this[BEACON_SYMBOL].active;
+		}
+	},
+	deactivate: { value: deactivateBeacon },
+	emit: { value: emitBeaconValue },
+	error: { value: emitBeaconError },
+	finish: { value: finishBeacon },
+	observable: {
+		enumerable: true,
+		get() {
+			return getObservable(this[BEACON_SYMBOL]);
+		}
+	},
+	value: {
+		enumerable: true,
+		get() {
+			return this[BEACON_SYMBOL].value;
+		}
+	}
+});
+function Observable(beacon) {
+	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+		beacon,
+		active: beacon.active
+	} });
+}
+Object.defineProperties(Observable.prototype, {
+	[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
+	active: {
+		enumerable: true,
+		get() {
+			const state = this[BEACON_SYMBOL];
+			return state.beacon.active && state.active;
+		}
+	},
+	deactivate: { value: deactiveateObservable },
+	subscribe: { value: subscribeToObservable }
+});
 /**
 * Create a new beacon
 *
@@ -10,61 +63,24 @@ import { SUBSCRIPTION_NAME, isSubscription, subscriptions } from "./internal/sub
 * @returns Beacon instance
 */
 function beacon(value, options) {
-	const state = {
-		value,
-		active: true,
-		observable: void 0,
-		options: createBeaconOptions(options),
-		subscriptions: subscriptions({ property: beaconSubscription })
-	};
-	const instance = {
-		deactivate: () => finishBeacon(state, false),
-		emit: (value, finish) => updateBeacon(BEACON_TYPE_NEXT, state, value, finish),
-		error: (value, finish) => updateBeacon(BEACON_TYPE_ERROR, state, value, finish),
-		finish: () => finishBeacon(state, true)
-	};
-	Object.defineProperties(instance, {
-		[BEACON_PROPERTY]: { value: BEACON_NAME },
-		active: {
-			enumerable: true,
-			get: () => state.active
-		},
-		observable: {
-			enumerable: true,
-			get: () => getObservable(state)
-		},
-		value: {
-			enumerable: true,
-			get: () => state.value
-		}
-	});
-	return Object.freeze(instance);
+	return new Beacon(value, options);
+}
+function closeBeacon(state, emit) {
+	if (!state.active) return;
+	state.active = false;
+	const subscriptions = state.subscriptions?.values.to.any;
+	if (subscriptions != null && subscriptions.size > 0) {
+		for (const [, observer] of subscriptions) if (emit) observer.complete?.();
+	}
+	state.subscriptions?.clear();
+	state.observable?.deactivate();
+	state.observable = void 0;
 }
 function createBeaconOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
 	return options;
 }
-function createObservable(beacon) {
-	const state = {
-		beacon,
-		active: beacon.active
-	};
-	const instance = {
-		deactivate: () => {
-			state.active = false;
-		},
-		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
-	};
-	Object.defineProperties(instance, {
-		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
-		active: {
-			enumerable: true,
-			get: () => beacon.active && state.active
-		}
-	});
-	return Object.freeze(instance);
-}
 function createObserver(first, second, third) {
 	let observer = { next: noop };
 	if (typeof first === "function") observer = {
@@ -79,17 +95,24 @@ function createObserver(first, second, third) {
 	}
 	return observer;
 }
-function finishBeacon(state, emit) {
-	if (!state.active) return;
-	state.active = false;
-	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
-	state.subscriptions.clear();
-	state.observable?.deactivate();
-	state.observable = void 0;
+function deactivateBeacon() {
+	closeBeacon(this[BEACON_SYMBOL], false);
+}
+function deactiveateObservable() {
+	this[BEACON_SYMBOL].active = false;
+}
+function emitBeaconError(error, finish) {
+	updateBeacon(this, BEACON_TYPE_ERROR, error, finish ?? false);
+}
+function emitBeaconValue(value, finish) {
+	updateBeacon(this, BEACON_TYPE_NEXT, value, finish ?? false);
+}
+function finishBeacon() {
+	closeBeacon(this[BEACON_SYMBOL], true);
 }
 function getObservable(state) {
 	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
-	state.observable ??= createObservable(state);
+	state.observable ??= new Observable(state);
 	return state.observable;
 }
 function getObservableCallback(value) {
@@ -105,7 +128,7 @@ function isBeacon(value) {
 	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return isPlainObject(value) && value[BEACON_PROPERTY] === name;
+	return typeof value === "object" && value !== null && value[BEACON_PROPERTY] === name;
 }
 /**
 * Is the value a beacon subscription?
@@ -125,8 +148,10 @@ function isBeaconSubscription(value) {
 function isObservable(value) {
 	return isBeaconInstance(BEACON_OBSERVABLE, value);
 }
-function subscribeToObservable(state, first, second, third) {
+function subscribeToObservable(first, second, third) {
+	const state = this[BEACON_SYMBOL];
 	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
+	state.beacon.subscriptions ??= subscriptions({ property: beaconSubscription });
 	const observer = createObserver(first, second, third);
 	const [subscription] = state.beacon.subscriptions.create({
 		isActive: () => state.beacon.active && state.active,
@@ -135,20 +160,20 @@ function subscribeToObservable(state, first, second, third) {
 	observer.next?.(state.beacon.value);
 	return subscription;
 }
-function updateBeacon(type, state, value, finish) {
+function updateBeacon(instance, type, value, finish) {
+	const state = instance[BEACON_SYMBOL];
 	if (!state.active) return;
 	if (type === BEACON_TYPE_NEXT) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
-	if (finish === true) finishBeacon(state, true);
+	const subscriptions = state.subscriptions?.values.to.any;
+	if (subscriptions != null && subscriptions.size > 0) for (const [, observer] of subscriptions) observer[type]?.(value);
+	if (finish === true) closeBeacon(state, true);
 }
 const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-const BEACON_PROPERTY = "$beacon";
-const BEACON_NAME = "beacon";
-const BEACON_OBSERVABLE = "observable";
+const BEACON_SYMBOL = Symbol(BEACON_PROPERTY);
 const BEACON_TYPE_ERROR = "error";
 const BEACON_TYPE_NEXT = "next";
 const beaconSubscription = {