@oscarpalmer/atoms 0.149.0 → 0.150.0

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/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 };