@everyonesoftware/common 1.0.0

package/sources/mutableCondition.ts

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

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