@everyonesoftware/common 1.0.0

package/sources/syncResult.ts

@@ -0,0 +1,300 @@
+import { PreCondition } from "./preCondition";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { instanceOfType, isPromise, isPromiseLike, isUndefinedOrNull, Type } from "./types";
+import { AsyncResult } from "./asyncResult";
+
+export class SyncResult<T> implements AsyncResult<T>
+{
+    private value: T | undefined;
+    private error: unknown | undefined;
+
+    private constructor(value: T | undefined, error: unknown | undefined)
+    {
+        PreCondition.assertTrue(value === undefined || error === undefined, "value === undefined || error === undefined", "Either value or error must be undefined.");
+
+        this.value = value;
+        this.error = error;
+    }
+
+    public static create<T>(action: () => T): SyncResult<T>
+    {
+        PreCondition.assertNotUndefinedAndNotNull(action, "action");
+
+        let value: T | undefined;
+        let error: unknown | undefined;
+        try
+        {
+            value = action();
+        }
+        catch (e)
+        {
+            error = e;
+        }
+        return new SyncResult(value, error);
+    }
+
+    public static value<T>(value: T): SyncResult<T>
+    {
+        return new SyncResult(value, undefined);
+    }
+
+    public static error<T>(error: unknown): SyncResult<T>
+    {
+        return new SyncResult<T>(undefined, error);
+    }
+
+    public await(): T
+    {
+        if (this.error)
+        {
+            throw this.error;
+        }
+        return this.value!;
+    }
+
+    public then<TResult1 = T, TResult2 = never>(onfullfilled?: ((value: T) => TResult1) | null, onrejected?: ((reason: unknown) => TResult2) | null): SyncResult<TResult1 | TResult2>;
+    public then<TResult1 = T, TResult2 = never>(onfullfilled?: ((value: T) => (TResult1 | PromiseLike<TResult1>)) | null, onrejected?: ((reason: unknown) => (TResult2 | PromiseLike<TResult2>)) | null): SyncResult<TResult1 | TResult2>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => (TResult1 | PromiseLike<TResult1>)) | null, onrejected?: ((reason: unknown) => (TResult2 | PromiseLike<TResult2>)) | null): SyncResult<TResult1 | TResult2> | PromiseAsyncResult<TResult1 | TResult2>
+    {
+        let result: SyncResult<TResult1 | TResult2> | PromiseAsyncResult<TResult1 | TResult2>;
+        if (this.error)
+        {
+            if (onrejected)
+            {
+                try
+                {
+                    const onRejectedResult: TResult2 | PromiseLike<TResult2> = onrejected(this.error);
+                    if (onRejectedResult instanceof SyncResult || onRejectedResult instanceof PromiseAsyncResult)
+                    {
+                        result = onRejectedResult;
+                    }
+                    else if (isPromise<TResult2>(onRejectedResult))
+                    {
+                        result = PromiseAsyncResult.create(onRejectedResult);
+                    }
+                    else
+                    {
+                        result = SyncResult.value(onRejectedResult as TResult2);
+                    }
+                }
+                catch (error)
+                {
+                    result = SyncResult.error(error);
+                }
+            }
+            else
+            {
+                result = SyncResult.error<TResult2>(this.error);
+            }
+        }
+        else
+        {
+            if (onfulfilled)
+            {
+                try
+                {
+                    const onFullfilledResult: TResult1 | PromiseLike<TResult1> = onfulfilled(this.value!);
+                    if (onFullfilledResult instanceof SyncResult || onFullfilledResult instanceof PromiseAsyncResult)
+                    {
+                        result = onFullfilledResult;
+                    }
+                    else if (isPromise<TResult1>(onFullfilledResult))
+                    {
+                        result = PromiseAsyncResult.create(onFullfilledResult);
+                    }
+                    else
+                    {
+                        result = SyncResult.value(onFullfilledResult as TResult1);
+                    }
+                }
+                catch (error)
+                {
+                    result = SyncResult.error(error);
+                }
+            }
+            else
+            {
+                result = SyncResult.value<TResult1>(this.value as TResult1);
+            }
+        }
+        return result;
+    }
+
+    public onValue(onValueFunction: (value: T) => void): SyncResult<T>;
+    public onValue(onValueFunction: (value: T) => Promise<void>): PromiseAsyncResult<T>;
+    onValue(onValueFunction: (value: T) => (void | Promise<void>)): SyncResult<T> | PromiseAsyncResult<T>
+    {
+        return this.then<T>((value: T) =>
+        {
+            let result: SyncResult<T> | PromiseAsyncResult<T>;
+            try
+            {
+                const onValueFunctionResult: (void | Promise<void>) = onValueFunction(value);
+                if (isPromise(onValueFunctionResult))
+                {
+                    result = PromiseAsyncResult.create(onValueFunctionResult.then(() => value));
+                }
+                else
+                {
+                    result = this;
+                }
+            }
+            catch (error)
+            {
+                result = SyncResult.error(error);
+            }
+            return result;
+        })
+    }
+
+    public catch<TResult = never>(onrejected: (reason: unknown) => TResult): SyncResult<T | TResult>;
+    public catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): SyncResult<T | TResult> | PromiseAsyncResult<T | TResult>
+    public catch<TError, TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => TResult): SyncResult<T | TResult>;
+    public catch<TError, TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => PromiseLike<TResult>): PromiseAsyncResult<T | TResult>;
+    catch<TResult = never>(errorTypeOrOnRejected?: Type<unknown> | ((reason: unknown) => TResult | PromiseLike<TResult>) | null, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): SyncResult<T | TResult> | PromiseAsyncResult<T | TResult>
+    {
+        let errorType: Type<TypeError> | undefined;
+        if (!isUndefinedOrNull(onrejected))
+        {
+            errorType = errorTypeOrOnRejected as Type<unknown>;
+
+            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+        }
+        else
+        {
+            onrejected = errorTypeOrOnRejected as ((reason: any) => TResult | PromiseLike<TResult>) | null;
+        }
+        PreCondition.assertNotUndefinedAndNotNull(onrejected, "onrejected");
+
+        let result: SyncResult<T | TResult> | PromiseAsyncResult<T | TResult> = this;
+        if (this.error && (!errorType || instanceOfType(this.error, errorType)))
+        {
+            try
+            {
+                const onRejectedResult: TResult | PromiseLike<TResult> = onrejected(this.error);
+                if (onRejectedResult instanceof SyncResult || onRejectedResult instanceof PromiseAsyncResult)
+                {
+                    result = onRejectedResult;
+                }
+                else if (isPromise<TResult>(onRejectedResult))
+                {
+                    result = PromiseAsyncResult.create(onRejectedResult);
+                }
+                else
+                {
+                    result = SyncResult.value(onRejectedResult as TResult);
+                }
+            }
+            catch (error)
+            {
+                result = SyncResult.error(error);
+            }
+        }
+        return result;
+    }
+
+    public onError(onErrorFunction: (reason: unknown) => void): SyncResult<T>;
+    public onError(onErrorFunction: (reason: unknown) => PromiseLike<void>): PromiseAsyncResult<T>;
+    public onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => void): SyncResult<T>;
+    public onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => PromiseLike<void>): PromiseAsyncResult<T>;
+    onError(errorTypeOrOnErrorFunction: Type<unknown> | ((reason: unknown) => (void | PromiseLike<void>)), onErrorFunction?: (reason: unknown) => (void | PromiseLike<void>)): SyncResult<T> | PromiseAsyncResult<T>
+    {
+        let errorType: Type<TypeError> | undefined;
+        if (!isUndefinedOrNull(onErrorFunction))
+        {
+            errorType = errorTypeOrOnErrorFunction as Type<unknown>;
+
+            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+        }
+        else
+        {
+            onErrorFunction = errorTypeOrOnErrorFunction as ((reason: any) => void | PromiseLike<void>);
+        }
+        PreCondition.assertNotUndefinedAndNotNull(onErrorFunction, "onErrorFunction");
+
+        let result: SyncResult<T> | PromiseAsyncResult<T> = this;
+        if (this.error && (!errorType || instanceOfType(this.error, errorType)))
+        {
+            try
+            {
+                const onErrorResult: void | PromiseLike<void> = onErrorFunction(this.error);
+                if (isPromise(onErrorResult))
+                {
+                    result = PromiseAsyncResult.create(onErrorResult).then(() => this);
+                }
+            }
+            catch (error)
+            {
+                result = SyncResult.error(error);
+            }
+        }
+        return result;
+    }
+
+    public convertError(convertErrorFunction: (reason: unknown) => unknown): SyncResult<T>;
+    public convertError(onErrorFunction: (reason: unknown) => PromiseLike<unknown>): PromiseAsyncResult<T>;
+    public convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => unknown): SyncResult<T>;
+    public convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => PromiseLike<unknown>): PromiseAsyncResult<T>;
+    convertError(errorTypeOrConvertErrorFunction: Type<unknown> | ((reason: unknown) => (unknown | PromiseLike<unknown>)), convertErrorFunction?: (reason: unknown) => (unknown | PromiseLike<unknown>)): SyncResult<T> | PromiseAsyncResult<T>
+    {
+        let errorType: Type<TypeError> | undefined;
+        if (!isUndefinedOrNull(convertErrorFunction))
+        {
+            errorType = errorTypeOrConvertErrorFunction as Type<unknown>;
+
+            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
+        }
+        else
+        {
+            convertErrorFunction = errorTypeOrConvertErrorFunction as ((reason: any) => void | PromiseLike<void>);
+        }
+        PreCondition.assertNotUndefinedAndNotNull(convertErrorFunction, "convertErrorFunction");
+
+        let result: SyncResult<T> | PromiseAsyncResult<T> = this;
+        if (this.error && (!errorType || instanceOfType(this.error, errorType)))
+        {
+            try
+            {
+                const convertErrorResult: unknown | PromiseLike<unknown> = convertErrorFunction(this.error);
+                if (isPromise(convertErrorResult))
+                {
+                    result = PromiseAsyncResult.error(convertErrorResult);
+                }
+                else
+                {
+                    result = SyncResult.error(convertErrorResult);
+                }
+            }
+            catch (error)
+            {
+                result = SyncResult.error(error);
+            }
+        }
+        return result;
+    }
+
+    public finally(onfinally?: (() => void) | null): SyncResult<T>
+    public finally(onfinally?: (() => Promise<void>) | null): PromiseAsyncResult<T>
+    finally(onfinally?: (() => (void | Promise<void>)) | null | undefined): PromiseAsyncResult<T> | SyncResult<T>
+    {
+        let result: PromiseAsyncResult<T> | SyncResult<T> = this;
+        if (onfinally)
+        {
+            try
+            {
+                const onfinallyResult: void | Promise<void> = onfinally();
+                if (isPromiseLike(onfinallyResult))
+                {
+                    result = PromiseAsyncResult.create(onfinallyResult).then(() => this);
+                }
+            }
+            catch (error)
+            {
+                result = SyncResult.error(error);
+            }
+        }
+        return result;
+    }
+
+    readonly [Symbol.toStringTag]: string = "SyncResult2";
+}

package/sources/takeAsyncIterator.ts

@@ -0,0 +1,141 @@
+import { AsyncIterator } from "./asyncIterator";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { JavascriptAsyncIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { Type } from "./types";
+
+/**
+ * An {@link AsyncIterator} that iterates over a maximum number of values.
+ */
+export class TakeAsyncIterator<T> implements AsyncIterator<T>
+{
+    private readonly innerIterator: AsyncIterator<T>;
+    private started: boolean;
+    private readonly maximumToTake: number;
+    private taken: number;
+
+    private constructor(innerIterator: AsyncIterator<T>, maximumToTake: number)
+    {
+        PreCondition.assertGreaterThanOrEqualTo(maximumToTake, 0, "maximumToTake");
+
+        this.innerIterator = innerIterator;
+        this.started = false;
+        this.maximumToTake = maximumToTake;
+        this.taken = 0;
+    }
+
+    public static create<T>(innerIterator: AsyncIterator<T>, maximumToTake: number)
+    {
+        return new TakeAsyncIterator(innerIterator, maximumToTake);
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.taken <= this.maximumToTake && this.innerIterator.hasCurrent();
+    }
+
+    public next(): PromiseAsyncResult<boolean>
+    {
+        return PromiseAsyncResult.create(async () =>
+        {
+            if (this.maximumToTake <= 0)
+            {
+                return false;
+            }
+            else if (!this.hasStarted())
+            {
+                this.started = true;
+                await this.innerIterator.start();
+                this.taken++;
+            }
+            else if (this.taken <= this.maximumToTake)
+            {
+                await this.innerIterator.next();
+                this.taken++;
+            }
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.innerIterator.getCurrent();
+    }
+
+    public start(): PromiseAsyncResult<this>
+    {
+        return AsyncIterator.start<T, this>(this);
+    }
+
+    public takeCurrent(): PromiseAsyncResult<T>
+    {
+        return AsyncIterator.takeCurrent(this);
+    }
+
+    public any(): PromiseAsyncResult<boolean>
+    {
+        return AsyncIterator.any(this);
+    }
+
+    public getCount(): PromiseAsyncResult<number>
+    {
+        return AsyncIterator.getCount(this);
+    }
+
+    public toArray(): PromiseAsyncResult<T[]>
+    {
+        return AsyncIterator.toArray(this);
+    }
+
+    public where(condition: (value: T) => boolean): AsyncIterator<T>
+    {
+        return AsyncIterator.where(this, condition);
+    }
+
+    public whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator<U>
+    {
+        return AsyncIterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator<U>
+    {
+        return AsyncIterator.whereInstanceOfType(this, type);
+    }
+
+    public map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.map(this, mapping);
+    }
+
+    public first(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>
+    {
+        return AsyncIterator.first(this, condition);
+    }
+
+    public last(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>
+    {
+        return AsyncIterator.last(this, condition);
+    }
+
+    public [Symbol.asyncIterator](): JavascriptAsyncIterator<T>
+    {
+        return AsyncIterator[Symbol.asyncIterator](this);
+    }
+
+    public take(maximumToTake: number): AsyncIterator<T>
+    {
+        return AsyncIterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): AsyncIterator<T>
+    {
+        return AsyncIterator.skip(this, maximumToSkip);
+    }
+}

package/sources/takeIterator.ts

@@ -0,0 +1,151 @@
+import { Iterator } from "./iterator";
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { SyncResult } from "./syncResult";
+import { Type } from "./types";
+
+/**
+ * An {@link Iterator} that iterates over a maximum number of values.
+ */
+export class TakeIterator<T> implements Iterator<T>
+{
+    private readonly innerIterator: Iterator<T>;
+    private started: boolean;
+    private readonly maximumToTake: number;
+    private taken: number;
+
+    private constructor(innerIterator: Iterator<T>, maximumToTake: number)
+    {
+        PreCondition.assertGreaterThanOrEqualTo(maximumToTake, 0, "maximumToTake");
+
+        this.innerIterator = innerIterator;
+        this.started = false;
+        this.maximumToTake = maximumToTake;
+        this.taken = 0;
+    }
+
+    public static create<T>(innerIterator: Iterator<T>, maximumToTake: number)
+    {
+        return new TakeIterator(innerIterator, maximumToTake);
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.taken <= this.maximumToTake && this.innerIterator.hasCurrent();
+    }
+
+    public next(): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            if (this.maximumToTake <= 0)
+            {
+                return false;
+            }
+            else if (!this.hasStarted())
+            {
+                this.started = true;
+                this.innerIterator.start().await();
+                this.taken++;
+            }
+            else if (this.taken <= this.maximumToTake)
+            {
+                this.innerIterator.next().await();
+                this.taken++;
+            }
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.innerIterator.getCurrent();
+    }
+
+    public start(): SyncResult<this>
+    {
+        return Iterator.start<T, this>(this);
+    }
+
+    public takeCurrent(): SyncResult<T>
+    {
+        return Iterator.takeCurrent(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterator.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterator.getCount(this);
+    }
+
+    public toArray(): SyncResult<T[]>
+    {
+        return Iterator.toArray(this);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>
+    {
+        return Iterator.concatenate(this, ...toConcatenate);
+    }
+
+    public where(condition: (value: T) => boolean): Iterator<T>
+    {
+        return Iterator.where(this, condition);
+    }
+
+    public whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>
+    {
+        return Iterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>
+    {
+        return Iterator.whereInstanceOfType(this, type);
+    }
+
+    public map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>
+    {
+        return Iterator.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.flatMap(this, mapping);
+    }
+
+    public first(condition?: (value: T) => boolean): SyncResult<T>
+    {
+        return Iterator.first(this, condition);
+    }
+
+    public last(condition?: (value: T) => boolean): SyncResult<T>
+    {
+        return Iterator.last(this, condition);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<T>
+    {
+        return Iterator[Symbol.iterator](this);
+    }
+
+    public take(maximumToTake: number): Iterator<T>
+    {
+        return Iterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): Iterator<T>
+    {
+        return Iterator.skip(this, maximumToSkip);
+    }
+}