@everyonesoftware/common 3.0.0 → 4.0.0

package/sources/depthFirstSearch.ts

@@ -1,230 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1,45 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

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