@everyonesoftware/common 2.0.0 → 4.0.0

package/sources/promiseAsyncResult.ts

@@ -1,174 +0,0 @@
-import { PreCondition } from "./preCondition";
-import { AsyncResult } from "./asyncResult";
-import { instanceOfType, isPromise, isUndefinedOrNull, Type } from "./types";
-
-export class PromiseAsyncResult<T> implements AsyncResult<T>
-{
-    private readonly promise: Promise<T>;
-
-    private constructor(promise: Promise<T>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(promise, "promise");
-
-        this.promise = promise;
-    }
-
-    public static create<T>(action: () => (T | Promise<T>)): PromiseAsyncResult<T>;
-    public static create<T>(promise: Promise<T>): PromiseAsyncResult<T>;
-    static create<T>(actionOrPromise: (() => (T | Promise<T>)) | Promise<T>): PromiseAsyncResult<T>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(actionOrPromise, "action or promise");
-
-        return new PromiseAsyncResult(Promise.resolve(isPromise<T>(actionOrPromise) ? actionOrPromise : actionOrPromise()));
-    }
-
-    public static value<T>(value: T): PromiseAsyncResult<T>
-    {
-        return PromiseAsyncResult.create(Promise.resolve(value));
-    }
-
-    public static error<T>(error: unknown): PromiseAsyncResult<T>
-    {
-        return PromiseAsyncResult.create(Promise.reject(error));
-    }
-
-    public static yield(): PromiseAsyncResult<void>
-    {
-        return PromiseAsyncResult.create(Promise.resolve());
-    }
-
-    public then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseAsyncResult<TResult1 | TResult2>
-    {
-        return PromiseAsyncResult.create(this.promise.then(onfulfilled, onrejected));
-    }
-
-    public onValue(onValueFunction: (value: T) => (void | Promise<void>)): PromiseAsyncResult<T>
-    {
-        return this.then<T>(async (value: T) =>
-        {
-            let result: PromiseAsyncResult<T>;
-            try
-            {
-                await onValueFunction(value);
-                result = this;
-            }
-            catch (error)
-            {
-                result = PromiseAsyncResult.error(error);
-            }
-            return result;
-        })
-    }
-
-    public catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>
-    public catch<TError,TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => (TResult | PromiseLike<TResult>)): PromiseAsyncResult<T | TResult>
-    catch<TResult = never>(errorTypeOrOnRejected?: Type<Error> | ((reason: unknown) => TResult | PromiseLike<TResult>) | null, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>
-    {
-        let errorType: Type<Error> | undefined;
-        if (!isUndefinedOrNull(onrejected))
-        {
-            errorType = errorTypeOrOnRejected as Type<unknown>;
-
-            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-        }
-        else
-        {
-            onrejected = errorTypeOrOnRejected as ((reason: any) => TResult | PromiseLike<TResult>) | null;
-        }
-
-        return PromiseAsyncResult.create<T | TResult>(this.promise.catch((reason: unknown) =>
-        {
-            let value: TResult | PromiseLike<TResult> | undefined;
-            if (errorType && !instanceOfType(reason, errorType))
-            {
-                throw reason;
-            }
-            else if (!isUndefinedOrNull(onrejected))
-            {
-                value = onrejected(reason);
-            }
-            return value!;
-        }));
-    }
-
-    public onError(onErrorFunction: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
-    public onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
-    onError(errorTypeOrOnErrorFunction: Type<unknown> | ((reason: unknown) => (void | PromiseLike<void>)), onErrorFunction?: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>
-    {
-        let errorType: Type<unknown> | undefined;
-        if (!isUndefinedOrNull(onErrorFunction))
-        {
-            errorType = errorTypeOrOnErrorFunction as Type<unknown>;
-
-            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-        }
-        else
-        {
-            onErrorFunction = errorTypeOrOnErrorFunction as ((reason: unknown) => void | PromiseLike<void>);
-        }
-        PreCondition.assertNotUndefinedAndNotNull(onErrorFunction, "onErrorFunction");
-
-        let result: PromiseAsyncResult<T>;
-        if (errorType)
-        {
-            result = this.catch(errorType, async (reason: unknown) =>
-            {
-                await onErrorFunction(reason);
-                throw reason;
-            });
-        }
-        else
-        {
-            result = this.catch(async (reason: unknown) =>
-            {
-                await onErrorFunction(reason);
-                throw reason;
-            });
-        }
-
-        return result;
-    }
-
-    public convertError(convertErrorFunction: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
-    public convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
-    convertError(errorTypeOrConvertErrorFunction: Type<unknown> | ((reason: unknown) => (unknown | PromiseLike<unknown>)), convertErrorFunction?: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>
-    {
-        let errorType: Type<unknown> | undefined;
-        if (!isUndefinedOrNull(convertErrorFunction))
-        {
-            errorType = errorTypeOrConvertErrorFunction as Type<unknown>;
-
-            PreCondition.assertNotUndefinedAndNotNull(errorType, "errorType");
-        }
-        else
-        {
-            convertErrorFunction = errorTypeOrConvertErrorFunction as ((reason: unknown) => void | PromiseLike<void>);
-        }
-        PreCondition.assertNotUndefinedAndNotNull(convertErrorFunction, "convertErrorFunction");
-
-        let result: PromiseAsyncResult<T>;
-        if (errorType)
-        {
-            result = this.catch(errorType, async (reason: unknown) =>
-            {
-                throw await convertErrorFunction(reason);
-            });
-        }
-        else
-        {
-            result = this.catch(async (reason: unknown) =>
-            {
-                throw await convertErrorFunction(reason);
-            });
-        }
-
-        return result;
-    }
-
-    public finally(onfinally?: (() => (void | Promise<void>)) | null): PromiseAsyncResult<T>
-    {
-        return PromiseAsyncResult.create(this.promise.finally(onfinally));
-    }
-    
-    readonly [Symbol.toStringTag]: string = "AsyncResult";
-}

package/sources/property.ts

@@ -1,63 +0,0 @@
-import { PreCondition } from "./preCondition";
-import { hasProperty, isFunction, isObject } from "./types";
-
-export class Property<T>
-{
-    private readonly getter: () => T;
-    private readonly setter: (value: T) => void;
-
-    private constructor(getter: () => T, setter: (value: T) => void)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
-        PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
-
-        this.getter = getter;
-        this.setter = setter;
-    }
-
-    public static create<T>(getter: () => T, setter: (value: T) => void): Property<T>;
-    public static create<T>(options: { getter: () => T, setter: (value: T) => void }): Property<T>;
-    public static create<T>(initialValue: T): Property<T>;
-    static create<T>(getterOptionsOrInitialValue: (() => T) | { getter: () => T, setter: (value: T) => void } | T, setter?: (value: T) => void): Property<T>
-    {
-        let getter: () => T;
-        if (isFunction(getterOptionsOrInitialValue))
-        {
-            getter = getterOptionsOrInitialValue;
-        }
-        else if (isObject(getterOptionsOrInitialValue) &&
-            hasProperty(getterOptionsOrInitialValue, "getter") &&
-            hasProperty(getterOptionsOrInitialValue, "setter"))
-        {
-            const options: { getter: () => T, setter: (value: T) => void } = getterOptionsOrInitialValue;
-            getter = options.getter;
-            setter = options.setter;
-        }
-        else
-        {
-            let initialValue: T = getterOptionsOrInitialValue;
-            getter = () => { return initialValue; };
-            setter = (value: T) => { initialValue = value; };
-        }
-        PreCondition.assertNotUndefinedAndNotNull(getter, "getter");
-        PreCondition.assertNotUndefinedAndNotNull(setter, "setter");
-
-        return new Property<T>(getter, setter);
-    }
-
-    public getValue(): T
-    {
-        return this.getter();
-    }
-
-    public setValue(value: T): this
-    {
-        this.setter(value);
-        return this;
-    }
-
-    public toString(): string
-    {
-        return `${this.getValue()}`;
-    }
-}

package/sources/queue.ts

@@ -1,49 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { JavascriptIterable } from "./javascript";
-import { ListQueue } from "./listQueue";
-import { ListStack } from "./listStack";
-import { AsyncResult } from "./asyncResult";
-
-/**
- * A data structure that stores values in a first-in-first-out order.
- */
-export abstract class Queue<T>
-{
-    /**
-     * Create an instance of the default {@link Queue} implementation.
-     * @returns A new {@link Queue} object.
-     */
-    public static create<T>(): ListQueue<T>
-    {
-        return ListQueue.create();
-    }
-
-    /**
-     * Get whether there are any values in this {@link Stack}.
-     */
-    public abstract any(): AsyncResult<boolean>;
-
-    /**
-     * Add the provided value onto the end of this {@link Queue}.
-     * @param value The value to add to the end of this {@link Queue}.
-     */
-    public abstract add(value: T): AsyncResult<void>;
-
-    /**
-     * Add the provided values to the end of this {@link Queue}.
-     * @param values The values to add to the end of this {@link Queue}.
-     */
-    public abstract addAll(values: JavascriptIterable<T>): AsyncResult<void>;
-
-    /**
-     * Remove the next value off of this {@link Queue}.
-     */
-    public abstract remove(): AsyncResult<T>;
-
-    /**
-     * Get whether this {@link Stack} contains the provided value.
-     * @param value The value to look for.
-     * @param equalFunctions The functions to use to compare values.
-     */
-    public abstract contains(value: T, equalFunctions?: EqualFunctions): AsyncResult<boolean>;
-}

package/sources/realNetwork.ts

@@ -1,28 +0,0 @@
-import { FetchHttpClient } from "./fetchHttpClient";
-import { HttpClient } from "./httpClient";
-import { HttpServer } from "./httpServer";
-import { Network } from "./network";
-import { NodeJSHttpServer } from "./nodeJSHttpServer";
-
-export class RealNetwork extends Network
-{
-    private constructor()
-    {
-        super();
-    }
-
-    public static create(): RealNetwork
-    {
-        return new RealNetwork();
-    }
-
-    public createHttpServer(): HttpServer
-    {
-        return NodeJSHttpServer.create();
-    }
-
-    public createHttpClient(): HttpClient
-    {
-        return FetchHttpClient.create();
-    }
-}

package/sources/recreationDotGovClient.ts

@@ -1,259 +0,0 @@
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { DateTime } from "./dateTime";
-import { HttpClient } from "./httpClient";
-import { HttpIncomingResponse } from "./httpIncomingResponse";
-import { HttpOutgoingRequest } from "./httpOutgoingRequest";
-import { Iterable } from "./iterable";
-import { List } from "./list";
-import { PreCondition } from "./preCondition";
-import { AsyncResult } from "./asyncResult";
-
-export interface RecreationDotGovDivisionDayAvailability
-{
-    readonly date: DateTime;
-
-    readonly walkup: boolean;
-
-    readonly reservationsRemaining: number;
-
-    readonly totalSpots: number;
-}
-
-export interface RecreationDotGovDivisionAvailabilityJson
-{
-    readonly bools: { [date: string]: boolean };
-
-    readonly rules: {
-        readonly name: string;
-        readonly value: number;
-    }[];
-
-    readonly quota_type_maps: {
-        readonly ConstantQuotaUsageDaily?: {
-            [date: string]: {
-                readonly is_hidden: boolean;
-                readonly remaining: number;
-                readonly season_type: string;
-                readonly show_walkup: boolean;
-                readonly total: number;
-            };
-        };
-        readonly QuotaUsageByMemberDaily?: {
-            [date: string]: {
-                readonly is_hidden: boolean;
-                readonly remaining: number;
-                readonly season_type: string;
-                readonly show_walkup: boolean;
-                readonly total: number;
-            };
-        };
-    };
-}
-
-export class RecreationDotGovDivisionAvailability
-{
-    public readonly json: RecreationDotGovDivisionAvailabilityJson;
-
-    public readonly minimumGroupSize?: number;
-    public readonly maximumGroupSize?: number;
-    public readonly dayAvailabilities: Iterable<RecreationDotGovDivisionDayAvailability>;
-
-    private constructor(json: RecreationDotGovDivisionAvailabilityJson)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(json, "json");
-
-        this.json = json;
-
-        const minGroupSize: string = "MinGroupSize".toLowerCase();
-        const maxGroupSize: string = "MaxGroupSize".toLowerCase();
-        for (const rule of json.rules)
-        {
-            switch (rule.name.toLowerCase())
-            {
-                case minGroupSize:
-                    this.minimumGroupSize = rule.value;
-                    break;
-
-                case maxGroupSize:
-                    this.maximumGroupSize = rule.value;
-                    break;
-            }
-        }
-
-        const dayAvailabilities = List.create<RecreationDotGovDivisionDayAvailability>();
-        const quotaUsageByMemberDaily = json.quota_type_maps?.QuotaUsageByMemberDaily;
-        if (quotaUsageByMemberDaily)
-        {
-            for (const quotaUsage of Object.entries(quotaUsageByMemberDaily))
-            {
-                const dateString: string = quotaUsage[0];
-
-                const usageData = quotaUsage[1];
-
-                let walkup: boolean = false;
-                let reservationsRemaining: number = 0;
-                const boolsEntry: boolean = json.bools[dateString];
-                if (boolsEntry)
-                {
-                    walkup = usageData.show_walkup;
-                    reservationsRemaining = usageData.remaining;
-                }
-
-                dayAvailabilities.add({
-                    date: DateTime.parse(dateString),
-                    totalSpots: usageData.total,
-                    walkup,
-                    reservationsRemaining,
-                });
-            }
-        }
-        this.dayAvailabilities = dayAvailabilities;
-    }
-
-    public static create(json: RecreationDotGovDivisionAvailabilityJson): RecreationDotGovDivisionAvailability
-    {
-        return new RecreationDotGovDivisionAvailability(json);
-    }
-}
-
-interface RecreationDotGovPayloadResponse<T>
-{
-    readonly payload: T;
-}
-
-export interface RecreationDotGovDivisionJson
-{
-    readonly id: string;
-
-    readonly name: string;
-
-    readonly type: string;
-
-    readonly district: string;
-}
-
-export interface RecreationDotGovPermitItineraryJson
-{
-    readonly id: string;
-
-    readonly name: string;
-
-    readonly divisions: { [divisionId: number]: RecreationDotGovDivisionJson };
-}
-
-export class RecreationDotGovError extends Error
-{
-    public constructor(message: string)
-    {
-        super(message);
-    }
-}
-
-export interface RecreationDotGovErrorResponse
-{
-    readonly error: string;
-}
-
-export class RecreationDotGovClient implements HttpClient
-{
-    private readonly httpClient: HttpClient;
-
-    private constructor(httpClient: HttpClient)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(httpClient, "httpClient");
-
-        this.httpClient = httpClient;
-    }
-
-    public static create(httpClient: HttpClient): RecreationDotGovClient
-    {
-        return new RecreationDotGovClient(httpClient);
-    }
-
-    public sendRequest(request: HttpOutgoingRequest): AsyncResult<HttpIncomingResponse>
-    {
-        return this.httpClient.sendRequest(request);
-    }
-
-    public sendGetRequest(url: string): AsyncResult<HttpIncomingResponse>
-    {
-        return HttpClient.sendGetRequest(this, url);
-    }
-
-    public getPermitItinerary(permitItineraryId: string): PromiseAsyncResult<RecreationDotGovPermitItineraryJson>
-    {
-        PreCondition.assertNotEmpty(permitItineraryId, "permitItineraryId");
-
-        return PromiseAsyncResult.create(async () =>
-        {
-            const response: HttpIncomingResponse = await this.sendGetRequest(`https://www.recreation.gov/api/permitcontent/${permitItineraryId}`);
-
-            const responseBody: string = await response.getBody();
-
-            const statusCode: number = response.getStatusCode();
-            if (statusCode < 200 || 300 <= statusCode)
-            {
-                const responseBodyJson: RecreationDotGovErrorResponse = JSON.parse(responseBody);
-                const errorMessage: string = responseBodyJson.error;
-                switch (errorMessage.toLowerCase())
-                {
-                    case "permit not found":
-                        throw new RecreationDotGovError(`No permit itinerary found for id: ${JSON.stringify(permitItineraryId)}`);
-                        
-                    default:
-                        throw new RecreationDotGovError(`Unrecognized error: ${JSON.stringify(errorMessage)}`);
-                }
-            }
-
-            const responseBodyJson: RecreationDotGovPayloadResponse<RecreationDotGovPermitItineraryJson> = JSON.parse(responseBody);
-            return responseBodyJson.payload;
-        });
-    }
-
-    public getDivisionAvailability(permitItineraryId: string, divisionId: string, month: number, year: number, earlyAccessPermitLotteryId?: string): PromiseAsyncResult<RecreationDotGovDivisionAvailability>
-    {
-        PreCondition.assertNotEmpty(permitItineraryId, "permitItineraryId");
-        PreCondition.assertNotEmpty(divisionId, "divisionId");
-        PreCondition.assertBetween(1, month, 12, "month");
-
-        return PromiseAsyncResult.create(async () =>
-        {
-            const url: string = earlyAccessPermitLotteryId
-                ? `https://www.recreation.gov/api/permititinerary/${permitItineraryId}/division/${divisionId}/eapavailability/month/${earlyAccessPermitLotteryId}?month=${month}&year=${year}`
-                : `https://www.recreation.gov/api/permititinerary/${permitItineraryId}/division/${divisionId}/availability/month?month=${month}&year=${year}`
-            const response: HttpIncomingResponse = await this.sendGetRequest(url);
-
-            let responseBody: string = await response.getBody();
-
-            const statusCode: number = response.getStatusCode();
-            if (statusCode < 200 || 300 <= statusCode)
-            {
-                const responseBodyJson: RecreationDotGovErrorResponse = JSON.parse(responseBody) as RecreationDotGovErrorResponse;
-                const errorMessage: string = responseBodyJson.error;
-                switch (errorMessage.toLowerCase())
-                {
-                    case "invalid permit id":
-                        throw new RecreationDotGovError(`No permit itinerary found for id: ${JSON.stringify(permitItineraryId)}`);
-
-                    case "request year is missing or invalid":
-                        // Ignore this error and just return an empty availability.
-                        const emptyResponseBody: RecreationDotGovPayloadResponse<RecreationDotGovDivisionAvailabilityJson> = {
-                            payload: {
-                                bools: {},
-                                rules: [],
-                                quota_type_maps: {},
-                            },
-                        };
-                        responseBody = JSON.stringify(emptyResponseBody);
-                        break;
-                        
-                    default:
-                        throw new RecreationDotGovError(`Unrecognized error: ${JSON.stringify(errorMessage)}`);
-                }
-            }
-
-            const responseBodyJson: RecreationDotGovPayloadResponse<RecreationDotGovDivisionAvailabilityJson> = JSON.parse(responseBody);
-            return RecreationDotGovDivisionAvailability.create(responseBodyJson.payload);
-        });
-    }
-}

package/sources/searchControl.ts

@@ -1,42 +0,0 @@
-import { JavascriptIterable } from "./javascript";
-
-/**
- * An object that can be used to implement a search algorithm.
- */
-export abstract class SearchControl<TVisit,TResult>
-{
-    /**
-     * Add the provided value to the to-visit list.
-     * @param value The value to add to the to-visit list.
-     */
-    public abstract addToVisit(value: TVisit): void;
-
-    /**
-     * Add the provided values to the to-visit list.
-     * @param values The values to add to the to-visit list.
-     */
-    public abstract addAllToVisit(values: JavascriptIterable<TVisit>): void;
-
-    /**
-     * Get whether the provided value has already been visited.
-     * @param value The value to check.
-     */
-    public abstract hasVisited(value: TVisit): boolean;
-
-    /**
-     * Add the provided value to the list of values to be returned.
-     * @param value The value to add.
-     */
-    public abstract addResult(value: TResult): void;
-
-    /**
-     * Add the provided values to the list of values to be returned.
-     * @param values The values to add.
-     */
-    public abstract addResults(values: JavascriptIterable<TResult>): void;
-
-    /**
-     * Immediately stop the search.
-     */
-    public abstract break(): never;
-}