@everyonesoftware/common 1.0.0 → 3.0.0

package/sources/listStack.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 { Stack } from "./stack";
-import { SyncResult } from "./syncResult";
-
-export class ListStack<T> implements Stack<T>
-{
-    private readonly list: List<T>;
-
-    private constructor(list?: List<T>)
-    {
-        this.list = list ?? List.create();
-    }
-
-    public static create<T>(list?: List<T>): ListStack<T>
-    {
-        return new ListStack<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 { Stack } from "./stack";
+import { SyncResult } from "./syncResult";
+
+export class ListStack<T> implements Stack<T>
+{
+    private readonly list: List<T>;
+
+    private constructor(list?: List<T>)
+    {
+        this.list = list ?? List.create();
+    }
+
+    public static create<T>(list?: List<T>): ListStack<T>
+    {
+        return new ListStack<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);
+    }
 }

package/sources/luxonDateTime.ts

@@ -1,109 +1,109 @@
-import * as luxon from "luxon";
-import { DateTime } from "./dateTime";
-
-const pctTimeZone: string = "America/Los_Angeles";
-
-export class LuxonDateTime implements DateTime
-{
-    private readonly dateTime: luxon.DateTime;
-
-    private constructor(dateTime: luxon.DateTime)
-    {
-        this.dateTime = dateTime;
-    }
-
-    private static create(dateTime: luxon.DateTime): LuxonDateTime
-    {
-        return new LuxonDateTime(dateTime);
-    }
-
-    public static parse(text: string): LuxonDateTime
-    {
-        return LuxonDateTime.create(luxon.DateTime.fromISO(text, { zone: pctTimeZone }));
-    }
-
-    public static now(): LuxonDateTime
-    {
-        return LuxonDateTime.create(luxon.DateTime.now().setZone(pctTimeZone));
-    }
-
-    public getYear(): number
-    {
-        return this.dateTime.year;
-    }
-
-    public getMonth(): number
-    {
-        return this.dateTime.month;
-    }
-
-    public getDay(): number
-    {
-        return this.dateTime.day;
-    }
-
-    public getHour(): number
-    {
-        return this.dateTime.hour;
-    }
-
-    public getMinute(): number
-    {
-        return this.dateTime.minute;
-    }
-
-    public getSecond(): number
-    {
-        return this.dateTime.second;
-    }
-
-    public addDays(days: number): LuxonDateTime
-    {
-        return LuxonDateTime.create(this.dateTime.plus({ days: days }));
-    }
-
-    public toString(): string
-    {
-        return this.dateTime.toISO()!;
-    }
-
-    public toDateString(): string
-    {
-        return this.dateTime.toISODate()!;
-    }
-
-    public compareTo(dateTime: DateTime, compareTimes: boolean): number
-    {
-        return DateTime.compareTo(this, dateTime, compareTimes);
-    }
-
-    public lessThan(dateTime: DateTime, compareTimes: boolean): boolean
-    {
-        return DateTime.lessThan(this, dateTime, compareTimes);
-    }
-
-    public lessThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean
-    {
-        return DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
-    }
-
-    public equals(dateTime: DateTime, compareTimes: boolean): boolean
-    {
-        return DateTime.equals(this, dateTime, compareTimes);
-    }
-
-    public greaterThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean
-    {
-        return DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
-    }
-
-    public greaterThan(dateTime: DateTime, compareTimes: boolean): boolean
-    {
-        return DateTime.greaterThan(this, dateTime, compareTimes);
-    }
-
-    public get debug(): string
-    {
-        return DateTime.debug(this);
-    }
+import * as luxon from "luxon";
+import { DateTime } from "./dateTime";
+
+const pctTimeZone: string = "America/Los_Angeles";
+
+export class LuxonDateTime implements DateTime
+{
+    private readonly dateTime: luxon.DateTime;
+
+    private constructor(dateTime: luxon.DateTime)
+    {
+        this.dateTime = dateTime;
+    }
+
+    private static create(dateTime: luxon.DateTime): LuxonDateTime
+    {
+        return new LuxonDateTime(dateTime);
+    }
+
+    public static parse(text: string): LuxonDateTime
+    {
+        return LuxonDateTime.create(luxon.DateTime.fromISO(text, { zone: pctTimeZone }));
+    }
+
+    public static now(): LuxonDateTime
+    {
+        return LuxonDateTime.create(luxon.DateTime.now().setZone(pctTimeZone));
+    }
+
+    public getYear(): number
+    {
+        return this.dateTime.year;
+    }
+
+    public getMonth(): number
+    {
+        return this.dateTime.month;
+    }
+
+    public getDay(): number
+    {
+        return this.dateTime.day;
+    }
+
+    public getHour(): number
+    {
+        return this.dateTime.hour;
+    }
+
+    public getMinute(): number
+    {
+        return this.dateTime.minute;
+    }
+
+    public getSecond(): number
+    {
+        return this.dateTime.second;
+    }
+
+    public addDays(days: number): LuxonDateTime
+    {
+        return LuxonDateTime.create(this.dateTime.plus({ days: days }));
+    }
+
+    public toString(): string
+    {
+        return this.dateTime.toISO()!;
+    }
+
+    public toDateString(): string
+    {
+        return this.dateTime.toISODate()!;
+    }
+
+    public compareTo(dateTime: DateTime, compareTimes: boolean): number
+    {
+        return DateTime.compareTo(this, dateTime, compareTimes);
+    }
+
+    public lessThan(dateTime: DateTime, compareTimes: boolean): boolean
+    {
+        return DateTime.lessThan(this, dateTime, compareTimes);
+    }
+
+    public lessThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean
+    {
+        return DateTime.lessThanOrEqualTo(this, dateTime, compareTimes);
+    }
+
+    public equals(dateTime: DateTime, compareTimes: boolean): boolean
+    {
+        return DateTime.equals(this, dateTime, compareTimes);
+    }
+
+    public greaterThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean
+    {
+        return DateTime.greaterThanOrEqualTo(this, dateTime, compareTimes);
+    }
+
+    public greaterThan(dateTime: DateTime, compareTimes: boolean): boolean
+    {
+        return DateTime.greaterThan(this, dateTime, compareTimes);
+    }
+
+    public get debug(): string
+    {
+        return DateTime.debug(this);
+    }
 }

package/sources/mapAsyncIterator.ts

@@ -1,141 +1,141 @@
-import { PreCondition } from "./preCondition";
-import { Type } from "./types";
-import { AsyncIterator } from "./asyncIterator";
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { JavascriptAsyncIterator } from "./javascript";
-
-/**
- * An {@link AsyncIterator} that maps {@link TInput} values to {@link TOutput} values.
- */
-export class MapAsyncIterator<TInput, TOutput> implements AsyncIterator<TOutput>
-{
-    private readonly inputIterator: AsyncIterator<TInput>;
-    private readonly mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>);
-    private current: TOutput | undefined;
-    private started: boolean;
-
-    protected constructor(inputIterator: AsyncIterator<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>))
-    {
-        PreCondition.assertNotUndefinedAndNotNull(inputIterator, "inputIterator");
-        PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
-
-        this.inputIterator = inputIterator;
-        this.mapping = mapping;
-        this.started = false;
-    }
-
-    public static create<TInput, TOutput>(inputIterator: AsyncIterator<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>)): MapAsyncIterator<TInput, TOutput>
-    {
-        return new MapAsyncIterator(inputIterator, mapping);
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            if (!this.hasStarted())
-            {
-                this.started = true;
-                await this.inputIterator.start();
-            }
-            else
-            {
-                await this.inputIterator.next();
-            }
-
-            const result: boolean = this.inputIterator.hasCurrent();
-            this.current = result
-                ? await this.mapping(this.inputIterator.getCurrent())
-                : undefined;
-
-            return result;
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.hasStarted() && this.inputIterator.hasCurrent();
-    }
-
-    public getCurrent(): TOutput
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.current!;
-    }
-
-    public start(): PromiseAsyncResult<this>
-    {
-        return AsyncIterator.start<TOutput, this>(this);
-    }
-
-    public takeCurrent(): PromiseAsyncResult<TOutput>
-    {
-        return AsyncIterator.takeCurrent(this);
-    }
-
-    public any(): PromiseAsyncResult<boolean>
-    {
-        return AsyncIterator.any(this);
-    }
-
-    public getCount(): PromiseAsyncResult<number>
-    {
-        return AsyncIterator.getCount(this);
-    }
-
-    public toArray(): PromiseAsyncResult<TOutput[]>
-    {
-        return AsyncIterator.toArray(this);
-    }
-
-    public map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | PromiseLike<TOutput2>)): AsyncIterator<TOutput2>
-    {
-        return AsyncIterator.map(this, mapping);
-    }
-
-    public [Symbol.asyncIterator](): JavascriptAsyncIterator<TOutput>
-    {
-        return AsyncIterator[Symbol.asyncIterator](this);
-    }
-
-    public first(condition?: (value: TOutput) => boolean): PromiseAsyncResult<TOutput>
-    {
-        return AsyncIterator.first(this, condition);
-    }
-
-    public last(): PromiseAsyncResult<TOutput>
-    {
-        return AsyncIterator.last(this);
-    }
-
-    public where(condition: (value: TOutput) => (boolean | PromiseLike<boolean>)): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.where(this, condition);
-    }
-
-    public whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): AsyncIterator<U>
-    {
-        return AsyncIterator.whereInstanceOf(this, typeCheck);
-    }
-
-    public whereInstanceOfType<U extends TOutput>(type: Type<U>): AsyncIterator<U>
-    {
-        return AsyncIterator.whereInstanceOfType(this, type);
-    }
-
-    public take(maximumToTake: number): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.skip(this, maximumToSkip);
-    }
+import { PreCondition } from "./preCondition";
+import { Type } from "./types";
+import { AsyncIterator } from "./asyncIterator";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { JavascriptAsyncIterator } from "./javascript";
+
+/**
+ * An {@link AsyncIterator} that maps {@link TInput} values to {@link TOutput} values.
+ */
+export class MapAsyncIterator<TInput, TOutput> implements AsyncIterator<TOutput>
+{
+    private readonly inputIterator: AsyncIterator<TInput>;
+    private readonly mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>);
+    private current: TOutput | undefined;
+    private started: boolean;
+
+    protected constructor(inputIterator: AsyncIterator<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>))
+    {
+        PreCondition.assertNotUndefinedAndNotNull(inputIterator, "inputIterator");
+        PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
+
+        this.inputIterator = inputIterator;
+        this.mapping = mapping;
+        this.started = false;
+    }
+
+    public static create<TInput, TOutput>(inputIterator: AsyncIterator<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>)): MapAsyncIterator<TInput, TOutput>
+    {
+        return new MapAsyncIterator(inputIterator, mapping);
+    }
+
+    public next(): PromiseAsyncResult<boolean>
+    {
+        return PromiseAsyncResult.create(async () =>
+        {
+            if (!this.hasStarted())
+            {
+                this.started = true;
+                await this.inputIterator.start();
+            }
+            else
+            {
+                await this.inputIterator.next();
+            }
+
+            const result: boolean = this.inputIterator.hasCurrent();
+            this.current = result
+                ? await this.mapping(this.inputIterator.getCurrent())
+                : undefined;
+
+            return result;
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.inputIterator.hasCurrent();
+    }
+
+    public getCurrent(): TOutput
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.current!;
+    }
+
+    public start(): PromiseAsyncResult<this>
+    {
+        return AsyncIterator.start<TOutput, this>(this);
+    }
+
+    public takeCurrent(): PromiseAsyncResult<TOutput>
+    {
+        return AsyncIterator.takeCurrent(this);
+    }
+
+    public any(): PromiseAsyncResult<boolean>
+    {
+        return AsyncIterator.any(this);
+    }
+
+    public getCount(): PromiseAsyncResult<number>
+    {
+        return AsyncIterator.getCount(this);
+    }
+
+    public toArray(): PromiseAsyncResult<TOutput[]>
+    {
+        return AsyncIterator.toArray(this);
+    }
+
+    public map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | PromiseLike<TOutput2>)): AsyncIterator<TOutput2>
+    {
+        return AsyncIterator.map(this, mapping);
+    }
+
+    public [Symbol.asyncIterator](): JavascriptAsyncIterator<TOutput>
+    {
+        return AsyncIterator[Symbol.asyncIterator](this);
+    }
+
+    public first(condition?: (value: TOutput) => boolean): PromiseAsyncResult<TOutput>
+    {
+        return AsyncIterator.first(this, condition);
+    }
+
+    public last(): PromiseAsyncResult<TOutput>
+    {
+        return AsyncIterator.last(this);
+    }
+
+    public where(condition: (value: TOutput) => (boolean | PromiseLike<boolean>)): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.where(this, condition);
+    }
+
+    public whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): AsyncIterator<U>
+    {
+        return AsyncIterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends TOutput>(type: Type<U>): AsyncIterator<U>
+    {
+        return AsyncIterator.whereInstanceOfType(this, type);
+    }
+
+    public take(maximumToTake: number): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): AsyncIterator<TOutput>
+    {
+        return AsyncIterator.skip(this, maximumToSkip);
+    }
 }