@everyonesoftware/common 1.0.0 → 3.0.0

package/sources/depthFirstSearch.ts

@@ -1,230 +1,230 @@
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { List } from "./list";
-import { ListStack } from "./listStack";
-import { PreCondition } from "./preCondition";
-import { SearchControl } from "./searchControl";
-import { Stack } from "./stack";
-import { Set } from "./set";
-import { Iterator } from "./iterator";
-import { SyncResult } from "./syncResult";
-import { isJavascriptIterable, Type } from "./types";
-
-class SearchBreakError extends Error
-{
-}
-
-class DepthFirstSearch<TVisit,TResult> implements SearchControl<TVisit,TResult>, Iterator<TResult>
-{
-    private readonly searchAction: (searchControl: SearchControl<TVisit,TResult>, visiting: TVisit) => void;
-    private readonly toVisit: ListStack<TVisit>;
-    private readonly visited: Set<TVisit>;
-    private readonly results: List<TResult>;
-    private started: boolean;
-    private done: boolean;
-
-    private constructor(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, visiting: TVisit) => void)
-    {
-        PreCondition.assertNotEmpty(initialToVisit, "initialToVisit");
-        PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
-
-        this.searchAction = searchAction;
-        this.toVisit = Stack.create();
-        this.toVisit.addAll(initialToVisit).await();
-        this.visited = Set.create();
-        this.results = List.create();
-        this.started = false;
-        this.done = false;
-    }
-
-    public static create<TVisit,TResult>(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, visiting: TVisit) => void): DepthFirstSearch<TVisit,TResult>
-    {
-        return new DepthFirstSearch(initialToVisit, searchAction);
-    }
-
-    public addToVisit(toVisit: TVisit): void
-    {
-        if (!this.hasVisited(toVisit))
-        {
-            this.toVisit.add(toVisit);
-        }
-    }
-
-    public addAllToVisit(values: JavascriptIterable<TVisit>): void
-    {
-        for (const value of values)
-        {
-            this.addToVisit(value);
-        }
-    }
-
-    public hasVisited(toVisit: TVisit): boolean
-    {
-        return this.visited.contains(toVisit).await();
-    }
-
-    public addResult(result: TResult): void
-    {
-        this.results.add(result);
-    }
-
-    public addResults(results: JavascriptIterable<TResult>): void
-    {
-        this.results.addAll(results);
-    }
-
-    public break(): never
-    {
-        throw new SearchBreakError();
-    }
-
-    public next(): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            let result: boolean = false;
-            if (!this.done)
-            {
-                if (!this.started)
-                {
-                    this.started = true;
-                }
-                else
-                {
-                    this.results.removeFirst().await();
-                }
-                
-                while (!this.hasCurrent() && this.toVisit.any().await())
-                {
-                    const current: TVisit = this.toVisit.remove().await();
-                    this.visited.add(current);
-                    this.searchAction(this, current);
-                }
-
-                result = this.hasCurrent();
-                this.done = !result;
-            }
-            return result;
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.results.any().await();
-    }
-
-    public getCurrent(): TResult
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.results.first().await();
-    }
-
-    public start(): SyncResult<this>
-    {
-        return Iterator.start<TResult,this>(this);
-    }
-
-    public takeCurrent(): SyncResult<TResult>
-    {
-        return Iterator.takeCurrent(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Iterator.any(this);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return Iterator.getCount(this);
-    }
-
-    public toArray(): SyncResult<TResult[]>
-    {
-        return Iterator.toArray(this);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<TResult>[]): Iterator<TResult>
-    {
-        return Iterator.concatenate(this, ...toConcatenate);
-    }
-
-    public where(condition: (value: TResult) => (boolean | SyncResult<boolean>)): Iterator<TResult>
-    {
-        return Iterator.where(this, condition);
-    }
-
-    public map<TOutput>(mapping: (value: TResult) => TOutput | SyncResult<TOutput>): Iterator<TOutput>
-    {
-        return Iterator.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: TResult) => JavascriptIterable<TOutput>): Iterator<TOutput>
-    {
-        return Iterator.flatMap(this, mapping);
-    }
-
-    public whereInstanceOf<U extends TResult>(typeCheck: (value: TResult) => value is U): Iterator<U>
-    {
-        return Iterator.whereInstanceOf(this, typeCheck);
-    }
-
-    public whereInstanceOfType<U extends TResult>(type: Type<U>): Iterator<U>
-    {
-        return Iterator.whereInstanceOfType(this, type);
-    }
-
-    public first(condition?: ((value: TResult) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TResult>
-    {
-        return Iterator.first(this, condition);
-    }
-
-    public last(condition?: ((value: TResult) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TResult>
-    {
-        return Iterator.last(this, condition);
-    }
-
-    public take(maximumToTake: number): Iterator<TResult>
-    {
-        return Iterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): Iterator<TResult>
-    {
-        return Iterator.skip(this, maximumToSkip);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<TResult>
-    {
-        return Iterator[Symbol.iterator](this);
-    }
-}
-
-export function depthFirstSearch<TVisit,TResult>(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void): Iterator<TResult>;
-export function depthFirstSearch<TVisit,TResult>(parameters: { initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void }): Iterator<TResult>;
-export function depthFirstSearch<TVisit,TResult>(parametersOrInitialToVisit: JavascriptIterable<TVisit> | { initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void }, searchAction?: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void): Iterator<TResult>
-{
-    let initialToVisit: JavascriptIterable<TVisit>;
-    if (isJavascriptIterable(parametersOrInitialToVisit))
-    {
-        initialToVisit = parametersOrInitialToVisit;
-        searchAction = searchAction!;
-    }
-    else
-    {
-        PreCondition.assertNotUndefinedAndNotNull(parametersOrInitialToVisit, "parameters");
-
-        initialToVisit = parametersOrInitialToVisit.initialToVisit;
-        searchAction = parametersOrInitialToVisit.searchAction;
-    }
-
-    PreCondition.assertNotUndefinedAndNotNull(initialToVisit, "initialToVisit");
-    PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
-
-    return DepthFirstSearch.create(initialToVisit, searchAction);
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { List } from "./list";
+import { ListStack } from "./listStack";
+import { PreCondition } from "./preCondition";
+import { SearchControl } from "./searchControl";
+import { Stack } from "./stack";
+import { Set } from "./set";
+import { Iterator } from "./iterator";
+import { SyncResult } from "./syncResult";
+import { isJavascriptIterable, Type } from "./types";
+
+class SearchBreakError extends Error
+{
+}
+
+class DepthFirstSearch<TVisit,TResult> implements SearchControl<TVisit,TResult>, Iterator<TResult>
+{
+    private readonly searchAction: (searchControl: SearchControl<TVisit,TResult>, visiting: TVisit) => void;
+    private readonly toVisit: ListStack<TVisit>;
+    private readonly visited: Set<TVisit>;
+    private readonly results: List<TResult>;
+    private started: boolean;
+    private done: boolean;
+
+    private constructor(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, visiting: TVisit) => void)
+    {
+        PreCondition.assertNotEmpty(initialToVisit, "initialToVisit");
+        PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
+
+        this.searchAction = searchAction;
+        this.toVisit = Stack.create();
+        this.toVisit.addAll(initialToVisit).await();
+        this.visited = Set.create();
+        this.results = List.create();
+        this.started = false;
+        this.done = false;
+    }
+
+    public static create<TVisit,TResult>(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, visiting: TVisit) => void): DepthFirstSearch<TVisit,TResult>
+    {
+        return new DepthFirstSearch(initialToVisit, searchAction);
+    }
+
+    public addToVisit(toVisit: TVisit): void
+    {
+        if (!this.hasVisited(toVisit))
+        {
+            this.toVisit.add(toVisit);
+        }
+    }
+
+    public addAllToVisit(values: JavascriptIterable<TVisit>): void
+    {
+        for (const value of values)
+        {
+            this.addToVisit(value);
+        }
+    }
+
+    public hasVisited(toVisit: TVisit): boolean
+    {
+        return this.visited.contains(toVisit).await();
+    }
+
+    public addResult(result: TResult): void
+    {
+        this.results.add(result);
+    }
+
+    public addResults(results: JavascriptIterable<TResult>): void
+    {
+        this.results.addAll(results);
+    }
+
+    public break(): never
+    {
+        throw new SearchBreakError();
+    }
+
+    public next(): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            let result: boolean = false;
+            if (!this.done)
+            {
+                if (!this.started)
+                {
+                    this.started = true;
+                }
+                else
+                {
+                    this.results.removeFirst().await();
+                }
+                
+                while (!this.hasCurrent() && this.toVisit.any().await())
+                {
+                    const current: TVisit = this.toVisit.remove().await();
+                    this.visited.add(current);
+                    this.searchAction(this, current);
+                }
+
+                result = this.hasCurrent();
+                this.done = !result;
+            }
+            return result;
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.results.any().await();
+    }
+
+    public getCurrent(): TResult
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.results.first().await();
+    }
+
+    public start(): SyncResult<this>
+    {
+        return Iterator.start<TResult,this>(this);
+    }
+
+    public takeCurrent(): SyncResult<TResult>
+    {
+        return Iterator.takeCurrent(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterator.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterator.getCount(this);
+    }
+
+    public toArray(): SyncResult<TResult[]>
+    {
+        return Iterator.toArray(this);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<TResult>[]): Iterator<TResult>
+    {
+        return Iterator.concatenate(this, ...toConcatenate);
+    }
+
+    public where(condition: (value: TResult) => (boolean | SyncResult<boolean>)): Iterator<TResult>
+    {
+        return Iterator.where(this, condition);
+    }
+
+    public map<TOutput>(mapping: (value: TResult) => TOutput | SyncResult<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: TResult) => JavascriptIterable<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.flatMap(this, mapping);
+    }
+
+    public whereInstanceOf<U extends TResult>(typeCheck: (value: TResult) => value is U): Iterator<U>
+    {
+        return Iterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends TResult>(type: Type<U>): Iterator<U>
+    {
+        return Iterator.whereInstanceOfType(this, type);
+    }
+
+    public first(condition?: ((value: TResult) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TResult>
+    {
+        return Iterator.first(this, condition);
+    }
+
+    public last(condition?: ((value: TResult) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TResult>
+    {
+        return Iterator.last(this, condition);
+    }
+
+    public take(maximumToTake: number): Iterator<TResult>
+    {
+        return Iterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): Iterator<TResult>
+    {
+        return Iterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<TResult>
+    {
+        return Iterator[Symbol.iterator](this);
+    }
+}
+
+export function depthFirstSearch<TVisit,TResult>(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void): Iterator<TResult>;
+export function depthFirstSearch<TVisit,TResult>(parameters: { initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void }): Iterator<TResult>;
+export function depthFirstSearch<TVisit,TResult>(parametersOrInitialToVisit: JavascriptIterable<TVisit> | { initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void }, searchAction?: (searchControl: SearchControl<TVisit,TResult>, current: TVisit) => void): Iterator<TResult>
+{
+    let initialToVisit: JavascriptIterable<TVisit>;
+    if (isJavascriptIterable(parametersOrInitialToVisit))
+    {
+        initialToVisit = parametersOrInitialToVisit;
+        searchAction = searchAction!;
+    }
+    else
+    {
+        PreCondition.assertNotUndefinedAndNotNull(parametersOrInitialToVisit, "parameters");
+
+        initialToVisit = parametersOrInitialToVisit.initialToVisit;
+        searchAction = parametersOrInitialToVisit.searchAction;
+    }
+
+    PreCondition.assertNotUndefinedAndNotNull(initialToVisit, "initialToVisit");
+    PreCondition.assertNotUndefinedAndNotNull(searchAction, "searchAction");
+
+    return DepthFirstSearch.create(initialToVisit, searchAction);
 }

package/sources/flatMapIterable.ts

@@ -1,104 +1,104 @@
-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 { ToStringFunctions } from "./toStringFunctions";
-import { Type } from "./types";
-
-export class FlatMapIterable<TInput,TOutput> implements Iterable<TOutput>
-{
-    private readonly innerIterable: Iterable<TInput>;
-    private readonly mapping: (value: TInput) => JavascriptIterable<TOutput>;
-
-    private constructor(innerIterable: Iterable<TInput>, mapping: (value: TInput) => JavascriptIterable<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) => JavascriptIterable<TOutput>): FlatMapIterable<TInput,TOutput>
-    {
-        return new FlatMapIterable(innerIterable, mapping);
-    }
-
-    public iterate(): Iterator<TOutput>
-    {
-        return this.innerIterable.iterate().flatMap(this.mapping);
-    }
-
-    public toArray(): SyncResult<TOutput[]>
-    {
-        return Iterable.toArray<TOutput>(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Iterable.any(this);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return Iterable.getCount(this);
-    }
-
-    public equals(right: JavascriptIterable<TOutput>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return Iterable.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable<TOutput>
-    {
-        return Iterable.concatenate<TOutput>(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 | SyncResult<boolean>)): Iterable<TOutput>
-    {
-        return Iterable.where(this, condition);
-    }
-
-    public instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput2) => value is TOutput2)): Iterable<TOutput2>
-    {
-        return Iterable.instanceOf<TOutput,TOutput2>(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>
-    {
-        return Iterable.first(this, condition);
-    }
-
-    public last(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>
-    {
-        return Iterable.last(this, condition);
-    }
-
-    public contains(value: TOutput, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.contains(this, value, equalFunctions);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<TOutput>
-    {
-        return Iterable[Symbol.iterator](this);
-    }
+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 { ToStringFunctions } from "./toStringFunctions";
+import { Type } from "./types";
+
+export class FlatMapIterable<TInput,TOutput> implements Iterable<TOutput>
+{
+    private readonly innerIterable: Iterable<TInput>;
+    private readonly mapping: (value: TInput) => JavascriptIterable<TOutput>;
+
+    private constructor(innerIterable: Iterable<TInput>, mapping: (value: TInput) => JavascriptIterable<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) => JavascriptIterable<TOutput>): FlatMapIterable<TInput,TOutput>
+    {
+        return new FlatMapIterable(innerIterable, mapping);
+    }
+
+    public iterate(): Iterator<TOutput>
+    {
+        return this.innerIterable.iterate().flatMap(this.mapping);
+    }
+
+    public toArray(): SyncResult<TOutput[]>
+    {
+        return Iterable.toArray<TOutput>(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterable.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterable.getCount(this);
+    }
+
+    public equals(right: JavascriptIterable<TOutput>, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return Iterable.equals(this, right, equalFunctions);
+    }
+
+    public toString(toStringFunctions?: ToStringFunctions): string
+    {
+        return Iterable.toString(this, toStringFunctions);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable<TOutput>
+    {
+        return Iterable.concatenate<TOutput>(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 | SyncResult<boolean>)): Iterable<TOutput>
+    {
+        return Iterable.where(this, condition);
+    }
+
+    public instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput2) => value is TOutput2)): Iterable<TOutput2>
+    {
+        return Iterable.instanceOf<TOutput,TOutput2>(this, typeOrTypeCheck);
+    }
+
+    public first(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>
+    {
+        return Iterable.first(this, condition);
+    }
+
+    public last(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>
+    {
+        return Iterable.last(this, condition);
+    }
+
+    public contains(value: TOutput, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return Iterable.contains(this, value, equalFunctions);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<TOutput>
+    {
+        return Iterable[Symbol.iterator](this);
+    }
 }