@kumologica/sdk 3.0.0

package/src/app/ui/editor-client/src/js/history.js

@@ -0,0 +1,337 @@
+ 
+RED.history = (function() {
+    var undo_history = [];
+
+    function undoEvent(ev) {
+        var i;
+        var len;
+        var node;
+        var subflow;
+        var modifiedTabs = {};
+        if (ev) {
+            if (ev.t == 'multi') {
+                len = ev.events.length;
+                for (i=len-1;i>=0;i--) {
+                    undoEvent(ev.events[i]);
+                }
+            } else if (ev.t == 'replace') {
+                RED.nodes.clear();
+                var imported = RED.nodes.import(ev.config);
+                imported[0].forEach(function(n) {
+                    if (ev.changed[n.id]) {
+                        n.changed = true;
+                    }
+                })
+
+                RED.nodes.version(ev.rev);
+            } else if (ev.t == 'add') {
+                if (ev.nodes) {
+                    for (i=0;i<ev.nodes.length;i++) {
+                        node = RED.nodes.node(ev.nodes[i]);
+                        if (node.z) {
+                            modifiedTabs[node.z] = true;
+                        }
+                        RED.nodes.remove(ev.nodes[i]);
+                    }
+                }
+                if (ev.links) {
+                    for (i=0;i<ev.links.length;i++) {
+                        RED.nodes.removeLink(ev.links[i]);
+                    }
+                }
+                if (ev.workspaces) {
+                    for (i=0;i<ev.workspaces.length;i++) {
+                        RED.nodes.removeWorkspace(ev.workspaces[i].id);
+                        RED.workspaces.remove(ev.workspaces[i]);
+                    }
+                }
+                if (ev.subflows) {
+                    for (i=0;i<ev.subflows.length;i++) {
+                        RED.nodes.removeSubflow(ev.subflows[i]);
+                        RED.workspaces.remove(ev.subflows[i]);
+                    }
+                }
+                if (ev.subflow) {
+                    if (ev.subflow.instances) {
+                        ev.subflow.instances.forEach(function(n) {
+                            var node = RED.nodes.node(n.id);
+                            if (node) {
+                                node.changed = n.changed;
+                                node.dirty = true;
+                            }
+                        });
+                    }
+                    if (ev.subflow.hasOwnProperty('changed')) {
+                        subflow = RED.nodes.subflow(ev.subflow.id);
+                        if (subflow) {
+                            subflow.changed = ev.subflow.changed;
+                        }
+                    }
+                }
+                if (ev.removedLinks) {
+                    for (i=0;i<ev.removedLinks.length;i++) {
+                        RED.nodes.addLink(ev.removedLinks[i]);
+                    }
+                }
+
+            } else if (ev.t == "delete") {
+                if (ev.workspaces) {
+                    for (i=0;i<ev.workspaces.length;i++) {
+                        RED.nodes.addWorkspace(ev.workspaces[i],ev.workspaces[i]._index);
+                        RED.workspaces.add(ev.workspaces[i],undefined,ev.workspaces[i]._index);
+                        delete ev.workspaces[i]._index;
+                    }
+                }
+                if (ev.subflows) {
+                    for (i=0;i<ev.subflows.length;i++) {
+                        RED.nodes.addSubflow(ev.subflows[i]);
+                    }
+                }
+                if (ev.subflowInputs && ev.subflowInputs.length > 0) {
+                    subflow = RED.nodes.subflow(ev.subflowInputs[0].z);
+                    subflow.in.push(ev.subflowInputs[0]);
+                    subflow.in[0].dirty = true;
+                }
+                if (ev.subflowOutputs && ev.subflowOutputs.length > 0) {
+                    subflow = RED.nodes.subflow(ev.subflowOutputs[0].z);
+                    ev.subflowOutputs.sort(function(a,b) { return a.i-b.i});
+                    for (i=0;i<ev.subflowOutputs.length;i++) {
+                        var output = ev.subflowOutputs[i];
+                        subflow.out.splice(output.i,0,output);
+                        for (var j=output.i+1;j<subflow.out.length;j++) {
+                            subflow.out[j].i++;
+                            subflow.out[j].dirty = true;
+                        }
+                        RED.nodes.eachLink(function(l) {
+                            if (l.source.type == "subflow:"+subflow.id) {
+                                if (l.sourcePort >= output.i) {
+                                    l.sourcePort++;
+                                }
+                            }
+                        });
+                    }
+                }
+                if (ev.subflow) {
+                    if (ev.subflow.hasOwnProperty('instances')) {
+                        ev.subflow.instances.forEach(function(n) {
+                            var node = RED.nodes.node(n.id);
+                            if (node) {
+                                node.changed = n.changed;
+                                node.dirty = true;
+                            }
+                        });
+                    }
+                    if (ev.subflow.hasOwnProperty('status')) {
+                        subflow = RED.nodes.subflow(ev.subflow.id);
+                        subflow.status = ev.subflow.status;
+                    }
+                }
+                if (subflow) {
+                    RED.nodes.filterNodes({type:"subflow:"+subflow.id}).forEach(function(n) {
+                        n.inputs = subflow.in.length;
+                        n.outputs = subflow.out.length;
+                        while (n.outputs > n.ports.length) {
+                            n.ports.push(n.ports.length);
+                        }
+                        n.resize = true;
+                        n.dirty = true;
+                    });
+                }
+                if (ev.nodes) {
+                    for (i=0;i<ev.nodes.length;i++) {
+                        RED.nodes.add(ev.nodes[i]);
+                        modifiedTabs[ev.nodes[i].z] = true;
+                    }
+                }
+                if (ev.links) {
+                    for (i=0;i<ev.links.length;i++) {
+                        RED.nodes.addLink(ev.links[i]);
+                    }
+                }
+                if (ev.changes) {
+                    for (i in ev.changes) {
+                        if (ev.changes.hasOwnProperty(i)) {
+                            node = RED.nodes.node(i);
+                            if (node) {
+                                for (var d in ev.changes[i]) {
+                                    if (ev.changes[i].hasOwnProperty(d)) {
+                                        node[d] = ev.changes[i][d];
+                                    }
+                                }
+                                node.dirty = true;
+                            }
+                        }
+                    }
+
+                }
+            } else if (ev.t == "move") {
+                for (i=0;i<ev.nodes.length;i++) {
+                    var n = ev.nodes[i];
+                    n.n.x = n.ox;
+                    n.n.y = n.oy;
+                    n.n.dirty = true;
+                    n.n.moved = n.moved;
+                }
+                // A move could have caused a link splice
+                if (ev.links) {
+                    for (i=0;i<ev.links.length;i++) {
+                        RED.nodes.removeLink(ev.links[i]);
+                    }
+                }
+                if (ev.removedLinks) {
+                    for (i=0;i<ev.removedLinks.length;i++) {
+                        RED.nodes.addLink(ev.removedLinks[i]);
+                    }
+                }
+            } else if (ev.t == "edit") {
+                for (i in ev.changes) {
+                    if (ev.changes.hasOwnProperty(i)) {
+                        if (ev.node._def.defaults && ev.node._def.defaults[i] && ev.node._def.defaults[i].type) {
+                            // This is a config node property
+                            var currentConfigNode = RED.nodes.node(ev.node[i]);
+                            if (currentConfigNode) {
+                                currentConfigNode.users.splice(currentConfigNode.users.indexOf(ev.node),1);
+                            }
+                            var newConfigNode = RED.nodes.node(ev.changes[i]);
+                            if (newConfigNode) {
+                                newConfigNode.users.push(ev.node);
+                            }
+                        }
+                        ev.node[i] = ev.changes[i];
+                    }
+                }
+                if (ev.subflow) {
+                    if (ev.subflow.hasOwnProperty('inputCount')) {
+                        if (ev.node.in.length > ev.subflow.inputCount) {
+                            ev.node.in.splice(ev.subflow.inputCount);
+                        } else if (ev.subflow.inputs.length > 0) {
+                            ev.node.in = ev.node.in.concat(ev.subflow.inputs);
+                        }
+                    }
+                    if (ev.subflow.hasOwnProperty('outputCount')) {
+                        if (ev.node.out.length > ev.subflow.outputCount) {
+                            ev.node.out.splice(ev.subflow.outputCount);
+                        } else if (ev.subflow.outputs.length > 0) {
+                            ev.node.out = ev.node.out.concat(ev.subflow.outputs);
+                        }
+                    }
+                    if (ev.subflow.hasOwnProperty('instances')) {
+                        ev.subflow.instances.forEach(function(n) {
+                            var node = RED.nodes.node(n.id);
+                            if (node) {
+                                node.changed = n.changed;
+                                node.dirty = true;
+                            }
+                        });
+                    }
+                    if (ev.subflow.hasOwnProperty('status')) {
+                        if (ev.subflow.status) {
+                            delete ev.node.status;
+                        }
+                    }
+                    RED.editor.validateNode(ev.node);
+                    RED.nodes.filterNodes({type:"subflow:"+ev.node.id}).forEach(function(n) {
+                        n.inputs = ev.node.in.length;
+                        n.outputs = ev.node.out.length;
+                        RED.editor.updateNodeProperties(n);
+                        RED.editor.validateNode(n);
+                    });
+                } else {
+                    var outputMap;
+                    if (ev.outputMap) {
+                        outputMap = {};
+                        for (var port in ev.outputMap) {
+                            if (ev.outputMap.hasOwnProperty(port) && ev.outputMap[port] !== "-1") {
+                                outputMap[ev.outputMap[port]] = port;
+                            }
+                        }
+                    }
+                    RED.editor.updateNodeProperties(ev.node,outputMap);
+                    RED.editor.validateNode(ev.node);
+                }
+                if (ev.links) {
+                    for (i=0;i<ev.links.length;i++) {
+                        RED.nodes.addLink(ev.links[i]);
+                    }
+                }
+                ev.node.dirty = true;
+                ev.node.changed = ev.changed;
+            } else if (ev.t == "createSubflow") {
+                if (ev.nodes) {
+                    RED.nodes.filterNodes({z:ev.subflow.subflow.id}).forEach(function(n) {
+                        n.x += ev.subflow.offsetX;
+                        n.y += ev.subflow.offsetY;
+                        n.z = ev.activeWorkspace;
+                        n.dirty = true;
+                    });
+                    for (i=0;i<ev.nodes.length;i++) {
+                        RED.nodes.remove(ev.nodes[i]);
+                    }
+                }
+                if (ev.links) {
+                    for (i=0;i<ev.links.length;i++) {
+                        RED.nodes.removeLink(ev.links[i]);
+                    }
+                }
+
+                RED.nodes.removeSubflow(ev.subflow.subflow);
+                RED.workspaces.remove(ev.subflow.subflow);
+
+                if (ev.removedLinks) {
+                    for (i=0;i<ev.removedLinks.length;i++) {
+                        RED.nodes.addLink(ev.removedLinks[i]);
+                    }
+                }
+            } else if (ev.t == "reorder") {
+                if (ev.order) {
+                    RED.workspaces.order(ev.order);
+                }
+            }
+
+            Object.keys(modifiedTabs).forEach(function(id) {
+                var subflow = RED.nodes.subflow(id);
+                if (subflow) {
+                    RED.editor.validateNode(subflow);
+                }
+            });
+
+            RED.nodes.dirty(ev.dirty);
+            RED.view.select(null);
+            RED.view.redraw(true);
+            RED.palette.refresh();
+            RED.workspaces.refresh();
+            RED.sidebar.config.refresh();
+            RED.subflow.refresh();
+        }
+
+    }
+
+    return {
+        //TODO: this function is a placeholder until there is a 'save' event that can be listened to
+        markAllDirty: function() {
+            for (var i=0;i<undo_history.length;i++) {
+                undo_history[i].dirty = true;
+            }
+        },
+        list: function() {
+            return undo_history
+        },
+        depth: function() {
+            return undo_history.length;
+        },
+        push: function(ev) {
+            undo_history.push(ev);
+        },
+        pop: function() {
+            var ev = undo_history.pop();
+            undoEvent(ev);
+        },
+        peek: function() {
+            return undo_history[undo_history.length-1];
+        },
+        clear: function() {
+            undo_history = [];
+        }
+    }
+
+})();

package/src/app/ui/editor-client/src/js/i18n.js

@@ -0,0 +1,81 @@
+ 
+
+RED.i18n = (function() {
+
+    var apiRootUrl;
+
+    return {
+        init: function(options, done) {
+            apiRootUrl = options.apiRootUrl||"";
+            i18n.init({
+                resGetPath: apiRootUrl+'__locales__/__ns__?lng=__lng__',
+                dynamicLoad: false,
+                load:'current',
+                ns: {
+                    namespaces: ["editor"],
+                    defaultNs: "editor"
+                },
+                fallbackLng: ['en-US'],
+                useCookie: false,
+                returnObjectTrees: true
+            },function() {
+                done();
+            });
+            RED["_"] = function() {
+                var v = i18n.t.apply(null,arguments);
+                if (typeof v === 'string') {
+                    return v;
+                } else {
+                    return arguments[0];
+                }
+            }
+
+        },
+        loadNodeCatalog: function(namespace,done) {
+            var languageList = i18n.functions.toLanguages(i18n.detectLanguage());
+            var toLoad = languageList.length;
+            languageList.forEach(function(lang) {
+                $.ajax({
+                    headers: {
+                        "Accept":"application/json"
+                    },
+                    cache: false,
+                    url: apiRootUrl+'nodes/'+namespace+'/messages?lng='+lang,
+                    success: function(data) {
+                        i18n.addResourceBundle(lang,namespace,data);
+                        toLoad--;
+                        if (toLoad === 0) {
+                            done();
+                        }
+                    }
+                });
+            })
+
+        },
+
+        loadNodeCatalogs: function(done) {
+            var languageList = i18n.functions.toLanguages(i18n.detectLanguage());
+            var toLoad = languageList.length;
+
+            languageList.forEach(function(lang) {
+                $.ajax({
+                    headers: {
+                        "Accept":"application/json"
+                    },
+                    cache: false,
+                    url: apiRootUrl+'nodes/messages?lng='+lang,
+                    success: function(data) {
+                        var namespaces = Object.keys(data);
+                        namespaces.forEach(function(ns) {
+                            i18n.addResourceBundle(lang,ns,data[ns]);
+                        });
+                        toLoad--;
+                        if (toLoad === 0) {
+                            done();
+                        }
+                    }
+                });
+            })
+        }
+    }
+})();

package/src/app/ui/editor-client/src/js/jquery-addons.js

@@ -0,0 +1,21 @@
+ 
+
+
+/**
+ * Trigger enabled/disabled events when element.prop("disabled",false/true) is
+ * called.
+ * Used by RED.popover to hide a popover when the trigger element is disabled
+ * as a disabled element doesn't emit mouseleave
+ */
+jQuery.propHooks.disabled = {
+    set: function (element, value) {
+        if (element.disabled !== value) {
+            element.disabled = value;
+            if (value) {
+                $(element).trigger('disabled');
+            } else {
+                $(element).trigger('enabled');
+            }
+        }
+    }
+};

package/src/app/ui/editor-client/src/js/keymap.json

@@ -0,0 +1,54 @@
+{
+    "*": {
+        "ctrl-f": "core:search",
+        "ctrl-s": "core:deploy",
+        "ctrl-=": "core:zoom-in",
+        "ctrl--": "core:zoom-out",
+        "ctrl-0": "core:zoom-reset",
+        "ctrl-t": "core:toggle-terminal",
+        "ctrl-1": "core:view-main-flow",
+        "ctrl-2": "core:view-test-flow",
+        "ctrl-enter": "core:confirm-edit-tray",
+        "ctrl-escape": "core:cancel-edit-tray",
+        "ctrl-g i": "core:show-info-tab",
+        "ctrl-g d": "core:show-debug-tab",
+        "ctrl-g c": "core:show-config-tab",
+        "ctrl-g x": "core:show-context-tab",
+        "ctrl-e": "core:show-export-dialog",
+        "ctrl-i": "core:show-import-dialog",
+        "ctrl-p": "core:toggle-palette",
+        "ctrl-,": "core:toggle-settings",
+        "ctrl-alt-r": "core:show-remote-diff",
+        "ctrl-alt-n": "core:new-project",
+        "ctrl-alt-o": "core:open-project",
+        "ctrl-g v": "core:show-version-control-tab",
+        "ctrl-shift-l": "core:show-event-log"
+    },
+    "sidebar-node-config": {
+        "backspace": "core:delete-config-selection",
+        "delete": "core:delete-config-selection",
+        "ctrl-a": "core:select-all-config-nodes",
+        "ctrl-z": "core:undo"
+    },
+    "workspace": {
+        "backspace": "core:delete-selection",
+        "delete": "core:delete-selection",
+        "enter": "core:edit-selected-node",
+        "ctrl-c": "core:copy-selection-to-internal-clipboard",
+        "ctrl-x": "core:cut-selection-to-internal-clipboard",
+        "ctrl-v": "core:paste-from-internal-clipboard",
+        "ctrl-z": "core:undo",
+        "ctrl-a": "core:select-all-nodes",
+        "shift-?": "core:show-help",
+        "up": "core:move-selection-up",
+        "right": "core:move-selection-right",
+        "down": "core:move-selection-down",
+        "left": "core:move-selection-left",
+        "shift-up": "core:step-selection-up",
+        "shift-right": "core:step-selection-right",
+        "shift-down": "core:step-selection-down",
+        "shift-left": "core:step-selection-left",
+        "ctrl-shift-j": "core:show-previous-tab",
+        "ctrl-shift-k": "core:show-next-tab"
+     }
+}

package/src/app/ui/editor-client/src/js/main-modals.js

@@ -0,0 +1,14 @@
+ 
+
+$(function() {
+  if (
+    window.location.hostname !== 'localhost' &&
+    window.location.hostname !== '127.0.0.1'
+  ) {
+    document.title = document.title + ' : ' + window.location.hostname;
+  }
+  RED.init({
+    apiRootUrl: '..',
+    disableComms: true
+  });
+});

package/src/app/ui/editor-client/src/js/main.js

@@ -0,0 +1,10 @@
+ 
+
+$(function() {
+    if ((window.location.hostname !== "localhost") && (window.location.hostname !== "127.0.0.1")) {
+        document.title = document.title+" : "+window.location.hostname;
+    }
+    RED.init({
+        apiRootUrl: ""
+    });
+});

package/src/app/ui/editor-client/src/js/modals/modal-home.js

@@ -0,0 +1,162 @@
+RED.modalHome = (function () {
+  let recentProjects = [];
+
+  // Listening from the main process the list of the recent projects
+  let ipcRenderer = window.__kumologica.electron.ipcRenderer;
+
+  ipcRenderer.on('dependencies', (e, msg) => {
+    // NPM dependency check
+    $('#dependenciesNpm i').removeClass('fa-question');
+    $('#dependenciesNpm').addClass(() => {
+      return msg.npm.status ? 'dep-ok' : 'dep-failed';
+    });
+    $('#dependenciesNpm i').addClass(msg.npm.status ? 'fa-check' : 'fa-times');
+    RED.popover.tooltip($('#dependenciesNpm'), msg.npm.info);
+
+    // AWS Cli dependency check
+    $('#dependenciesAws i').removeClass('fa-question');
+    $('#dependenciesAws').addClass(() => {
+      return msg.npm.status ? 'dep-ok' : 'dep-failed';
+    });
+    $('#dependenciesAws i').addClass(msg.aws.status ? 'fa-check' : 'fa-times');
+    RED.popover.tooltip($('#dependenciesAws'), msg.aws.info);
+
+    // AWS Profile dependency check
+    $('#dependenciesProfile i').removeClass('fa-question');
+    $('#dependenciesProfile').addClass(() => {
+      return msg.npm.status ? 'dep-ok' : 'dep-failed';
+    });
+    $('#dependenciesProfile i').addClass(
+      msg.awsProfile.status ? 'fa-check' : 'fa-times'
+    );
+    RED.popover.tooltip($('#dependenciesProfile'), msg.awsProfile.info);
+  });
+
+  ipcRenderer.on('receiveProps', (e, msg) => {
+    recentProjects = msg.payload.recentProjects;
+    renderRecentProjects(recentProjects);
+  });
+
+  // app version
+  ipcRenderer.send('app_version');
+
+  ipcRenderer.on('app_version', (event, arg) => {
+    ipcRenderer.removeAllListeners('app_version');
+    $('#ideversion').text(`Version ${arg.version}`);
+  });
+
+  /**
+   * Render the section of recent projects, or hide the section if array is empty.
+   * @param {Array(Strings)} recentProjects -
+   */
+  function renderRecentProjects(recentProjects) {
+    if (recentProjects && recentProjects.length > 0) {
+      recentProjects.map((recent) => {
+        renderRecentSingleProject(recent);
+      });
+    }
+  }
+
+  function renderRecentSingleProject(projectLocation) {
+    let projectName = window.__kumologica.libs.path.basename(projectLocation);
+    projectName = projectName.replace(/^@/, '').replace(/[^a-zA-Z0-9-]/g, '-');
+
+    let listRecentProjects = $('#listRecentProjects');
+
+    // recentProject markup
+    let recentProjectMarkup = `
+    <div id="recent-${projectName}" class="recentProject">
+      <span class="recentProjectName">${projectName}</span>
+    </div>
+    `;
+    $(recentProjectMarkup).appendTo(listRecentProjects);
+    // click event for recent project
+    $(`#recent-${projectName}`).click((e) => {
+      e.preventDefault();
+      window.__kumologica.main.dispatch(
+        generateHeaderIPC('open-project-in-editor'),
+        {
+          payload: {
+            projectLocation,
+          },
+        }
+      );
+    });
+    // Highlight when hover over
+    $(`#recent-${projectName}`).mouseenter(function () {
+      $(this).addClass('actionSelected');
+    });
+    $(`#recent-${projectName}`).mouseleave(function () {
+      $(this).removeClass('actionSelected');
+    });
+
+    RED.popover.tooltip($(`#recent-${projectName}`), projectLocation);
+  }
+
+  function generateHeaderIPC(operation) {
+    let prefix = 'modal-home';
+    return `${prefix}:${operation}`;
+  }
+
+  function init() {
+    // Click event for "Open another from computer..."
+    $('#openProjectBtn').click((e) => {
+      e.preventDefault();
+      console.log('firing event open project');
+      window.__kumologica.main.dispatch(
+        generateHeaderIPC('show-dialog-openproject'),
+        null
+      );
+      return false;
+    });
+
+    // Click event for "New Project from scratch"
+    $('#actionNewProject').click(function (event) {
+      event.preventDefault();
+      window.__kumologica.main.dispatch(
+        generateHeaderIPC('show-dialog-newproject'),
+        null
+      );
+    });
+
+    $('#actionNewProject').mouseenter(() => {
+      $('#action-new-title').addClass('actionSelected');
+      $('#action-new-logo').addClass('fa-file');
+      $('#action-new-logo').removeClass('fa-file-o');
+      $('#action-new-logo').addClass('actionSelected');
+    });
+
+    $('#actionNewProject').mouseleave(() => {
+      $('#action-new-title').removeClass('actionSelected');
+      $('#action-new-logo').removeClass('actionSelected');
+      $('#action-new-logo').removeClass('fa-file');
+      $('#action-new-logo').addClass('fa-file-o');
+    });
+
+    // Open project actions
+    $('#actionOpenProject').click(function (event) {
+      event.preventDefault();
+      window.__kumologica.main.dispatch(
+        generateHeaderIPC('show-dialog-openproject'),
+        null
+      );
+    });
+
+    $('#actionOpenProject').mouseenter(() => {
+      $('#action-open-title').addClass('actionSelected');
+      $('#action-open-logo').addClass('actionSelected');
+      $('#action-open-logo').addClass('fa-folder-open');
+      $('#action-open-logo').removeClass('fa-folder-open-o');
+    });
+
+    $('#actionOpenProject').mouseleave(() => {
+      $('#action-open-title').removeClass('actionSelected');
+      $('#action-open-logo').removeClass('actionSelected');
+      $('#action-open-logo').removeClass('fa-folder-open');
+      $('#action-open-logo').addClass('fa-folder-open-o');
+    });
+  }
+  return {
+    init: init,
+  };
+})();