@oscarpalmer/atoms 0.149.0 → 0.151.0

package/types/promise/models.d.ts

@@ -0,0 +1,81 @@
+export declare class CancelablePromise<Value = void> extends Promise<Value> {
+    #private;
+    constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
+    /**
+     * Cancel the promise, rejecting it with an optional reason
+     * @param reason Optional reason for canceling the promise
+     */
+    cancel(reason?: unknown): void;
+}
+export type FulfilledPromise<Value> = {
+    status: typeof PROMISE_TYPE_FULFILLED;
+    value: Value;
+};
+export type PromiseData<Items extends unknown[]> = {
+    last: number;
+    result: Items | PromisesResult<Items>;
+};
+export type PromiseHandlers<Items extends unknown[]> = {
+    resolve: (value: Items | PromisesResult<Items>) => void;
+    reject: (reason: unknown) => void;
+};
+export type PromiseOptions = {
+    /**
+     * AbortSignal for aborting the promise; when aborted, the promise will reject with the reason of the signal
+     */
+    signal?: AbortSignal;
+    /**
+     * How long to wait for (in milliseconds; defaults to `0`)
+     */
+    time?: number;
+};
+export type PromiseParameters<Items extends unknown[]> = {
+    abort: () => void;
+    complete: boolean;
+    data: PromiseData<Items>;
+    handlers: PromiseHandlers<Items>;
+    index: number;
+    signal?: AbortSignal;
+    value?: unknown;
+};
+/**
+ * Promise handling strategy
+ *
+ * - `complete`: wait for all promises to settle, then return the results
+ * 	- Returns an array of fulfilled and/or rejected results
+ * - `first`: rejects on the first rejected promise
+ * 	- Returns an array of values
+ */
+export type PromiseStrategy = 'complete' | 'first';
+export declare class PromiseTimeoutError extends Error {
+    constructor();
+}
+export type Promises<Items extends unknown[]> = {
+    [K in keyof Items]: Promise<Items[K]>;
+};
+export type PromisesOptions = {
+    signal?: AbortSignal;
+    strategy?: PromiseStrategy;
+};
+export type PromisesResult<Items extends unknown[]> = {
+    [K in keyof Items]: Items[K] extends Promise<infer Value> ? PromisesResultItem<Value> : never;
+};
+export type PromisesResultItem<Value> = FulfilledPromise<Value> | RejectedPromise;
+export type RejectedPromise = {
+    status: typeof PROMISE_TYPE_REJECTED;
+    reason: unknown;
+};
+export declare const PROMISE_ABORT_OPTIONS: {
+    once: boolean;
+};
+export declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+export declare const PROMISE_EVENT_NAME = "abort";
+export declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
+export declare const PROMISE_MESSAGE_EXPECTATION_PROMISES = "Promises expected an array of promises";
+export declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
+export declare const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
+export declare const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
+export declare const PROMISE_STRATEGY_ALL: Set<PromiseStrategy>;
+export declare const PROMISE_STRATEGY_DEFAULT: PromiseStrategy;
+export declare const PROMISE_TYPE_FULFILLED = "fulfilled";
+export declare const PROMISE_TYPE_REJECTED = "rejected";

package/types/promise/timed.d.ts

@@ -0,0 +1,17 @@
+import type { RequiredKeys } from '../models';
+import { type PromiseOptions } from './models';
+export declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
+/**
+ * Create a promise that should be settled within a certain amount of time
+ * @param promise Promise to settle
+ * @param options Timed options
+ * @returns Timed promise
+ */
+export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, 'time'>): Promise<Value>;
+/**
+ * Create a promise that should be settled within a certain amount of time
+ * @param promise Promise to settle
+ * @param time How long to wait for _(in milliseconds; defaults to `0`)_
+ * @returns Timed promise
+ */
+export declare function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;

package/types/result/index.d.ts

@@ -1,6 +1,6 @@
 import { attemptPromise } from '../promise';
 import { matchResult } from './match';
-import type { Err, ExtendedErr, ExtendedResult, Ok, Result } from './models';
+import type { ExtendedResult, Result } from './models';
 import { attemptFlow } from './work/flow';
 import { attemptPipe } from './work/pipe';
 /**
@@ -49,38 +49,7 @@ export declare namespace attempt {
     var pipe: typeof attemptPipe;
     var promise: typeof attemptPromise;
 }
-/**
- * Creates an extended error result
- * @param error Error value
- * @param original Original error
- * @returns Error result
- */
-export declare function error<E>(value: E, original: Error): ExtendedErr<E>;
-/**
- * Creates an error result
- * @param error Error value
- * @returns Error result
- */
-export declare function error<E>(value: E): Err<E>;
-/**
- * Creates an ok result
- * @param value Value
- * @returns Ok result
- */
-export declare function ok<Value>(value: Value): Ok<Value>;
-/**
- * Gets the value of an ok result _(or a default value)_
- * @param value Result to unwrap
- * @param defaultValue Default value
- * @returns Value of the result _(or the default value)_
- */
-export declare function unwrap<Value, E = Error>(value: Result<Value, E>, defaultValue: Value): Value;
-/**
- * Gets the value of an ok result _(or a default value)_
- * @param value Result to unwrap
- * @param defaultValue Default value
- * @returns Value of the result _(or the default value)_
- */
-export declare function unwrap(value: unknown, defaultValue: unknown): unknown;
 export { isError, isOk, isResult } from '../internal/result';
+export { toResult as fromPromise } from '../promise/misc';
+export { error, ok, toPromise, unwrap } from './misc';
 export type { Err, ExtendedErr, ExtendedResult, Ok, Result } from './models';

package/types/result/misc.d.ts

@@ -0,0 +1,51 @@
+import type { AnyResult, Err, ExtendedErr, Ok, Result } from './models';
+/**
+ * Creates an extended error result
+ * @param error Error value
+ * @param original Original error
+ * @returns Error result
+ */
+export declare function error<E>(value: E, original: Error): ExtendedErr<E>;
+/**
+ * Creates an error result
+ * @param error Error value
+ * @returns Error result
+ */
+export declare function error<E>(value: E): Err<E>;
+export declare function getError<E>(value: E, original?: Error): Err<E> | ExtendedErr<E>;
+/**
+ * Creates an ok result
+ * @param value Value
+ * @returns Ok result
+ */
+export declare function ok<Value>(value: Value): Ok<Value>;
+/**
+ * Converts a result to a promise
+ *
+ * Resolves if ok, rejects for error
+ * @param result Result to convert
+ * @returns Promised result
+ */
+export declare function toPromise<Value, E = Error>(callback: () => AnyResult<Value, E>): Promise<Value>;
+/**
+ * Converts a result to a promise
+ *
+ * Resolves if ok, rejects for error
+ * @param result Result to convert
+ * @returns Promised result
+ */
+export declare function toPromise<Value, E = Error>(result: AnyResult<Value, E>): Promise<Value>;
+/**
+ * Gets the value of an ok result _(or a default value)_
+ * @param value Result to unwrap
+ * @param defaultValue Default value
+ * @returns Value of the result _(or the default value)_
+ */
+export declare function unwrap<Value, E = Error>(value: Result<Value, E>, defaultValue: Value): Value;
+/**
+ * Gets the value of an ok result _(or a default value)_
+ * @param value Result to unwrap
+ * @param defaultValue Default value
+ * @returns Value of the result _(or the default value)_
+ */
+export declare function unwrap(value: unknown, defaultValue: unknown): unknown;

package/dist/internal/frame-rate.js

@@ -1,25 +0,0 @@
-function calculate() {
-	return new Promise((resolve) => {
-		const values = [];
-		let last;
-		function step(now) {
-			if (last != null) values.push(now - last);
-			last = now;
-			if (values.length >= TOTAL) resolve(values.sort().slice(TRIM_PART, -TRIM_PART).reduce((first, second) => first + second, 0) / (values.length - TRIM_TOTAL));
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
-var TOTAL = 10;
-var TRIM_PART = 2;
-var TRIM_TOTAL = 4;
-var FRAME_RATE_MS = 1e3 / 60;
-/**
-* A calculated average of the refresh rate of the display _(in milliseconds)_
-*/
-calculate().then((value) => {
-	FRAME_RATE_MS = value;
-});
-var frame_rate_default = FRAME_RATE_MS;
-export { frame_rate_default as default };

package/dist/promise.js

@@ -1,221 +0,0 @@
-var CancelablePromise = class extends Promise {
-	#rejector;
-	constructor(executor) {
-		let rejector;
-		super((resolve, reject) => {
-			rejector = reject;
-			executor(resolve, reject);
-		});
-		this.#rejector = rejector;
-	}
-	/**
-	* Cancel the promise, rejecting it with an optional reason
-	* @param reason Optional reason for canceling the promise
-	*/
-	cancel(reason) {
-		this.#rejector(reason);
-	}
-};
-var PromiseTimeoutError = class extends Error {
-	constructor() {
-		super(MESSAGE_TIMEOUT);
-		this.name = ERROR_NAME;
-	}
-};
-async function attemptPromise(value, options) {
-	const isFunction = typeof value === "function";
-	if (!isFunction && !(value instanceof Promise)) return Promise.reject(new TypeError(MESSAGE_EXPECTATION_ATTEMPT));
-	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
-		rejector(signal.reason);
-	}
-	async function handler(resolve, reject) {
-		try {
-			let result = isFunction ? value() : await value;
-			if (result instanceof Promise) result = await result;
-			settlePromise(abort, resolve, result, signal);
-		} catch (error) {
-			settlePromise(abort, reject, error, signal);
-		}
-	}
-	let rejector;
-	signal?.addEventListener(EVENT_NAME, abort, ABORT_OPTIONS);
-	const promise = new Promise((resolve, reject) => {
-		rejector = reject;
-		handler(resolve, reject);
-	});
-	return time > 0 ? getTimed(promise, time, signal) : promise;
-}
-/**
-* Create a cancelable promise
-* @param executor Executor function for the promise
-* @returns Cancelable promise
-*/
-function cancelable(executor) {
-	return new CancelablePromise(executor);
-}
-function delay(options) {
-	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
-		clearTimeout(timeout);
-		rejector(signal.reason);
-	}
-	signal?.addEventListener("abort", abort, ABORT_OPTIONS);
-	let rejector;
-	let timeout;
-	return new Promise((resolve, reject) => {
-		rejector = reject;
-		timeout = setTimeout(() => {
-			settlePromise(abort, resolve, void 0, signal);
-		}, time);
-	});
-}
-function getNumberOrDefault(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
-}
-function getPromiseOptions(input) {
-	if (typeof input === "number") return { time: getNumberOrDefault(input) };
-	if (input instanceof AbortSignal) return {
-		signal: input,
-		time: 0
-	};
-	const options = typeof input === "object" && input !== null ? input : {};
-	return {
-		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
-		time: getNumberOrDefault(options.time)
-	};
-}
-function getPromisesOptions(input) {
-	if (typeof input === "string") return { strategy: getStrategyOrDefault(input) };
-	if (input instanceof AbortSignal) return {
-		signal: input,
-		strategy: DEFAULT_STRATEGY
-	};
-	const options = typeof input === "object" && input !== null ? input : {};
-	return {
-		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
-		strategy: getStrategyOrDefault(options.strategy)
-	};
-}
-function getStrategyOrDefault(value) {
-	return strategies.has(value) ? value : DEFAULT_STRATEGY;
-}
-async function getTimed(promise, time, signal) {
-	function abort() {
-		clearTimeout(timeout);
-		rejector(signal.reason);
-	}
-	signal?.addEventListener(EVENT_NAME, abort, ABORT_OPTIONS);
-	let rejector;
-	let timeout;
-	return Promise.race([promise, new Promise((_, reject) => {
-		rejector = reject;
-		timeout = setTimeout(() => {
-			settlePromise(abort, reject, new PromiseTimeoutError(), signal);
-		}, time);
-	})]).then((value) => {
-		clearTimeout(timeout);
-		signal?.removeEventListener(EVENT_NAME, abort);
-		return value;
-	});
-}
-function handleResult(status, parameters) {
-	const { abort, complete, data, handlers, index, signal, value } = parameters;
-	if (signal?.aborted ?? false) return;
-	if (!complete && status === TYPE_REJECTED) {
-		settlePromise(abort, handlers.reject, value, signal);
-		return;
-	}
-	data.result[index] = !complete ? value : status === TYPE_FULFILLED ? {
-		status,
-		value
-	} : {
-		status,
-		reason: value
-	};
-	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
-}
-/**
-* Is the value a fulfilled promise result?
-* @param value Value to check
-* @returns `true` if the value is a fulfilled promise result, `false` otherwise
-*/
-function isFulfilled(value) {
-	return isType(value, TYPE_FULFILLED);
-}
-/**
-* Is the value a rejected promise result?
-* @param value Value to check
-* @returns `true` if the value is a rejected promise result, `false` otherwise
-*/
-function isRejected(value) {
-	return isType(value, TYPE_REJECTED);
-}
-function isType(value, type) {
-	return typeof value === "object" && value !== null && value.status === type;
-}
-async function promises(items, options) {
-	const { signal, strategy } = getPromisesOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	if (!Array.isArray(items)) return Promise.reject(new TypeError(MESSAGE_EXPECTATION_PROMISES));
-	const actual = items.filter((item) => item instanceof Promise);
-	const { length } = actual;
-	if (length === 0) return actual;
-	const complete = strategy === DEFAULT_STRATEGY;
-	function abort() {
-		handlers.reject(signal.reason);
-	}
-	signal?.addEventListener("abort", abort, ABORT_OPTIONS);
-	const data = {
-		last: length - 1,
-		result: []
-	};
-	let handlers;
-	return new Promise((resolve, reject) => {
-		handlers = {
-			reject,
-			resolve
-		};
-		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(TYPE_FULFILLED, {
-			abort,
-			complete,
-			data,
-			handlers,
-			index,
-			signal,
-			value
-		})).catch((reason) => handleResult(TYPE_REJECTED, {
-			abort,
-			complete,
-			data,
-			handlers,
-			index,
-			signal,
-			value: reason
-		}));
-	});
-}
-function settlePromise(aborter, settler, value, signal) {
-	signal?.removeEventListener(EVENT_NAME, aborter);
-	settler(value);
-}
-async function timed(promise, options) {
-	if (!(promise instanceof Promise)) return Promise.reject(new TypeError(MESSAGE_EXPECTATION_TIMED));
-	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	return time > 0 ? getTimed(promise, time, signal) : promise;
-}
-var ABORT_OPTIONS = { once: true };
-var DEFAULT_STRATEGY = "complete";
-var ERROR_NAME = "PromiseTimeoutError";
-var EVENT_NAME = "abort";
-var MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-var MESSAGE_EXPECTATION_PROMISES = "Promises expected an array of promises";
-var MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
-var MESSAGE_TIMEOUT = "Promise timed out";
-var strategies = new Set(["complete", "first"]);
-var TYPE_FULFILLED = "fulfilled";
-var TYPE_REJECTED = "rejected";
-export { CancelablePromise, PromiseTimeoutError, attemptPromise, cancelable, delay, isFulfilled, isRejected, promises, timed };

package/src/internal/frame-rate.ts

@@ -1,63 +0,0 @@
-// #region Functions
-
-function calculate(): Promise<number> {
-	return new Promise(resolve => {
-		const values: number[] = [];
-
-		let last: DOMHighResTimeStamp;
-
-		function step(now: DOMHighResTimeStamp): void {
-			if (last != null) {
-				values.push(now - last);
-			}
-
-			last = now;
-
-			if (values.length >= TOTAL) {
-				const median =
-					values
-						.sort()
-						.slice(TRIM_PART, -TRIM_PART)
-						.reduce((first, second) => first + second, 0) /
-					(values.length - TRIM_TOTAL);
-
-				resolve(median);
-			} else {
-				requestAnimationFrame(step);
-			}
-		}
-
-		requestAnimationFrame(step);
-	});
-}
-
-// #endregion
-
-// #region Variables
-
-const TOTAL = 10;
-
-const TRIM_PART = 2;
-
-const TRIM_TOTAL = 4;
-
-let FRAME_RATE_MS = 1000 / 60;
-
-// #endregion
-
-// #region Initialization
-
-/**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-calculate().then(value => {
-	FRAME_RATE_MS = value;
-});
-
-// #endregion
-
-// #region Exports
-
-export default FRAME_RATE_MS;
-
-// #endregion