@everyonesoftware/common 1.0.0 → 3.0.0

package/sources/promiseAsyncResult.ts

@@ -1,174 +1,174 @@
-import { PreCondition } from "./preCondition";
-import { AsyncResult } from "./asyncResult";
-import { instanceOfType, isPromise, isUndefinedOrNull, Type } from "./types";
-
-export class PromiseAsyncResult<T> implements AsyncResult<T>
-{
-    private readonly promise: Promise<T>;
-
-    private constructor(promise: Promise<T>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(promise, "promise");
-
-        this.promise = promise;
-    }
-
-    public static create<T>(action: () => (T | Promise<T>)): PromiseAsyncResult<T>;
-    public static create<T>(promise: Promise<T>): PromiseAsyncResult<T>;
-    static create<T>(actionOrPromise: (() => (T | Promise<T>)) | Promise<T>): PromiseAsyncResult<T>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(actionOrPromise, "action or promise");
-
-        return new PromiseAsyncResult(Promise.resolve(isPromise<T>(actionOrPromise) ? actionOrPromise : actionOrPromise()));
-    }
-
-    public static value<T>(value: T): PromiseAsyncResult<T>
-    {
-        return PromiseAsyncResult.create(Promise.resolve(value));
-    }
-
-    public static error<T>(error: unknown): PromiseAsyncResult<T>
-    {
-        return PromiseAsyncResult.create(Promise.reject(error));
-    }
-
-    public static yield(): PromiseAsyncResult<void>
-    {
-        return PromiseAsyncResult.create(Promise.resolve());
-    }
-
-    public then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseAsyncResult<TResult1 | TResult2>
-    {
-        return PromiseAsyncResult.create(this.promise.then(onfulfilled, onrejected));
-    }
-
-    public onValue(onValueFunction: (value: T) => (void | Promise<void>)): PromiseAsyncResult<T>
-    {
-        return this.then<T>(async (value: T) =>
-        {
-            let result: PromiseAsyncResult<T>;
-            try
-            {
-                await onValueFunction(value);
-                result = this;
-            }
-            catch (error)
-            {
-                result = PromiseAsyncResult.error(error);
-            }
-            return result;
-        })
-    }
-
-    public catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>
-    public catch<TError,TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => (TResult | PromiseLike<TResult>)): PromiseAsyncResult<T | TResult>
-    catch<TResult = never>(errorTypeOrOnRejected?: Type<Error> | ((reason: unknown) => TResult | PromiseLike<TResult>) | null, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>
-    {
-        let errorType: Type<Error> | undefined;
-        if (!isUndefinedOrNull(onrejected))
-        {
-            errorType = errorTypeOrOnRejected as Type<unknown>;
-
-            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-        }
-        else
-        {
-            onrejected = errorTypeOrOnRejected as ((reason: any) => TResult | PromiseLike<TResult>) | null;
-        }
-
-        return PromiseAsyncResult.create<T | TResult>(this.promise.catch((reason: unknown) =>
-        {
-            let value: TResult | PromiseLike<TResult> | undefined;
-            if (errorType && !instanceOfType(reason, errorType))
-            {
-                throw reason;
-            }
-            else if (!isUndefinedOrNull(onrejected))
-            {
-                value = onrejected(reason);
-            }
-            return value!;
-        }));
-    }
-
-    public onError(onErrorFunction: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
-    public onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
-    onError(errorTypeOrOnErrorFunction: Type<unknown> | ((reason: unknown) => (void | PromiseLike<void>)), onErrorFunction?: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>
-    {
-        let errorType: Type<unknown> | undefined;
-        if (!isUndefinedOrNull(onErrorFunction))
-        {
-            errorType = errorTypeOrOnErrorFunction as Type<unknown>;
-
-            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-        }
-        else
-        {
-            onErrorFunction = errorTypeOrOnErrorFunction as ((reason: unknown) => void | PromiseLike<void>);
-        }
-        PreCondition.assertNotUndefinedAndNotNull(onErrorFunction, "onErrorFunction");
-
-        let result: PromiseAsyncResult<T>;
-        if (errorType)
-        {
-            result = this.catch(errorType, async (reason: unknown) =>
-            {
-                await onErrorFunction(reason);
-                throw reason;
-            });
-        }
-        else
-        {
-            result = this.catch(async (reason: unknown) =>
-            {
-                await onErrorFunction(reason);
-                throw reason;
-            });
-        }
-
-        return result;
-    }
-
-    public convertError(convertErrorFunction: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
-    public convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
-    convertError(errorTypeOrConvertErrorFunction: Type<unknown> | ((reason: unknown) => (unknown | PromiseLike<unknown>)), convertErrorFunction?: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>
-    {
-        let errorType: Type<unknown> | undefined;
-        if (!isUndefinedOrNull(convertErrorFunction))
-        {
-            errorType = errorTypeOrConvertErrorFunction as Type<unknown>;
-
-            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-        }
-        else
-        {
-            convertErrorFunction = errorTypeOrConvertErrorFunction as ((reason: unknown) => void | PromiseLike<void>);
-        }
-        PreCondition.assertNotUndefinedAndNotNull(convertErrorFunction, "convertErrorFunction");
-
-        let result: PromiseAsyncResult<T>;
-        if (errorType)
-        {
-            result = this.catch(errorType, async (reason: unknown) =>
-            {
-                throw await convertErrorFunction(reason);
-            });
-        }
-        else
-        {
-            result = this.catch(async (reason: unknown) =>
-            {
-                throw await convertErrorFunction(reason);
-            });
-        }
-
-        return result;
-    }
-
-    public finally(onfinally?: (() => (void | Promise<void>)) | null): PromiseAsyncResult<T>
-    {
-        return PromiseAsyncResult.create(this.promise.finally(onfinally));
-    }
-    
-    readonly [Symbol.toStringTag]: string = "AsyncResult";
+import { PreCondition } from "./preCondition";
+import { AsyncResult } from "./asyncResult";
+import { instanceOfType, isPromise, isUndefinedOrNull, Type } from "./types";
+
+export class PromiseAsyncResult<T> implements AsyncResult<T>
+{
+    private readonly promise: Promise<T>;
+
+    private constructor(promise: Promise<T>)
+    {
+        PreCondition.assertNotUndefinedAndNotNull(promise, "promise");
+
+        this.promise = promise;
+    }
+
+    public static create<T>(action: () => (T | Promise<T>)): PromiseAsyncResult<T>;
+    public static create<T>(promise: Promise<T>): PromiseAsyncResult<T>;
+    static create<T>(actionOrPromise: (() => (T | Promise<T>)) | Promise<T>): PromiseAsyncResult<T>
+    {
+        PreCondition.assertNotUndefinedAndNotNull(actionOrPromise, "action or promise");
+
+        return new PromiseAsyncResult(Promise.resolve(isPromise<T>(actionOrPromise) ? actionOrPromise : actionOrPromise()));
+    }
+
+    public static value<T>(value: T): PromiseAsyncResult<T>
+    {
+        return PromiseAsyncResult.create(Promise.resolve(value));
+    }
+
+    public static error<T>(error: unknown): PromiseAsyncResult<T>
+    {
+        return PromiseAsyncResult.create(Promise.reject(error));
+    }
+
+    public static yield(): PromiseAsyncResult<void>
+    {
+        return PromiseAsyncResult.create(Promise.resolve());
+    }
+
+    public then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseAsyncResult<TResult1 | TResult2>
+    {
+        return PromiseAsyncResult.create(this.promise.then(onfulfilled, onrejected));
+    }
+
+    public onValue(onValueFunction: (value: T) => (void | Promise<void>)): PromiseAsyncResult<T>
+    {
+        return this.then<T>(async (value: T) =>
+        {
+            let result: PromiseAsyncResult<T>;
+            try
+            {
+                await onValueFunction(value);
+                result = this;
+            }
+            catch (error)
+            {
+                result = PromiseAsyncResult.error(error);
+            }
+            return result;
+        })
+    }
+
+    public catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>
+    public catch<TError,TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => (TResult | PromiseLike<TResult>)): PromiseAsyncResult<T | TResult>
+    catch<TResult = never>(errorTypeOrOnRejected?: Type<Error> | ((reason: unknown) => TResult | PromiseLike<TResult>) | null, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>
+    {
+        let errorType: Type<Error> | undefined;
+        if (!isUndefinedOrNull(onrejected))
+        {
+            errorType = errorTypeOrOnRejected as Type<unknown>;
+
+            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+        }
+        else
+        {
+            onrejected = errorTypeOrOnRejected as ((reason: any) => TResult | PromiseLike<TResult>) | null;
+        }
+
+        return PromiseAsyncResult.create<T | TResult>(this.promise.catch((reason: unknown) =>
+        {
+            let value: TResult | PromiseLike<TResult> | undefined;
+            if (errorType && !instanceOfType(reason, errorType))
+            {
+                throw reason;
+            }
+            else if (!isUndefinedOrNull(onrejected))
+            {
+                value = onrejected(reason);
+            }
+            return value!;
+        }));
+    }
+
+    public onError(onErrorFunction: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
+    public onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
+    onError(errorTypeOrOnErrorFunction: Type<unknown> | ((reason: unknown) => (void | PromiseLike<void>)), onErrorFunction?: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>
+    {
+        let errorType: Type<unknown> | undefined;
+        if (!isUndefinedOrNull(onErrorFunction))
+        {
+            errorType = errorTypeOrOnErrorFunction as Type<unknown>;
+
+            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+        }
+        else
+        {
+            onErrorFunction = errorTypeOrOnErrorFunction as ((reason: unknown) => void | PromiseLike<void>);
+        }
+        PreCondition.assertNotUndefinedAndNotNull(onErrorFunction, "onErrorFunction");
+
+        let result: PromiseAsyncResult<T>;
+        if (errorType)
+        {
+            result = this.catch(errorType, async (reason: unknown) =>
+            {
+                await onErrorFunction(reason);
+                throw reason;
+            });
+        }
+        else
+        {
+            result = this.catch(async (reason: unknown) =>
+            {
+                await onErrorFunction(reason);
+                throw reason;
+            });
+        }
+
+        return result;
+    }
+
+    public convertError(convertErrorFunction: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
+    public convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
+    convertError(errorTypeOrConvertErrorFunction: Type<unknown> | ((reason: unknown) => (unknown | PromiseLike<unknown>)), convertErrorFunction?: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>
+    {
+        let errorType: Type<unknown> | undefined;
+        if (!isUndefinedOrNull(convertErrorFunction))
+        {
+            errorType = errorTypeOrConvertErrorFunction as Type<unknown>;
+
+            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+        }
+        else
+        {
+            convertErrorFunction = errorTypeOrConvertErrorFunction as ((reason: unknown) => void | PromiseLike<void>);
+        }
+        PreCondition.assertNotUndefinedAndNotNull(convertErrorFunction, "convertErrorFunction");
+
+        let result: PromiseAsyncResult<T>;
+        if (errorType)
+        {
+            result = this.catch(errorType, async (reason: unknown) =>
+            {
+                throw await convertErrorFunction(reason);
+            });
+        }
+        else
+        {
+            result = this.catch(async (reason: unknown) =>
+            {
+                throw await convertErrorFunction(reason);
+            });
+        }
+
+        return result;
+    }
+
+    public finally(onfinally?: (() => (void | Promise<void>)) | null): PromiseAsyncResult<T>
+    {
+        return PromiseAsyncResult.create(this.promise.finally(onfinally));
+    }
+    
+    readonly [Symbol.toStringTag]: string = "AsyncResult";
 }

package/sources/queue.ts

@@ -1,49 +1,49 @@
-import { EqualFunctions } from "./equalFunctions";
-import { JavascriptIterable } from "./javascript";
-import { ListQueue } from "./listQueue";
-import { ListStack } from "./listStack";
-import { AsyncResult } from "./asyncResult";
-
-/**
- * A data structure that stores values in a first-in-first-out order.
- */
-export abstract class Queue<T>
-{
-    /**
-     * Create an instance of the default {@link Queue} implementation.
-     * @returns A new {@link Queue} object.
-     */
-    public static create<T>(): ListQueue<T>
-    {
-        return ListQueue.create();
-    }
-
-    /**
-     * Get whether there are any values in this {@link Stack}.
-     */
-    public abstract any(): AsyncResult<boolean>;
-
-    /**
-     * Add the provided value onto the end of this {@link Queue}.
-     * @param value The value to add to the end of this {@link Queue}.
-     */
-    public abstract add(value: T): AsyncResult<void>;
-
-    /**
-     * Add the provided values to the end of this {@link Queue}.
-     * @param values The values to add to the end of this {@link Queue}.
-     */
-    public abstract addAll(values: JavascriptIterable<T>): AsyncResult<void>;
-
-    /**
-     * Remove the next value off of this {@link Queue}.
-     */
-    public abstract remove(): AsyncResult<T>;
-
-    /**
-     * Get whether this {@link Stack} contains the provided value.
-     * @param value The value to look for.
-     * @param equalFunctions The functions to use to compare values.
-     */
-    public abstract contains(value: T, equalFunctions?: EqualFunctions): AsyncResult<boolean>;
+import { EqualFunctions } from "./equalFunctions";
+import { JavascriptIterable } from "./javascript";
+import { ListQueue } from "./listQueue";
+import { ListStack } from "./listStack";
+import { AsyncResult } from "./asyncResult";
+
+/**
+ * A data structure that stores values in a first-in-first-out order.
+ */
+export abstract class Queue<T>
+{
+    /**
+     * Create an instance of the default {@link Queue} implementation.
+     * @returns A new {@link Queue} object.
+     */
+    public static create<T>(): ListQueue<T>
+    {
+        return ListQueue.create();
+    }
+
+    /**
+     * Get whether there are any values in this {@link Stack}.
+     */
+    public abstract any(): AsyncResult<boolean>;
+
+    /**
+     * Add the provided value onto the end of this {@link Queue}.
+     * @param value The value to add to the end of this {@link Queue}.
+     */
+    public abstract add(value: T): AsyncResult<void>;
+
+    /**
+     * Add the provided values to the end of this {@link Queue}.
+     * @param values The values to add to the end of this {@link Queue}.
+     */
+    public abstract addAll(values: JavascriptIterable<T>): AsyncResult<void>;
+
+    /**
+     * Remove the next value off of this {@link Queue}.
+     */
+    public abstract remove(): AsyncResult<T>;
+
+    /**
+     * Get whether this {@link Stack} contains the provided value.
+     * @param value The value to look for.
+     * @param equalFunctions The functions to use to compare values.
+     */
+    public abstract contains(value: T, equalFunctions?: EqualFunctions): AsyncResult<boolean>;
 }