@everyonesoftware/common 3.0.0 → 5.0.0

package/sources/syncResult.ts

@@ -1,300 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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);
-    }
-}