@everyonesoftware/common 1.0.0

package/sources/map.ts

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

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

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

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