dojox.string.d.ts

// Type definitions for Dojo v1.9
// Project: http://dojotoolkit.org
// Definitions by: Michael Van Sickle <https://github.com/vansimke>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

declare namespace dojox {

    namespace string_ {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/string/sprintf.html
         *
         *
         * @param format
         * @param filler
         */
        interface sprintf { (format: String, filler: any): void }
        namespace sprintf {
            /**
             *
             * @param format
             */
            interface Formatter { (format: String): void }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/string/Builder.html
         *
         * A fast buffer for creating large strings.
         *
         * @param str       Optional
         */
        interface Builder { (str?: String): void }
        namespace Builder {
            /**
             *
             */
            var length: number
            /**
             * Append all arguments to the end of the buffer
             *
             * @param s
             */
            interface append { (s: String[]): void }
            /**
             * Append an array of items to the internal buffer.
             *
             * @param strings
             */
            interface appendArray { (strings: any[]): void }
            /**
             * Remove all characters from the buffer.
             *
             */
            interface clear { (): void }
            /**
             * Alias for append.
             *
             * @param s
             */
            interface concat { (s: String[]): void }
            /**
             * Insert string str starting at index.
             *
             * @param index
             * @param str
             */
            interface insert { (index: number, str: String): void }
            /**
             * Remove len characters starting at index start.  If len
             * is not provided, the end of the string is assumed.
             *
             * @param start
             * @param len               Optional
             */
            interface remove { (start: number, len: number): void }
            /**
             * Replace instances of one string with another in the buffer.
             *
             * @param oldStr
             * @param newStr
             */
            interface replace { (oldStr: String, newStr: String): void }
            /**
             * Return the string representation of the internal buffer.
             *
             */
            interface toString { (): void }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/string/tokenize.html
         *
         * Split a string by a regular expression with the ability to capture the delimeters
         *
         * @param str
         * @param re
         * @param parseDelim       OptionalEach group (excluding the 0 group) is passed as a parameter. If the function returnsa value, it's added to the list of tokens.
         * @param instance       OptionalUsed as the "this" instance when calling parseDelim
         */
        interface tokenize { (str: String, re: RegExp, parseDelim?: Function, instance?: Object): void }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/string/BidiEngine.html
         *
         * This class provides a bidi transformation engine, i.e.
         * functions for reordering and shaping bidi text.
         * Bidi stands for support for languages with a bidirectional script.
         *
         * Usually Unicode Bidi Algorithm used by OS platform (and web browsers) is capable of properly transforming
         * Bidi text and as a result it is adequately displayed on the screen. However, in some situations,
         * Unicode Bidi Algorithm is not invoked or is not properly applied. This may occur in situation in which software
         * responsible for rendering the text is not leveraging Unicode Bidi Algorithm implemented by OS (e.g. dojox.GFX renderers).
         *
         * Bidi engine provided in this class implements Unicode Bidi Algorithm as specified at
         * http://www.unicode.org/reports/tr9/.
         *
         * For more information on basic Bidi concepts please read
         * "Bidirectional script support - A primer" available from
         * http://www.ibm.com/developerworks/websphere/library/techarticles/bidi/bidigen.html.
         *
         * As of February 2011, Bidi engine has following limitations:
         *
         * No support for following numeric shaping options:
         * H - Hindi,
         * C - Contextual,
         * N - Nominal.
         *
         * No support for following shaping options:
         * I - Initial shaping,
         * M - Middle shaping,
         * F - Final shaping,
         * B - Isolated shaping.
         *
         * No support for source-to-target or/and target-to-source maps.
         * No support for LRE/RLE/LRO/RLO/PDF (they are handled like neutrals).
         * No support for Windows compatibility.
         * No support for  insert/remove marks.
         * No support for code pages (currently only UTF-8 is supported. Ideally we should convert from any code page to UTF-8).
         *
         */
        class BidiEngine {
            constructor();
            /**
             * Central public API for Bidi engine. Transforms the text according to formatIn, formatOut parameters.
             * If formatIn or formatOut parametrs are not valid throws an exception.
             * Both formatIn and formatOut parameters are 5 letters long strings.
             * For example - "ILYNN". Each letter is associated with specific attribute of Bidi layout.
             * Possible and default values for each one of the letters are provided below:
             *
             * First letter:
             *
             * Letter position/index:
             *   1
             * Letter meaning:
             *   Ordering Schema.
             * Possible values:
             * I - Implicit (Logical).
             * V - Visual.
             *
             * Default value:
             *   I
             * Second letter:
             *
             * Letter position/index:
             *   2
             * Letter meaning:
             *   Orientation.
             * Possible values:
             * L - Left To Right.
             * R - Right To Left.
             * C - Contextual Left to Right.
             * D - Contextual Right to Left.
             *
             * Default value:
             *   L
             * Third letter:
             *
             * Letter position/index:
             *   3
             * Letter meaning:
             *   Symmetric Swapping.
             * Possible values:
             * Y - Symmetric swapping is on.
             * N - Symmetric swapping is off.
             *
             * Default value:
             *   Y
             * Fourth letter:
             *
             * Letter position/index:
             *   4
             * Letter meaning:
             *   Shaping.
             * Possible values:
             * S - Text is shaped.
             * N - Text is not shaped.
             *
             * Default value:
             *   N
             * Fifth letter:
             *
             * Letter position/index:
             *   5
             * Letter meaning:
             *   Numeric Shaping.
             * Possible values:
             * N - Nominal.
             *
             * Default value:
             *   N
             * The output of this function is original text (passed via first argument) transformed from input Bidi layout (second argument)
             * to output Bidi layout (last argument).
             *
             * Sample call:
             *
             * mytext = bidiTransform("HELLO WORLD", "ILYNN", "VLYNN");
             * In this case, "HELLO WORLD" text is transformed from Logical - LTR to Visual - LTR Bidi layout with
             *
             * default values for symmetric swapping (Yes), shaping (Not shaped) and numeric shaping (Nominal).
             *
             * @param text
             * @param formatIn Input Bidi layout in which inputText is passed to the function.
             * @param formatOut Output Bidi layout to which inputText should be transformed.
             */
            bidiTransform(text: String, formatIn: String, formatOut: String): any;
            /**
             * Determine the base direction of a bidi text according
             * to its first strong directional character.
             *
             * @param text The text to check.
             */
            checkContextual(text: String): any;
            /**
             * Return true if text contains RTL directed character.
             * Iterates over the text string, letter by letter starting from its beginning,
             * searching for RTL directed character.
             * Return true if found else false. Needed for vml transformation.
             *
             * @param text The source string.
             */
            hasBidiChar(text: String): any;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/string/BidiComplex.html
         *
         *
         */
        interface BidiComplex {
            /**
             * Attach key listeners to the INPUT field to accomodate dynamic complex BiDi expressions
             *
             * @param field
             * @param pattern
             */
            attachInput(field: HTMLElement, pattern: String): void;
            /**
             * Create the display string by adding the Unicode direction Markers
             *
             * @param str
             * @param pattern
             */
            createDisplayString(str: String, pattern: String): void;
            /**
             * removes all Unicode directional markers from the string
             *
             * @param str
             */
            stripSpecialCharacters(str: any): void;
        }
    }

}

declare module "dojox/string/tokenize" {
    var exp: dojox.string_.tokenize
    export=exp;
}
declare module "dojox/string/sprintf" {
    var exp: dojox.string_.sprintf
    export=exp;
}
declare module "dojox/string/Builder" {
    var exp: dojox.string_.Builder
    export=exp;
}
declare module "dojox/string/BidiComplex" {
    var exp: dojox.string_.BidiComplex
    export=exp;
}
declare module "dojox/string/BidiEngine" {
    var exp: dojox.string_.BidiEngine
    export=exp;
}