@everyonesoftware/common 1.0.0

package/sources/depthFirstSearch.ts

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

package/sources/disposable.ts

@@ -0,0 +1,31 @@
+import { SyncDisposable } from "./basicDisposable";
+import { AsyncResult } from "./asyncResult";
+
+/**
+ * An object that can be disposed.
+ */
+export abstract class Disposable
+{
+    /**
+     * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
+     * disposed.
+     * @param disposedFunction The function to invoke when the returned {@link Disposable} is
+     * disposed.
+     */
+    public static create(disposedFunction: () => void): SyncDisposable
+    {
+        return SyncDisposable.create(disposedFunction);
+    }
+
+    /**
+     * Synchronously clean up any resources that this object is using. This function will return
+     * true if this invocation disposed of the object. Subsequent calls to dispose() will return
+     * false.
+     */
+    public abstract dispose(): AsyncResult<boolean>;
+
+    /**
+     * Get whether this {@link Disposable} has been disposed yet.
+     */
+    public abstract isDisposed(): boolean;
+}

package/sources/emptyError.ts

@@ -0,0 +1,10 @@
+/**
+ * An {@link Error} that is created when something is empty.
+ */
+export class EmptyError extends Error
+{
+    public constructor(message?: string)
+    {
+        super(message);
+    }
+}

package/sources/english.ts

@@ -0,0 +1,45 @@
+import { Iterator } from "./iterator";
+import { JavascriptIterable } from "./javascript";
+import { PreCondition } from "./preCondition";
+
+export function andList(values: JavascriptIterable<string>): string
+{
+    return list("and", values);
+}
+
+export function orList(values: JavascriptIterable<string>): string
+{
+    return list("or", values);
+}
+
+function list(conjunction: string, values: JavascriptIterable<string>): string
+{
+    PreCondition.assertNotEmpty(conjunction, "conjunction");
+    PreCondition.assertNotUndefinedAndNotNull(values, "values");
+
+    let result: string = "";
+    let index = 0;
+    const iterator: Iterator<string> = Iterator.create(values).start().await();
+    while (iterator.hasCurrent())
+    {
+        const currentValue: string = iterator.takeCurrent().await();
+        if (index >= 1)
+        {
+            if (iterator.hasCurrent())
+            {
+                result += `, `;
+            }
+            else
+            {
+                if (index >= 2)
+                {
+                    result += `,`;
+                }
+                result += ` ${conjunction} `;
+            }
+        }
+        result += currentValue;
+        index++;
+    }
+    return result;
+}

package/sources/equalFunctions.ts

@@ -0,0 +1,123 @@
+import { Comparer } from "./comparer";
+import { Iterable } from "./iterable";
+import { isMap, Map } from "./map";
+import { PreCondition } from "./preCondition";
+import { SyncResult } from "./syncResult";
+import { getPropertyNames, hasProperty, isBoolean, isJavascriptIterable, isObject, isString } from "./types";
+
+/**
+ * A collection of {@link Function}s that can be used to determine if two values are equal.
+ */
+export class EqualFunctions
+{
+    private readonly equalFunctions: ((left: unknown, right: unknown) => (boolean | SyncResult<boolean> | undefined))[];
+
+    private constructor()
+    {
+        this.equalFunctions = [];
+    }
+
+    public static create(): EqualFunctions
+    {
+        return new EqualFunctions();
+    }
+
+    private defaultEqualFunction(left: unknown, right: unknown): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            let result: boolean | undefined = Comparer.equalSameUndefinedNull(left, right);
+            if (result === undefined)
+            {
+                result = false;
+
+                if (isMap(left))
+                {
+                    if (isMap(right))
+                    {
+                        result = Map.equals(left, right, this).await();
+                    }
+                }
+                else if (isJavascriptIterable(left) && !isString(left))
+                {
+                    if (isJavascriptIterable(right) && !isString(right) && !isMap(right))
+                    {
+                        result = Iterable.equals(left, right, this).await();
+                    }
+                }
+                else if (isObject(left))
+                {
+                    if (isObject(right))
+                    {
+                        result = true;
+
+                        for (const leftPropertyName of getPropertyNames(left))
+                        {
+                            if (!hasProperty(left, leftPropertyName) || !hasProperty(right, leftPropertyName))
+                            {
+                                result = false;
+                                break;
+                            }
+                            else
+                            {
+                                result = this.areEqual(left[leftPropertyName], right[leftPropertyName]).await();
+                            }
+                        }
+
+                        if (result)
+                        {
+                            for (const rightPropertyName of getPropertyNames(right))
+                            {
+                                if (!hasProperty(left, rightPropertyName) || !hasProperty(right, rightPropertyName))
+                                {
+                                    result = false;
+                                    break;
+                                }
+                                else
+                                {
+                                    result = this.areEqual(left[rightPropertyName], right[rightPropertyName]).await();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    /**
+     * Get whether the provided values are equal based on the registered equal {@link Function}s.
+     * @param left The left value in the comparison.
+     * @param right The right value in the comparison.
+     */
+    public areEqual(left: unknown, right: unknown): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            let result: boolean | SyncResult<boolean> | undefined;
+            for (const equalFunction of this.equalFunctions)
+            {
+                result = equalFunction(left, right);
+                if (result !== undefined)
+                {
+                    break;
+                }
+            }
+            if (result === undefined)
+            {
+                result = this.defaultEqualFunction(left, right);
+            }
+            return isBoolean(result) ? result : result.await();
+        });
+    }
+
+    public add(equalFunction: (left: unknown, right: unknown) => (boolean | undefined)): this
+    {
+        PreCondition.assertNotUndefinedAndNotNull(equalFunction, "equalFunction");
+
+        this.equalFunctions.unshift(equalFunction);
+
+        return this;
+    }
+}

package/sources/fetchHttpClient.ts

@@ -0,0 +1,89 @@
+import { FetchHttpIncomingResponse } from "./fetchHttpResponse";
+import { HttpClient } from "./httpClient";
+import { HttpOutgoingRequest } from "./httpOutgoingRequest";
+import { HttpHeader } from "./httpHeader";
+import { HttpMethod } from "./httpMethod";
+import { PostCondition } from "./postCondition";
+import { PreCondition } from "./preCondition";
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+
+/**
+ * A {@link HttpClient} that uses {@link fetch}() to make network requests.
+ */
+export class FetchHttpClient implements HttpClient
+{
+    protected constructor()
+    {
+    }
+
+    public static create(): FetchHttpClient
+    {
+        return new FetchHttpClient();
+    }
+
+    public sendRequest(request: HttpOutgoingRequest): PromiseAsyncResult<FetchHttpIncomingResponse>
+    {
+        PreCondition.assertNotUndefinedAndNotNull(request, "request");
+
+        return PromiseAsyncResult.create(async () =>
+        {
+            const requestInit: RequestInit = {
+                method: FetchHttpClient.convertMethod(request.getMethod()),
+                headers: request.getHeaders()
+                    .map<[string, string]>((header: HttpHeader) => [header.getName(), header.getValue()])
+                    .toArray()
+                    .await(),
+                body: request.getBody() || undefined,
+            };
+
+            const fetchResponse: Response = await fetch(request.getURL(), requestInit);
+            return FetchHttpIncomingResponse.create(fetchResponse);
+        });
+    }
+
+    public sendGetRequest(url: string): PromiseAsyncResult<FetchHttpIncomingResponse>
+    {
+        return this.sendRequest(HttpOutgoingRequest.create(HttpMethod.GET, url));
+    }
+
+    public static convertMethod(method: HttpMethod): string
+    {
+        PreCondition.assertNotUndefinedAndNotNull(method, "method");
+
+        let result: string;
+        switch (method)
+        {
+            case HttpMethod.CONNECT:
+                result = "CONNECT";
+                break;
+            case HttpMethod.DELETE:
+                result = "DELETE";
+                break;
+            case HttpMethod.GET:
+                result = "GET";
+                break;
+            case HttpMethod.HEAD:
+                result = "HEAD";
+                break;
+            case HttpMethod.OPTIONS:
+                result = "OPTIONS";
+                break;
+            case HttpMethod.PATCH:
+                result = "PATCH";
+                break;
+            case HttpMethod.POST:
+                result = "POST";
+                break;
+            case HttpMethod.PUT:
+                result = "PUT";
+                break;
+            case HttpMethod.TRACE:
+                result = "TRACE";
+                break;
+        }
+
+        PostCondition.assertNotEmpty(result, "result");
+
+        return result;
+    }
+}

package/sources/fetchHttpResponse.ts

@@ -0,0 +1,106 @@
+import { PromiseAsyncResult } from "./promiseAsyncResult";
+import { HttpHeader } from "./httpHeader";
+import { HttpHeaders } from "./httpHeaders";
+import { HttpIncomingResponse } from "./httpIncomingResponse";
+import { MutableHttpHeaders } from "./mutableHttpHeaders";
+import { NotFoundError } from "./notFoundError";
+import { PreCondition } from "./preCondition";
+import { escapeAndQuote } from "./strings";
+import { SyncResult } from "./syncResult";
+
+/**
+ * An {@link HttpIncomingResponse} that comes from a {@link FetchHttpClient}.
+ */
+export class FetchHttpIncomingResponse extends HttpIncomingResponse
+{
+    private readonly response: Response;
+
+    private constructor(response: Response)
+    {
+        PreCondition.assertNotUndefinedAndNotNull(response, "response");
+
+        super();
+
+        this.response = response;
+    }
+
+    public static create(response: Response): FetchHttpIncomingResponse
+    {
+        return new FetchHttpIncomingResponse(response);
+    }
+
+    public getStatusCode(): number
+    {
+        return this.response.status;
+    }
+
+    public getHeaders(): SyncResult<HttpHeaders>
+    {
+        return SyncResult.create(() =>
+        {
+            const result: MutableHttpHeaders = HttpHeaders.create();
+            for (const header of this.response.headers)
+            {
+                result.set(header[0], header[1]);
+            }
+            return result;
+        });
+    }
+
+    public getHeader(headerName: string): SyncResult<HttpHeader>
+    {
+        PreCondition.assertNotEmpty(headerName, "headerName");
+
+        return SyncResult.create(() =>
+        {
+            let result: HttpHeader | undefined;
+
+            const lowerHeaderName: string = headerName.toLowerCase();
+            for (const header of this.response.headers)
+            {
+                if (lowerHeaderName === header[0].toLowerCase())
+                {
+                    result = HttpHeader.create(header[0], header[1]);
+                    break;
+                }
+            }
+            if (result === undefined)
+            {
+                throw new NotFoundError(`Could not find a header with the name ${escapeAndQuote(headerName)}.`)
+            }
+
+            return result;
+        });
+    }
+    
+    public getHeaderValue(headerName: string): SyncResult<string>
+    {
+        PreCondition.assertNotEmpty(headerName, "headerName");
+
+        return SyncResult.create(() =>
+        {
+            let result: string | undefined;
+
+            const lowerHeaderName: string = headerName.toLowerCase();
+            for (const header of this.response.headers)
+            {
+                if (lowerHeaderName === header[0].toLowerCase())
+                {
+                    result = header[1];
+                    break;
+                }
+            }
+            if (result === undefined)
+            {
+                throw new NotFoundError(`Could not find a header with the name ${escapeAndQuote(headerName)}.`)
+            }
+
+            return result;
+        });
+    }
+
+    public getBody(): PromiseAsyncResult<string>
+    {
+        return PromiseAsyncResult.create(this.response.text());
+    }
+}