@everyonesoftware/common 3.0.0 → 5.0.0

package/sources/map.ts

@@ -1,302 +0,0 @@
-import { Comparer } from "./comparer";
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { MutableMap } from "./mutableMap";
-import { NotFoundError } from "./notFoundError";
-import { PreCondition } from "./preCondition";
-import { join } from "./strings";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { hasFunction, isUndefinedOrNull, Type } from "./types";
-
-/**
- * Get whether the provided value is {@link Map}.
- * @param value The value to check.
- */
-export function isMap(value: unknown): value is Map<unknown, unknown>
-{
-    return value instanceof Map ||
-        (
-            hasFunction(value, "containsKey", 1) &&
-            hasFunction(value, "get", 1) &&
-            hasFunction(value, "set", 2) &&
-            hasFunction(value, "iterateKeys", 0) &&
-            hasFunction(value, "iterateValues", 0)
-        );
-}
-
-/**
- * An entry within a {@link Map}.
- */
-export interface MapEntry<TKey, TValue>
-{
-    /**
-     * The key of the {@link MapEntry}.
-     */
-    readonly key: TKey,
-    /**
-     * The value of the {@link MapEntry}.
-     */
-    readonly value: TValue,
-}
-
-/**
- * A type that maps {@link TKey} values to {@link TValue} values.
- */
-export abstract class Map<TKey, TValue> implements Iterable<MapEntry<TKey, TValue>>
-{
-    /**
-     * Create a new instance of the default {@link MutableMap} implementation.
-     */
-    public static create<TKey, TValue>(): MutableMap<TKey, TValue>
-    {
-        return MutableMap.create();
-    }
-
-    /**
-     * Iterate over the entries in this {@link Map}.
-     */
-    public abstract iterate(): Iterator<MapEntry<TKey, TValue>>;
-
-    public any(): SyncResult<boolean>
-    {
-        return Map.any(this);
-    }
-
-    public static any<TKey,TValue>(map: Map<TKey,TValue>): SyncResult<boolean>
-    {
-        return Iterable.any(map);
-    }
-
-    public toArray(): SyncResult<MapEntry<TKey, TValue>[]>
-    {
-        return Map.toArray(this);
-    }
-
-    public static toArray<TKey,TValue>(map: Map<TKey,TValue>): SyncResult<MapEntry<TKey,TValue>[]>
-    {
-        return Iterable.toArray(map);
-    }
-
-    public equals(right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Map.equals(this, right, equalFunctions);
-    }
-
-    public static equals<TKey, TValue>(left: Map<TKey, TValue>, right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            if (isUndefinedOrNull(equalFunctions))
-            {
-                equalFunctions = EqualFunctions.create();
-            }
-
-            let result: boolean | undefined = Comparer.equalSameUndefinedNull(left, right);
-            if (result === undefined)
-            {
-                result = true;
-                for (const entry of right)
-                {
-                    result = left.get(entry.key)
-                        .then((value: TValue) => equalFunctions!.areEqual(value, entry.value).await())
-                        .catch(() => false)
-                        .await();
-                    if (result === false)
-                    {
-                        break;
-                    }
-                }
-            }
-            return result;
-        });
-    }
-
-    /**
-     * Get the {@link String} representation of this {@link Map}.
-     */
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return Map.toString(this, toStringFunctions);
-    }
-
-    /**
-     * Get the {@link String} representation of the provided {@link Map}.
-     */
-    public static toString<TKey, TValue>(map: Map<TKey, TValue>, toStringFunctions?: ToStringFunctions): string
-    {
-        PreCondition.assertNotUndefinedAndNotNull(map, "iterable");
-
-        if (!toStringFunctions)
-        {
-            toStringFunctions = ToStringFunctions.create();
-        }
-        return `{${join(",", map.map((entry: MapEntry<unknown, unknown>) => `${toStringFunctions.toString(entry.key)}:${toStringFunctions.toString(entry.value)}`))}}`;
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>
-    {
-        return Map.concatenate(this, ...toConcatenate);
-    }
-
-    public static concatenate<TKey,TValue>(map: Map<TKey,TValue>, ...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>
-    {
-        return Iterable.concatenate(map, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return Map.map(this, mapping);
-    }
-
-    public static map<TKey,TValue,TOutput>(map: Map<TKey,TValue>, mapping: (value: MapEntry<TKey,TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return Iterable.map(map, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Map.flatMap(this, mapping);
-    }
-
-    public static flatMap<TKey,TValue,TOutput>(map: Map<TKey,TValue>, mapping: (value: MapEntry<TKey,TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.flatMap(map, mapping);
-    } 
-
-    public where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>
-    {
-        return Map.where(this, condition);
-    }
-
-    public static where<TKey,TValue>(map: Map<TKey,TValue>, condition: (value: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey,TValue>>
-    {
-        return Iterable.where(map, condition);
-    }
-
-    public instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>
-    {
-        return Map.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public static instanceOf<TKey,TValue,T extends MapEntry<TKey, TValue>>(map: Map<TKey,TValue>, typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>
-    {
-        return Iterable.instanceOf(map, typeOrTypeCheck);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>
-    {
-        return Map[Symbol.iterator](this);
-    }
-
-    public static [Symbol.iterator]<TKey,TValue>(map: Map<TKey,TValue>): JavascriptIterator<MapEntry<TKey,TValue>>
-    {
-        return Iterable[Symbol.iterator](map);
-    }
-
-    /**
-     * Get the number of entries in this {@link Map}.
-     */
-    public getCount(): SyncResult<number>
-    {
-        return Map.getCount(this);
-    }
-
-    public static getCount<TKey,TValue>(map: Map<TKey,TValue>): SyncResult<number>
-    {
-        return Iterable.getCount(map);
-    }
-
-    public first(condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return Map.first(this, condition);
-    }
-
-    public static first<TKey,TValue>(map: Map<TKey,TValue>, condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return Iterable.first(map, condition);
-    }
-
-    public last(condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return Map.last(this, condition);
-    }
-
-    public static last<TKey,TValue>(map: Map<TKey,TValue>, condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return Iterable.last(map, condition);
-    }
-
-    /**
-     * Get whether this {@link Map} contains the provided key.
-     * @param key The key to look for.
-     */
-    public abstract containsKey(key: TKey): SyncResult<boolean>;
-
-    /**
-     * Get the value associated with the provided key.
-     * @param key The key of the value to get.
-     */
-    public abstract get(key: TKey): SyncResult<TValue>;
-
-    /**
-     * Iterate over the keys in this {@link Map}.
-     */
-    public iterateKeys(): Iterator<TKey>
-    {
-        return Map.iterateKeys(this);
-    }
-
-    /**
-     * Iterate over the keys in the {@link Map}.
-     * @param map The map to iterate over.
-     */
-    public static iterateKeys<TKey, TValue>(map: Map<TKey, TValue>): Iterator<TKey>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(map, "map");
-
-        return map.iterate().map((entry: MapEntry<TKey, TValue>) => entry.key);
-    }
-
-    /**
-     * Iterate over the values in this {@link Map}.
-     */
-    public iterateValues(): Iterator<TValue>
-    {
-        return Map.iterateValues(this);
-    }
-
-    /**
-     * Iterate over the keys in the {@link Map}.
-     * @param map The map to iterate over.
-     */
-    public static iterateValues<TKey, TValue>(map: Map<TKey, TValue>): Iterator<TValue>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(map, "map");
-
-        return map.iterate().map((entry: MapEntry<TKey, TValue>) => entry.value);
-    }
-
-    public contains(value: MapEntry<TKey,TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Map.contains(this, value, equalFunctions);
-    }
-
-    public static contains<TKey,TValue>(map: Map<TKey,TValue>, value: MapEntry<TKey,TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            if (!equalFunctions)
-            {
-                equalFunctions = EqualFunctions.create();
-            }
-
-            return map.get(value.key)
-                .then(entryValue => equalFunctions!.areEqual(entryValue, value.value).await())
-                .catch(NotFoundError, () => false)
-                .await();
-        });
-    }
-}

package/sources/mapAsyncIterator.ts

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

package/sources/mapIterable.ts

@@ -1,105 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-import { Type } from "./types";
-
-/**
- * An {@link Iterable} that converts {@link TInput} values to {@link TOutput} values.
- */
-export class MapIterable<TInput,TOutput> implements Iterable<TOutput>
-{
-    private readonly innerIterable: Iterable<TInput>;
-    private readonly mapping: (value: TInput) => (TOutput | SyncResult<TOutput>);
-
-    protected constructor(innerIterable: Iterable<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>))
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterable, "innerIterable");
-        PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
-
-        this.innerIterable = innerIterable;
-        this.mapping = mapping;
-    }
-
-    public static create<TInput,TOutput>(innerIterable: Iterable<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): MapIterable<TInput,TOutput>
-    {
-        return new MapIterable<TInput,TOutput>(innerIterable, mapping);
-    }
-
-    public iterate(): Iterator<TOutput>
-    {
-        return this.innerIterable.iterate().map(this.mapping);
-    }
-
-    public toArray(): SyncResult<TOutput[]>
-    {
-        return Iterable.toArray(this);
-    }
-
-    public equals(right: Iterable<TOutput>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.equals(this, right, equalFunctions);
-    }
-
-    public toString(): string
-    {
-        return Iterable.toString(this);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable<TOutput>
-    {
-        return Iterable.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterable<TOutput2>
-    {
-        return Iterable.map(this, mapping);
-    }
-
-    public flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterable<TOutput2>
-    {
-        return Iterable.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: TOutput) => boolean): Iterable<TOutput>
-    {
-        return Iterable.where(this, condition);
-    }
-
-    public instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput) => value is TOutput2)): Iterable<TOutput2>
-    {
-        return Iterable.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<TOutput>
-    {
-        return Iterable[Symbol.iterator](this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return this.innerIterable.any();
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return this.innerIterable.getCount();
-    }
-
-    public first(): SyncResult<TOutput>
-    {
-        return Iterable.first(this);
-    }
-
-    public last(): SyncResult<TOutput>
-    {
-        return Iterable.last(this);
-    }
-
-    public contains(value: TOutput, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.contains(this, value, equalFunctions);
-    }
-}

package/sources/mapIterator.ts

@@ -1,145 +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 maps {@link TInput} values to {@link TOutput} values.
- */
-export class MapIterator<TInput, TOutput> implements Iterator<TOutput>
-{
-    private readonly inputIterator: Iterator<TInput>;
-    private readonly mapping: (value: TInput) => (TOutput | SyncResult<TOutput>);
-    private started: boolean;
-
-    protected constructor(inputIterator: Iterator<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>))
-    {
-        PreCondition.assertNotUndefinedAndNotNull(inputIterator, "inputIterator");
-        PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
-
-        this.inputIterator = inputIterator;
-        this.mapping = mapping;
-        this.started = false;
-    }
-
-    public static create<TInput, TOutput>(inputIterator: Iterator<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): MapIterator<TInput, TOutput>
-    {
-        return new MapIterator(inputIterator, mapping);
-    }
-
-    public next(): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            if (!this.hasStarted())
-            {
-                this.started = true;
-                this.inputIterator.start();
-            }
-            else
-            {
-                this.inputIterator.next();
-            }
-            return this.inputIterator.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.hasStarted() && this.inputIterator.hasCurrent();
-    }
-
-    public getCurrent(): TOutput
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        const mappingResult: TOutput | SyncResult<TOutput> = this.mapping(this.inputIterator.getCurrent());
-        return mappingResult instanceof SyncResult ? mappingResult.await() : mappingResult;
-    }
-
-    public start(): SyncResult<this>
-    {
-        return Iterator.start<TOutput, this>(this);
-    }
-
-    public takeCurrent(): SyncResult<TOutput>
-    {
-        return Iterator.takeCurrent(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Iterator.any(this);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return Iterator.getCount(this);
-    }
-
-    public toArray(): SyncResult<TOutput[]>
-    {
-        return Iterator.toArray(this);
-    }
-
-    public concatenate(toConcatenate: JavascriptIterable<TOutput>): Iterator<TOutput>
-    {
-        return Iterator.concatenate(this, toConcatenate);
-    }
-
-    public map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterator<TOutput2>
-    {
-        return Iterator.map(this, mapping);
-    }
-
-    public flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterator<TOutput2>
-    {
-        return Iterator.flatMap(this, mapping);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<TOutput>
-    {
-        return Iterator[Symbol.iterator](this);
-    }
-
-    public first(condition?: (value: TOutput) => boolean): SyncResult<TOutput>
-    {
-        return Iterator.first(this, condition);
-    }
-
-    public last(): SyncResult<TOutput>
-    {
-        return Iterator.last(this);
-    }
-
-    public where(condition: (value: TOutput) => boolean): Iterator<TOutput>
-    {
-        return Iterator.where(this, condition);
-    }
-
-    public whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): Iterator<U>
-    {
-        return Iterator.whereInstanceOf(this, typeCheck);
-    }
-
-    public whereInstanceOfType<U extends TOutput>(type: Type<U>): Iterator<U>
-    {
-        return Iterator.whereInstanceOfType(this, type);
-    }
-
-    public take(maximumToTake: number): Iterator<TOutput>
-    {
-        return Iterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): Iterator<TOutput>
-    {
-        return Iterator.skip(this, maximumToSkip);
-    }
-}