@oscarpalmer/atoms 0.191.0 → 0.193.0

package/dist/internal/subscription.d.mts

@@ -0,0 +1,52 @@
+import { Key } from "../models.mjs";
+//#region src/internal/subscription.d.ts
+type Subscription = {
+  /**
+   * Is the subscription active?
+   */
+  get active(): boolean;
+  /**
+   * Unsubscribe from changes
+   */
+  unsubscribe(): void;
+};
+type SubscriptionParameters = {
+  isActive?: () => boolean;
+  key?: Key;
+  property: SubscriptionProperty;
+  subscriptions: Subscriptions;
+  value: unknown;
+};
+type SubscriptionProperty = {
+  key: string;
+  value: unknown;
+};
+type Subscriptions<Value = unknown> = {
+  items: SubscriptionsItems;
+  keys?: Set<Key>;
+  values: SubscriptionsValues<Value>;
+};
+type SubscriptionsItems = {
+  any: Set<Subscription>;
+  keyed?: Map<Key, Set<Subscription>>;
+};
+type SubscriptionsValues<Value = unknown> = {
+  from: SubscriptionsValuesItem<Value, Subscription>;
+  to: SubscriptionsValuesItem<Subscription, Value>;
+};
+type SubscriptionsValuesItem<MapKey, MapValue> = {
+  any: Map<MapKey, MapValue>;
+  keyed?: Map<Key, Map<MapKey, MapValue>>;
+};
+declare function clearSubscriptions(store: Subscriptions): void;
+declare function getSubscription(parameters: SubscriptionParameters): Subscription;
+declare function getSubscriptions<Value = unknown>(keys?: Set<Key>): Subscriptions<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 { Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, clearSubscriptions, getSubscription, getSubscriptions, isSubscription };

package/dist/internal/subscription.mjs

@@ -0,0 +1,127 @@
+import { isPlainObject } from "./is.mjs";
+//#region src/internal/subscription.ts
+function addSubscription(subscription, state) {
+	const { key, subscriptions, value } = state.parameters;
+	const { items, values } = subscriptions;
+	if (key == null) {
+		items.any.add(subscription);
+		values.from.any.set(value, subscription);
+		values.to.any.set(subscription, value);
+		return;
+	}
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
+ // istanbul ignore next
+	return;
+	let keyedItems = items.keyed.get(key);
+	if (keyedItems == null) {
+		keyedItems = /* @__PURE__ */ new Set();
+		items.keyed.set(key, keyedItems);
+	}
+	keyedItems.add(subscription);
+	let keyedFrom = values.from.keyed.get(key);
+	if (keyedFrom == null) {
+		keyedFrom = /* @__PURE__ */ new Map();
+		values.from.keyed.set(key, keyedFrom);
+	}
+	keyedFrom.set(value, subscription);
+	let keyedTo = values.to.keyed.get(key);
+	if (keyedTo == null) {
+		keyedTo = /* @__PURE__ */ new Map();
+		values.to.keyed.set(key, keyedTo);
+	}
+	keyedTo.set(subscription, value);
+}
+function clearSubscriptions(store) {
+	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
+	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
+}
+function getExistingSubscription(state) {
+	const { parameters } = state;
+	const { values } = parameters.subscriptions;
+	return parameters.key == null ? values.from.any.get(parameters.value) : values.from.keyed?.get(parameters.key)?.get(parameters.value);
+}
+function getSubscription(parameters) {
+	const state = {
+		parameters,
+		active: true
+	};
+	const existing = getExistingSubscription(state);
+	if (existing != null) return existing;
+	if (parameters.subscriptions.keys != null && parameters.key != null && !parameters.subscriptions.keys.has(parameters.key)) throw new Error();
+	const instance = { unsubscribe: () => {
+		removeSubscription(instance, state);
+	} };
+	Object.defineProperties(instance, {
+		[PROPERTY]: {
+			enumerable: false,
+			value: true
+		},
+		[parameters.property.key]: {
+			enumerable: false,
+			value: parameters.property.value
+		},
+		active: {
+			enumerable: true,
+			get: () => (parameters.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(instance, state);
+	return Object.freeze(instance);
+}
+function getSubscriptions(keys) {
+	return {
+		keys,
+		items: {
+			any: /* @__PURE__ */ new Set(),
+			keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+		},
+		values: {
+			from: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			},
+			to: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			}
+		}
+	};
+}
+/**
+* Is the value a subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a subscription, otherwise `false`
+*/
+function isSubscription(value) {
+	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
+}
+function removeFromStore(items, values, subscription, value, key) {
+	items.delete(subscription);
+	if (key == null) {
+		values.from.any.delete(value);
+		values.to.any.delete(subscription);
+	} else {
+		values.from.keyed?.get(key)?.delete(value);
+		values.to.keyed?.get(key)?.delete(subscription);
+	}
+}
+function removeSubscription(subscription, state) {
+	if (!state.active) return;
+	state.active = false;
+	const { key, subscriptions, value } = state.parameters;
+	const { items, values } = subscriptions;
+	if (key == null) {
+		removeFromStore(items.any, values, subscription, value);
+		return;
+	}
+	const keyed = items.keyed?.get(key);
+	if (items.keyed == null || keyed == null)
+ // istanbul ignore next
+	return;
+	removeFromStore(keyed, values, subscription, value, key);
+	if (keyed.size === 0) items.keyed.delete(key);
+}
+const PROPERTY = "$subscription";
+//#endregion
+export { clearSubscriptions, getSubscription, getSubscriptions, isSubscription };

package/dist/models.d.mts

@@ -156,5 +156,9 @@ type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint
  * Thanks, type-fest!
  */
 type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
+/**
+ * A function that unsubscribes from a subscription
+ */
+type Unsubscriber = () => void;
 //#endregion
-export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, EventPosition, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray, UnionToIntersection };
+export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, EventPosition, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray, UnionToIntersection, Unsubscriber };

package/dist/queue.d.mts

@@ -3,7 +3,7 @@ import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
 /**
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
-type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Get keys of all active queues
    */
@@ -52,7 +52,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
    * @param signal Optional signal to abort the item
    * @returns Queued item
    */
-  add(key: string, parameters: Tail<CallbackParameters>, signal?: AbortSignal): Queued<CallbackResult>;
+  add(key: string, parameters: Tail<CallbackParameters>, signal?: AbortSignal): Queued<ReturnType<Callback>>;
   /**
    * Clear all items for a specific key _(or all items for all keys, if no key is provided)_
    *
@@ -65,7 +65,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
    * @param key Key to get the queue for
    * @returns Queue for the key, or `undefined` if it doesn't exist
    */
-  get(key: string): Queue<Tail<CallbackParameters>, CallbackResult> | undefined;
+  get(key: string): Queue<Callback, Tail<CallbackParameters>> | undefined;
   /**
    * Pause the queue for a specific key _(or all queues, if no key is provided)_
    *
@@ -101,7 +101,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Is the queue active?
    */
@@ -141,7 +141,7 @@ type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callback
    * @param signal Optional signal to abort the item
    * @returns Queued item
    */
-  add(parameters: CallbackParameters, signal?: AbortSignal): Queued<CallbackResult>;
+  add(parameters: CallbackParameters, signal?: AbortSignal): Queued<ReturnType<Callback>>;
   /**
    * Remove and reject all items in the queue
    */
@@ -195,17 +195,7 @@ type Queued<Value> = {
   /**
    * Queued promise
    */
-  readonly promise: Promise<QueuedResult<Value>>;
-};
-type QueuedResult<Value> = {
-  /**
-   * Has the queue finished processing all items?
-   */
-  finished: boolean;
-  /**
-   * Result for the queued promise
-   */
-  value: Value extends Promise<infer Result> ? Result : Value;
+  readonly promise: Promise<Value extends Promise<infer Result> ? Result : Value>;
 };
 type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
 /**
@@ -214,17 +204,29 @@ type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest
  * @param value Value to check
  * @returns `true` if the value is a keyed queue, otherwise `false`
  */
-declare function isKeyedQueue(value: unknown): value is KeyedQueue<unknown[], unknown>;
+declare function isKeyedQueue(value: unknown): value is KeyedQueue<GenericAsyncCallback>;
 /**
  * Is the value a queue?
  *
  * @param value Value to check
  * @returns `true` if the value is a queue, otherwise `false`
  */
-declare function isQueue(value: unknown): value is Queue<unknown[], unknown>;
+declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
 declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, ReturnType<Callback>>;
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
+declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
+declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for an asynchronous callback function
  *
@@ -232,7 +234,7 @@ declare function keyedQueue<Callback extends (key: string, ...parameters: any[])
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for a synchronous callback function
  *
@@ -240,9 +242,9 @@ declare function queue<Callback extends GenericAsyncCallback>(callback: Callback
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, ReturnType<Callback>>;
+declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 declare namespace queue {
   var keyed: typeof keyedQueue;
 }
 //#endregion
-export { KeyedQueue, Queue, QueueError, QueueOptions, Queued, QueuedResult, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };
+export { KeyedQueue, Queue, QueueError, QueueOptions, Queued, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/queue.mjs

@@ -125,6 +125,12 @@ function createQueue(callback, options, key) {
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
+function getItems(state) {
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -148,7 +154,7 @@ function getStatus(state, status) {
 	for (const [key, queue] of queues) if (queue[status]) result.push(key);
 	return result;
 }
-function handleQueuedResult(item, error, result, finished) {
+function handleQueuedResult(item, error, result) {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort);
 	if (item.signal?.aborted ?? false) {
 		item.reject();
@@ -158,10 +164,7 @@ function handleQueuedResult(item, error, result, finished) {
 		item.reject(result);
 		return;
 	}
-	item.resolve({
-		finished,
-		value: result
-	});
+	item.resolve(result);
 }
 function handleQueues(state, type, key) {
 	if (typeof key === "string") {
@@ -212,21 +215,7 @@ function keyedQueue(callback, options) {
 		pause: (key) => {
 			handleQueues(state, HANDLE_PAUSE, key);
 		},
-		remove: (key, id) => {
-			if (key == null) {
-				handleQueues(state, HANDLE_CLEAR);
-				state.queues.clear();
-				return;
-			}
-			const queue = getQueue(state, key);
-			if (queue == null) return;
-			if (typeof id === "number") {
-				queue.remove(id);
-				return;
-			}
-			queue.clear();
-			state.queues.delete(key);
-		},
+		remove: (key, id) => removeQueue(state, key, id),
 		resume: (key) => {
 			handleQueues(state, HANDLE_RESUME, key);
 		}
@@ -258,12 +247,7 @@ function keyedQueue(callback, options) {
 		},
 		items: {
 			enumerable: true,
-			get: () => {
-				const size = {};
-				const queues = state.queues.entries();
-				for (const [key, queue] of queues) size[key] = queue.size;
-				return size;
-			}
+			get: () => getItems(state)
 		},
 		keys: {
 			enumerable: true,
@@ -288,6 +272,21 @@ function queue(callback, options) {
 	return createQueue(callback, options);
 }
 queue.keyed = keyedQueue;
+function removeQueue(state, key, id) {
+	if (key == null) {
+		handleQueues(state, HANDLE_CLEAR);
+		state.queues.clear();
+		return;
+	}
+	const queue = getQueue(state, key);
+	if (queue == null) return;
+	if (typeof id === "number") {
+		queue.remove(id);
+		return;
+	}
+	queue.clear();
+	state.queues.delete(key);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -307,11 +306,11 @@ async function run(state) {
 		if (state.paused) {
 			const paused = item;
 			state.handled.push(() => {
-				handleQueuedResult(paused, error, result, state.items.length === 0);
+				handleQueuedResult(paused, error, result);
 			});
 			break;
 		}
-		handleQueuedResult(item, error, result, state.items.length === 0);
+		handleQueuedResult(item, error, result);
 		item = state.items.shift();
 	}
 	state.runners -= 1;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.191.0",
+	"version": "0.193.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",