@everyonesoftware/common 1.0.0 → 3.0.0

package/sources/javascriptAsyncIteratorToAsyncIteratorAdapter.ts

@@ -1,124 +1,124 @@
-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);
-    }
+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/javascriptSetSet.ts

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

package/sources/listQueue.ts

@@ -1,62 +1,62 @@
-import { EmptyError } from "./emptyError";
-import { EqualFunctions } from "./equalFunctions";
-import { JavascriptIterable } from "./javascript";
-import { List } from "./list";
-import { PreCondition } from "./preCondition";
-import { Queue } from "./queue";
-import { SyncResult } from "./syncResult";
-
-export class ListQueue<T> implements Queue<T>
-{
-    private readonly list: List<T>;
-
-    private constructor(list?: List<T>)
-    {
-        this.list = list ?? List.create();
-    }
-
-    public static create<T>(list?: List<T>): ListQueue<T>
-    {
-        return new ListQueue<T>(list);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return this.list.any();
-    }
-
-    public add(value: T): SyncResult<void>
-    {
-        return SyncResult.create(() =>
-        {
-            this.list.add(value);
-        });
-    }
-
-    public addAll(values: JavascriptIterable<T>): SyncResult<void>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(values, "values");
-
-        return SyncResult.create(() =>
-        {
-            this.list.addAll(values);
-        });
-    }
-
-    public remove(): SyncResult<T>
-    {
-        return SyncResult.create(() =>
-        {
-            if (!this.any().await())
-            {
-                throw new EmptyError();
-            }
-            return this.list.removeLast().await();
-        });
-    }
-
-    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return this.list.contains(value, equalFunctions);
-    }
+import { EmptyError } from "./emptyError";
+import { EqualFunctions } from "./equalFunctions";
+import { JavascriptIterable } from "./javascript";
+import { List } from "./list";
+import { PreCondition } from "./preCondition";
+import { Queue } from "./queue";
+import { SyncResult } from "./syncResult";
+
+export class ListQueue<T> implements Queue<T>
+{
+    private readonly list: List<T>;
+
+    private constructor(list?: List<T>)
+    {
+        this.list = list ?? List.create();
+    }
+
+    public static create<T>(list?: List<T>): ListQueue<T>
+    {
+        return new ListQueue<T>(list);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return this.list.any();
+    }
+
+    public add(value: T): SyncResult<void>
+    {
+        return SyncResult.create(() =>
+        {
+            this.list.add(value);
+        });
+    }
+
+    public addAll(values: JavascriptIterable<T>): SyncResult<void>
+    {
+        PreCondition.assertNotUndefinedAndNotNull(values, "values");
+
+        return SyncResult.create(() =>
+        {
+            this.list.addAll(values);
+        });
+    }
+
+    public remove(): SyncResult<T>
+    {
+        return SyncResult.create(() =>
+        {
+            if (!this.any().await())
+            {
+                throw new EmptyError();
+            }
+            return this.list.removeLast().await();
+        });
+    }
+
+    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return this.list.contains(value, equalFunctions);
+    }
 }