@kumologica/sdk 3.0.0

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

@@ -0,0 +1,704 @@
+var RED = (function () {
+  let disableComms = false;
+
+  function appendNodeConfig(nodeConfig, done) {
+    done = done || function () {};
+    var m = /<!-- --- \[red-module:(\S+)\] --- -->/.exec(nodeConfig.trim());
+    var moduleId;
+    if (m) {
+      moduleId = m[1];
+    } else {
+      moduleId = 'unknown';
+    }
+    try {
+      var hasDeferred = false;
+
+      var nodeConfigEls = $('<div>' + nodeConfig + '</div>');
+      var scripts = nodeConfigEls.find('script');
+      var scriptCount = scripts.length;
+      scripts.each(function (i, el) {
+        var srcUrl = $(el).attr('src');
+        if (srcUrl && !/^\s*(https?:|\/|\.)/.test(srcUrl)) {
+          $(el).remove();
+          var newScript = document.createElement('script');
+          newScript.onload = function () {
+            scriptCount--;
+            if (scriptCount === 0) {
+              $('body').append(nodeConfigEls);
+              done();
+            }
+          };
+          $('body').append(newScript);
+          newScript.src = RED.settings.apiRootUrl + srcUrl;
+          hasDeferred = true;
+        } else {
+          if (
+            /\/ace.js$/.test(srcUrl) ||
+            /\/ext-language_tools.js$/.test(srcUrl)
+          ) {
+            // Block any attempts to load ace.js from a CDN - this will
+            // break the version of ace included in the editor.
+            // At the time of commit, the contrib-python nodes did this.
+            // This is a crude fix until the python nodes are fixed.
+            console.warn('Blocked attempt to load', srcUrl, 'by', moduleId);
+            $(el).remove();
+          }
+          scriptCount--;
+        }
+      });
+      if (!hasDeferred) {
+        $('body').append(nodeConfigEls);
+        done();
+      }
+    } catch (err) {
+      RED.notify(`<p>Failed to load '${moduleId}'</p><p>${err.toString()}</p>`,
+        {
+          type: 'error',
+          timeout: 10000,
+        }
+      );
+      console.log('[' + moduleId + '] ' + err.toString());
+      done();
+    }
+  }
+
+  function loadNodeList() {
+    $.ajax({
+      headers: {
+        Accept: 'application/json',
+      },
+      cache: false,
+      url: 'nodes',
+      success: function (data) {
+        RED.nodes.setNodeList(data);
+        // RED.i18n.loadNodeCatalogs(function () {
+          loadIconList(loadNodes);
+        // });
+      },
+    });
+  }
+
+  function loadIconList(done) {
+    $.ajax({
+      headers: {
+        Accept: 'application/json',
+      },
+      cache: false,
+      url: '__icons',
+      success: function (data) {
+        RED.nodes.setIconSets(data);
+        if (done) {
+          done();
+        }
+      },
+    });
+  }
+
+  function loadNodes() {
+    $.ajax({
+      headers: {
+        Accept: 'text/html',
+      },
+      cache: false,
+      url: 'nodes',
+      success: function (data) {
+        var configs = data
+          .trim()
+          .split(/(?=<!-- --- \[red-module:\S+\] --- -->)/);
+        var stepConfig = function () {
+          if (configs.length === 0) {
+            $('body').i18n();
+            $('#palette > .palette-spinner').hide();
+            $('.palette-scroll').removeClass('hide');
+            $('#palette-search').removeClass('hide');
+            loadFlows(function () {
+              if (RED.settings.theme('projects.enabled', false)) {
+                RED.projects.refresh(function (activeProject) {
+                  RED.sidebar.info.refresh();
+                  if (!activeProject) {
+                    // Projects enabled but no active project
+                    RED.menu.setDisabled('menu-item-projects-open', true);
+                    RED.menu.setDisabled('menu-item-projects-settings', true);
+                    if (activeProject === false) {
+                      // User previously decline the migration to projects.
+                    } else {
+                      // null/undefined
+                      RED.projects.showStartup();
+                    }
+                  }
+                  completeLoad();
+                });
+              } else {
+                // Projects disabled by the user
+                RED.sidebar.info.refresh();
+                completeLoad();
+              }
+            });
+          } else {
+            var config = configs.shift();
+            appendNodeConfig(config, stepConfig);
+          }
+        };
+        stepConfig();
+      },
+    });
+  }
+
+  function loadFlows(done) {
+    $.ajax({
+      headers: {
+        Accept: 'application/json',
+      },
+      cache: false,
+      url: 'flows',
+      success: function (nodes) {
+        if (nodes) {
+          var currentHash = window.location.hash;
+          RED.nodes.version(nodes.rev);
+          RED.nodes.import(nodes.flows);
+          RED.nodes.dirty(false);
+          RED.view.redraw(true);
+          if (/^#flow\/.+$/.test(currentHash)) {
+            RED.workspaces.show(currentHash.substring(6));
+          }
+        }
+        done();
+      },
+    });
+  }
+
+  function completeLoad() {
+    var persistentNotifications = {};
+    RED.comms.subscribe('notification/#', function (topic, msg) {
+      var parts = topic.split('/');
+      var notificationId = parts[1];
+      if (notificationId === 'runtime-deploy') {
+        // handled in ui/deploy.js
+        return;
+      }
+      if (notificationId === 'node') {
+        // handled below
+        return;
+      }
+      if (notificationId === 'project-update') {
+        RED.nodes.clear();
+        RED.history.clear();
+        RED.view.redraw(true);
+        RED.projects.refresh(function () {
+          loadFlows(function () {
+            RED.sidebar.info.refresh();
+          });
+        });
+        return;
+      }
+
+      if (msg.text) {
+        msg.default = msg.text;
+        var text = msg.text; //RED._(msg.text, msg);
+        var options = {
+          type: msg.type,
+          fixed: msg.timeout === undefined,
+          timeout: msg.timeout,
+          id: notificationId,
+        };
+        if (notificationId === 'runtime-state') {
+          if (msg.error === 'safe-mode') {
+            options.buttons = [
+              {
+                text: 'Close',
+                click: function () {
+                  persistentNotifications[notificationId].hideNotification();
+                },
+              },
+            ];
+          } else if (msg.error === 'missing-types') {
+            text +=
+              '<ul><li>' +
+              msg.types.map(RED.utils.sanitize).join('</li><li>') +
+              '</li></ul>';
+            if (!!RED.projects.getActiveProject()) {
+              options.buttons = [
+                {
+                  text: 'Manage project dependencies',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                    RED.projects.settings.show('deps');
+                  },
+                },
+              ];
+              // } else if (RED.settings.theme('palette.editable') !== false) {
+            } else {
+              options.buttons = [
+                {
+                  text: 'Close',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                  },
+                },
+              ];
+            }
+          } else if (msg.error === 'credentials_load_failed') {
+            if (RED.settings.theme('projects.enabled', false)) {
+              // projects enabled
+              if (RED.user.hasPermission('projects.write')) {
+                options.buttons = [
+                  {
+                    text: 'Setup credentials',
+                    click: function () {
+                      persistentNotifications[
+                        notificationId
+                      ].hideNotification();
+                      RED.projects.showCredentialsPrompt();
+                    },
+                  },
+                ];
+              }
+            } else {
+              options.buttons = [
+                {
+                  text: 'Close',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                  },
+                },
+              ];
+            }
+          } else if (msg.error === 'missing_flow_file') {
+            if (RED.user.hasPermission('projects.write')) {
+              options.buttons = [
+                {
+                  text: 'Setup credentials',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                    RED.projects.showFilesPrompt();
+                  },
+                },
+              ];
+            }
+          } else if (msg.error === 'missing_package_file') {
+            if (RED.user.hasPermission('projects.write')) {
+              options.buttons = [
+                {
+                  text: 'Setup credentials',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                    RED.projects.showFilesPrompt();
+                  },
+                },
+              ];
+            }
+          } else if (msg.error === 'project_empty') {
+            if (RED.user.hasPermission('projects.write')) {
+              options.buttons = [
+                {
+                  text: 'No thanks',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                  },
+                },
+                {
+                  text: 'Create default project files',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                    RED.projects.createDefaultFileSet();
+                  },
+                },
+              ];
+            }
+          } else if (msg.error === 'git_merge_conflict') {
+            RED.nodes.clear();
+            RED.sidebar.versionControl.refresh(true);
+            if (RED.user.hasPermission('projects.write')) {
+              options.buttons = [
+                {
+                  text: 'Show merge conflicts',
+                  click: function () {
+                    persistentNotifications[notificationId].hideNotification();
+                    RED.sidebar.versionControl.showLocalChanges();
+                  },
+                },
+              ];
+            }
+          }
+        }
+        if (!persistentNotifications.hasOwnProperty(notificationId)) {
+          persistentNotifications[notificationId] = RED.notify(text, options);
+        } else {
+          persistentNotifications[notificationId].update(text, options);
+        }
+      } else if (persistentNotifications.hasOwnProperty(notificationId)) {
+        persistentNotifications[notificationId].close();
+        delete persistentNotifications[notificationId];
+      }
+    });
+    RED.comms.subscribe('status/#', function (topic, msg) {
+      var parts = topic.split('/');
+      var node = RED.nodes.node(parts[1]);
+      if (node) {
+        if (msg.hasOwnProperty('text') && /^[a-zA-Z]/.test(msg.text)) {
+          msg.text = node._(msg.text.toString(), {
+            defaultValue: msg.text.toString(),
+          });
+        }
+        node.status = msg;
+        node.dirty = true;
+        RED.view.redraw();
+      }
+    });
+    RED.comms.subscribe('notification/node/#', function (topic, msg) {
+      var i, m;
+      var typeList;
+      var info;
+      if (topic == 'notification/node/added') {
+        var addedTypes = [];
+        msg.forEach(function (m) {
+          var id = m.id;
+          RED.nodes.addNodeSet(m);
+          addedTypes = addedTypes.concat(m.types);
+          RED.i18n.loadNodeCatalog(id, function () {
+            $.get('nodes/' + id, function (data) {
+              appendNodeConfig(data);
+            });
+          });
+        });
+        if (addedTypes.length) {
+          typeList = '<ul><li>' + addedTypes.join('</li><li>') + '</li></ul>';
+          RED.notify(`Node added to palette: ${addedTypes.length} ` + typeList,
+            'success'
+          );
+        }
+        loadIconList();
+      } else if (topic == 'notification/node/removed') {
+        for (i = 0; i < msg.length; i++) {
+          m = msg[i];
+          info = RED.nodes.removeNodeSet(m.id);
+          if (info.added) {
+            typeList = '<ul><li>' + m.types.join('</li><li>') + '</li></ul>';
+            RED.notify(`Node removed from palette: ${m.types.length}` + typeList,
+              'success'
+            );
+          }
+        }
+        loadIconList();
+      } else if (topic == 'notification/node/enabled') {
+        if (msg.types) {
+          info = RED.nodes.getNodeSet(msg.id);
+          if (info.added) {
+            RED.nodes.enableNodeSet(msg.id);
+            typeList = '<ul><li>' + msg.types.join('</li><li>') + '</li></ul>';
+            // RED.notify(
+            //   RED._('palette.event.nodeEnabled', { count: msg.types.length }) +
+            //     typeList,
+            //   'success'
+            // );
+          } else {
+            $.get('nodes/' + msg.id, function (data) {
+              appendNodeConfig(data);
+              typeList =
+                '<ul><li>' + msg.types.join('</li><li>') + '</li></ul>';
+              RED.notify(`Node added to palette: ${msg.types.length} `+ typeList,
+                'success'
+              );
+            });
+          }
+        }
+      } else if (topic == 'notification/node/disabled') {
+        if (msg.types) {
+          RED.nodes.disableNodeSet(msg.id);
+          typeList = '<ul><li>' + msg.types.join('</li><li>') + '</li></ul>';
+          // RED.notify(
+          //   RED._('palette.event.nodeDisabled', { count: msg.types.length }) +
+          //     typeList,
+          //   'success'
+          // );
+        }
+      } else if (topic == 'notification/node/upgraded') {
+        // RED.notify(
+        //   RED._('palette.event.nodeUpgraded', {
+        //     module: msg.module,
+        //     version: msg.version,
+        //   }),
+        //   'success'
+        // );
+        RED.nodes.registry.setModulePendingUpdated(msg.module, msg.version);
+      }
+    });
+    RED.comms.subscribe('event-log/#', function (topic, payload) {
+      var id = topic.substring(9);
+      RED.eventLog.log(id, payload);
+    });
+  }
+
+  function showAbout() {
+    $.get('red/about', function (data) {
+      var aboutHeader =
+        '<div style="text-align:center;">' +
+        '<img width="50px" src="red/images/kumologica-core-icon.svg" />' +
+        '</div>';
+
+      RED.sidebar.info.set(aboutHeader + marked(data));
+      RED.sidebar.info.show();
+    });
+  }
+
+  function loadEditor() {
+    var menuOptions = [];
+    if (RED.settings.theme('projects.enabled', false)) {
+      menuOptions.push({
+        id: 'menu-item-projects-menu',
+        label: 'Projects',
+        options: [
+          {
+            id: 'menu-item-projects-new',
+            label: 'New',
+            disabled: false,
+            onselect: 'core:new-project',
+          },
+          {
+            id: 'menu-item-projects-open',
+            label: 'Open',
+            disabled: false,
+            onselect: 'core:open-project',
+          },
+          {
+            id: 'menu-item-projects-settings',
+            label: 'Project Settings',
+            disabled: false,
+            onselect: 'core:show-project-settings',
+          },
+        ],
+      });
+    }
+
+    menuOptions.push({
+      id: 'menu-item-view-menu',
+      label: 'View',
+      options: [
+        {
+          id: 'menu-item-palette',
+          label: 'Show palette',
+          toggle: true,
+          onselect: 'core:toggle-palette',
+          selected: true,
+        },
+        {
+          id: 'menu-item-sidebar',
+          label: 'Show sidebar',
+          toggle: true,
+          onselect: 'core:toggle-sidebar',
+          selected: false,
+        },
+        {
+          id: 'menu-item-event-log',
+          label: 'Event log',
+          onselect: 'core:show-event-log',
+        },
+        null,
+      ],
+    });
+    menuOptions.push(null);
+    menuOptions.push({
+      id: 'menu-item-import',
+      label: 'Import',
+      options: [
+        {
+          id: 'menu-item-import-clipboard',
+          label: 'Clipboard',
+          onselect: 'core:show-import-dialog',
+        },
+        {
+          id: 'menu-item-import-library',
+          label: 'Library',
+          options: [],
+        },
+      ],
+    });
+    menuOptions.push({
+      id: 'menu-item-export',
+      label: 'Export',
+      options: [
+        {
+          id: 'menu-item-export-clipboard',
+          label: 'Clipboard',
+          onselect: 'core:show-export-dialog',
+        },
+        {
+          id: 'menu-item-export-library',
+          label: 'Library',
+          disabled: true,
+          onselect: 'core:library-export',
+        },
+      ],
+    });
+    menuOptions.push(null);
+    menuOptions.push({
+      id: 'menu-item-search',
+      label: 'Search',
+      onselect: 'core:search',
+    });
+    menuOptions.push(null);
+    menuOptions.push({
+      id: 'menu-item-config-nodes',
+      label: 'Configuration nodes',
+      onselect: 'core:show-config-tab',
+    });
+    menuOptions.push({
+      id: 'menu-item-workspace',
+      label: 'Flows',
+      options: [
+        {
+          id: 'menu-item-workspace-add',
+          label: 'Add',
+          onselect: 'core:add-flow',
+        },
+        {
+          id: 'menu-item-workspace-edit',
+          label: 'Rename',
+          onselect: 'core:edit-flow',
+        },
+        {
+          id: 'menu-item-workspace-delete',
+          label: 'Delete',
+          onselect: 'core:remove-flow',
+        },
+      ],
+    });
+    menuOptions.push({
+      id: 'menu-item-subflow',
+      label: 'Subflows',
+      options: [
+        {
+          id: 'menu-item-subflow-create',
+          label: 'Create Subflow',
+          onselect: 'core:create-subflow',
+        },
+        {
+          id: 'menu-item-subflow-convert',
+          label: 'Selection to Subflow',
+          disabled: true,
+          onselect: 'core:convert-to-subflow',
+        },
+      ],
+    });
+    menuOptions.push(null);
+    if (RED.settings.theme('palette.editable') !== false) {
+      menuOptions.push({
+        id: 'menu-item-edit-palette',
+        label: 'Manage palette',
+        onselect: 'core:manage-palette',
+      });
+      menuOptions.push(null);
+    }
+
+    menuOptions.push({
+      id: 'menu-item-user-settings',
+      label: 'Settings',
+      onselect: 'core:show-user-settings',
+    });
+    menuOptions.push(null);
+
+    menuOptions.push({
+      id: 'menu-item-keyboard-shortcuts',
+      label: 'Keyboard shortcuts',
+      onselect: 'core:show-help',
+    });
+    menuOptions.push({
+      id: 'menu-item-help',
+      label: RED.settings.theme(
+        'menu.menu-item-help.label',
+        'Kumologica website'
+      ),
+      href: RED.settings.theme(
+        'menu.menu-item-help.url',
+        'http://kumologica.com/docs'
+      ),
+    });
+    menuOptions.push({
+      id: 'menu-item-kumologica-core-version',
+      label: 'v' + RED.settings.version,
+      onselect: 'core:show-about',
+    });
+
+    RED.view.init();
+    RED.userSettings.init();
+    RED.user.init();
+    RED.library.init();
+    RED.keyboard.init();
+    RED.palette.init();
+    RED.eventLog.init();
+    if (RED.settings.theme('palette.editable') !== false) {
+      RED.palette.editor.init();
+    }
+
+    RED.sidebar.init();
+
+    if (RED.settings.theme('projects.enabled', false)) {
+      RED.projects.init();
+    }
+
+    RED.subflow.init();
+    RED.workspaces.init();
+    RED.clipboard.init();
+    RED.search.init();
+    RED.projectInfo.init();
+    RED.uiSettings.init();
+
+    RED.editor.init();
+    //RED.diff.init();
+
+    RED.menu.init({ id: 'btn-sidemenu', options: menuOptions });
+
+    RED.deploy.init(RED.settings.theme('deployButton', null));
+    RED.notifications.init();
+
+    RED.actions.add('core:show-about', showAbout);
+    RED.nodes.init();
+
+    if (!disableComms) {
+      RED.comms.connect();
+    }
+
+    // Modals
+    RED.modalNewProject.init();
+    RED.modalHome.init();
+    RED.modalWelcome.init();
+    RED.updatePanel.init();
+    RED.modalNodeLibrary.init();
+
+    //RED.comms.connectWS();
+
+    $('#main-container').show();
+    $('.header-toolbar').show();
+
+    // Terminal must go before headers, as they reference the terminal in the shelves section
+    //RED.terminal.init();
+    RED.logviewer.init();
+    RED.header.init();
+
+    loadNodeList();
+  }
+
+  var initialised = false;
+
+  function init(options) {
+    if (initialised) {
+      throw new Error('RED already initialised');
+    }
+    disableComms = options.disableComms || false;
+    initialised = true;
+    ace.require('ace/ext/language_tools');
+    options = options || {};
+    options.apiRootUrl = options.apiRootUrl || '';
+    if (options.apiRootUrl && !/\/$/.test(options.apiRootUrl)) {
+      options.apiRootUrl = options.apiRootUrl + '/';
+    }
+    RED.i18n.init(options, function () {
+      RED.settings.init(options, loadEditor);
+    });
+  }
+
+  return {
+    init: init,
+  };
+})();
+var App = RED;