@everyonesoftware/common 1.0.0

package/sources/stringIterator.ts

@@ -0,0 +1,149 @@
+import { Iterator } from "./iterator";
+import { JavascriptIterable, JavascriptIterator } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { SyncResult } from "./syncResult";
+import { Type } from "./types";
+
+/**
+ * An {@link Iterator} that iterates over the characters in a {@link string}.
+ */
+export class StringIterator implements Iterator<string>
+{
+    private readonly value: string;
+    private currentIndex: number;
+    private started: boolean;
+
+    private constructor(value: string)
+    {
+        this.value = value;
+        this.currentIndex = 0;
+        this.started = false;
+    }
+
+    public static create(value: string): StringIterator
+    {
+        PreCondition.assertNotUndefinedAndNotNull(value, "value");
+
+        return new StringIterator(value);
+    }
+
+    public getCurrentIndex(): number
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.currentIndex;
+    }
+
+    public next(): SyncResult<boolean>
+    {
+        return SyncResult.create(() =>
+        {
+            if (!this.hasStarted())
+            {
+                this.started = true;
+            }
+            else if (this.hasCurrent())
+            {
+                this.currentIndex++;
+            }
+            return this.hasCurrent();
+        });
+    }
+
+    public hasStarted(): boolean
+    {
+        return this.started;
+    }
+
+    public hasCurrent(): boolean
+    {
+        return this.hasStarted() && this.currentIndex < this.value.length;
+    }
+
+    public getCurrent(): string
+    {
+        PreCondition.assertTrue(this.hasCurrent(), "this.hasCurrent()");
+
+        return this.value[this.currentIndex];
+    }
+
+    public start(): SyncResult<this>
+    {
+        return Iterator.start<string, this>(this);
+    }
+
+    public takeCurrent(): SyncResult<string>
+    {
+        return Iterator.takeCurrent(this);
+    }
+
+    public any(): SyncResult<boolean>
+    {
+        return Iterator.any(this);
+    }
+
+    public getCount(): SyncResult<number>
+    {
+        return Iterator.getCount(this);
+    }
+
+    public toArray(): SyncResult<string[]>
+    {
+        return Iterator.toArray(this);
+    }
+
+    public concatenate(...toConcatenate: JavascriptIterable<string>[]): Iterator<string>
+    {
+        return Iterator.concatenate(this, ...toConcatenate);
+    }
+
+    public map<TOutput>(mapping: (value: string) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>
+    {
+        return Iterator.map(this, mapping);
+    }
+
+    public flatMap<TOutput>(mapping: (value: string) => JavascriptIterable<TOutput>): Iterator<TOutput>
+    {
+        return Iterator.flatMap(this, mapping);
+    }
+
+    public first(): SyncResult<string>
+    {
+        return Iterator.first(this);
+    }
+
+    public last(): SyncResult<string>
+    {
+        return Iterator.last(this);
+    }
+
+    public where(condition: (value: string) => boolean): Iterator<string>
+    {
+        return Iterator.where(this, condition);
+    }
+
+    public whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): Iterator<U>
+    {
+        return Iterator.whereInstanceOf(this, typeCheck);
+    }
+
+    public whereInstanceOfType<U extends string>(type: Type<U>): Iterator<U>
+    {
+        return Iterator.whereInstanceOfType(this, type);
+    }
+
+    public take(maximumToTake: number): Iterator<string>
+    {
+        return Iterator.take(this, maximumToTake);
+    }
+
+    public skip(maximumToSkip: number): Iterator<string>
+    {
+        return Iterator.skip(this, maximumToSkip);
+    }
+
+    public [Symbol.iterator](): JavascriptIterator<string>
+    {
+        return Iterator[Symbol.iterator](this);
+    }
+}

package/sources/strings.ts

@@ -0,0 +1,322 @@
+import { JavascriptIterable } from "./javascript";
+import { PreCondition } from "./preCondition";
+import { isString } from "./types";
+
+export function getLength(value: string | undefined | null): number
+{
+    return value !== undefined && value !== null ? value.length : 0;
+}
+
+export function toString(value: undefined | null | { toString(): string }): string
+{
+    let result: string;
+    if (value === undefined)
+    {
+        result = "undefined";
+    }
+    else if (value === null)
+    {
+        result = "null";
+    }
+    else
+    {
+        result = value.toString();
+    }
+
+    return result;
+}
+
+/**
+ * Join the provided values with the provided separator in between each value.
+ * @param separator The value to use to separate the individual values.
+ * @param values The values to join.
+ * @returns The joined {@link string}.
+ */
+export function join(separator: string, values: JavascriptIterable<string>): string;
+export function join(parameters: { separator: string, values: JavascriptIterable<string> }): string;
+export function join(separatorOrParameters: string | { separator: string, values: JavascriptIterable<string> }, values?: JavascriptIterable<string>): string
+{
+    let separator: string;
+    if (isString(separatorOrParameters) || separatorOrParameters === undefined || separatorOrParameters === null)
+    {
+        separator = separatorOrParameters;
+    }
+    else
+    {
+        separator = separatorOrParameters.separator;
+        values = separatorOrParameters.values;
+    }
+
+    PreCondition.assertNotUndefinedAndNotNull(separator, "separator");
+    PreCondition.assertNotUndefinedAndNotNull(values, "values");
+
+    return Array.from(values).join(separator);
+}
+
+export function escape(value: string | undefined | null, dontEscape?: string[]): string;
+export function escape(parameters: { value: string | undefined | null, dontEscape?: string[] }): string;
+export function escape(valueOrParameters: string | undefined | null | { value: string | undefined | null, dontEscape?: string[] }, dontEscape?: string[]): string
+{
+    let value: string | undefined | null;
+    if (isString(valueOrParameters) || valueOrParameters === undefined || valueOrParameters === null)
+    {
+        value = valueOrParameters;
+    }
+    else
+    {
+        value = valueOrParameters.value;
+        dontEscape = valueOrParameters.dontEscape;
+    }
+
+    let result: string;
+    if (value === undefined)
+    {
+        result = "undefined";
+    }
+    else if (value === null)
+    {
+        result = "null";
+    }
+    else
+    {
+        if (!dontEscape)
+        {
+            dontEscape = [];
+        }
+
+        result = "";
+        for (const character of value)
+        {
+            if (dontEscape.includes(character))
+            {
+                result += character;
+            }
+            else
+            {
+                switch (character)
+                {
+                    case "\n":
+                        result += "\\n";
+                        break;
+
+                    case "\r":
+                        result += "\\r";
+                        break;
+
+                    case "\t":
+                        result += "\\t";
+                        break;
+
+                    case "\'":
+                        result += "\\\'";
+                        break;
+
+                    case "\"":
+                        result += "\\\"";
+                        break;
+
+                    default:
+                        result += character;
+                        break;
+                }
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * Get a version of the provided value that is quoted with the provided quote.
+ * @param value The value to quote.
+ * @param quote The quotes to surround the provided value with.
+ */
+export function quote(value: string | undefined | null, quote?: string): string;
+/**
+ * Get a version of the provided value that is quoted with the provided quote.
+ * @param parameters The parameters to use to invoke this function.
+ */
+export function quote(parameters: { value: string | undefined | null, quote?: string }): string;
+export function quote(valueOrParameters: string | undefined | null | { value: string | undefined | null, quote?: string }, quote?: string): string
+{
+    let value: string | undefined | null;
+    if (isString(valueOrParameters) || valueOrParameters === undefined || valueOrParameters === null)
+    {
+        value = valueOrParameters;
+    }
+    else
+    {
+        value = valueOrParameters.value;
+        quote = valueOrParameters.quote;
+    }
+
+    let result: string;
+    if (value === undefined)
+    {
+        result = "undefined";
+    }
+    else if (value === null)
+    {
+        result = "null";
+    }
+    else
+    {
+        if (quote === undefined)
+        {
+            quote = "\"";
+        }
+        result = `${quote}${value}${quote}`;
+    }
+    return result;
+}
+
+/**
+ * Get a version of the provided value where the characters are escaped and quoted.
+ * @param value The value to escape and quote.
+ * @param quoteString The quote to surround the value with.
+ * @param dontEscape The characters to not escape.
+ */
+export function escapeAndQuote(value: string | undefined | null, quoteString?: string, dontEscape?: string[]): string;
+export function escapeAndQuote(parameters: { value: string | undefined | null, quoteString?: string, dontEscape?: string[] }): string;
+export function escapeAndQuote(valueOrParameters: string | undefined | null | { value: string | undefined | null, quoteString?: string, dontEscape?: string[] }, quoteString?: string, dontEscape?: string[]): string
+{
+    let value: string | undefined | null;
+    if (isString(valueOrParameters) || valueOrParameters === undefined || valueOrParameters === null)
+    {
+        value = valueOrParameters;
+    }
+    else
+    {
+        value = valueOrParameters.value;
+        quoteString = valueOrParameters.quoteString;
+        dontEscape = valueOrParameters.dontEscape;
+    }
+
+    let result: string;
+    if (value === undefined)
+    {
+        result = "undefined";
+    }
+    else if (value === null)
+    {
+        result = "null";
+    }
+    else
+    {
+        result = escape(value, dontEscape);
+        result = quote(result, quoteString);
+    }
+    return result;
+}
+
+/**
+ * Get whether the provided value only contains whitespace characters.
+ * @param value The value to check.
+ */
+export function isWhitespace(value: string): boolean
+{
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    PreCondition.assertSame(1, value.length, "value.length");
+
+    let result: boolean = true;
+    switch (value[0])
+    {
+        case " ":
+        case "\r":
+        case "\n":
+        case "\t":
+            result = true;
+            break;
+
+        default:
+            result = false;
+            break;
+    }
+    return result;
+}
+
+/**
+ * Get whether the provided value only contains letters.
+ * @param value The value to check.
+ */
+export function isLetter(value: string): boolean
+{
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    PreCondition.assertSame(1, value.length, "value.length");
+    
+    const character: string = value[0];
+    let result: boolean = false;
+    if ("A" <= character)
+    {
+        result = (character <= "Z");
+        if (!result && "a" <= character)
+        {
+            result = (character <= "z");
+        }
+    }
+    return result;
+}
+
+/**
+ * Get whether the provided value only contains letters.
+ * @param value The value to check.
+ */
+export function isLowercasedLetter(value: string): boolean
+{
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    PreCondition.assertSame(1, value.length, "value.length");
+
+    const character: string = value[0];
+    return ("a" <= character && character <= "z");
+}
+
+/**
+ * Get whether the provided value only contains letters.
+ * @param value The value to check.
+ */
+export function isUppercasedLetter(value: string): boolean
+{
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    PreCondition.assertSame(1, value.length, "value.length");
+
+    const character: string = value[0];
+    return ("A" <= character && character <= "Z");
+}
+
+/**
+ * Get whether the provided value only contains digits.
+ * @param value The value to check.
+ */
+export function isDigit(value: string): boolean
+{
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    PreCondition.assertSame(1, value.length, "value.length");
+
+    const character: string = value[0];
+    return ("0" <= character && character <= "9");
+}
+
+/**
+ * Get whether the provided value only contains letters and digits.
+ * @param value The value to check.
+ */
+export function isLetterOrDigit(value: string): boolean
+{
+    PreCondition.assertNotUndefinedAndNotNull(value, "value");
+    PreCondition.assertSame(1, value.length, "value.length");
+
+    const character: string = value[0];
+    let result: boolean = false;
+    if ("0" <= character)
+    {
+        result = (character <= "9");
+        if (!result && "A" <= character)
+        {
+            result = (character <= "Z");
+            if (!result && "a" <= character)
+            {
+                result = (character <= "z");
+            }
+        }
+    }
+    return result;
+}