@everyonesoftware/common 2.0.0 → 4.0.0

package/sources/javascriptArrayList.ts

@@ -1,175 +0,0 @@
-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 JavascriptArrayList<T> implements List<T>
-{
-    private readonly array: T[];
-
-    private constructor()
-    {
-        this.array = [];
-    }
-
-    public static create<T>(values?: JavascriptIterable<T>): JavascriptArrayList<T>
-    {
-        const result: JavascriptArrayList<T> = new JavascriptArrayList<T>();
-        if (values)
-        {
-            result.addAll(values);
-        }
-        return result;
-    }
-
-    public set(index: number, value: T): this
-    {
-        PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-
-        this.array[index] = value;
-
-        return this;
-    }
-
-    public iterate(): Iterator<T>
-    {
-        return Iterator.create(this.array);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return SyncResult.value(this.array.length);
-    }
-
-    public get(index: number): SyncResult<T>
-    {
-        PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-
-        return SyncResult.value(this.array[index]);
-    }
-
-    public insert(index: number, value: T): this
-    {
-        PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
-
-        this.array.splice(index, 0, value);
-
-        return this;
-    }
-
-    public insertAll(index: number, values: JavascriptIterable<T>): this
-    {
-        PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
-        PreCondition.assertNotUndefinedAndNotNull(values, "values");
-
-        this.array.splice(index, 0, ...values);
-
-        return this;
-    }
-
-    public removeAt(index: number): SyncResult<T>
-    {
-        PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
-
-        return SyncResult.value(this.array.splice(index, 1)[0]);
-    }
-
-    public removeFirst(): SyncResult<T>
-    {
-        PreCondition.assertNotEmpty(this, "this");
-
-        return SyncResult.value(this.array.shift()!);
-    }
-
-    public removeLast(): SyncResult<T>
-    {
-        PreCondition.assertNotEmpty(this, "this");
-
-        return SyncResult.value(this.array.pop()!);
-    }
-
-    public add(value: T): this
-    {
-        return List.add(this, value);
-    }
-
-    public addAll(values: JavascriptIterable<T>): this
-    {
-        return List.addAll(this, values);
-    }
-
-    public remove(value: T, equalFunctions?: EqualFunctions): SyncResult<T>
-    {
-        return List.remove(this, value, equalFunctions);
-    }
-
-    public toArray(): SyncResult<T[]>
-    {
-        return SyncResult.value(this.array.slice());
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return List.any(this);
-    }
-
-    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return List.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return List.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
-    {
-        return List.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return List.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return List.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
-    {
-        return List.where(this, condition);
-    }
-
-    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
-    {
-        return List.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return List.first(this, condition);
-    }
-
-    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return List.last(this, condition);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return List[Symbol.iterator](this);
-    }
-
-    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return List.contains(this, value, equalFunctions);
-    }
-}

package/sources/javascriptAsyncIteratorToAsyncIteratorAdapter.ts

@@ -1,124 +0,0 @@
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { AsyncIterator } from "./asyncIterator";
-import { JavascriptAsyncIterable, JavascriptAsyncIterator, JavascriptIteratorResult } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { isJavascriptAsyncIterable, Type } from "./types";
-import { AsyncIteratorToJavascriptAsyncIteratorAdapter } from "./asyncIteratorToJavascriptAsyncIteratorAdapter";
-
-export class JavascriptAsyncIteratorToAsyncIteratorAdapter<T> implements AsyncIterator<T>
-{
-    private readonly javascriptIterator: JavascriptAsyncIterator<T>;
-    private javascriptIteratorResult?: JavascriptIteratorResult<T>;
-
-    private constructor(javascriptIterator: JavascriptAsyncIterator<T>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(javascriptIterator, "javascriptIterator");
-
-        this.javascriptIterator = javascriptIterator;
-    }
-
-    public static create<T>(javascriptIterator: JavascriptAsyncIterator<T> | JavascriptAsyncIterable<T>): JavascriptAsyncIteratorToAsyncIteratorAdapter<T>
-    {
-        if (isJavascriptAsyncIterable<T>(javascriptIterator))
-        {
-            javascriptIterator = javascriptIterator[Symbol.asyncIterator]();
-        }
-        return new JavascriptAsyncIteratorToAsyncIteratorAdapter(javascriptIterator);
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            this.javascriptIteratorResult = await this.javascriptIterator.next();
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.javascriptIteratorResult !== undefined;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.javascriptIteratorResult?.done === false;
-    }
-
-    public getCurrent(): T
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.javascriptIteratorResult!.value;
-    }
-
-    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 map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.map(this, mapping);
-    }
-
-    public [Symbol.asyncIterator](): JavascriptAsyncIterator<T>
-    {
-        return AsyncIterator[Symbol.asyncIterator](this);
-    }
-
-    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 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 take(maximumToTake: number): AsyncIterator<T>
-    {
-        return AsyncIterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): AsyncIterator<T>
-    {
-        return AsyncIterator.skip(this, maximumToSkip);
-    }
-}

package/sources/javascriptIteratorToIteratorAdapter.ts

@@ -1,133 +0,0 @@
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator, JavascriptIteratorResult } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-import { isJavascriptIterable, Type } from "./types";
-
-export class JavascriptIteratorToIteratorAdapter<T> implements Iterator<T>
-{
-    private readonly javascriptIterator: JavascriptIterator<T>;
-    private javascriptIteratorResult?: JavascriptIteratorResult<T>;
-
-    private constructor(javascriptIterator: JavascriptIterator<T>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(javascriptIterator, "javascriptIterator");
-
-        this.javascriptIterator = javascriptIterator;
-    }
-
-    public static create<T>(javascriptIterator: JavascriptIterator<T> | JavascriptIterable<T>): JavascriptIteratorToIteratorAdapter<T>
-    {
-        if (isJavascriptIterable<T>(javascriptIterator))
-        {
-            javascriptIterator = javascriptIterator[Symbol.iterator]();
-        }
-        return new JavascriptIteratorToIteratorAdapter(javascriptIterator);
-    }
-
-    public next(): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            this.javascriptIteratorResult = this.javascriptIterator.next();
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.javascriptIteratorResult !== undefined;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.javascriptIteratorResult?.done === false;
-    }
-
-    public getCurrent(): T
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.javascriptIteratorResult!.value;
-    }
-
-    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 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 [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return Iterator[Symbol.iterator](this);
-    }
-
-    public first(condition?: (value: T) => boolean): SyncResult<T>
-    {
-        return Iterator.first(this, condition);
-    }
-
-    public last(): SyncResult<T>
-    {
-        return Iterator.last(this);
-    }
-
-    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 take(maximumToTake: number): Iterator<T>
-    {
-        return Iterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): Iterator<T>
-    {
-        return Iterator.skip(this, maximumToSkip);
-    }
-}

package/sources/javascriptMapMap.ts

@@ -1,143 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator, JavascriptMap } from "./javascript";
-import { MapEntry } from "./map";
-import { MutableMap } from "./mutableMap";
-import { NotFoundError } from "./notFoundError";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { Type } from "./types";
-
-export class JavascriptMapMap<TKey,TValue> implements MutableMap<TKey,TValue>
-{
-    private readonly javascriptMap: JavascriptMap<TKey,TValue>;
-
-    private constructor()
-    {
-        this.javascriptMap = new JavascriptMap();
-    }
-
-    public static create<TKey,TValue>(): JavascriptMapMap<TKey,TValue>
-    {
-        return new JavascriptMapMap<TKey,TValue>();
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return SyncResult.value(this.javascriptMap.size > 0);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return SyncResult.value(this.javascriptMap.size);
-    }
-
-    public containsKey(key: TKey): SyncResult<boolean>
-    {
-        return SyncResult.value(this.javascriptMap.has(key));
-    }
-
-    public get(key: TKey): SyncResult<TValue>
-    {
-        return this.containsKey(key).await()
-            ? SyncResult.value(this.javascriptMap.get(key)!)
-            : SyncResult.error(new NotFoundError(`The key ${JSON.stringify(key)} was not found in the map.`));
-    }
-
-    public set(key: TKey, value: TValue): this
-    {
-        this.javascriptMap.set(key, value);
-
-        return this;
-    }
-
-    public remove(key: TKey): SyncResult<TValue>
-    {
-        const value: TValue | undefined = this.javascriptMap.get(key);
-        return this.javascriptMap.delete(key)
-            ? SyncResult.value(value!)
-            : SyncResult.error(new NotFoundError(`The key ${JSON.stringify(key)} was not found in the map.`));
-    }
-
-    public iterate(): Iterator<MapEntry<TKey,TValue>>
-    {
-        return Iterator.create(this.javascriptMap.entries())
-            .map((entry: [TKey,TValue]) => { return {key: entry[0], value: entry[1]}; });
-    }
-
-    public iterateKeys(): Iterator<TKey>
-    {
-        return Iterator.create(this.javascriptMap.keys());
-    }
-
-    public iterateValues(): Iterator<TValue>
-    {
-        return Iterator.create(this.javascriptMap.values());
-    }
-
-    public toArray(): SyncResult<MapEntry<TKey, TValue>[]>
-    {
-        return MutableMap.toArray(this);
-    }
-
-    public equals(right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return MutableMap.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return MutableMap.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return MutableMap.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return MutableMap.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.where(this, condition);
-    }
-
-    public instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>
-    {
-        return MutableMap.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.first(this, condition);
-    }
-
-    public last(condition?: ((entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.last(this, condition);
-    }
-
-    public getOrSet(key: TKey, valueCreator: () => TValue | SyncResult<TValue>): SyncResult<TValue>
-    {
-        return MutableMap.getOrSet(this, key, valueCreator);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>
-    {
-        return MutableMap[Symbol.iterator](this);
-    }
-
-    public contains(value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return MutableMap.contains(this, value, equalFunctions);
-    }
-}

package/sources/javascriptSetSet.ts

@@ -1,134 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator, JavascriptSet } from "./javascript";
-import { NotFoundError } from "./notFoundError";
-import { Set } from "./set";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { Type } from "./types";
-
-export class JavascriptSetSet<T> implements Set<T>
-{
-    private readonly set: JavascriptSet<T>;
-
-    private constructor()
-    {
-        this.set = new JavascriptSet<T>();
-    }
-
-    public static create<T>(initialValues?: JavascriptIterable<T>): JavascriptSetSet<T>
-    {
-        const result: JavascriptSetSet<T> = new JavascriptSetSet<T>();
-        if (initialValues)
-        {
-            result.addAll(initialValues);
-        }
-        return result;
-    }
-
-    public add(value: T): this
-    {
-        this.set.add(value);
-
-        return this;
-    }
-
-    public addAll(values: JavascriptIterable<T>): this
-    {
-        return Set.addAll(this, values);
-    }
-
-    public remove(value: T): SyncResult<void>
-    {
-        return SyncResult.create(() =>
-        {
-            if (!this.set.delete(value))
-            {
-                throw new NotFoundError(`Could not find ${JSON.stringify(value)}.`);
-            }
-        });
-    }
-
-    public union(values: JavascriptIterable<T>): Set<T>
-    {
-        return Set.union(this, values);
-    }
-
-    public iterate(): Iterator<T>
-    {
-        return Iterator.create(this.set);
-    }
-
-    public toArray(): SyncResult<T[]>
-    {
-        return Set.toArray(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Set.any(this);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return SyncResult.value(this.set.size);
-    }
-
-    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Set.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return Set.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
-    {
-        return Set.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable<TOutput>
-    {
-        return Set.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Set.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
-    {
-        return Set.where(this, condition);
-    }
-
-    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
-    {
-        return Set.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Set.first(this, condition);
-    }
-
-    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Set.last(this, condition);
-    }
-
-    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return equalFunctions === undefined
-            ? SyncResult.value(this.set.has(value))
-            : Iterable.contains(this, value, equalFunctions);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return Set[Symbol.iterator](this);
-    }
-}