@everyonesoftware/common 3.0.0 → 4.0.0

package/sources/mutableCondition.ts

@@ -1,451 +0,0 @@
-import { AssertMessageParameters } from "./assertMessageParameters";
-import { Bytes } from "./bytes";
-import { Comparer } from "./comparer";
-import { Comparison } from "./comparison";
-import { Condition } from "./condition";
-import { EqualFunctions } from "./equalFunctions";
-import { Iterable } from "./iterable";
-import { JavascriptIterable } from "./javascript";
-import { ToStringFunctions } from "./toStringFunctions";
-import {
-    hasFunction, hasProperty, instanceOf, isJavascriptIterable, isString, isUndefinedOrNull, Type
-} from "./types";
-
-/**
- * A collection of condition methods that can be used to assert the state of an application.
- */
-export class MutableCondition implements Condition
-{
-    private toStringFunctions: ToStringFunctions;
-    private equalFunctions: EqualFunctions;
-    private createErrorFunction: (message: string) => Error;
-
-    protected constructor()
-    {
-        this.toStringFunctions = ToStringFunctions.create();
-        this.equalFunctions = EqualFunctions.create();
-        this.createErrorFunction = MutableCondition.defaultCreateErrorFunction;
-    }
-
-    private static defaultCreateErrorFunction(message: string): Error
-    {
-        return new Error(message);
-    }
-
-    /**
-     * Create a new {@link MutableCondition} object.
-     */
-    public static create(): MutableCondition
-    {
-        return new MutableCondition();
-    }
-
-    /**
-     * Set the {@link ToStringFunctions} that will be used to convert values to their {@link String}
-     * representations.
-     * @param toStringFunctions The {@link ToStringFunctions} that will be used to convert values to
-     * their {@link String} representations.
-     * @returns This object for method chaining.
-     */
-    public setToStringFunctions(toStringFunctions: ToStringFunctions): this
-    {
-        this.assertNotUndefinedAndNotNull(toStringFunctions, "toStringFunctions");
-
-        this.toStringFunctions = toStringFunctions;
-
-        return this;
-    }
-
-    /**
-     * Set the {@link EqualFunctions} that will be used to determine if values are equal.
-     * @param equalFunctions The {@link EqualFunctions} that will be used to determine if values are
-     * equal.
-     * @returns This object for method chaining.
-     */
-    public setEqualFunctions(equalFunctions: EqualFunctions): this
-    {
-        this.assertNotUndefinedAndNotNull(equalFunctions, "equalFunctions");
-
-        this.equalFunctions = equalFunctions;
-
-        return this;
-    }
-
-    /**
-     * Set the {@link Function} that will be used to create {@link Error}s.
-     * @param createErrorFunction The {@link Function} to use to create {@link Error}.
-     * @returns This object for method chaining.
-     */
-    public setCreateErrorFunction(createErrorFunction: (message: string) => Error): this
-    {
-        this.assertNotUndefinedAndNotNull(createErrorFunction, "createErrorFunction");
-
-        this.createErrorFunction = createErrorFunction;
-        return this;
-    }
-
-    public assertUndefined(value: unknown, expression?: string, message?: string): asserts value is undefined
-    {
-        Condition.assertUndefined(this, value, expression, message);
-    }
-
-    public assertNotUndefined<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>
-    {
-        Condition.assertNotUndefined(this, value, expression, message);
-    }
-
-    /**
-     * Get whether the provided values are equal.
-     * @param left The left part of the comparison.
-     * @param right The right part of the comparison.
-     */
-    public areEqual(left: unknown, right: unknown): boolean
-    {
-        return this.equalFunctions.areEqual(left, right).await();
-    }
-
-    /**
-     * Get the {@link String} representation of the provided value.
-     * @param value The value to get the {@link String} representation of.
-     */
-    public toValueString(value: unknown): string
-    {
-        return this.toStringFunctions.toString(value);
-    }
-
-    /**
-     * Create an {@link Error} based on the provided {@link AssertMessageParameters}.
-     * @param parameters The {@link AssertMessageParameters} that define how the should be made.
-     */
-    public createError(parameters: AssertMessageParameters): Error
-    {
-        const message: string = MutableCondition.createErrorMessage(parameters);
-        return this.createErrorFunction(message);
-    }
-
-    /**
-     * Create an error message based on the provided parameters.
-     * @param parameters The parameters to use to create the error message.
-     */
-    public static createErrorMessage(parameters: AssertMessageParameters): string
-    {
-        let result: string = "";
-
-        if (parameters.message)
-        {
-            result += `Message: ${parameters.message}`;
-        }
-
-        if (parameters.expression)
-        {
-            if (result)
-            {
-                result += "\n";
-            }
-            result += `Expression: ${parameters.expression}`;
-        }
-
-        if (result)
-        {
-            result += "\n";
-        }
-        result += `Expected: ${parameters.expected}`;
-
-        if (result)
-        {
-            result += "\n";
-        }
-        result += `Actual: ${parameters.actual}`;
-
-        return result;
-    }
-
-    public assertNotUndefinedAndNotNull<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>
-    {
-        if (value === undefined || value === null)
-        {
-            throw this.createError({
-                expected: `not ${this.toValueString(undefined)} and not ${this.toValueString(null)}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertTrue(value: boolean, expression?: string, message?: string): asserts value is true
-    {
-        Condition.assertTrue(this, value, expression, message);
-    }
-
-    public assertFalse(value: boolean, expression?: string, message?: string): asserts value is false
-    {
-        if (value !== false)
-        {
-            throw this.createError({
-                expected: this.toValueString(false),
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertSame<T>(expected: T, actual: T, expression?: string, message?: string): void
-    {
-        if (expected !== actual)
-        {
-            throw this.createError({
-                expected: this.toValueString(expected),
-                actual: this.toValueString(actual),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertNotSame<T>(expected: T, actual: T, expression?: string, message?: string): void
-    {
-        if (expected === actual)
-        {
-            throw this.createError({
-                expected: `not ${this.toValueString(expected)}`,
-                actual: this.toValueString(actual),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertEqual<T>(expected: T, actual: T, expression?: string, message?: string): void
-    {
-        let comparison: Comparison | undefined = Comparer.compareSameUndefinedNull(expected, actual);
-        if (comparison === undefined && this.areEqual(expected, actual))
-        {
-            comparison = Comparison.Equal;
-        }
-
-        if (comparison !== Comparison.Equal)
-        {
-            throw this.createError({
-                expected: this.toValueString(expected),
-                actual: this.toValueString(actual),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertNotEqual<T>(notExpected: T, actual: T, expression?: string, message?: string): void
-    {
-        let comparison: Comparison | undefined = Comparer.compareSameUndefinedNull(notExpected, actual);
-        if (comparison === undefined && this.areEqual(notExpected, actual))
-        {
-            comparison = Comparison.Equal;
-        }
-
-        if (comparison === Comparison.Equal)
-        {
-            throw this.createError({
-                expected: `not ${this.toValueString(notExpected)}`,
-                actual: this.toValueString(actual),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertNotEmpty<T extends JavascriptIterable<unknown> | string | null | undefined>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>
-    {
-        this.assertNotUndefinedAndNotNull(value, expression, message);
-        if ((isString(value) && value.length === 0) ||
-            (isJavascriptIterable(value) && !Iterable.create(value).any()))
-        {
-            throw this.createError({
-                expected: "not empty",
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertLessThan(value: number, upperBound: number, expression?: string, message?: string): void
-    {
-        if (!(value < upperBound))
-        {
-            throw this.createError({
-                expected: `less than ${this.toValueString(upperBound)}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertLessThanOrEqualTo(value: number, upperBound: number, expression?: string, message?: string): void
-    {
-        if (!(value <= upperBound))
-        {
-            throw this.createError({
-                expected: `less than or equal to ${this.toValueString(upperBound)}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertGreaterThanOrEqualTo(value: number, lowerBound: number, expression?: string, message?: string): void
-    {
-        if (!(lowerBound <= value))
-        {
-            throw this.createError({
-                expected: `greater than or equal to ${this.toValueString(lowerBound)}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertGreaterThan(value: number, lowerBound: number, expression?: string, message?: string): void
-    {
-        if (!(lowerBound < value))
-        {
-            throw this.createError({
-                expected: `greater than ${this.toValueString(lowerBound)}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertBetween(lowerBound: number, value: number, upperBound: number, expression?: string, message?: string): void
-    {
-        this.assertLessThanOrEqualTo(lowerBound, upperBound, "lowerBound");
-        if (isUndefinedOrNull(value) || !(lowerBound <= value && value <= upperBound))
-        {
-            throw this.createError({
-                expected: (lowerBound === upperBound
-                    ? this.toValueString(lowerBound)
-                    : `between ${this.toValueString(lowerBound)} and ${this.toValueString(upperBound)}`),
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertAccessIndex(index: number, count: number, expression?: string, message?: string): void
-    {
-        this.assertGreaterThanOrEqualTo(count, 1, "count");
-        this.assertInteger(index, expression);
-        this.assertBetween(0, index, count - 1, expression, message);
-    }
-
-    public assertInsertIndex(index: number, count: number, expression?: string, message?: string): void
-    {
-        this.assertGreaterThanOrEqualTo(count, 0, "count");
-        this.assertInteger(index, expression);
-        this.assertBetween(0, index, count, expression, message);
-    }
-
-    public assertOneOf<T>(possibilities: JavascriptIterable<T>, value: T, expression?: string, message?: string): void
-    {
-        this.assertNotUndefinedAndNotNull(possibilities, "possibilities");
-
-        let found: boolean = false;
-        for (const possibility of possibilities)
-        {
-            if (this.areEqual(possibility, value))
-            {
-                found = true;
-                break;
-            }
-        }
-
-        if (!found)
-        {
-            throw this.createError({
-                expected: `one of ${this.toValueString(possibilities)}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertByte(value: number, expression?: string, message?: string): void
-    {
-        this.assertBetween(Bytes.minimumValue, value, Bytes.maximumValue, expression, message);
-        this.assertInteger(value, "value");
-    }
-
-    public assertInteger(value: number, expression?: string, message?: string): void
-    {
-        if (value % 1 !== 0)
-        {
-            throw this.createError({
-                expected: `integer`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertCharacter(value: string, expression?: string, message?: string): void
-    {
-        if (!value || value.length !== 1)
-        {
-            throw this.createError({
-                expected: `character`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-
-    public assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): asserts value is T;
-    public assertInstanceOf<T>(parameters: { value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string }): void;
-    public assertInstanceOf<T>(parametersOrValue: unknown | { value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string }, type?: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): void;
-    public assertInstanceOf<T>(parametersOrValue: unknown | { value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string }, type?: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): void
-    {
-        let value: unknown;
-        if (hasProperty(parametersOrValue, "value") &&
-            hasProperty(parametersOrValue, "type"))
-        {
-            value = parametersOrValue.value;
-            type = parametersOrValue.type as Type<T>;
-            if (hasFunction(parametersOrValue, "typeCheck"))
-            {
-                typeCheck = parametersOrValue.typeCheck as (value: unknown) => value is T;
-            }
-            if (hasProperty(parametersOrValue, "expression"))
-            {
-                expression = parametersOrValue.expression as string;
-            }
-            if (hasProperty(parametersOrValue, "message"))
-            {
-                message = parametersOrValue.message as string;
-            }
-        }
-        else
-        {
-            value = parametersOrValue;
-        }
-
-        if (!instanceOf(value, type!, typeCheck))
-        {
-            throw this.createError({
-                expected: `instance of ${type!.name}`,
-                actual: this.toValueString(value),
-                expression: expression,
-                message: message,
-            });
-        }
-    }
-}

package/sources/mutableHttpHeaders.ts

@@ -1,204 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { HttpHeader } from "./httpHeader";
-import { HttpHeaders } from "./httpHeaders";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { List } from "./list";
-import { NotFoundError } from "./notFoundError";
-import { PreCondition } from "./preCondition";
-import { escapeAndQuote } from "./strings";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { isString, Type } from "./types";
-
-export class MutableHttpHeaders implements HttpHeaders
-{
-    private readonly headers: List<HttpHeader>;
-
-    private constructor(headers?: JavascriptIterable<HttpHeader>)
-    {
-        this.headers = List.create();
-        if (headers)
-        {
-            this.setAll(headers);
-        }
-    }
-
-    public static create(headers?: JavascriptIterable<HttpHeader>): MutableHttpHeaders
-    {
-        return new MutableHttpHeaders(headers);
-    }
-
-    public iterate(): Iterator<HttpHeader>
-    {
-        return this.headers.iterate();
-    }
-
-    public get(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.headers)
-            {
-                if (header.getName().toLowerCase() === lowerHeaderName)
-                {
-                    result = header
-                    break;
-                }
-            }
-            if (result === undefined)
-            {
-                throw new NotFoundError(`No HttpHeader found with the name ${escapeAndQuote(headerName)}.`);
-            }
-
-            return result;
-        });
-    }
-
-    public getValue(headerName: string): SyncResult<string>
-    {
-        return this.get(headerName)
-            .then((header: HttpHeader) => header.getValue());
-    }
-
-    /**
-     * Set a {@link HttpHeader} value in this collection. This will overwrite any existing 
-     * {@link HttpHeader} with the same name.
-     * @param headerName The name of the header to set.
-     * @param headerValue The value of the header to set.
-     */
-    public set(headerName: string, headerValue: string): this;
-    public set(header: HttpHeader): this;
-    set(headerOrHeaderName: HttpHeader | string, headerValue?: string): this
-    {
-        let headerName: string;
-        if (isString(headerOrHeaderName))
-        {
-            headerName = headerOrHeaderName;
-        }
-        else
-        {
-            headerName = headerOrHeaderName.getName();
-            headerValue = headerOrHeaderName.getValue();
-        }
-        PreCondition.assertNotEmpty(headerName, "headerName");
-        PreCondition.assertNotUndefinedAndNotNull(headerValue, "headerValue");
-
-        let insertIndex: number = 0;
-        for (let insertIndex = 0; insertIndex < this.headers.getCount().await(); insertIndex++)
-        {
-            const header: HttpHeader = this.headers.get(insertIndex).await();
-            if (header.getName() === headerName)
-            {
-                this.headers.removeAt(insertIndex);
-                break;
-            }
-        }
-        this.headers.insert(insertIndex, HttpHeader.create(headerName, headerValue));
-
-        return this;
-    }
-
-    public setAll(headers: JavascriptIterable<HttpHeader>): this
-    {
-        PreCondition.assertNotUndefinedAndNotNull(headers, "headers");
-
-        for (const header of headers)
-        {
-            this.set(header);
-        }
-
-        return this;
-    }
-
-    public setContentType(contentType: string): this
-    {
-        return this.set(HttpHeaders.contentTypeHeaderName, contentType);
-    }
-
-    public getContentType(): SyncResult<HttpHeader>
-    {
-        return this.get(HttpHeaders.contentTypeHeaderName);
-    }
-
-    public getContentTypeValue(): SyncResult<string>
-    {
-        return this.getValue(HttpHeaders.contentTypeHeaderName);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return this.headers.getCount();
-    }
-
-    public toArray(): SyncResult<HttpHeader[]>
-    {
-        return HttpHeaders.toArray(this);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return HttpHeaders.any(this);
-    }
-
-    public equals(right: JavascriptIterable<HttpHeader>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return HttpHeaders.equals(this, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return HttpHeaders.toString(this, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable<HttpHeader>
-    {
-        return HttpHeaders.concatenate(this, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return HttpHeaders.map(this, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return HttpHeaders.flatMap(this, mapping);
-    }
-
-    public where(condition: (value: HttpHeader) => (boolean | SyncResult<boolean>)): Iterable<HttpHeader>
-    {
-        return HttpHeaders.where(this, condition);
-    }
-
-    public instanceOf<TOutput extends HttpHeader>(typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable<TOutput>
-    {
-        return HttpHeaders.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public first(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>
-    {
-        return HttpHeaders.first(this, condition);
-    }
-
-    public last(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>
-    {
-        return HttpHeaders.last(this, condition);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<HttpHeader>
-    {
-        return HttpHeaders[Symbol.iterator](this);
-    }
-
-    public contains(value: HttpHeader, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return HttpHeaders.contains(this, value, equalFunctions);
-    }
-}