@everyonesoftware/common 1.0.0 → 3.0.0

package/sources/characterReadStreamIterator.ts

@@ -1,128 +1,128 @@
-import { AsyncIterator } from "./asyncIterator";
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { CharacterReadStream } from "./characterReadStream";
-import { JavascriptAsyncIterator } from "./javascript";
-import { NotFoundError } from "./notFoundError";
-import { PreCondition } from "./preCondition";
-import { Type } from "./types";
-
-export class CharacterReadStreamAsyncIterator implements AsyncIterator<string>
-{
-    private readonly readStream: CharacterReadStream;
-    private current: string;
-    private started: boolean;
-
-    private constructor(readStream: CharacterReadStream)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-
-        this.readStream = readStream;
-        this.current = "";
-        this.started = false;
-    }
-
-    public static create(readStream: CharacterReadStream): CharacterReadStreamAsyncIterator
-    {
-        return new CharacterReadStreamAsyncIterator(readStream);
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            this.started = true;
-
-            this.current = await this.readStream.readCharacter()
-                .catch(NotFoundError, () => "");
-
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.current !== "";
-    }
-
-    public getCurrent(): string
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.current;
-    }
-
-    public start(): PromiseAsyncResult<this>
-    {
-        return AsyncIterator.start<string,this>(this);
-    }
-
-    public takeCurrent(): PromiseAsyncResult<string>
-    {
-        return AsyncIterator.takeCurrent(this);
-    }
-
-    public any(): PromiseAsyncResult<boolean>
-    {
-        return AsyncIterator.any(this);
-    }
-
-    public getCount(): PromiseAsyncResult<number>
-    {
-        return AsyncIterator.getCount(this);
-    }
-
-    public toArray(): PromiseAsyncResult<string[]>
-    {
-        return AsyncIterator.toArray(this);
-    }
-
-    public where(condition: (value: string) => boolean | PromiseLike<boolean>): AsyncIterator<string>
-    {
-        return AsyncIterator.where(this, condition);
-    }
-
-    public map<TOutput>(mapping: (value: string) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.map(this, mapping);
-    }
-
-    public whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): AsyncIterator<U>
-    {
-        return AsyncIterator.whereInstanceOf(this, typeCheck);
-    }
-
-    public whereInstanceOfType<U extends string>(type: Type<U>): AsyncIterator<U>
-    {
-        return AsyncIterator.whereInstanceOfType(this, type);
-    }
-
-    public first(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>
-    {
-        return AsyncIterator.first(this, condition);
-    }
-
-    public last(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>
-    {
-        return AsyncIterator.last(this, condition);
-    }
-
-    public take(maximumToTake: number): AsyncIterator<string>
-    {
-        return AsyncIterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): AsyncIterator<string>
-    {
-        return AsyncIterator.skip(this, maximumToSkip);
-    }
-
-    public [Symbol.asyncIterator](): JavascriptAsyncIterator<string>
-    {
-        return AsyncIterator[Symbol.asyncIterator](this);
-    }
+import { AsyncIterator } from "./asyncIterator";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { CharacterReadStream } from "./characterReadStream";
+import { JavascriptAsyncIterator } from "./javascript";
+import { NotFoundError } from "./notFoundError";
+import { PreCondition } from "./preCondition";
+import { Type } from "./types";
+
+export class CharacterReadStreamAsyncIterator implements AsyncIterator<string>
+{
+    private readonly readStream: CharacterReadStream;
+    private current: string;
+    private started: boolean;
+
+    private constructor(readStream: CharacterReadStream)
+    {
+        PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
+
+        this.readStream = readStream;
+        this.current = "";
+        this.started = false;
+    }
+
+    public static create(readStream: CharacterReadStream): CharacterReadStreamAsyncIterator
+    {
+        return new CharacterReadStreamAsyncIterator(readStream);
+    }
+
+    public next(): PromiseAsyncResult<boolean>
+    {
+        return PromiseAsyncResult.create(async () =>
+        {
+            this.started = true;
+
+            this.current = await this.readStream.readCharacter()
+                .catch(NotFoundError, () => "");
+
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.current !== "";
+    }
+
+    public getCurrent(): string
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.current;
+    }
+
+    public start(): PromiseAsyncResult<this>
+    {
+        return AsyncIterator.start<string,this>(this);
+    }
+
+    public takeCurrent(): PromiseAsyncResult<string>
+    {
+        return AsyncIterator.takeCurrent(this);
+    }
+
+    public any(): PromiseAsyncResult<boolean>
+    {
+        return AsyncIterator.any(this);
+    }
+
+    public getCount(): PromiseAsyncResult<number>
+    {
+        return AsyncIterator.getCount(this);
+    }
+
+    public toArray(): PromiseAsyncResult<string[]>
+    {
+        return AsyncIterator.toArray(this);
+    }
+
+    public where(condition: (value: string) => boolean | PromiseLike<boolean>): AsyncIterator<string>
+    {
+        return AsyncIterator.where(this, condition);
+    }
+
+    public map<TOutput>(mapping: (value: string) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.map(this, mapping);
+    }
+
+    public whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): AsyncIterator<U>
+    {
+        return AsyncIterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends string>(type: Type<U>): AsyncIterator<U>
+    {
+        return AsyncIterator.whereInstanceOfType(this, type);
+    }
+
+    public first(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>
+    {
+        return AsyncIterator.first(this, condition);
+    }
+
+    public last(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>
+    {
+        return AsyncIterator.last(this, condition);
+    }
+
+    public take(maximumToTake: number): AsyncIterator<string>
+    {
+        return AsyncIterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): AsyncIterator<string>
+    {
+        return AsyncIterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.asyncIterator](): JavascriptAsyncIterator<string>
+    {
+        return AsyncIterator[Symbol.asyncIterator](this);
+    }
 }

package/sources/concatenateIterable.ts

@@ -1,119 +1,119 @@
-import { ConcatenateIterator } from "./concatenateIterator";
-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 ConcatenateIterable<T> implements Iterable<T>
-{
-    private readonly innerIterables: Iterable<Iterable<T>>;
-
-    private constructor(innerIterables: Iterable<Iterable<T>>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterables, "innerIterables");
-
-        this.innerIterables = innerIterables;
-    }
-
-    public static create<T>(innerIterable: Iterable<T>, ...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterable<T>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterable, "innerIterable");
-        PreCondition.assertNotUndefinedAndNotNull(toConcatenate, "toConcatenate");
-
-        const innerIterables: List<Iterable<T>> = List.create();
-        innerIterables.add(innerIterable);
-        for (const value of toConcatenate)
-        {
-            innerIterables.add(Iterable.create(value));
-        }
-        return new ConcatenateIterable<T>(innerIterables);
-    }
-
-    public iterate(): Iterator<T>
-    {
-        return ConcatenateIterator.create<T>(...this.innerIterables);
-    }
-
-    public toArray(): SyncResult<T[]>
-    {
-        return Iterable.toArray(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return Iterable.any(this);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return SyncResult.create(() =>
-        {
-            let result: number = 0;
-            for (const innerIterable of this.innerIterables)
-            {
-                result += innerIterable.getCount().await();
-            }
-            return result;
-        });
-    }
-
-    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return Iterable.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
-    {
-        return Iterable.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
-    {
-        return Iterable.where(this, condition);
-    }
-
-    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
-    {
-        return Iterable.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Iterable.first(this, condition);
-    }
-
-    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
-    {
-        return Iterable.last(this, condition);
-    }
-
-    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.contains(this, value, equalFunctions);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<T>
-    {
-        return Iterable[Symbol.iterator](this);
-    }
+import { ConcatenateIterator } from "./concatenateIterator";
+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 ConcatenateIterable<T> implements Iterable<T>
+{
+    private readonly innerIterables: Iterable<Iterable<T>>;
+
+    private constructor(innerIterables: Iterable<Iterable<T>>)
+    {
+        PreCondition.assertNotUndefinedAndNotNull(innerIterables, "innerIterables");
+
+        this.innerIterables = innerIterables;
+    }
+
+    public static create<T>(innerIterable: Iterable<T>, ...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterable<T>
+    {
+        PreCondition.assertNotUndefinedAndNotNull(innerIterable, "innerIterable");
+        PreCondition.assertNotUndefinedAndNotNull(toConcatenate, "toConcatenate");
+
+        const innerIterables: List<Iterable<T>> = List.create();
+        innerIterables.add(innerIterable);
+        for (const value of toConcatenate)
+        {
+            innerIterables.add(Iterable.create(value));
+        }
+        return new ConcatenateIterable<T>(innerIterables);
+    }
+
+    public iterate(): Iterator<T>
+    {
+        return ConcatenateIterator.create<T>(...this.innerIterables);
+    }
+
+    public toArray(): SyncResult<T[]>
+    {
+        return Iterable.toArray(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterable.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return SyncResult.create(() =>
+        {
+            let result: number = 0;
+            for (const innerIterable of this.innerIterables)
+            {
+                result += innerIterable.getCount().await();
+            }
+            return result;
+        });
+    }
+
+    public equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return Iterable.equals(this, right, equalFunctions);
+    }
+
+    public toString(toStringFunctions?: ToStringFunctions): string
+    {
+        return Iterable.toString(this, toStringFunctions);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>
+    {
+        return Iterable.concatenate(this, ...toConcatenate);
+    }
+
+    public map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable<TOutput>
+    {
+        return Iterable.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>
+    {
+        return Iterable.flatMap(this, mapping);
+    }
+
+    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>
+    {
+        return Iterable.where(this, condition);
+    }
+
+    public instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>
+    {
+        return Iterable.instanceOf(this, typeOrTypeCheck);
+    }
+
+    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
+    {
+        return Iterable.first(this, condition);
+    }
+
+    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
+    {
+        return Iterable.last(this, condition);
+    }
+
+    public contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return Iterable.contains(this, value, equalFunctions);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<T>
+    {
+        return Iterable[Symbol.iterator](this);
+    }
 }