@everyonesoftware/common 2.0.0 → 4.0.0

package/sources/characterListStream.ts

@@ -1,151 +0,0 @@
-import { CharacterList } from "./characterList";
-import { CharacterReadStream } from "./characterReadStream";
-import { CharacterWriteStream } from "./characterWriteStream";
-import { EmptyError } from "./emptyError";
-import { JavascriptIterable } from "./javascript";
-import { PreCondition } from "./preCondition";
-import { AsyncResult } from "./asyncResult";
-import { join } from "./strings";
-import { SyncResult } from "./syncResult";
-import { isNumber, isString, isUndefinedOrNull } from "./types";
-
-/**
- * A {@link CharacterReadStream} and {@link CharacterWriteStream} implementation that is implemented using a
- * {@link CharacterList}.
- */
-export class CharacterListStream implements CharacterReadStream, CharacterWriteStream
-{
-    private readonly list: CharacterList;
-
-    private constructor()
-    {
-        this.list = CharacterList.create();
-    }
-
-    public static create(initialValues?: JavascriptIterable<string>): CharacterListStream
-    {
-        const result: CharacterListStream = new CharacterListStream();
-        if (initialValues)
-        {
-            result.writeCharacters(initialValues).await();
-        }
-        return result;
-    }
-
-    public writeCharacters(characters: JavascriptIterable<string>, startIndex?: number, length?: number): SyncResult<number>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(characters, "characters");
-
-        const characterString: string = isString(characters) ? characters : join("", characters);
-        if (isUndefinedOrNull(startIndex))
-        {
-            startIndex = 0;
-        }
-        if (isUndefinedOrNull(length))
-        {
-            length = characterString.length - startIndex;
-        }
-
-        PreCondition.assertInsertIndex(startIndex, characterString.length, "startIndex");
-        PreCondition.assertBetween(0, length, characterString.length - startIndex, "length");
-
-        this.list.addAll(characterString.slice(startIndex, length + startIndex));
-
-        return SyncResult.value(length);
-    }
-
-
-    public writeString(text: string): AsyncResult<number>
-    {
-        this.list.addAll(text);
-
-        return SyncResult.value(text.length);
-    }
-
-    public writeLine(text?: string): AsyncResult<number>
-    {
-        return CharacterWriteStream.writeLine(this, text);
-    }
-
-    /**
-     * Get the number of characters that are available to be read.
-     */
-    public getAvailableCharacterCount(): number
-    {
-        return this.list.getCount().await();
-    }
-
-    public readCharacter(): AsyncResult<string>
-    {
-        return !this.list.any().await()
-            ? SyncResult.error(new EmptyError())
-            : SyncResult.value(this.list.removeFirst().await());
-    }
-    
-    public readCharacters(count: number): SyncResult<string>;
-    public readCharacters(output: string[], startIndex?: number, count?: number): SyncResult<number>;
-    readCharacters(countOrOutput: number | string[], startIndex?: number, count?: number): SyncResult<number> | SyncResult<string>
-    {
-        let result: SyncResult<number> | SyncResult<string>;
-        if (isNumber(countOrOutput))
-        {
-            PreCondition.assertGreaterThanOrEqualTo(countOrOutput, 0, "count");
-
-            if (!this.list.any().await())
-            {
-                result = SyncResult.error<string>(new EmptyError());
-            }
-            else
-            {
-                const bytesReadCount: number = Math.min(countOrOutput, this.list.getCount().await());
-                let output: string = "";
-                for (let i = 0; i < bytesReadCount; i++)
-                {
-                    output += this.list.removeFirst().await();
-                }
-                result = SyncResult.value(output);
-            }
-        }
-        else
-        {
-            PreCondition.assertNotUndefinedAndNotNull(countOrOutput, "output");
-
-            if (isUndefinedOrNull(startIndex))
-            {
-                startIndex = 0;
-            }
-            if (isUndefinedOrNull(count))
-            {
-                count = countOrOutput.length - startIndex;
-            }
-
-            PreCondition.assertInsertIndex(startIndex, countOrOutput.length, "startIndex");
-            PreCondition.assertBetween(0, count, countOrOutput.length - startIndex, "count");
-
-            if (!this.list.any().await())
-            {
-                result = SyncResult.error<number>(new EmptyError());
-            }
-            else
-            {
-                const bytesReadCount: number = Math.min(count, this.list.getCount().await());
-                for (let i = 0; i < bytesReadCount; i++)
-                {
-                    countOrOutput[startIndex + i] = this.list.removeFirst().await();
-                }
-                result = SyncResult.value(bytesReadCount);
-            }
-        }
-        return result;
-    }
-
-    public readUntil(searchString: string): AsyncResult<string>
-    {
-        return CharacterReadStream.readUntil(this, searchString);
-    }
-
-    public readLine(): AsyncResult<string>
-    {
-        return CharacterReadStream.readLine(this);
-    }
-}

package/sources/characterReadStream.ts

@@ -1,81 +0,0 @@
-import { PreCondition } from "./preCondition";
-import { AsyncResult } from "./asyncResult";
-import { SyncResult } from "./syncResult";
-
-export abstract class CharacterReadStream
-{
-    /**
-     * Read a single character from this stream.
-     */
-    public abstract readCharacter(): AsyncResult<string>;
-
-    public readCharacters(count: number): AsyncResult<string>
-    {
-        return CharacterReadStream.readCharacters(this, count);
-    }
-
-    public static readCharacters(readStream: CharacterReadStream, count: number): AsyncResult<string>
-    {
-        let characters: string = "";
-        function readUntilCount(countRemaining: number): AsyncResult<string>
-        {
-            return readStream.readCharacter()
-                .then((character: string) =>
-                {
-                    characters += character;
-                    return countRemaining === 0
-                        ? SyncResult.value(characters)
-                        : readUntilCount(countRemaining - 1);
-                });
-        }
-        return readUntilCount(count);
-    }
-
-    /**
-     * Read characters from this stream until the provided {@link searchString} is found or the end
-     * of the stream is reached. The {@link searchString} will be included in the returned string if
-     * it is found..
-     * @param searchString The string to search for.
-     */
-    public readUntil(searchString: string): AsyncResult<string>
-    {
-        return CharacterReadStream.readUntil(this, searchString);
-    }
-
-    public static readUntil(readStream: CharacterReadStream, searchString: string): AsyncResult<string>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-        PreCondition.assertNotEmpty(searchString, "searchString");
-
-        let characters: string = "";
-        function readUntilSearchString(): AsyncResult<string>
-        {
-            return readStream.readCharacter()
-                .then((character: string) =>
-                {
-                    characters += character;
-                    return characters.endsWith(searchString)
-                        ? SyncResult.value(characters)
-                        : readUntilSearchString();
-                });
-        }
-        return readUntilSearchString();
-    }
-
-    /**
-     * Read a sequence of characters from this stream until either a newline character ('\\n') or
-     * the end of the stream is reached. Terminating newline characters will be included in the
-     * returned string.
-     */
-    public readLine(): AsyncResult<string>
-    {
-        return CharacterReadStream.readLine(this);
-    }
-
-    public static readLine(readStream: CharacterReadStream): AsyncResult<string>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-
-        return readStream.readUntil("\n");
-    }
-}

package/sources/characterReadStreamIterator.ts

@@ -1,128 +0,0 @@
-import { AsyncIterator } from "./asyncIterator";
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { CharacterReadStream } from "./characterReadStream";
-import { JavascriptAsyncIterator } from "./javascript";
-import { NotFoundError } from "./notFoundError";
-import { PreCondition } from "./preCondition";
-import { Type } from "./types";
-
-export class CharacterReadStreamAsyncIterator implements AsyncIterator<string>
-{
-    private readonly readStream: CharacterReadStream;
-    private current: string;
-    private started: boolean;
-
-    private constructor(readStream: CharacterReadStream)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(readStream, "readStream");
-
-        this.readStream = readStream;
-        this.current = "";
-        this.started = false;
-    }
-
-    public static create(readStream: CharacterReadStream): CharacterReadStreamAsyncIterator
-    {
-        return new CharacterReadStreamAsyncIterator(readStream);
-    }
-
-    public next(): PromiseAsyncResult<boolean>
-    {
-        return PromiseAsyncResult.create(async () =>
-        {
-            this.started = true;
-
-            this.current = await this.readStream.readCharacter()
-                .catch(NotFoundError, () => "");
-
-            return this.hasCurrent();
-        });
-    }
-
-    public hasStarted(): boolean
-    {
-        return this.started;
-    }
-
-    public hasCurrent(): boolean
-    {
-        return this.current !== "";
-    }
-
-    public getCurrent(): string
-    {
-        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
-
-        return this.current;
-    }
-
-    public start(): PromiseAsyncResult<this>
-    {
-        return AsyncIterator.start<string,this>(this);
-    }
-
-    public takeCurrent(): PromiseAsyncResult<string>
-    {
-        return AsyncIterator.takeCurrent(this);
-    }
-
-    public any(): PromiseAsyncResult<boolean>
-    {
-        return AsyncIterator.any(this);
-    }
-
-    public getCount(): PromiseAsyncResult<number>
-    {
-        return AsyncIterator.getCount(this);
-    }
-
-    public toArray(): PromiseAsyncResult<string[]>
-    {
-        return AsyncIterator.toArray(this);
-    }
-
-    public where(condition: (value: string) => boolean | PromiseLike<boolean>): AsyncIterator<string>
-    {
-        return AsyncIterator.where(this, condition);
-    }
-
-    public map<TOutput>(mapping: (value: string) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>
-    {
-        return AsyncIterator.map(this, mapping);
-    }
-
-    public whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): AsyncIterator<U>
-    {
-        return AsyncIterator.whereInstanceOf(this, typeCheck);
-    }
-
-    public whereInstanceOfType<U extends string>(type: Type<U>): AsyncIterator<U>
-    {
-        return AsyncIterator.whereInstanceOfType(this, type);
-    }
-
-    public first(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>
-    {
-        return AsyncIterator.first(this, condition);
-    }
-
-    public last(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>
-    {
-        return AsyncIterator.last(this, condition);
-    }
-
-    public take(maximumToTake: number): AsyncIterator<string>
-    {
-        return AsyncIterator.take(this, maximumToTake);
-    }
-
-    public skip(maximumToSkip: number): AsyncIterator<string>
-    {
-        return AsyncIterator.skip(this, maximumToSkip);
-    }
-
-    public [Symbol.asyncIterator](): JavascriptAsyncIterator<string>
-    {
-        return AsyncIterator[Symbol.asyncIterator](this);
-    }
-}

package/sources/characterWriteStream.ts

@@ -1,45 +0,0 @@
-import { PromiseAsyncResult } from "./promiseAsyncResult";
-import { PostCondition } from "./postCondition";
-import { PreCondition } from "./preCondition";
-import { AsyncResult } from "./asyncResult";
-
-export abstract class CharacterWriteStream
-{
-    /**
-     * Write the provided text to this {@link CharacterWriteStream}.
-     * @param text The text to write.
-     * @returns The number of characters that were written.
-     */
-    public abstract writeString(text: string): AsyncResult<number>
-
-    /**
-     * Write the provided text (if provided) and then write a newline character sequence to this
-     * {@link CharacterWriteStream}.
-     * @param text The optional text to write before the newline character sequence.
-     * @returns The number of characters that were written.
-     */
-    public writeLine(text?: string): AsyncResult<number>
-    {
-        return CharacterWriteStream.writeLine(this, text);
-    }
-
-    public static writeLine(writeStream: CharacterWriteStream, text?: string): AsyncResult<number>
-    {
-        PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
-
-        return PromiseAsyncResult.create(async () =>
-        {
-            let result: number = 0;
-
-            if (text)
-            {
-                result += await writeStream.writeString(text);
-            }
-            result += await writeStream.writeString("\n");
-
-            PostCondition.assertGreaterThan(result, 0, "result");
-
-            return result;
-        });
-    }
-}

package/sources/commandLineParameter.ts

@@ -1,45 +0,0 @@
-/**
- * An individual parameter from a {@link CommandLineParameters} object.
- */
-export class CommandLineParameter<T>
-{
-    /**
-     * The full name of this {@link CommandLineParameter}.
-     */
-    private readonly name: string;
-    /**
-     * The description for this {@link CommandLineParameter}.
-     */
-    private readonly description: string;
-    /**
-     * The function that can be invoked to get this {@link CommandLineParameter}'s value.
-     */
-    private readonly valueGetter: () => T;
-
-    private constructor(name: string, description: string, valueGetter: () => T)
-    {
-        this.name = name;
-        this.description = description;
-        this.valueGetter = valueGetter;
-    }
-
-    /**
-     * Create a new {@link CommandLineParameter}.
-     * @param name The full name of the {@link CommandLineParameter}.
-     * @param description The description for the {@link CommandLineParameter}.
-     * @param valueGetter The function that will be used to get the returned
-     * {@link CommandLineParameter}'s value.
-     */
-    public static create<T>(name: string, description: string, valueGetter: () => T)
-    {
-        return new CommandLineParameter<T>(name, description, valueGetter);
-    }
-
-    /**
-     * Get the value for this {@link CommandLineParameter}.
-     */
-    public getValue(): T
-    {
-        return this.valueGetter();
-    }
-}

package/sources/commandLineParameters.ts

@@ -1,21 +0,0 @@
-import { JavascriptIterable } from "./javascript";
-
-/**
- * A class that can be used to define and interact with an application's command line interface.
- */
-export class CommandLineParameters
-{
-    private readonly args: JavascriptIterable<string>;
-
-    private constructor(argv: JavascriptIterable<string>)
-    {
-        this.args = argv
-    }
-
-    public static create(args: JavascriptIterable<string>): CommandLineParameters
-    {
-        return new CommandLineParameters(args)
-    }
-
-    
-}

package/sources/comparable.ts

@@ -1,144 +0,0 @@
-import { Comparison } from "./comparison";
-import { PreCondition } from "./preCondition";
-
-/**
- * An type that can be compared against another type.
- */
-export abstract class Comparable<T>
-{
-    protected constructor()
-    {
-    }
-
-    /**
-     * Compare this value against the provided value.
-     * @param value The value to compare against.
-     */
-    public abstract compareTo(value: T): Comparison;
-
-    /**
-     * Get whether this value is less than the provided value.
-     * @param value The value to compare against.
-     */
-    public lessThan(value: T): boolean
-    {
-        return Comparable.lessThan(this, value);
-    }
-
-    /**
-     * Get whether the left value is less than the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    public static lessThan<T>(left: Comparable<T>, right: T): boolean
-    {
-        PreCondition.assertNotUndefinedAndNotNull(left, "left");
-
-        return left.compareTo(right) === Comparison.LessThan;
-    }
-
-    /**
-     * Get whether this value is less than or equal to the provided value.
-     * @param value The value to compare against.
-     */
-    public lessThanOrEqualTo(value: T): boolean
-    {
-        return Comparable.lessThanOrEqualTo(this, value);
-    }
-
-    /**
-     * Get whether the left value is less than or equal to the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    public static lessThanOrEqualTo<T>(left: Comparable<T>, right: T): boolean
-    {
-        PreCondition.assertNotUndefinedAndNotNull(left, "left");
-
-        return left.compareTo(right) !== Comparison.GreaterThan;
-    }
-
-    /**
-     * Get whether this value equals the provided value.
-     * @param value The value to compare against.
-     */
-    public equals(value: T): boolean
-    {
-        return Comparable.equals(this, value);
-    }
-
-    /**
-     * Get whether the left value equals the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    public static equals<T>(left: Comparable<T>, right: T): boolean
-    {
-        PreCondition.assertNotUndefinedAndNotNull(left, "left");
-
-        return left.compareTo(right) === Comparison.Equal;
-    }
-
-    /**
-     * Get whether this value is not equal to the provided value.
-     * @param value The value to compare against.
-     */
-    public notEquals(value: T): boolean
-    {
-        return Comparable.notEquals(this, value);
-    }
-
-    /**
-     * Get whether the left value is not equal to the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    public static notEquals<T>(left: Comparable<T>, right: T): boolean
-    {
-        PreCondition.assertNotUndefinedAndNotNull(left, "left");
-
-        return left.compareTo(right) !== Comparison.Equal;
-    }
-
-    /**
-     * Get whether this value is greater than or equal to the provided value.
-     * @param value The value to compare against.
-     */
-    public greaterThanOrEqualTo(value: T): boolean
-    {
-        return Comparable.greaterThanOrEqualTo(this, value);
-    }
-
-    /**
-     * Get whether the left value is greater than or equal to the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    public static greaterThanOrEqualTo<T>(left: Comparable<T>, right: T): boolean
-    {
-        PreCondition.assertNotUndefinedAndNotNull(left, "left");
-
-        return left.compareTo(right) !== Comparison.LessThan;
-    }
-
-    /**
-     * Get whether this value is greater than the provided value.
-     * @param value The value to compare against.
-     */
-    public greaterThan(value: T): boolean
-    {
-        return Comparable.greaterThan(this, value);
-    }
-
-    /**
-     * Get whether the left value is greater than the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    public static greaterThan<T>(left: Comparable<T>, right: T): boolean
-    {
-        PreCondition.assertNotUndefinedAndNotNull(left, "left");
-
-        return left.compareTo(right) === Comparison.GreaterThan;
-    }
-}