@kumologica/sdk 3.0.0

package/src/app/ui/editor-client/src/vendor/jquery/js/jquery.ui.touch-punch.min.js

@@ -0,0 +1,11 @@
+/*!
+ * jQuery UI Touch Punch 0.2.3
+ *
+ * Copyright 2011–2014, Dave Furfero
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * Depends:
+ *  jquery.ui.widget.js
+ *  jquery.ui.mouse.js
+ */
+!function(a){function f(a,b){if(!(a.originalEvent.touches.length>1)){a.preventDefault();var c=a.originalEvent.changedTouches[0],d=document.createEvent("MouseEvents");d.initMouseEvent(b,!0,!0,window,1,c.screenX,c.screenY,c.clientX,c.clientY,!1,!1,!1,!1,0,null),a.target.dispatchEvent(d)}}if(a.support.touch="ontouchend"in document,a.support.touch){var e,b=a.ui.mouse.prototype,c=b._mouseInit,d=b._mouseDestroy;b._touchStart=function(a){var b=this;!e&&b._mouseCapture(a.originalEvent.changedTouches[0])&&(e=!0,b._touchMoved=!1,f(a,"mouseover"),f(a,"mousemove"),f(a,"mousedown"))},b._touchMove=function(a){e&&(this._touchMoved=!0,f(a,"mousemove"))},b._touchEnd=function(a){e&&(f(a,"mouseup"),f(a,"mouseout"),this._touchMoved||f(a,"click"),e=!1)},b._mouseInit=function(){var b=this;b.element.bind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),c.call(b)},b._mouseDestroy=function(){var b=this;b.element.unbind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),d.call(b)}}}(jQuery);

package/src/app/ui/editor-client/src/vendor/jsonata/formatter.js

@@ -0,0 +1,183 @@
+(function() {
+    function indentLine(str,length) {
+        if (length <= 0) {
+            return str;
+        }
+        var i = (new Array(length)).join(" ");
+        str = str.replace(/^\s*/,i);
+        return str;
+    }
+    function formatExpression(str) {
+        var length = str.length;
+        var start = 0;
+        var inString = false;
+        var inBox = false;
+        var quoteChar;
+        var list = [];
+        var stack = [];
+        var frame;
+        var v;
+        var matchingBrackets = {
+            "(":")",
+            "[":"]",
+            "{":"}"
+        }
+        for (var i=0;i<length;i++) {
+            var c = str[i];
+            if (!inString) {
+                if (c === "'" || c === '"') {
+                    inString = true;
+                    quoteChar = c;
+                    frame = {type:"string",pos:i};
+                    list.push(frame);
+                    stack.push(frame);
+                } else if (c === ";") {
+                    frame = {type:";",pos:i};
+                    list.push(frame);
+                } else if (c === ",") {
+                    frame = {type:",",pos:i};
+                    list.push(frame);
+                } else if (/[\(\[\{]/.test(c)) {
+                    frame = {type:"open-block",char:c,pos:i};
+                    list.push(frame);
+                    stack.push(frame);
+                } else if (/[\}\)\]]/.test(c)) {
+                    var oldFrame = stack.pop();
+                    if (matchingBrackets[oldFrame.char] !== c) {
+                        //console.log("Stack frame mismatch",c,"at",i,"expected",matchingBrackets[oldFrame.char],"from",oldFrame.pos);
+                        return str;
+                    }
+                    //console.log("Closing",c,"at",i,"compare",oldFrame.type,oldFrame.pos);
+                    oldFrame.width = i-oldFrame.pos;
+                    frame = {type:"close-block",pos:i,char:c,width:oldFrame.width}
+                    list.push(frame);
+                }
+            } else {
+                if (c === quoteChar) {
+                    // Next char must be a ]
+                    inString = false;
+                    stack.pop();
+                }
+            }
+
+        }
+        // console.log(stack);
+        var result = str;
+        var indent = 0;
+        var offset = 0;
+        var pre,post,indented;
+        var longStack = [];
+        list.forEach(function(f) {
+            if (f.type === ";" || f.type === ",") {
+                if (longStack[longStack.length-1]) {
+                    pre = result.substring(0,offset+f.pos+1);
+                    post = result.substring(offset+f.pos+1);
+                    indented = indentLine(post,indent);
+                    result = pre+"\n"+indented;
+                    offset += indented.length-post.length+1;
+                }
+            } else if (f.type === "open-block") {
+                if (f.width > 30) {
+                    longStack.push(true);
+                    indent += 4;
+                    pre = result.substring(0,offset+f.pos+1);
+                    post = result.substring(offset+f.pos+1);
+                    indented = indentLine(post,indent);
+                    result = pre+"\n"+indented;
+                    offset += indented.length-post.length+1;
+                } else {
+                    longStack.push(false);
+                }
+            } else if (f.type === "close-block") {
+                if (f.width > 30) {
+                    indent -= 4;
+                    pre = result.substring(0,offset+f.pos);
+                    post = result.substring(offset+f.pos);
+                    indented = indentLine(post,indent);
+                    result = pre+"\n"+indented;
+                    offset += indented.length-post.length+1;
+                }
+                longStack.pop();
+            }
+        })
+        //console.log(result);
+        return result;
+    }
+
+    jsonata.format = formatExpression;
+    jsonata.functions =
+    {
+        '$abs':{ args:[ 'number' ]},
+        '$append':{ args:[ 'array1', 'array2' ]},
+        '$average':{ args:[ 'array' ]},
+        '$base64decode':{ args:[  ]},
+        '$base64encode':{ args:[  ]},
+        '$boolean':{ args:[ 'arg' ]},
+        '$ceil':{ args:[ 'number' ]},
+        '$contains':{ args:[ 'str', 'pattern' ]},
+        '$count':{ args:[ 'array' ]},
+        '$each':{ args:[ 'object', 'function' ]},
+        '$env': { args:[ 'string' ]},
+        '$eval': { args: ['expr', 'context']},
+        '$exists':{ args:[ 'arg' ]},
+        '$filter':{ args:[ 'array', 'function' ]},
+        '$floor':{ args:[ 'number' ]},
+        '$flowContext': {args:['string']},
+        '$formatBase': {args:['number','radix']},
+        '$formatInteger': {args:['number', 'picture']},
+        '$formatNumber': {args:['number', 'picture', 'options']},
+        '$fromMillis': {args:['number']},
+        '$globalContext': {args:['string']},
+        '$join':{ args:[ 'array', 'separator' ]},
+        '$keys':{ args:[ 'object' ]},
+        '$length':{ args:[ 'str' ]},
+        '$lookup':{ args:[ 'object', 'key' ]},
+        '$lowercase':{ args:[ 'str' ]},
+        '$map':{ args:[ 'array', 'function' ]},
+        '$match':{ args:[ 'str', 'pattern', 'limit' ]},
+        '$max':{ args:[ 'array' ]},
+        '$merge':{ args:[ 'array' ]},
+        '$millis':{ args:[  ]},
+        '$min':{ args:[ 'array' ]},
+        '$not':{ args:[ 'arg' ]},
+        '$now':{ args:[  ]},
+        '$number':{ args:[ 'arg' ]},
+        '$pad': {args:['str', 'width','char']},
+        '$parseInteger': {args:['string', 'picture']},
+        '$power':{ args:[ 'base', 'exponent' ]},
+        '$random':{ args:[  ]},
+        '$reduce':{ args:[ 'array', 'function' , 'init' ]},
+        '$replace':{ args:[ 'str', 'pattern', 'replacement', 'limit' ]},
+        '$reverse':{ args:[ 'array' ]},
+        '$round':{ args:[ 'number', 'precision' ]},
+        '$shuffle':{ args:[ 'array' ]},
+        '$sift':{ args:[ 'object', 'function' ]},
+        '$sort':{ args:[ 'array', 'function' ]},
+        '$split':{ args:[ 'str', 'separator', 'limit' ]},
+        '$spread':{ args:[ 'object' ]},
+        '$sqrt':{ args:[ 'number' ]},
+        '$string':{ args:[ 'arg' ]},
+        '$substring':{ args:[ 'str', 'start', 'length' ]},
+        '$substringAfter':{ args:[ 'str', 'chars' ]},
+        '$substringBefore':{ args:[ 'str', 'chars' ]},
+        '$sum':{ args:[ 'array' ]},
+        '$toMillis':{args:['timestamp']}, // <-------------
+        '$trim':{ args:[ 'str' ]},
+        '$uppercase':{ args:[ 'str' ]},
+        '$zip':{ args:[ 'array1' ]},
+        '$vars': {args:['string']},
+        '$single': {args:['array','function']}
+    }
+    jsonata.getFunctionSnippet = function(fn) {
+        var snippetText = "";
+        if (jsonata.functions.hasOwnProperty(fn)) {
+            var def = jsonata.functions[fn];
+            snippetText = "\\"+fn+"(";
+            if (def.args) {
+                snippetText += def.args.map(function(a,i) { return "${"+(i+1)+":"+a+"}"}).join(", ");
+            }
+            snippetText += ")\n"
+        }
+        return snippetText;
+    }
+})();

package/src/app/ui/editor-client/src/vendor/jsonata/mode-jsonata.js

@@ -0,0 +1,134 @@
+ace.define("ace/mode/jsonata",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules","ace/worker/worker_client","ace/mode/text"], function(require, exports, module) {
+
+    "use strict";
+
+    var oop = require("../lib/oop");
+    var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+
+    var WorkerClient = require("../worker/worker_client").WorkerClient;
+    var jsonataFunctions = Object.keys(jsonata.functions);
+    // sort in length order (long->short) otherwise substringAfter gets matched
+    // as substring etc.
+    jsonataFunctions.sort(function(A,B) {
+        return B.length-A.length;
+    });
+    jsonataFunctions = jsonataFunctions.join("|").replace(/\$/g,"\\$");
+
+    var JSONataHighlightRules = function() {
+
+        var keywordMapper = this.createKeywordMapper({
+            "keyword.operator":
+            "and|or|in",
+            "constant.language":
+            "null|Infinity|NaN|undefined",
+            "constant.language.boolean":
+            "true|false",
+            "storage.type":
+            "function"
+        }, "identifier");
+        this.$rules = {
+            "start" : [
+                {
+                    token : "string",
+                    regex : "'(?=.)",
+                    next  : "qstring"
+                },
+                {
+                    token : "string",
+                    regex : '"(?=.)',
+                    next  : "qqstring"
+                },
+                {
+                    token : "constant.numeric", // hex
+                    regex : /0(?:[xX][0-9a-fA-F]+|[bB][01]+)\b/
+                },
+                {
+                    token : "constant.numeric", // float
+                    regex : /[+-]?\d[\d_]*(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/
+                },
+                {   token: "keyword",
+                regex: /λ/
+            },
+            {
+                token: "keyword",
+                regex: jsonataFunctions
+            },
+            {
+                token : keywordMapper,
+                regex : "[a-zA-Z\\$_\u00a1-\uffff][a-zA-Z\\d\\$_\u00a1-\uffff]*"
+            },
+            {
+                token : "punctuation.operator",
+                regex : /[.](?![.])/
+            },
+            {
+                token : "keyword.operator",
+                regex : /\|\||<=|>=|\.\.|\*\*|!=|:=|[=<>`!$%&*+\-~\/^]/,
+                next  : "start"
+            },
+            {
+                token : "punctuation.operator",
+                regex : /[?:,;.]/,
+                next  : "start"
+            },
+            {
+                token : "paren.lparen",
+                regex : /[\[({]/,
+                    next  : "start"
+                },
+                {
+                    token : "paren.rparen",
+                    regex : /[\])}]/
+                }
+            ],
+            "qqstring" : [
+                {
+                    token : "string",
+                    regex : '"|$',
+                    next  : "start"
+                }, {
+                    defaultToken: "string"
+                }
+            ],
+            "qstring" : [
+                {
+                    token : "string",
+                    regex : "'|$",
+                    next  : "start"
+                }, {
+                    defaultToken: "string"
+                }
+            ]
+        };
+    };
+
+    oop.inherits(JSONataHighlightRules, TextHighlightRules);
+
+    var TextMode = require("./text").Mode;
+    var Mode = function() {
+        this.HighlightRules = JSONataHighlightRules;
+    };
+    oop.inherits(Mode, TextMode);
+
+
+    (function() {
+        this.createWorker = function(session) {
+            var worker = new WorkerClient(["ace"], "ace/mode/jsonata_worker", "JSONataWorker");
+            worker.attachToDocument(session.getDocument());
+
+            worker.on("annotate", function(e) {
+                session.setAnnotations(e.data);
+            });
+
+            worker.on("terminate", function() {
+                session.clearAnnotations();
+            });
+
+            return worker;
+        };
+        this.$id = "ace/mode/jsonata";
+    }).call(Mode.prototype);
+
+    exports.Mode = Mode;
+
+});

package/src/app/ui/editor-client/src/vendor/jsonata/snippets-jsonata.js

@@ -0,0 +1,11 @@
+ace.define("ace/snippets/jsonata",["require","exports","module"], function(require, exports, module) {
+	"use strict";
+	var snippetText = "";
+	for (var fn in jsonata.functions) {
+		if (jsonata.functions.hasOwnProperty(fn)) {
+			snippetText += "# "+fn+"\nsnippet "+fn+"\n\t"+jsonata.getFunctionSnippet(fn)+"\n"
+		}
+	}
+	exports.snippetText = snippetText;
+	exports.scope = "jsonata";
+});