@oscarpalmer/atoms 0.149.0 → 0.150.0

package/src/promise/models.ts

@@ -0,0 +1,131 @@
+// #region Types
+
+export class CancelablePromise<Value = void> extends Promise<Value> {
+	#rejector!: (reason: unknown) => void;
+
+	constructor(
+		executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void,
+	) {
+		let rejector: (reason: unknown) => void;
+
+		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?: unknown): void {
+		this.#rejector(reason);
+	}
+}
+
+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 class PromiseTimeoutError extends Error {
+	constructor() {
+		super(PROMISE_MESSAGE_TIMEOUT);
+
+		this.name = PROMISE_ERROR_NAME;
+	}
+}
+
+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;
+};
+
+// #endregion
+
+// #region Variables
+
+export const PROMISE_ABORT_OPTIONS = {once: true};
+
+export const PROMISE_ERROR_NAME = 'PromiseTimeoutError';
+
+export const PROMISE_EVENT_NAME = 'abort';
+
+export const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = 'Attempt expected a function or a promise';
+
+export const PROMISE_MESSAGE_EXPECTATION_PROMISES = 'Promises expected an array of promises';
+
+export const PROMISE_MESSAGE_EXPECTATION_RESULT = 'toResult expected a Promise';
+
+export const PROMISE_MESSAGE_EXPECTATION_TIMED = 'Timed function expected a Promise';
+
+export const PROMISE_MESSAGE_TIMEOUT = 'Promise timed out';
+
+export const PROMISE_STRATEGY_ALL = new Set<PromiseStrategy>(['complete', 'first']);
+
+export const PROMISE_STRATEGY_DEFAULT: PromiseStrategy = 'complete';
+
+export const PROMISE_TYPE_FULFILLED = 'fulfilled';
+
+export const PROMISE_TYPE_REJECTED = 'rejected';
+
+// #endregion

package/src/promise/timed.ts

@@ -0,0 +1,90 @@
+import type {RequiredKeys} from '../models';
+import {getPromiseOptions} from './helpers';
+import {settlePromise} from './misc';
+import {
+	PROMISE_ABORT_OPTIONS,
+	PROMISE_EVENT_NAME,
+	PROMISE_MESSAGE_EXPECTATION_TIMED,
+	PromiseTimeoutError,
+	type PromiseOptions,
+} from './models';
+
+// #region Functions
+
+export async function getTimedPromise<Value>(
+	promise: Promise<Value>,
+	time: number,
+	signal?: AbortSignal,
+): Promise<Value> {
+	function abort(): void {
+		cancelAnimationFrame(frame);
+
+		rejector(signal!.reason);
+	}
+
+	function run(now: DOMHighResTimeStamp): void {
+		start ??= now;
+
+		if (time === 0 || now - start >= time - 5) {
+			settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
+		} else {
+			frame = requestAnimationFrame(run);
+		}
+	}
+
+	signal?.addEventListener(PROMISE_EVENT_NAME, abort, PROMISE_ABORT_OPTIONS);
+
+	let frame: DOMHighResTimeStamp;
+	let rejector: (reason: unknown) => void;
+	let start: DOMHighResTimeStamp;
+
+	return Promise.race<Value>([
+		promise,
+		new Promise((_, reject) => {
+			rejector = reject;
+
+			frame = requestAnimationFrame(run);
+		}),
+	]).then(value => {
+		cancelAnimationFrame(frame);
+
+		signal?.removeEventListener(PROMISE_EVENT_NAME, abort);
+
+		return 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 async 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 async function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;
+
+export async function timed<Value>(promise: Promise<Value>, options: unknown): Promise<Value> {
+	if (!(promise instanceof Promise)) {
+		return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
+	}
+
+	const {signal, time} = getPromiseOptions(options);
+
+	if (signal?.aborted ?? false) {
+		return Promise.reject(signal!.reason);
+	}
+
+	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
+}
+
+// #endregion

package/src/result/index.ts

@@ -1,7 +1,7 @@
-import {isOk} from '../internal/result';
 import {attemptPromise} from '../promise';
 import {matchResult} from './match';
-import type {Err, ExtendedErr, ExtendedResult, Ok, Result} from './models';
+import {getError, ok} from './misc';
+import type {ExtendedErr, ExtendedResult, Result} from './models';
 import {attemptFlow} from './work/flow';
 import {attemptPipe} from './work/pipe';
 
@@ -94,75 +94,13 @@ attempt.match = matchResult;
 attempt.pipe = attemptPipe;
 attempt.promise = attemptPromise;
 
-/**
- * Creates an extended error result
- * @param error Error value
- * @param original Original error
- * @returns Error result
- */
-export function error<E>(value: E, original: Error): ExtendedErr<E>;
-
-/**
- * Creates an error result
- * @param error Error value
- * @returns Error result
- */
-export function error<E>(value: E): Err<E>;
-
-export function error<E>(value: E, original?: Error): Err<E> | ExtendedErr<E> {
-	return getError(value, original);
-}
-
-function getError<E>(value: E, original?: Error): Err<E> | ExtendedErr<E> {
-	const errorResult: Err<E> | ExtendedErr<E> = {
-		error: value,
-		ok: false,
-	};
-
-	if (original instanceof Error) {
-		(errorResult as ExtendedErr<E>).original = original;
-	}
-
-	return errorResult;
-}
-
-/**
- * Creates an ok result
- * @param value Value
- * @returns Ok result
- */
-export function ok<Value>(value: Value): Ok<Value> {
-	return {
-		ok: true,
-		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 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 function unwrap(value: unknown, defaultValue: unknown): unknown;
-
-export function unwrap(value: unknown, defaultValue: unknown): unknown {
-	return isOk(value) ? value.value : defaultValue;
-}
-
 // #endregion
 
 // #region Exports
 
 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';
 
 // #endregion

package/src/result/misc.ts

@@ -0,0 +1,115 @@
+import {isOk, isResult} from '../internal/result';
+import type {AnyResult, Err, ExtendedErr, Ok, Result} from './models';
+
+// #region Functions
+
+/**
+ * Creates an extended error result
+ * @param error Error value
+ * @param original Original error
+ * @returns Error result
+ */
+export function error<E>(value: E, original: Error): ExtendedErr<E>;
+
+/**
+ * Creates an error result
+ * @param error Error value
+ * @returns Error result
+ */
+export function error<E>(value: E): Err<E>;
+
+export function error<E>(value: E, original?: Error): Err<E> | ExtendedErr<E> {
+	return getError(value, original);
+}
+
+export function getError<E>(value: E, original?: Error): Err<E> | ExtendedErr<E> {
+	const errorResult: Err<E> | ExtendedErr<E> = {
+		error: value,
+		ok: false,
+	};
+
+	if (original instanceof Error) {
+		(errorResult as ExtendedErr<E>).original = original;
+	}
+
+	return errorResult;
+}
+
+/**
+ * Creates an ok result
+ * @param value Value
+ * @returns Ok result
+ */
+export function ok<Value>(value: Value): Ok<Value> {
+	return {
+		ok: true,
+		value,
+	};
+}
+
+/**
+ * Converts a result to a promise
+ *
+ * Resolves if ok, rejects for error
+ * @param result Result to convert
+ * @returns Promised result
+ */
+export async 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 async function toPromise<Value, E = Error>(result: 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 async function toPromise<Value, E = Error>(
+	result: AnyResult<Value, E> | (() => AnyResult<Value, E>),
+): Promise<Value> {
+	const actual = typeof result === 'function' ? result() : result;
+
+	if (!isResult(actual)) {
+		return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
+	}
+
+	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
+}
+
+/**
+ * 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 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 function unwrap(value: unknown, defaultValue: unknown): unknown;
+
+export function unwrap(value: unknown, defaultValue: unknown): unknown {
+	return isOk(value) ? value.value : defaultValue;
+}
+
+// #endregion
+
+// #region Variables
+
+const MESSAGE_PROMISE_RESULT = 'toPromise expected to receive a Result';
+
+// #endregion

package/types/index.d.ts

@@ -32,7 +32,7 @@ export * from './logger';
 export * from './math';
 export * from './models';
 export * from './number';
-export * from './promise';
+export * from './promise/index';
 export * from './query';
 export * from './queue';
 export * from './random';

package/types/promise/delay.d.ts

@@ -0,0 +1,13 @@
+import { type PromiseOptions } from './models';
+/**
+ * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted
+ * @param options Options for the delay
+ * @returns Delayed promise
+ */
+export declare function delay(options?: PromiseOptions): Promise<void>;
+/**
+ * Create a delayed promise that resolves after a certain amount of time
+ * @param time How long to wait for _(in milliseconds; defaults to `0`)_
+ * @returns Delayed promise
+ */
+export declare function delay(time?: number): Promise<void>;

package/types/promise/helpers.d.ts

@@ -0,0 +1,17 @@
+import type { RequiredKeys } from '../models';
+import { type FulfilledPromise, type PromiseOptions, type PromisesOptions, type PromiseStrategy, type RejectedPromise } from './models';
+export declare function getPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
+export declare function getPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
+export 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
+ */
+export 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
+ */
+export declare function isRejected(value: unknown): value is RejectedPromise;

package/types/promise/index.d.ts

@@ -0,0 +1,53 @@
+import { type PromiseOptions, type Promises, type PromisesOptions, type PromisesResult } from './models';
+/**
+ * Wrap a promise with safety handlers, with optional abort capabilities and timeout
+ * @param promise Promise to wrap
+ * @param options Options for the promise
+ * @returns Wrapped promise
+ */
+export declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+/**
+ * Wrap a promise-returning callback with safety handlers, with optional abort capabilities and timeout
+ * @param callback Callback to wrap
+ * @param options Options for the promise
+ * @returns Promise-wrapped callback
+ */
+export declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+/**
+ * Wrap a callback with a promise and safety handlers, with optional abort capabilities and timeout
+ * @param callback Callback to wrap
+ * @param options Options for the promise
+ * @returns Promise-wrapped callback
+ */
+export declare function attemptPromise<Value>(callback: () => Value, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+/**
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param options Options for handling the promises
+ * @returns List of results
+ */
+export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: Promises<Items>, options?: Options): Promise<Options['strategy'] extends 'first' ? Items : PromisesResult<Items>>;
+/**
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * If any promise in the list is rejected, the whole function will reject
+ * @param items List of promises
+ * @param strategy Strategy for handling the promises; rejects on the first error encountered
+ * @returns List of results
+ */
+export declare function promises<Items extends unknown[]>(items: Promises<Items>, strategy: 'first'): Promise<Items>;
+/**
+ * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+export declare function promises<Items extends unknown[]>(items: Promises<Items>, signal?: AbortSignal): Promise<PromisesResult<Items>>;
+export { toPromise as fromResult } from '../result/misc';
+export { delay } from './delay';
+export { isFulfilled, isRejected } from './helpers';
+export { cancelable, toResult } from './misc';
+export { CancelablePromise, PromiseTimeoutError, type FulfilledPromise, type RejectedPromise, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type PromisesResult, type PromisesResultItem, } from './models';
+export { timed } from './timed';

package/types/promise/misc.d.ts

@@ -0,0 +1,22 @@
+import type { Result } from '../result/models';
+import { CancelablePromise, type PromiseParameters } from './models';
+/**
+ * Create a cancelable promise
+ * @param executor Executor function for the promise
+ * @returns Cancelable promise
+ */
+export declare function cancelable<Value>(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void): CancelablePromise<Value>;
+export declare function handleResult<Items extends unknown[]>(status: string, parameters: PromiseParameters<Items>): void;
+export declare function settlePromise(aborter: () => void, settler: (value: any) => void, value: unknown, signal?: AbortSignal): void;
+/**
+ * Converts a promise to a promised result
+ * @param callback Promise callback
+ * @returns Promised result
+ */
+export declare function toResult<Value>(callback: () => Promise<Value>): Promise<Result<Value>>;
+/**
+ * Converts a promise to a promised result
+ * @param promise Promise to convert
+ * @returns Promised result
+ */
+export declare function toResult<Value>(promise: Promise<Value>): Promise<Result<Value>>;

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';