TouchDevelop/lib/String.ts

///<reference path='refs.ts'/>
module TDev.RT {
    //? A piece of text
    //@ stem("s") icon("ABC") immutable isData builtin ctx(general,indexkey,cloudfield,walltap,enumerable,json)
    export module String_
    {

        //? Returns a string collection that contains the substrings in this string that are delimited by elements of a specified string.
        //@ [separator].defl(",")
        //@ [result].writesMutable
        //@ robust
        export function split(self:string, separator:string) : Collection<string> { return Collection.mkStrings(self.split(separator)); }

        export function valueFromKeyUrl(url: string) {
            if (/^apikey:/i.test(url))
                return Web.url_decode(url.substring("apikey:".length));
            return null;
        }

        export function valueToKeyUrl(value: string) {
            return "apikey:" + Web.url_encode(value);
        }

        export function valueFromArtUrl(url: string) {
            var m = /^data:[^,]*base64,/i.exec(url)
            if (m)
                return Web.base64_decode(url.substring(m[0].length));
            return null;
        }

        export function valueToArtUrl(value: string) {
            return "data:text/plain;base64," + Web.base64_encode(value);
        }

        export function fromArtUrl(url: string) {
            var value = valueFromArtUrl(url);
            if (value) return Promise.wrap(value);

            var key = valueFromKeyUrl(url);
            if (key) return ApiManager.getKeyAsync(key);

            return ArtCache.getArtAsync(url)
                .then(dataUrl => {
                    if (dataUrl) return Promise.as(valueFromArtUrl(dataUrl));
                    else Util.httpGetTextAsync(url)
                })
                .then(txt => txt, e => { 
                    App.logEvent(App.ERROR, "art", lf("failed to load url {0}", url), undefined);
                    return ""
                });
        }

        //? Trims the string at the given length and adds ``...`` if necessary
        //@ [lim].defl(140)
        export function trim_overflow(self: string, lim: number): string {
            var v = self;
            if (v && v.length > lim)
                v = v.slice(0, lim) + "...";
            return v;
        }

        //? Displays string on the wall
        export function post_to_wall(self:string, s:IStackFrame)
        {
		    // backdoor for session testing
            if (dbg && self != null && self.indexOf("magic trap ") == 0) {
               var tests = new Revisions.SessionTests(s.rt);
               tests.runtest(self.substr(11));
               return; 
            }

            if (self != null) {

                if (s.rt.onCssPage())
                    s.rt.postUnboxedText(self, s.pc);
                else
                  s.rt.postBoxedTextWithTap(self, self, s.pc);
            }
        }

        //? Returns the number of characters
        //@ robust
        export function count(self:string):number { return self.length; }

        //? Gets the charecter unicode value at a given index. Returns NaN if out of bounds
        export function code_at(self: string, index: number): number { return self.charCodeAt(index); }

        //? Gets the character at a specified index. Returns invalid if out of bounds.
        export function at(self:string, index:number):string { return index < 0 || index >= self.length ? undefined : self.charAt(index); }

        //? Returns a copy of this string converted to lowercase, using the casing rules of the current culture.
        //@ robust
        export function to_lower_case(self:string) : string { return self.toLocaleLowerCase(); }

        //? Returns a copy of this string converted to uppercase, using the casing rules of the current culture.
        //@ robust
        export function to_upper_case(self:string) : string { return self.toLocaleUpperCase(); }

        //? Converts a single character string into its unicode number
        export function to_unicode(self:string) : number { return self.length == 1 ? self.charCodeAt(0) : undefined; }

        //? Compares two pieces of text
        //@ robust
        export function compare(self:string, other:string) : number
        {
            var r = self.localeCompare(other); 
            if (r < 0) return -1;
            if (r > 0) return 1;
            return 0;
        }

        //? Concatenates two pieces of text
        //@ robust
        export function concat(self:string, other:string) : string { return self + other; }

        //? Concatenates two pieces of text
        //@ name("\u2225") infixPriority(6)
        //@ robust
        export function concat_op(self:string, other:string) : string { return self + other; }

        //@ robust
        export function concatAny(a:any, b:any) : string
        {
            function toStr(v:any) {
                if (v === undefined || v === null) return "(invalid)";
                if (typeof v == "string") return v;
                if (typeof v == "JsonObject") return v.toString();
                if (v.to_string) return v.to_string();
                return v + "";
            }
            return toStr(a) + toStr(b);
        }

        //? Returns a value indicating if the second string is contained
        //@ robust
        export function contains(self:string, value:string) : boolean { return self.indexOf(value) > -1; }

        //? Checks if two strings are the same
        //@ robust
        export function equals(self:string, other:string) : boolean { return self == other; }

        //? Determines whether the ending matches the specified string
        //@ robust
        export function ends_with(self:string, value:string) : boolean 
        {
            var i = self.lastIndexOf(value);
            return i > -1 && i == (self.length - value.length); // TODO: more efficient implementation
        }

        //? Returns the index of the first occurence if found starting at a given position
        //@ robust
        export function index_of(self:string, value:string, start:number) : number { return self.indexOf(value, start); }

        //? Inserts a string at a given position
        export function insert(self: string, start: number, value: string): string
        {
            if (!value) return self;
            if (start < 0 || start > self.length) return undefined;

            return self.slice(0, start) + value + self.slice(start);
        }

        //? Indicates if the string is empty
        //@ robust
        export function is_empty(self:string) : boolean { return self.length == 0; }

        //? Indicates if the string matches a regular expression
        export function is_match_regex(self: string, pattern: string): boolean
        {
            var rx = new RegExp(pattern, "gm");
            return rx.test(self);
        }

        //? Returns the index of the last occurence if found starting at a given position
        //@ robust
        export function last_index_of(self:string, value:string, start:number) : number { return self.lastIndexOf(value, start); }

        //? Gets the groups from the matching the regex expression (pattern)
        export function match(self: string, pattern: string): Collection<string> 
        {
            try {
                var rx = new RegExp(pattern, "m");
                var r = rx.exec(self);
                if (!r)
                    return Collections.create_string_collection();
                return Collection.mkStrings(Util.toArray(r));
            }
            catch (e) {
                Time.log('invalid regex pattern: ' + pattern);
                return Collections.create_string_collection();
            }
        }

        //? Gets the strings matching the regex expression (pattern)
        export function matches(self: string, pattern: string): Collection<string>
        {
            try {
                var rx = new RegExp(pattern, "gm");
                var r = self.match(rx);
                return Collection.mkStrings(r || []);
            }
            catch (e) {
                Time.log('invalid regex pattern: ' + pattern);
                return Collections.create_string_collection();
            }
        }

        //? Returns the string with characters removed starting at a given index
        //@ robust
        export function remove(self:string, start:number) : string { return self.slice(0, start); }

        //? Returns a given string with a replacement
        //@ robust
        export function replace(self: string, old: string, new_: string): string {
            if (!old) return self;
            return self.split(old).join(new_);
        }

        //? Replace every match of the regex according to the replacement string
        export function replace_regex(self: string, pattern: string, replace: string): string
        {
            try 
            {
                var rx = new RegExp(pattern, "gm");
                return self.replace(rx, replace);
            }
            catch (e) 
            {
                Time.log('invalid regex pattern: ' + pattern);
                return undefined;
            }
        }

        //? Run `replacer` on every match of the regex
        export function replace_regex_with_converter(self: string, pattern: string, replace: StringConverter<Collection<string>>, s:IStackFrame): string
        {
            try 
            {
                var rx = new RegExp(pattern, "gm");
            }
            catch (e) 
            {
                Time.log('invalid regex pattern: ' + pattern);
                return undefined;
            }

            return self.replace(rx, (...args:string[]) =>
                s.rt.runUserAction(replace, [Collection.fromArray(args, "string")]))
        }

        //? Determines whether the beginning matches the specified string
        export function starts_with(self:string, value:string) : boolean {
            return self.indexOf(value) == 0; // TODO: more efficient implementation
        }

        //? Returns a substring given a start index and a length
        export function substring(self:string, start:number, length:number) : string { return self.substr(start, length); }

        //? Removes all leading and trailing occurrences of a set of characters specified in a string from the current string.
        //@ [chars].defl(" \t")
        //@ robust
        export function trim(self: string, chars: string): string
        {
            if (!self || !chars) return self;

            return trim_start(trim_end(self, chars), chars);
        }

        //? Removes all leading occurrences of a set of characters specified in a string from the current string.
        //@ [chars].defl(" \t")
        //@ robust
        export function trim_start(self:string, chars:string) : string
        {
            if (!self || !chars) return self;

            var i = 0;
            for(; i < self.length && chars.indexOf(self[i]) > -1; i++) {}
            return self.substr(i);
        }

        //? Removes all trailing occurrences of a set of characters specified in a string from the current string.
        //@ [chars].defl(" \t")
        //@ robust
        export function trim_end(self: string, chars: string): string
        {
            if (!self || !chars) return self;

            var i = self.length;
            for(; i > 0 && chars.indexOf(self[i-1]) > -1; i--) {}
            return self.substring(0, i);
        }

        //? Parses the string as a time (12:30:12) and returns the number of seconds.
        export function to_time(self: string): number
        {
            if (self != null) {
                var s = trim(self, ' \t\n\r');
                var m = s.match(/(\d{1,2})\s*:\s*(\d{1,2})\s*(:\s*(\d{1,2}))?\s*(pm|am)?/i);
                if (m) {
                    var hours = parseFloat(m[1]);
                    if (m[5] && /pm/i.test(m[5])) hours += 12;
                    var minutes = parseFloat(m[2]);
                    var seconds = m[4] ? parseFloat(m[4]) : 0;
                    return Math_.clamp(0, 23, hours) * 3600 + Math_.clamp(0, 59, minutes) * 60 + seconds;
                }
            }
            return undefined;
        }

        //? Parses the string as a number
        export function to_number(self:string) : number
        {
            // TODO: localization
            if (/^\s*[-+]?\d*\.?(\d+([eE][-+]?\d+)?)?\s*$/.test(self)) {
                var r = parseFloat(self);
                if (isNaN(r)) return undefined;
                return r;
            } else {
                return undefined;
            }
        }

        //? Parses the string as a boolean
        export function to_boolean(self:string) : boolean { return self.trim().toLocaleLowerCase() == "true"; }

        //? Parses the string as a geo coordinate.
        export function to_location(self: string): Location_
        {
            var s = trim_start(trim_end(self, ")}] "), "([{ ");
            var seps = ',;:';
            for (var i = 0; i < seps.length; ++i) {
                var index = s.indexOf(seps[i]);
                if (index > -1) {
                    var lat = to_number(s.substring(0, index));
                    var long = to_number(s.substring(index + 1));
                    if (lat && long && !isNaN(lat) && !isNaN(long)) {
                        return Location_.mkShort(lat, long);
                    }
                }
            }
            return undefined;
        }

        //? Shares the string (email, sms, facebook, social or '' to pick from a list)
        //@ uiAsync flow(SinkSharing)
        //@ [network].defl("social")
        export function share(self: string, network: string, r : ResumeCtx): void
        {
            HTML.showProgressNotification(lf("sharing text..."));
            ShareManager.shareTextAsync(self, network)
                    .done(() => r.resume());
        }

        // Stores text in the clipboard

        //? Stores text in the clipboard
        //@ flow(SinkClipboard) uiAsync
        export function copy_to_clipboard(self:string, r : ResumeCtx) : void
        {
            ShareManager.copyToClipboardAsync(self).done(() => r.resume());
        }

        //? Parses the string as a date and time.
        export function to_datetime(self:string) : DateTime { return DateTime.parse(self); }

        //? Parses the string as a color.
        export function to_color(self: string): Color { return Color.fromHtml(self); }

        export function picker()
        {
            var inp = HTML.mkTextInput("text", lf("color"));
            return <IPicker>{
                html: inp,
                validate: () => true,
                get: () => inp.value,
                set: function(v) { inp.value = v + "" }
            };
        }

        //? Converts the value into a json data structure.
        export function to_json(self: string): JsonObject {
            return JsonObject.wrap(self);
        }
    }
}