@everyonesoftware/common 3.0.0 → 4.0.0

package/sources/mutableMap.ts

@@ -1,292 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { JavascriptMapMap } from "./javascriptMapMap";
-import { NotFoundError } from "./notFoundError";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { hasFunction, Type } from "./types";
-import { isMap, Map, MapEntry } from "./map";
-
-/**
- * Get whether the provided value is {@link Map}.
- * @param value The value to check.
- */
-export function isMutableMap(value: unknown): value is MutableMap<unknown, unknown>
-{
-    return value instanceof MutableMap ||
-        (
-            isMap(value) && 
-            hasFunction(value, "set", 2) &&
-            hasFunction(value, "getOrSet", 2)
-        );
-}
-
-/**
- * A type that maps {@link TKey} values to {@link TValue} values.
- */
-export abstract class MutableMap<TKey, TValue> implements Map<TKey, TValue>
-{
-    /**
-     * Create a new instance of the default {@link Map} implementation.
-     */
-    public static create<TKey, TValue>(): MutableMap<TKey, TValue>
-    {
-        return JavascriptMapMap.create();
-    }
-
-    /**
-     * Iterate over the entries in this {@link MutableMap}.
-     */
-    public abstract iterate(): Iterator<MapEntry<TKey, TValue>>;
-
-    public any(): SyncResult<boolean>
-    {
-        return MutableMap.any(this);
-    }
-
-    public static any<TKey,TValue>(map: MutableMap<TKey,TValue>): SyncResult<boolean>
-    {
-        return Map.any(map);
-    }
-
-    public toArray(): SyncResult<MapEntry<TKey, TValue>[]>
-    {
-        return MutableMap.toArray(this);
-    }
-
-    public static toArray<TKey,TValue>(map: MutableMap<TKey,TValue>): SyncResult<MapEntry<TKey,TValue>[]>
-    {
-        return Map.toArray(map);
-    }
-
-    public equals(right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return MutableMap.equals(this, right, equalFunctions);
-    }
-
-    public static equals<TKey, TValue>(left: MutableMap<TKey, TValue>, right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Map.equals(left, right, equalFunctions);
-    }
-
-    /**
-     * Get the {@link String} representation of this {@link MutableMap}.
-     */
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return MutableMap.toString(this, toStringFunctions);
-    }
-
-    /**
-     * Get the {@link String} representation of the provided {@link MutableMap}.
-     */
-    public static toString<TKey, TValue>(map: MutableMap<TKey, TValue>, toStringFunctions?: ToStringFunctions): string
-    {
-        return Map.toString(map, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.concatenate(this, ...toConcatenate);
-    }
-
-    public static concatenate<TKey,TValue>(map: MutableMap<TKey,TValue>, ...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>
-    {
-        return Map.concatenate(map, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return MutableMap.map(this, mapping);
-    }
-
-    public static map<TKey,TValue,TOutput>(map: MutableMap<TKey,TValue>, mapping: (value: MapEntry<TKey,TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return Map.map(map, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return MutableMap.flatMap(this, mapping);
-    }
-
-    public static flatMap<TKey,TValue,TOutput>(map: MutableMap<TKey,TValue>, mapping: (value: MapEntry<TKey,TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Map.flatMap(map, mapping);
-    }
-
-    public where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.where(this, condition);
-    }
-
-    public static where<TKey,TValue>(map: MutableMap<TKey,TValue>, condition: (value: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey,TValue>>
-    {
-        return Map.where(map, condition);
-    }
-
-    public instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>
-    {
-        return MutableMap.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public static instanceOf<TKey,TValue,T extends MapEntry<TKey, TValue>>(map: MutableMap<TKey,TValue>, typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>
-    {
-        return Map.instanceOf(map, typeOrTypeCheck);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>
-    {
-        return MutableMap[Symbol.iterator](this);
-    }
-
-    public static [Symbol.iterator]<TKey,TValue>(map: MutableMap<TKey,TValue>): JavascriptIterator<MapEntry<TKey,TValue>>
-    {
-        return Map[Symbol.iterator](map);
-    }
-
-    /**
-     * Get the number of entries in this {@link MutableMap}.
-     */
-    public getCount(): SyncResult<number>
-    {
-        return MutableMap.getCount(this);
-    }
-
-    public static getCount<TKey,TValue>(map: MutableMap<TKey,TValue>): SyncResult<number>
-    {
-        return Map.getCount(map);
-    }
-
-    public first(condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.first(this, condition);
-    }
-
-    public static first<TKey,TValue>(map: MutableMap<TKey,TValue>, condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return Map.first(map, condition);
-    }
-
-    public last(condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return MutableMap.last(this, condition);
-    }
-
-    public static last<TKey,TValue>(map: MutableMap<TKey,TValue>, condition?: (entry: MapEntry<TKey,TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>
-    {
-        return Map.last(map, condition);
-    }
-
-    /**
-     * Get whether this {@link MutableMap} contains the provided key.
-     * @param key The key to look for.
-     */
-    public abstract containsKey(key: TKey): SyncResult<boolean>;
-
-    /**
-     * Get the value associated with the provided key.
-     * @param key The key of the value to get.
-     */
-    public abstract get(key: TKey): SyncResult<TValue>;
-
-    /**
-     * Set the key/value association in this {@link MutableMap}.
-     * @param key The key associated with the value.
-     * @param value The value associated with the key.
-     */
-    public abstract set(key: TKey, value: TValue): this;
-
-    /**
-     * Get the {@link TValue} associated with the provided {@link TKey}. If the provided
-     * {@link TKey} doesn't exist in this {@link MutableMap}, then invoke the provided {@link valueCreator}
-     * and associate the returned {@link TValue} with the provided {@link TKey}. Then return the new
-     * {@link TValue}.
-     * @param key The {@link TKey} of the {@link TValue} to get.
-     * @param valueCreator The {@link Function} that will be invoked if the {@link TKey} doesn't
-     * exist in this {@link MutableMap}.
-     */
-    public getOrSet(key: TKey, valueCreator: () => (TValue | SyncResult<TValue>)): SyncResult<TValue>
-    {
-        return MutableMap.getOrSet(this, key, valueCreator);
-    }
-
-    /**
-     * Get the {@link TValue} associated with the provided {@link TKey}. If the provided
-     * {@link TKey} doesn't exist in the {@link MutableMap}, then invoke the provided {@link valueCreator}
-     * and associate the returned {@link TValue} with the provided {@link TKey}. Then return the new
-     * {@link TValue}.
-     * @param key The {@link TKey} of the {@link TValue} to get.
-     * @param valueCreator The {@link Function} that will be invoked if the {@link TKey} doesn't
-     * exist in this {@link MutableMap}.
-     */
-    public static getOrSet<TKey, TValue>(map: MutableMap<TKey, TValue>, key: TKey, valueCreator: () => (TValue | SyncResult<TValue>)): SyncResult<TValue>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(map, "map");
-        PreCondition.assertNotUndefinedAndNotNull(valueCreator, "valueCreator");
-
-        return map.get(key)
-            .catch(NotFoundError, () =>
-            {
-                const creatorResult: TValue | SyncResult<TValue> = valueCreator();
-                const value: TValue = creatorResult instanceof SyncResult ? creatorResult.await() : creatorResult;
-                map.set(key, value);
-                return value;
-            });
-    }
-
-    /**
-     * Remove the provided {@link TKey} from this {@link MutableMap}. If the {@link TKey} doesn't exist in
-     * this {@link MutableMap}, then return a {@link NotFoundError}. If the {@link TKey} does exist, then
-     * return the {@link TValue} that was associated with it.
-     * @param key The {@link TKey} to remove from this {@link MutableMap}.
-     */
-    public abstract remove(key: TKey): SyncResult<TValue>;
-
-    /**
-     * Iterate over the keys in this {@link MutableMap}.
-     */
-    public iterateKeys(): Iterator<TKey>
-    {
-        return MutableMap.iterateKeys(this);
-    }
-
-    /**
-     * Iterate over the keys in the {@link MutableMap}.
-     * @param map The map to iterate over.
-     */
-    public static iterateKeys<TKey, TValue>(map: MutableMap<TKey, TValue>): Iterator<TKey>
-    {
-        return Map.iterateKeys(map);
-    }
-
-    /**
-     * Iterate over the values in this {@link MutableMap}.
-     */
-    public iterateValues(): Iterator<TValue>
-    {
-        return MutableMap.iterateValues(this);
-    }
-
-    /**
-     * Iterate over the keys in the {@link MutableMap}.
-     * @param map The map to iterate over.
-     */
-    public static iterateValues<TKey, TValue>(map: MutableMap<TKey, TValue>): Iterator<TValue>
-    {
-        return Map.iterateValues(map);
-    }
-
-    public contains(value: MapEntry<TKey,TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return MutableMap.contains(this, value, equalFunctions);
-    }
-
-    public static contains<TKey,TValue>(map: MutableMap<TKey,TValue>, value: MapEntry<TKey,TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Map.contains(map, value, equalFunctions);
-    }
-}

package/sources/network.ts

@@ -1,18 +0,0 @@
-import { HttpClient } from "./httpClient";
-import { HttpServer } from "./httpServer";
-
-/**
- * An object that provides access to the network.
- */
-export abstract class Network
-{
-    /**
-     * Create a new {@link HttpServer} that is connected to this {@link Network}.
-     */
-    public abstract createHttpServer(): HttpServer;
-
-    /**
-     * Create a new {@link HttpClient} that is connected to this {@link Network}.
-     */
-    public abstract createHttpClient(): HttpClient;
-}

package/sources/node.ts

@@ -1,37 +0,0 @@
-import { Iterator } from "./iterator";
-import { PreCondition } from "./preCondition";
-import { Set } from "./set";
-
-export class Node<T>
-{
-    private readonly value: T;
-    private connectedNodes: Set<Node<T>>;
-
-    private constructor(value: T)
-    {
-        this.value = value;
-        this.connectedNodes = Set.create();
-    }
-
-    public static create<T>(value: T): Node<T>
-    {
-        return new Node<T>(value);
-    }
-
-    public getValue(): T
-    {
-        return this.value;
-    }
-
-    public iterateConnectedNodes(): Iterator<Node<T>>
-    {
-        return this.connectedNodes.iterate();
-    }
-
-    public addConnectedNode(node: Node<T>): void
-    {
-        PreCondition.assertNotUndefinedAndNotNull(node, "node");
-
-        this.connectedNodes.add(node);
-    }
-}

package/sources/nodeJSCharacterWriteStream.ts

@@ -1,42 +0,0 @@
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { CharacterWriteStream } from "./characterWriteStream";
-import { PreCondition } from "./preCondition";
-
-export class NodeJSCharacterWriteStream extends CharacterWriteStream
-{
-    private readonly nodeJSWriteStream: NodeJS.WriteStream;
-
-    private constructor(nodeJSWriteStream: NodeJS.WriteStream)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(nodeJSWriteStream, "nodeJSWriteStream");
-
-        super();
-
-        this.nodeJSWriteStream = nodeJSWriteStream;
-    }
-
-    public static create(nodeJSWriteStream: NodeJS.WriteStream): NodeJSCharacterWriteStream
-    {
-        return new NodeJSCharacterWriteStream(nodeJSWriteStream);
-    }
-
-    public writeString(text: string): PromiseAsyncResult<number>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(text, "text");
-
-        return PromiseAsyncResult.create(new Promise<number>((resolve, reject) =>
-        {
-            this.nodeJSWriteStream.write(text, (error?: Error | null) =>
-            {
-                if (error)
-                {
-                    reject(error);
-                }
-                else
-                {
-                    resolve(text.length);
-                }
-            });
-        }));
-    }
-}

package/sources/nodeJSHttpIncomingRequest.ts

@@ -1,132 +0,0 @@
-import { HttpIncomingRequest } from "./httpIncomingRequest";
-import * as http from "http";
-import { PreCondition } from "./preCondition";
-import { HttpHeader } from "./httpHeader";
-import { HttpHeaders } from "./httpHeaders";
-import { HttpMethod, parseHttpMethod } from "./httpMethod";
-import { NotFoundError } from "./notFoundError";
-import { isArray } from "./types";
-import { escapeAndQuote } from "./strings";
-import { SyncResult } from "./syncResult";
-import { AsyncResult } from "./asyncResult";
-
-export class NodeJSHttpIncomingRequest extends HttpIncomingRequest
-{
-    private readonly request: http.IncomingMessage;
-
-    private constructor(request: http.IncomingMessage)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(request, "request");
-
-        super();
-
-        this.request = request;
-    }
-
-    public static create(request: http.IncomingMessage): NodeJSHttpIncomingRequest
-    {
-        return new NodeJSHttpIncomingRequest(request);
-    }
-
-    public getMethod(): HttpMethod
-    {
-        return parseHttpMethod(this.request.method!).await();
-    }
-
-    public getHost(): SyncResult<string>
-    {
-        return SyncResult.value(process.env.HOST ?? "localhost");
-    }
-
-    public getURLPath(): string
-    {
-        const url: URL = new URL(this.request.url!);
-        return url.pathname;
-    }
-
-    private static toHttpHeader(header: [string, string | string[] | undefined]): HttpHeader
-    {
-        const headerName: string = header[0];
-        const headerValue: string = this.toHttpHeaderValue(header[1]);
-        return HttpHeader.create(headerName, headerValue);
-    }
-
-    private static toHttpHeaderValue(headerValue: string | string[] | undefined): string
-    {
-        let result: string | string[] | undefined = headerValue;
-        if (result === undefined)
-        {
-            result = "";
-        }
-        else if (isArray(result))
-        {
-            result = result.join(",");
-        }
-        return result;
-    }
-
-    public getHeaders(): SyncResult<HttpHeaders>
-    {
-        return SyncResult.value(HttpHeaders.create(Object.entries(this.request.headers).map(NodeJSHttpIncomingRequest.toHttpHeader)));
-    }
-
-    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 Object.entries(this.request.headers))
-            {
-                if (header[0].toLowerCase() === lowerHeaderName)
-                {
-                    result = HttpHeader.create(header[0], NodeJSHttpIncomingRequest.toHttpHeaderValue(header[1]));
-                    break;
-                }
-            }
-            if (result === undefined)
-            {
-                throw new NotFoundError(`No header with the name ${escapeAndQuote(headerName)} found.`);
-            }
-
-            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 Object.entries(this.request.headers))
-            {
-                if (header[0].toLowerCase() === lowerHeaderName)
-                {
-                    result = NodeJSHttpIncomingRequest.toHttpHeaderValue(header[1]);
-                    break;
-                }
-            }
-            if (result === undefined)
-            {
-                throw new NotFoundError(`No header with the name ${escapeAndQuote(headerName)} found.`);
-            }
-
-            return result;
-        });
-    }
-
-    public getBody(): SyncResult<string>
-    {
-        return SyncResult.create(() =>
-        {
-            throw new NotFoundError("Could not read the body from the incoming HTTP request.");
-        });
-    }
-}

package/sources/nodeJSHttpServer.ts

@@ -1,134 +0,0 @@
-import * as http from "http";
-
-import { HttpServer } from "./httpServer";
-import { HttpIncomingRequest } from "./httpIncomingRequest";
-import { HttpOutgoingResponse } from "./httpOutgoingResponse";
-import { PreCondition } from "./preCondition";
-import { HttpHeaders } from "./httpHeaders";
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { AsyncResult } from "./asyncResult";
-
-/**
- * A {@link HttpServer} implementation that uses the Node.js HTTP module.
- */
-export class NodeJSHttpServer extends HttpServer
-{
-    private httpServer: http.Server | undefined;
-    private disposed: boolean;
-
-    private constructor()
-    {
-        super();
-
-        this.disposed = false;
-    }
-
-    public static create(): NodeJSHttpServer
-    {
-        return new NodeJSHttpServer();
-    }
-
-    public dispose(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(new Promise<boolean>((resolve, reject) =>
-        {
-            if (this.disposed)
-            {
-                resolve(false);
-            }
-            else if (!this.httpServer)
-            {
-                this.disposed = true;
-                resolve(true);
-            }
-            else
-            {
-                this.httpServer.close((error?: Error) =>
-                {
-                    if (error)
-                    {
-                        reject(error);
-                    }
-                    else
-                    {
-                        this.disposed = true;
-                        this.httpServer = undefined;
-                        resolve(true);
-                    }
-                });
-            }
-        }));
-    }
-
-    public isDisposed(): boolean
-    {
-        return this.disposed;
-    }
-
-    public isStarted(): boolean
-    {
-        return !!this.httpServer;
-    }
-
-    public addRequestHandler(requestPath: string, handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void
-    {
-        throw new Error("Method not implemented.");
-    }
-
-    public setDefaultRequestHandler(handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void
-    {
-        throw new Error("Method not implemented.");
-    }
-
-    public start(portNumber: number): PromiseAsyncResult<void>
-    {
-        PreCondition.assertGreaterThanOrEqualTo(portNumber, 1, "portNumber");
-        PreCondition.assertFalse(this.isDisposed(), "this.isDisposed()");
-        PreCondition.assertUndefined(this.httpServer, "this.httpServer");
-
-        return PromiseAsyncResult.create(new Promise<void>((resolve, reject) =>
-        {
-            if (this.httpServer)
-            {
-                reject(new Error("Can't run a HttpServer multiple times."));
-            }
-            else
-            {
-                this.httpServer = http.createServer();
-
-                this.httpServer.on("request", (request: http.IncomingMessage, response: http.ServerResponse<http.IncomingMessage> & { req: http.IncomingMessage }) =>
-                {
-                    // const httpRequest: HttpIncomingRequest = NodeJSHttpIncomingRequest.create(request);
-                    const httpResponse: HttpOutgoingResponse = HttpOutgoingResponse.create()
-                        .setStatusCode(200)
-                        .setHeader("Content-Type", "text/plain")
-                        .setBody("Hello world!");
-
-                    const statusCode: number = httpResponse.getStatusCode();
-                    const headers: HttpHeaders = httpResponse.getHeaders();
-
-                    const responseHeaders: http.OutgoingHttpHeaders = {};
-                    for (const header of headers)
-                    {
-                        responseHeaders[header.getName()] = header.getValue();
-                    }
-
-                    response.writeHead(statusCode, responseHeaders);
-                    response.end(httpResponse.getBody());
-                });
-
-                this.httpServer.on("close", () =>
-                {
-                    resolve();
-                });
-
-                this.httpServer.on("error", (error: Error) =>
-                {
-                    reject(error);
-                });
-
-                this.httpServer.listen(portNumber);
-            }
-        }));
-    }
-}

package/sources/notFoundError.ts

@@ -1,12 +0,0 @@
-import { join } from "./strings";
-
-/**
- * An {@link Error} that is thrown when a value is not found.
- */
-export class NotFoundError extends Error
-{
-    public constructor(...message: string[])
-    {
-        super(join("\n", message));
-    }
-}