@everyonesoftware/common 2.0.0 → 3.0.0

package/sources/takeAsyncIterator.ts

@@ -1,141 +1,141 @@
-import { AsyncIterator } from "./asyncIterator";
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { JavascriptAsyncIterator } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { Type } from "./types";
-
-/**
- * An {@link AsyncIterator} that iterates over a maximum number of values.
- */
-export class TakeAsyncIterator<T> implements AsyncIterator<T>
-{
-    private readonly innerIterator: AsyncIterator<T>;
-    private started: boolean;
-    private readonly maximumToTake: number;
-    private taken: number;
-
-    private constructor(innerIterator: AsyncIterator<T>, maximumToTake: number)
-    {
-        PreCondition.assertGreaterThanOrEqualTo(maximumToTake, 0, "maximumToTake");
-
-        this.innerIterator = innerIterator;
-        this.started = false;
-        this.maximumToTake = maximumToTake;
-        this.taken = 0;
-    }
-
-    public static create<T>(innerIterator: AsyncIterator<T>, maximumToTake: number)
-    {
-        return new TakeAsyncIterator(innerIterator, maximumToTake);
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.hasStarted() && this.taken <= this.maximumToTake && this.innerIterator.hasCurrent();
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            if (this.maximumToTake <= 0)
-            {
-                return false;
-            }
-            else if (!this.hasStarted())
-            {
-                this.started = true;
-                await this.innerIterator.start();
-                this.taken++;
-            }
-            else if (this.taken <= this.maximumToTake)
-            {
-                await this.innerIterator.next();
-                this.taken++;
-            }
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public getCurrent(): T
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.innerIterator.getCurrent();
-    }
-
-    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 where(condition: (value: T) => 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 map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.map(this, mapping);
-    }
-
-    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 [Symbol.asyncIterator](): JavascriptAsyncIterator<T>
-    {
-        return AsyncIterator[Symbol.asyncIterator](this);
-    }
-
-    public take(maximumToTake: number): AsyncIterator<T>
-    {
-        return AsyncIterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): AsyncIterator<T>
-    {
-        return AsyncIterator.skip(this, maximumToSkip);
-    }
+import { AsyncIterator } from "./asyncIterator";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { JavascriptAsyncIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { Type } from "./types";
+
+/**
+ * An {@link AsyncIterator} that iterates over a maximum number of values.
+ */
+export class TakeAsyncIterator<T> implements AsyncIterator<T>
+{
+    private readonly innerIterator: AsyncIterator<T>;
+    private started: boolean;
+    private readonly maximumToTake: number;
+    private taken: number;
+
+    private constructor(innerIterator: AsyncIterator<T>, maximumToTake: number)
+    {
+        PreCondition.assertGreaterThanOrEqualTo(maximumToTake, 0, "maximumToTake");
+
+        this.innerIterator = innerIterator;
+        this.started = false;
+        this.maximumToTake = maximumToTake;
+        this.taken = 0;
+    }
+
+    public static create<T>(innerIterator: AsyncIterator<T>, maximumToTake: number)
+    {
+        return new TakeAsyncIterator(innerIterator, maximumToTake);
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.taken <= this.maximumToTake && this.innerIterator.hasCurrent();
+    }
+
+    public next(): PromiseAsyncResult<boolean>
+    {
+        return PromiseAsyncResult.create(async () =>
+        {
+            if (this.maximumToTake <= 0)
+            {
+                return false;
+            }
+            else if (!this.hasStarted())
+            {
+                this.started = true;
+                await this.innerIterator.start();
+                this.taken++;
+            }
+            else if (this.taken <= this.maximumToTake)
+            {
+                await this.innerIterator.next();
+                this.taken++;
+            }
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.innerIterator.getCurrent();
+    }
+
+    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 where(condition: (value: T) => 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 map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.map(this, mapping);
+    }
+
+    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 [Symbol.asyncIterator](): JavascriptAsyncIterator<T>
+    {
+        return AsyncIterator[Symbol.asyncIterator](this);
+    }
+
+    public take(maximumToTake: number): AsyncIterator<T>
+    {
+        return AsyncIterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): AsyncIterator<T>
+    {
+        return AsyncIterator.skip(this, maximumToSkip);
+    }
 }

package/sources/whereAsyncIterator.ts

@@ -1,143 +1,143 @@
-import { AsyncIterator } from "./asyncIterator";
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { JavascriptAsyncIterator } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { Type } from "./types";
-
-/**
- * An {@link Iterator} that only returns values that match a condition.
- */
-export class WhereAsyncIterator<T> implements AsyncIterator<T>
-{
-    private readonly innerIterator: AsyncIterator<T>;
-    private started: boolean;
-    private readonly condition: (value: T) => (boolean | PromiseLike<boolean>);
-
-    private constructor(innerIterator: AsyncIterator<T>, condition: (value: T) => (boolean | PromiseLike<boolean>))
-    {
-        PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
-        PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
-
-        this.innerIterator = innerIterator;
-        this.started = false;
-        this.condition = condition;
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.hasStarted() && this.innerIterator.hasCurrent();
-    }
-
-    public getCurrent(): T
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.innerIterator.getCurrent();
-    }
-
-    public static create<T>(innerIterator: AsyncIterator<T>, condition: (value: T) => (boolean | PromiseLike<boolean>)): WhereAsyncIterator<T>
-    {
-        return new WhereAsyncIterator(innerIterator, condition);
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            if (!this.hasStarted())
-            {
-                await this.innerIterator.start();
-                this.started = true;
-
-                while (this.hasCurrent() && !await this.condition(this.getCurrent()))
-                {
-                    await this.innerIterator.next();
-                }
-            }
-            else
-            {
-                do
-                {
-                    await this.innerIterator.next();
-                }
-                while (this.hasCurrent() && !await this.condition(this.getCurrent()));
-            }
-            return this.hasCurrent();
-        });
-    }
-
-    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 where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>
-    {
-        return AsyncIterator.where(this, condition);
-    }
-
-    public map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.map(this, mapping);
-    }
-
-    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 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 take(maximumToTake: number): AsyncIterator<T>
-    {
-        return AsyncIterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): AsyncIterator<T>
-    {
-        return AsyncIterator.skip(this, maximumToSkip);
-    }
-
-    public [Symbol.asyncIterator](): JavascriptAsyncIterator<T>
-    {
-        return AsyncIterator[Symbol.asyncIterator](this);
-    }
+import { AsyncIterator } from "./asyncIterator";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { JavascriptAsyncIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { Type } from "./types";
+
+/**
+ * An {@link Iterator} that only returns values that match a condition.
+ */
+export class WhereAsyncIterator<T> implements AsyncIterator<T>
+{
+    private readonly innerIterator: AsyncIterator<T>;
+    private started: boolean;
+    private readonly condition: (value: T) => (boolean | PromiseLike<boolean>);
+
+    private constructor(innerIterator: AsyncIterator<T>, condition: (value: T) => (boolean | PromiseLike<boolean>))
+    {
+        PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
+        PreCondition.assertNotUndefinedAndNotNull(condition, "condition");
+
+        this.innerIterator = innerIterator;
+        this.started = false;
+        this.condition = condition;
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.innerIterator.hasCurrent();
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.innerIterator.getCurrent();
+    }
+
+    public static create<T>(innerIterator: AsyncIterator<T>, condition: (value: T) => (boolean | PromiseLike<boolean>)): WhereAsyncIterator<T>
+    {
+        return new WhereAsyncIterator(innerIterator, condition);
+    }
+
+    public next(): PromiseAsyncResult<boolean>
+    {
+        return PromiseAsyncResult.create(async () =>
+        {
+            if (!this.hasStarted())
+            {
+                await this.innerIterator.start();
+                this.started = true;
+
+                while (this.hasCurrent() && !await this.condition(this.getCurrent()))
+                {
+                    await this.innerIterator.next();
+                }
+            }
+            else
+            {
+                do
+                {
+                    await this.innerIterator.next();
+                }
+                while (this.hasCurrent() && !await this.condition(this.getCurrent()));
+            }
+            return this.hasCurrent();
+        });
+    }
+
+    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 where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>
+    {
+        return AsyncIterator.where(this, condition);
+    }
+
+    public map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.map(this, mapping);
+    }
+
+    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 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 take(maximumToTake: number): AsyncIterator<T>
+    {
+        return AsyncIterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): AsyncIterator<T>
+    {
+        return AsyncIterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.asyncIterator](): JavascriptAsyncIterator<T>
+    {
+        return AsyncIterator[Symbol.asyncIterator](this);
+    }
 }