@everyonesoftware/common 1.0.0

package/sources/characterList.ts

@@ -0,0 +1,195 @@
+import { EqualFunctions } from "./equalFunctions";
+import { Iterable } from "./iterable";
+import { Iterator } from "./iterator";
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { List } from "./list";
+import { PreCondition } from "./preCondition";
+import { StringIterator } from "./stringIterator";
+import { join } from "./strings";
+import { SyncResult } from "./syncResult";
+import { ToStringFunctions } from "./toStringFunctions";
+import { isString, Type } from "./types";
+
+export class CharacterList implements List<string>
+{
+    private characters: string;
+
+    private constructor(values?: JavascriptIterable<string> | string)
+    {
+        if (isString(values))
+        {
+            this.characters = values;
+        }
+        else if (values)
+        {
+            this.characters = join("", values);
+        }
+        else
+        {
+            this.characters = "";
+        }
+    }
+
+    public static create(values?: JavascriptIterable<string>): CharacterList
+    {
+        return new CharacterList(values);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return SyncResult.value(this.characters.length);
+    }
+
+    public insert(index: number, value: string): this
+    {
+        PreCondition.assertInsertIndex(index, this.getCount().await(), "index");
+        PreCondition.assertCharacter(value, "value");
+
+        if (index === 0)
+        {
+            this.characters = value + this.characters;
+        }
+        else if (index === this.getCount().await())
+        {
+            this.characters += value;
+        }
+        else
+        {
+            this.characters = this.characters.slice(0, index) + value + this.characters.slice(index);
+        }
+
+        return this;
+    }
+
+    public removeAt(index: number): SyncResult<string>
+    {
+        PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
+
+        const result: string = this.get(index).await();
+        this.characters =
+            (index === 0 ? "" : this.characters.slice(0, index)) +
+            (index === this.getCount().await() - 1 ? "" : this.characters.slice(index + 1));
+
+        return SyncResult.value(result);
+    }
+
+    public set(index: number, value: string): this
+    {
+        PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
+        PreCondition.assertCharacter(value, "value");
+
+        this.characters =
+            (index === 0 ? "" : this.characters.slice(0, index)) +
+            value +
+            (index === this.getCount().await() - 1 ? "" : this.characters.slice(index + 1));
+
+        return this;
+    }
+
+    public iterate(): Iterator<string>
+    {
+        return StringIterator.create(this.characters);
+    }
+
+    public get(index: number): SyncResult<string>
+    {
+        PreCondition.assertAccessIndex(index, this.getCount().await(), "index");
+
+        return SyncResult.value(this.characters.charAt(index));
+    }
+
+    public add(value: string): this
+    {
+        return List.add(this, value);
+    }
+
+    public addAll(values: JavascriptIterable<string>): this
+    {
+        return List.addAll(this, values);
+    }
+
+    public insertAll(index: number, values: JavascriptIterable<string>): this
+    {
+        return List.insertAll(this, index, values);
+    }
+
+    public remove(value: string, equalFunctions?: EqualFunctions): SyncResult<string>
+    {
+        return List.remove(this, value, equalFunctions);
+    }
+
+    public removeFirst(): SyncResult<string>
+    {
+        return List.removeFirst(this);
+    }
+
+    public removeLast(): SyncResult<string>
+    {
+        return List.removeLast(this);
+    }
+
+    public toArray(): SyncResult<string[]>
+    {
+        return List.toArray(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return List.any(this);
+    }
+
+    public equals(right: JavascriptIterable<string>, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return List.equals(this, right, equalFunctions);
+    }
+
+    public toString(toStringFunctions?: ToStringFunctions): string
+    {
+        return List.toString(this, toStringFunctions);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<string>[]): Iterable<string>
+    {
+        return List.concatenate(this, ...toConcatenate);
+    }
+
+    public map<TOutput>(mapping: (value: string) => TOutput | SyncResult<TOutput>): Iterable<TOutput>
+    {
+        return List.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: string) => JavascriptIterable<TOutput>): Iterable<TOutput>
+    {
+        return List.flatMap(this, mapping);
+    }
+
+    public where(condition: (value: string) => (boolean | SyncResult<boolean>)): Iterable<string>
+    {
+        return List.where(this, condition);
+    }
+
+    public instanceOf<TOutput extends string>(typeOrTypeCheck: Type<TOutput> | ((value: string) => value is TOutput)): Iterable<TOutput>
+    {
+        return List.instanceOf(this, typeOrTypeCheck);
+    }
+
+    public first(condition?: (value: string) => (boolean | SyncResult<boolean>)): SyncResult<string>
+    {
+        return List.first(this, condition);
+    }
+
+    public last(condition?: (value: string) => (boolean | SyncResult<boolean>)): SyncResult<string>
+    {
+        return List.last(this, condition);
+    }
+
+    public contains(value: string, equalFunctions?: EqualFunctions): SyncResult<boolean>
+    {
+        return List.contains(this, value, equalFunctions);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<string>
+    {
+        return List[Symbol.iterator](this);
+    }
+}

package/sources/characterListStream.ts

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

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

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

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

@@ -0,0 +1,45 @@
+/**
+ * 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

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