@everyonesoftware/common 2.0.0 → 4.0.0

package/sources/set.ts

@@ -1,244 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { JavascriptSetSet } from "./javascriptSetSet";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { hasFunction, Type } from "./types";
-
-/**
- * Get whether the provided value is a {@link Set}.
- * @param value The value to check.
- */
-export function isSet(value: unknown): value is Set<unknown>
-{
-    return value instanceof Set ||
-        (
-            hasFunction(value, "add", 1) &&
-            hasFunction(value, "addAll", 1) &&
-            hasFunction(value, "remove", 1)
-        );
-}
-
-export abstract class Set<T> implements Iterable<T>
-{
-    public static create<T>(initialValues?: JavascriptIterable<T>): JavascriptSetSet<T>
-    {
-        return JavascriptSetSet.create(initialValues);
-    }
-
-    /**
-     * Add the provided value to this {@link Set}.
-     * @param value The value to add to this {@link Set}.
-     */
-    public abstract add(value: T): this;
-
-    public addAll(values: JavascriptIterable<T>): this
-    {
-        return Set.addAll(this, values);
-    }
-
-    public static addAll<T, TSet extends Set<T>>(set: TSet, values: JavascriptIterable<T>): TSet
-    {
-        PreCondition.assertNotUndefinedAndNotNull(set, "set");
-        PreCondition.assertNotUndefinedAndNotNull(values, "values");
-
-        for (const value of values)
-        {
-            set.add(value);
-        }
-        return set;
-    }
-
-    /**
-     * Remove the provided value from this {@link Set}. Return a {@link NotFoundError} if the value
-     * is not found.
-     * @param value The value to remove.
-     */
-    public abstract remove(value: T): SyncResult<void>;
-
-    public abstract iterate(): Iterator<T>;
-
-    public union(values: JavascriptIterable<T>): Set<T>
-    {
-        return Set.union(this, values);
-    }
-
-    public static union<T>(set: Set<T>, values: JavascriptIterable<T>): Set<T>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(set, "set");
-        PreCondition.assertNotUndefinedAndNotNull(values, "values");
-
-        const result: Set<T> = Set.create();
-        result.addAll(set);
-        result.addAll(values);
-        return result;
-    }
-
-    public toArray(): SyncResult<T[]>
-    {
-        return Set.toArray(this);
-    }
-
-    public static toArray<T>(set: Set<T>): SyncResult<T[]>
-    {
-        return Iterable.toArray(set);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Set.any(this);
-    }
-
-    public static any<T>(set: Set<T>): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            return set.getCount().await() > 0;
-        });
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return Set.getCount(this);
-    }
-
-    public static getCount<T>(set: Set<T>): SyncResult<number>
-    {
-        return Iterable.getCount(set);
-    }
-
-    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Set.equals(this, right, equalFunctions);
-    }
-
-    public static equals<T>(left: Set<T>, right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return isSet(right)
-            ? Set.equalSet(left, right, equalFunctions)
-            : Iterable.equals(left, right, equalFunctions);
-    }
-
-    public static equalSet<T>(left: Set<T>, right: Set<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            let result: boolean = left.getCount().await() === right.getCount().await();
-            if (result)
-            {
-                for (const leftValue of left)
-                {
-                    if (!right.contains(leftValue, equalFunctions).await())
-                    {
-                        result = false;
-                        break;
-                    }
-                }
-            }
-            return result;
-        });
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return Set.toString(this, toStringFunctions);
-    }
-
-    public static toString<T>(set: Set<T>, toStringFunctions?: ToStringFunctions): string
-    {
-        return Iterable.toString(set, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
-    {
-        return Set.concatenate(this, ...toConcatenate);
-    }
-
-    public static concatenate<T>(set: Set<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
-    {
-        return Iterable.concatenate(set, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return Set.map<T, TOutput>(this, mapping);
-    }
-
-    public static map<TInput, TOutput>(set: Set<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return Iterable.map<TInput, TOutput>(set, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Set.flatMap(this, mapping);
-    }
-
-    public static flatMap<TInput, TOutput>(set: Set<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.flatMap<TInput, TOutput>(set, mapping);
-    }
-
-    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
-    {
-        return Set.where(this, condition);
-    }
-
-    public static where<T>(set: Set<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
-    {
-        return Iterable.where(set, condition);
-    }
-
-    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
-    {
-        return Set.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public static instanceOf<TInput, TOutput extends TInput>(set: Set<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable<TOutput>
-    {
-        return Iterable.instanceOf(set, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Set.first(this, condition);
-    }
-
-    public static first<T>(set: Set<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>
-    {
-        return Iterable.first(set, condition);
-    }
-
-    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Set.last(this, condition);
-    }
-
-    public static last<T>(set: Set<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>
-    {
-        return Iterable.last(set, condition);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return Set[Symbol.iterator](this);
-    }
-
-    public static [Symbol.iterator]<T>(set: Set<T>): JavascriptIterator<T>
-    {
-        return Iterable[Symbol.iterator](set);
-    }
-
-    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Set.contains(this, value, equalFunctions);
-    }
-
-    public static contains<T>(set: Set<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.contains(set, value, equalFunctions);
-    }
-}

package/sources/skipAsyncIterator.ts

@@ -1,145 +0,0 @@
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { AsyncIterator } from "./asyncIterator";
-import { JavascriptAsyncIterator } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { Type } from "./types";
-
-/**
- * An {@link AsyncIterator} that skips the first maximum number of values from an inner
- * {@link AsyncIterator} before beginning to return values.
- */
-export class SkipAsyncIterator<T> implements AsyncIterator<T>
-{
-    private readonly innerIterator: AsyncIterator<T>;
-    private started: boolean;
-    private readonly maximumToSkip: number;
-
-    private constructor(innerIterator: AsyncIterator<T>, maximumToSkip: number)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
-        PreCondition.assertNotUndefinedAndNotNull(maximumToSkip, "maximumToSkip");
-        PreCondition.assertInteger(maximumToSkip, "maximumToSkip");
-        PreCondition.assertGreaterThanOrEqualTo(maximumToSkip, 0, "maximumToSkip");
-
-        this.innerIterator = innerIterator;
-        this.started = false;
-        this.maximumToSkip = maximumToSkip;
-    }
-
-    public static create<T>(innerIterator: AsyncIterator<T>, maximumToSkip: number): SkipAsyncIterator<T>
-    {
-        return new SkipAsyncIterator(innerIterator, maximumToSkip);
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            if (!this.hasStarted())
-            {
-                this.started = true;
-                await this.innerIterator.start();
-
-                for (let i = 0; i < this.maximumToSkip; i++)
-                {
-                    if (!await this.innerIterator.next())
-                    {
-                        break;
-                    }
-                }
-            }
-            else
-            {
-                await this.innerIterator.next();
-            }
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.hasStarted() && this.innerIterator.hasCurrent();
-    }
-
-    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 | PromiseLike<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/skipIterator.ts

@@ -1,155 +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 skips the first maximum number of values from an inner {@link Iterator}
- * before beginning to return values.
- */
-export class SkipIterator<T> implements Iterator<T>
-{
-    private readonly innerIterator: Iterator<T>;
-    private started: boolean;
-    private readonly maximumToSkip: number;
-
-    private constructor(innerIterator: Iterator<T>, maximumToSkip: number)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
-        PreCondition.assertNotUndefinedAndNotNull(maximumToSkip, "maximumToSkip");
-        PreCondition.assertInteger(maximumToSkip, "maximumToSkip");
-        PreCondition.assertGreaterThanOrEqualTo(maximumToSkip, 0, "maximumToSkip");
-
-        this.innerIterator = innerIterator;
-        this.started = false;
-        this.maximumToSkip = maximumToSkip;
-    }
-
-    public static create<T>(innerIterator: Iterator<T>, maximumToSkip: number)
-    {
-        return new SkipIterator(innerIterator, maximumToSkip);
-    }
-
-    public next(): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            if (!this.hasStarted())
-            {
-                this.started = true;
-                this.innerIterator.start().await();
-
-                for (let i = 0; i < this.maximumToSkip; i++)
-                {
-                    if (!this.innerIterator.next().await())
-                    {
-                        break;
-                    }
-                }
-            }
-            else
-            {
-                this.innerIterator.next().await();
-            }
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.hasStarted() && this.innerIterator.hasCurrent();
-    }
-
-    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);
-    }
-}

package/sources/stack.ts

@@ -1,48 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { JavascriptIterable } from "./javascript";
-import { ListStack } from "./listStack";
-import { AsyncResult } from "./asyncResult";
-
-/**
- * A data structure that stores values in a first-in-last-out order.
- */
-export abstract class Stack<T>
-{
-    /**
-     * Create an instance of the default {@link Stack} implementation.
-     * @returns A new {@link Stack} object.
-     */
-    public static create<T>(): ListStack<T>
-    {
-        return ListStack.create();
-    }
-
-    /**
-     * Get whether there are any values in this {@link Stack}.
-     */
-    public abstract any(): AsyncResult<boolean>;
-
-    /**
-     * Push the provided value onto the top of this {@link Stack}.
-     * @param value The value to push on the top of this {@link Stack}.
-     */
-    public abstract add(value: T): AsyncResult<void>;
-
-    /**
-     * Push the provided values onto the top of this {@link Stack}.
-     * @param values The values to push onto this {@link Stack}.
-     */
-    public abstract addAll(values: JavascriptIterable<T>): AsyncResult<void>;
-
-    /**
-     * Remove the top value off of this {@link Stack}.
-     */
-    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>;
-}

package/sources/stringComparer.ts

@@ -1,33 +0,0 @@
-import { Comparer } from "./comparer";
-import { Comparison } from "./comparison";
-
-/**
- * A {@link Comparer} that performs {@link string} comparisons.
- */
-export class StringComparer extends Comparer<string>
-{
-    protected constructor()
-    {
-        super();
-    }
-
-    public static create(): StringComparer
-    {
-        return new StringComparer();
-    }
-
-    public override compare(left: string, right: string): Comparison
-    {
-        return StringComparer.compare(left, right);
-    }
-
-    public static compare(left: string, right: string): Comparison
-    {
-        let result: Comparison | undefined = Comparer.compareSameUndefinedNull(left, right);
-        if (result === undefined)
-        {
-            result = (left < right ? Comparison.LessThan : Comparison.GreaterThan);
-        }
-        return result;
-    }
-}