@everyonesoftware/common 1.0.0

package/sources/comparable.ts

@@ -0,0 +1,144 @@
+import { Comparison } from "./comparison";
+import { PreCondition } from "./preCondition";
+
+/**
+ * An type that can be compared against another type.
+ */
+export abstract class Comparable<T>
+{
+    protected constructor()
+    {
+    }
+
+    /**
+     * Compare this value against the provided value.
+     * @param value The value to compare against.
+     */
+    public abstract compareTo(value: T): Comparison;
+
+    /**
+     * Get whether this value is less than the provided value.
+     * @param value The value to compare against.
+     */
+    public lessThan(value: T): boolean
+    {
+        return Comparable.lessThan(this, value);
+    }
+
+    /**
+     * Get whether the left value is less than the right value.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public static lessThan<T>(left: Comparable<T>, right: T): boolean
+    {
+        PreCondition.assertNotUndefinedAndNotNull(left, "left");
+
+        return left.compareTo(right) === Comparison.LessThan;
+    }
+
+    /**
+     * Get whether this value is less than or equal to the provided value.
+     * @param value The value to compare against.
+     */
+    public lessThanOrEqualTo(value: T): boolean
+    {
+        return Comparable.lessThanOrEqualTo(this, value);
+    }
+
+    /**
+     * Get whether the left value is less than or equal to the right value.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public static lessThanOrEqualTo<T>(left: Comparable<T>, right: T): boolean
+    {
+        PreCondition.assertNotUndefinedAndNotNull(left, "left");
+
+        return left.compareTo(right) !== Comparison.GreaterThan;
+    }
+
+    /**
+     * Get whether this value equals the provided value.
+     * @param value The value to compare against.
+     */
+    public equals(value: T): boolean
+    {
+        return Comparable.equals(this, value);
+    }
+
+    /**
+     * Get whether the left value equals the right value.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public static equals<T>(left: Comparable<T>, right: T): boolean
+    {
+        PreCondition.assertNotUndefinedAndNotNull(left, "left");
+
+        return left.compareTo(right) === Comparison.Equal;
+    }
+
+    /**
+     * Get whether this value is not equal to the provided value.
+     * @param value The value to compare against.
+     */
+    public notEquals(value: T): boolean
+    {
+        return Comparable.notEquals(this, value);
+    }
+
+    /**
+     * Get whether the left value is not equal to the right value.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public static notEquals<T>(left: Comparable<T>, right: T): boolean
+    {
+        PreCondition.assertNotUndefinedAndNotNull(left, "left");
+
+        return left.compareTo(right) !== Comparison.Equal;
+    }
+
+    /**
+     * Get whether this value is greater than or equal to the provided value.
+     * @param value The value to compare against.
+     */
+    public greaterThanOrEqualTo(value: T): boolean
+    {
+        return Comparable.greaterThanOrEqualTo(this, value);
+    }
+
+    /**
+     * Get whether the left value is greater than or equal to the right value.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public static greaterThanOrEqualTo<T>(left: Comparable<T>, right: T): boolean
+    {
+        PreCondition.assertNotUndefinedAndNotNull(left, "left");
+
+        return left.compareTo(right) !== Comparison.LessThan;
+    }
+
+    /**
+     * Get whether this value is greater than the provided value.
+     * @param value The value to compare against.
+     */
+    public greaterThan(value: T): boolean
+    {
+        return Comparable.greaterThan(this, value);
+    }
+
+    /**
+     * Get whether the left value is greater than the right value.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public static greaterThan<T>(left: Comparable<T>, right: T): boolean
+    {
+        PreCondition.assertNotUndefinedAndNotNull(left, "left");
+
+        return left.compareTo(right) === Comparison.GreaterThan;
+    }
+}

package/sources/comparer.ts

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

@@ -0,0 +1,20 @@
+/**
+ * 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

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

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