[upd] plankton

lib/plankton/plankton.d.ts

@@ -1350,3 +1350,242 @@ declare namespace lib_plankton.args {
         }): string;
     }
 }
+declare var plain_text_to_html: (text: string) => string;
+/**
+ * @desc makes a valid
+ */
+declare var format_sentence: (str: string, rtl?: boolean, caseSense?: boolean) => string;
+declare var fill_string_template: (template_string: string, object: any, fabric: Function, delimiter: string, default_string: string, sloppy: boolean) => string;
+declare var make_string_template: (_template: string, _fabrics?: Object) => (object: {
+    [key: string]: string;
+}) => string;
+declare var make_eml_header: (object: {
+    [key: string]: string;
+}) => string;
+declare var make_eml_body: Object;
+declare namespace lib_plankton.string {
+    /**
+     * @author neuc,frac
+     */
+    function empty(str: string): boolean;
+    /**
+     * @desc returns a unique string
+     * @param {string} prefix an optional prefix for the generated string
+     * @return {string}
+     * @author fenris
+     */
+    function generate(prefix?: string): string;
+    /**
+     * @author fenris
+     */
+    function join(parts: Array<string>, glue?: string): string;
+    /**
+     * @desc splits a string, but returns an empty list, if the string is empty
+     * @param {string} chain
+     * @param {string} separator
+     * @return {Array<string>}
+     * @author fenris
+     */
+    function split(chain: string, separator?: string): Array<string>;
+    /**
+     * @author neu3no
+     */
+    function explode(str: string, needle: string, max: int): Array<string>;
+    /**
+     * @desc concats a given word with itself n times
+     * @param {string} word
+     * @param {int}
+     * @return {string}
+     * @author fenris
+     */
+    function repeat(word: string, count: int): string;
+    /**
+     * @desc lengthens a string by repeatedly appending or prepending another string
+     * @param {string} word the string to pad
+     * @param {int} length the length, which the result shall have
+     * @param {string} symbol the string, which will be added (multiple times)
+     * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
+     * @return {string} the padded string
+     * @author fenris
+     */
+    function pad(word: string, length: int, symbol?: string, mode?: string): string;
+    /**
+     * @desc checks if a given string conttains a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author fenris
+     */
+    function contains(chain: string, part: string): boolean;
+    /**
+     * @desc checks if a given string starts with a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author fenris
+     */
+    function startsWith(chain: string, part: string): boolean;
+    /**
+     * @desc checks if a given string ends with a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author fenris
+     */
+    function endsWith(chain: string, part: string): boolean;
+    /**
+     * @desc count the occourrences of a string in a string
+     * @param string haystack_string the string wich should be examined
+     * @param string needle_string the string which should be counted
+     * @author neuc
+     */
+    function count_occourrences(haystack_string: string, needle_string: string, check_escape: boolean): int;
+    /**
+     * @author fenris
+     */
+    function replace(str: string, replacements: Array<{
+        from: string;
+        to: string;
+    }>, options?: {}): string;
+    /**
+     * @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
+     * @author fenris
+     */
+    function coin(str: string, args: {
+        [id: string]: string;
+    }, options?: {
+        legacy?: boolean;
+        open?: string;
+        close?: string;
+    }): string;
+    /**
+     * @author fenris
+     * @deprecated use limit
+     */
+    function cut(str: string, length: int, delimiter?: string): string;
+    /**
+     */
+    function limit(str: string, options?: {
+        length?: int;
+        indicator?: string;
+    }): string;
+    /**
+     */
+    function slice(str: string, size: int): Array<string>;
+}
+/**
+ * @deprecated
+ */
+declare namespace lib_string {
+    const empty: typeof lib_plankton.string.empty;
+    const generate: typeof lib_plankton.string.generate;
+    const split: typeof lib_plankton.string.split;
+    const explode: typeof lib_plankton.string.repeat;
+    const repeat: typeof lib_plankton.string.repeat;
+    const pad: typeof lib_plankton.string.pad;
+    const contains: typeof lib_plankton.string.contains;
+    const startsWith: typeof lib_plankton.string.startsWith;
+    const endsWith: typeof lib_plankton.string.endsWith;
+    const count_occourrences: typeof lib_plankton.string.count_occourrences;
+    const coin: typeof lib_plankton.string.coin;
+    const stance: typeof lib_plankton.string.coin;
+    const cut: typeof lib_plankton.string.cut;
+}
+declare namespace lib_plankton.string {
+    /**
+     * an implementation of c sprintf
+     * @param {string} string format string
+     * @param {array} args arguments which should be filled into
+     * @returns {string}
+     */
+    var sprintf: (input: string, args?: Array<any>, original?: any) => string;
+    /**
+     * an implementation of c printf
+     * @param {string} string format string
+     * @param {array} args arguments which should be filled into
+     * @returns {string}
+     */
+    function printf(format: any, args: any): void;
+}
+declare var sprintf: (input: string, args?: Array<any>, original?: any) => string;
+declare var printf: typeof lib_plankton.string.printf;
+declare var eml_log: any;
+declare var track_exports: any;
+declare var make_logger: (prefix: any, current_loglevel: any) => (obj: any, lvl: any) => void;
+/**
+ * @author fenris
+ */
+declare namespace lib_plankton.xml {
+    /**
+     * @author fenris
+     */
+    abstract class class_node {
+        /**
+         * @author fenris
+         */
+        abstract compile(depth?: int): string;
+    }
+    /**
+     * @author fenris
+     */
+    class class_node_text extends class_node {
+        /**
+         * @author fenris
+         */
+        protected content: string;
+        /**
+         * @author fenris
+         */
+        constructor(content: string);
+        /**
+         * @author fenris
+         */
+        compile(depth?: int): string;
+    }
+    /**
+     * @author fenris
+     */
+    class class_node_comment extends class_node {
+        /**
+         * @author fenris
+         */
+        protected content: string;
+        /**
+         * @author fenris
+         */
+        constructor(content: string);
+        /**
+         * @author fenris
+         */
+        compile(depth?: int): string;
+    }
+    /**
+     * @author fenris
+     */
+    class class_node_complex extends class_node {
+        /**
+         * @author fenris
+         */
+        protected name: string;
+        /**
+         * @author fenris
+         */
+        protected attributes: {
+            [key: string]: string;
+        };
+        /**
+         * @author fenris
+         */
+        protected children: Array<class_node>;
+        /**
+         * @author fenris
+         */
+        constructor(name: string, attributes?: {
+            [key: string]: string;
+        }, children?: any[]);
+        /**
+         * @author fenris
+         */
+        compile(depth?: int): string;
+    }
+}

tools/update-plankton

@@ -13,6 +13,8 @@ modules="${modules} call"
 modules="${modules} json"
 modules="${modules} file"
 modules="${modules} args"
+modules="${modules} string"
+modules="${modules} xml"
 
 
 ## exec