@oscarpalmer/atoms 0.189.0 → 0.190.0

package/dist/internal/result.d.mts

@@ -4,42 +4,42 @@ import { Err, ExtendedErr, Ok, Result } from "../result/models.mjs";
  * Is the _Result_ an extended error?
  *
  * @param result _Result_ to check
- * @returns `true` if the _Result_ is an extended error, `false` otherwise
+ * @returns `true` if the _Result_ is an extended error, otherwise `false`
  */
 declare function isError<Value, E = Error>(result: ExtendedErr<E> | Result<Value, E>, extended: true): result is ExtendedErr<E>;
 /**
  * Is the _Result_ an error?
  *
  * @param result _Result_ to check
- * @returns `true` if the _Result_ is an error, `false` otherwise
+ * @returns `true` if the _Result_ is an error, otherwise `false`
  */
 declare function isError<Value, E = Error>(result: Result<Value, E>): result is Err<E>;
 /**
  * Is the value an error?
  *
  * @param value Value to check
- * @returns `true` if the value is an error, `false` otherwise
+ * @returns `true` if the value is an error, otherwise `false`
  */
 declare function isError(value: unknown): value is Err<unknown> | ExtendedErr<unknown>;
 /**
  * Is the _Result_ ok?
  *
  * @param value _Result_ to check
- * @returns `true` if the _Result_ is ok, `false` otherwise
+ * @returns `true` if the _Result_ is ok, otherwise `false`
  */
 declare function isOk<Value, E = Error>(value: Result<Value, E>): value is Ok<Value>;
 /**
  * Is the value ok?
  *
  * @param value Value to check
- * @returns `true` if the value is ok, `false` otherwise
+ * @returns `true` if the value is ok, otherwise `false`
  */
 declare function isOk(value: unknown): value is Ok<unknown>;
 /**
  * Is the value a _Result_?
  *
  * @param value Value to check
- * @returns `true` if the value is a _Result_, `false` otherwise
+ * @returns `true` if the value is a _Result_, otherwise `false`
  */
 declare function isResult(value: unknown): value is ExtendedErr<unknown> | Result<unknown, unknown>;
 //#endregion

package/dist/internal/result.mjs

@@ -10,7 +10,7 @@ function isOk(value) {
 * Is the value a _Result_?
 *
 * @param value Value to check
-* @returns `true` if the value is a _Result_, `false` otherwise
+* @returns `true` if the value is a _Result_, otherwise `false`
 */
 function isResult(value) {
 	return isResultValue(value, true) || isResultValue(value, false);

package/dist/internal/value/has.d.mts

@@ -6,7 +6,7 @@ import { Result } from "../../result/models.mjs";
  *
  * @param data Object to check in
  * @param path Path for property, e.g., `foo.bar.baz`
- * @returns `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, otherwise `false`
  *
  * @example
  * ```typescript
@@ -25,7 +25,7 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  * @param data Object to check in
  * @param path Path for property, e.g., `foo.bar.baz`
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @returns `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, otherwise `false`
  *
  * @example
  * ```typescript

package/dist/logger.d.mts

@@ -1,5 +1,5 @@
 //#region src/logger.d.ts
-type LoggerInstance = {
+type Logger = {
   /**
    * Log any number of values at the "debug" log level
    */
@@ -51,8 +51,7 @@ type LoggerInstance = {
 /**
  * A named timer that can be used to log durations to the console
  */
-declare class TimedLogger {
-  #private;
+type TimedLogger = {
   /**
    * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
    */
@@ -67,13 +66,14 @@ declare class TimedLogger {
    * _(Will always log the total duration, even if logging is disabled)_
    */
   get stop(): () => void;
-  constructor(label: string);
-}
+};
+declare function isLogger(value: unknown): value is Logger;
+declare function isTimedLogger(value: unknown): value is TimedLogger;
 /**
  * A logger that can be used to log messages to the console
  *
  * _(Logging can be enabled or disabled by setting the `enabled` property)_
  */
-declare const Logger: LoggerInstance;
+declare const Logger: Logger;
 //#endregion
-export { Logger, type TimedLogger };
+export { Logger, type TimedLogger, isLogger, isTimedLogger };

package/dist/logger.mjs

@@ -1,50 +1,60 @@
 import { noop } from "./internal/function/misc.mjs";
 //#region src/logger.ts
-/**
-* A named timer that can be used to log durations to the console
-*/
-var TimedLogger = class {
-	#logger;
-	#stopper;
-	#state;
-	/**
-	* Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
-	*/
-	get active() {
-		return this.#state.started && !this.#state.stopped && enabled;
-	}
-	/**
-	* Log the current duration of the timer _(ignored if logging is disabled)_
-	*/
-	get log() {
-		return this.active ? this.#logger : noop;
-	}
-	/**
-	* Stop the timer and logs the total duration
-	*
-	* _(Will always log the total duration, even if logging is disabled)_
-	*/
-	get stop() {
-		return this.active ? this.#stopTimer() : noop;
-	}
-	constructor(label) {
-		this.#logger = console.timeLog.bind(console, label);
-		this.#stopper = console.timeEnd.bind(console, label);
-		this.#state = {
-			label,
-			started: enabled,
-			stopped: false
-		};
-		if (this.#state.started) console.time(label);
-	}
-	#stopTimer() {
-		const stopper = this.#stopper;
-		this.#state.stopped = true;
-		this.#logger = void 0;
-		this.#stopper = void 0;
-		return stopper;
+function isLogger(value) {
+	return isLoggerInstance(NAME_LOGGER, value);
+}
+function isLoggerInstance(name, value) {
+	return typeof value === "object" && value !== null && value[KEY_LOGGER] === name;
+}
+function isTimedLogger(value) {
+	return isLoggerInstance(NAME_TIMED, value);
+}
+function timedLogger(label) {
+	function stop() {
+		const fn = stopper;
+		state.stopped = true;
+		logger = void 0;
+		stopper = void 0;
+		return fn;
 	}
-};
+	let logger = console.timeLog.bind(console, label);
+	let stopper = console.timeEnd.bind(console, label);
+	const state = {
+		label,
+		started: enabled,
+		stopped: false
+	};
+	const instance = {};
+	Object.defineProperties(instance, {
+		[KEY_LOGGER]: {
+			enumerable: false,
+			value: NAME_TIMED
+		},
+		active: {
+			enumerable: true,
+			get() {
+				return state.started && !state.stopped && enabled;
+			}
+		},
+		log: {
+			enumerable: true,
+			get() {
+				return this.active ? logger : noop;
+			}
+		},
+		stop: {
+			enumerable: true,
+			get() {
+				return instance.active ? stop() : noop;
+			}
+		}
+	});
+	if (state.started) console.time(label);
+	return Object.freeze(instance);
+}
+const KEY_LOGGER = "$logger";
+const NAME_LOGGER = "Logger";
+const NAME_TIMED = "TimedLogger";
 const methods = [
 	"debug",
 	"dir",
@@ -63,7 +73,12 @@ const methods = [
 const Logger = (() => {
 	const instance = {};
 	Object.defineProperties(instance, {
+		[KEY_LOGGER]: {
+			enumerable: false,
+			value: NAME_LOGGER
+		},
 		enabled: {
+			enumerable: true,
 			get() {
 				return enabled;
 			},
@@ -71,15 +86,21 @@ const Logger = (() => {
 				enabled = typeof value === "boolean" ? value : enabled;
 			}
 		},
-		time: { value(label) {
-			return new TimedLogger(label);
-		} }
+		time: {
+			enumerable: true,
+			value(label) {
+				return timedLogger(label);
+			}
+		}
+	});
+	for (const method of methods) Object.defineProperty(instance, method, {
+		enumerable: true,
+		get() {
+			return enabled ? console[method].bind(console) : noop;
+		}
 	});
-	for (const method of methods) Object.defineProperty(instance, method, { get() {
-		return enabled ? console[method].bind(console) : noop;
-	} });
 	return Object.freeze(instance);
 })();
 let enabled = true;
 //#endregion
-export { Logger };
+export { Logger, isLogger, isTimedLogger };

package/dist/promise/helpers.d.mts

@@ -10,14 +10,14 @@ declare function getStrategyOrDefault(value: unknown): PromiseStrategy;
  * Is the value a fulfilled _Promise_ result?
  *
  * @param value Value to check
- * @returns `true` if the value is a fulfilled _Promise_ result, `false` otherwise
+ * @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
  */
 declare function isFulfilled<Value>(value: unknown): value is FulfilledPromise<Value>;
 /**
  * Is the value a rejected _Promise_ result?
  *
  * @param value Value to check
- * @returns `true` if the value is a rejected _Promise_ result, `false` otherwise
+ * @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
  */
 declare function isRejected(value: unknown): value is RejectedPromise;
 //#endregion

package/dist/promise/helpers.mjs

@@ -36,7 +36,7 @@ function getStrategyOrDefault(value) {
 * Is the value a fulfilled _Promise_ result?
 *
 * @param value Value to check
-* @returns `true` if the value is a fulfilled _Promise_ result, `false` otherwise
+* @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
 */
 function isFulfilled(value) {
 	return isType(value, PROMISE_TYPE_FULFILLED);
@@ -45,7 +45,7 @@ function isFulfilled(value) {
 * Is the value a rejected _Promise_ result?
 *
 * @param value Value to check
-* @returns `true` if the value is a rejected _Promise_ result, `false` otherwise
+* @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
 */
 function isRejected(value) {
 	return isType(value, PROMISE_TYPE_REJECTED);

package/dist/queue.d.mts

@@ -3,8 +3,7 @@ import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
 /**
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
-declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> {
-  #private;
+type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
   /**
    * Get keys of all active queues
    */
@@ -45,7 +44,6 @@ declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallb
    * Number of queues
    */
   get queues(): number;
-  constructor(callback: GenericAsyncCallback, options: Required<QueueOptions>);
   /**
    * Queue an item for a specific key
    *
@@ -99,12 +97,11 @@ declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallb
    * @param key Optional key to resume the queue for
    */
   resume(key?: string): void;
-}
+};
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> {
-  #private;
+type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
   /**
    * Is the queue active?
    */
@@ -137,7 +134,6 @@ declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>,
    * Number of items in the queue
    */
   get size(): number;
-  constructor(callback: GenericAsyncCallback, options: Required<QueueOptions>, key?: string);
   /**
    * Add an item to the queue
    *
@@ -167,7 +163,7 @@ declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>,
    * Resume the queue
    */
   resume(): void;
-}
+};
 /**
  * An error thrown by the Queue when an operation fails
  */
@@ -209,10 +205,26 @@ type QueuedResult<Value> = {
   /**
    * Result for the queued promise
    */
-  value: Value;
+  value: Value extends Promise<infer Result> ? Result : Value;
 };
 type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
-declare function keyedQueue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+/**
+ * Is the value keyed queue?
+ *
+ * @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>;
+/**
+ * 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 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 queue for an asynchronous callback function
  *
@@ -220,7 +232,7 @@ declare function keyedQueue<Callback extends GenericAsyncCallback>(callback: Cal
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
 /**
  * Create a queue for a synchronous callback function
  *
@@ -233,4 +245,4 @@ declare namespace queue {
   var keyed: typeof keyedQueue;
 }
 //#endregion
-export { type KeyedQueue, type Queue, type QueueError, type QueueOptions, type Queued, type QueuedResult, keyedQueue, queue };
+export { KeyedQueue, Queue, QueueError, QueueOptions, Queued, QueuedResult, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };