@everyonesoftware/common 1.0.0

package/sources/flatMapIterable.ts

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

package/sources/flatMapIterator.ts

@@ -0,0 +1,152 @@
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { Iterator } from "./iterator";
+import { SyncResult } from "./syncResult";
+import { Type } from "./types";
+
+export class FlatMapIterator<TInput,TOutput> implements Iterator<TOutput>
+{
+    private readonly innerIterator: Iterator<TInput>;
+    private readonly mapping: (value: TInput) => JavascriptIterable<TOutput>;
+    private mappingIterator: Iterator<TOutput> | undefined;
+    private started: boolean;
+
+    private constructor(innerIterator: Iterator<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>)
+    {
+        PreCondition.assertNotUndefinedAndNotNull(innerIterator, "innerIterator");
+        PreCondition.assertNotUndefinedAndNotNull(mapping, "mapping");
+
+        this.innerIterator = innerIterator;
+        this.mapping = mapping;
+        this.started = false;
+    }
+
+    public static create<TInput,TOutput>(innerIterator: Iterator<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): FlatMapIterator<TInput,TOutput>
+    {
+        return new FlatMapIterator(innerIterator, mapping);
+    }
+
+    public next(): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            this.innerIterator.start().await();
+
+            while (this.innerIterator.hasCurrent())
+            {
+                if (this.mappingIterator === undefined)
+                {
+                    this.mappingIterator = Iterator.create(this.mapping(this.innerIterator.getCurrent()));
+                }
+
+                if (this.mappingIterator.next().await())
+                {
+                    break;
+                }
+                else if (this.innerIterator.next().await())
+                {
+                    this.mappingIterator = undefined;
+                }
+            }
+
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.mappingIterator?.hasCurrent() ?? false;
+    }
+
+    public getCurrent(): TOutput
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.mappingIterator!.getCurrent();
+    }
+
+    public start(): SyncResult<this>
+    {
+        return Iterator.start<TOutput,this>(this);
+    }
+
+    public takeCurrent(): SyncResult<TOutput>
+    {
+        return Iterator.takeCurrent(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterator.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterator.getCount(this);
+    }
+
+    public toArray(): SyncResult<TOutput[]>
+    {
+        return Iterator.toArray(this);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterator<TOutput>
+    {
+        return Iterator.concatenate(this, ...toConcatenate);
+    }
+
+    public where(condition: (value: TOutput) => (boolean | SyncResult<boolean>)): Iterator<TOutput>
+    {
+        return Iterator.where(this, condition);
+    }
+
+    public map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterator<TOutput2>
+    {
+        return Iterator.map(this, mapping);
+    }
+
+    public flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterator<TOutput2>
+    {
+        return Iterator.flatMap(this, mapping);
+    }
+
+    public whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): Iterator<U>
+    {
+        return Iterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends TOutput>(type: Type<U>): Iterator<U>
+    {
+        return Iterator.whereInstanceOfType(this, type);
+    }
+
+    public first(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>
+    {
+        return Iterator.first(this, condition);
+    }
+
+    public last(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>
+    {
+        return Iterator.last(this, condition);
+    }
+
+    public take(maximumToTake: number): Iterator<TOutput>
+    {
+        return Iterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): Iterator<TOutput>
+    {
+        return Iterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<TOutput>
+    {
+        return Iterator[Symbol.iterator](this);
+    }
+}

package/sources/generator.ts

@@ -0,0 +1,251 @@
+import { Iterator } from "./iterator";
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { List } from "./list";
+import { PreCondition } from "./preCondition";
+import { SyncResult } from "./syncResult";
+import { Type } from "./types";
+
+/**
+ * A control that can be used to interact with a {@link Generator} while it is generating values.
+ */
+export interface GeneratorControl<T>
+{
+    /**
+     * Add the provided value to the list of values that the {@link Generator} will return.
+     * @param value The value to add to the {@link Generator}'s list of values.
+     */
+    addValue(value: T): void;
+
+    /**
+     * Add the provided values to the list of values that the {@link Generator} will return.
+     * @param returnValues The values to add to the {@link Generator}'s list of values.
+     */
+    addValues(returnValues: JavascriptIterable<T>): void;
+
+    /**
+     * Get whether the {@link Generator} currently has a value.
+     */
+    hasCurrent(): boolean;
+
+    /**
+     * Get the current value of the {@link Generator}.
+     */
+    getCurrent(): T;
+}
+
+class InnerGeneratorControl<T> implements GeneratorControl<T>
+{
+    private readonly returnValues: List<T>;
+    private done: boolean;
+
+    private constructor()
+    {
+        this.returnValues = List.create();
+        this.done = false;
+    }
+
+    public static create<T>(): InnerGeneratorControl<T>
+    {
+        return new InnerGeneratorControl<T>();
+    }
+
+    public addValue(returnValue: T): void
+    {
+        PreCondition.assertFalse(this.isDone(), "this.isDone()");
+
+        this.returnValues.add(returnValue);
+    }
+
+    public addValues(returnValues: JavascriptIterable<T>): void
+    {
+        PreCondition.assertFalse(this.isDone(), "this.isDone()");
+
+        this.returnValues.addAll(returnValues);
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.returnValues.any().await();
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+        PreCondition.assertFalse(this.isDone(), "this.isDone()");
+
+        return this.returnValues.first().await();
+    }
+
+    public removeCurrent(): void
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+        PreCondition.assertFalse(this.isDone(), "this.isDone()");
+
+        this.returnValues.removeFirst().await();
+    }
+
+    public setDone(): void
+    {
+        PreCondition.assertFalse(this.hasCurrent(), "this.hasCurrent()");
+        PreCondition.assertFalse(this.isDone(), "this.isDone()");
+
+        this.done = true;
+    }
+
+    public isDone(): boolean
+    {
+        return this.done;
+    }
+}
+
+export class Generator<T> implements Iterator<T>
+{
+    private readonly control: InnerGeneratorControl<T>;
+    private readonly generatorAction: (control: GeneratorControl<T>) => (void | T);
+    private started: boolean;
+
+    private constructor(generatorAction: (control: GeneratorControl<T>) => (void | T))
+    {
+        PreCondition.assertNotUndefinedAndNotNull(generatorAction, "generatorAction");
+
+        this.control = InnerGeneratorControl.create();
+        this.generatorAction = generatorAction;
+        this.started = false;
+    }
+
+    public static create<T>(generatorAction: (control: GeneratorControl<T>) => (void | T)): Generator<T>
+    {
+        return new Generator<T>(generatorAction);
+    }
+
+    public next(): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            if (!this.control.isDone())
+            {
+                if (!this.hasStarted())
+                {
+                    this.started = true;
+                }
+                else
+                {
+                    this.control.removeCurrent();
+                }
+
+                if (!this.control.hasCurrent())
+                {
+                    const actionResult: void | T = this.generatorAction(this.control);
+                    if (actionResult !== undefined)
+                    {
+                        this.control.addValue(actionResult);
+                    }
+
+                    if (!this.control.hasCurrent())
+                    {
+                        this.control.setDone();
+                    }
+                }
+            }
+
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.control.hasCurrent();
+    }
+
+    public getCurrent(): T
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.control.getCurrent();
+    }
+
+    public start(): SyncResult<this>
+    {
+        return Iterator.start<T, this>(this);
+    }
+
+    public takeCurrent(): SyncResult<T>
+    {
+        return Iterator.takeCurrent(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterator.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterator.getCount(this);
+    }
+
+    public toArray(): SyncResult<T[]>
+    {
+        return Iterator.toArray(this);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>
+    {
+        return Iterator.concatenate(this, ...toConcatenate);
+    }
+
+    public where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator<T>
+    {
+        return Iterator.where(this, condition);
+    }
+
+    public map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.flatMap(this, mapping);
+    }
+
+    public whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>
+    {
+        return Iterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>
+    {
+        return Iterator.whereInstanceOfType(this, type);
+    }
+
+    public first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
+    {
+        return Iterator.first(this, condition);
+    }
+
+    public last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>
+    {
+        return Iterator.last(this, condition);
+    }
+
+    public take(maximumToTake: number): Iterator<T>
+    {
+        return Iterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): Iterator<T>
+    {
+        return Iterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<T>
+    {
+        return Iterator[Symbol.iterator](this);
+    }
+}

package/sources/httpClient.ts

@@ -0,0 +1,36 @@
+import { FetchHttpClient } from "./fetchHttpClient";
+import { HttpOutgoingRequest } from "./httpOutgoingRequest";
+import { HttpIncomingResponse } from "./httpIncomingResponse";
+import { HttpMethod } from "./httpMethod";
+import { AsyncResult } from "./asyncResult";
+
+/**
+ * An object that can make HTTP network requests.
+ */
+export abstract class HttpClient
+{
+    public static create(): HttpClient
+    {
+        return FetchHttpClient.create();
+    }
+
+    /**
+     * Send the provided {@link HttpOutgoingRequest}.
+     * @param request The {@link HttpOutgoingRequest} to send.
+     */
+    public abstract sendRequest(request: HttpOutgoingRequest): AsyncResult<HttpIncomingResponse>;
+
+    /**
+     * Send a GET {@link HttpOutgoingRequest} to the provided URL.
+     * @param url The URL to send the GET {@link HttpOutgoingRequest} to.
+     */
+    public sendGetRequest(url: string): AsyncResult<HttpIncomingResponse>
+    {
+        return HttpClient.sendGetRequest(this, url);
+    }
+
+    public static sendGetRequest(httpClient: HttpClient, url: string): AsyncResult<HttpIncomingResponse>
+    {
+        return httpClient.sendRequest(HttpOutgoingRequest.create(HttpMethod.GET, url));
+    }
+}

package/sources/httpHeader.ts

@@ -0,0 +1,37 @@
+import { PreCondition } from "./preCondition";
+import { escapeAndQuote } from "./strings";
+
+export class HttpHeader
+{
+    private readonly name: string;
+    private readonly value: string;
+
+    private constructor(name: string, value: string)
+    {
+        PreCondition.assertNotEmpty(name, "name");
+        PreCondition.assertNotUndefinedAndNotNull(value, "value");
+
+        this.name = name;
+        this.value = value;
+    }
+
+    public static create(name: string, value: string): HttpHeader
+    {
+        return new HttpHeader(name, value);
+    }
+
+    public getName(): string
+    {
+        return this.name;
+    }
+
+    public getValue(): string
+    {
+        return this.value;
+    }
+
+    public toString(): string
+    {
+        return `${escapeAndQuote(this.name)}:${escapeAndQuote(this.value)}`;
+    }
+}