@everyonesoftware/common 2.0.0 → 4.0.0

package/sources/comparer.ts

@@ -1,133 +0,0 @@
-import { Comparison } from "./comparison";
-
-/**
- * A type that can be used to compare values.
- */
-export abstract class Comparer<TLeft, TRight = TLeft>
-{
-    /**
-     * Compare the two provided values.
-     * @param left The left value to compare.
-     * @param right The right value to compare.
-     */
-    public abstract compare(left: TLeft, right: TRight): Comparison;
-
-    /**
-     * Get whether the left value is less than the right value.
-     * @param left The left value to compare.
-     * @param right The right value to compare.
-     */
-    public lessThan(left: TLeft, right: TRight): boolean
-    {
-        return this.compare(left, right) === Comparison.LessThan;
-    }
-
-    /**
-     * Get whether the left value is less than or equal to the right value.
-     * @param left The left value to compare.
-     * @param right The right value to compare.
-     */
-    public lessThanOrEqual(left: TLeft, right: TRight): boolean
-    {
-        return this.compare(left, right) !== Comparison.GreaterThan;
-    }
-
-    /**
-     * Get whether the left value equals the right value.
-     * @param left The left value to compare.
-     * @param right The right value to compare.
-     */
-    public equal(left: TLeft, right: TRight): boolean
-    {
-        return this.compare(left, right) === Comparison.Equal;
-    }
-
-    /**
-     * Get whether the left value is greater than or equal to the right value.
-     * @param left The left value to compare.
-     * @param right The right value to compare.
-     */
-    public greaterThanOrEqualTo(left: TLeft, right: TRight): boolean
-    {
-        return this.compare(left, right) !== Comparison.LessThan;
-    }
-
-    /**
-     * Get whether the left value is greater than the right value.
-     * @param left The left value to compare.
-     * @param right The right value to compare.
-     */
-    public greaterThan(left: TLeft, right: TRight): boolean
-    {
-        return this.compare(left, right) === Comparison.GreaterThan;
-    }
-
-    /**
-     * Attempt to compare the left and right values. The comparison will be done on whether they are
-     * the same value (left === right) or whether one is undefined or null. If they aren't the same
-     * value and neither is undefined or null, then this function can't compare them and will return
-     * undefined.
-     * @param left The left value of the comparison.
-     * @param right The right value of the comparison.
-     */
-    public static compareSameUndefinedNull(left: unknown, right: unknown): Comparison | undefined
-    {
-        let result: Comparison | undefined = undefined;
-        if (left === right)
-        {
-            result = Comparison.Equal;
-        }
-        else if (left === undefined)
-        {
-            result = Comparison.LessThan;
-        }
-        else if (right === undefined)
-        {
-            result = Comparison.GreaterThan;
-        }
-        else if (left === null)
-        {
-            result = Comparison.LessThan;
-        }
-        else if (right === null)
-        {
-            result = Comparison.GreaterThan;
-        }
-        return result;
-    }
-
-    /**
-     * Get whether the left and right values are equal. The comparison will be done on whether they
-     * are the same value (left === right) or whether one is undefined or null. If they aren't the
-     * same value and neither is undefined or null, then this function can't determine whether they
-     * are equal and will return undefined.
-     * @param left The left value of the comparison.
-     * @param right The right value of the comparison.
-     */
-    public static equalSameUndefinedNull(left: unknown, right: unknown): boolean | undefined
-    {
-        let result: Comparison | undefined = Comparer.compareSameUndefinedNull(left, right);
-        return result === undefined ? undefined : result === Comparison.Equal;
-    }
-
-    public static compareNumbers(left: number | undefined | null, right: number | undefined | null): Comparison
-    {
-        let result: Comparison | undefined = Comparer.compareSameUndefinedNull(left, right);
-        if (result === undefined)
-        {
-            if (left! < right!)
-            {
-                result = Comparison.LessThan;
-            }
-            // else if (left === right)
-            // {
-            //     result = Comparison.Equal;
-            // }
-            else
-            {
-                result = Comparison.GreaterThan;
-            }
-        }
-        return result;
-    }
-}

package/sources/comparison.ts

@@ -1,20 +0,0 @@
-/**
- * The result of comparing two values.
- */
-export enum Comparison
-{
-    /**
-     * The left value is less than the right value.
-     */
-    LessThan,
-
-    /**
-     * The two values are equal.
-     */
-    Equal,
-
-    /**
-     * The left value is greater than the right value.
-     */
-    GreaterThan,
-}

package/sources/concatenateIterable.ts

@@ -1,119 +0,0 @@
-import { ConcatenateIterator } from "./concatenateIterator";
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { List } from "./list";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { Type } from "./types";
-
-export class ConcatenateIterable<T> implements Iterable<T>
-{
-    private readonly innerIterables: Iterable<Iterable<T>>;
-
-    private constructor(innerIterables: Iterable<Iterable<T>>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterables, "innerIterables");
-
-        this.innerIterables = innerIterables;
-    }
-
-    public static create<T>(innerIterable: Iterable<T>, ...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterable<T>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterable, "innerIterable");
-        PreCondition.assertNotUndefinedAndNotNull(toConcatenate, "toConcatenate");
-
-        const innerIterables: List<Iterable<T>> = List.create();
-        innerIterables.add(innerIterable);
-        for (const value of toConcatenate)
-        {
-            innerIterables.add(Iterable.create(value));
-        }
-        return new ConcatenateIterable<T>(innerIterables);
-    }
-
-    public iterate(): Iterator<T>
-    {
-        return ConcatenateIterator.create<T>(...this.innerIterables);
-    }
-
-    public toArray(): SyncResult<T[]>
-    {
-        return Iterable.toArray(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Iterable.any(this);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return SyncResult.create(() =>
-        {
-            let result: number = 0;
-            for (const innerIterable of this.innerIterables)
-            {
-                result += innerIterable.getCount().await();
-            }
-            return result;
-        });
-    }
-
-    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return Iterable.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
-    {
-        return Iterable.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
-    {
-        return Iterable.where(this, condition);
-    }
-
-    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
-    {
-        return Iterable.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Iterable.first(this, condition);
-    }
-
-    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Iterable.last(this, condition);
-    }
-
-    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.contains(this, value, equalFunctions);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return Iterable[Symbol.iterator](this);
-    }
-}

package/sources/concatenateIterator.ts

@@ -1,165 +0,0 @@
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { List } from "./list";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-import { Type } from "./types";
-
-export class ConcatenateIterator<T> implements Iterator<T>
-{
-    private readonly innerIterators: Iterator<Iterator<T>>;
-
-    private constructor(innerIterators: Iterator<Iterator<T>>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterators, "innerIterators");
-
-        this.innerIterators = innerIterators;
-    }
-
-    public static create<T>(...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterator<T>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(toConcatenate, "toConcatenate");
-
-        const innerIterators: List<Iterator<T>> = List.create();
-        for (const value of toConcatenate)
-        {
-            innerIterators.add(Iterator.create(value));
-        }
-        return new ConcatenateIterator<T>(innerIterators.iterate());
-    }
-
-    public next(): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            let innerIteratorAtBeginning: boolean = false;
-            if (!this.innerIterators.hasStarted())
-            {
-                this.innerIterators.next().await();
-                innerIteratorAtBeginning = true;
-            }
-
-            while (this.innerIterators.hasCurrent())
-            {
-                const innerIterator: Iterator<T> = this.innerIterators.getCurrent();
-                if (innerIteratorAtBeginning)
-                {
-                    innerIterator.start().await();
-                }
-                else
-                {
-                    innerIterator.next().await();
-                }
-
-                if (innerIterator.hasCurrent())
-                {
-                    break;
-                }
-                else
-                {
-                    this.innerIterators.next().await();
-                    innerIteratorAtBeginning = true;
-                }
-            }
-
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.innerIterators.hasStarted();
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.innerIterators.hasCurrent();
-    }
-
-    public getCurrent(): T
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.innerIterators.getCurrent().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 | SyncResult<boolean>)): Iterator<T>
-    {
-        return Iterator.where(this, condition);
-    }
-
-    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 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 first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Iterator.first(this, condition);
-    }
-
-    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Iterator.last(this, condition);
-    }
-
-    public take(maximumToTake: number): Iterator<T>
-    {
-        return Iterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): Iterator<T>
-    {
-        return Iterator.skip(this, maximumToSkip);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return Iterator[Symbol.iterator](this);
-    }
-}