@oscarpalmer/atoms 0.189.1 → 0.190.0

package/dist/function/memoize.mjs

@@ -2,95 +2,6 @@ import { isPlainObject } from "../internal/is.mjs";
 import { getString, join } from "../internal/string.mjs";
 import { SizedMap } from "../sized/map.mjs";
 //#region src/function/memoize.ts
-/**
-* A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
-*/
-var Memoized = class {
-	#state;
-	/**
-	* Maximum cache size
-	*
-	* @returns Maximum cache size _(or `Number.NaN` if the instance has been destroyed)_
-	*/
-	get maximum() {
-		return this.#state.cache?.maximum ?? NaN;
-	}
-	/**
-	* Current cache size
-	*
-	* @returns Current cache size _(or `Number.NaN` if the instance has been destroyed)_
-	*/
-	get size() {
-		return this.#state.cache?.size ?? NaN;
-	}
-	constructor(callback, options) {
-		const cache = new SizedMap(options.cacheSize);
-		const getter = (...parameters) => {
-			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
-			if (cache.has(key)) return cache.get(key);
-			const value = callback(...parameters);
-			cache.set(key, value);
-			return value;
-		};
-		this.#state = {
-			cache,
-			getter
-		};
-	}
-	/**
-	* Clear the cache
-	*/
-	clear() {
-		this.#state.cache?.clear();
-	}
-	/**
-	* Delete a result from the cache
-	*
-	* @param key Key to delete
-	* @returns `true` if the key existed and was removed, otherwise `false`
-	*/
-	delete(key) {
-		return this.#state.cache?.delete(key) ?? false;
-	}
-	/**
-	* Destroy the instance
-	*
-	* _(When a Memoized instance is destroyed, its cache and callback are removed, and calls to `run` will throw an error)_
-	*/
-	destroy() {
-		this.#state.cache?.clear();
-		this.#state.cache = void 0;
-		this.#state.getter = void 0;
-	}
-	/**
-	* Get a result from the cache
-	*
-	* @param key Key to get
-	* @returns Cached result or `undefined` if it does not exist
-	*/
-	get(key) {
-		return this.#state.cache?.get(key);
-	}
-	/**
-	* Does the result exist?
-	*
-	* @param key Key to check
-	* @returns `true` if the result exists, otherwise `false`
-	*/
-	has(key) {
-		return this.#state.cache?.has(key) ?? false;
-	}
-	/**
-	* Run the callback with the provided parameters
-	*
-	* @param parameters Parameters to pass to the callback
-	* @returns Cached or computed _(then cached)_ result
-	*/
-	run(...parameters) {
-		if (this.#state.cache == null || this.#state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
-		return this.#state.getter(...parameters);
-	}
-};
 function getMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
@@ -107,7 +18,49 @@ function getMemoizationOptions(input) {
 */
 function memoize(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MEMOIZED_ERROR_CALLBACK);
-	return new Memoized(callback, getMemoizationOptions(options));
+	const state = { options: getMemoizationOptions(options) };
+	state.cache = new SizedMap(state.options.cacheSize);
+	state.getter = (...parameters) => {
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
+		if (state.cache.has(key)) return state.cache.get(key);
+		const value = callback(...parameters);
+		state.cache?.set(key, value);
+		return value;
+	};
+	const instance = {
+		clear: () => {
+			state.cache?.clear();
+		},
+		delete: (key) => {
+			return state.cache?.delete(key) ?? false;
+		},
+		destroy: () => {
+			state.cache?.clear();
+			state.cache = void 0;
+			state.getter = void 0;
+		},
+		get: (key) => {
+			return state.cache?.get(key);
+		},
+		has: (key) => {
+			return state.cache?.has(key) ?? false;
+		},
+		run: (...parameters) => {
+			if (state.cache == null || state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
+			return state.getter(...parameters);
+		}
+	};
+	Object.defineProperties(instance, {
+		maximum: {
+			enumerable: true,
+			get: () => state.cache?.maximum ?? NaN
+		},
+		size: {
+			enumerable: true,
+			get: () => state.cache?.size ?? NaN
+		}
+	});
+	return Object.freeze(instance);
 }
 const DEFAULT_CACHE_SIZE = 1024;
 const MEMOIZED_ERROR_CALLBACK = "Memoized requires a callback function";

package/dist/function/once.mjs

@@ -41,10 +41,22 @@ function asyncOnce(callback) {
 		});
 	};
 	Object.defineProperties(fn, {
-		called: { get: () => state.called },
-		cleared: { get: () => state.cleared },
-		error: { get: () => state.error },
-		finished: { get: () => state.finished }
+		called: {
+			enumerable: true,
+			get: () => state.called
+		},
+		cleared: {
+			enumerable: true,
+			get: () => state.cleared
+		},
+		error: {
+			enumerable: true,
+			get: () => state.error
+		},
+		finished: {
+			enumerable: true,
+			get: () => state.finished
+		}
 	});
 	fn.clear = () => {
 		if (!state.called || !state.finished || state.cleared) return;

package/dist/herald.d.mts

@@ -1,8 +1,6 @@
 import { GenericCallback } from "./models.mjs";
 //#region src/herald.d.ts
-declare class Events<Map extends Record<string, GenericCallback>> {
-  #private;
-  constructor(herald: Herald<Map>);
+type Events<Map extends Record<string, GenericCallback>> = {
   /**
    * Subscribe to an event with a callback
    *
@@ -19,17 +17,9 @@ declare class Events<Map extends Record<string, GenericCallback>> {
    * @returns Unsubscriber function
    */
   unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void;
-}
-/**
- * A _Herald_ is an announcer for named events, allowing emission, subscription, and unsubscription of events
- */
-declare class Herald<Map extends Record<string, GenericCallback>> {
-  #private;
-  /**
-   * Events interface for subscribing to and unsubscribing from events
-   */
+};
+type Herald<Map extends Record<string, GenericCallback>> = {
   readonly events: Events<Map>;
-  constructor(names: (keyof Map)[]);
   /**
    * Remove all event subscribers
    */
@@ -56,7 +46,7 @@ declare class Herald<Map extends Record<string, GenericCallback>> {
    * @param callback Callback function
    */
   unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void;
-}
+};
 type Unsubscriber = () => void;
 /**
  * Create a _Herald_ for announcing named events
@@ -65,5 +55,19 @@ type Unsubscriber = () => void;
  * @returns _Herald_ instance
  */
 declare function herald<Events extends Record<string, GenericCallback>>(names: (keyof Events)[]): Herald<Events>;
+/**
+ * Is the value events for a herald?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is events for a herald, otherwise `false`
+ */
+declare function isEvents<Map extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is Events<Map>;
+/**
+ * Is the value a herald?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a herald, otherwise `false`
+ */
+declare function isHerald<Events extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is Herald<Events>;
 //#endregion
-export { type Events, type Herald, Unsubscriber, herald };
+export { Events, Herald, Unsubscriber, herald, isEvents, isHerald };

package/dist/herald.mjs

@@ -1,92 +1,16 @@
 import { noop } from "./internal/function/misc.mjs";
 //#region src/herald.ts
-var Events = class {
-	#herald;
-	constructor(herald) {
-		this.#herald = herald;
-	}
-	/**
-	* Subscribe to an event with a callback
-	*
-	* @param event Event name
-	* @param callback Callback function
-	* @returns Unsubscriber function
-	*/
-	subscribe(event, callback) {
-		return this.#herald.subscribe(event, callback);
-	}
-	/**
-	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
-	*
-	* @param event Event name
-	* @param callback Callback function
-	* @returns Unsubscriber function
-	*/
-	unsubscribe(event, callback) {
-		return this.#herald.unsubscribe(event, callback);
-	}
-};
-/**
-* A _Herald_ is an announcer for named events, allowing emission, subscription, and unsubscription of events
-*/
-var Herald = class {
-	#names;
-	#subscribers = /* @__PURE__ */ new Map();
-	constructor(names) {
-		this.#names = new Set(names);
-		Object.defineProperty(this, "events", { value: new Events(this) });
-	}
-	/**
-	* Remove all event subscribers
-	*/
-	clear() {
-		this.#subscribers.clear();
-	}
-	/**
-	* Emit an event with parameters
-	*
-	* @param event Event name
-	* @param parameters Event parameters
-	*/
-	emit(event, ...parameters) {
-		const subscribers = this.#subscribers.get(event);
-		if (subscribers == null) return;
-		for (const callback of subscribers) callback(...parameters);
-	}
-	/**
-	* Subscribe to an event with a callback
-	*
-	* @param event Event name
-	* @param callback Callback function
-	* @returns Unsubscriber function
-	*/
-	subscribe(event, callback) {
-		if (!this.#names.has(event) || typeof callback !== "function") return noop;
-		let subscribers = this.#subscribers.get(event);
-		if (subscribers == null) {
-			subscribers = /* @__PURE__ */ new Set();
-			this.#subscribers.set(event, subscribers);
-		}
-		subscribers.add(callback);
-		return () => {
-			subscribers?.delete(callback);
-		};
-	}
-	/**
-	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
-	*
-	* @param event Event name
-	* @param callback Callback function
-	*/
-	unsubscribe(event, callback) {
-		if (!this.#names.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
-		const subscribers = this.#subscribers.get(event);
-		if (subscribers == null) return;
-		if (callback == null) subscribers.clear();
-		else subscribers.delete(callback);
-		if (callback == null || subscribers.size === 0) this.#subscribers.delete(event);
-	}
-};
+function getEvents(herald) {
+	const events = {
+		subscribe: (event, callback) => herald.subscribe(event, callback),
+		unsubscribe: (event, callback) => herald.unsubscribe(event, callback)
+	};
+	Object.defineProperty(events, KEY_HERALD, {
+		enumerable: false,
+		value: NAME_EVENTS
+	});
+	return Object.freeze(events);
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -95,8 +19,74 @@ var Herald = class {
 */
 function herald(names) {
 	if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string")) throw new Error(MESSAGE);
-	return new Herald(names);
+	const set = new Set(names);
+	const subscribers = /* @__PURE__ */ new Map();
+	const instance = {
+		clear() {
+			subscribers.clear();
+		},
+		emit(event, ...parameters) {
+			const callbacks = subscribers.get(event);
+			if (callbacks == null) return;
+			for (const callback of callbacks) callback(...parameters);
+		},
+		subscribe(event, callback) {
+			if (!set.has(event) || typeof callback !== "function") return noop;
+			let eventSubscribers = subscribers.get(event);
+			if (eventSubscribers == null) {
+				eventSubscribers = /* @__PURE__ */ new Set();
+				subscribers.set(event, eventSubscribers);
+			}
+			eventSubscribers.add(callback);
+			return () => {
+				eventSubscribers?.delete(callback);
+			};
+		},
+		unsubscribe(event, callback) {
+			if (!set.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
+			const eventSubscribers = subscribers.get(event);
+			if (eventSubscribers == null) return;
+			if (callback == null) eventSubscribers.clear();
+			else eventSubscribers.delete(callback);
+			if (callback == null || eventSubscribers.size === 0) subscribers.delete(event);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_HERALD]: {
+			enumerable: false,
+			value: NAME_HERALD
+		},
+		events: {
+			enumerable: true,
+			value: getEvents(instance)
+		}
+	});
+	return Object.freeze(instance);
+}
+/**
+* Is the value events for a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is events for a herald, otherwise `false`
+*/
+function isEvents(value) {
+	return isHeraldInstance(NAME_EVENTS, value);
+}
+/**
+* Is the value a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is a herald, otherwise `false`
+*/
+function isHerald(value) {
+	return isHeraldInstance(NAME_HERALD, value);
+}
+function isHeraldInstance(name, value) {
+	return typeof value === "object" && value != null && KEY_HERALD in value && value[KEY_HERALD] === name;
 }
+const KEY_HERALD = "$herald";
 const MESSAGE = "Herald requires an array of event names.";
+const NAME_EVENTS = "events";
+const NAME_HERALD = "herald";
 //#endregion
-export { herald };
+export { herald, isEvents, isHerald };