Fix menu padding to handle both icons and submenus

Fixes #3683

.gitattributes

@@ -0,0 +1 @@
+/packages/node_modules/** linguist-generated=false

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,61 @@
+name: 🐞 Report a bug
+description: File a bug/issue on the core of Node-RED
+labels: [needs-triage]
+body:
+- type: markdown
+  attributes:
+    value: |
+        This issue tracker is for problems with the Node-RED runtime, the editor or the core nodes.
+
+        If your issue is:
+          - a general 'how-to' type question,
+          - a feature request or suggestion for a change,
+          - or problems with 3rd party (`node-red-contrib-`) nodes
+
+        please use the [Node-RED Forum](https://discourse.nodered.org) or [slack team](https://nodered.org/slack).
+
+        You could also consider asking a question on [Stack Overflow](https://stackoverflow.com/questions/tagged/node-red) and tag it `node-red`.
+
+        That way the whole Node-RED user community can help, rather than rely on the core development team.
+
+        To help us understand the issue, please fill-in as much of the following information as you can:
+- type: textarea
+  attributes:
+    label: Current Behavior
+    description: A clear & concise description of what you're experiencing.
+  validations:
+    required: false
+- type: textarea
+  attributes:
+    label: Expected Behavior
+    description: A clear & concise description of what you expected to happen.
+  validations:
+    required: false
+- type: textarea
+  attributes:
+    label: Steps To Reproduce
+    description: Steps to reproduce the behavior.
+  validations:
+    required: false
+- type: textarea
+  attributes:
+    label: Example flow
+    description: If you have a minimal example flow that demonstrates the issue, share it here.
+    value: |
+      ```
+      paste your flow here
+      ```
+  validations:
+    required: false
+- type: textarea
+  attributes:
+    label: Environment
+    description: Please tell us about your environment. Include any relevant information on how you are running Node-RED.
+    value: |
+        - Node-RED version:
+        - Node.js version:
+        - npm version:
+        - Platform/OS:
+        - Browser:
+  validations:
+    required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: true
+contact_links:
+  - name: ❓ Questions
+    url: https://discourse.nodered.org
+    about: Ask your question on the Node-RED forum
+  - name: ⭐️ Feature Request
+    url: https://discourse.nodered.org/c/development/feature-requests
+    about: Discuss your request with the community
+  - name: 🗂 Documentation
+    url: https://nodered.org/docs
+    about: Go straight to the documentation
+  - name: 💬 Slack
+    url: https://nodered.org/slack
+    about: Chat about the project on our slack team

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,34 @@
+<!--
+## Before you hit that Submit button....
+
+Please read our [contribution guidelines](https://github.com/node-red/node-red/blob/master/CONTRIBUTING.md)
+before submitting a pull-request.
+
+## Types of changes
+
+What types of changes does your code introduce?
+Put an `x` in the boxes that apply
+-->
+
+- [ ] Bugfix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+
+<!--
+If you want to raise a pull-request with a new feature, or a refactoring
+of existing code, it **may well get rejected** if it hasn't been discussed on
+the [forum](https://discourse.nodered.org) or
+[slack team](https://nodered.org/slack) first.
+
+-->
+
+## Proposed changes
+
+<!-- Describe the nature of this change. What problem does it address? -->
+
+## Checklist
+<!-- Put an `x` in the boxes that apply -->
+
+- [ ] I have read the [contribution guidelines](https://github.com/node-red/node-red/blob/master/CONTRIBUTING.md)
+- [ ] For non-bugfix PRs, I have discussed this change on the forum/slack team.
+- [ ] I have run `grunt` to verify the unit tests pass
+- [ ] I have added suitable unit tests to cover the new/changed functionality

.github/scripts/update-node-red-docker.js

@@ -0,0 +1,29 @@
+const fs = require("fs");
+
+const newVersion = require("../../package.json").version;
+
+if (process.env.GITHUB_REF !== "refs/tags/"+newVersion) {
+    console.log(`GITHUB_REF doesn't match the package.json version: ${process.env.GITHUB_REF} !== ${newVersion}`);
+    process.exit(0);
+}
+
+if (!/^\d+\.\d+\.\d+$/.test(newVersion)) {
+    console.log(`Not updating for a non-stable release - ${newVersion}`);
+    process.exit(0);
+}
+
+const currentVersion = require("../../../node-red-docker/package.json").version;
+
+console.log(`Update from ${currentVersion} to ${newVersion}`)
+
+updateFile(__dirname+"/../../../node-red-docker/package.json", currentVersion, newVersion);
+updateFile(__dirname+"/../../../node-red-docker/docker-custom/package.json", currentVersion, newVersion);
+updateFile(__dirname+"/../../../node-red-docker/README.md", currentVersion, newVersion);
+
+console.log(`::set-env name=newVersion::${newVersion}`);
+
+function updateFile(path,from,to) {
+    let contents = fs.readFileSync(path,"utf8");
+    contents = contents.replace(new RegExp(from.replace(/\./g,"\\."),"g"), to);
+    fs.writeFileSync(path, contents);
+}

.github/scripts/update-node-red-website.js

@@ -0,0 +1,18 @@
+const fs = require("fs");
+
+const newVersion = require("../../package.json").version;
+
+if (process.env.GITHUB_REF !== "refs/tags/"+newVersion) {
+    console.log(`GITHUB_REF doesn't match the package.json version: ${process.env.GITHUB_REF} !== ${newVersion}`);
+    process.exit(0);
+}
+
+if (!/^\d+\.\d+\.\d+$/.test(newVersion)) {
+    console.log(`Not updating for a non-stable release - ${newVersion}`);
+    process.exit(0);
+}
+
+const path = __dirname+"/../../../node-red.github.io/index.html";
+let contents = fs.readFileSync(path, "utf8");
+contents = contents.replace(/<span class="node-red-latest-version">v\d+\.\d+\.\d+<\/span>/, `<span class="node-red-latest-version">v${newVersion}<\/span>` );
+fs.writeFileSync(path, contents);

.github/workflows/release.yml

@@ -0,0 +1,59 @@
+name: Publish Release
+env:
+  ACTIONS_ALLOW_UNSECURE_COMMANDS: true
+on:
+  release:
+    types: [published]
+
+jobs:
+  generate:
+    name: 'Update node-red-docker image'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out node-red repository
+        uses: actions/checkout@v2
+        with:
+            path: 'node-red'
+      - name: Check out node-red-docker repository
+        uses: actions/checkout@v2
+        with:
+            repository: 'node-red/node-red-docker'
+            path: 'node-red-docker'
+      - name: Check out node-red.github.io repository
+        uses: actions/checkout@v2
+        with:
+            repository: 'node-red/node-red.github.io'
+            path: 'node-red.github.io'
+      - uses: actions/setup-node@v1
+        with:
+            node-version: '16'
+      - run: node ./node-red/.github/scripts/update-node-red-docker.js
+      - name: Create Docker Pull Request
+        uses: peter-evans/create-pull-request@v2
+        with:
+          token: ${{ secrets.NR_REPO_TOKEN }}
+          committer: GitHub <noreply@github.com>
+          author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>
+          path: 'node-red-docker'
+          commit-message: 'Bump to ${{ env.newVersion }}'
+          title: '🚀 Update to Node-RED ${{ env.newVersion }} release'
+          body: |
+            Updates the Node-RED Docker repo for the ${{ env.newVersion }} release.
+
+            Once this is merged, you will need to create a new release with the tag `v${{ env.newVersion }}`.
+
+            This PR was auto-generated by a GitHub Action. Any questions, speak to @knolleary
+      - run: node ./node-red/.github/scripts/update-node-red-website.js
+      - name: Create Website Pull Request
+        uses: peter-evans/create-pull-request@v2
+        with:
+          token: ${{ secrets.NR_REPO_TOKEN }}
+          committer: GitHub <noreply@github.com>
+          author: ${{ github.actor }} <${{ github.actor }}@users.noreply.github.com>
+          path: 'node-red.github.io'
+          commit-message: 'Bump to ${{ env.newVersion }}'
+          title: '🚀 Update to Node-RED ${{ env.newVersion }} release'
+          body: |
+            Updates the Node-RED Website repo for the ${{ env.newVersion }} release.
+
+            This PR was auto-generated by a GitHub Action. Any questions, speak to @knolleary

.github/workflows/tests.yml

@@ -0,0 +1,30 @@
+name: Run tests
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master, dev ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [14, 16]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: Install Dependencies
+      run: npm install
+    - name: Run tests
+      run: |
+        npm run test
+    - name: Publish to coveralls.io
+      if: ${{ matrix.node-version == 14 }}
+      uses: coverallsapp/github-action@v1.1.2
+      with:
+        github-token: ${{ github.token }}

.gitignore

@@ -7,7 +7,9 @@
 .sessions.json
 .settings
 .tern-project
+.i18n-editor-metadata
 *.backup
+*.bak
 *_cred*
 coverage
 credentials.json
@@ -17,3 +19,11 @@ node_modules
 public
 locales/zz-ZZ
 nodes/core/locales/zz-ZZ
+!packages/node_modules
+packages/node_modules/@node-red/editor-client/public
+!test/**/node_modules
+docs
+!packages/node_modules/**/docs
+.vscode
+.nyc_output
+sync.ffs_db

.nodemonignore

@@ -1,5 +1,4 @@
 /Gruntfile.js
 /.git/*
-/lib/*
 *.backup
 /public/*

.npmignore

@@ -1,7 +0,0 @@
-.settings
-.jshintignore
-.jshintrc
-.project
-.tern-project
-.travis.yml
-.git

.travis.yml

@@ -1,21 +0,0 @@
-sudo: false
-language: node_js
-env:
-  - CXX="g++-4.8"
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - g++-4.8
-    - gcc-4.8
-node_js:
-  - "8"
-  - "7"
-  - "6"
-  - "4"
-script:
-  - istanbul cover ./node_modules/.bin/grunt --report lcovonly && istanbul report text && ( cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js || true ) && rm -rf coverage
-before_script:
-  - npm install -g istanbul
-  - npm install coveralls

API.md

@@ -0,0 +1,19 @@
+Node-RED consists of 6 node modules under the `@node-red` scope, which are pulled together
+by the top-level `node-red` module. The typical scenario is where you are embedding Node-RED into your
+own application, in which case you would use the `node-red` module rather than any of the
+internal modules directly.
+
+```javascript
+let RED = require("node-red");
+```
+
+
+Module | Description
+-------|-------
+[node-red](node-red.html) | the main module that pulls together all of the internal modules and provides the executable version of Node-RED
+[@node-red/editor-api](@node-red_editor-api.html) | an Express application that serves the Node-RED editor and provides the Admin HTTP API
+[@node-red/runtime](@node-red_runtime.html) | the core runtime of Node-RED
+[@node-red/util](@node-red_util.html) | common utilities for the Node-RED runtime and editor modules
+[@node-red/registry](@node-red_registry.html) | the internal node registry
+@node-red/nodes | the default set of core nodes. This module only contains the Node-RED nodes - it does not expose any APIs.
+@node-red/editor-client | the client-side resources of the Node-RED editor application

CONTRIBUTING.md

@@ -9,7 +9,7 @@ We welcome contributions, but request you follow these guidelines.
 
 This project adheres to the [Contributor Covenant 1.4](http://contributor-covenant.org/version/1/4/).
 By participating, you are expected to uphold this code. Please report unacceptable
-behavior to any of the [project's core team](https://github.com/orgs/node-red/teams/core).
+behavior to the project's core team at team@nodered.org.
 
 ## Raising issues
 
@@ -26,25 +26,30 @@ relevant nodes, press Ctrl-E and copy the flow data from the Export dialog.
 At a minimum, please include:
 
  - Version of Node-RED - either release number if you downloaded a zip, or the first few lines of `git log` if you are cloning the repository directly.
- - Version of node.js - what does `node -v` say?
+ - Version of Node.js - what does `node -v` say?
 
 ## Feature requests
 
-For feature requests, please raise them on the [mailing list](https://groups.google.com/forum/#!forum/node-red).
+For feature requests, please raise them on the [forum](https://discourse.nodered.org).
 
 ## Pull-Requests
 
 If you want to raise a pull-request with a new feature, or a refactoring
 of existing code, it may well get rejected if you haven't discussed it on
-the [mailing list](https://groups.google.com/forum/#!forum/node-red) first.
+the [forum](https://discourse.nodered.org) first.
 
-All contributors need to sign the JS Foundation's Contributor License Agreement.
-It is an online process and quick to do. You can read the details of the agreement
-here: https://cla.js.foundation/node-red/node-red.
+All contributors need to sign the OpenJS Foundation's Contributor License Agreement.
+It is an online process and quick to do. If you raise a pull-request without
+having signed the CLA, you will be prompted to do so automatically.
 
-If you raise a pull-request without having signed the CLA, you will be prompted
-to do so automatically.
 
+### Code Branches
+
+When raising a PR for a fix or a new feature, it is important to target the right branch.
+
+ - `master` - this is the main branch for the latest stable release of Node-RED. All bug fixes for that release should target this branch.
+ - `v1.x` - this is the maintenance branch for the 1.x stream. If a fix *only* applies to 1.x, then it should target this branch. If it applies to the current stable release as well, target `master` first. We will then decide if it needs to be back ported to the 1.x stream.
+ - `dev` - this is the branch for new feature development targeting the next milestone release.
 
 ### Coding standards
 

Gruntfile.js

@@ -15,17 +15,35 @@
  **/
 
 var path = require("path");
+var fs = require("fs-extra");
+var sass = require("sass");
 
 module.exports = function(grunt) {
 
-    var nodemonArgs = ["-v"];
+    var nodemonArgs = ["-V"];
     var flowFile = grunt.option('flowFile');
     if (flowFile) {
         nodemonArgs.push(flowFile);
+        process.env.NODE_RED_ENABLE_PROJECTS=false;
+    }
+    var userDir = grunt.option('userDir');
+    if (userDir) {
+        nodemonArgs.push("-u");
+        nodemonArgs.push(userDir);
     }
 
+    var browserstack = grunt.option('browserstack');
+    if (browserstack) {
+        process.env.BROWSERSTACK = true;
+    }
+    var nonHeadless = grunt.option('non-headless');
+    if (nonHeadless) {
+        process.env.NODE_RED_NON_HEADLESS = true;
+    }
+    const pkg = grunt.file.readJSON('package.json');
+    process.env.NODE_RED_PACKAGE_VERSION = pkg.version;
     grunt.initConfig({
-        pkg: grunt.file.readJSON('package.json'),
+        pkg: pkg,
         paths: {
             dist: ".dist"
         },
@@ -37,20 +55,28 @@ module.exports = function(grunt) {
                 ui: 'bdd',
                 reporter: 'spec'
             },
-            all: { src: ['test/**/*_spec.js'] },
-            core: { src: ["test/_spec.js","test/red/**/*_spec.js"]},
+            all: { src: ["test/unit/_spec.js","test/unit/**/*_spec.js","test/nodes/**/*_spec.js"] },
+            core: { src: ["test/unit/_spec.js","test/unit/**/*_spec.js"]},
             nodes: { src: ["test/nodes/**/*_spec.js"]}
         },
-        mocha_istanbul: {
+        webdriver: {
+            all: {
+                configFile: 'test/editor/wdio.conf.js'
+            }
+        },
+        nyc: {
             options: {
-                globals: ['expect'],
-                timeout: 3000,
-                ignoreLeaks: false,
-                ui: 'bdd',
-                reportFormats: ['lcov'],
-                print: 'both'
+                cwd: '.',
+                include: ['packages/node_modules/**'],
+                excludeNodeModules: false,
+                exclude: ['packages/node_modules/@node-red/editor-client/**'],
+                reporter: ['lcov', 'html','text-summary'],
+                reportDir: 'coverage',
+                all: true
             },
-            coverage: { src: ['test/**/*_spec.js'] }
+            all:   { cmd: false, args: ['grunt', 'simplemocha:all'] },
+            core:  { options: { exclude:['packages/node_modules/@node-red/editor-client/**', 'packages/node_modules/@node-red/nodes/**']},cmd: false, args: ['grunt', 'simplemocha:core'] },
+            nodes: { cmd: false, args: ['grunt', 'simplemocha:nodes'] }
         },
         jshint: {
             options: {
@@ -66,22 +92,20 @@ module.exports = function(grunt) {
                 //"loopfunc": true, // allow functions to be defined in loops
                 //"sub": true       // don't warn that foo['bar'] should be written as foo.bar
             },
-            all: [
-                'Gruntfile.js',
-                'red.js',
-                'red/**/*.js',
-                'nodes/core/*/*.js',
-                'editor/js/**/*.js'
-            ],
-            core: {
-                files: {
-                    src: [
-                        'Gruntfile.js',
-                        'red.js',
-                        'red/**/*.js'
-                    ]
-                }
-            },
+            // all: [
+            //     'Gruntfile.js',
+            //     'red.js',
+            //     'packages/**/*.js'
+            // ],
+            // core: {
+            //     files: {
+            //         src: [
+            //             'Gruntfile.js',
+            //             'red.js',
+            //             'packages/**/*.js',
+            //         ]
+            //     }
+            // },
             nodes: {
                 files: {
                     src: [ 'nodes/core/*/*.js' ]
@@ -89,7 +113,7 @@ module.exports = function(grunt) {
             },
             editor: {
                 files: {
-                    src: [ 'editor/js/**/*.js' ]
+                    src: [ 'packages/node_modules/@node-red/editor-client/src/js/**/*.js' ]
                 }
             },
             tests: {
@@ -109,74 +133,105 @@ module.exports = function(grunt) {
                 src: [
                     // Ensure editor source files are concatenated in
                     // the right order
-                    "editor/js/red.js",
-                    "editor/js/events.js",
-                    "editor/js/i18n.js",
-                    "editor/js/settings.js",
-                    "editor/js/user.js",
-                    "editor/js/comms.js",
-                    "editor/js/text/bidi.js",
-                    "editor/js/text/format.js",
-                    "editor/js/ui/state.js",
-                    "editor/js/nodes.js",
-                    "editor/js/history.js",
-                    "editor/js/validators.js",
-                    "editor/js/ui/utils.js",
-                    "editor/js/ui/common/editableList.js",
-                    "editor/js/ui/common/checkboxSet.js",
-                    "editor/js/ui/common/menu.js",
-                    "editor/js/ui/common/panels.js",
-                    "editor/js/ui/common/popover.js",
-                    "editor/js/ui/common/searchBox.js",
-                    "editor/js/ui/common/tabs.js",
-                    "editor/js/ui/common/stack.js",
-                    "editor/js/ui/common/typedInput.js",
-                    "editor/js/ui/actions.js",
-                    "editor/js/ui/deploy.js",
-                    "editor/js/ui/diff.js",
-                    "editor/js/ui/keyboard.js",
-                    "editor/js/ui/workspaces.js",
-                    "editor/js/ui/view.js",
-                    "editor/js/ui/sidebar.js",
-                    "editor/js/ui/palette.js",
-                    "editor/js/ui/tab-info.js",
-                    "editor/js/ui/tab-config.js",
-                    "editor/js/ui/palette-editor.js",
-                    "editor/js/ui/editor.js",
-                    "editor/js/ui/tray.js",
-                    "editor/js/ui/clipboard.js",
-                    "editor/js/ui/library.js",
-                    "editor/js/ui/notifications.js",
-                    "editor/js/ui/search.js",
-                    "editor/js/ui/typeSearch.js",
-                    "editor/js/ui/subflow.js",
-                    "editor/js/ui/userSettings.js",
-                    "editor/js/ui/touch/radialMenu.js"
+                    "packages/node_modules/@node-red/editor-client/src/js/polyfills.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/jquery-addons.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/red.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/events.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/hooks.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/i18n.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/settings.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/user.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/comms.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/text/bidi.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/text/format.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/state.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/plugins.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/nodes.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/font-awesome.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/history.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/validators.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/utils.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/editableList.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/treeList.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/checkboxSet.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/menu.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/panels.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/popover.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/searchBox.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/tabs.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/stack.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/typedInput.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/toggleButton.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/common/autoComplete.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/actions.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/deploy.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/diagnostics.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/diff.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/keyboard.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/workspaces.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/statusBar.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/view.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/view-annotations.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/view-navigator.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/view-tools.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/sidebar.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/palette.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tab-info.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tab-info-outliner.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tab-help.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tab-config.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tab-context.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/palette-editor.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/editor.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/editors/panes/*.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/editors/*.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/editors/code-editors/*.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/event-log.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tray.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/clipboard.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/library.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/notifications.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/search.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/contextMenu.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/actionList.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/typeSearch.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/subflow.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/group.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/userSettings.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/projects/projects.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/projects/projectSettings.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/projects/projectUserSettings.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/projects/tab-versionControl.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/touch/radialMenu.js",
+                    "packages/node_modules/@node-red/editor-client/src/js/ui/tour/*.js"
                 ],
-                dest: "public/red/red.js"
+                dest: "packages/node_modules/@node-red/editor-client/public/red/red.js"
             },
             vendor: {
                 files: {
-                    "public/vendor/vendor.js": [
-                        "editor/vendor/jquery/js/jquery-1.11.3.min.js",
-                        "editor/vendor/bootstrap/js/bootstrap.min.js",
-                        "editor/vendor/jquery/js/jquery-ui-1.10.3.custom.min.js",
-                        "editor/vendor/jquery/js/jquery.ui.touch-punch.min.js",
-                        "editor/vendor/marked/marked.min.js",
-                        "editor/vendor/d3/d3.v3.min.js",
-                        "editor/vendor/i18next/i18next.min.js"
-                    ],
-                    "public/vendor/vendor.css": [
-                        // TODO: resolve relative resource paths in
-                        //       bootstrap/FA/jquery
-                    ],
-                    "public/vendor/jsonata/jsonata.min.js": [
+                    "packages/node_modules/@node-red/editor-client/public/vendor/vendor.js": [
+                        "packages/node_modules/@node-red/editor-client/src/vendor/jquery/js/jquery-3.5.1.min.js",
+                        "packages/node_modules/@node-red/editor-client/src/vendor/jquery/js/jquery-migrate-3.3.0.min.js",
+                        "packages/node_modules/@node-red/editor-client/src/vendor/jquery/js/jquery-ui.min.js",
+                        "packages/node_modules/@node-red/editor-client/src/vendor/jquery/js/jquery.ui.touch-punch.min.js",
+                        "node_modules/marked/marked.min.js",
+                        "node_modules/dompurify/dist/purify.min.js",
+                        "packages/node_modules/@node-red/editor-client/src/vendor/d3/d3.v3.min.js",
+                        "node_modules/i18next/i18next.min.js",
+                        "node_modules/i18next-http-backend/i18nextHttpBackend.min.js",
+                        "node_modules/jquery-i18next/jquery-i18next.min.js",
                         "node_modules/jsonata/jsonata-es5.min.js",
-                        "editor/vendor/jsonata/formatter.js"
+                        "packages/node_modules/@node-red/editor-client/src/vendor/jsonata/formatter.js",
+                        "packages/node_modules/@node-red/editor-client/src/vendor/ace/ace.js",
+                        "packages/node_modules/@node-red/editor-client/src/vendor/ace/ext-language_tools.js",
                     ],
-                    "public/vendor/ace/worker-jsonata.js": [
+                    // "packages/node_modules/@node-red/editor-client/public/vendor/vendor.css": [
+                    //     // TODO: resolve relative resource paths in
+                    //     //       bootstrap/FA/jquery
+                    // ],
+                    "packages/node_modules/@node-red/editor-client/public/vendor/ace/worker-jsonata.js": [
                         "node_modules/jsonata/jsonata-es5.min.js",
-                        "editor/vendor/jsonata/worker-jsonata.js"
+                        "packages/node_modules/@node-red/editor-client/src/vendor/jsonata/worker-jsonata.js"
                     ]
                 }
             }
@@ -184,63 +239,62 @@ module.exports = function(grunt) {
         uglify: {
             build: {
                 files: {
-                    'public/red/red.min.js': 'public/red/red.js',
-                    'public/red/main.min.js': 'public/red/main.js',
-                    'public/vendor/ace/mode-jsonata.js': 'editor/vendor/jsonata/mode-jsonata.js',
-                    'public/vendor/ace/snippets/jsonata.js': 'editor/vendor/jsonata/snippets-jsonata.js'
+                    'packages/node_modules/@node-red/editor-client/public/red/red.min.js': 'packages/node_modules/@node-red/editor-client/public/red/red.js',
+                    'packages/node_modules/@node-red/editor-client/public/red/main.min.js': 'packages/node_modules/@node-red/editor-client/public/red/main.js',
+                    'packages/node_modules/@node-red/editor-client/public/vendor/ace/mode-jsonata.js': 'packages/node_modules/@node-red/editor-client/src/vendor/jsonata/mode-jsonata.js',
+                    'packages/node_modules/@node-red/editor-client/public/vendor/ace/snippets/jsonata.js': 'packages/node_modules/@node-red/editor-client/src/vendor/jsonata/snippets-jsonata.js'
                 }
             }
         },
         sass: {
             build: {
                 options: {
+                    implementation: sass,
                     outputStyle: 'compressed'
                 },
                 files: [{
-                    dest: 'public/red/style.min.css',
-                    src: 'editor/sass/style.scss'
-                },
-                {
-                    dest: 'public/vendor/bootstrap/css/bootstrap.min.css',
-                    src: 'editor/vendor/bootstrap/css/bootstrap.css'
+                    dest: 'packages/node_modules/@node-red/editor-client/public/red/style.min.css',
+                    src: 'packages/node_modules/@node-red/editor-client/src/sass/style.scss'
                 }]
             }
         },
         jsonlint: {
             messages: {
                 src: [
-                    'nodes/core/locales/en-US/messages.json',
-                    'red/api/locales/en-US/editor.json',
-                    'red/runtime/locales/en-US/runtime.json'
+                    'packages/node_modules/@node-red/nodes/locales/**/*.json',
+                    'packages/node_modules/@node-red/editor-client/locales/**/*.json',
+                    'packages/node_modules/@node-red/runtime/locales/**/*.json'
                 ]
             },
             keymaps: {
                 src: [
-                    'editor/js/keymap.json'
+                    'packages/node_modules/@node-red/editor-client/src/js/keymap.json'
                 ]
             }
         },
         attachCopyright: {
             js: {
                 src: [
-                    'public/red/red.min.js',
-                    'public/red/main.min.js'
+                    'packages/node_modules/@node-red/editor-client/public/red/red.min.js',
+                    'packages/node_modules/@node-red/editor-client/public/red/main.min.js'
                 ]
             },
             css: {
                 src: [
-                    'public/red/style.min.css'
+                    'packages/node_modules/@node-red/editor-client/public/red/style.min.css'
                 ]
             }
         },
         clean: {
             build: {
                 src: [
-                    "public/red",
-                    "public/index.html",
-                    "public/favicon.ico",
-                    "public/icons",
-                    "public/vendor"
+                    "packages/node_modules/@node-red/editor-client/public/red",
+                    "packages/node_modules/@node-red/editor-client/public/index.html",
+                    "packages/node_modules/@node-red/editor-client/public/favicon.ico",
+                    "packages/node_modules/@node-red/editor-client/public/icons",
+                    "packages/node_modules/@node-red/editor-client/public/vendor",
+                    "packages/node_modules/@node-red/editor-client/public/types/node",
+                    "packages/node_modules/@node-red/editor-client/public/types/node-red",
                 ]
             },
             release: {
@@ -252,30 +306,36 @@ module.exports = function(grunt) {
         watch: {
             js: {
                 files: [
-                    'editor/js/**/*.js'
+                    'packages/node_modules/@node-red/editor-client/src/js/**/*.js'
                 ],
-                tasks: ['copy:build','concat','uglify','attachCopyright:js']
+                tasks: ['copy:build','concat',/*'uglify',*/ 'attachCopyright:js']
             },
             sass: {
                 files: [
-                    'editor/sass/**/*.scss'
+                    'packages/node_modules/@node-red/editor-client/src/sass/**/*.scss'
                 ],
                 tasks: ['sass','attachCopyright:css']
             },
             json: {
                 files: [
-                    'nodes/core/locales/en-US/messages.json',
-                    'red/api/locales/en-US/editor.json',
-                    'red/runtime/locales/en-US/runtime.json'
+                    'packages/node_modules/@node-red/nodes/locales/**/*.json',
+                    'packages/node_modules/@node-red/editor-client/locales/**/*.json',
+                    'packages/node_modules/@node-red/runtime/locales/**/*.json'
                 ],
                 tasks: ['jsonlint:messages']
             },
             keymaps: {
                 files: [
-                    'editor/js/keymap.json'
+                    'packages/node_modules/@node-red/editor-client/src/js/keymap.json'
                 ],
                 tasks: ['jsonlint:keymaps','copy:build']
             },
+            tours: {
+                files: [
+                    'packages/node_modules/@node-red/editor-client/src/tours/**/*.js'
+                ],
+                tasks: ['copy:build']
+            },
             misc: {
                 files: [
                     'CHANGELOG.md'
@@ -287,12 +347,13 @@ module.exports = function(grunt) {
         nodemon: {
             /* uses .nodemonignore */
             dev: {
-                script: 'red.js',
+                script: 'packages/node_modules/node-red/red.js',
                 options: {
                     args: nodemonArgs,
                     ext: 'js,html,json',
                     watch: [
-                        'red','nodes'
+                        'packages/node_modules',
+                        '!packages/node_modules/@node-red/editor-client'
                     ]
                 }
             }
@@ -311,69 +372,75 @@ module.exports = function(grunt) {
             build: {
                 files:[
                     {
-                        src: 'editor/js/main.js',
-                        dest: 'public/red/main.js'
+                        src: 'packages/node_modules/@node-red/editor-client/src/js/main.js',
+                        dest: 'packages/node_modules/@node-red/editor-client/public/red/main.js'
                     },
                     {
-                        src: 'editor/js/keymap.json',
-                        dest: 'public/red/keymap.json'
+                        src: 'packages/node_modules/@node-red/editor-client/src/js/keymap.json',
+                        dest: 'packages/node_modules/@node-red/editor-client/public/red/keymap.json'
                     },
                     {
-                        cwd: 'editor/images',
+                        cwd: 'packages/node_modules/@node-red/editor-client/src/images',
                         src: '**',
                         expand: true,
-                        dest: 'public/red/images/'
+                        dest: 'packages/node_modules/@node-red/editor-client/public/red/images/'
                     },
                     {
-                        cwd: 'editor/vendor',
+                        cwd: 'packages/node_modules/@node-red/editor-client/src/vendor',
                         src: [
                             'ace/**',
-                            //'bootstrap/css/**',
-                            'bootstrap/img/**',
-                            'jquery/css/**',
-                            'font-awesome/**'
+                            'jquery/css/base/**',
+                            'font-awesome/**',
+                            'monaco/dist/**',
+                            'monaco/types/extraLibs.js',
+                            'monaco/style.css',
+                            'monaco/monaco-bootstrap.js'
                         ],
                         expand: true,
-                        dest: 'public/vendor/'
+                        dest: 'packages/node_modules/@node-red/editor-client/public/vendor/'
                     },
                     {
-                        cwd: 'editor/icons',
+                        cwd: 'packages/node_modules/@node-red/editor-client/src',
+                        src: [
+                            'types/node/*.ts',
+                            'types/node-red/*.ts',
+                        ],
+                        expand: true,
+                        dest: 'packages/node_modules/@node-red/editor-client/public/'
+                    },
+                    {
+                        cwd: 'packages/node_modules/@node-red/editor-client/src/icons',
                         src: '**',
                         expand: true,
-                        dest: 'public/icons/'
+                        dest: 'packages/node_modules/@node-red/editor-client/public/icons/'
                     },
                     {
                         expand: true,
-                        src: ['editor/index.html','editor/favicon.ico'],
-                        dest: 'public/',
+                        src: ['packages/node_modules/@node-red/editor-client/src/index.html','packages/node_modules/@node-red/editor-client/src/favicon.ico'],
+                        dest: 'packages/node_modules/@node-red/editor-client/public/',
                         flatten: true
                     },
                     {
                         src: 'CHANGELOG.md',
-                        dest: 'public/red/about'
+                        dest: 'packages/node_modules/@node-red/editor-client/public/red/about'
+                    },
+                    {
+                        src: 'CHANGELOG.md',
+                        dest: 'packages/node_modules/node-red/'
+                    },
+                    {
+                        cwd: 'packages/node_modules/@node-red/editor-client/src/ace/bin/',
+                        src: '**',
+                        expand: true,
+                        dest: 'packages/node_modules/@node-red/editor-client/public/vendor/ace/'
+                    },
+                    {
+                        cwd: 'packages/node_modules/@node-red/editor-client/src/tours',
+                        src: '**',
+                        expand: true,
+                        dest: 'packages/node_modules/@node-red/editor-client/public/red/tours/'
                     }
                 ]
-            },
-            release: {
-                files: [{
-                    mode: true,
-                    expand: true,
-                    src: [
-                        '*.md',
-                        'LICENSE',
-                        'package.json',
-                        'settings.js',
-                        'red.js',
-                        'lib/.gitignore',
-                        'nodes/*.demo',
-                        'nodes/core/**',
-                        'red/**',
-                        'public/**',
-                        'editor/templates/**',
-                        'bin/**'
-                    ],
-                    dest: path.resolve('<%= paths.dist %>/node-red-<%= pkg.version %>')
-                }]
             }
         },
         chmod: {
@@ -381,20 +448,96 @@ module.exports = function(grunt) {
                 mode: '755'
             },
             release: {
-                // Target-specific file/dir lists and/or options go here.
                 src: [
-                    path.resolve('<%= paths.dist %>/node-red-<%= pkg.version %>/nodes/core/hardware/nrgpio*')
+                    "packages/node_modules/@node-red/nodes/core/hardware/nrgpio",
+                    "packages/node_modules/@node-red/runtime/lib/storage/localfilesystem/projects/git/node-red-*sh"
                 ]
             }
         },
+        'npm-command': {
+            options: {
+                cmd: "pack",
+                cwd: "<%= paths.dist %>/modules"
+            },
+            'node-red': { options: { args: [__dirname+'/packages/node_modules/node-red'] } },
+            '@node-red/editor-api': { options: { args: [__dirname+'/packages/node_modules/@node-red/editor-api'] } },
+            '@node-red/editor-client': { options: { args: [__dirname+'/packages/node_modules/@node-red/editor-client'] } },
+            '@node-red/nodes': { options: { args: [__dirname+'/packages/node_modules/@node-red/nodes'] } },
+            '@node-red/registry': { options: { args: [__dirname+'/packages/node_modules/@node-red/registry'] } },
+            '@node-red/runtime': { options: { args: [__dirname+'/packages/node_modules/@node-red/runtime'] } },
+            '@node-red/util': { options: { args: [__dirname+'/packages/node_modules/@node-red/util'] } }
+
+
+        },
+        mkdir: {
+            release: {
+                options: {
+                    create: ['<%= paths.dist %>/modules']
+                },
+            },
+        },
         compress: {
             release: {
                 options: {
                     archive: '<%= paths.dist %>/node-red-<%= pkg.version %>.zip'
                 },
                 expand: true,
-                cwd: '<%= paths.dist %>/',
-                src: ['node-red-<%= pkg.version %>/**']
+                cwd: 'packages/node_modules/',
+                src: [
+                    '**',
+                    '!@node-red/editor-client/src/**'
+                ]
+            }
+        },
+        jsdoc : {
+            modules: {
+                src: [
+                    'API.md',
+                    'packages/node_modules/node-red/lib/red.js',
+                    'packages/node_modules/@node-red/runtime/lib/index.js',
+                    'packages/node_modules/@node-red/runtime/lib/api/*.js',
+                    'packages/node_modules/@node-red/runtime/lib/events.js',
+                    'packages/node_modules/@node-red/runtime/lib/hooks.js',
+                    'packages/node_modules/@node-red/util/**/*.js',
+                    'packages/node_modules/@node-red/editor-api/lib/index.js',
+                    'packages/node_modules/@node-red/editor-api/lib/auth/index.js',
+                    'packages/node_modules/@node-red/registry/lib/index.js'
+                ],
+                options: {
+                    destination: 'docs',
+                    configure: './jsdoc.json',
+                    fred: "hi there"
+                }
+            },
+            _editor: {
+                src: [
+                    'packages/node_modules/@node-red/editor-client/src/js'
+                    ],
+                options: {
+                    destination: 'packages/node_modules/@node-red/editor-client/docs',
+                    configure: './jsdoc.json'
+                }
+            }
+
+        },
+        jsdoc2md: {
+            runtimeAPI: {
+                options: {
+                    separators: true
+                },
+                src: [
+                    'packages/node_modules/@node-red/runtime/lib/index.js',
+                    'packages/node_modules/@node-red/runtime/lib/api/*.js',
+                    'packages/node_modules/@node-red/runtime/lib/events.js'
+                ],
+                dest: 'packages/node_modules/@node-red/runtime/docs/api.md'
+            },
+            nodeREDUtil: {
+                options: {
+                    separators: true
+                },
+                src: 'packages/node_modules/@node-red/util/**/*.js',
+                dest: 'packages/node_modules/@node-red/util/docs/api.md'
             }
         }
     });
@@ -407,17 +550,42 @@ module.exports = function(grunt) {
     grunt.loadNpmTasks('grunt-contrib-watch');
     grunt.loadNpmTasks('grunt-concurrent');
     grunt.loadNpmTasks('grunt-sass');
-    grunt.loadNpmTasks('grunt-nodemon');
     grunt.loadNpmTasks('grunt-contrib-compress');
     grunt.loadNpmTasks('grunt-contrib-copy');
     grunt.loadNpmTasks('grunt-chmod');
     grunt.loadNpmTasks('grunt-jsonlint');
-    grunt.loadNpmTasks('grunt-mocha-istanbul');
+    if (fs.existsSync(path.join("node_modules", "grunt-webdriver"))) {
+        grunt.loadNpmTasks('grunt-webdriver');
+    }
+    grunt.loadNpmTasks('grunt-jsdoc');
+    grunt.loadNpmTasks('grunt-jsdoc-to-markdown');
+    grunt.loadNpmTasks('grunt-npm-command');
+    grunt.loadNpmTasks('grunt-mkdir');
+    grunt.loadNpmTasks('grunt-simple-nyc');
+
+    grunt.registerMultiTask('nodemon', 'Runs a nodemon monitor of your node.js server.', function () {
+        const nodemon = require('nodemon');
+        this.async();
+        const options = this.options();
+        options.script = this.data.script;
+        let callback;
+        if (options.callback) {
+            callback = options.callback;
+            delete options.callback;
+        } else {
+            callback = function(nodemonApp) {
+                nodemonApp.on('log', function (event) {
+                    console.log(event.colour);
+                });
+            };
+        }
+        callback(nodemon(options));
+    });
 
     grunt.registerMultiTask('attachCopyright', function() {
         var files = this.data.src;
         var copyright = "/**\n"+
-            " * Copyright JS Foundation and other contributors, http://js.foundation\n"+
+            " * Copyright OpenJS Foundation and other contributors, https://openjsf.org/\n"+
             " *\n"+
             " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"+
             " * you may not use this file except in compliance with the License.\n"+
@@ -454,6 +622,38 @@ module.exports = function(grunt) {
         }
     });
 
+    grunt.registerTask('verifyPackageDependencies', function() {
+        var done = this.async();
+        var verifyDependencies = require("./scripts/verify-package-dependencies.js");
+        verifyDependencies().then(function(failures) {
+            if (failures.length > 0) {
+                failures.forEach(f => grunt.log.error(f));
+                grunt.fail.fatal("Failed to verify package dependencies");
+            }
+            done();
+        });
+    });
+
+    grunt.registerTask('verifyUiTestDependencies', function() {
+        if (!fs.existsSync(path.join("node_modules", "grunt-webdriver"))) {
+            grunt.fail.fatal('You need to install the UI test dependencies first.\nUse the script in "scripts/install-ui-test-dependencies.sh"');
+            return false;
+        }
+    });
+    grunt.registerTask('generatePublishScript',
+        'Generates a script to publish build output to npm',
+            function () {
+                const done = this.async();
+                const generatePublishScript = require("./scripts/generate-publish-script.js");
+                generatePublishScript().then(function(output) {
+                    grunt.log.writeln(output);
+
+                    const filePath = path.join(grunt.config.get('paths.dist'),"modules","publish.sh");
+                    grunt.file.write(filePath,output);
+
+                    done();
+                });
+            });
     grunt.registerTask('setDevEnv',
         'Sets NODE_ENV=development so non-minified assets are used',
             function () {
@@ -462,33 +662,61 @@ module.exports = function(grunt) {
 
     grunt.registerTask('default',
         'Builds editor content then runs code style checks and unit tests on all components',
-        ['build','test-core','test-editor','test-nodes']);
+        ['build','verifyPackageDependencies','jshint:editor','nyc:all']);
+
+    grunt.registerTask('no-coverage',
+        'Builds editor content then runs code style checks and unit tests on all components without code coverage',
+        ['build','verifyPackageDependencies','jshint:editor','simplemocha:all']);
+
 
     grunt.registerTask('test-core',
         'Runs code style check and unit tests on core runtime code',
-        ['jshint:core','simplemocha:core']);
+        ['build','nyc:core']);
 
     grunt.registerTask('test-editor',
         'Runs code style check on editor code',
         ['jshint:editor']);
 
+    if (!fs.existsSync(path.join("node_modules", "grunt-webdriver"))) {
+        grunt.registerTask('test-ui',
+            'Builds editor content then runs unit tests on editor ui',
+            ['verifyUiTestDependencies']);
+    } else {
+        grunt.registerTask('test-ui',
+            'Builds editor content then runs unit tests on editor ui',
+            ['verifyUiTestDependencies','build','jshint:editor','webdriver:all']);
+    }
+
     grunt.registerTask('test-nodes',
         'Runs unit tests on core nodes',
-        ['simplemocha:nodes']);
+        ['build','nyc:nodes']);
 
     grunt.registerTask('build',
         'Builds editor content',
         ['clean:build','jsonlint','concat:build','concat:vendor','copy:build','uglify:build','sass:build','attachCopyright']);
 
+    grunt.registerTask('build-dev',
+        'Developer mode: build dev version',
+        ['clean:build','concat:build','concat:vendor','copy:build','sass:build','setDevEnv']);
+
     grunt.registerTask('dev',
         'Developer mode: run node-red, watch for source changes and build/restart',
         ['build','setDevEnv','concurrent:dev']);
 
     grunt.registerTask('release',
         'Create distribution zip file',
-        ['build','clean:release','copy:release','chmod:release','compress:release']);
+        ['build','verifyPackageDependencies','clean:release','mkdir:release','chmod:release','compress:release','pack-modules','generatePublishScript']);
+
+    grunt.registerTask('pack-modules',
+        'Create module pack files for release',
+        ['mkdir:release','npm-command']);
+
 
     grunt.registerTask('coverage',
         'Run Istanbul code test coverage task',
-        ['build','mocha_istanbul']);
+        ['build','nyc:all']);
+
+    grunt.registerTask('docs',
+        'Generates API documentation',
+        ['jsdoc']);
 };

LICENSE

@@ -1,4 +1,4 @@
-Copyright JS Foundation and other contributors, http://js.foundation
+Copyright OpenJS Foundation and other contributors, https://openjsf.org/
 
                                  Apache License
                            Version 2.0, January 2004

README.md

@@ -2,19 +2,19 @@
 
 http://nodered.org
 
-[![Build Status](https://travis-ci.org/node-red/node-red.svg)](https://travis-ci.org/node-red/node-red)
+[![Build Status](https://travis-ci.org/node-red/node-red.svg?branch=master)](https://travis-ci.org/node-red/node-red)
 [![Coverage Status](https://coveralls.io/repos/node-red/node-red/badge.svg?branch=master)](https://coveralls.io/r/node-red/node-red?branch=master)
 
-A visual tool for wiring the Internet of Things.
+Low-code programming for event-driven applications.
 
-![Node-RED: A visual tool for wiring the Internet of Things](http://nodered.org/images/node-red-screenshot.png)
+![Node-RED: Low-code programming for event-driven applications](http://nodered.org/images/node-red-screenshot.png)
 
 ## Quick Start
 
 Check out http://nodered.org/docs/getting-started/ for full instructions on getting
 started.
 
-1. `sudo npm install -g node-red`
+1. `sudo npm install -g --unsafe-perm node-red`
 2. `node-red`
 3. Open <http://localhost:1880>
 
@@ -22,8 +22,7 @@ started.
 
 More documentation can be found [here](http://nodered.org/docs).
 
-For further help, or general discussion, please use the
-[mailing list](https://groups.google.com/forum/#!forum/node-red).
+For further help, or general discussion, please use the [Node-RED Forum](https://discourse.nodered.org) or [slack team](https://nodered.org/slack).
 
 ## Developers
 
@@ -45,9 +44,6 @@ If you want to run the latest code from git, here's how to get started:
 4. Run
 
         npm start
-   or
-
-        node red.js
 
 ## Contributing
 
@@ -56,19 +52,19 @@ Before raising a pull-request, please read our
 
 This project adheres to the [Contributor Covenant 1.4](http://contributor-covenant.org/version/1/4/).
  By participating, you are expected to uphold this code. Please report unacceptable
- behavior to any of the [project's core team](https://github.com/orgs/node-red/teams/core).
+ behavior to any of the project's core team at team@nodered.org.
 
 ## Authors
 
-Node-RED is a project of the [JS Foundation](http://js.foundation).
+Node-RED is a project of the [OpenJS Foundation](http://openjsf.org).
 
-It was created by [IBM Emerging Technology](https://www.ibm.com/blogs/emerging-technology/).
-
-* Nick O'Leary [@knolleary](http://twitter.com/knolleary)
-* Dave Conway-Jones [@ceejay](http://twitter.com/ceejay)
+It is maintained by:
 
+ * Nick O'Leary [@knolleary](http://twitter.com/knolleary)
+ * Dave Conway-Jones [@ceejay](http://twitter.com/ceejay)
+ * And many others...
 
 
 ## Copyright and license
 
-Copyright JS Foundation and other contributors, http://js.foundation under [the Apache 2.0 license](LICENSE).
+Copyright OpenJS Foundation and other contributors, https://openjsf.org under [the Apache 2.0 license](LICENSE).

SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report any potential security issues to `team@nodered.org`. This will notify the core project team who will respond accordingly.

editor/js/history.js

@@ -1,327 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-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]);
-                        RED.workspaces.add(ev.workspaces[i]);
-                    }
-                }
-                if (ev.subflow && ev.subflow.subflow) {
-                    RED.nodes.addSubflow(ev.subflow.subflow);
-                }
-                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 && 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 (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[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;
-                            }
-                        });
-                    }
-                    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);
-                    });
-                } 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.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.redraw(true);
-            RED.palette.refresh();
-            RED.workspaces.refresh();
-            RED.sidebar.config.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];
-        }
-    }
-
-})();

editor/js/i18n.js

@@ -1,86 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-RED.i18n = (function() {
-
-    return {
-        init: function(done) {
-            i18n.init({
-                resGetPath: 'locales/__ns__?lng=__lng__',
-                dynamicLoad: false,
-                load:'current',
-                ns: {
-                    namespaces: ["editor","node-red","jsonata","infotips"],
-                    defaultNs: "editor"
-                },
-                fallbackLng: ['en-US'],
-                useCookie: false
-            },function() {
-                done();
-            });
-            RED["_"] = function() {
-                return i18n.t.apply(null,arguments);
-            }
-
-        },
-        loadCatalog: 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: 'locales/'+namespace+'?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: 'locales/nodes?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();
-                        }
-                    }
-                });
-            })
-        }
-    }
-})();

editor/js/keymap.json

@@ -1,39 +0,0 @@
-{
-    "*": {
-        "ctrl-shift-p":"core:manage-palette",
-        "ctrl-f": "core:search",
-        "ctrl-=": "core:zoom-in",
-        "ctrl--": "core:zoom-out",
-        "ctrl-0": "core:zoom-reset",
-        "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-e": "core:show-export-dialog",
-        "ctrl-i": "core:show-import-dialog",
-        "ctrl-space": "core:toggle-sidebar",
-        "ctrl-,": "core:show-user-settings"
-    },
-    "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"
-     }
-}

editor/js/main.js

@@ -1,277 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-(function() {
-
-    function loadNodeList() {
-        $.ajax({
-            headers: {
-                "Accept":"application/json"
-            },
-            cache: false,
-            url: 'nodes',
-            success: function(data) {
-                RED.nodes.setNodeList(data);
-                RED.i18n.loadNodeCatalogs(loadNodes);
-            }
-        });
-    }
-
-    function loadNodes() {
-        $.ajax({
-            headers: {
-                "Accept":"text/html"
-            },
-            cache: false,
-            url: 'nodes',
-            success: function(data) {
-                $("body").append(data);
-                $("body").i18n();
-                $("#palette > .palette-spinner").hide();
-                $(".palette-scroll").removeClass("hide");
-                $("#palette-search").removeClass("hide");
-                loadFlows();
-            }
-        });
-    }
-
-    function loadFlows() {
-        $.ajax({
-            headers: {
-                "Accept":"application/json",
-            },
-            cache: false,
-            url: 'flows',
-            success: function(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));
-                }
-
-                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 (msg.text) {
-                        var text = RED._(msg.text,{default:msg.text});
-                        if (!persistentNotifications.hasOwnProperty(notificationId)) {
-                            persistentNotifications[notificationId] = RED.notify(text,msg.type,msg.timeout === undefined,msg.timeout);
-                        } else {
-                            persistentNotifications[notificationId].update(text,msg.timeout);
-                        }
-                    } 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")) {
-                            if (msg.text[0] !== ".") {
-                                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.loadCatalog(id, function() {
-                                $.get('nodes/'+id, function(data) {
-                                    $("body").append(data);
-                                });
-                            });
-                        });
-                        if (addedTypes.length) {
-                            typeList = "<ul><li>"+addedTypes.join("</li><li>")+"</li></ul>";
-                            RED.notify(RED._("palette.event.nodeAdded", {count:addedTypes.length})+typeList,"success");
-                        }
-                    } 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(RED._("palette.event.nodeRemoved", {count:m.types.length})+typeList,"success");
-                            }
-                        }
-                    } 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) {
-                                    $("body").append(data);
-                                    typeList = "<ul><li>"+msg.types.join("</li><li>")+"</li></ul>";
-                                    RED.notify(RED._("palette.event.nodeAdded", {count: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 == "node/upgraded") {
-                        RED.notify(RED._("palette.event.nodeUpgraded", {module:msg.module,version:msg.version}),"success");
-                        RED.nodes.registry.setModulePendingUpdated(msg.module,msg.version);
-                    }
-                    // Refresh flow library to ensure any examples are updated
-                    RED.library.loadFlowLibrary();
-                });
-            }
-        });
-    }
-
-    function showAbout() {
-        $.get('red/about', function(data) {
-            var aboutHeader = '<div style="text-align:center;">'+
-                                '<img width="50px" src="red/images/node-red-icon.svg" />'+
-                              '</div>';
-
-            RED.sidebar.info.set(aboutHeader+marked(data));
-            RED.sidebar.info.show();
-        });
-    }
-
-    function loadEditor() {
-        var menuOptions = [];
-        menuOptions.push({id:"menu-item-view-menu",label:RED._("menu.label.view.view"),options:[
-            // {id:"menu-item-view-show-grid",setting:"view-show-grid",label:RED._("menu.label.view.showGrid"),toggle:true,onselect:"core:toggle-show-grid"},
-            // {id:"menu-item-view-snap-grid",setting:"view-snap-grid",label:RED._("menu.label.view.snapGrid"),toggle:true,onselect:"core:toggle-snap-grid"},
-            // {id:"menu-item-status",setting:"node-show-status",label:RED._("menu.label.displayStatus"),toggle:true,onselect:"core:toggle-status", selected: true},
-            //null,
-            // {id:"menu-item-bidi",label:RED._("menu.label.view.textDir"),options:[
-            //     {id:"menu-item-bidi-default",toggle:"text-direction",label:RED._("menu.label.view.defaultDir"),selected: true, onselect:function(s) { if(s){RED.text.bidi.setTextDirection("")}}},
-            //     {id:"menu-item-bidi-ltr",toggle:"text-direction",label:RED._("menu.label.view.ltr"), onselect:function(s) { if(s){RED.text.bidi.setTextDirection("ltr")}}},
-            //     {id:"menu-item-bidi-rtl",toggle:"text-direction",label:RED._("menu.label.view.rtl"), onselect:function(s) { if(s){RED.text.bidi.setTextDirection("rtl")}}},
-            //     {id:"menu-item-bidi-auto",toggle:"text-direction",label:RED._("menu.label.view.auto"), onselect:function(s) { if(s){RED.text.bidi.setTextDirection("auto")}}}
-            // ]},
-            // null,
-            {id:"menu-item-sidebar",label:RED._("menu.label.sidebar.show"),toggle:true,onselect:"core:toggle-sidebar", selected: true},
-            null
-        ]});
-        menuOptions.push(null);
-        menuOptions.push({id:"menu-item-import",label:RED._("menu.label.import"),options:[
-            {id:"menu-item-import-clipboard",label:RED._("menu.label.clipboard"),onselect:"core:show-import-dialog"},
-            {id:"menu-item-import-library",label:RED._("menu.label.library"),options:[]}
-        ]});
-        menuOptions.push({id:"menu-item-export",label:RED._("menu.label.export"),disabled:true,options:[
-            {id:"menu-item-export-clipboard",label:RED._("menu.label.clipboard"),disabled:true,onselect:"core:show-export-dialog"},
-            {id:"menu-item-export-library",label:RED._("menu.label.library"),disabled:true,onselect:"core:library-export"}
-        ]});
-        menuOptions.push(null);
-        menuOptions.push({id:"menu-item-search",label:RED._("menu.label.search"),onselect:"core:search"});
-        menuOptions.push(null);
-        menuOptions.push({id:"menu-item-config-nodes",label:RED._("menu.label.displayConfig"),onselect:"core:show-config-tab"});
-        menuOptions.push({id:"menu-item-workspace",label:RED._("menu.label.flows"),options:[
-            {id:"menu-item-workspace-add",label:RED._("menu.label.add"),onselect:"core:add-flow"},
-            {id:"menu-item-workspace-edit",label:RED._("menu.label.rename"),onselect:"core:edit-flow"},
-            {id:"menu-item-workspace-delete",label:RED._("menu.label.delete"),onselect:"core:remove-flow"}
-        ]});
-        menuOptions.push({id:"menu-item-subflow",label:RED._("menu.label.subflows"), options: [
-            {id:"menu-item-subflow-create",label:RED._("menu.label.createSubflow"),onselect:"core:create-subflow"},
-            {id:"menu-item-subflow-convert",label:RED._("menu.label.selectionToSubflow"),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:RED._("menu.label.editPalette"),onselect:"core:manage-palette"});
-            menuOptions.push(null);
-        }
-
-        menuOptions.push({id:"menu-item-user-settings",label:RED._("menu.label.settings"),onselect:"core:show-user-settings"});
-        menuOptions.push(null);
-
-        menuOptions.push({id:"menu-item-keyboard-shortcuts",label:RED._("menu.label.keyboardShortcuts"),onselect:"core:show-help"});
-        menuOptions.push({id:"menu-item-help",
-            label: RED.settings.theme("menu.menu-item-help.label",RED._("menu.label.help")),
-            href: RED.settings.theme("menu.menu-item-help.url","http://nodered.org/docs")
-        });
-        menuOptions.push({id:"menu-item-node-red-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();
-        if (RED.settings.theme('palette.editable') !== false) {
-            RED.palette.editor.init();
-        }
-
-        RED.sidebar.init();
-        RED.subflow.init();
-        RED.workspaces.init();
-        RED.clipboard.init();
-        RED.search.init();
-        RED.editor.init();
-        RED.diff.init();
-
-        RED.menu.init({id:"btn-sidemenu",options: menuOptions});
-
-        RED.deploy.init(RED.settings.theme("deployButton",null));
-
-        RED.actions.add("core:show-about", showAbout);
-        RED.nodes.init();
-        RED.comms.connect();
-
-        $("#main-container").show();
-        $(".header-toolbar").show();
-
-        loadNodeList();
-    }
-
-    $(function() {
-
-        if ((window.location.hostname !== "localhost") && (window.location.hostname !== "127.0.0.1")) {
-            document.title = document.title+" : "+window.location.hostname;
-        }
-
-        ace.require("ace/ext/language_tools");
-
-        RED.i18n.init(function() {
-            RED.settings.init(loadEditor);
-        })
-    });
-})();

editor/js/ui/actions.js

@@ -1,35 +0,0 @@
-RED.actions = (function() {
-    var actions = {
-
-    }
-
-    function addAction(name,handler) {
-        actions[name] = handler;
-    }
-    function removeAction(name) {
-        delete actions[name];
-    }
-    function getAction(name) {
-        return actions[name];
-    }
-    function invokeAction(name) {
-        if (actions.hasOwnProperty(name)) {
-            actions[name]();
-        }
-    }
-    function listActions() {
-        var result = [];
-        Object.keys(actions).forEach(function(action) {
-            var shortcut = RED.keyboard.getShortcut(action);
-            result.push({id:action,scope:shortcut?shortcut.scope:undefined,key:shortcut?shortcut.key:undefined,user:shortcut?shortcut.user:undefined})
-        })
-        return result;
-    }
-    return {
-        add: addAction,
-        remove: removeAction,
-        get: getAction,
-        invoke: invokeAction,
-        list: listActions
-    }
-})();

editor/js/ui/clipboard.js

@@ -1,380 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-
-RED.clipboard = (function() {
-
-    var dialog;
-    var dialogContainer;
-    var exportNodesDialog;
-    var importNodesDialog;
-    var disabled = false;
-
-    function setupDialogs() {
-        dialog = $('<div id="clipboard-dialog" class="hide node-red-dialog"><form class="dialog-form form-horizontal"></form></div>')
-            .appendTo("body")
-            .dialog({
-                modal: true,
-                autoOpen: false,
-                width: 500,
-                resizable: false,
-                buttons: [
-                    {
-                        id: "clipboard-dialog-cancel",
-                        text: RED._("common.label.cancel"),
-                        click: function() {
-                            $( this ).dialog( "close" );
-                        }
-                    },
-                    {
-                        id: "clipboard-dialog-close",
-                        class: "primary",
-                        text: RED._("common.label.close"),
-                        click: function() {
-                            $( this ).dialog( "close" );
-                        }
-                    },
-                    {
-                        id: "clipboard-dialog-copy",
-                        class: "primary",
-                        text: RED._("clipboard.export.copy"),
-                        click: function() {
-                            $("#clipboard-export").select();
-                            document.execCommand("copy");
-                            document.getSelection().removeAllRanges();
-                            RED.notify(RED._("clipboard.nodesExported"));
-                            $( this ).dialog( "close" );
-                        }
-                    },
-                    {
-                        id: "clipboard-dialog-ok",
-                        class: "primary",
-                        text: RED._("common.label.import"),
-                        click: function() {
-                            RED.view.importNodes($("#clipboard-import").val(),$("#import-tab > a.selected").attr('id') === 'import-tab-new');
-                            $( this ).dialog( "close" );
-                        }
-                    }
-                ],
-                open: function(e) {
-                    $(this).parent().find(".ui-dialog-titlebar-close").hide();
-                },
-                close: function(e) {
-                }
-            });
-
-        dialogContainer = dialog.children(".dialog-form");
-
-        exportNodesDialog =
-            '<div class="form-row">'+
-                '<label style="width:auto;margin-right: 10px;" data-i18n="clipboard.export.copy"></label>'+
-                '<span id="export-range-group" class="button-group">'+
-                    '<a id="export-range-selected" class="editor-button toggle" href="#" data-i18n="clipboard.export.selected"></a>'+
-                    '<a id="export-range-flow" class="editor-button toggle" href="#" data-i18n="clipboard.export.current"></a>'+
-                    '<a id="export-range-full" class="editor-button toggle" href="#" data-i18n="clipboard.export.all"></a>'+
-                '</span>'+
-                '</div>'+
-            '<div class="form-row">'+
-                '<textarea readonly style="resize: none; width: 100%; border-radius: 4px;font-family: monospace; font-size: 12px; background:#f3f3f3; padding-left: 0.5em; box-sizing:border-box;" id="clipboard-export" rows="5"></textarea>'+
-            '</div>'+
-            '<div class="form-row" style="text-align: right;">'+
-                '<span id="export-format-group" class="button-group">'+
-                    '<a id="export-format-mini" class="editor-button editor-button-small toggle" href="#" data-i18n="clipboard.export.compact"></a>'+
-                    '<a id="export-format-full" class="editor-button editor-button-small toggle" href="#" data-i18n="clipboard.export.formatted"></a>'+
-                '</span>'+
-            '</div>';
-
-        importNodesDialog = '<div class="form-row">'+
-            '<textarea style="resize: none; width: 100%; border-radius: 0px;font-family: monospace; font-size: 12px; background:#eee; padding-left: 0.5em; box-sizing:border-box;" id="clipboard-import" rows="5" placeholder="'+
-            RED._("clipboard.pasteNodes")+
-            '"></textarea>'+
-            '</div>'+
-            '<div class="form-row">'+
-            '<label style="width:auto;margin-right: 10px;" data-i18n="clipboard.import.import"></label>'+
-            '<span id="import-tab" class="button-group">'+
-                '<a id="import-tab-current" class="editor-button toggle selected" href="#" data-i18n="clipboard.export.current"></a>'+
-                '<a id="import-tab-new" class="editor-button toggle" href="#" data-i18n="clipboard.import.newFlow"></a>'+
-            '</span>'+
-            '</div>';
-    }
-
-    function validateImport() {
-        var importInput = $("#clipboard-import");
-        var v = importInput.val();
-        v = v.substring(v.indexOf('['),v.lastIndexOf(']')+1);
-        try {
-            JSON.parse(v);
-            importInput.removeClass("input-error");
-            importInput.val(v);
-            $("#clipboard-dialog-ok").button("enable");
-        } catch(err) {
-            if (v !== "") {
-                importInput.addClass("input-error");
-            }
-            $("#clipboard-dialog-ok").button("disable");
-        }
-    }
-
-    function importNodes() {
-        if (disabled) {
-            return;
-        }
-        dialogContainer.empty();
-        dialogContainer.append($(importNodesDialog));
-        dialogContainer.i18n();
-
-        $("#clipboard-dialog-ok").show();
-        $("#clipboard-dialog-cancel").show();
-        $("#clipboard-dialog-close").hide();
-        $("#clipboard-dialog-copy").hide();
-        $("#clipboard-dialog-ok").button("disable");
-        $("#clipboard-import").keyup(validateImport);
-        $("#clipboard-import").on('paste',function() { setTimeout(validateImport,10)});
-
-        $("#import-tab > a").click(function(evt) {
-            evt.preventDefault();
-            if ($(this).hasClass('disabled') || $(this).hasClass('selected')) {
-                return;
-            }
-            $(this).parent().children().removeClass('selected');
-            $(this).addClass('selected');
-        });
-
-        dialog.dialog("option","title",RED._("clipboard.importNodes")).dialog("open");
-    }
-
-    function exportNodes() {
-        if (disabled) {
-            return;
-        }
-
-        dialogContainer.empty();
-        dialogContainer.append($(exportNodesDialog));
-        dialogContainer.i18n();
-        var format = RED.settings.flowFilePretty ? "export-format-full" : "export-format-mini";
-
-        $("#export-format-group > a").click(function(evt) {
-            evt.preventDefault();
-            if ($(this).hasClass('disabled') || $(this).hasClass('selected')) {
-                $("#clipboard-export").focus();
-                return;
-            }
-            $(this).parent().children().removeClass('selected');
-            $(this).addClass('selected');
-
-            var flow = $("#clipboard-export").val();
-            if (flow.length > 0) {
-                var nodes = JSON.parse(flow);
-
-                format = $(this).attr('id');
-                if (format === 'export-format-full') {
-                    flow = JSON.stringify(nodes,null,4);
-                } else {
-                    flow = JSON.stringify(nodes);
-                }
-                $("#clipboard-export").val(flow);
-                $("#clipboard-export").focus();
-            }
-        });
-
-        $("#export-range-group > a").click(function(evt) {
-            evt.preventDefault();
-            if ($(this).hasClass('disabled') || $(this).hasClass('selected')) {
-                $("#clipboard-export").focus();
-                return;
-            }
-            $(this).parent().children().removeClass('selected');
-            $(this).addClass('selected');
-            var type = $(this).attr('id');
-            var flow = "";
-            var nodes = null;
-            if (type === 'export-range-selected') {
-                var selection = RED.view.selection();
-                // Don't include the subflow meta-port nodes in the exported selection
-                nodes = RED.nodes.createExportableNodeSet(selection.nodes.filter(function(n) { return n.type !== 'subflow'}));
-            } else if (type === 'export-range-flow') {
-                var activeWorkspace = RED.workspaces.active();
-                nodes = RED.nodes.filterNodes({z:activeWorkspace});
-                var parentNode = RED.nodes.workspace(activeWorkspace)||RED.nodes.subflow(activeWorkspace);
-                nodes.unshift(parentNode);
-                nodes = RED.nodes.createExportableNodeSet(nodes);
-            } else if (type === 'export-range-full') {
-                nodes = RED.nodes.createCompleteNodeSet(false);
-            }
-            if (nodes !== null) {
-                if (format === "export-format-full") {
-                    flow = JSON.stringify(nodes,null,4);
-                } else {
-                    flow = JSON.stringify(nodes);
-                }
-            }
-            if (flow.length > 0) {
-                $("#export-copy").removeClass('disabled');
-            } else {
-                $("#export-copy").addClass('disabled');
-            }
-            $("#clipboard-export").val(flow);
-            $("#clipboard-export").focus();
-        })
-
-        $("#clipboard-dialog-ok").hide();
-        $("#clipboard-dialog-cancel").hide();
-        $("#clipboard-dialog-copy").hide();
-        $("#clipboard-dialog-close").hide();
-        var selection = RED.view.selection();
-        if (selection.nodes) {
-            $("#export-range-selected").click();
-        } else {
-            $("#export-range-selected").addClass('disabled').removeClass('selected');
-            $("#export-range-flow").click();
-        }
-        if (format === "export-format-full") {
-            $("#export-format-full").click();
-        } else {
-            $("#export-format-mini").click();
-        }
-        $("#clipboard-export")
-            .focus(function() {
-                var textarea = $(this);
-                textarea.select();
-                textarea.mouseup(function() {
-                    textarea.unbind("mouseup");
-                    return false;
-                })
-            });
-        dialog.dialog("option","title",RED._("clipboard.exportNodes")).dialog( "open" );
-
-        $("#clipboard-export").focus();
-        if (!document.queryCommandSupported("copy")) {
-            $("#clipboard-dialog-cancel").hide();
-            $("#clipboard-dialog-close").show();
-        } else {
-            $("#clipboard-dialog-cancel").show();
-            $("#clipboard-dialog-copy").show();
-        }
-    }
-
-    function hideDropTarget() {
-        $("#dropTarget").hide();
-        RED.keyboard.remove("escape");
-    }
-    function copyText(value,element,msg) {
-        var truncated = false;
-        if (typeof value !== "string" ) {
-            value = JSON.stringify(value, function(key,value) {
-                if (value !== null && typeof value === 'object') {
-                    if (value.__encoded__ && value.hasOwnProperty('data') && value.hasOwnProperty('length')) {
-                        truncated = value.data.length !== value.length;
-                        return value.data;
-                    }
-                }
-                return value;
-            });
-        }
-        if (truncated) {
-            msg += "_truncated";
-        }
-        $("#clipboard-hidden").val(value).select();
-        var result =  document.execCommand("copy");
-        if (result && element) {
-            var popover = RED.popover.create({
-                target: element,
-                direction: 'left',
-                size: 'small',
-                content: RED._(msg)
-            });
-            setTimeout(function() {
-                popover.close();
-            },1000);
-            popover.open();
-        }
-        return result;
-    }
-    return {
-        init: function() {
-            setupDialogs();
-
-            $('<input type="text" id="clipboard-hidden">').appendTo("body");
-
-            RED.events.on("view:selection-changed",function(selection) {
-                if (!selection.nodes) {
-                    RED.menu.setDisabled("menu-item-export",true);
-                    RED.menu.setDisabled("menu-item-export-clipboard",true);
-                    RED.menu.setDisabled("menu-item-export-library",true);
-                } else {
-                    RED.menu.setDisabled("menu-item-export",false);
-                    RED.menu.setDisabled("menu-item-export-clipboard",false);
-                    RED.menu.setDisabled("menu-item-export-library",false);
-                }
-            });
-
-            RED.actions.add("core:show-export-dialog",exportNodes);
-            RED.actions.add("core:show-import-dialog",importNodes);
-
-
-            RED.events.on("editor:open",function() { disabled = true; });
-            RED.events.on("editor:close",function() { disabled = false; });
-            RED.events.on("search:open",function() { disabled = true; });
-            RED.events.on("search:close",function() { disabled = false; });
-            RED.events.on("type-search:open",function() { disabled = true; });
-            RED.events.on("type-search:close",function() { disabled = false; });
-
-
-            $('#chart').on("dragenter",function(event) {
-                if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1 ||
-                     $.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
-                    $("#dropTarget").css({display:'table'});
-                    RED.keyboard.add("*", "escape" ,hideDropTarget);
-                }
-            });
-
-            $('#dropTarget').on("dragover",function(event) {
-                if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1 ||
-                     $.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
-                    event.preventDefault();
-                }
-            })
-            .on("dragleave",function(event) {
-                hideDropTarget();
-            })
-            .on("drop",function(event) {
-                if ($.inArray("text/plain",event.originalEvent.dataTransfer.types) != -1) {
-                    var data = event.originalEvent.dataTransfer.getData("text/plain");
-                    data = data.substring(data.indexOf('['),data.lastIndexOf(']')+1);
-                    RED.view.importNodes(data);
-                } else if ($.inArray("Files",event.originalEvent.dataTransfer.types) != -1) {
-                    var files = event.originalEvent.dataTransfer.files;
-                    if (files.length === 1) {
-                        var file = files[0];
-                        var reader = new FileReader();
-                        reader.onload = (function(theFile) {
-                            return function(e) {
-                                RED.view.importNodes(e.target.result);
-                            };
-                        })(file);
-                        reader.readAsText(file);
-                    }
-                }
-                hideDropTarget();
-                event.preventDefault();
-            });
-
-        },
-        import: importNodes,
-        export: exportNodes,
-        copyText: copyText
-    }
-})();

editor/js/ui/common/menu.js

@@ -1,267 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.menu = (function() {
-
-    var menuItems = {};
-
-    function createMenuItem(opt) {
-        var item;
-
-        if (opt !== null && opt.id) {
-            var themeSetting = RED.settings.theme("menu."+opt.id);
-            if (themeSetting === false) {
-                return null;
-            }
-        }
-
-        function setInitialState() {
-            var savedStateActive = RED.settings.get("menu-" + opt.id);
-            if (opt.setting) {
-                // May need to migrate pre-0.17 setting
-
-                if (savedStateActive !== null) {
-                    RED.settings.set(opt.setting,savedStateActive);
-                    RED.settings.remove("menu-" + opt.id);
-                } else {
-                    savedStateActive = RED.settings.get(opt.setting);
-                }
-            }
-            if (savedStateActive) {
-                link.addClass("active");
-                triggerAction(opt.id,true);
-            } else if (savedStateActive === false) {
-                link.removeClass("active");
-                triggerAction(opt.id,false);
-            } else if (opt.hasOwnProperty("selected")) {
-                if (opt.selected) {
-                    link.addClass("active");
-                } else {
-                    link.removeClass("active");
-                }
-                triggerAction(opt.id,opt.selected);
-            }
-        }
-
-        if (opt === null) {
-            item = $('<li class="divider"></li>');
-        } else {
-            item = $('<li></li>');
-
-            if (opt.group) {
-                item.addClass("menu-group-"+opt.group);
-
-            }
-            var linkContent = '<a '+(opt.id?'id="'+opt.id+'" ':'')+'tabindex="-1" href="#">';
-            if (opt.toggle) {
-                linkContent += '<i class="fa fa-square pull-left"></i>';
-                linkContent += '<i class="fa fa-check-square pull-left"></i>';
-
-            }
-            if (opt.icon !== undefined) {
-                if (/\.png/.test(opt.icon)) {
-                    linkContent += '<img src="'+opt.icon+'"/> ';
-                } else {
-                    linkContent += '<i class="'+(opt.icon?opt.icon:'" style="display: inline-block;"')+'"></i> ';
-                }
-            }
-
-            if (opt.sublabel) {
-                linkContent += '<span class="menu-label-container"><span class="menu-label">'+opt.label+'</span>'+
-                               '<span class="menu-sublabel">'+opt.sublabel+'</span></span>'
-            } else {
-                linkContent += '<span class="menu-label">'+opt.label+'</span>'
-            }
-
-            linkContent += '</a>';
-
-            var link = $(linkContent).appendTo(item);
-
-            menuItems[opt.id] = opt;
-
-            if (opt.onselect) {
-                link.click(function(e) {
-                    e.preventDefault();
-                    if ($(this).parent().hasClass("disabled")) {
-                        return;
-                    }
-                    if (opt.toggle) {
-                        var selected = isSelected(opt.id);
-                        if (typeof opt.toggle === "string") {
-                            if (!selected) {
-                                for (var m in menuItems) {
-                                    if (menuItems.hasOwnProperty(m)) {
-                                        var mi = menuItems[m];
-                                        if (mi.id != opt.id && opt.toggle == mi.toggle) {
-                                            setSelected(mi.id,false);
-                                        }
-                                    }
-                                }
-                                setSelected(opt.id,true);
-                            }
-                        } else {
-                            setSelected(opt.id, !selected);
-                        }
-                    } else {
-                        triggerAction(opt.id);
-                    }
-                });
-                if (opt.toggle) {
-                    setInitialState();
-                }
-            } else if (opt.href) {
-                link.attr("target","_blank").attr("href",opt.href);
-            } else if (!opt.options) {
-                item.addClass("disabled");
-                link.click(function(event) {
-                    event.preventDefault();
-                });
-            }
-            if (opt.options) {
-                item.addClass("dropdown-submenu pull-left");
-                var submenu = $('<ul id="'+opt.id+'-submenu" class="dropdown-menu"></ul>').appendTo(item);
-
-                for (var i=0;i<opt.options.length;i++) {
-                    var li = createMenuItem(opt.options[i]);
-                    if (li) {
-                        li.appendTo(submenu);
-                    }
-                }
-            }
-            if (opt.disabled) {
-                item.addClass("disabled");
-            }
-        }
-
-
-        return item;
-
-    }
-    function createMenu(options) {
-
-        var menuParent = $("#"+options.id);
-
-        var topMenu = $("<ul/>",{id:options.id+"-submenu", class:"dropdown-menu pull-right"});
-
-        if (menuParent.length === 1) {
-            topMenu.insertAfter(menuParent);
-        }
-
-        var lastAddedSeparator = false;
-        for (var i=0;i<options.options.length;i++) {
-            var opt = options.options[i];
-            if (opt !== null || !lastAddedSeparator) {
-                var li = createMenuItem(opt);
-                if (li) {
-                    li.appendTo(topMenu);
-                    lastAddedSeparator = (opt === null);
-                }
-            }
-        }
-
-        return topMenu;
-    }
-
-    function triggerAction(id, args) {
-        var opt = menuItems[id];
-        var callback = opt.onselect;
-        if (typeof opt.onselect === 'string') {
-            callback = RED.actions.get(opt.onselect);
-        }
-        if (callback) {
-            callback.call(opt,args);
-        } else {
-            console.log("No callback for",id,opt.onselect);
-        }
-    }
-
-    function isSelected(id) {
-        return $("#" + id).hasClass("active");
-    }
-
-    function setSelected(id,state) {
-        if (isSelected(id) == state) {
-            return;
-        }
-        var opt = menuItems[id];
-        if (state) {
-            $("#"+id).addClass("active");
-        } else {
-            $("#"+id).removeClass("active");
-        }
-        if (opt && opt.onselect) {
-            triggerAction(opt.id,state);
-        }
-        RED.settings.set(opt.setting||("menu-"+opt.id), state);
-    }
-
-    function toggleSelected(id) {
-        setSelected(id,!isSelected(id));
-    }
-
-    function setDisabled(id,state) {
-        if (state) {
-            $("#"+id).parent().addClass("disabled");
-        } else {
-            $("#"+id).parent().removeClass("disabled");
-        }
-    }
-
-    function addItem(id,opt) {
-        var item = createMenuItem(opt);
-        if (opt.group) {
-            var groupItems = $("#"+id+"-submenu").children(".menu-group-"+opt.group);
-            if (groupItems.length === 0) {
-                item.appendTo("#"+id+"-submenu");
-            } else {
-                for (var i=0;i<groupItems.length;i++) {
-                    var groupItem = groupItems[i];
-                    var label = $(groupItem).find(".menu-label").html();
-                    if (opt.label < label) {
-                        $(groupItem).before(item);
-                        break;
-                    }
-                }
-                if (i === groupItems.length) {
-                    item.appendTo("#"+id+"-submenu");
-                }
-            }
-        } else {
-            item.appendTo("#"+id+"-submenu");
-        }
-    }
-    function removeItem(id) {
-        $("#"+id).parent().remove();
-    }
-
-    function setAction(id,action) {
-        var opt = menuItems[id];
-        if (opt) {
-            opt.onselect = action;
-        }
-    }
-
-    return {
-        init: createMenu,
-        setSelected: setSelected,
-        isSelected: isSelected,
-        toggleSelected: toggleSelected,
-        setDisabled: setDisabled,
-        addItem: addItem,
-        removeItem: removeItem,
-        setAction: setAction
-        //TODO: add an api for replacing a submenu - see library.js:loadFlowLibrary
-    }
-})();

editor/js/ui/common/panels.js

@@ -1,81 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-
-RED.panels = (function() {
-
-    function createPanel(options) {
-        var container = options.container || $("#"+options.id);
-        var children = container.children();
-        if (children.length !== 2) {
-            throw new Error("Container must have exactly two children");
-        }
-
-        container.addClass("red-ui-panels");
-        var separator = $('<div class="red-ui-panels-separator"></div>').insertAfter(children[0]);
-        var startPosition;
-        var panelHeights = [];
-        var modifiedHeights = false;
-        var panelRatio;
-
-        separator.draggable({
-                axis: "y",
-                containment: container,
-                scroll: false,
-                start:function(event,ui) {
-                    var height = container.height();
-                    startPosition = ui.position.top;
-                    panelHeights = [$(children[0]).height(),$(children[1]).height()];
-                },
-                drag: function(event,ui) {
-                    var height = container.height();
-                    var delta = ui.position.top-startPosition;
-                    var newHeights = [panelHeights[0]+delta,panelHeights[1]-delta];
-                    $(children[0]).height(newHeights[0]);
-                    $(children[1]).height(newHeights[1]);
-                    if (options.resize) {
-                        options.resize(newHeights[0],newHeights[1]);
-                    }
-                    ui.position.top -= delta;
-                    panelRatio = newHeights[0]/height;
-                },
-                stop:function(event,ui) {
-                    modifiedHeights = true;
-                }
-        });
-
-        return {
-            resize: function(height) {
-                var panelHeights = [$(children[0]).height(),$(children[1]).height()];
-                container.height(height);
-                if (modifiedHeights) {
-                    var topPanelHeight = panelRatio*height;
-                    var bottomPanelHeight = height - topPanelHeight - 48;
-                    panelHeights = [topPanelHeight,bottomPanelHeight];
-                    $(children[0]).height(panelHeights[0]);
-                    $(children[1]).height(panelHeights[1]);
-                }
-                if (options.resize) {
-                    options.resize(panelHeights[0],panelHeights[1]);
-                }
-            }
-        }
-    }
-
-    return {
-        create: createPanel
-    }
-})();

editor/js/ui/common/popover.js

@@ -1,135 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-RED.popover = (function() {
-    var deltaSizes = {
-        "default": {
-            top: 10,
-            leftRight: 17,
-            leftLeft: 25
-        },
-        "small": {
-            top: 5,
-            leftRight: 8,
-            leftLeft: 16
-        }
-    }
-    function createPopover(options) {
-        var target = options.target;
-        var direction = options.direction || "right";
-        var trigger = options.trigger;
-        var content = options.content;
-        var delay = options.delay;
-        var width = options.width||"auto";
-        var size = options.size||"default";
-        if (!deltaSizes[size]) {
-            throw new Error("Invalid RED.popover size value:",size);
-        }
-
-        var timer = null;
-        var active;
-        var div;
-
-        var openPopup = function() {
-            if (active) {
-                div = $('<div class="red-ui-popover red-ui-popover-'+direction+'"></div>').appendTo("body");
-                if (size !== "default") {
-                    div.addClass("red-ui-popover-size-"+size);
-                }
-                if (typeof content === 'function') {
-                    content.call(res).appendTo(div);
-                } else {
-                    div.html(content);
-                }
-                if (width !== "auto") {
-                    div.width(width);
-                }
-
-
-                var targetPos = target.offset();
-                var targetWidth = target.width();
-                var targetHeight = target.height();
-
-                var divHeight = div.height();
-                var divWidth = div.width();
-                if (direction === 'right') {
-                    div.css({top: targetPos.top+targetHeight/2-divHeight/2-deltaSizes[size].top,left:targetPos.left+targetWidth+deltaSizes[size].leftRight});
-                } else if (direction === 'left') {
-                    div.css({top: targetPos.top+targetHeight/2-divHeight/2-deltaSizes[size].top,left:targetPos.left-deltaSizes[size].leftLeft-divWidth});
-                }
-
-                div.fadeIn("fast");
-            }
-        }
-        var closePopup = function() {
-            if (!active) {
-                if (div) {
-                    div.fadeOut("fast",function() {
-                        $(this).remove();
-                    });
-                    div = null;
-                }
-            }
-        }
-
-        if (trigger === 'hover') {
-
-            target.on('mouseenter',function(e) {
-                clearTimeout(timer);
-                active = true;
-                timer = setTimeout(openPopup,delay.show);
-            });
-            target.on('mouseleave', function(e) {
-                if (timer) {
-                    clearTimeout(timer);
-                }
-                active = false;
-                setTimeout(closePopup,delay.hide);
-            });
-        } else if (trigger === 'click') {
-            target.click(function(e) {
-                e.preventDefault();
-                e.stopPropagation();
-                active = !active;
-                if (!active) {
-                    closePopup();
-                } else {
-                    openPopup();
-                }
-            });
-        }
-        var res = {
-            setContent: function(_content) {
-                content = _content;
-            },
-            open: function () {
-                active = true;
-                openPopup();
-            },
-            close: function () {
-                active = false;
-                closePopup();
-            }
-        }
-        return res;
-
-    }
-
-    return {
-        create: createPopover
-    }
-
-})();

editor/js/ui/common/searchBox.js

@@ -1,99 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-(function($) {
-
-    $.widget( "nodered.searchBox", {
-        _create: function() {
-            var that = this;
-
-            this.currentTimeout = null;
-            this.lastSent = "";
-            this.element.val("");
-            this.uiContainer = this.element.wrap("<div>").parent();
-            this.uiContainer.addClass("red-ui-searchBox-container");
-
-            $('<i class="fa fa-search"></i>').prependTo(this.uiContainer);
-            this.clearButton = $('<a href="#"><i class="fa fa-times"></i></a>').appendTo(this.uiContainer);
-            this.clearButton.on("click",function(e) {
-                e.preventDefault();
-                that.element.val("");
-                that._change("",true);
-                that.element.focus();
-            });
-
-            this.resultCount = $('<span>',{class:"red-ui-searchBox-resultCount hide"}).appendTo(this.uiContainer);
-
-            this.element.val("");
-            this.element.on("keydown",function(evt) {
-                if (evt.keyCode === 27) {
-                    that.element.val("");
-                }
-            })
-            this.element.on("keyup",function(evt) {
-                that._change($(this).val());
-            });
-
-            this.element.on("focus",function() {
-                $("body").one("mousedown",function() {
-                    that.element.blur();
-                });
-            });
-
-        },
-        _change: function(val,instant) {
-            var fireEvent = false;
-            if (val === "") {
-                this.clearButton.hide();
-                fireEvent = true;
-            } else {
-                this.clearButton.show();
-                fireEvent = (val.length >= (this.options.minimumLength||0));
-            }
-            var current = this.element.val();
-            fireEvent = fireEvent && current !== this.lastSent;
-            if (fireEvent) {
-                if (!instant && this.options.delay > 0) {
-                    clearTimeout(this.currentTimeout);
-                    var that = this;
-                    this.currentTimeout = setTimeout(function() {
-                        that.lastSent = that.element.val();
-                        that._trigger("change");
-                    },this.options.delay);
-                } else {
-                    this._trigger("change");
-                }
-            }
-        },
-        value: function(val) {
-            if (val === undefined) {
-                return this.element.val();
-            } else {
-                this.element.val(val);
-                this._change(val);
-            }
-        },
-        count: function(val) {
-            if (val === undefined || val === null || val === "") {
-                this.resultCount.text("").hide();
-            } else {
-                this.resultCount.text(val).show();
-            }
-        },
-        change: function() {
-            this._trigger("change");
-        }
-    });
-})(jQuery);

editor/js/ui/common/tabs.js

@@ -1,379 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-
-
-RED.tabs = (function() {
-    function createTabs(options) {
-        var tabs = {};
-        var currentTabWidth;
-        var currentActiveTabWidth = 0;
-
-        var ul = options.element || $("#"+options.id);
-        var wrapper = ul.wrap( "<div>" ).parent();
-        var scrollContainer = ul.wrap( "<div>" ).parent();
-        wrapper.addClass("red-ui-tabs");
-        if (options.vertical) {
-            wrapper.addClass("red-ui-tabs-vertical");
-        }
-        if (options.addButton && typeof options.addButton === 'function') {
-            wrapper.addClass("red-ui-tabs-add");
-            var addButton = $('<div class="red-ui-tab-button"><a href="#"><i class="fa fa-plus"></i></a></div>').appendTo(wrapper);
-            addButton.find('a').click(function(evt) {
-                evt.preventDefault();
-                options.addButton();
-            })
-
-        }
-        var scrollLeft;
-        var scrollRight;
-
-        if (options.scrollable) {
-            wrapper.addClass("red-ui-tabs-scrollable");
-            scrollContainer.addClass("red-ui-tabs-scroll-container");
-            scrollContainer.scroll(updateScroll);
-            scrollLeft = $('<div class="red-ui-tab-button red-ui-tab-scroll red-ui-tab-scroll-left"><a href="#" style="display:none;"><i class="fa fa-caret-left"></i></a></div>').appendTo(wrapper).find("a");
-            scrollLeft.on('mousedown',function(evt) { scrollEventHandler(evt,'-=150') }).on('click',function(evt){ evt.preventDefault();});
-            scrollRight = $('<div class="red-ui-tab-button red-ui-tab-scroll red-ui-tab-scroll-right"><a href="#" style="display:none;"><i class="fa fa-caret-right"></i></a></div>').appendTo(wrapper).find("a");
-            scrollRight.on('mousedown',function(evt) { scrollEventHandler(evt,'+=150') }).on('click',function(evt){ evt.preventDefault();});
-        }
-        function scrollEventHandler(evt,dir) {
-            evt.preventDefault();
-            if ($(this).hasClass('disabled')) {
-                return;
-            }
-            var currentScrollLeft = scrollContainer.scrollLeft();
-            scrollContainer.animate( { scrollLeft: dir }, 100);
-            var interval = setInterval(function() {
-                var newScrollLeft = scrollContainer.scrollLeft()
-                if (newScrollLeft === currentScrollLeft) {
-                    clearInterval(interval);
-                    return;
-                }
-                currentScrollLeft = newScrollLeft;
-                scrollContainer.animate( { scrollLeft: dir }, 100);
-            },100);
-            $(this).one('mouseup',function() {
-                clearInterval(interval);
-            })
-        }
-
-
-        ul.children().first().addClass("active");
-        ul.children().addClass("red-ui-tab");
-
-        function onTabClick() {
-            if (options.onclick) {
-                options.onclick(tabs[$(this).attr('href').slice(1)]);
-            }
-            activateTab($(this));
-            return false;
-        }
-
-        function updateScroll() {
-            if (ul.children().length !== 0) {
-                var sl = scrollContainer.scrollLeft();
-                var scWidth = scrollContainer.width();
-                var ulWidth = ul.width();
-                if (sl === 0) {
-                    scrollLeft.hide();
-                } else {
-                    scrollLeft.show();
-                }
-                if (sl === ulWidth-scWidth) {
-                    scrollRight.hide();
-                } else {
-                    scrollRight.show();
-                }
-            }
-        }
-        function onTabDblClick() {
-            if (options.ondblclick) {
-                options.ondblclick(tabs[$(this).attr('href').slice(1)]);
-            }
-            return false;
-        }
-
-        function activateTab(link) {
-            if (typeof link === "string") {
-                link = ul.find("a[href='#"+link+"']");
-            }
-            if (link.length === 0) {
-                return;
-            }
-            if (!link.parent().hasClass("active")) {
-                ul.children().removeClass("active");
-                ul.children().css({"transition": "width 100ms"});
-                link.parent().addClass("active");
-                if (options.scrollable) {
-                    var pos = link.parent().position().left;
-                    if (pos-21 < 0) {
-                        scrollContainer.animate( { scrollLeft: '+='+(pos-50) }, 300);
-                    } else if (pos + 120 > scrollContainer.width()) {
-                        scrollContainer.animate( { scrollLeft: '+='+(pos + 140-scrollContainer.width()) }, 300);
-                    }
-                }
-                if (options.onchange) {
-                    options.onchange(tabs[link.attr('href').slice(1)]);
-                }
-                updateTabWidths();
-                setTimeout(function() {
-                    ul.children().css({"transition": ""});
-                },100);
-            }
-        }
-        function activatePreviousTab() {
-            var previous = ul.find("li.active").prev();
-            if (previous.length > 0) {
-                activateTab(previous.find("a"));
-            }
-        }
-        function activateNextTab() {
-            var next = ul.find("li.active").next();
-            if (next.length > 0) {
-                activateTab(next.find("a"));
-            }
-        }
-
-        function updateTabWidths() {
-            if (options.vertical) {
-                return;
-            }
-            var tabs = ul.find("li.red-ui-tab");
-            var width = wrapper.width();
-            var tabCount = tabs.size();
-            var tabWidth = (width-12-(tabCount*6))/tabCount;
-            currentTabWidth = (100*tabWidth/width)+"%";
-            currentActiveTabWidth = currentTabWidth+"%";
-            if (options.scrollable) {
-                tabWidth = Math.max(tabWidth,140);
-                currentTabWidth = tabWidth+"px";
-                currentActiveTabWidth = 0;
-                var listWidth = Math.max(wrapper.width(),12+(tabWidth+6)*tabCount);
-                ul.width(listWidth);
-                updateScroll();
-            } else if (options.hasOwnProperty("minimumActiveTabWidth")) {
-                if (tabWidth < options.minimumActiveTabWidth) {
-                    tabCount -= 1;
-                    tabWidth = (width-12-options.minimumActiveTabWidth-(tabCount*6))/tabCount;
-                    currentTabWidth = (100*tabWidth/width)+"%";
-                    currentActiveTabWidth = options.minimumActiveTabWidth+"px";
-                } else {
-                    currentActiveTabWidth = 0;
-                }
-            }
-            tabs.css({width:currentTabWidth});
-            if (tabWidth < 50) {
-                ul.find(".red-ui-tab-close").hide();
-                ul.find(".red-ui-tab-icon").hide();
-                ul.find(".red-ui-tab-label").css({paddingLeft:Math.min(12,Math.max(0,tabWidth-38))+"px"})
-            } else {
-                ul.find(".red-ui-tab-close").show();
-                ul.find(".red-ui-tab-icon").show();
-                ul.find(".red-ui-tab-label").css({paddingLeft:""})
-            }
-            if (currentActiveTabWidth !== 0) {
-                ul.find("li.red-ui-tab.active").css({"width":options.minimumActiveTabWidth});
-                ul.find("li.red-ui-tab.active .red-ui-tab-close").show();
-                ul.find("li.red-ui-tab.active .red-ui-tab-icon").show();
-                ul.find("li.red-ui-tab.active .red-ui-tab-label").css({paddingLeft:""})
-            }
-
-        }
-
-        ul.find("li.red-ui-tab a").on("click",onTabClick).on("dblclick",onTabDblClick);
-        setTimeout(function() {
-            updateTabWidths();
-        },0);
-
-
-        function removeTab(id) {
-            var li = ul.find("a[href='#"+id+"']").parent();
-            if (li.hasClass("active")) {
-                var tab = li.prev();
-                if (tab.size() === 0) {
-                    tab = li.next();
-                }
-                activateTab(tab.find("a"));
-            }
-            li.remove();
-            if (options.onremove) {
-                options.onremove(tabs[id]);
-            }
-            delete tabs[id];
-            updateTabWidths();
-        }
-
-        return {
-            addTab: function(tab) {
-                tabs[tab.id] = tab;
-                var li = $("<li/>",{class:"red-ui-tab"}).appendTo(ul);
-                li.attr('id',"red-ui-tab-"+(tab.id.replace(".","-")));
-                li.data("tabId",tab.id);
-                var link = $("<a/>",{href:"#"+tab.id, class:"red-ui-tab-label"}).appendTo(li);
-                if (tab.icon) {
-                    $('<img src="'+tab.icon+'" class="red-ui-tab-icon"/>').appendTo(link);
-                }
-                var span = $('<span/>',{class:"bidiAware"}).text(tab.label).appendTo(link);
-                span.attr('dir', RED.text.bidi.resolveBaseTextDir(tab.label));
-
-                link.on("click",onTabClick);
-                link.on("dblclick",onTabDblClick);
-                if (tab.closeable) {
-                    var closeLink = $("<a/>",{href:"#",class:"red-ui-tab-close"}).appendTo(li);
-                    closeLink.append('<i class="fa fa-times" />');
-
-                    closeLink.on("click",function(event) {
-                        event.preventDefault();
-                        removeTab(tab.id);
-                    });
-                }
-                updateTabWidths();
-                if (options.onadd) {
-                    options.onadd(tab);
-                }
-                link.attr("title",tab.label);
-                if (ul.find("li.red-ui-tab").size() == 1) {
-                    activateTab(link);
-                }
-                if (options.onreorder) {
-                    var originalTabOrder;
-                    var tabDragIndex;
-                    var tabElements = [];
-                    var startDragIndex;
-
-                    li.draggable({
-                        axis:"x",
-                        distance: 20,
-                        start: function(event,ui) {
-                            originalTabOrder = [];
-                            tabElements = [];
-                            ul.children().each(function(i) {
-                                tabElements[i] = {
-                                    el:$(this),
-                                    text: $(this).text(),
-                                    left: $(this).position().left,
-                                    width: $(this).width()
-                                };
-                                if ($(this).is(li)) {
-                                    tabDragIndex = i;
-                                    startDragIndex = i;
-                                }
-                                originalTabOrder.push($(this).data("tabId"));
-                            });
-                            ul.children().each(function(i) {
-                                if (i!==tabDragIndex) {
-                                    $(this).css({
-                                        position: 'absolute',
-                                        left: tabElements[i].left+"px",
-                                        width: tabElements[i].width+2,
-                                        transition: "left 0.3s"
-                                    });
-                                }
-
-                            })
-                            if (!li.hasClass('active')) {
-                                li.css({'zIndex':1});
-                            }
-                        },
-                        drag: function(event,ui) {
-                            ui.position.left += tabElements[tabDragIndex].left+scrollContainer.scrollLeft();
-                            var tabCenter = ui.position.left + tabElements[tabDragIndex].width/2 - scrollContainer.scrollLeft();
-                            for (var i=0;i<tabElements.length;i++) {
-                                if (i === tabDragIndex) {
-                                    continue;
-                                }
-                                if (tabCenter > tabElements[i].left && tabCenter < tabElements[i].left+tabElements[i].width) {
-                                    if (i < tabDragIndex) {
-                                        tabElements[i].left += tabElements[tabDragIndex].width+8;
-                                        tabElements[tabDragIndex].el.detach().insertBefore(tabElements[i].el);
-                                    } else {
-                                        tabElements[i].left -= tabElements[tabDragIndex].width+8;
-                                        tabElements[tabDragIndex].el.detach().insertAfter(tabElements[i].el);
-                                    }
-                                    tabElements[i].el.css({left:tabElements[i].left+"px"});
-
-                                    tabElements.splice(i, 0, tabElements.splice(tabDragIndex, 1)[0]);
-
-                                    tabDragIndex = i;
-                                    break;
-                                }
-                            }
-                        },
-                        stop: function(event,ui) {
-                            ul.children().css({position:"relative",left:"",transition:""});
-                            if (!li.hasClass('active')) {
-                                li.css({zIndex:""});
-                            }
-                            updateTabWidths();
-                            if (startDragIndex !== tabDragIndex) {
-                                options.onreorder(originalTabOrder, $.makeArray(ul.children().map(function() { return $(this).data('tabId');})));
-                            }
-                            activateTab(tabElements[tabDragIndex].el.data('tabId'));
-                        }
-                    })
-                }
-            },
-            removeTab: removeTab,
-            activateTab: activateTab,
-            nextTab: activateNextTab,
-            previousTab: activatePreviousTab,
-            resize: updateTabWidths,
-            count: function() {
-                return ul.find("li.red-ui-tab").size();
-            },
-            contains: function(id) {
-                return ul.find("a[href='#"+id+"']").length > 0;
-            },
-            renameTab: function(id,label) {
-                tabs[id].label = label;
-                var tab = ul.find("a[href='#"+id+"']");
-                tab.attr("title",label);
-                tab.find("span.bidiAware").text(label).attr('dir', RED.text.bidi.resolveBaseTextDir(label));
-                updateTabWidths();
-            },
-            order: function(order) {
-                var existingTabOrder = $.makeArray(ul.children().map(function() { return $(this).data('tabId');}));
-                if (existingTabOrder.length !== order.length) {
-                    return
-                }
-                var i;
-                var match = true;
-                for (i=0;i<order.length;i++) {
-                    if (order[i] !== existingTabOrder[i]) {
-                        match = false;
-                        break;
-                    }
-                }
-                if (match) {
-                    return;
-                }
-                var existingTabMap = {};
-                var existingTabs = ul.children().detach().each(function() {
-                    existingTabMap[$(this).data("tabId")] = $(this);
-                });
-                for (i=0;i<order.length;i++) {
-                    existingTabMap[order[i]].appendTo(ul);
-                }
-            }
-
-        }
-    }
-
-    return {
-        create: createTabs
-    }
-})();

editor/js/ui/common/typedInput.js

@@ -1,472 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-(function($) {
-    var allOptions = {
-        msg: {value:"msg",label:"msg.",validate:RED.utils.validatePropertyExpression},
-        flow: {value:"flow",label:"flow.",validate:RED.utils.validatePropertyExpression},
-        global: {value:"global",label:"global.",validate:RED.utils.validatePropertyExpression},
-        str: {value:"str",label:"string",icon:"red/images/typedInput/az.png"},
-        num: {value:"num",label:"number",icon:"red/images/typedInput/09.png",validate:/^[+-]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?$/},
-        bool: {value:"bool",label:"boolean",icon:"red/images/typedInput/bool.png",options:["true","false"]},
-        json: {
-            value:"json",
-            label:"JSON",
-            icon:"red/images/typedInput/json.png",
-            validate: function(v) { try{JSON.parse(v);return true;}catch(e){return false;}},
-            expand: function() {
-                var that = this;
-                var value = this.value();
-                try {
-                    value = JSON.stringify(JSON.parse(value),null,4);
-                } catch(err) {
-                }
-                RED.editor.editJSON({
-                    value: value,
-                    complete: function(v) {
-                        var value = v;
-                        try {
-                            value = JSON.stringify(JSON.parse(v));
-                        } catch(err) {
-                        }
-                        that.value(value);
-                    }
-                })
-            }
-        },
-        re: {value:"re",label:"regular expression",icon:"red/images/typedInput/re.png"},
-        date: {value:"date",label:"timestamp",hasValue:false},
-        jsonata: {
-            value: "jsonata",
-            label: "expression",
-            icon: "red/images/typedInput/expr.png",
-            validate: function(v) { try{jsonata(v);return true;}catch(e){return false;}},
-            expand:function() {
-                var that = this;
-                RED.editor.editExpression({
-                    value: this.value().replace(/\t/g,"\n"),
-                    complete: function(v) {
-                        that.value(v.replace(/\n/g,"\t"));
-                    }
-                })
-            }
-        },
-        bin: {
-            value: "bin",
-            label: "buffer",
-            icon: "red/images/typedInput/bin.png",
-            expand: function() {
-                var that = this;
-                RED.editor.editBuffer({
-                    value: this.value(),
-                    complete: function(v) {
-                        that.value(v);
-                    }
-                })
-            }
-        }
-    };
-    var nlsd = false;
-
-    $.widget( "nodered.typedInput", {
-        _create: function() {
-            if (!nlsd && RED && RED._) {
-                for (var i in allOptions) {
-                    if (allOptions.hasOwnProperty(i)) {
-                        allOptions[i].label = RED._("typedInput.type."+i,{defaultValue:allOptions[i].label});
-                    }
-                }
-            }
-            nlsd = true;
-            var that = this;
-
-            this.disarmClick = false;
-            this.element.addClass('red-ui-typedInput');
-            this.uiWidth = this.element.outerWidth();
-            this.elementDiv = this.element.wrap("<div>").parent().addClass('red-ui-typedInput-input');
-            this.uiSelect = this.elementDiv.wrap( "<div>" ).parent();
-            var attrStyle = this.element.attr('style');
-            var m;
-            if ((m = /width\s*:\s*(\d+(%|px))/i.exec(attrStyle)) !== null) {
-                this.element.css('width','100%');
-                this.uiSelect.width(m[1]);
-                this.uiWidth = null;
-            } else {
-                this.uiSelect.width(this.uiWidth);
-            }
-            ["Right","Left"].forEach(function(d) {
-                var m = that.element.css("margin"+d);
-                that.uiSelect.css("margin"+d,m);
-                that.element.css("margin"+d,0);
-            });
-            this.uiSelect.addClass("red-ui-typedInput-container");
-
-            this.options.types = this.options.types||Object.keys(allOptions);
-
-            this.selectTrigger = $('<button tabindex="0"></button>').prependTo(this.uiSelect);
-            $('<i class="fa fa-sort-desc"></i>').appendTo(this.selectTrigger);
-            this.selectLabel = $('<span></span>').appendTo(this.selectTrigger);
-
-            this.types(this.options.types);
-
-            if (this.options.typeField) {
-                this.typeField = $(this.options.typeField).hide();
-                var t = this.typeField.val();
-                if (t && this.typeMap[t]) {
-                    this.options.default = t;
-                }
-            } else {
-                this.typeField = $("<input>",{type:'hidden'}).appendTo(this.uiSelect);
-            }
-
-            this.element.on('focus', function() {
-                that.uiSelect.addClass('red-ui-typedInput-focus');
-            });
-            this.element.on('blur', function() {
-                that.uiSelect.removeClass('red-ui-typedInput-focus');
-            });
-            this.element.on('change', function() {
-                that.validate();
-            })
-            this.selectTrigger.click(function(event) {
-                event.preventDefault();
-                that._showTypeMenu();
-            });
-            this.selectTrigger.on('keydown',function(evt) {
-                if (evt.keyCode === 40) {
-                    // Down
-                    that._showTypeMenu();
-                }
-            }).on('focus', function() {
-                that.uiSelect.addClass('red-ui-typedInput-focus');
-            })
-
-            // explicitly set optionSelectTrigger display to inline-block otherwise jQ sets it to 'inline'
-            this.optionSelectTrigger = $('<button tabindex="0" class="red-ui-typedInput-option-trigger" style="display:inline-block"><span class="red-ui-typedInput-option-caret"><i class="fa fa-sort-desc"></i></span></button>').appendTo(this.uiSelect);
-            this.optionSelectLabel = $('<span class="red-ui-typedInput-option-label"></span>').prependTo(this.optionSelectTrigger);
-            this.optionSelectTrigger.click(function(event) {
-                event.preventDefault();
-                that._showOptionSelectMenu();
-            }).on('keydown', function(evt) {
-                if (evt.keyCode === 40) {
-                    // Down
-                    that._showOptionSelectMenu();
-                }
-            }).on('blur', function() {
-                that.uiSelect.removeClass('red-ui-typedInput-focus');
-            }).on('focus', function() {
-                that.uiSelect.addClass('red-ui-typedInput-focus');
-            });
-
-            this.optionExpandButton = $('<button tabindex="0" class="red-ui-typedInput-option-expand" style="display:inline-block"><i class="fa fa-ellipsis-h"></i></button>').appendTo(this.uiSelect);
-
-
-            this.type(this.options.default||this.typeList[0].value);
-        },
-        _showTypeMenu: function() {
-            if (this.typeList.length > 1) {
-                this._showMenu(this.menu,this.selectTrigger);
-                this.menu.find("[value='"+this.propertyType+"']").focus();
-            } else {
-                this.element.focus();
-            }
-        },
-        _showOptionSelectMenu: function() {
-            if (this.optionMenu) {
-                this.optionMenu.css({
-                    minWidth:this.optionSelectLabel.width()
-                });
-
-                this._showMenu(this.optionMenu,this.optionSelectLabel);
-                var selectedOption = this.optionMenu.find("[value='"+this.value()+"']");
-                if (selectedOption.length === 0) {
-                    selectedOption = this.optionMenu.children(":first");
-                }
-                selectedOption.focus();
-
-            }
-        },
-        _hideMenu: function(menu) {
-            $(document).off("mousedown.close-property-select");
-            menu.hide();
-            if (this.elementDiv.is(":visible")) {
-                this.element.focus();
-            } else if (this.optionSelectTrigger.is(":visible")){
-                this.optionSelectTrigger.focus();
-            } else {
-                this.selectTrigger.focus();
-            }
-        },
-        _createMenu: function(opts,callback) {
-            var that = this;
-            var menu = $("<div>").addClass("red-ui-typedInput-options");
-            opts.forEach(function(opt) {
-                if (typeof opt === 'string') {
-                    opt = {value:opt,label:opt};
-                }
-                var op = $('<a href="#"></a>').attr("value",opt.value).appendTo(menu);
-                if (opt.label) {
-                    op.text(opt.label);
-                }
-                if (opt.icon) {
-                    $('<img>',{src:opt.icon,style:"margin-right: 4px; height: 18px;"}).prependTo(op);
-                } else {
-                    op.css({paddingLeft: "18px"});
-                }
-
-                op.click(function(event) {
-                    event.preventDefault();
-                    callback(opt.value);
-                    that._hideMenu(menu);
-                });
-            });
-            menu.css({
-                display: "none",
-            });
-            menu.appendTo(document.body);
-
-            menu.on('keydown', function(evt) {
-                if (evt.keyCode === 40) {
-                    // DOWN
-                    $(this).children(":focus").next().focus();
-                } else if (evt.keyCode === 38) {
-                    // UP
-                    $(this).children(":focus").prev().focus();
-                } else if (evt.keyCode === 27) {
-                    that._hideMenu(menu);
-                }
-            })
-
-
-
-            return menu;
-
-        },
-        _showMenu: function(menu,relativeTo) {
-            if (this.disarmClick) {
-                this.disarmClick = false;
-                return
-            }
-            var that = this;
-            var pos = relativeTo.offset();
-            var height = relativeTo.height();
-            var menuHeight = menu.height();
-            var top = (height+pos.top-3);
-            if (top+menuHeight > $(window).height()) {
-                top -= (top+menuHeight)-$(window).height()+5;
-            }
-            menu.css({
-                top: top+"px",
-                left: (2+pos.left)+"px",
-            });
-            menu.slideDown(100);
-            this._delay(function() {
-                that.uiSelect.addClass('red-ui-typedInput-focus');
-                $(document).on("mousedown.close-property-select", function(event) {
-                    if(!$(event.target).closest(menu).length) {
-                        that._hideMenu(menu);
-                    }
-                    if ($(event.target).closest(relativeTo).length) {
-                        that.disarmClick = true;
-                        event.preventDefault();
-                    }
-                })
-            });
-        },
-        _getLabelWidth: function(label) {
-            var labelWidth = label.outerWidth();
-            if (labelWidth === 0) {
-                var container = $('<div class="red-ui-typedInput-container"></div>').css({
-                    position:"absolute",
-                    top:0,
-                    left:-1000
-                }).appendTo(document.body);
-                var newTrigger = label.clone().appendTo(container);
-                labelWidth = newTrigger.outerWidth();
-                container.remove();
-            }
-            return labelWidth;
-        },
-        _resize: function() {
-            if (this.uiWidth !== null) {
-                this.uiSelect.width(this.uiWidth);
-            }
-            if (this.typeMap[this.propertyType] && this.typeMap[this.propertyType].hasValue === false) {
-                this.selectTrigger.addClass("red-ui-typedInput-full-width");
-            } else {
-                this.selectTrigger.removeClass("red-ui-typedInput-full-width");
-                var labelWidth = this._getLabelWidth(this.selectTrigger);
-                this.elementDiv.css('left',labelWidth+"px");
-                if (this.optionExpandButton.is(":visible")) {
-                    this.elementDiv.css('right',"22px");
-                } else {
-                    this.elementDiv.css('right','0');
-                }
-                if (this.optionSelectTrigger) {
-                    this.optionSelectTrigger.css({'left':(labelWidth)+"px",'width':'calc( 100% - '+labelWidth+'px )'});
-                }
-            }
-        },
-        _destroy: function() {
-            this.menu.remove();
-        },
-        types: function(types) {
-            var that = this;
-            var currentType = this.type();
-            this.typeMap = {};
-            this.typeList = types.map(function(opt) {
-                var result;
-                if (typeof opt === 'string') {
-                    result = allOptions[opt];
-                } else {
-                    result = opt;
-                }
-                that.typeMap[result.value] = result;
-                return result;
-            });
-            this.selectTrigger.toggleClass("disabled", this.typeList.length === 1);
-            if (this.menu) {
-                this.menu.remove();
-            }
-            this.menu = this._createMenu(this.typeList, function(v) { that.type(v) });
-            if (currentType && !this.typeMap.hasOwnProperty(currentType)) {
-                this.type(this.typeList[0].value);
-            }
-        },
-        width: function(desiredWidth) {
-            this.uiWidth = desiredWidth;
-            this._resize();
-        },
-        value: function(value) {
-            if (!arguments.length) {
-                return this.element.val();
-            } else {
-                if (this.typeMap[this.propertyType].options) {
-                    if (this.typeMap[this.propertyType].options.indexOf(value) === -1) {
-                        value = "";
-                    }
-                    this.optionSelectLabel.text(value);
-                }
-                this.element.val(value);
-                this.element.trigger('change',this.type(),value);
-            }
-        },
-        type: function(type) {
-            if (!arguments.length) {
-                return this.propertyType;
-            } else {
-                var that = this;
-                var opt = this.typeMap[type];
-                if (opt && this.propertyType !== type) {
-                    this.propertyType = type;
-                    this.typeField.val(type);
-                    this.selectLabel.empty();
-                    var image;
-                    if (opt.icon) {
-                        image = new Image();
-                        image.name = opt.icon;
-                        image.src = opt.icon;
-                        $('<img>',{src:opt.icon,style:"margin-right: 4px;height: 18px;"}).prependTo(this.selectLabel);
-                    } else {
-                        this.selectLabel.text(opt.label);
-                    }
-                    if (opt.options) {
-                        if (this.optionExpandButton) {
-                            this.optionExpandButton.hide();
-                        }
-                        if (this.optionSelectTrigger) {
-                            this.optionSelectTrigger.show();
-                            this.elementDiv.hide();
-                            this.optionMenu = this._createMenu(opt.options,function(v){
-                                that.optionSelectLabel.text(v);
-                                that.value(v);
-                            });
-                            var currentVal = this.element.val();
-                            if (opt.options.indexOf(currentVal) !== -1) {
-                                this.optionSelectLabel.text(currentVal);
-                            } else {
-                                this.value(opt.options[0]);
-                            }
-                        }
-                    } else {
-                        if (this.optionMenu) {
-                            this.optionMenu.remove();
-                            this.optionMenu = null;
-                        }
-                        if (this.optionSelectTrigger) {
-                            this.optionSelectTrigger.hide();
-                        }
-                        if (opt.hasValue === false) {
-                            this.oldValue = this.element.val();
-                            this.element.val("");
-                            this.elementDiv.hide();
-                        } else {
-                            if (this.oldValue !== undefined) {
-                                this.element.val(this.oldValue);
-                                delete this.oldValue;
-                            }
-                            this.elementDiv.show();
-                        }
-                        if (opt.expand && typeof opt.expand === 'function') {
-                            this.optionExpandButton.show();
-                            this.optionExpandButton.off('click');
-                            this.optionExpandButton.on('click',function(evt) {
-                                evt.preventDefault();
-                                opt.expand.call(that);
-                            })
-                        } else {
-                            this.optionExpandButton.hide();
-                        }
-                        this.element.trigger('change',this.propertyType,this.value());
-                    }
-                    if (image) {
-                        image.onload = function() { that._resize(); }
-                        image.onerror = function() { that._resize(); }
-                    } else {
-                        this._resize();
-                    }
-                }
-            }
-        },
-        validate: function() {
-            var result;
-            var value = this.value();
-            var type = this.type();
-            if (this.typeMap[type] && this.typeMap[type].validate) {
-                var val = this.typeMap[type].validate;
-                if (typeof val === 'function') {
-                    result = val(value);
-                } else {
-                    result = val.test(value);
-                }
-            } else {
-                result = true;
-            }
-            if (result) {
-                this.uiSelect.removeClass('input-error');
-            } else {
-                this.uiSelect.addClass('input-error');
-            }
-            return result;
-        },
-        show: function() {
-            this.uiSelect.show();
-            this._resize();
-        },
-        hide: function() {
-            this.uiSelect.hide();
-        }
-    });
-})(jQuery);

editor/js/ui/deploy.js

@@ -1,442 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-RED.deploy = (function() {
-
-    var deploymentTypes = {
-        "full":{img:"red/images/deploy-full-o.png"},
-        "nodes":{img:"red/images/deploy-nodes-o.png"},
-        "flows":{img:"red/images/deploy-flows-o.png"}
-    }
-
-    var ignoreDeployWarnings = {
-        unknown: false,
-        unusedConfig: false,
-        invalid: false
-    }
-
-    var deploymentType = "full";
-
-    var deployInflight = false;
-
-    var currentDiff = null;
-
-    function changeDeploymentType(type) {
-        deploymentType = type;
-        $("#btn-deploy-icon").attr("src",deploymentTypes[type].img);
-    }
-
-    /**
-     * options:
-     *   type: "default" - Button with drop-down options - no further customisation available
-     *   type: "simple"  - Button without dropdown. Customisations:
-     *      label: the text to display - default: "Deploy"
-     *      icon : the icon to use. Null removes the icon. default: "red/images/deploy-full-o.png"
-     */
-    function init(options) {
-        options = options || {};
-        var type = options.type || "default";
-
-        if (type == "default") {
-            $('<li><span class="deploy-button-group button-group">'+
-              '<a id="btn-deploy" class="deploy-button disabled" href="#">'+
-                '<span class="deploy-button-content">'+
-                 '<img id="btn-deploy-icon" src="red/images/deploy-full-o.png"> '+
-                 '<span>'+RED._("deploy.deploy")+'</span>'+
-                '</span>'+
-                '<span class="deploy-button-spinner hide">'+
-                 '<img src="red/images/spin.svg"/>'+
-                '</span>'+
-              '</a>'+
-              '<a id="btn-deploy-options" data-toggle="dropdown" class="deploy-button" href="#"><i class="fa fa-caret-down"></i></a>'+
-              '</span></li>').prependTo(".header-toolbar");
-              RED.menu.init({id:"btn-deploy-options",
-                  options: [
-                      {id:"deploymenu-item-full",toggle:"deploy-type",icon:"red/images/deploy-full.png",label:RED._("deploy.full"),sublabel:RED._("deploy.fullDesc"),selected: true, onselect:function(s) { if(s){changeDeploymentType("full")}}},
-                      {id:"deploymenu-item-flow",toggle:"deploy-type",icon:"red/images/deploy-flows.png",label:RED._("deploy.modifiedFlows"),sublabel:RED._("deploy.modifiedFlowsDesc"), onselect:function(s) {if(s){changeDeploymentType("flows")}}},
-                      {id:"deploymenu-item-node",toggle:"deploy-type",icon:"red/images/deploy-nodes.png",label:RED._("deploy.modifiedNodes"),sublabel:RED._("deploy.modifiedNodesDesc"),onselect:function(s) { if(s){changeDeploymentType("nodes")}}}
-                  ]
-              });
-        } else if (type == "simple") {
-            var label = options.label || RED._("deploy.deploy");
-            var icon = 'red/images/deploy-full-o.png';
-            if (options.hasOwnProperty('icon')) {
-                icon = options.icon;
-            }
-
-            $('<li><span class="deploy-button-group button-group">'+
-              '<a id="btn-deploy" class="deploy-button disabled" href="#">'+
-                '<span class="deploy-button-content">'+
-                  (icon?'<img id="btn-deploy-icon" src="'+icon+'"> ':'')+
-                  '<span>'+label+'</span>'+
-                '</span>'+
-                '<span class="deploy-button-spinner hide">'+
-                 '<img src="red/images/spin.svg"/>'+
-                '</span>'+
-              '</a>'+
-              '</span></li>').prependTo(".header-toolbar");
-        }
-
-        $('#btn-deploy').click(function(event) {
-            event.preventDefault();
-            save();
-        });
-
-        RED.actions.add("core:deploy-flows",save);
-
-        $( "#node-dialog-confirm-deploy" ).dialog({
-                title: RED._('deploy.confirm.button.confirm'),
-                modal: true,
-                autoOpen: false,
-                width: 550,
-                height: "auto",
-                buttons: [
-                    {
-                        text: RED._("common.label.cancel"),
-                        click: function() {
-                            $( this ).dialog( "close" );
-                        }
-                    },
-                    {
-                        id: "node-dialog-confirm-deploy-review",
-                        text: RED._("deploy.confirm.button.review"),
-                        class: "primary disabled",
-                        click: function() {
-                            if (!$("#node-dialog-confirm-deploy-review").hasClass('disabled')) {
-                                RED.diff.showRemoteDiff();
-                                $( this ).dialog( "close" );
-                            }
-                        }
-                    },
-                    {
-                        id: "node-dialog-confirm-deploy-merge",
-                        text: RED._("deploy.confirm.button.merge"),
-                        class: "primary disabled",
-                        click: function() {
-                            RED.diff.mergeDiff(currentDiff);
-                            $( this ).dialog( "close" );
-                        }
-                    },
-                    {
-                        id: "node-dialog-confirm-deploy-deploy",
-                        text: RED._("deploy.confirm.button.confirm"),
-                        class: "primary",
-                        click: function() {
-
-                            var ignoreChecked = $( "#node-dialog-confirm-deploy-hide" ).prop("checked");
-                            if (ignoreChecked) {
-                                ignoreDeployWarnings[$( "#node-dialog-confirm-deploy-type" ).val()] = true;
-                            }
-                            save(true,/conflict/.test($("#node-dialog-confirm-deploy-type" ).val()));
-                            $( this ).dialog( "close" );
-                        }
-                    },
-                    {
-                        id: "node-dialog-confirm-deploy-overwrite",
-                        text: RED._("deploy.confirm.button.overwrite"),
-                        class: "primary",
-                        click: function() {
-                            save(true,/conflict/.test($("#node-dialog-confirm-deploy-type" ).val()));
-                            $( this ).dialog( "close" );
-                        }
-                    }
-                ],
-                create: function() {
-                    $("#node-dialog-confirm-deploy").parent().find("div.ui-dialog-buttonpane")
-                        .prepend('<div style="height:0; vertical-align: middle; display:inline-block; margin-top: 13px; float:left;">'+
-                                   '<input style="vertical-align:top;" type="checkbox" id="node-dialog-confirm-deploy-hide"> '+
-                                   '<label style="display:inline;" for="node-dialog-confirm-deploy-hide" data-i18n="deploy.confirm.doNotWarn"></label>'+
-                                   '<input type="hidden" id="node-dialog-confirm-deploy-type">'+
-                                   '</div>');
-                },
-                open: function() {
-                    var deployType = $("#node-dialog-confirm-deploy-type" ).val();
-                    if (/conflict/.test(deployType)) {
-                        $( "#node-dialog-confirm-deploy" ).dialog('option','title', RED._('deploy.confirm.button.review'));
-                        $("#node-dialog-confirm-deploy-deploy").hide();
-                        $("#node-dialog-confirm-deploy-review").addClass('disabled').show();
-                        $("#node-dialog-confirm-deploy-merge").addClass('disabled').show();
-                        $("#node-dialog-confirm-deploy-overwrite").toggle(deployType === "deploy-conflict");
-                        currentDiff = null;
-                        $("#node-dialog-confirm-deploy-conflict-checking").show();
-                        $("#node-dialog-confirm-deploy-conflict-auto-merge").hide();
-                        $("#node-dialog-confirm-deploy-conflict-manual-merge").hide();
-
-                        var now = Date.now();
-                        RED.diff.getRemoteDiff(function(diff) {
-                            var ellapsed = Math.max(1000 - (Date.now()-now), 0);
-                            currentDiff = diff;
-                            setTimeout(function() {
-                                $("#node-dialog-confirm-deploy-conflict-checking").hide();
-                                var d = Object.keys(diff.conflicts);
-                                if (d.length === 0) {
-                                    $("#node-dialog-confirm-deploy-conflict-auto-merge").show();
-                                    $("#node-dialog-confirm-deploy-merge").removeClass('disabled')
-                                } else {
-                                    $("#node-dialog-confirm-deploy-conflict-manual-merge").show();
-                                }
-                                $("#node-dialog-confirm-deploy-review").removeClass('disabled')
-                            },ellapsed);
-                        })
-
-
-                        $("#node-dialog-confirm-deploy-hide").parent().hide();
-                    } else {
-                        $( "#node-dialog-confirm-deploy" ).dialog('option','title', RED._('deploy.confirm.button.confirm'));
-                        $("#node-dialog-confirm-deploy-deploy").show();
-                        $("#node-dialog-confirm-deploy-overwrite").hide();
-                        $("#node-dialog-confirm-deploy-review").hide();
-                        $("#node-dialog-confirm-deploy-merge").hide();
-                        $("#node-dialog-confirm-deploy-hide").parent().show();
-                    }
-                }
-        });
-
-        RED.events.on('nodes:change',function(state) {
-            if (state.dirty) {
-                window.onbeforeunload = function() {
-                    return RED._("deploy.confirm.undeployedChanges");
-                }
-                $("#btn-deploy").removeClass("disabled");
-            } else {
-                window.onbeforeunload = null;
-                $("#btn-deploy").addClass("disabled");
-            }
-        });
-
-        var activeNotifyMessage;
-        RED.comms.subscribe("notification/runtime-deploy",function(topic,msg) {
-            if (!activeNotifyMessage) {
-                var currentRev = RED.nodes.version();
-                if (currentRev === null || deployInflight || currentRev === msg.revision) {
-                    return;
-                }
-                var message = $('<div>'+RED._('deploy.confirm.backgroundUpdate')+
-                    '<br><br><div class="ui-dialog-buttonset">'+
-                    '<button>'+RED._('deploy.confirm.button.ignore')+'</button>'+
-                    '<button class="primary">'+RED._('deploy.confirm.button.review')+'</button>'+
-                    '</div></div>');
-                $(message.find('button')[0]).click(function(evt) {
-                    evt.preventDefault();
-                    activeNotifyMessage.close();
-                    activeNotifyMessage = null;
-                })
-                $(message.find('button')[1]).click(function(evt) {
-                    evt.preventDefault();
-                    activeNotifyMessage.close();
-                    var nns = RED.nodes.createCompleteNodeSet();
-                    resolveConflict(nns,false);
-                    activeNotifyMessage = null;
-                })
-                activeNotifyMessage = RED.notify(message,null,true);
-            }
-        });
-    }
-
-    function getNodeInfo(node) {
-        var tabLabel = "";
-        if (node.z) {
-            var tab = RED.nodes.workspace(node.z);
-            if (!tab) {
-                tab = RED.nodes.subflow(node.z);
-                tabLabel = tab.name;
-            } else {
-                tabLabel = tab.label;
-            }
-        }
-        var label = RED.utils.getNodeLabel(node,node.id);
-        return {tab:tabLabel,type:node.type,label:label};
-    }
-    function sortNodeInfo(A,B) {
-        if (A.tab < B.tab) { return -1;}
-        if (A.tab > B.tab) { return 1;}
-        if (A.type < B.type) { return -1;}
-        if (A.type > B.type) { return 1;}
-        if (A.name < B.name) { return -1;}
-        if (A.name > B.name) { return 1;}
-        return 0;
-    }
-
-    function resolveConflict(currentNodes, activeDeploy) {
-        $( "#node-dialog-confirm-deploy-config" ).hide();
-        $( "#node-dialog-confirm-deploy-unknown" ).hide();
-        $( "#node-dialog-confirm-deploy-unused" ).hide();
-        $( "#node-dialog-confirm-deploy-conflict" ).show();
-        $( "#node-dialog-confirm-deploy-type" ).val(activeDeploy?"deploy-conflict":"background-conflict");
-        $( "#node-dialog-confirm-deploy" ).dialog( "open" );
-    }
-
-    function save(skipValidation,force) {
-        if (!$("#btn-deploy").hasClass("disabled")) {
-            if (!skipValidation) {
-                var hasUnknown = false;
-                var hasInvalid = false;
-                var hasUnusedConfig = false;
-
-                var unknownNodes = [];
-                var invalidNodes = [];
-
-                RED.nodes.eachNode(function(node) {
-                    hasInvalid = hasInvalid || !node.valid;
-                    if (!node.valid) {
-                        invalidNodes.push(getNodeInfo(node));
-                    }
-                    if (node.type === "unknown") {
-                        if (unknownNodes.indexOf(node.name) == -1) {
-                            unknownNodes.push(node.name);
-                        }
-                    }
-                });
-                hasUnknown = unknownNodes.length > 0;
-
-                var unusedConfigNodes = [];
-                RED.nodes.eachConfig(function(node) {
-                    if (node.users.length === 0 && (node._def.hasUsers !== false)) {
-                        unusedConfigNodes.push(getNodeInfo(node));
-                        hasUnusedConfig = true;
-                    }
-                });
-
-                $( "#node-dialog-confirm-deploy-config" ).hide();
-                $( "#node-dialog-confirm-deploy-unknown" ).hide();
-                $( "#node-dialog-confirm-deploy-unused" ).hide();
-                $( "#node-dialog-confirm-deploy-conflict" ).hide();
-
-                var showWarning = false;
-
-                if (hasUnknown && !ignoreDeployWarnings.unknown) {
-                    showWarning = true;
-                    $( "#node-dialog-confirm-deploy-type" ).val("unknown");
-                    $( "#node-dialog-confirm-deploy-unknown" ).show();
-                    $( "#node-dialog-confirm-deploy-unknown-list" )
-                        .html("<li>"+unknownNodes.join("</li><li>")+"</li>");
-                } else if (hasInvalid && !ignoreDeployWarnings.invalid) {
-                    showWarning = true;
-                    $( "#node-dialog-confirm-deploy-type" ).val("invalid");
-                    $( "#node-dialog-confirm-deploy-config" ).show();
-                    invalidNodes.sort(sortNodeInfo);
-                    $( "#node-dialog-confirm-deploy-invalid-list" )
-                        .html("<li>"+invalidNodes.map(function(A) { return (A.tab?"["+A.tab+"] ":"")+A.label+" ("+A.type+")"}).join("</li><li>")+"</li>");
-
-                } else if (hasUnusedConfig && !ignoreDeployWarnings.unusedConfig) {
-                    // showWarning = true;
-                    // $( "#node-dialog-confirm-deploy-type" ).val("unusedConfig");
-                    // $( "#node-dialog-confirm-deploy-unused" ).show();
-                    //
-                    // unusedConfigNodes.sort(sortNodeInfo);
-                    // $( "#node-dialog-confirm-deploy-unused-list" )
-                    //     .html("<li>"+unusedConfigNodes.map(function(A) { return (A.tab?"["+A.tab+"] ":"")+A.label+" ("+A.type+")"}).join("</li><li>")+"</li>");
-                }
-                if (showWarning) {
-                    $( "#node-dialog-confirm-deploy-hide" ).prop("checked",false);
-                    $( "#node-dialog-confirm-deploy" ).dialog( "open" );
-                    return;
-                }
-            }
-
-            var nns = RED.nodes.createCompleteNodeSet();
-
-            var startTime = Date.now();
-            $(".deploy-button-content").css('opacity',0);
-            $(".deploy-button-spinner").show();
-            $("#btn-deploy").addClass("disabled");
-
-            var data = {flows:nns};
-
-            if (!force) {
-                data.rev = RED.nodes.version();
-            }
-
-            deployInflight = true;
-            $("#header-shade").show();
-            $("#editor-shade").show();
-            $("#palette-shade").show();
-            $("#sidebar-shade").show();
-            $.ajax({
-                url:"flows",
-                type: "POST",
-                data: JSON.stringify(data),
-                contentType: "application/json; charset=utf-8",
-                headers: {
-                    "Node-RED-Deployment-Type":deploymentType
-                }
-            }).done(function(data,textStatus,xhr) {
-                RED.nodes.dirty(false);
-                RED.nodes.version(data.rev);
-                RED.nodes.originalFlow(nns);
-                if (hasUnusedConfig) {
-                    RED.notify(
-                    '<p>'+RED._("deploy.successfulDeploy")+'</p>'+
-                    '<p>'+RED._("deploy.unusedConfigNodes")+' <a href="#" onclick="RED.sidebar.config.show(true); return false;">'+RED._("deploy.unusedConfigNodesLink")+'</a></p>',"success",false,6000);
-                } else {
-                    RED.notify(RED._("deploy.successfulDeploy"),"success");
-                }
-                RED.nodes.eachNode(function(node) {
-                    if (node.changed) {
-                        node.dirty = true;
-                        node.changed = false;
-                    }
-                    if (node.moved) {
-                        node.dirty = true;
-                        node.moved = false;
-                    }
-                    if(node.credentials) {
-                        delete node.credentials;
-                    }
-                });
-                RED.nodes.eachConfig(function (confNode) {
-                    confNode.changed = false;
-                    if (confNode.credentials) {
-                        delete confNode.credentials;
-                    }
-                });
-                RED.nodes.eachWorkspace(function(ws) {
-                    ws.changed = false;
-                })
-                // Once deployed, cannot undo back to a clean state
-                RED.history.markAllDirty();
-                RED.view.redraw();
-                RED.events.emit("deploy");
-            }).fail(function(xhr,textStatus,err) {
-                RED.nodes.dirty(true);
-                $("#btn-deploy").removeClass("disabled");
-                if (xhr.status === 401) {
-                    RED.notify(RED._("deploy.deployFailed",{message:RED._("user.notAuthorized")}),"error");
-                } else if (xhr.status === 409) {
-                    resolveConflict(nns, true);
-                } else if (xhr.responseText) {
-                    RED.notify(RED._("deploy.deployFailed",{message:xhr.responseText}),"error");
-                } else {
-                    RED.notify(RED._("deploy.deployFailed",{message:RED._("deploy.errors.noResponse")}),"error");
-                }
-            }).always(function() {
-                deployInflight = false;
-                var delta = Math.max(0,300-(Date.now()-startTime));
-                setTimeout(function() {
-                    $(".deploy-button-content").css('opacity',1);
-                    $(".deploy-button-spinner").hide();
-                    $("#header-shade").hide();
-                    $("#editor-shade").hide();
-                    $("#palette-shade").hide();
-                    $("#sidebar-shade").hide();
-                },delta);
-            });
-        }
-    }
-    return {
-        init: init
-    }
-})();

editor/js/ui/library.js

@@ -1,493 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.library = (function() {
-
-
-    var exportToLibraryDialog;
-
-    function loadFlowLibrary() {
-        $.getJSON("library/flows",function(data) {
-            //console.log(data);
-
-            var buildMenu = function(data,root) {
-                var i;
-                var li;
-                var a;
-                var ul = document.createElement("ul");
-                if (root === "") {
-                    ul.id = "menu-item-import-library-submenu";
-                }
-                ul.className = "dropdown-menu";
-                if (data.d) {
-                    for (i in data.d) {
-                        if (data.d.hasOwnProperty(i)) {
-                            li = document.createElement("li");
-                            li.className = "dropdown-submenu pull-left";
-                            a = document.createElement("a");
-                            a.href="#";
-                            var label = i.replace(/^node-red-contrib-/,"").replace(/^node-red-node-/,"").replace(/-/," ").replace(/_/," ");
-                            a.innerHTML = label;
-                            li.appendChild(a);
-                            li.appendChild(buildMenu(data.d[i],root+(root!==""?"/":"")+i));
-                            ul.appendChild(li);
-                        }
-                    }
-                }
-                if (data.f) {
-                    for (i in data.f) {
-                        if (data.f.hasOwnProperty(i)) {
-                            li = document.createElement("li");
-                            a = document.createElement("a");
-                            a.href="#";
-                            a.innerHTML = data.f[i];
-                            a.flowName = root+(root!==""?"/":"")+data.f[i];
-                            a.onclick = function() {
-                                $.get('library/flows/'+this.flowName, function(data) {
-                                    RED.view.importNodes(data);
-                                });
-                            };
-                            li.appendChild(a);
-                            ul.appendChild(li);
-                        }
-                    }
-                }
-                return ul;
-            };
-            var examples;
-            if (data.d && data.d._examples_) {
-                examples = data.d._examples_;
-                delete data.d._examples_;
-            }
-            var menu = buildMenu(data,"");
-            $("#menu-item-import-examples").remove();
-            if (examples) {
-                RED.menu.addItem("menu-item-import",{id:"menu-item-import-examples",label:RED._("menu.label.examples"),options:[]})
-                $("#menu-item-import-examples-submenu").replaceWith(buildMenu(examples,"_examples_"));
-            }
-            //TODO: need an api in RED.menu for this
-            $("#menu-item-import-library-submenu").replaceWith(menu);
-        });
-    }
-
-    function createUI(options) {
-        var libraryData = {};
-        var selectedLibraryItem = null;
-        var libraryEditor = null;
-
-        // Orion editor has set/getText
-        // ACE editor has set/getValue
-        // normalise to set/getValue
-        if (options.editor.setText) {
-            // Orion doesn't like having pos passed in, so proxy the call to drop it
-            options.editor.setValue = function(text,pos) {
-                options.editor.setText.call(options.editor,text);
-            }
-        }
-        if (options.editor.getText) {
-            options.editor.getValue = options.editor.getText;
-        }
-
-        function buildFileListItem(item) {
-            var li = document.createElement("li");
-            li.onmouseover = function(e) { $(this).addClass("list-hover"); };
-            li.onmouseout = function(e) { $(this).removeClass("list-hover"); };
-            return li;
-        }
-
-        function buildFileList(root,data) {
-            var ul = document.createElement("ul");
-            var li;
-            for (var i=0; i<data.length; i++) {
-                var v = data[i];
-                if (typeof v === "string") {
-                    // directory
-                    li = buildFileListItem(v);
-                    li.onclick = (function () {
-                        var dirName = v;
-                        return function(e) {
-                            var bcli = $('<li class="active"><span class="divider">/</span> <a href="#">'+dirName+'</a></li>');
-                            $("a",bcli).click(function(e) {
-                                $(this).parent().nextAll().remove();
-                                $.getJSON("library/"+options.url+root+dirName,function(data) {
-                                    $("#node-select-library").children().first().replaceWith(buildFileList(root+dirName+"/",data));
-                                });
-                                e.stopPropagation();
-                            });
-                            var bc = $("#node-dialog-library-breadcrumbs");
-                            $(".active",bc).removeClass("active");
-                            bc.append(bcli);
-                            $.getJSON("library/"+options.url+root+dirName,function(data) {
-                                $("#node-select-library").children().first().replaceWith(buildFileList(root+dirName+"/",data));
-                            });
-                        }
-                    })();
-                    li.innerHTML = '<i class="fa fa-folder"></i> '+v+"</i>";
-                    ul.appendChild(li);
-                } else {
-                    // file
-                    li = buildFileListItem(v);
-                    li.innerHTML = v.name;
-                    li.onclick = (function() {
-                        var item = v;
-                        return function(e) {
-                            $(".list-selected",ul).removeClass("list-selected");
-                            $(this).addClass("list-selected");
-                            $.get("library/"+options.url+root+item.fn, function(data) {
-                                selectedLibraryItem = item;
-                                libraryEditor.setValue(data,-1);
-                            });
-                        }
-                    })();
-                    ul.appendChild(li);
-                }
-            }
-            return ul;
-        }
-
-        $('#node-input-name').css("width","66%").after(
-            '<div class="btn-group" style="margin-left: 5px;">'+
-            '<a id="node-input-'+options.type+'-lookup" class="editor-button" data-toggle="dropdown"><i class="fa fa-book"></i> <i class="fa fa-caret-down"></i></a>'+
-            '<ul class="dropdown-menu pull-right" role="menu">'+
-            '<li><a id="node-input-'+options.type+'-menu-open-library" tabindex="-1" href="#">'+RED._("library.openLibrary")+'</a></li>'+
-            '<li><a id="node-input-'+options.type+'-menu-save-library" tabindex="-1" href="#">'+RED._("library.saveToLibrary")+'</a></li>'+
-            '</ul></div>'
-        );
-
-        $('#node-input-'+options.type+'-menu-open-library').click(function(e) {
-            $("#node-select-library").children().remove();
-            var bc = $("#node-dialog-library-breadcrumbs");
-            bc.children().first().nextAll().remove();
-            libraryEditor.setValue('',-1);
-
-            $.getJSON("library/"+options.url,function(data) {
-                $("#node-select-library").append(buildFileList("/",data));
-                $("#node-dialog-library-breadcrumbs a").click(function(e) {
-                    $(this).parent().nextAll().remove();
-                    $("#node-select-library").children().first().replaceWith(buildFileList("/",data));
-                    e.stopPropagation();
-                });
-                $( "#node-dialog-library-lookup" ).dialog( "open" );
-            });
-
-            e.preventDefault();
-        });
-
-        $('#node-input-'+options.type+'-menu-save-library').click(function(e) {
-            //var found = false;
-            var name = $("#node-input-name").val().replace(/(^\s*)|(\s*$)/g,"");
-
-            //var buildPathList = function(data,root) {
-            //    var paths = [];
-            //    if (data.d) {
-            //        for (var i in data.d) {
-            //            var dn = root+(root==""?"":"/")+i;
-            //            var d = {
-            //                label:dn,
-            //                files:[]
-            //            };
-            //            for (var f in data.d[i].f) {
-            //                d.files.push(data.d[i].f[f].fn.split("/").slice(-1)[0]);
-            //            }
-            //            paths.push(d);
-            //            paths = paths.concat(buildPathList(data.d[i],root+(root==""?"":"/")+i));
-            //        }
-            //    }
-            //    return paths;
-            //};
-            $("#node-dialog-library-save-folder").attr("value","");
-
-            var filename = name.replace(/[^\w-]/g,"-");
-            if (filename === "") {
-                filename = "unnamed-"+options.type;
-            }
-            $("#node-dialog-library-save-filename").attr("value",filename+".js");
-
-            //var paths = buildPathList(libraryData,"");
-            //$("#node-dialog-library-save-folder").autocomplete({
-            //        minLength: 0,
-            //        source: paths,
-            //        select: function( event, ui ) {
-            //            $("#node-dialog-library-save-filename").autocomplete({
-            //                    minLength: 0,
-            //                    source: ui.item.files
-            //            });
-            //        }
-            //});
-
-            $( "#node-dialog-library-save" ).dialog( "open" );
-            e.preventDefault();
-        });
-
-        libraryEditor = ace.edit('node-select-library-text');
-        libraryEditor.setTheme("ace/theme/tomorrow");
-        if (options.mode) {
-            libraryEditor.getSession().setMode(options.mode);
-        }
-        libraryEditor.setOptions({
-            readOnly: true,
-            highlightActiveLine: false,
-            highlightGutterLine: false
-        });
-        libraryEditor.renderer.$cursorLayer.element.style.opacity=0;
-        libraryEditor.$blockScrolling = Infinity;
-
-        $( "#node-dialog-library-lookup" ).dialog({
-            title: RED._("library.typeLibrary", {type:options.type}),
-            modal: true,
-            autoOpen: false,
-            width: 800,
-            height: 450,
-            buttons: [
-                {
-                    text: RED._("common.label.cancel"),
-                    click: function() {
-                        $( this ).dialog( "close" );
-                    }
-                },
-                {
-                    text: RED._("common.label.load"),
-                    class: "primary",
-                    click: function() {
-                        if (selectedLibraryItem) {
-                            for (var i=0; i<options.fields.length; i++) {
-                                var field = options.fields[i];
-                                $("#node-input-"+field).val(selectedLibraryItem[field]);
-                            }
-                            options.editor.setValue(libraryEditor.getValue(),-1);
-                        }
-                        $( this ).dialog( "close" );
-                    }
-                }
-            ],
-            open: function(e) {
-                var form = $("form",this);
-                form.height(form.parent().height()-30);
-                $("#node-select-library-text").height("100%");
-                $(".form-row:last-child",form).children().height(form.height()-60);
-            },
-            resize: function(e) {
-                var form = $("form",this);
-                form.height(form.parent().height()-30);
-                $(".form-row:last-child",form).children().height(form.height()-60);
-            }
-        });
-
-        function saveToLibrary(overwrite) {
-            var name = $("#node-input-name").val().replace(/(^\s*)|(\s*$)/g,"");
-            if (name === "") {
-                name = RED._("library.unnamedType",{type:options.type});
-            }
-            var filename = $("#node-dialog-library-save-filename").val().replace(/(^\s*)|(\s*$)/g,"");
-            var pathname = $("#node-dialog-library-save-folder").val().replace(/(^\s*)|(\s*$)/g,"");
-            if (filename === "" || !/.+\.js$/.test(filename)) {
-                RED.notify(RED._("library.invalidFilename"),"warning");
-                return;
-            }
-            var fullpath = pathname+(pathname===""?"":"/")+filename;
-            if (!overwrite) {
-                //var pathnameParts = pathname.split("/");
-                //var exists = false;
-                //var ds = libraryData;
-                //for (var pnp in pathnameParts) {
-                //    if (ds.d && pathnameParts[pnp] in ds.d) {
-                //        ds = ds.d[pathnameParts[pnp]];
-                //    } else {
-                //        ds = null;
-                //        break;
-                //    }
-                //}
-                //if (ds && ds.f) {
-                //    for (var f in ds.f) {
-                //        if (ds.f[f].fn == fullpath) {
-                //            exists = true;
-                //            break;
-                //        }
-                //    }
-                //}
-                //if (exists) {
-                //    $("#node-dialog-library-save-content").html(RED._("library.dialogSaveOverwrite",{libraryType:options.type,libraryName:fullpath}));
-                //    $("#node-dialog-library-save-confirm").dialog( "open" );
-                //    return;
-                //}
-            }
-            var queryArgs = [];
-            var data = {};
-            for (var i=0; i<options.fields.length; i++) {
-                var field = options.fields[i];
-                if (field == "name") {
-                    data.name = name;
-                } else {
-                    data[field] = $("#node-input-"+field).val();
-                }
-            }
-
-            data.text = options.editor.getValue();
-            $.ajax({
-                url:"library/"+options.url+'/'+fullpath,
-                type: "POST",
-                data: JSON.stringify(data),
-                contentType: "application/json; charset=utf-8"
-            }).done(function(data,textStatus,xhr) {
-                RED.notify(RED._("library.savedType", {type:options.type}),"success");
-            }).fail(function(xhr,textStatus,err) {
-                if (xhr.status === 401) {
-                    RED.notify(RED._("library.saveFailed",{message:RED._("user.notAuthorized")}),"error");
-                } else {
-                    RED.notify(RED._("library.saveFailed",{message:xhr.responseText}),"error");
-                }
-            });
-        }
-        $( "#node-dialog-library-save-confirm" ).dialog({
-            title: RED._("library.saveToLibrary"),
-            modal: true,
-            autoOpen: false,
-            width: 530,
-            height: 230,
-            buttons: [
-                {
-                    text: RED._("common.label.cancel"),
-                    click: function() {
-                        $( this ).dialog( "close" );
-                    }
-                },
-                {
-                    text: RED._("common.label.save"),
-                    class: "primary",
-                    click: function() {
-                        saveToLibrary(true);
-                        $( this ).dialog( "close" );
-                    }
-                }
-            ]
-        });
-        $( "#node-dialog-library-save" ).dialog({
-            title: RED._("library.saveToLibrary"),
-            modal: true,
-            autoOpen: false,
-            width: 530,
-            height: 230,
-            buttons: [
-                {
-                    text: RED._("common.label.cancel"),
-                    click: function() {
-                        $( this ).dialog( "close" );
-                    }
-                },
-                {
-                    text: RED._("common.label.save"),
-                    class: "primary",
-                    click: function() {
-                        saveToLibrary(false);
-                        $( this ).dialog( "close" );
-                    }
-                }
-            ]
-        });
-
-    }
-
-    function exportFlow() {
-        //TODO: don't rely on the main dialog
-        var nns = RED.nodes.createExportableNodeSet(RED.view.selection().nodes);
-        $("#node-input-library-filename").attr('nodes',JSON.stringify(nns));
-        exportToLibraryDialog.dialog( "open" );
-    }
-
-    return {
-        init: function() {
-
-            RED.actions.add("core:library-export",exportFlow);
-
-            RED.events.on("view:selection-changed",function(selection) {
-                if (!selection.nodes) {
-                    RED.menu.setDisabled("menu-item-export",true);
-                    RED.menu.setDisabled("menu-item-export-clipboard",true);
-                    RED.menu.setDisabled("menu-item-export-library",true);
-                } else {
-                    RED.menu.setDisabled("menu-item-export",false);
-                    RED.menu.setDisabled("menu-item-export-clipboard",false);
-                    RED.menu.setDisabled("menu-item-export-library",false);
-                }
-            });
-
-            if (RED.settings.theme("menu.menu-item-import-library") !== false) {
-                loadFlowLibrary();
-            }
-
-            exportToLibraryDialog = $('<div id="library-dialog" class="hide"><form class="dialog-form form-horizontal"></form></div>')
-                .appendTo("body")
-                .dialog({
-                    modal: true,
-                    autoOpen: false,
-                    width: 500,
-                    resizable: false,
-                    title: RED._("library.exportToLibrary"),
-                    buttons: [
-                        {
-                            id: "library-dialog-cancel",
-                            text: RED._("common.label.cancel"),
-                            click: function() {
-                                $( this ).dialog( "close" );
-                            }
-                        },
-                        {
-                            id: "library-dialog-ok",
-                            class: "primary",
-                            text: RED._("common.label.export"),
-                            click: function() {
-                                //TODO: move this to RED.library
-                                var flowName = $("#node-input-library-filename").val();
-                                if (!/^\s*$/.test(flowName)) {
-                                    $.ajax({
-                                        url:'library/flows/'+flowName,
-                                        type: "POST",
-                                        data: $("#node-input-library-filename").attr('nodes'),
-                                        contentType: "application/json; charset=utf-8"
-                                    }).done(function() {
-                                        RED.library.loadFlowLibrary();
-                                        RED.notify(RED._("library.savedNodes"),"success");
-                                    }).fail(function(xhr,textStatus,err) {
-                                        if (xhr.status === 401) {
-                                            RED.notify(RED._("library.saveFailed",{message:RED._("user.notAuthorized")}),"error");
-                                        } else {
-                                            RED.notify(RED._("library.saveFailed",{message:xhr.responseText}),"error");
-                                        }
-                                    });
-                                }
-                                $( this ).dialog( "close" );
-                            }
-                        }
-                    ],
-                    open: function(e) {
-                        $(this).parent().find(".ui-dialog-titlebar-close").hide();
-                    },
-                    close: function(e) {
-                    }
-                });
-            exportToLibraryDialog.children(".dialog-form").append($(
-                '<div class="form-row">'+
-                '<label for="node-input-library-filename" data-i18n="[append]editor:library.filename"><i class="fa fa-file"></i> </label>'+
-                '<input type="text" id="node-input-library-filename" data-i18n="[placeholder]editor:library.fullFilenamePlaceholder">'+
-                '<input type="text" style="display: none;" />'+ // Second hidden input to prevent submit on Enter
-                '</div>'
-            ));
-        },
-        create: createUI,
-        loadFlowLibrary: loadFlowLibrary,
-
-        export: exportFlow
-    }
-})();

editor/js/ui/notifications.js

@@ -1,87 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.notify = (function() {
-    var currentNotifications = [];
-    var c = 0;
-    return function(msg,type,fixed,timeout) {
-        if (currentNotifications.length > 4) {
-            var ll = currentNotifications.length;
-            for (var i = 0;ll > 4 && i<currentNotifications.length;i+=1) {
-                var notifiction = currentNotifications[i];
-                if (!notifiction.fixed) {
-                    window.clearTimeout(notifiction.timeoutid);
-                    notifiction.close();
-                    ll -= 1;
-                }
-            }
-        }
-        var n = document.createElement("div");
-        n.id="red-notification-"+c;
-        n.className = "notification";
-        n.fixed = fixed;
-        if (type) {
-            n.className = "notification notification-"+type;
-        }
-        n.style.display = "none";
-        if (typeof msg === "string") {
-            n.innerHTML = msg;
-        } else {
-            $(n).append(msg);
-        }
-        $("#notifications").append(n);
-        $(n).slideDown(300);
-        n.close = (function() {
-            var nn = n;
-            return function() {
-                currentNotifications.splice(currentNotifications.indexOf(nn),1);
-                $(nn).slideUp(300, function() {
-                    nn.parentNode.removeChild(nn);
-                });
-            };
-        })();
-
-        n.update = (function() {
-            var nn = n;
-            return function(msg,timeout) {
-                if (typeof msg === "string") {
-                    nn.innerHTML = msg;
-                } else {
-                    $(nn).empty().append(msg);
-                }
-                if (timeout !== undefined && timeout > 0) {
-                    window.clearTimeout(nn.timeoutid);
-                    nn.timeoutid = window.setTimeout(nn.close,timeout);
-                } else {
-                    window.clearTimeout(nn.timeoutid);
-                }
-            }
-        })();
-
-        if (!fixed) {
-            $(n).click((function() {
-                var nn = n;
-                return function() {
-                    nn.close();
-                    window.clearTimeout(nn.timeoutid);
-                };
-            })());
-            n.timeoutid = window.setTimeout(n.close,timeout||3000);
-        }
-        currentNotifications.push(n);
-        c+=1;
-        return n;
-    }
-})();

editor/js/ui/palette-editor.js

@@ -1,956 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.palette.editor = (function() {
-
-    var disabled = false;
-
-    var editorTabs;
-    var filterInput;
-    var searchInput;
-    var nodeList;
-    var packageList;
-    var loadedList = [];
-    var filteredList = [];
-    var loadedIndex = {};
-
-    var typesInUse = {};
-    var nodeEntries = {};
-    var eventTimers = {};
-    var activeFilter = "";
-
-    function semVerCompare(A,B) {
-        var aParts = A.split(".").map(function(m) { return parseInt(m);});
-        var bParts = B.split(".").map(function(m) { return parseInt(m);});
-        for (var i=0;i<3;i++) {
-            var j = aParts[i]-bParts[i];
-            if (j<0) { return -1 }
-            if (j>0) { return 1 }
-        }
-        return 0;
-    }
-
-    function delayCallback(start,callback) {
-        var delta = Date.now() - start;
-        if (delta < 300) {
-            delta = 300;
-        } else {
-            delta = 0;
-        }
-        setTimeout(function() {
-            callback();
-        },delta);
-    }
-    function changeNodeState(id,state,shade,callback) {
-        shade.show();
-        var start = Date.now();
-        $.ajax({
-            url:"nodes/"+id,
-            type: "PUT",
-            data: JSON.stringify({
-                enabled: state
-            }),
-            contentType: "application/json; charset=utf-8"
-        }).done(function(data,textStatus,xhr) {
-            delayCallback(start,function() {
-                shade.hide();
-                callback();
-            });
-        }).fail(function(xhr,textStatus,err) {
-            delayCallback(start,function() {
-                shade.hide();
-                callback(xhr);
-            });
-        })
-    }
-    function installNodeModule(id,version,shade,callback) {
-        var requestBody = {
-            module: id
-        };
-        if (callback === undefined) {
-            callback = shade;
-            shade = version;
-        } else {
-            requestBody.version = version;
-        }
-        shade.show();
-        $.ajax({
-            url:"nodes",
-            type: "POST",
-            data: JSON.stringify(requestBody),
-            contentType: "application/json; charset=utf-8"
-        }).done(function(data,textStatus,xhr) {
-            shade.hide();
-            callback();
-        }).fail(function(xhr,textStatus,err) {
-            shade.hide();
-            callback(xhr);
-        });
-    }
-    function removeNodeModule(id,callback) {
-        $.ajax({
-            url:"nodes/"+id,
-            type: "DELETE"
-        }).done(function(data,textStatus,xhr) {
-            callback();
-        }).fail(function(xhr,textStatus,err) {
-            callback(xhr);
-        })
-    }
-
-    function refreshNodeModuleList() {
-        for (var id in nodeEntries) {
-            if (nodeEntries.hasOwnProperty(id)) {
-                _refreshNodeModule(id);
-            }
-        }
-    }
-
-    function refreshNodeModule(module) {
-        if (!eventTimers.hasOwnProperty(module)) {
-            eventTimers[module] = setTimeout(function() {
-                delete eventTimers[module];
-                _refreshNodeModule(module);
-            },100);
-        }
-    }
-
-
-    function getContrastingBorder(rgbColor){
-        var parts = /^rgba?\(\s*(\d+),\s*(\d+),\s*(\d+)[,)]/.exec(rgbColor);
-        if (parts) {
-            var r = parseInt(parts[1]);
-            var g = parseInt(parts[2]);
-            var b = parseInt(parts[3]);
-            var yiq = ((r*299)+(g*587)+(b*114))/1000;
-            if (yiq > 160) {
-                r = Math.floor(r*0.8);
-                g = Math.floor(g*0.8);
-                b = Math.floor(b*0.8);
-                return "rgb("+r+","+g+","+b+")";
-            }
-        }
-        return rgbColor;
-    }
-
-    function formatUpdatedAt(dateString) {
-        var now = new Date();
-        var d = new Date(dateString);
-        var delta = (Date.now() - new Date(dateString).getTime())/1000;
-
-        if (delta < 60) {
-            return RED._('palette.editor.times.seconds');
-        }
-        delta = Math.floor(delta/60);
-        if (delta < 10) {
-            return RED._('palette.editor.times.minutes');
-        }
-        if (delta < 60) {
-            return RED._('palette.editor.times.minutesV',{count:delta});
-        }
-
-        delta = Math.floor(delta/60);
-
-        if (delta < 24) {
-            return RED._('palette.editor.times.hoursV',{count:delta});
-        }
-
-        delta = Math.floor(delta/24);
-
-        if (delta < 7) {
-            return RED._('palette.editor.times.daysV',{count:delta})
-        }
-        var weeks = Math.floor(delta/7);
-        var days = delta%7;
-
-        if (weeks < 4) {
-            return RED._('palette.editor.times.weeksV',{count:weeks})
-        }
-
-        var months = Math.floor(weeks/4);
-        weeks = weeks%4;
-
-        if (months < 12) {
-            return RED._('palette.editor.times.monthsV',{count:months})
-        }
-        var years = Math.floor(months/12);
-        months = months%12;
-
-        if (months === 0) {
-            return RED._('palette.editor.times.yearsV',{count:years})
-        } else {
-            return RED._('palette.editor.times.year'+(years>1?'s':'')+'MonthsV',{y:years,count:months})
-        }
-    }
-
-
-    function _refreshNodeModule(module) {
-        if (!nodeEntries.hasOwnProperty(module)) {
-            nodeEntries[module] = {info:RED.nodes.registry.getModule(module)};
-            var index = [module];
-            for (var s in nodeEntries[module].info.sets) {
-                if (nodeEntries[module].info.sets.hasOwnProperty(s)) {
-                    index.push(s);
-                    index = index.concat(nodeEntries[module].info.sets[s].types)
-                }
-            }
-            nodeEntries[module].index = index.join(",").toLowerCase();
-            nodeList.editableList('addItem', nodeEntries[module]);
-        } else {
-            var moduleInfo = nodeEntries[module].info;
-            var nodeEntry = nodeEntries[module].elements;
-            if (nodeEntry) {
-                var activeTypeCount = 0;
-                var typeCount = 0;
-                nodeEntries[module].totalUseCount = 0;
-                nodeEntries[module].setUseCount = {};
-
-                for (var setName in moduleInfo.sets) {
-                    if (moduleInfo.sets.hasOwnProperty(setName)) {
-                        var inUseCount = 0;
-                        var set = moduleInfo.sets[setName];
-                        var setElements = nodeEntry.sets[setName];
-
-                        if (set.enabled) {
-                            activeTypeCount += set.types.length;
-                        }
-                        typeCount += set.types.length;
-                        for (var i=0;i<moduleInfo.sets[setName].types.length;i++) {
-                            var t = moduleInfo.sets[setName].types[i];
-                            inUseCount += (typesInUse[t]||0);
-                            var swatch = setElements.swatches[t];
-                            if (set.enabled) {
-                                var def = RED.nodes.getType(t);
-                                if (def && def.color) {
-                                    swatch.css({background:def.color});
-                                    swatch.css({border: "1px solid "+getContrastingBorder(swatch.css('backgroundColor'))})
-
-                                } else {
-                                    swatch.css({background:"#eee",border:"1px dashed #999"})
-                                }
-                            } else {
-                                swatch.css({background:"#eee",border:"1px dashed #999"})
-                            }
-                        }
-                        nodeEntries[module].setUseCount[setName] = inUseCount;
-                        nodeEntries[module].totalUseCount += inUseCount;
-
-                        if (inUseCount > 0) {
-                            setElements.enableButton.html(RED._('palette.editor.inuse'));
-                            setElements.enableButton.addClass('disabled');
-                        } else {
-                            setElements.enableButton.removeClass('disabled');
-                            if (set.enabled) {
-                                setElements.enableButton.html(RED._('palette.editor.disable'));
-                            } else {
-                                setElements.enableButton.html(RED._('palette.editor.enable'));
-                            }
-                        }
-                        setElements.setRow.toggleClass("palette-module-set-disabled",!set.enabled);
-                    }
-                }
-                var nodeCount = (activeTypeCount === typeCount)?typeCount:activeTypeCount+" / "+typeCount;
-                nodeEntry.setCount.html(RED._('palette.editor.nodeCount',{count:typeCount,label:nodeCount}));
-
-                if (nodeEntries[module].totalUseCount > 0) {
-                    nodeEntry.enableButton.html(RED._('palette.editor.inuse'));
-                    nodeEntry.enableButton.addClass('disabled');
-                    nodeEntry.removeButton.hide();
-                } else {
-                    nodeEntry.enableButton.removeClass('disabled');
-                    if (moduleInfo.local) {
-                        nodeEntry.removeButton.css('display', 'inline-block');
-                    }
-                    if (activeTypeCount === 0) {
-                        nodeEntry.enableButton.html(RED._('palette.editor.enableall'));
-                    } else {
-                        nodeEntry.enableButton.html(RED._('palette.editor.disableall'));
-                    }
-                    nodeEntry.container.toggleClass("disabled",(activeTypeCount === 0));
-                }
-            }
-            if (moduleInfo.pending_version) {
-                nodeEntry.versionSpan.html(moduleInfo.version+' <i class="fa fa-long-arrow-right"></i> '+moduleInfo.pending_version).appendTo(nodeEntry.metaRow)
-                nodeEntry.updateButton.html(RED._('palette.editor.updated')).addClass('disabled').show();
-            } else if (loadedIndex.hasOwnProperty(module)) {
-                if (semVerCompare(loadedIndex[module].version,moduleInfo.version) === 1) {
-                    nodeEntry.updateButton.show();
-                    nodeEntry.updateButton.html(RED._('palette.editor.update',{version:loadedIndex[module].version}));
-                } else {
-                    nodeEntry.updateButton.hide();
-                }
-            } else {
-                nodeEntry.updateButton.hide();
-            }
-        }
-
-    }
-
-    function filterChange(val) {
-        activeFilter = val.toLowerCase();
-        var visible = nodeList.editableList('filter');
-        var size = nodeList.editableList('length');
-        if (val === "") {
-            filterInput.searchBox('count');
-        } else {
-            filterInput.searchBox('count',visible+" / "+size);
-        }
-    }
-
-
-    var catalogueCount;
-    var catalogueLoadStatus = [];
-    var catalogueLoadStart;
-    var catalogueLoadErrors = false;
-
-    var activeSort = sortModulesAZ;
-
-    function handleCatalogResponse(err,catalog,index,v) {
-        catalogueLoadStatus.push(err||v);
-        if (!err) {
-            if (v.modules) {
-                v.modules.forEach(function(m) {
-                    loadedIndex[m.id] = m;
-                    m.index = [m.id];
-                    if (m.keywords) {
-                        m.index = m.index.concat(m.keywords);
-                    }
-                    if (m.updated_at) {
-                        m.timestamp = new Date(m.updated_at).getTime();
-                    } else {
-                        m.timestamp = 0;
-                    }
-                    m.index = m.index.join(",").toLowerCase();
-                })
-                loadedList = loadedList.concat(v.modules);
-            }
-            searchInput.searchBox('count',loadedList.length);
-        } else {
-            catalogueLoadErrors = true;
-        }
-        if (catalogueCount > 1) {
-            $(".palette-module-shade-status").html(RED._('palette.editor.loading')+"<br>"+catalogueLoadStatus.length+"/"+catalogueCount);
-        }
-        if (catalogueLoadStatus.length === catalogueCount) {
-            if (catalogueLoadErrors) {
-                RED.notify(RED._('palette.editor.errors.catalogLoadFailed',{url: catalog}),"error",false,8000);
-            }
-            var delta = 250-(Date.now() - catalogueLoadStart);
-            setTimeout(function() {
-                $("#palette-module-install-shade").hide();
-            },Math.max(delta,0));
-
-        }
-    }
-
-    function initInstallTab() {
-        if (loadedList.length === 0) {
-            loadedList = [];
-            loadedIndex = {};
-            packageList.editableList('empty');
-
-            $(".palette-module-shade-status").html(RED._('palette.editor.loading'));
-            var catalogues = RED.settings.theme('palette.catalogues')||['https://catalogue.nodered.org/catalogue.json'];
-            catalogueLoadStatus = [];
-            catalogueLoadErrors = false;
-            catalogueCount = catalogues.length;
-            if (catalogues.length > 1) {
-                $(".palette-module-shade-status").html(RED._('palette.editor.loading')+"<br>0/"+catalogues.length);
-            }
-            $("#palette-module-install-shade").show();
-            catalogueLoadStart = Date.now();
-            var handled = 0;
-            catalogues.forEach(function(catalog,index) {
-                $.getJSON(catalog, {_: new Date().getTime()},function(v) {
-                    handleCatalogResponse(null,catalog,index,v);
-                    refreshNodeModuleList();
-                }).fail(function(jqxhr, textStatus, error) {
-                    handleCatalogResponse(jqxhr,catalog,index);
-                }).always(function() {
-                    handled++;
-                    if (handled === catalogueCount) {
-                        searchInput.searchBox('change');
-                    }
-                })
-            });
-        }
-    }
-
-    function refreshFilteredItems() {
-        packageList.editableList('empty');
-        var currentFilter = searchInput.searchBox('value').trim();
-        if (currentFilter === ""){
-            packageList.editableList('addItem',{count:loadedList.length})
-            return;
-        }
-        filteredList.sort(activeSort);
-        for (var i=0;i<Math.min(10,filteredList.length);i++) {
-            packageList.editableList('addItem',filteredList[i]);
-        }
-        if (filteredList.length === 0) {
-            packageList.editableList('addItem',{});
-        }
-
-        if (filteredList.length > 10) {
-            packageList.editableList('addItem',{start:10,more:filteredList.length-10})
-        }
-    }
-    function sortModulesAZ(A,B) {
-        return A.info.id.localeCompare(B.info.id);
-    }
-    function sortModulesRecent(A,B) {
-        return -1 * (A.info.timestamp-B.info.timestamp);
-    }
-
-
-    function init() {
-        if (RED.settings.theme('palette.editable') === false) {
-            return;
-        }
-        createSettingsPane();
-
-        RED.userSettings.add({
-            id:'palette',
-            title: RED._("palette.editor.palette"),
-            get: getSettingsPane,
-            close: function() {
-                settingsPane.detach();
-            },
-            focus: function() {
-                editorTabs.resize();
-                setTimeout(function() {
-                    filterInput.focus();
-                },200);
-            }
-        })
-
-        RED.actions.add("core:manage-palette",function() {
-                RED.userSettings.show('palette');
-            });
-
-        RED.events.on('registry:module-updated', function(ns) {
-            refreshNodeModule(ns.module);
-        });
-        RED.events.on('registry:node-set-enabled', function(ns) {
-            refreshNodeModule(ns.module);
-        });
-        RED.events.on('registry:node-set-disabled', function(ns) {
-            refreshNodeModule(ns.module);
-        });
-        RED.events.on('registry:node-type-added', function(nodeType) {
-            if (!/^subflow:/.test(nodeType)) {
-                var ns = RED.nodes.registry.getNodeSetForType(nodeType);
-                refreshNodeModule(ns.module);
-            }
-        });
-        RED.events.on('registry:node-type-removed', function(nodeType) {
-            if (!/^subflow:/.test(nodeType)) {
-                var ns = RED.nodes.registry.getNodeSetForType(nodeType);
-                refreshNodeModule(ns.module);
-            }
-        });
-        RED.events.on('registry:node-set-added', function(ns) {
-            refreshNodeModule(ns.module);
-            for (var i=0;i<filteredList.length;i++) {
-                if (filteredList[i].info.id === ns.module) {
-                    var installButton = filteredList[i].elements.installButton;
-                    installButton.addClass('disabled');
-                    installButton.html(RED._('palette.editor.installed'));
-                    break;
-                }
-            }
-        });
-        RED.events.on('registry:node-set-removed', function(ns) {
-            var module = RED.nodes.registry.getModule(ns.module);
-            if (!module) {
-                var entry = nodeEntries[ns.module];
-                if (entry) {
-                    nodeList.editableList('removeItem', entry);
-                    delete nodeEntries[ns.module];
-                    for (var i=0;i<filteredList.length;i++) {
-                        if (filteredList[i].info.id === ns.module) {
-                            var installButton = filteredList[i].elements.installButton;
-                            installButton.removeClass('disabled');
-                            installButton.html(RED._('palette.editor.install'));
-                            break;
-                        }
-                    }
-                }
-            }
-        });
-        RED.events.on('nodes:add', function(n) {
-            if (!/^subflow:/.test(n.type)) {
-                typesInUse[n.type] = (typesInUse[n.type]||0)+1;
-                if (typesInUse[n.type] === 1) {
-                    var ns = RED.nodes.registry.getNodeSetForType(n.type);
-                    refreshNodeModule(ns.module);
-                }
-            }
-        })
-        RED.events.on('nodes:remove', function(n) {
-            if (typesInUse.hasOwnProperty(n.type)) {
-                typesInUse[n.type]--;
-                if (typesInUse[n.type] === 0) {
-                    delete typesInUse[n.type];
-                    var ns = RED.nodes.registry.getNodeSetForType(n.type);
-                    refreshNodeModule(ns.module);
-                }
-            }
-        })
-    }
-
-    var settingsPane;
-
-    function getSettingsPane() {
-        initInstallTab();
-        editorTabs.activateTab('nodes');
-        return settingsPane;
-    }
-
-
-
-    function createSettingsPane() {
-        settingsPane = $('<div id="user-settings-tab-palette"></div>');
-        var content = $('<div id="palette-editor">'+
-            '<ul id="palette-editor-tabs"></ul>'+
-        '</div>').appendTo(settingsPane);
-
-        editorTabs = RED.tabs.create({
-            element: settingsPane.find('#palette-editor-tabs'),
-            onchange:function(tab) {
-                content.find(".palette-editor-tab").hide();
-                tab.content.show();
-                if (filterInput) {
-                    filterInput.searchBox('value',"");
-                }
-                if (searchInput) {
-                    searchInput.searchBox('value',"");
-                }
-                if (tab.id === 'install') {
-                    if (searchInput) {
-                        searchInput.focus();
-                    }
-                } else {
-                    if (filterInput) {
-                        filterInput.focus();
-                    }
-                }
-            },
-            minimumActiveTabWidth: 110
-        });
-
-
-        var modulesTab = $('<div>',{class:"palette-editor-tab"}).appendTo(content);
-
-        editorTabs.addTab({
-            id: 'nodes',
-            label: RED._('palette.editor.tab-nodes'),
-            content: modulesTab
-        })
-
-        var filterDiv = $('<div>',{class:"palette-search"}).appendTo(modulesTab);
-        filterInput = $('<input type="text" data-i18n="[placeholder]palette.filter"></input>')
-            .appendTo(filterDiv)
-            .searchBox({
-                delay: 200,
-                change: function() {
-                    filterChange($(this).val());
-                }
-            });
-
-
-        nodeList = $('<ol>',{id:"palette-module-list", style:"position: absolute;top: 35px;bottom: 0;left: 0;right: 0px;"}).appendTo(modulesTab).editableList({
-            addButton: false,
-            scrollOnAdd: false,
-            sort: function(A,B) {
-                return A.info.name.localeCompare(B.info.name);
-            },
-            filter: function(data) {
-                if (activeFilter === "" ) {
-                    return true;
-                }
-
-                return (activeFilter==="")||(data.index.indexOf(activeFilter) > -1);
-            },
-            addItem: function(container,i,object) {
-                var entry = object.info;
-                if (entry) {
-                    var headerRow = $('<div>',{class:"palette-module-header"}).appendTo(container);
-                    var titleRow = $('<div class="palette-module-meta palette-module-name"><i class="fa fa-cube"></i></div>').appendTo(headerRow);
-                    $('<span>').html(entry.name).appendTo(titleRow);
-                    var metaRow = $('<div class="palette-module-meta palette-module-version"><i class="fa fa-tag"></i></div>').appendTo(headerRow);
-                    var versionSpan = $('<span>').html(entry.version).appendTo(metaRow);
-                    var buttonRow = $('<div>',{class:"palette-module-meta"}).appendTo(headerRow);
-                    var setButton = $('<a href="#" class="editor-button editor-button-small palette-module-set-button"><i class="fa fa-angle-right palette-module-node-chevron"></i> </a>').appendTo(buttonRow);
-                    var setCount = $('<span>').appendTo(setButton);
-                    var buttonGroup = $('<div>',{class:"palette-module-button-group"}).appendTo(buttonRow);
-
-                    var updateButton = $('<a href="#" class="editor-button editor-button-small"></a>').html(RED._('palette.editor.update')).appendTo(buttonGroup);
-                    updateButton.attr('id','up_'+Math.floor(Math.random()*1000000000));
-                    updateButton.click(function(evt) {
-                        evt.preventDefault();
-                        if ($(this).hasClass('disabled')) {
-                            return;
-                        }
-                        $("#palette-module-install-confirm").data('module',entry.name);
-                        $("#palette-module-install-confirm").data('version',loadedIndex[entry.name].version);
-                        $("#palette-module-install-confirm").data('shade',shade);
-
-                        $("#palette-module-install-confirm-body").html(entry.local?
-                            RED._("palette.editor.confirm.update.body"):
-                            RED._("palette.editor.confirm.cannotUpdate.body")
-                        );
-                        $(".palette-module-install-confirm-button-install").hide();
-                        $(".palette-module-install-confirm-button-remove").hide();
-                        if (entry.local) {
-                            $(".palette-module-install-confirm-button-update").show();
-                        } else {
-                            $(".palette-module-install-confirm-button-update").hide();
-                        }
-                        $("#palette-module-install-confirm")
-                            .dialog('option', 'title',RED._("palette.editor.confirm.update.title"))
-                            .dialog('open');
-                    })
-
-
-                    var removeButton = $('<a href="#" class="editor-button editor-button-small"></a>').html(RED._('palette.editor.remove')).appendTo(buttonGroup);
-                    removeButton.attr('id','up_'+Math.floor(Math.random()*1000000000));
-                    removeButton.click(function(evt) {
-                        evt.preventDefault();
-
-                        $("#palette-module-install-confirm").data('module',entry.name);
-                        $("#palette-module-install-confirm").data('shade',shade);
-                        $("#palette-module-install-confirm-body").html(RED._("palette.editor.confirm.remove.body"));
-                        $(".palette-module-install-confirm-button-install").hide();
-                        $(".palette-module-install-confirm-button-remove").show();
-                        $(".palette-module-install-confirm-button-update").hide();
-                        $("#palette-module-install-confirm")
-                            .dialog('option', 'title', RED._("palette.editor.confirm.remove.title"))
-                            .dialog('open');
-                    })
-                    if (!entry.local) {
-                        removeButton.hide();
-                    }
-                    var enableButton = $('<a href="#" class="editor-button editor-button-small"></a>').html(RED._('palette.editor.disableall')).appendTo(buttonGroup);
-
-                    var contentRow = $('<div>',{class:"palette-module-content"}).appendTo(container);
-                    var shade = $('<div class="palette-module-shade hide"><img src="red/images/spin.svg" class="palette-spinner"/></div>').appendTo(container);
-
-                    object.elements = {
-                        updateButton: updateButton,
-                        removeButton: removeButton,
-                        enableButton: enableButton,
-                        setCount: setCount,
-                        container: container,
-                        shade: shade,
-                        versionSpan: versionSpan,
-                        sets: {}
-                    }
-                    setButton.click(function(evt) {
-                        evt.preventDefault();
-                        if (container.hasClass('expanded')) {
-                            container.removeClass('expanded');
-                            contentRow.slideUp();
-                        } else {
-                            container.addClass('expanded');
-                            contentRow.slideDown();
-                        }
-                    })
-
-                    var setList = Object.keys(entry.sets)
-                    setList.sort(function(A,B) {
-                        return A.toLowerCase().localeCompare(B.toLowerCase());
-                    });
-                    setList.forEach(function(setName) {
-                        var set = entry.sets[setName];
-                        var setRow = $('<div>',{class:"palette-module-set"}).appendTo(contentRow);
-                        var buttonGroup = $('<div>',{class:"palette-module-set-button-group"}).appendTo(setRow);
-                        var typeSwatches = {};
-                        set.types.forEach(function(t) {
-                            var typeDiv = $('<div>',{class:"palette-module-type"}).appendTo(setRow);
-                            typeSwatches[t] = $('<span>',{class:"palette-module-type-swatch"}).appendTo(typeDiv);
-                            $('<span>',{class:"palette-module-type-node"}).html(t).appendTo(typeDiv);
-                        })
-
-                        var enableButton = $('<a href="#" class="editor-button editor-button-small"></a>').appendTo(buttonGroup);
-                        enableButton.click(function(evt) {
-                            evt.preventDefault();
-                            if (object.setUseCount[setName] === 0) {
-                                var currentSet = RED.nodes.registry.getNodeSet(set.id);
-                                shade.show();
-                                var newState = !currentSet.enabled
-                                changeNodeState(set.id,newState,shade,function(xhr){
-                                    if (xhr) {
-                                        if (xhr.responseJSON) {
-                                            RED.notify(RED._('palette.editor.errors.'+(newState?'enable':'disable')+'Failed',{module: id,message:xhr.responseJSON.message}));
-                                        }
-                                    }
-                                });
-                            }
-                        })
-
-                        object.elements.sets[set.name] = {
-                            setRow: setRow,
-                            enableButton: enableButton,
-                            swatches: typeSwatches
-                        };
-                    });
-                    enableButton.click(function(evt) {
-                        evt.preventDefault();
-                        if (object.totalUseCount === 0) {
-                            changeNodeState(entry.name,(container.hasClass('disabled')),shade,function(xhr){
-                                if (xhr) {
-                                    if (xhr.responseJSON) {
-                                        RED.notify(RED._('palette.editor.errors.installFailed',{module: id,message:xhr.responseJSON.message}));
-                                    }
-                                }
-                            });
-                        }
-                    })
-                    refreshNodeModule(entry.name);
-                } else {
-                    $('<div>',{class:"red-ui-search-empty"}).html(RED._('search.empty')).appendTo(container);
-                }
-            }
-        });
-
-
-
-        var installTab = $('<div>',{class:"palette-editor-tab hide"}).appendTo(content);
-
-        editorTabs.addTab({
-            id: 'install',
-            label: RED._('palette.editor.tab-install'),
-            content: installTab
-        })
-
-        var toolBar = $('<div>',{class:"palette-editor-toolbar"}).appendTo(installTab);
-
-        var searchDiv = $('<div>',{class:"palette-search"}).appendTo(installTab);
-        searchInput = $('<input type="text" data-i18n="[placeholder]palette.search"></input>')
-            .appendTo(searchDiv)
-            .searchBox({
-                delay: 300,
-                change: function() {
-                    var searchTerm = $(this).val().trim().toLowerCase();
-                    if (searchTerm.length > 0) {
-                        filteredList = loadedList.filter(function(m) {
-                            return (m.index.indexOf(searchTerm) > -1);
-                        }).map(function(f) { return {info:f}});
-                        refreshFilteredItems();
-                        searchInput.searchBox('count',filteredList.length+" / "+loadedList.length);
-                    } else {
-                        searchInput.searchBox('count',loadedList.length);
-                        packageList.editableList('empty');
-                        packageList.editableList('addItem',{count:loadedList.length});
-
-                    }
-                }
-            });
-
-
-        $('<span>').html(RED._("palette.editor.sort")+' ').appendTo(toolBar);
-        var sortGroup = $('<span class="button-group"></span>').appendTo(toolBar);
-        var sortAZ = $('<a href="#" class="sidebar-header-button-toggle selected" data-i18n="palette.editor.sortAZ"></a>').appendTo(sortGroup);
-        var sortRecent = $('<a href="#" class="sidebar-header-button-toggle" data-i18n="palette.editor.sortRecent"></a>').appendTo(sortGroup);
-
-        sortAZ.click(function(e) {
-            e.preventDefault();
-            if ($(this).hasClass("selected")) {
-                return;
-            }
-            $(this).addClass("selected");
-            sortRecent.removeClass("selected");
-            activeSort = sortModulesAZ;
-            refreshFilteredItems();
-        });
-
-        sortRecent.click(function(e) {
-            e.preventDefault();
-            if ($(this).hasClass("selected")) {
-                return;
-            }
-            $(this).addClass("selected");
-            sortAZ.removeClass("selected");
-            activeSort = sortModulesRecent;
-            refreshFilteredItems();
-        });
-
-
-        var refreshSpan = $('<span>').appendTo(toolBar);
-        var refreshButton = $('<a href="#" class="sidebar-header-button"><i class="fa fa-refresh"></i></a>').appendTo(refreshSpan);
-        refreshButton.click(function(e) {
-            e.preventDefault();
-            loadedList = [];
-            loadedIndex = {};
-            initInstallTab();
-        })
-
-        packageList = $('<ol>',{style:"position: absolute;top: 78px;bottom: 0;left: 0;right: 0px;"}).appendTo(installTab).editableList({
-            addButton: false,
-            scrollOnAdd: false,
-            addItem: function(container,i,object) {
-                if (object.count) {
-                    $('<div>',{class:"red-ui-search-empty"}).html(RED._('palette.editor.moduleCount',{count:object.count})).appendTo(container);
-                    return
-                }
-                if (object.more) {
-                    container.addClass('palette-module-more');
-                    var moreRow = $('<div>',{class:"palette-module-header palette-module"}).appendTo(container);
-                    var moreLink = $('<a href="#"></a>').html(RED._('palette.editor.more',{count:object.more})).appendTo(moreRow);
-                    moreLink.click(function(e) {
-                        e.preventDefault();
-                        packageList.editableList('removeItem',object);
-                        for (var i=object.start;i<Math.min(object.start+10,object.start+object.more);i++) {
-                            packageList.editableList('addItem',filteredList[i]);
-                        }
-                        if (object.more > 10) {
-                            packageList.editableList('addItem',{start:object.start+10, more:object.more-10})
-                        }
-                    })
-                    return;
-                }
-                if (object.info) {
-                    var entry = object.info;
-                    var headerRow = $('<div>',{class:"palette-module-header"}).appendTo(container);
-                    var titleRow = $('<div class="palette-module-meta"><i class="fa fa-cube"></i></div>').appendTo(headerRow);
-                    $('<span>',{class:"palette-module-name"}).html(entry.name||entry.id).appendTo(titleRow);
-                    $('<a target="_blank" class="palette-module-link"><i class="fa fa-external-link"></i></a>').attr('href',entry.url).appendTo(titleRow);
-                    var descRow = $('<div class="palette-module-meta"></div>').appendTo(headerRow);
-                    $('<div>',{class:"palette-module-description"}).html(entry.description).appendTo(descRow);
-
-                    var metaRow = $('<div class="palette-module-meta"></div>').appendTo(headerRow);
-                    $('<span class="palette-module-version"><i class="fa fa-tag"></i> '+entry.version+'</span>').appendTo(metaRow);
-                    $('<span class="palette-module-updated"><i class="fa fa-calendar"></i> '+formatUpdatedAt(entry.updated_at)+'</span>').appendTo(metaRow);
-                    var buttonRow = $('<div>',{class:"palette-module-meta"}).appendTo(headerRow);
-                    var buttonGroup = $('<div>',{class:"palette-module-button-group"}).appendTo(buttonRow);
-                    var shade = $('<div class="palette-module-shade hide"><img src="red/images/spin.svg" class="palette-spinner"/></div>').appendTo(container);
-                    var installButton = $('<a href="#" class="editor-button editor-button-small"></a>').html(RED._('palette.editor.install')).appendTo(buttonGroup);
-                    installButton.click(function(e) {
-                        e.preventDefault();
-                        if (!$(this).hasClass('disabled')) {
-                            $("#palette-module-install-confirm").data('module',entry.id);
-                            $("#palette-module-install-confirm").data('version',entry.version);
-                            $("#palette-module-install-confirm").data('url',entry.url);
-                            $("#palette-module-install-confirm").data('shade',shade);
-                            $("#palette-module-install-confirm-body").html(RED._("palette.editor.confirm.install.body"));
-                            $(".palette-module-install-confirm-button-install").show();
-                            $(".palette-module-install-confirm-button-remove").hide();
-                            $(".palette-module-install-confirm-button-update").hide();
-                            $("#palette-module-install-confirm")
-                                .dialog('option', 'title', RED._("palette.editor.confirm.install.title"))
-                                .dialog('open');
-                        }
-                    })
-                    if (nodeEntries.hasOwnProperty(entry.id)) {
-                        installButton.addClass('disabled');
-                        installButton.html(RED._('palette.editor.installed'));
-                    }
-
-                    object.elements = {
-                        installButton:installButton
-                    }
-                } else {
-                    $('<div>',{class:"red-ui-search-empty"}).html(RED._('search.empty')).appendTo(container);
-                }
-            }
-        });
-
-        $('<div id="palette-module-install-shade" class="palette-module-shade hide"><div class="palette-module-shade-status"></div><img src="red/images/spin.svg" class="palette-spinner"/></div>').appendTo(installTab);
-
-        $('<div id="palette-module-install-confirm" class="hide"><form class="form-horizontal"><div id="palette-module-install-confirm-body" class="node-dialog-confirm-row"></div></form></div>').appendTo(document.body);
-        $("#palette-module-install-confirm").dialog({
-            title: RED._('palette.editor.confirm.title'),
-            modal: true,
-            autoOpen: false,
-            width: 550,
-            height: "auto",
-            buttons: [
-                {
-                    text: RED._("common.label.cancel"),
-                    click: function() {
-                        $( this ).dialog( "close" );
-                    }
-                },
-                {
-                    text: RED._("palette.editor.confirm.button.review"),
-                    class: "primary palette-module-install-confirm-button-install",
-                    click: function() {
-                        var url = $(this).data('url');
-                        window.open(url);
-                    }
-                },
-                {
-                    text: RED._("palette.editor.confirm.button.install"),
-                    class: "primary palette-module-install-confirm-button-install",
-                    click: function() {
-                        var id = $(this).data('module');
-                        var version = $(this).data('version');
-                        var shade = $(this).data('shade');
-                        installNodeModule(id,version,shade,function(xhr) {
-                             if (xhr) {
-                                 if (xhr.responseJSON) {
-                                     RED.notify(RED._('palette.editor.errors.installFailed',{module: id,message:xhr.responseJSON.message}));
-                                 }
-                             }
-                        });
-                        $( this ).dialog( "close" );
-                    }
-                },
-                {
-                    text: RED._("palette.editor.confirm.button.remove"),
-                    class: "primary palette-module-install-confirm-button-remove",
-                    click: function() {
-                        var id = $(this).data('module');
-                        var shade = $(this).data('shade');
-                        shade.show();
-                        removeNodeModule(id, function(xhr) {
-                            shade.hide();
-                            if (xhr) {
-                                if (xhr.responseJSON) {
-                                    RED.notify(RED._('palette.editor.errors.removeFailed',{module: id,message:xhr.responseJSON.message}));
-                                }
-                            }
-                        })
-
-                        $( this ).dialog( "close" );
-                    }
-                },
-                {
-                    text: RED._("palette.editor.confirm.button.update"),
-                    class: "primary palette-module-install-confirm-button-update",
-                    click: function() {
-                        var id = $(this).data('module');
-                        var version = $(this).data('version');
-                        var shade = $(this).data('shade');
-                        shade.show();
-                        installNodeModule(id,version,shade,function(xhr) {
-                             if (xhr) {
-                                 if (xhr.responseJSON) {
-                                     RED.notify(RED._('palette.editor.errors.updateFailed',{module: id,message:xhr.responseJSON.message}));
-                                 }
-                             }
-                        });
-                        $( this ).dialog( "close" );
-                    }
-                }
-            ]
-        })
-    }
-
-    return {
-        init: init
-    }
-})();

editor/js/ui/palette.js

@@ -1,479 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-RED.palette = (function() {
-
-    var exclusion = ['config','unknown','deprecated'];
-    var coreCategories = ['subflows', 'input', 'output', 'function', 'social', 'mobile', 'storage', 'analysis', 'advanced'];
-
-    var categoryContainers = {};
-
-    function createCategoryContainer(category, label){
-        label = (label || category).replace(/_/g, " ");
-        var catDiv = $('<div id="palette-container-'+category+'" class="palette-category palette-close hide">'+
-            '<div id="palette-header-'+category+'" class="palette-header"><i class="expanded fa fa-angle-down"></i><span>'+label+'</span></div>'+
-            '<div class="palette-content" id="palette-base-category-'+category+'">'+
-            '<div id="palette-'+category+'-input"></div>'+
-            '<div id="palette-'+category+'-output"></div>'+
-            '<div id="palette-'+category+'-function"></div>'+
-            '</div>'+
-            '</div>').appendTo("#palette-container");
-
-        categoryContainers[category] = {
-            container: catDiv,
-            close: function() {
-                catDiv.removeClass("palette-open");
-                catDiv.addClass("palette-closed");
-                $("#palette-base-category-"+category).slideUp();
-                $("#palette-header-"+category+" i").removeClass("expanded");
-            },
-            open: function() {
-                catDiv.addClass("palette-open");
-                catDiv.removeClass("palette-closed");
-                $("#palette-base-category-"+category).slideDown();
-                $("#palette-header-"+category+" i").addClass("expanded");
-            },
-            toggle: function() {
-                if (catDiv.hasClass("palette-open")) {
-                    categoryContainers[category].close();
-                } else {
-                    categoryContainers[category].open();
-                }
-            }
-        };
-
-        $("#palette-header-"+category).on('click', function(e) {
-            categoryContainers[category].toggle();
-        });
-    }
-
-    function setLabel(type, el,label, info) {
-        var nodeWidth = 82;
-        var nodeHeight = 25;
-        var lineHeight = 20;
-        var portHeight = 10;
-
-        var words = label.split(/[ -]/);
-
-        var displayLines = [];
-
-        var currentLine = words[0];
-        var currentLineWidth = RED.view.calculateTextWidth(currentLine, "palette_label", 0);
-
-        for (var i=1;i<words.length;i++) {
-            var newWidth = RED.view.calculateTextWidth(currentLine+" "+words[i], "palette_label", 0);
-            if (newWidth < nodeWidth) {
-                currentLine += " "+words[i];
-                currentLineWidth = newWidth;
-            } else {
-                displayLines.push(currentLine);
-                currentLine = words[i];
-                currentLineWidth = RED.view.calculateTextWidth(currentLine, "palette_label", 0);
-            }
-        }
-        displayLines.push(currentLine);
-
-        var lines = displayLines.join("<br/>");
-        var multiLineNodeHeight = 8+(lineHeight*displayLines.length);
-        el.css({height:multiLineNodeHeight+"px"});
-
-        var labelElement = el.find(".palette_label");
-        labelElement.html(lines).attr('dir', RED.text.bidi.resolveBaseTextDir(lines));
-
-        el.find(".palette_port").css({top:(multiLineNodeHeight/2-5)+"px"});
-
-        var popOverContent;
-        try {
-            var l = "<p><b>"+RED.text.bidi.enforceTextDirectionWithUCC(label)+"</b></p>";
-            if (label != type) {
-                l = "<p><b>"+RED.text.bidi.enforceTextDirectionWithUCC(label)+"</b><br/><i>"+type+"</i></p>";
-            }
-            popOverContent = $(l+(info?info:$("script[data-help-name='"+type+"']").html()||"<p>"+RED._("palette.noInfo")+"</p>").trim())
-                                .filter(function(n) {
-                                    return (this.nodeType == 1 && this.nodeName == "P") || (this.nodeType == 3 && this.textContent.trim().length > 0)
-                                }).slice(0,2);
-        } catch(err) {
-            // Malformed HTML may cause errors. TODO: need to understand what can break
-            // NON-NLS: internal debug
-            console.log("Error generating pop-over label for ",type);
-            console.log(err.toString());
-            popOverContent = "<p><b>"+label+"</b></p><p>"+RED._("palette.noInfo")+"</p>";
-        }
-
-        el.data('popover').setContent(popOverContent);
-    }
-
-    function escapeNodeType(nt) {
-        return nt.replace(" ","_").replace(".","_").replace(":","_");
-    }
-
-    function addNodeType(nt,def) {
-        var nodeTypeId = escapeNodeType(nt);
-        if ($("#palette_node_"+nodeTypeId).length) {
-            return;
-        }
-        if (exclusion.indexOf(def.category)===-1) {
-
-            var category = def.category.replace(/ /g,"_");
-            var rootCategory = category.split("-")[0];
-
-            var d = document.createElement("div");
-            d.id = "palette_node_"+nodeTypeId;
-            d.type = nt;
-
-            var label = /^(.*?)([ -]in|[ -]out)?$/.exec(nt)[1];
-            if (typeof def.paletteLabel !== "undefined") {
-                try {
-                    label = (typeof def.paletteLabel === "function" ? def.paletteLabel.call(def) : def.paletteLabel)||"";
-                } catch(err) {
-                    console.log("Definition error: "+nt+".paletteLabel",err);
-                }
-            }
-
-            $('<div/>',{class:"palette_label"+(def.align=="right"?" palette_label_right":"")}).appendTo(d);
-
-            d.className="palette_node";
-
-
-            if (def.icon) {
-                var icon_url = RED.utils.getNodeIcon(def);
-                var iconContainer = $('<div/>',{class:"palette_icon_container"+(def.align=="right"?" palette_icon_container_right":"")}).appendTo(d);
-                $('<div/>',{class:"palette_icon",style:"background-image: url("+icon_url+")"}).appendTo(iconContainer);
-            }
-
-            d.style.backgroundColor = def.color;
-
-            if (def.outputs > 0) {
-                var portOut = document.createElement("div");
-                portOut.className = "palette_port palette_port_output";
-                d.appendChild(portOut);
-            }
-
-            if (def.inputs > 0) {
-                var portIn = document.createElement("div");
-                portIn.className = "palette_port palette_port_input";
-                d.appendChild(portIn);
-            }
-
-            if ($("#palette-base-category-"+rootCategory).length === 0) {
-                if(coreCategories.indexOf(rootCategory) !== -1){
-                    createCategoryContainer(rootCategory, RED._("node-red:palette.label."+rootCategory, {defaultValue:rootCategory}));
-                } else {
-                    var ns = def.set.id;
-                    createCategoryContainer(rootCategory, RED._(ns+":palette.label."+rootCategory, {defaultValue:rootCategory}));
-                }
-            }
-            $("#palette-container-"+rootCategory).show();
-
-            if ($("#palette-"+category).length === 0) {
-                $("#palette-base-category-"+rootCategory).append('<div id="palette-'+category+'"></div>');
-            }
-
-            $("#palette-"+category).append(d);
-            d.onmousedown = function(e) { e.preventDefault(); };
-
-            var popover = RED.popover.create({
-                target:$(d),
-                trigger: "hover",
-                width: "300px",
-                content: "hi",
-                delay: { show: 750, hide: 50 }
-            });
-            $(d).data('popover',popover);
-
-            // $(d).popover({
-            //     title:d.type,
-            //     placement:"right",
-            //     trigger: "hover",
-            //     delay: { show: 750, hide: 50 },
-            //     html: true,
-            //     container:'body'
-            // });
-            $(d).click(function() {
-                RED.view.focus();
-                var helpText;
-                if (nt.indexOf("subflow:") === 0) {
-                    helpText = marked(RED.nodes.subflow(nt.substring(8)).info||"");
-                } else {
-                    helpText = $("script[data-help-name='"+d.type+"']").html()||"";
-                }
-                RED.sidebar.info.set(helpText);
-            });
-            var chart = $("#chart");
-            var chartOffset = chart.offset();
-            var chartSVG = $("#chart>svg").get(0);
-            var activeSpliceLink;
-            var mouseX;
-            var mouseY;
-            var spliceTimer;
-            $(d).draggable({
-                helper: 'clone',
-                appendTo: 'body',
-                revert: true,
-                revertDuration: 50,
-                containment:'#main-container',
-                start: function() {RED.view.focus();},
-                stop: function() { d3.select('.link_splice').classed('link_splice',false); if (spliceTimer) { clearTimeout(spliceTimer); spliceTimer = null;}},
-                drag: function(e,ui) {
-
-                    // TODO: this is the margin-left of palette node. Hard coding
-                    // it here makes me sad
-                    //console.log(ui.helper.position());
-                    ui.position.left += 17.5;
-
-                    if (def.inputs > 0 && def.outputs > 0) {
-                        mouseX = ui.position.left+(ui.helper.width()/2) - chartOffset.left + chart.scrollLeft();
-                        mouseY = ui.position.top+(ui.helper.height()/2) - chartOffset.top + chart.scrollTop();
-
-                        if (!spliceTimer) {
-                            spliceTimer = setTimeout(function() {
-                                var nodes = [];
-                                var bestDistance = Infinity;
-                                var bestLink = null;
-                                if (chartSVG.getIntersectionList) {
-                                    var svgRect = chartSVG.createSVGRect();
-                                    svgRect.x = mouseX;
-                                    svgRect.y = mouseY;
-                                    svgRect.width = 1;
-                                    svgRect.height = 1;
-                                    nodes = chartSVG.getIntersectionList(svgRect,chartSVG);
-                                    mouseX /= RED.view.scale();
-                                    mouseY /= RED.view.scale();
-                                } else {
-                                    // Firefox doesn't do getIntersectionList and that
-                                    // makes us sad
-                                    mouseX /= RED.view.scale();
-                                    mouseY /= RED.view.scale();
-                                    nodes = RED.view.getLinksAtPoint(mouseX,mouseY);
-                                }
-                                for (var i=0;i<nodes.length;i++) {
-                                    if (d3.select(nodes[i]).classed('link_background')) {
-                                        var length = nodes[i].getTotalLength();
-                                        for (var j=0;j<length;j+=10) {
-                                            var p = nodes[i].getPointAtLength(j);
-                                            var d2 = ((p.x-mouseX)*(p.x-mouseX))+((p.y-mouseY)*(p.y-mouseY));
-                                            if (d2 < 200 && d2 < bestDistance) {
-                                                bestDistance = d2;
-                                                bestLink = nodes[i];
-                                            }
-                                        }
-                                    }
-                                }
-                                if (activeSpliceLink && activeSpliceLink !== bestLink) {
-                                    d3.select(activeSpliceLink.parentNode).classed('link_splice',false);
-                                }
-                                if (bestLink) {
-                                    d3.select(bestLink.parentNode).classed('link_splice',true)
-                                } else {
-                                    d3.select('.link_splice').classed('link_splice',false);
-                                }
-                                if (activeSpliceLink !== bestLink) {
-                                    if (bestLink) {
-                                        $(ui.helper).data('splice',d3.select(bestLink).data()[0]);
-                                    } else {
-                                        $(ui.helper).removeData('splice');
-                                    }
-                                }
-                                activeSpliceLink = bestLink;
-                                spliceTimer = null;
-                            },200);
-                        }
-                    }
-                }
-            });
-
-            var nodeInfo = null;
-            if (def.category == "subflows") {
-                $(d).dblclick(function(e) {
-                    RED.workspaces.show(nt.substring(8));
-                    e.preventDefault();
-                });
-                nodeInfo = marked(def.info||"");
-            }
-            setLabel(nt,$(d),label,nodeInfo);
-
-            var categoryNode = $("#palette-container-"+category);
-            if (categoryNode.find(".palette_node").length === 1) {
-                categoryContainers[category].open();
-            }
-
-        }
-    }
-
-    function removeNodeType(nt) {
-        var nodeTypeId = escapeNodeType(nt);
-        var paletteNode = $("#palette_node_"+nodeTypeId);
-        var categoryNode = paletteNode.closest(".palette-category");
-        paletteNode.remove();
-        if (categoryNode.find(".palette_node").length === 0) {
-            if (categoryNode.find("i").hasClass("expanded")) {
-                categoryNode.find(".palette-content").slideToggle();
-                categoryNode.find("i").toggleClass("expanded");
-            }
-        }
-    }
-    function hideNodeType(nt) {
-        var nodeTypeId = escapeNodeType(nt);
-        $("#palette_node_"+nodeTypeId).hide();
-    }
-
-    function showNodeType(nt) {
-        var nodeTypeId = escapeNodeType(nt);
-        $("#palette_node_"+nodeTypeId).show();
-    }
-
-    function refreshNodeTypes() {
-        RED.nodes.eachSubflow(function(sf) {
-            var paletteNode = $("#palette_node_subflow_"+sf.id.replace(".","_"));
-            var portInput = paletteNode.find(".palette_port_input");
-            var portOutput = paletteNode.find(".palette_port_output");
-
-            if (portInput.length === 0 && sf.in.length > 0) {
-                var portIn = document.createElement("div");
-                portIn.className = "palette_port palette_port_input";
-                paletteNode.append(portIn);
-            } else if (portInput.length !== 0 && sf.in.length === 0) {
-                portInput.remove();
-            }
-
-            if (portOutput.length === 0 && sf.out.length > 0) {
-                var portOut = document.createElement("div");
-                portOut.className = "palette_port palette_port_output";
-                paletteNode.append(portOut);
-            } else if (portOutput.length !== 0 && sf.out.length === 0) {
-                portOutput.remove();
-            }
-            setLabel(sf.type+":"+sf.id,paletteNode,sf.name,marked(sf.info||""));
-        });
-    }
-
-    function filterChange(val) {
-        var re = new RegExp(val.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'),'i');
-        $("#palette-container .palette_node").each(function(i,el) {
-            var currentLabel = $(el).find(".palette_label").text();
-            if (val === "" || re.test(el.id) || re.test(currentLabel)) {
-                $(this).show();
-            } else {
-                $(this).hide();
-            }
-        });
-
-        for (var category in categoryContainers) {
-            if (categoryContainers.hasOwnProperty(category)) {
-                if (categoryContainers[category].container
-                        .find(".palette_node")
-                        .filter(function() { return $(this).css('display') !== 'none'}).length === 0) {
-                    categoryContainers[category].close();
-                } else {
-                    categoryContainers[category].open();
-                }
-            }
-        }
-    }
-
-    function init() {
-
-        RED.events.on('registry:node-type-added', function(nodeType) {
-            var def = RED.nodes.getType(nodeType);
-            addNodeType(nodeType,def);
-            if (def.onpaletteadd && typeof def.onpaletteadd === "function") {
-                def.onpaletteadd.call(def);
-            }
-        });
-        RED.events.on('registry:node-type-removed', function(nodeType) {
-            removeNodeType(nodeType);
-        });
-
-        RED.events.on('registry:node-set-enabled', function(nodeSet) {
-            for (var j=0;j<nodeSet.types.length;j++) {
-                showNodeType(nodeSet.types[j]);
-                var def = RED.nodes.getType(nodeSet.types[j]);
-                if (def.onpaletteadd && typeof def.onpaletteadd === "function") {
-                    def.onpaletteadd.call(def);
-                }
-            }
-        });
-        RED.events.on('registry:node-set-disabled', function(nodeSet) {
-            for (var j=0;j<nodeSet.types.length;j++) {
-                hideNodeType(nodeSet.types[j]);
-                var def = RED.nodes.getType(nodeSet.types[j]);
-                if (def.onpaletteremove && typeof def.onpaletteremove === "function") {
-                    def.onpaletteremove.call(def);
-                }
-            }
-        });
-        RED.events.on('registry:node-set-removed', function(nodeSet) {
-            if (nodeSet.added) {
-                for (var j=0;j<nodeSet.types.length;j++) {
-                    removeNodeType(nodeSet.types[j]);
-                    var def = RED.nodes.getType(nodeSet.types[j]);
-                    if (def.onpaletteremove && typeof def.onpaletteremove === "function") {
-                        def.onpaletteremove.call(def);
-                    }
-                }
-            }
-        });
-
-
-        $("#palette > .palette-spinner").show();
-
-        $("#palette-search input").searchBox({
-            delay: 100,
-            change: function() {
-                filterChange($(this).val());
-            }
-        })
-
-        var categoryList = coreCategories;
-        if (RED.settings.paletteCategories) {
-            categoryList = RED.settings.paletteCategories;
-        } else if (RED.settings.theme('palette.categories')) {
-            categoryList = RED.settings.theme('palette.categories');
-        }
-        if (!Array.isArray(categoryList)) {
-            categoryList = coreCategories
-        }
-        categoryList.forEach(function(category){
-            createCategoryContainer(category, RED._("palette.label."+category,{defaultValue:category}));
-        });
-
-        $("#palette-collapse-all").on("click", function(e) {
-            e.preventDefault();
-            for (var cat in categoryContainers) {
-                if (categoryContainers.hasOwnProperty(cat)) {
-                    categoryContainers[cat].close();
-                }
-            }
-        });
-        $("#palette-expand-all").on("click", function(e) {
-            e.preventDefault();
-            for (var cat in categoryContainers) {
-                if (categoryContainers.hasOwnProperty(cat)) {
-                    categoryContainers[cat].open();
-                }
-            }
-        });
-    }
-
-    return {
-        init: init,
-        add:addNodeType,
-        remove:removeNodeType,
-        hide:hideNodeType,
-        show:showNodeType,
-        refresh:refreshNodeTypes
-    };
-})();

editor/js/ui/search.js

@@ -1,286 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.search = (function() {
-
-    var disabled = false;
-    var dialog = null;
-    var searchInput;
-    var searchResults;
-    var selected = -1;
-    var visible = false;
-
-    var index = {};
-    var keys = [];
-    var results = [];
-
-    function indexNode(n) {
-        var l = RED.utils.getNodeLabel(n);
-        if (l) {
-            l = (""+l).toLowerCase();
-            index[l] = index[l] || {};
-            index[l][n.id] = {node:n,label:l}
-        }
-        l = l||n.label||n.name||n.id||"";
-
-
-        var properties = ['id','type','name','label','info'];
-        if (n._def && n._def.defaults) {
-            properties = properties.concat(Object.keys(n._def.defaults));
-        }
-        for (var i=0;i<properties.length;i++) {
-            if (n.hasOwnProperty(properties[i])) {
-                var v = n[properties[i]];
-                if (typeof v === 'string' || typeof v === 'number') {
-                    v = (""+v).toLowerCase();
-                    index[v] = index[v] || {};
-                    index[v][n.id] = {node:n,label:l};
-                }
-            }
-        }
-
-
-    }
-    function indexWorkspace() {
-        index = {};
-        RED.nodes.eachWorkspace(indexNode);
-        RED.nodes.eachSubflow(indexNode);
-        RED.nodes.eachConfig(indexNode);
-        RED.nodes.eachNode(indexNode);
-        keys = Object.keys(index);
-        keys.sort();
-        keys.forEach(function(key) {
-            index[key] = Object.keys(index[key]).map(function(id) {
-                return index[key][id];
-            })
-        })
-    }
-
-    function search(val) {
-        searchResults.editableList('empty');
-        selected = -1;
-        results = [];
-        if (val.length > 0) {
-            val = val.toLowerCase();
-            var i;
-            var j;
-            var list = [];
-            var nodes = {};
-            for (i=0;i<keys.length;i++) {
-                var key = keys[i];
-                var kpos = keys[i].indexOf(val);
-                if (kpos > -1) {
-                    for (j=0;j<index[key].length;j++) {
-                        var node = index[key][j];
-                        nodes[node.node.id] = nodes[node.node.id] = node;
-                        nodes[node.node.id].index = Math.min(nodes[node.node.id].index||Infinity,kpos);
-                    }
-                }
-            }
-            list = Object.keys(nodes);
-            list.sort(function(A,B) {
-                return nodes[A].index - nodes[B].index;
-            });
-
-            for (i=0;i<list.length;i++) {
-                results.push(nodes[list[i]]);
-            }
-            if (results.length > 0) {
-                for (i=0;i<Math.min(results.length,25);i++) {
-                    searchResults.editableList('addItem',results[i])
-                }
-            } else {
-                searchResults.editableList('addItem',{});
-            }
-        }
-    }
-    function ensureSelectedIsVisible() {
-        var selectedEntry = searchResults.find("li.selected");
-        if (selectedEntry.length === 1) {
-            var scrollWindow = searchResults.parent();
-            var scrollHeight = scrollWindow.height();
-            var scrollOffset = scrollWindow.scrollTop();
-            var y = selectedEntry.position().top;
-            var h = selectedEntry.height();
-            if (y+h > scrollHeight) {
-                scrollWindow.animate({scrollTop: '-='+(scrollHeight-(y+h)-10)},50);
-            } else if (y<0) {
-                scrollWindow.animate({scrollTop: '+='+(y-10)},50);
-            }
-        }
-    }
-
-    function createDialog() {
-        dialog = $("<div>",{id:"red-ui-search",class:"red-ui-search"}).appendTo("#main-container");
-        var searchDiv = $("<div>",{class:"red-ui-search-container"}).appendTo(dialog);
-        searchInput = $('<input type="text" data-i18n="[placeholder]menu.label.searchInput">').appendTo(searchDiv).searchBox({
-            delay: 200,
-            change: function() {
-                search($(this).val());
-            }
-        });
-        searchInput.on('keydown',function(evt) {
-            var children;
-            if (results.length > 0) {
-                if (evt.keyCode === 40) {
-                    // Down
-                    children = searchResults.children();
-                    if (selected < children.length-1) {
-                        if (selected > -1) {
-                            $(children[selected]).removeClass('selected');
-                        }
-                        selected++;
-                    }
-                    $(children[selected]).addClass('selected');
-                    ensureSelectedIsVisible();
-                    evt.preventDefault();
-                } else if (evt.keyCode === 38) {
-                    // Up
-                    children = searchResults.children();
-                    if (selected > 0) {
-                        if (selected < children.length) {
-                            $(children[selected]).removeClass('selected');
-                        }
-                        selected--;
-                    }
-                    $(children[selected]).addClass('selected');
-                    ensureSelectedIsVisible();
-                    evt.preventDefault();
-                } else if (evt.keyCode === 13) {
-                    // Enter
-                    if (results.length > 0) {
-                        reveal(results[Math.max(0,selected)].node);
-                    }
-                }
-            }
-        });
-        searchInput.i18n();
-
-        var searchResultsDiv = $("<div>",{class:"red-ui-search-results-container"}).appendTo(dialog);
-        searchResults = $('<ol>',{id:"search-result-list", style:"position: absolute;top: 5px;bottom: 5px;left: 5px;right: 5px;"}).appendTo(searchResultsDiv).editableList({
-            addButton: false,
-            addItem: function(container,i,object) {
-                var node = object.node;
-                if (node === undefined) {
-                    $('<div>',{class:"red-ui-search-empty"}).html(RED._('search.empty')).appendTo(container);
-
-                } else {
-                    var def = node._def;
-                    var div = $('<a>',{href:'#',class:"red-ui-search-result"}).appendTo(container);
-
-                    var nodeDiv = $('<div>',{class:"red-ui-search-result-node"}).appendTo(div);
-                    var colour = def.color;
-                    var icon_url = RED.utils.getNodeIcon(def,node);
-                    if (node.type === 'tab') {
-                        colour = "#C0DEED";
-                    }
-                    nodeDiv.css('backgroundColor',colour);
-
-                    var iconContainer = $('<div/>',{class:"palette_icon_container"}).appendTo(nodeDiv);
-                    $('<div/>',{class:"palette_icon",style:"background-image: url("+icon_url+")"}).appendTo(iconContainer);
-
-                    var contentDiv = $('<div>',{class:"red-ui-search-result-description"}).appendTo(div);
-                    if (node.z) {
-                        var workspace = RED.nodes.workspace(node.z);
-                        if (!workspace) {
-                            workspace = RED.nodes.subflow(node.z);
-                            workspace = "subflow:"+workspace.name;
-                        } else {
-                            workspace = "flow:"+workspace.label;
-                        }
-                        $('<div>',{class:"red-ui-search-result-node-flow"}).html(workspace).appendTo(contentDiv);
-                    }
-
-                    $('<div>',{class:"red-ui-search-result-node-label"}).html(object.label || node.id).appendTo(contentDiv);
-                    $('<div>',{class:"red-ui-search-result-node-type"}).html(node.type).appendTo(contentDiv);
-                    $('<div>',{class:"red-ui-search-result-node-id"}).html(node.id).appendTo(contentDiv);
-
-                    div.click(function(evt) {
-                        evt.preventDefault();
-                        reveal(node);
-                    });
-                }
-            },
-            scrollOnAdd: false
-        });
-
-    }
-    function reveal(node) {
-        hide();
-        RED.view.reveal(node.id);
-    }
-
-    function show() {
-        if (disabled) {
-            return;
-        }
-        if (!visible) {
-            RED.keyboard.add("*","escape",function(){hide()});
-            $("#header-shade").show();
-            $("#editor-shade").show();
-            $("#palette-shade").show();
-            $("#sidebar-shade").show();
-            $("#sidebar-separator").hide();
-            indexWorkspace();
-            if (dialog === null) {
-                createDialog();
-            }
-            dialog.slideDown(300);
-            RED.events.emit("search:open");
-            visible = true;
-        }
-        searchInput.focus();
-    }
-    function hide() {
-        if (visible) {
-            RED.keyboard.remove("escape");
-            visible = false;
-            $("#header-shade").hide();
-            $("#editor-shade").hide();
-            $("#palette-shade").hide();
-            $("#sidebar-shade").hide();
-            $("#sidebar-separator").show();
-            if (dialog !== null) {
-                dialog.slideUp(200,function() {
-                    searchInput.searchBox('value','');
-                });
-            }
-            RED.events.emit("search:close");
-        }
-    }
-
-    function init() {
-        RED.actions.add("core:search",show);
-
-        RED.events.on("editor:open",function() { disabled = true; });
-        RED.events.on("editor:close",function() { disabled = false; });
-        RED.events.on("type-search:open",function() { disabled = true; });
-        RED.events.on("type-search:close",function() { disabled = false; });
-
-
-
-        $("#header-shade").on('mousedown',hide);
-        $("#editor-shade").on('mousedown',hide);
-        $("#palette-shade").on('mousedown',hide);
-        $("#sidebar-shade").on('mousedown',hide);
-    }
-
-    return {
-        init: init,
-        show: show,
-        hide: hide
-    };
-
-})();

editor/js/ui/sidebar.js

@@ -1,228 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.sidebar = (function() {
-
-    //$('#sidebar').tabs();
-    var sidebar_tabs = RED.tabs.create({
-        id:"sidebar-tabs",
-        onchange:function(tab) {
-            $("#sidebar-content").children().hide();
-            $("#sidebar-footer").children().hide();
-            if (tab.onchange) {
-                tab.onchange.call(tab);
-            }
-            $(tab.wrapper).show();
-            if (tab.toolbar) {
-                $(tab.toolbar).show();
-            }
-        },
-        onremove: function(tab) {
-            $(tab.wrapper).hide();
-            if (tab.onremove) {
-                tab.onremove.call(tab);
-            }
-        },
-        minimumActiveTabWidth: 110
-    });
-
-    var knownTabs = {
-
-    };
-
-    function addTab(title,content,closeable,visible) {
-        var options;
-        if (typeof title === "string") {
-            // TODO: legacy support in case anyone uses this...
-            options = {
-                id: content.id,
-                label: title,
-                name: title,
-                content: content,
-                closeable: closeable,
-                visible: visible
-            }
-        } else if (typeof title === "object") {
-            options = title;
-        }
-
-        options.wrapper = $('<div>',{style:"height:100%"}).appendTo("#sidebar-content")
-        options.wrapper.append(options.content);
-        options.wrapper.hide();
-
-        if (!options.enableOnEdit) {
-            options.shade = $('<div>',{class:"sidebar-shade hide"}).appendTo(options.wrapper);
-        }
-
-        if (options.toolbar) {
-            $("#sidebar-footer").append(options.toolbar);
-            $(options.toolbar).hide();
-        }
-        var id = options.id;
-
-        RED.menu.addItem("menu-item-view-menu",{
-            id:"menu-item-view-menu-"+options.id,
-            label:options.name,
-            onselect:function() {
-                showSidebar(options.id);
-            },
-            group: "sidebar-tabs"
-        });
-
-        knownTabs[options.id] = options;
-
-        if (options.visible !== false) {
-            sidebar_tabs.addTab(knownTabs[options.id]);
-        }
-    }
-
-    function removeTab(id) {
-        sidebar_tabs.removeTab(id);
-        $(knownTabs[id].wrapper).remove();
-        if (knownTabs[id].footer) {
-            knownTabs[id].footer.remove();
-        }
-        delete knownTabs[id];
-        RED.menu.removeItem("menu-item-view-menu-"+id);
-    }
-
-    var sidebarSeparator =  {};
-    $("#sidebar-separator").draggable({
-            axis: "x",
-            start:function(event,ui) {
-                sidebarSeparator.closing = false;
-                sidebarSeparator.opening = false;
-                var winWidth = $(window).width();
-                sidebarSeparator.start = ui.position.left;
-                sidebarSeparator.chartWidth = $("#workspace").width();
-                sidebarSeparator.chartRight = winWidth-$("#workspace").width()-$("#workspace").offset().left-2;
-
-                if (!RED.menu.isSelected("menu-item-sidebar")) {
-                    sidebarSeparator.opening = true;
-                    var newChartRight = 7;
-                    $("#sidebar").addClass("closing");
-                    $("#workspace").css("right",newChartRight);
-                    $("#editor-stack").css("right",newChartRight+1);
-                    $("#sidebar").width(0);
-                    RED.menu.setSelected("menu-item-sidebar",true);
-                    RED.events.emit("sidebar:resize");
-                }
-                sidebarSeparator.width = $("#sidebar").width();
-            },
-            drag: function(event,ui) {
-                var d = ui.position.left-sidebarSeparator.start;
-                var newSidebarWidth = sidebarSeparator.width-d;
-                if (sidebarSeparator.opening) {
-                    newSidebarWidth -= 3;
-                }
-
-                if (newSidebarWidth > 150) {
-                    if (sidebarSeparator.chartWidth+d < 200) {
-                        ui.position.left = 200+sidebarSeparator.start-sidebarSeparator.chartWidth;
-                        d = ui.position.left-sidebarSeparator.start;
-                        newSidebarWidth = sidebarSeparator.width-d;
-                    }
-                }
-
-                if (newSidebarWidth < 150) {
-                    if (!sidebarSeparator.closing) {
-                        $("#sidebar").addClass("closing");
-                        sidebarSeparator.closing = true;
-                    }
-                    if (!sidebarSeparator.opening) {
-                        newSidebarWidth = 150;
-                        ui.position.left = sidebarSeparator.width-(150 - sidebarSeparator.start);
-                        d = ui.position.left-sidebarSeparator.start;
-                    }
-                } else if (newSidebarWidth > 150 && (sidebarSeparator.closing || sidebarSeparator.opening)) {
-                    sidebarSeparator.closing = false;
-                    $("#sidebar").removeClass("closing");
-                }
-
-                var newChartRight = sidebarSeparator.chartRight-d;
-                $("#workspace").css("right",newChartRight);
-                $("#editor-stack").css("right",newChartRight+1);
-                $("#sidebar").width(newSidebarWidth);
-
-                sidebar_tabs.resize();
-                RED.events.emit("sidebar:resize");
-            },
-            stop:function(event,ui) {
-                if (sidebarSeparator.closing) {
-                    $("#sidebar").removeClass("closing");
-                    RED.menu.setSelected("menu-item-sidebar",false);
-                    if ($("#sidebar").width() < 180) {
-                        $("#sidebar").width(180);
-                        $("#workspace").css("right",187);
-                        $("#editor-stack").css("right",188);
-                    }
-                }
-                $("#sidebar-separator").css("left","auto");
-                $("#sidebar-separator").css("right",($("#sidebar").width()+2)+"px");
-                RED.events.emit("sidebar:resize");
-            }
-    });
-
-    function toggleSidebar(state) {
-        if (!state) {
-            $("#main-container").addClass("sidebar-closed");
-        } else {
-            $("#main-container").removeClass("sidebar-closed");
-            sidebar_tabs.resize();
-        }
-        RED.events.emit("sidebar:resize");
-    }
-
-    function showSidebar(id) {
-        if (id) {
-            if (!containsTab(id)) {
-                sidebar_tabs.addTab(knownTabs[id]);
-            }
-            sidebar_tabs.activateTab(id);
-            if (!RED.menu.isSelected("menu-item-sidebar")) {
-                RED.menu.setSelected("menu-item-sidebar",true);
-            }
-        }
-    }
-
-    function containsTab(id) {
-        return sidebar_tabs.contains(id);
-    }
-
-    function init () {
-        RED.actions.add("core:toggle-sidebar",function(state){
-            if (state === undefined) {
-                RED.menu.toggleSelected("menu-item-sidebar");
-            } else {
-                toggleSidebar(state);
-            }
-        });
-        showSidebar();
-        RED.sidebar.info.init();
-        RED.sidebar.config.init();
-        // hide info bar at start if screen rather narrow...
-        if ($(window).width() < 600) { RED.menu.setSelected("menu-item-sidebar",false); }
-    }
-
-    return {
-        init: init,
-        addTab: addTab,
-        removeTab: removeTab,
-        show: showSidebar,
-        containsTab: containsTab,
-        toggleSidebar: toggleSidebar,
-    }
-
-})();

editor/js/ui/subflow.js

@@ -1,631 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-RED.subflow = (function() {
-
-
-    function getSubflow() {
-        return RED.nodes.subflow(RED.workspaces.active());
-    }
-
-    function findAvailableSubflowIOPosition(subflow,isInput) {
-        var pos = {x:50,y:30};
-        if (!isInput) {
-            pos.x += 110;
-        }
-        for (var i=0;i<subflow.out.length+subflow.in.length;i++) {
-            var port;
-            if (i < subflow.out.length) {
-                port = subflow.out[i];
-            } else {
-                port = subflow.in[i-subflow.out.length];
-            }
-            if (port.x == pos.x && port.y == pos.y) {
-                pos.x += 55;
-                i=0;
-            }
-        }
-        return pos;
-    }
-
-    function addSubflowInput() {
-        var subflow = RED.nodes.subflow(RED.workspaces.active());
-        if (subflow.in.length === 1) {
-            return;
-        }
-        var position = findAvailableSubflowIOPosition(subflow,true);
-        var newInput = {
-            type:"subflow",
-            direction:"in",
-            z:subflow.id,
-            i:subflow.in.length,
-            x:position.x,
-            y:position.y,
-            id:RED.nodes.id()
-        };
-        var oldInCount = subflow.in.length;
-        subflow.in.push(newInput);
-        subflow.dirty = true;
-        var wasDirty = RED.nodes.dirty();
-        var wasChanged = subflow.changed;
-        subflow.changed = true;
-        var result = refresh(true);
-        var historyEvent = {
-            t:'edit',
-            node:subflow,
-            dirty:wasDirty,
-            changed:wasChanged,
-            subflow: {
-                inputCount: oldInCount,
-                instances: result.instances
-            }
-        };
-        RED.history.push(historyEvent);
-        RED.view.select();
-        RED.nodes.dirty(true);
-        RED.view.redraw();
-        $("#workspace-subflow-input-add").addClass("active");
-        $("#workspace-subflow-input-remove").removeClass("active");
-    }
-
-    function removeSubflowInput() {
-        var activeSubflow = RED.nodes.subflow(RED.workspaces.active());
-        if (activeSubflow.in.length === 0) {
-            return;
-        }
-        var removedInput = activeSubflow.in[0];
-        var removedInputLinks = [];
-        RED.nodes.eachLink(function(l) {
-            if (l.source.type == "subflow" && l.source.z == activeSubflow.id && l.source.i == removedInput.i) {
-                removedInputLinks.push(l);
-            } else if (l.target.type == "subflow:"+activeSubflow.id) {
-                removedInputLinks.push(l);
-            }
-        });
-        removedInputLinks.forEach(function(l) { RED.nodes.removeLink(l)});
-        activeSubflow.in = [];
-        $("#workspace-subflow-input-add").removeClass("active");
-        $("#workspace-subflow-input-remove").addClass("active");
-        activeSubflow.changed = true;
-        return {subflowInputs: [ removedInput ], links:removedInputLinks};
-    }
-
-    function addSubflowOutput(id) {
-        var subflow = RED.nodes.subflow(RED.workspaces.active());
-        var position = findAvailableSubflowIOPosition(subflow,false);
-
-        var newOutput = {
-            type:"subflow",
-            direction:"out",
-            z:subflow.id,
-            i:subflow.out.length,
-            x:position.x,
-            y:position.y,
-            id:RED.nodes.id()
-        };
-        var oldOutCount = subflow.out.length;
-        subflow.out.push(newOutput);
-        subflow.dirty = true;
-        var wasDirty = RED.nodes.dirty();
-        var wasChanged = subflow.changed;
-        subflow.changed = true;
-
-        var result = refresh(true);
-
-        var historyEvent = {
-            t:'edit',
-            node:subflow,
-            dirty:wasDirty,
-            changed:wasChanged,
-            subflow: {
-                outputCount: oldOutCount,
-                instances: result.instances
-            }
-        };
-        RED.history.push(historyEvent);
-        RED.view.select();
-        RED.nodes.dirty(true);
-        RED.view.redraw();
-        $("#workspace-subflow-output .spinner-value").html(subflow.out.length);
-    }
-
-    function removeSubflowOutput(removedSubflowOutputs) {
-        var activeSubflow = RED.nodes.subflow(RED.workspaces.active());
-        if (activeSubflow.out.length === 0) {
-            return;
-        }
-        if (typeof removedSubflowOutputs === "undefined") {
-            removedSubflowOutputs = [activeSubflow.out[activeSubflow.out.length-1]];
-        }
-        var removedLinks = [];
-        removedSubflowOutputs.sort(function(a,b) { return b.i-a.i});
-        for (i=0;i<removedSubflowOutputs.length;i++) {
-            var output = removedSubflowOutputs[i];
-            activeSubflow.out.splice(output.i,1);
-            var subflowRemovedLinks = [];
-            var subflowMovedLinks = [];
-            RED.nodes.eachLink(function(l) {
-                if (l.target.type == "subflow" && l.target.z == activeSubflow.id && l.target.i == output.i) {
-                    subflowRemovedLinks.push(l);
-                }
-                if (l.source.type == "subflow:"+activeSubflow.id) {
-                    if (l.sourcePort == output.i) {
-                        subflowRemovedLinks.push(l);
-                    } else if (l.sourcePort > output.i) {
-                        subflowMovedLinks.push(l);
-                    }
-                }
-            });
-            subflowRemovedLinks.forEach(function(l) { RED.nodes.removeLink(l)});
-            subflowMovedLinks.forEach(function(l) { l.sourcePort--; });
-
-            removedLinks = removedLinks.concat(subflowRemovedLinks);
-            for (var j=output.i;j<activeSubflow.out.length;j++) {
-                activeSubflow.out[j].i--;
-                activeSubflow.out[j].dirty = true;
-            }
-        }
-        activeSubflow.changed = true;
-
-        return {subflowOutputs: removedSubflowOutputs, links: removedLinks}
-    }
-
-    function refresh(markChange) {
-        var activeSubflow = RED.nodes.subflow(RED.workspaces.active());
-        refreshToolbar(activeSubflow);
-        var subflowInstances = [];
-        if (activeSubflow) {
-            RED.nodes.filterNodes({type:"subflow:"+activeSubflow.id}).forEach(function(n) {
-                subflowInstances.push({
-                    id: n.id,
-                    changed: n.changed
-                });
-                if (markChange) {
-                    n.changed = true;
-                }
-                n.inputs = activeSubflow.in.length;
-                n.outputs = activeSubflow.out.length;
-                while (n.outputs < n.ports.length) {
-                    n.ports.pop();
-                }
-                n.resize = true;
-                n.dirty = true;
-                RED.editor.updateNodeProperties(n);
-            });
-            RED.editor.validateNode(activeSubflow);
-            return {
-                instances: subflowInstances
-            }
-        }
-    }
-    function refreshToolbar(activeSubflow) {
-        if (activeSubflow) {
-            $("#workspace-subflow-input-add").toggleClass("active", activeSubflow.in.length !== 0);
-            $("#workspace-subflow-input-remove").toggleClass("active",activeSubflow.in.length === 0);
-
-            $("#workspace-subflow-output .spinner-value").html(activeSubflow.out.length);
-        }
-    }
-
-    function showWorkspaceToolbar(activeSubflow) {
-        var toolbar = $("#workspace-toolbar");
-        toolbar.empty();
-
-        $('<a class="button" id="workspace-subflow-edit" href="#" data-i18n="[append]subflow.editSubflowProperties"><i class="fa fa-pencil"></i> </a>').appendTo(toolbar);
-        $('<span style="margin-left: 5px;" data-i18n="subflow.input"></span> '+
-            '<div style="display: inline-block;" class="button-group">'+
-            '<a id="workspace-subflow-input-remove" class="button active" href="#">0</a>'+
-            '<a id="workspace-subflow-input-add" class="button" href="#">1</a>'+
-            '</div>').appendTo(toolbar);
-
-        $('<span style="margin-left: 5px;" data-i18n="subflow.output"></span> <div id="workspace-subflow-output" style="display: inline-block;" class="button-group spinner-group">'+
-            '<a id="workspace-subflow-output-remove" class="button" href="#"><i class="fa fa-minus"></i></a>'+
-            '<div class="spinner-value">3</div>'+
-            '<a id="workspace-subflow-output-add" class="button" href="#"><i class="fa fa-plus"></i></a>'+
-            '</div>').appendTo(toolbar);
-
-        // $('<a class="button disabled" id="workspace-subflow-add-input" href="#" data-i18n="[append]subflow.input"><i class="fa fa-plus"></i> </a>').appendTo(toolbar);
-        // $('<a class="button" id="workspace-subflow-add-output" href="#" data-i18n="[append]subflow.output"><i class="fa fa-plus"></i> </a>').appendTo(toolbar);
-        $('<a class="button" id="workspace-subflow-delete" href="#" data-i18n="[append]subflow.deleteSubflow"><i class="fa fa-trash"></i> </a>').appendTo(toolbar);
-        toolbar.i18n();
-
-
-        $("#workspace-subflow-output-remove").click(function(event) {
-            event.preventDefault();
-            var wasDirty = RED.nodes.dirty();
-            var wasChanged = activeSubflow.changed;
-            var result = removeSubflowOutput();
-            if (result) {
-                var inst = refresh(true);
-                RED.history.push({
-                    t:'delete',
-                    links:result.links,
-                    subflowOutputs: result.subflowOutputs,
-                    changed: wasChanged,
-                    dirty:wasDirty,
-                    subflow: {
-                        instances: inst.instances
-                    }
-                });
-
-                RED.view.select();
-                RED.nodes.dirty(true);
-                RED.view.redraw(true);
-            }
-        });
-        $("#workspace-subflow-output-add").click(function(event) {
-            event.preventDefault();
-            addSubflowOutput();
-        });
-
-        $("#workspace-subflow-input-add").click(function(event) {
-            event.preventDefault();
-            addSubflowInput();
-        });
-        $("#workspace-subflow-input-remove").click(function(event) {
-            event.preventDefault();
-            var wasDirty = RED.nodes.dirty();
-            var wasChanged = activeSubflow.changed;
-            activeSubflow.changed = true;
-            var result = removeSubflowInput();
-            if (result) {
-                var inst = refresh(true);
-                RED.history.push({
-                    t:'delete',
-                    links:result.links,
-                    changed: wasChanged,
-                    subflowInputs: result.subflowInputs,
-                    dirty:wasDirty,
-                    subflow: {
-                        instances: inst.instances
-                    }
-                });
-                RED.view.select();
-                RED.nodes.dirty(true);
-                RED.view.redraw(true);
-            }
-        });
-
-        $("#workspace-subflow-edit").click(function(event) {
-            RED.editor.editSubflow(RED.nodes.subflow(RED.workspaces.active()));
-            event.preventDefault();
-        });
-
-        $("#workspace-subflow-delete").click(function(event) {
-            event.preventDefault();
-            var startDirty = RED.nodes.dirty();
-            var historyEvent = removeSubflow(RED.workspaces.active());
-            historyEvent.t = 'delete';
-            historyEvent.dirty = startDirty;
-
-            RED.history.push(historyEvent);
-
-        });
-
-        refreshToolbar(activeSubflow);
-
-        $("#chart").css({"margin-top": "40px"});
-        $("#workspace-toolbar").show();
-    }
-    function hideWorkspaceToolbar() {
-        $("#workspace-toolbar").hide().empty();
-        $("#chart").css({"margin-top": "0"});
-    }
-
-    function removeSubflow(id) {
-        var removedNodes = [];
-        var removedLinks = [];
-
-        var activeSubflow = RED.nodes.subflow(id);
-
-        RED.nodes.eachNode(function(n) {
-            if (n.type == "subflow:"+activeSubflow.id) {
-                removedNodes.push(n);
-            }
-            if (n.z == activeSubflow.id) {
-                removedNodes.push(n);
-            }
-        });
-        RED.nodes.eachConfig(function(n) {
-            if (n.z == activeSubflow.id) {
-                removedNodes.push(n);
-            }
-        });
-
-        var removedConfigNodes = [];
-        for (var i=0;i<removedNodes.length;i++) {
-            var removedEntities = RED.nodes.remove(removedNodes[i].id);
-            removedLinks = removedLinks.concat(removedEntities.links);
-            removedConfigNodes = removedConfigNodes.concat(removedEntities.nodes);
-        }
-        // TODO: this whole delete logic should be in RED.nodes.removeSubflow..
-        removedNodes = removedNodes.concat(removedConfigNodes);
-
-        RED.nodes.removeSubflow(activeSubflow);
-        RED.workspaces.remove(activeSubflow);
-        RED.nodes.dirty(true);
-        RED.view.redraw();
-
-        return {
-            nodes:removedNodes,
-            links:removedLinks,
-            subflow: {
-                subflow: activeSubflow
-            }
-        }
-    }
-    function init() {
-        RED.events.on("workspace:change",function(event) {
-            var activeSubflow = RED.nodes.subflow(event.workspace);
-            if (activeSubflow) {
-                showWorkspaceToolbar(activeSubflow);
-            } else {
-                hideWorkspaceToolbar();
-            }
-        });
-        RED.events.on("view:selection-changed",function(selection) {
-            if (!selection.nodes) {
-                RED.menu.setDisabled("menu-item-subflow-convert",true);
-            } else {
-                RED.menu.setDisabled("menu-item-subflow-convert",false);
-            }
-        });
-
-        RED.actions.add("core:create-subflow",createSubflow);
-        RED.actions.add("core:convert-to-subflow",convertToSubflow);
-    }
-
-    function createSubflow() {
-        var lastIndex = 0;
-        RED.nodes.eachSubflow(function(sf) {
-           var m = (new RegExp("^Subflow (\\d+)$")).exec(sf.name);
-           if (m) {
-               lastIndex = Math.max(lastIndex,m[1]);
-           }
-        });
-
-        var name = "Subflow "+(lastIndex+1);
-
-        var subflowId = RED.nodes.id();
-        var subflow = {
-            type:"subflow",
-            id:subflowId,
-            name:name,
-            info:"",
-            in: [],
-            out: []
-        };
-        RED.nodes.addSubflow(subflow);
-        RED.history.push({
-            t:'createSubflow',
-            subflow: {
-                subflow:subflow
-            },
-            dirty:RED.nodes.dirty()
-        });
-        RED.workspaces.show(subflowId);
-        RED.nodes.dirty(true);
-    }
-
-    function convertToSubflow() {
-        var selection = RED.view.selection();
-        if (!selection.nodes) {
-            RED.notify(RED._("subflow.errors.noNodesSelected"),"error");
-            return;
-        }
-        var i,n;
-        var nodes = {};
-        var new_links = [];
-        var removedLinks = [];
-
-        var candidateInputs = [];
-        var candidateOutputs = [];
-        var candidateInputNodes = {};
-
-
-        var boundingBox = [selection.nodes[0].x,
-            selection.nodes[0].y,
-            selection.nodes[0].x,
-            selection.nodes[0].y];
-
-        for (i=0;i<selection.nodes.length;i++) {
-            n = selection.nodes[i];
-            nodes[n.id] = {n:n,outputs:{}};
-            boundingBox = [
-                Math.min(boundingBox[0],n.x),
-                Math.min(boundingBox[1],n.y),
-                Math.max(boundingBox[2],n.x),
-                Math.max(boundingBox[3],n.y)
-            ]
-        }
-
-        var center = [(boundingBox[2]+boundingBox[0]) / 2,(boundingBox[3]+boundingBox[1]) / 2];
-
-        RED.nodes.eachLink(function(link) {
-            if (nodes[link.source.id] && nodes[link.target.id]) {
-                // A link wholely within the selection
-            }
-
-            if (nodes[link.source.id] && !nodes[link.target.id]) {
-                // An outbound link from the selection
-                candidateOutputs.push(link);
-                removedLinks.push(link);
-            }
-            if (!nodes[link.source.id] && nodes[link.target.id]) {
-                // An inbound link
-                candidateInputs.push(link);
-                candidateInputNodes[link.target.id] = link.target;
-                removedLinks.push(link);
-            }
-        });
-
-        var outputs = {};
-        candidateOutputs = candidateOutputs.filter(function(v) {
-             if (outputs[v.source.id+":"+v.sourcePort]) {
-                 outputs[v.source.id+":"+v.sourcePort].targets.push(v.target);
-                 return false;
-             }
-             v.targets = [];
-             v.targets.push(v.target);
-             outputs[v.source.id+":"+v.sourcePort] = v;
-             return true;
-        });
-        candidateOutputs.sort(function(a,b) { return a.source.y-b.source.y});
-
-        if (Object.keys(candidateInputNodes).length > 1) {
-             RED.notify(RED._("subflow.errors.multipleInputsToSelection"),"error");
-             return;
-        }
-
-        var lastIndex = 0;
-        RED.nodes.eachSubflow(function(sf) {
-           var m = (new RegExp("^Subflow (\\d+)$")).exec(sf.name);
-           if (m) {
-               lastIndex = Math.max(lastIndex,m[1]);
-           }
-        });
-
-        var name = "Subflow "+(lastIndex+1);
-
-        var subflowId = RED.nodes.id();
-        var subflow = {
-            type:"subflow",
-            id:subflowId,
-            name:name,
-            info:"",
-            in: Object.keys(candidateInputNodes).map(function(v,i) { var index = i; return {
-                type:"subflow",
-                direction:"in",
-                x:candidateInputNodes[v].x-(candidateInputNodes[v].w/2)-80,
-                y:candidateInputNodes[v].y,
-                z:subflowId,
-                i:index,
-                id:RED.nodes.id(),
-                wires:[{id:candidateInputNodes[v].id}]
-            }}),
-            out: candidateOutputs.map(function(v,i) { var index = i; return {
-                type:"subflow",
-                direction:"in",
-                x:v.source.x+(v.source.w/2)+80,
-                y:v.source.y,
-                z:subflowId,
-                i:index,
-                id:RED.nodes.id(),
-                wires:[{id:v.source.id,port:v.sourcePort}]
-            }})
-        };
-
-        RED.nodes.addSubflow(subflow);
-
-        var subflowInstance = {
-            id:RED.nodes.id(),
-            type:"subflow:"+subflow.id,
-            x: center[0],
-            y: center[1],
-            z: RED.workspaces.active(),
-            inputs: subflow.in.length,
-            outputs: subflow.out.length,
-            h: Math.max(30/*node_height*/,(subflow.out.length||0) * 15),
-            changed:true
-        }
-        subflowInstance._def = RED.nodes.getType(subflowInstance.type);
-        RED.editor.validateNode(subflowInstance);
-        RED.nodes.add(subflowInstance);
-
-        candidateInputs.forEach(function(l) {
-            var link = {source:l.source, sourcePort:l.sourcePort, target: subflowInstance};
-            new_links.push(link);
-            RED.nodes.addLink(link);
-        });
-
-        candidateOutputs.forEach(function(output,i) {
-            output.targets.forEach(function(target) {
-                var link = {source:subflowInstance, sourcePort:i, target: target};
-                new_links.push(link);
-                RED.nodes.addLink(link);
-            });
-        });
-
-        subflow.in.forEach(function(input) {
-            input.wires.forEach(function(wire) {
-                var link = {source: input, sourcePort: 0, target: RED.nodes.node(wire.id) }
-                new_links.push(link);
-                RED.nodes.addLink(link);
-            });
-        });
-        subflow.out.forEach(function(output,i) {
-            output.wires.forEach(function(wire) {
-                var link = {source: RED.nodes.node(wire.id), sourcePort: wire.port , target: output }
-                new_links.push(link);
-                RED.nodes.addLink(link);
-            });
-        });
-
-        for (i=0;i<removedLinks.length;i++) {
-            RED.nodes.removeLink(removedLinks[i]);
-        }
-
-        for (i=0;i<selection.nodes.length;i++) {
-            n = selection.nodes[i];
-            if (/^link /.test(n.type)) {
-                n.links = n.links.filter(function(id) {
-                    var isLocalLink = nodes.hasOwnProperty(id);
-                    if (!isLocalLink) {
-                        var otherNode = RED.nodes.node(id);
-                        if (otherNode && otherNode.links) {
-                            var i = otherNode.links.indexOf(n.id);
-                            if (i > -1) {
-                                otherNode.links.splice(i,1);
-                            }
-                        }
-                    }
-                    return isLocalLink;
-                });
-            }
-            n.z = subflow.id;
-        }
-
-        RED.history.push({
-            t:'createSubflow',
-            nodes:[subflowInstance.id],
-            links:new_links,
-            subflow: {
-                subflow: subflow
-            },
-
-            activeWorkspace: RED.workspaces.active(),
-            removedLinks: removedLinks,
-
-            dirty:RED.nodes.dirty()
-        });
-        RED.view.select(null);
-        RED.editor.validateNode(subflow);
-        RED.nodes.dirty(true);
-        RED.view.redraw(true);
-    }
-
-
-
-    return {
-        init: init,
-        createSubflow: createSubflow,
-        convertToSubflow: convertToSubflow,
-        removeSubflow: removeSubflow,
-        refresh: refresh,
-        removeInput: removeSubflowInput,
-        removeOutput: removeSubflowOutput
-    }
-})();

editor/js/ui/tab-config.js

@@ -1,315 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.sidebar.config = (function() {
-
-
-    var content = document.createElement("div");
-    content.className = "sidebar-node-config";
-
-    $('<div class="button-group sidebar-header">'+
-      '<a class="sidebar-header-button-toggle selected" id="workspace-config-node-filter-all" href="#"><span data-i18n="sidebar.config.filterAll"></span></a>'+
-      '<a class="sidebar-header-button-toggle" id="workspace-config-node-filter-unused" href="#"><span data-i18n="sidebar.config.filterUnused"></span></a> '+
-      '</div>'
-    ).appendTo(content);
-
-
-    var toolbar = $('<div>'+
-        '<a class="sidebar-footer-button" id="workspace-config-node-collapse-all" href="#"><i class="fa fa-angle-double-up"></i></a> '+
-        '<a class="sidebar-footer-button" id="workspace-config-node-expand-all" href="#"><i class="fa fa-angle-double-down"></i></a>'+
-        '</div>');
-
-    var globalCategories = $("<div>").appendTo(content);
-    var flowCategories = $("<div>").appendTo(content);
-    var subflowCategories = $("<div>").appendTo(content);
-
-    var showUnusedOnly = false;
-
-    var categories = {};
-
-    function getOrCreateCategory(name,parent,label) {
-        name = name.replace(/\./i,"-");
-        if (!categories[name]) {
-            var container = $('<div class="palette-category workspace-config-node-category" id="workspace-config-node-category-'+name+'"></div>').appendTo(parent);
-            var header = $('<div class="workspace-config-node-tray-header palette-header"><i class="fa fa-angle-down expanded"></i></div>').appendTo(container);
-            if (label) {
-                $('<span class="config-node-label"/>').text(label).appendTo(header);
-            } else {
-                $('<span class="config-node-label" data-i18n="sidebar.config.'+name+'">').appendTo(header);
-            }
-            $('<span class="config-node-filter-info"></span>').appendTo(header);
-            category = $('<ul class="palette-content config-node-list"></ul>').appendTo(container);
-            container.i18n();
-            var icon = header.find("i");
-            var result = {
-                label: label,
-                list: category,
-                size: function() {
-                    return result.list.find("li:not(.config_node_none)").length
-                },
-                open: function(snap) {
-                    if (!icon.hasClass("expanded")) {
-                        icon.addClass("expanded");
-                        if (snap) {
-                            result.list.show();
-                        } else {
-                            result.list.slideDown();
-                        }
-                    }
-                },
-                close: function(snap) {
-                    if (icon.hasClass("expanded")) {
-                        icon.removeClass("expanded");
-                        if (snap) {
-                            result.list.hide();
-                        } else {
-                            result.list.slideUp();
-                        }
-                    }
-                },
-                isOpen: function() {
-                    return icon.hasClass("expanded");
-                }
-            };
-
-            header.on('click', function(e) {
-                if (result.isOpen()) {
-                    result.close();
-                } else {
-                    result.open();
-                }
-            });
-            categories[name] = result;
-        } else {
-            if (categories[name].label !== label) {
-                categories[name].list.parent().find('.config-node-label').text(label);
-                categories[name].label = label;
-            }
-        }
-        return categories[name];
-    }
-
-    function createConfigNodeList(id,nodes) {
-        var category = getOrCreateCategory(id.replace(/\./i,"-"))
-        var list = category.list;
-
-        nodes.sort(function(A,B) {
-            if (A.type < B.type) { return -1;}
-            if (A.type > B.type) { return 1;}
-            return 0;
-        });
-        if (showUnusedOnly) {
-            var hiddenCount = nodes.length;
-            nodes = nodes.filter(function(n) {
-                return n._def.hasUsers!==false && n.users.length === 0;
-            })
-            hiddenCount = hiddenCount - nodes.length;
-            if (hiddenCount > 0) {
-                list.parent().find('.config-node-filter-info').text(RED._('sidebar.config.filtered',{count:hiddenCount})).show();
-            } else {
-                list.parent().find('.config-node-filter-info').hide();
-            }
-        } else {
-            list.parent().find('.config-node-filter-info').hide();
-        }
-        list.empty();
-        if (nodes.length === 0) {
-            $('<li class="config_node_none" data-i18n="sidebar.config.none">NONE</li>').i18n().appendTo(list);
-            category.close(true);
-        } else {
-            var currentType = "";
-            nodes.forEach(function(node) {
-                var label = RED.utils.getNodeLabel(node,node.id);
-                if (node.type != currentType) {
-                    $('<li class="config_node_type">'+node.type+'</li>').appendTo(list);
-                    currentType = node.type;
-                }
-
-                var entry = $('<li class="palette_node config_node palette_node_id_'+node.id.replace(/\./g,"-")+'"></li>').appendTo(list);
-                $('<div class="palette_label"></div>').text(label).appendTo(entry);
-                if (node._def.hasUsers !== false) {
-                    var iconContainer = $('<div/>',{class:"palette_icon_container  palette_icon_container_right"}).text(node.users.length).appendTo(entry);
-                    if (node.users.length === 0) {
-                        entry.addClass("config_node_unused");
-                    }
-                }
-                entry.on('click',function(e) {
-                    RED.sidebar.info.refresh(node);
-                });
-                entry.on('dblclick',function(e) {
-                    RED.editor.editConfig("", node.type, node.id);
-                });
-                var userArray = node.users.map(function(n) { return n.id });
-                entry.on('mouseover',function(e) {
-                    RED.nodes.eachNode(function(node) {
-                        if( userArray.indexOf(node.id) != -1) {
-                            node.highlighted = true;
-                            node.dirty = true;
-                        }
-                    });
-                    RED.view.redraw();
-                });
-
-                entry.on('mouseout',function(e) {
-                    RED.nodes.eachNode(function(node) {
-                        if(node.highlighted) {
-                            node.highlighted = false;
-                            node.dirty = true;
-                        }
-                    });
-                    RED.view.redraw();
-                });
-            });
-            category.open(true);
-        }
-    }
-
-    function refreshConfigNodeList() {
-        var validList = {"global":true};
-
-        getOrCreateCategory("global",globalCategories);
-
-        RED.nodes.eachWorkspace(function(ws) {
-            validList[ws.id.replace(/\./g,"-")] = true;
-            getOrCreateCategory(ws.id,flowCategories,ws.label);
-        })
-        RED.nodes.eachSubflow(function(sf) {
-            validList[sf.id.replace(/\./g,"-")] = true;
-            getOrCreateCategory(sf.id,subflowCategories,sf.name);
-        })
-        $(".workspace-config-node-category").each(function() {
-            var id = $(this).attr('id').substring("workspace-config-node-category-".length);
-            if (!validList[id]) {
-                $(this).remove();
-                delete categories[id];
-            }
-        })
-        var globalConfigNodes = [];
-        var configList = {};
-        RED.nodes.eachConfig(function(cn) {
-            if (cn.z) {//} == RED.workspaces.active()) {
-                configList[cn.z.replace(/\./g,"-")] = configList[cn.z.replace(/\./g,"-")]||[];
-                configList[cn.z.replace(/\./g,"-")].push(cn);
-            } else if (!cn.z) {
-                globalConfigNodes.push(cn);
-            }
-        });
-        for (var id in validList) {
-            if (validList.hasOwnProperty(id)) {
-                createConfigNodeList(id,configList[id]||[]);
-            }
-        }
-        createConfigNodeList('global',globalConfigNodes);
-    }
-
-    function init() {
-        RED.sidebar.addTab({
-            id: "config",
-            label: RED._("sidebar.config.label"),
-            name: RED._("sidebar.config.name"),
-            content: content,
-            toolbar: toolbar,
-            closeable: true,
-            visible: false,
-            onchange: function() { refreshConfigNodeList(); }
-        });
-        RED.actions.add("core:show-config-tab",function() {RED.sidebar.show('config')});
-
-        $("#workspace-config-node-collapse-all").on("click", function(e) {
-            e.preventDefault();
-            for (var cat in categories) {
-                if (categories.hasOwnProperty(cat)) {
-                    categories[cat].close();
-                }
-            }
-        });
-        $("#workspace-config-node-expand-all").on("click", function(e) {
-            e.preventDefault();
-            for (var cat in categories) {
-                if (categories.hasOwnProperty(cat)) {
-                    if (categories[cat].size() > 0) {
-                        categories[cat].open();
-                    }
-                }
-            }
-        });
-        $('#workspace-config-node-filter-all').on("click",function(e) {
-            e.preventDefault();
-            if (showUnusedOnly) {
-                $(this).addClass('selected');
-                $('#workspace-config-node-filter-unused').removeClass('selected');
-                showUnusedOnly = !showUnusedOnly;
-                refreshConfigNodeList();
-            }
-        });
-        $('#workspace-config-node-filter-unused').on("click",function(e) {
-            e.preventDefault();
-            if (!showUnusedOnly) {
-                $(this).addClass('selected');
-                $('#workspace-config-node-filter-all').removeClass('selected');
-                showUnusedOnly = !showUnusedOnly;
-                refreshConfigNodeList();
-            }
-        });
-
-
-    }
-    function show(id) {
-        if (typeof id === 'boolean') {
-            if (id) {
-                $('#workspace-config-node-filter-unused').click();
-            } else {
-                $('#workspace-config-node-filter-all').click();
-            }
-        }
-        refreshConfigNodeList();
-        if (typeof id === "string") {
-            $('#workspace-config-node-filter-all').click();
-            id = id.replace(/\./g,"-");
-            setTimeout(function() {
-                var node = $(".palette_node_id_"+id);
-                var y = node.position().top;
-                var h = node.height();
-                var scrollWindow = $(".sidebar-node-config");
-                var scrollHeight = scrollWindow.height();
-
-                if (y+h > scrollHeight) {
-                    scrollWindow.animate({scrollTop: '-='+(scrollHeight-(y+h)-30)},150);
-                } else if (y<0) {
-                    scrollWindow.animate({scrollTop: '+='+(y-10)},150);
-                }
-                var flash = 21;
-                var flashFunc = function() {
-                    if ((flash%2)===0) {
-                        node.removeClass('node_highlighted');
-                    } else {
-                        node.addClass('node_highlighted');
-                    }
-                    flash--;
-                    if (flash >= 0) {
-                        setTimeout(flashFunc,100);
-                    }
-                }
-                flashFunc();
-            },100);
-        }
-        RED.sidebar.show("config");
-    }
-    return {
-        init:init,
-        show:show,
-        refresh:refreshConfigNodeList
-    }
-})();

editor/js/ui/tab-info.js

@@ -1,394 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-RED.sidebar.info = (function() {
-
-    marked.setOptions({
-        renderer: new marked.Renderer(),
-        gfm: true,
-        tables: true,
-        breaks: false,
-        pedantic: false,
-        sanitize: true,
-        smartLists: true,
-        smartypants: false
-    });
-
-    var content;
-    var sections;
-    var nodeSection;
-    var infoSection;
-    var tipBox;
-
-    var expandedSections = {
-        "property": false
-    };
-
-    function init() {
-
-        content = document.createElement("div");
-        content.className = "sidebar-node-info"
-
-        RED.actions.add("core:show-info-tab",show);
-
-        var stackContainer = $("<div>",{class:"sidebar-node-info-stack"}).appendTo(content);
-
-        sections = RED.stack.create({
-            container: stackContainer
-        }).hide();
-
-        nodeSection = sections.add({
-            title: RED._("sidebar.info.node"),
-            collapsible: false
-        });
-        infoSection = sections.add({
-            title: RED._("sidebar.info.information"),
-            collapsible: false
-        });
-        infoSection.content.css("padding","6px");
-        infoSection.container.css("border-bottom","none");
-
-        var tipContainer = $('<div class="node-info-tips"></div>').appendTo(content);
-        tipBox = $('<div class="node-info-tip"></div>').appendTo(tipContainer);
-        var tipButtons = $('<div class="node-info-tips-buttons"></div>').appendTo(tipContainer);
-
-        var tipRefresh = $('<a href="#" class="workspace-footer-button"><i class="fa fa-refresh"></a>').appendTo(tipButtons);
-        tipRefresh.click(function(e) {
-            e.preventDefault();
-            tips.next();
-        })
-
-        var tipClose = $('<a href="#" class="workspace-footer-button"><i class="fa fa-times"></a>').appendTo(tipButtons);
-        tipClose.click(function(e) {
-            e.preventDefault();
-            RED.actions.invoke("core:toggle-show-tips");
-            RED.notify(RED._("sidebar.info.showTips"));
-        });
-
-        RED.sidebar.addTab({
-            id: "info",
-            label: RED._("sidebar.info.label"),
-            name: RED._("sidebar.info.name"),
-            content: content,
-            enableOnEdit: true
-        });
-        if (tips.enabled()) {
-            tips.start();
-        } else {
-            tips.stop();
-        }
-
-    }
-
-    function show() {
-        RED.sidebar.show("info");
-    }
-
-    function jsonFilter(key,value) {
-        if (key === "") {
-            return value;
-        }
-        var t = typeof value;
-        if ($.isArray(value)) {
-            return "[array:"+value.length+"]";
-        } else if (t === "object") {
-            return "[object]"
-        } else if (t === "string") {
-            if (value.length > 30) {
-                return value.substring(0,30)+" ...";
-            }
-        }
-        return value;
-    }
-
-    function addTargetToExternalLinks(el) {
-        $(el).find("a").each(function(el) {
-            var href = $(this).attr('href');
-            if (/^https?:/.test(href)) {
-                $(this).attr('target','_blank');
-            }
-        });
-        return el;
-    }
-    function refresh(node) {
-        sections.show();
-        $(nodeSection.content).empty();
-        $(infoSection.content).empty();
-
-        var table = $('<table class="node-info"></table>');
-        var tableBody = $('<tbody>').appendTo(table);
-        var propRow;
-        var subflowNode;
-        if (node.type === "tab") {
-            nodeSection.title.html(RED._("sidebar.info.flow"));
-            propRow = $('<tr class="node-info-node-row"><td>'+RED._("sidebar.info.tabName")+'</td><td></td></tr>').appendTo(tableBody);
-            $(propRow.children()[1]).html('&nbsp;'+(node.label||""))
-            propRow = $('<tr class="node-info-node-row"><td>'+RED._("sidebar.info.id")+"</td><td></td></tr>").appendTo(tableBody);
-            RED.utils.createObjectElement(node.id).appendTo(propRow.children()[1]);
-            propRow = $('<tr class="node-info-node-row"><td>'+RED._("sidebar.info.status")+'</td><td></td></tr>').appendTo(tableBody);
-            $(propRow.children()[1]).html((!!!node.disabled)?RED._("sidebar.info.enabled"):RED._("sidebar.info.disabled"))
-        } else {
-            nodeSection.title.html(RED._("sidebar.info.node"));
-            if (node.type !== "subflow" && node.name) {
-                $('<tr class="node-info-node-row"><td>'+RED._("common.label.name")+'</td><td>&nbsp;<span class="bidiAware" dir="'+RED.text.bidi.resolveBaseTextDir(node.name)+'">'+node.name+'</span></td></tr>').appendTo(tableBody);
-            }
-            $('<tr class="node-info-node-row"><td>'+RED._("sidebar.info.type")+"</td><td>&nbsp;"+node.type+"</td></tr>").appendTo(tableBody);
-            propRow = $('<tr class="node-info-node-row"><td>'+RED._("sidebar.info.id")+"</td><td></td></tr>").appendTo(tableBody);
-            RED.utils.createObjectElement(node.id).appendTo(propRow.children()[1]);
-
-            var m = /^subflow(:(.+))?$/.exec(node.type);
-
-            if (!m && node.type != "subflow" && node.type != "comment") {
-                if (node._def) {
-                    var count = 0;
-                    var defaults = node._def.defaults;
-                    for (var n in defaults) {
-                        if (n != "name" && defaults.hasOwnProperty(n)) {
-                            var val = node[n];
-                            var type = typeof val;
-                            count++;
-                            propRow = $('<tr class="node-info-property-row'+(expandedSections.property?"":" hide")+'"><td>'+n+"</td><td></td></tr>").appendTo(tableBody);
-                            if (defaults[n].type) {
-                                var configNode = RED.nodes.node(val);
-                                if (!configNode) {
-                                    RED.utils.createObjectElement(undefined).appendTo(propRow.children()[1]);
-                                } else {
-                                    var configLabel = RED.utils.getNodeLabel(configNode,val);
-                                    var container = propRow.children()[1];
-
-                                    var div = $('<span>',{class:""}).appendTo(container);
-                                    var nodeDiv = $('<div>',{class:"palette_node palette_node_small"}).appendTo(div);
-                                    var colour = configNode._def.color;
-                                    var icon_url = RED.utils.getNodeIcon(configNode._def);
-                                    nodeDiv.css({'backgroundColor':colour, "cursor":"pointer"});
-                                    var iconContainer = $('<div/>',{class:"palette_icon_container"}).appendTo(nodeDiv);
-                                    $('<div/>',{class:"palette_icon",style:"background-image: url("+icon_url+")"}).appendTo(iconContainer);
-                                    var nodeContainer = $('<span></span>').css({"verticalAlign":"top","marginLeft":"6px"}).html(configLabel).appendTo(container);
-
-                                    nodeDiv.on('dblclick',function() {
-                                        RED.editor.editConfig("", configNode.type, configNode.id);
-                                    })
-
-                                }
-                            } else {
-                                RED.utils.createObjectElement(val).appendTo(propRow.children()[1]);
-                            }
-                        }
-                    }
-                    if (count > 0) {
-                        $('<tr class="node-info-property-expand blank"><td colspan="2"><a href="#" class=" node-info-property-header'+(expandedSections.property?" expanded":"")+'"><span class="node-info-property-show-more">'+RED._("sidebar.info.showMore")+'</span><span class="node-info-property-show-less">'+RED._("sidebar.info.showLess")+'</span> <i class="fa fa-caret-down"></i></a></td></tr>').appendTo(tableBody);
-                    }
-                }
-            }
-
-            if (m) {
-                if (m[2]) {
-                    subflowNode = RED.nodes.subflow(m[2]);
-                } else {
-                    subflowNode = node;
-                }
-
-                $('<tr class="blank"><th colspan="2">'+RED._("sidebar.info.subflow")+'</th></tr>').appendTo(tableBody);
-
-                var userCount = 0;
-                var subflowType = "subflow:"+subflowNode.id;
-                RED.nodes.eachNode(function(n) {
-                    if (n.type === subflowType) {
-                        userCount++;
-                    }
-                });
-                $('<tr class="node-info-subflow-row"><td>'+RED._("common.label.name")+'</td><td><span class="bidiAware" dir=\"'+RED.text.bidi.resolveBaseTextDir(subflowNode.name)+'">'+subflowNode.name+'</span></td></tr>').appendTo(tableBody);
-                $('<tr class="node-info-subflow-row"><td>'+RED._("sidebar.info.instances")+"</td><td>"+userCount+'</td></tr>').appendTo(tableBody);
-            }
-        }
-        $(table).appendTo(nodeSection.content);
-
-        var infoText = "";
-
-        if (!subflowNode && node.type !== "comment" && node.type !== "tab") {
-            var helpText = $("script[data-help-name='"+node.type+"']").html()||"";
-            infoText = helpText;
-        } else if (node.type === "tab") {
-            infoText = marked(node.info||"");
-        }
-
-        if (subflowNode) {
-            infoText = infoText + marked(subflowNode.info||"");
-        } else if (node._def && node._def.info) {
-            var info = node._def.info;
-            var textInfo = (typeof info === "function" ? info.call(node) : info);
-            // TODO: help
-            infoText = infoText + marked(textInfo);
-        }
-        if (infoText) {
-            setInfoText(infoText);
-        }
-
-
-        $(".node-info-property-header").click(function(e) {
-            e.preventDefault();
-            expandedSections["property"] = !expandedSections["property"];
-            $(this).toggleClass("expanded",expandedSections["property"]);
-            $(".node-info-property-row").toggle(expandedSections["property"]);
-        });
-    }
-    function setInfoText(infoText) {
-        var info = addTargetToExternalLinks($('<div class="node-help"><span class="bidiAware" dir=\"'+RED.text.bidi.resolveBaseTextDir(infoText)+'">'+infoText+'</span></div>')).appendTo(infoSection.content);
-        info.find(".bidiAware").contents().filter(function() { return this.nodeType === 3 && this.textContent.trim() !== "" }).wrap( "<span></span>" );
-        var foldingHeader = "H3";
-        info.find(foldingHeader).wrapInner('<a class="node-info-header expanded" href="#"></a>')
-            .find("a").prepend('<i class="fa fa-angle-right">').click(function(e) {
-                e.preventDefault();
-                var isExpanded = $(this).hasClass('expanded');
-                var el = $(this).parent().next();
-                while(el.length === 1 && el[0].nodeName !== foldingHeader) {
-                    el.toggle(!isExpanded);
-                    el = el.next();
-                }
-                $(this).toggleClass('expanded',!isExpanded);
-            })
-    }
-    var tips = (function() {
-        var enabled = true;
-        var startDelay = 1000;
-        var cycleDelay = 15000;
-        var startTimeout;
-        var refreshTimeout;
-        var tipCount = -1;
-
-        RED.actions.add("core:toggle-show-tips",function(state) {
-            if (state === undefined) {
-                RED.userSettings.toggle("view-show-tips");
-            } else {
-                enabled = state;
-                if (enabled) {
-                    startTips();
-                } else {
-                    stopTips();
-                }
-            }
-        });
-
-        function setTip() {
-            var r = Math.floor(Math.random() * tipCount);
-            var tip = RED._("infotips:info.tip"+r);
-
-            var m;
-            while ((m=/({{(.*?)}})/.exec(tip))) {
-                var shortcut = RED.keyboard.getShortcut(m[2]);
-                if (shortcut) {
-                    tip = tip.replace(m[1],RED.keyboard.formatKey(shortcut.key));
-                } else {
-                    return;
-                }
-            }
-            while ((m=/(\[(.*?)\])/.exec(tip))) {
-                tip = tip.replace(m[1],RED.keyboard.formatKey(m[2]));
-            }
-            tipBox.html(tip).fadeIn(200);
-            if (startTimeout) {
-                startTimeout = null;
-                refreshTimeout = setInterval(cycleTips,cycleDelay);
-            }
-        }
-        function cycleTips() {
-            tipBox.fadeOut(300,function() {
-                setTip();
-            })
-        }
-        function startTips() {
-            $(".sidebar-node-info").addClass('show-tips');
-            if (enabled) {
-                if (!startTimeout && !refreshTimeout) {
-                    if (tipCount === -1) {
-                        do {
-                            tipCount++;
-                        } while(RED._("infotips:info.tip"+tipCount)!=="infotips:info.tip"+tipCount);
-                    }
-                    startTimeout = setTimeout(setTip,startDelay);
-                }
-            }
-        }
-        function stopTips() {
-            $(".sidebar-node-info").removeClass('show-tips');
-            clearInterval(refreshTimeout);
-            clearTimeout(startTimeout);
-            refreshTimeout = null;
-            startTimeout = null;
-        }
-        function nextTip() {
-            clearInterval(refreshTimeout);
-            startTimeout = true;
-            setTip();
-        }
-        return {
-            start: startTips,
-            stop: stopTips,
-            next: nextTip,
-            enabled: function() { return enabled; }
-        }
-    })();
-
-    function clear() {
-        sections.hide();
-        //
-    }
-
-    function set(html) {
-        // tips.stop();
-        sections.show();
-        nodeSection.container.hide();
-        $(infoSection.content).empty();
-        setInfoText(html);
-        $(".sidebar-node-info-stack").scrollTop(0);
-    }
-
-
-
-    RED.events.on("view:selection-changed",function(selection) {
-        if (selection.nodes) {
-            if (selection.nodes.length == 1) {
-                var node = selection.nodes[0];
-                if (node.type === "subflow" && node.direction) {
-                    refresh(RED.nodes.subflow(node.z));
-                } else {
-                    refresh(node);
-                }
-            }
-        } else {
-            var activeWS = RED.workspaces.active();
-
-            var flow = RED.nodes.workspace(activeWS) || RED.nodes.subflow(activeWS);
-            if (flow) {
-                refresh(flow);
-            } else {
-                var workspace = RED.nodes.workspace(RED.workspaces.active());
-                if (workspace && workspace.info) {
-                    refresh(workspace);
-                } else {
-                    clear();
-                }
-            }
-        }
-    });
-
-    return {
-        init: init,
-        show: show,
-        refresh: refresh,
-        clear: clear,
-        set: set
-    }
-})();

editor/js/ui/typeSearch.js

@@ -1,295 +0,0 @@
-RED.typeSearch = (function() {
-
-    var shade;
-
-    var disabled = false;
-    var dialog = null;
-    var searchInput;
-    var searchResults;
-    var searchResultsDiv;
-    var selected = -1;
-    var visible = false;
-
-    var activeFilter = "";
-    var addCallback;
-
-    var typesUsed = {};
-
-    function search(val) {
-        activeFilter = val.toLowerCase();
-        var visible = searchResults.editableList('filter');
-        setTimeout(function() {
-            selected = 0;
-            searchResults.children().removeClass('selected');
-            searchResults.children(":visible:first").addClass('selected');
-        },100);
-
-    }
-
-    function ensureSelectedIsVisible() {
-        var selectedEntry = searchResults.find("li.selected");
-        if (selectedEntry.length === 1) {
-            var scrollWindow = searchResults.parent();
-            var scrollHeight = scrollWindow.height();
-            var scrollOffset = scrollWindow.scrollTop();
-            var y = selectedEntry.position().top;
-            var h = selectedEntry.height();
-            if (y+h > scrollHeight) {
-                scrollWindow.animate({scrollTop: '-='+(scrollHeight-(y+h)-10)},50);
-            } else if (y<0) {
-                scrollWindow.animate({scrollTop: '+='+(y-10)},50);
-            }
-        }
-    }
-
-    function createDialog() {
-        //shade = $('<div>',{class:"red-ui-type-search-shade"}).appendTo("#main-container");
-        dialog = $("<div>",{id:"red-ui-type-search",class:"red-ui-search red-ui-type-search"}).appendTo("#main-container");
-        var searchDiv = $("<div>",{class:"red-ui-search-container"}).appendTo(dialog);
-        searchInput = $('<input type="text">').attr("placeholder",RED._("search.addNode")).appendTo(searchDiv).searchBox({
-            delay: 50,
-            change: function() {
-                search($(this).val());
-            }
-        });
-        searchInput.on('keydown',function(evt) {
-            var children = searchResults.children(":visible");
-            if (children.length > 0) {
-                if (evt.keyCode === 40) {
-                    // Down
-                    if (selected < children.length-1) {
-                        if (selected > -1) {
-                            $(children[selected]).removeClass('selected');
-                        }
-                        selected++;
-                    }
-                    $(children[selected]).addClass('selected');
-                    ensureSelectedIsVisible();
-                    evt.preventDefault();
-                } else if (evt.keyCode === 38) {
-                    // Up
-                    if (selected > 0) {
-                        if (selected < children.length) {
-                            $(children[selected]).removeClass('selected');
-                        }
-                        selected--;
-                    }
-                    $(children[selected]).addClass('selected');
-                    ensureSelectedIsVisible();
-                    evt.preventDefault();
-                } else if (evt.keyCode === 13) {
-                    // Enter
-                    var index = Math.max(0,selected);
-                    if (index < children.length) {
-                        // TODO: dips into editableList impl details
-                        confirm($(children[index]).find(".red-ui-editableList-item-content").data('data'));
-                    }
-                }
-            }
-        });
-
-        searchResultsDiv = $("<div>",{class:"red-ui-search-results-container"}).appendTo(dialog);
-        searchResults = $('<ol>',{id:"search-result-list", style:"position: absolute;top: 0;bottom: 0;left: 0;right: 0;"}).appendTo(searchResultsDiv).editableList({
-            addButton: false,
-            filter: function(data) {
-                if (activeFilter === "" ) {
-                    return true;
-                }
-                if (data.recent || data.common) {
-                    return false;
-                }
-                return (activeFilter==="")||(data.index.indexOf(activeFilter) > -1);
-            },
-            addItem: function(container,i,object) {
-                var def = object.def;
-                object.index = object.type.toLowerCase();
-                if (object.separator) {
-                    container.addClass("red-ui-search-result-separator")
-                }
-                var div = $('<a>',{href:'#',class:"red-ui-search-result"}).appendTo(container);
-
-                var nodeDiv = $('<div>',{class:"red-ui-search-result-node"}).appendTo(div);
-                var colour = def.color;
-                var icon_url = RED.utils.getNodeIcon(def);
-                nodeDiv.css('backgroundColor',colour);
-
-                var iconContainer = $('<div/>',{class:"palette_icon_container"}).appendTo(nodeDiv);
-                $('<div/>',{class:"palette_icon",style:"background-image: url("+icon_url+")"}).appendTo(iconContainer);
-
-                if (def.inputs > 0) {
-                    $('<div/>',{class:"red-ui-search-result-node-port"}).appendTo(nodeDiv);
-                }
-                if (def.outputs > 0) {
-                    $('<div/>',{class:"red-ui-search-result-node-port red-ui-search-result-node-output"}).appendTo(nodeDiv);
-                }
-
-                var contentDiv = $('<div>',{class:"red-ui-search-result-description"}).appendTo(div);
-
-                var label = object.label;
-                object.index += "|"+label.toLowerCase();
-
-                $('<div>',{class:"red-ui-search-result-node-label"}).html(label).appendTo(contentDiv);
-
-                div.click(function(evt) {
-                    evt.preventDefault();
-                    confirm(object);
-                });
-            },
-            scrollOnAdd: false
-        });
-
-    }
-    function confirm(def) {
-        hide();
-        typesUsed[def.type] = Date.now();
-        addCallback(def.type);
-    }
-
-    function handleMouseActivity(evt) {
-        if (visible) {
-            var t = $(evt.target);
-            while (t.prop('nodeName').toLowerCase() !== 'body') {
-                if (t.attr('id') === 'red-ui-type-search') {
-                    return;
-                }
-                t = t.parent();
-            }
-            hide(true);
-        }
-    }
-    function show(opts) {
-        if (!visible) {
-            RED.keyboard.add("*","escape",function(){hide()});
-            if (dialog === null) {
-                createDialog();
-            }
-            visible = true;
-            setTimeout(function() {
-                $(document).on('mousedown.type-search',handleMouseActivity);
-                $(document).on('mouseup.type-search',handleMouseActivity);
-                $(document).on('click.type-search',handleMouseActivity);
-            },200);
-        } else {
-            dialog.hide();
-            searchResultsDiv.hide();
-        }
-        refreshTypeList();
-        addCallback = opts.add;
-        RED.events.emit("type-search:open");
-        //shade.show();
-        dialog.css({left:opts.x+"px",top:opts.y+"px"}).show();
-        searchResultsDiv.slideDown(300);
-        setTimeout(function() {
-            searchResultsDiv.find(".red-ui-editableList-container").scrollTop(0);
-            searchInput.focus();
-        },100);
-    }
-    function hide(fast) {
-        if (visible) {
-            RED.keyboard.remove("escape");
-            visible = false;
-            if (dialog !== null) {
-                searchResultsDiv.slideUp(fast?50:200,function() {
-                    dialog.hide();
-                    searchInput.searchBox('value','');
-                });
-                //shade.hide();
-            }
-            RED.events.emit("type-search:close");
-            RED.view.focus();
-            $(document).off('mousedown.type-search');
-            $(document).off('mouseup.type-search');
-            $(document).off('click.type-search');
-        }
-    }
-
-    function getTypeLabel(type, def) {
-        var label = type;
-        if (typeof def.paletteLabel !== "undefined") {
-            try {
-                label = (typeof def.paletteLabel === "function" ? def.paletteLabel.call(def) : def.paletteLabel)||"";
-                label += " ("+type+")";
-            } catch(err) {
-                console.log("Definition error: "+type+".paletteLabel",err);
-            }
-        }
-        return label;
-    }
-
-    function refreshTypeList() {
-        var i;
-        searchResults.editableList('empty');
-        searchInput.searchBox('value','');
-        selected = -1;
-        var common = [
-            'inject','debug','function','change','switch'
-        ];
-
-        var recentlyUsed = Object.keys(typesUsed);
-        recentlyUsed.sort(function(a,b) {
-            return typesUsed[b]-typesUsed[a];
-        });
-        recentlyUsed = recentlyUsed.filter(function(t) {
-            return common.indexOf(t) === -1;
-        });
-
-        var items = [];
-        RED.nodes.registry.getNodeTypes().forEach(function(t) {
-            var def = RED.nodes.getType(t);
-            if (def.category !== 'config' && t !== 'unknown' && t !== 'tab') {
-                items.push({type:t,def: def, label:getTypeLabel(t,def)});
-            }
-        });
-        items.sort(function(a,b) {
-            var al = a.label.toLowerCase();
-            var bl = b.label.toLowerCase();
-            if (al < bl) {
-                return -1;
-            } else if (al === bl) {
-                return 0;
-            } else {
-                return 1;
-            }
-        })
-
-        var commonCount = 0;
-        var item;
-        for(i=0;i<common.length;i++) {
-            item = {
-                type: common[i],
-                common: true,
-                def: RED.nodes.getType(common[i])
-            };
-            item.label = getTypeLabel(item.type,item.def);
-            if (i === common.length-1) {
-                item.separator = true;
-            }
-            searchResults.editableList('addItem', item);
-        }
-        for(i=0;i<Math.min(5,recentlyUsed.length);i++) {
-            item = {
-                type:recentlyUsed[i],
-                def: RED.nodes.getType(recentlyUsed[i]),
-                recent: true
-            };
-            item.label = getTypeLabel(item.type,item.def);
-            if (i === recentlyUsed.length-1) {
-                item.separator = true;
-            }
-            searchResults.editableList('addItem', item);
-        }
-        for (i=0;i<items.length;i++) {
-            searchResults.editableList('addItem', items[i]);
-        }
-        setTimeout(function() {
-            selected = 0;
-            searchResults.children(":first").addClass('selected');
-        },100);
-    }
-
-    return {
-        show: show,
-        hide: hide
-    };
-
-})();

editor/js/ui/utils.js

@@ -1,741 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
-RED.utils = (function() {
-
-    function formatString(str) {
-        return str.replace(/\r?\n/g,"↵").replace(/\t/g,"→");
-    }
-    function sanitize(m) {
-        return m.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;");
-    }
-
-    function buildMessageSummaryValue(value) {
-        var result;
-        if (Array.isArray(value)) {
-            result = $('<span class="debug-message-object-value debug-message-type-meta"></span>').html('array['+value.length+']');
-        } else if (value === null) {
-            result = $('<span class="debug-message-object-value debug-message-type-null">null</span>');
-        } else if (typeof value === 'object') {
-            if (value.hasOwnProperty('type') && value.type === 'Buffer' && value.hasOwnProperty('data')) {
-                result = $('<span class="debug-message-object-value debug-message-type-meta"></span>').html('buffer['+value.length+']');
-            } else if (value.hasOwnProperty('type') && value.type === 'array' && value.hasOwnProperty('data')) {
-                result = $('<span class="debug-message-object-value debug-message-type-meta"></span>').html('array['+value.length+']');
-            } else {
-                result = $('<span class="debug-message-object-value debug-message-type-meta">object</span>');
-            }
-        } else if (typeof value === 'string') {
-            var subvalue;
-            if (value.length > 30) {
-                subvalue = sanitize(value.substring(0,30))+"&hellip;";
-            } else {
-                subvalue = sanitize(value);
-            }
-            result = $('<span class="debug-message-object-value debug-message-type-string"></span>').html('"'+formatString(subvalue)+'"');
-        } else {
-            result = $('<span class="debug-message-object-value debug-message-type-other"></span>').text(""+value);
-        }
-        return result;
-    }
-    function makeExpandable(el,onbuild,ontoggle,expand) {
-        el.addClass("debug-message-expandable");
-        el.prop('toggle',function() {
-            return function(state) {
-                var parent = el.parent();
-                if (parent.hasClass('collapsed')) {
-                    if (state) {
-                        if (onbuild && !parent.hasClass('built')) {
-                            onbuild();
-                            parent.addClass('built');
-                        }
-                        parent.removeClass('collapsed');
-                        return true;
-                    }
-                } else {
-                    if (!state) {
-                        parent.addClass('collapsed');
-                        return true;
-                    }
-                }
-                return false;
-            }
-        });
-        el.click(function(e) {
-            var parent = $(this).parent();
-            var currentState = !parent.hasClass('collapsed');
-            if ($(this).prop('toggle')(!currentState)) {
-                if (ontoggle) {
-                    ontoggle(!currentState);
-                }
-            }
-            // if (parent.hasClass('collapsed')) {
-            //     if (onbuild && !parent.hasClass('built')) {
-            //         onbuild();
-            //         parent.addClass('built');
-            //     }
-            //     if (ontoggle) {
-            //         ontoggle(true);
-            //     }
-            //     parent.removeClass('collapsed');
-            // } else {
-            //     parent.addClass('collapsed');
-            //     if (ontoggle) {
-            //         ontoggle(false);
-            //     }
-            // }
-            e.preventDefault();
-        });
-        if (expand) {
-            el.click();
-        }
-
-    }
-
-    var pinnedPaths = {};
-    var formattedPaths = {};
-
-    function addMessageControls(obj,sourceId,key,msg,rootPath,strippedKey) {
-        if (!pinnedPaths.hasOwnProperty(sourceId)) {
-            pinnedPaths[sourceId] = {}
-        }
-        var tools = $('<span class="debug-message-tools"></span>').appendTo(obj);
-        var copyTools = $('<span class="debug-message-tools-copy button-group"></span>').appendTo(tools);
-        if (!!key) {
-            var copyPath = $('<button class="editor-button editor-button-small"><i class="fa fa-terminal"></i></button>').appendTo(copyTools).click(function(e) {
-                e.preventDefault();
-                e.stopPropagation();
-                RED.clipboard.copyText(key,copyPath,"clipboard.copyMessagePath");
-            })
-        }
-        var copyPayload = $('<button class="editor-button editor-button-small"><i class="fa fa-clipboard"></i></button>').appendTo(copyTools).click(function(e) {
-            e.preventDefault();
-            e.stopPropagation();
-            RED.clipboard.copyText(msg,copyPayload,"clipboard.copyMessageValue");
-        })
-        if (strippedKey !== '') {
-            var isPinned = pinnedPaths[sourceId].hasOwnProperty(strippedKey);
-
-            var pinPath = $('<button class="editor-button editor-button-small debug-message-tools-pin"><i class="fa fa-map-pin"></i></button>').appendTo(tools).click(function(e) {
-                e.preventDefault();
-                e.stopPropagation();
-                if (pinnedPaths[sourceId].hasOwnProperty(strippedKey)) {
-                    delete pinnedPaths[sourceId][strippedKey];
-                    $(this).removeClass("selected");
-                    obj.removeClass("debug-message-row-pinned");
-                } else {
-                    var rootedPath = "$"+(strippedKey[0] === '['?"":".")+strippedKey;
-                    pinnedPaths[sourceId][strippedKey] = normalisePropertyExpression(rootedPath);
-                    $(this).addClass("selected");
-                    obj.addClass("debug-message-row-pinned");
-                }
-            }).toggleClass("selected",isPinned);
-            obj.toggleClass("debug-message-row-pinned",isPinned);
-        }
-    }
-    function checkExpanded(strippedKey,expandPaths,minRange,maxRange) {
-        if (expandPaths && expandPaths.length > 0) {
-            if (strippedKey === '' && minRange === undefined) {
-                return true;
-            }
-            for (var i=0;i<expandPaths.length;i++) {
-                var p = expandPaths[i];
-                if (p.indexOf(strippedKey) === 0 && (p[strippedKey.length] === "." ||  p[strippedKey.length] === "[") ) {
-
-                    if (minRange !== undefined && p[strippedKey.length] === "[") {
-                        var subkey = p.substring(strippedKey.length);
-                        var m = (/\[(\d+)\]/.exec(subkey));
-                        if (m) {
-                            var index = parseInt(m[1]);
-                            return minRange<=index && index<=maxRange;
-                        }
-                    } else {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-
-    function formatNumber(element,obj,sourceId,path,cycle,initialFormat) {
-        var format = (formattedPaths[sourceId] && formattedPaths[sourceId][path]) || initialFormat || "dec";
-        if (cycle) {
-            if (format === 'dec') {
-                if ((obj.toString().length===13) && (obj<=2147483647000)) {
-                    format = 'dateMS';
-                } else if ((obj.toString().length===10) && (obj<=2147483647)) {
-                    format = 'dateS';
-                } else {
-                    format = 'hex'
-                }
-            } else if (format === 'dateMS' || format == 'dateS') {
-                format = 'hex';
-            } else {
-                format = 'dec';
-            }
-            formattedPaths[sourceId] = formattedPaths[sourceId]||{};
-            formattedPaths[sourceId][path] = format;
-        } else if (initialFormat !== undefined){
-            formattedPaths[sourceId] = formattedPaths[sourceId]||{};
-            formattedPaths[sourceId][path] = format;
-        }
-        if (format === 'dec') {
-            element.text(""+obj);
-        } else if (format === 'dateMS') {
-            element.text((new Date(obj)).toISOString());
-        } else if (format === 'dateS') {
-            element.text((new Date(obj*1000)).toISOString());
-        } else if (format === 'hex') {
-            element.text("0x"+(obj).toString(16));
-        }
-    }
-
-    function formatBuffer(element,button,sourceId,path,cycle) {
-        var format = (formattedPaths[sourceId] && formattedPaths[sourceId][path]) || "raw";
-        if (cycle) {
-            if (format === 'raw') {
-                format = 'string';
-            } else {
-                format = 'raw';
-            }
-            formattedPaths[sourceId] = formattedPaths[sourceId]||{};
-            formattedPaths[sourceId][path] = format;
-        }
-        if (format === 'raw') {
-            button.text('raw');
-            element.removeClass('debug-message-buffer-string').addClass('debug-message-buffer-raw');
-        } else if (format === 'string') {
-            button.text('string');
-            element.addClass('debug-message-buffer-string').removeClass('debug-message-buffer-raw');
-        }
-    }
-
-    function buildMessageElement(obj,options) {
-        options = options || {};
-        var key = options.key;
-        var typeHint = options.typeHint;
-        var hideKey = options.hideKey;
-        var path = options.path;
-        var sourceId = options.sourceId;
-        var rootPath = options.rootPath;
-        var expandPaths = options.expandPaths;
-        var ontoggle = options.ontoggle;
-        var exposeApi = options.exposeApi;
-
-        var subElements = {};
-        var i;
-        var e;
-        var entryObj;
-        var expandableHeader;
-        var header;
-        var headerHead;
-        var value;
-        var strippedKey;
-        if (path !== undefined && rootPath !== undefined) {
-             strippedKey = path.substring(rootPath.length+(path[rootPath.length]==="."?1:0));
-        }
-        var element = $('<span class="debug-message-element"></span>');
-        element.collapse = function() {
-            element.find(".debug-message-expandable").parent().addClass("collapsed");
-        }
-        header = $('<span class="debug-message-row"></span>').appendTo(element);
-        if (sourceId) {
-            addMessageControls(header,sourceId,path,obj,rootPath,strippedKey);
-        }
-        if (!key) {
-            element.addClass("debug-message-top-level");
-            if (sourceId) {
-                var pinned = pinnedPaths[sourceId];
-                expandPaths = [];
-                if (pinned) {
-                    for (var pinnedPath in pinned) {
-                        if (pinned.hasOwnProperty(pinnedPath)) {
-                            try {
-                                var res = getMessageProperty({$:obj},pinned[pinnedPath]);
-                                if (res !== undefined) {
-                                    expandPaths.push(pinnedPath);
-                                }
-                            } catch(err) {
-                            }
-                        }
-                    }
-                    expandPaths.sort();
-                }
-                element.clearPinned = function() {
-                    element.find(".debug-message-row-pinned").removeClass("debug-message-row-pinned");
-                    pinnedPaths[sourceId] = {};
-                }
-            }
-        } else {
-            if (!hideKey) {
-                $('<span class="debug-message-object-key"></span>').text(key).appendTo(header);
-                $('<span>: </span>').appendTo(header);
-            }
-        }
-        entryObj = $('<span class="debug-message-object-value"></span>').appendTo(header);
-
-        var isArray = Array.isArray(obj);
-        var isArrayObject = false;
-        if (obj && typeof obj === 'object' && obj.hasOwnProperty('type') && obj.hasOwnProperty('data') && ((obj.__encoded__ && obj.type === 'array') || obj.type === 'Buffer')) {
-            isArray = true;
-            isArrayObject = true;
-        }
-
-        if (obj === null || obj === undefined) {
-            $('<span class="debug-message-type-null">'+obj+'</span>').appendTo(entryObj);
-        } else if (typeof obj === 'string') {
-            if (/[\t\n\r]/.test(obj)) {
-                element.addClass('collapsed');
-                $('<i class="fa fa-caret-right debug-message-object-handle"></i> ').prependTo(header);
-                makeExpandable(header, function() {
-                    $('<span class="debug-message-type-meta debug-message-object-type-header"></span>').html(typeHint||'string').appendTo(header);
-                    var row = $('<div class="debug-message-object-entry collapsed"></div>').appendTo(element);
-                    $('<pre class="debug-message-type-string"></pre>').text(obj).appendTo(row);
-                },function(state) {if (ontoggle) { ontoggle(path,state);}}, checkExpanded(strippedKey,expandPaths));
-            }
-            e = $('<span class="debug-message-type-string debug-message-object-header"></span>').html('"'+formatString(sanitize(obj))+'"').appendTo(entryObj);
-            if (/^#[0-9a-f]{6}$/i.test(obj)) {
-                $('<span class="debug-message-type-string-swatch"></span>').css('backgroundColor',obj).appendTo(e);
-            }
-
-        } else if (typeof obj === 'number') {
-            e = $('<span class="debug-message-type-number"></span>').appendTo(entryObj);
-
-            if (Number.isInteger(obj) && (obj >= 0)) { // if it's a +ve integer
-                e.addClass("debug-message-type-number-toggle");
-                e.click(function(evt) {
-                    evt.preventDefault();
-                    formatNumber($(this), obj, sourceId, path, true);
-                });
-            }
-            formatNumber(e,obj,sourceId,path,false,typeHint==='hex'?'hex':undefined);
-
-        } else if (isArray) {
-            element.addClass('collapsed');
-
-            var originalLength = obj.length;
-            if (typeHint) {
-                var m = /\[(\d+)\]/.exec(typeHint);
-                if (m) {
-                    originalLength = parseInt(m[1]);
-                }
-            }
-            var data = obj;
-            var type = 'array';
-            if (isArrayObject) {
-                data = obj.data;
-                if (originalLength === undefined) {
-                    originalLength = data.length;
-                }
-                if (data.__encoded__) {
-                    data = data.data;
-                }
-                type = obj.type.toLowerCase();
-            } else if (/buffer/.test(typeHint)) {
-                type = 'buffer';
-            }
-            var fullLength = data.length;
-
-                if (originalLength > 0) {
-                $('<i class="fa fa-caret-right debug-message-object-handle"></i> ').prependTo(header);
-                var arrayRows = $('<div class="debug-message-array-rows"></div>').appendTo(element);
-                element.addClass('debug-message-buffer-raw');
-            }
-            if (key) {
-                headerHead = $('<span class="debug-message-type-meta"></span>').html(typeHint||(type+'['+originalLength+']')).appendTo(entryObj);
-            } else {
-                headerHead = $('<span class="debug-message-object-header"></span>').appendTo(entryObj);
-                $('<span>[ </span>').appendTo(headerHead);
-                var arrayLength = Math.min(originalLength,10);
-                for (i=0;i<arrayLength;i++) {
-                    buildMessageSummaryValue(data[i]).appendTo(headerHead);
-                    if (i < arrayLength-1) {
-                        $('<span>, </span>').appendTo(headerHead);
-                    }
-                }
-                if (originalLength > arrayLength) {
-                    $('<span> &hellip;</span>').appendTo(headerHead);
-                }
-                if (arrayLength === 0) {
-                    $('<span class="debug-message-type-meta">empty</span>').appendTo(headerHead);
-                }
-                $('<span> ]</span>').appendTo(headerHead);
-            }
-            if (originalLength > 0) {
-
-                makeExpandable(header,function() {
-                    if (!key) {
-                        headerHead = $('<span class="debug-message-type-meta debug-message-object-type-header"></span>').html(typeHint||(type+'['+originalLength+']')).appendTo(header);
-                    }
-                    if (type === 'buffer') {
-                        var stringRow = $('<div class="debug-message-string-rows"></div>').appendTo(element);
-                        var sr = $('<div class="debug-message-object-entry collapsed"></div>').appendTo(stringRow);
-                        var stringEncoding = "";
-                        try {
-                            stringEncoding = String.fromCharCode.apply(null, new Uint16Array(data))
-                        } catch(err) {
-                            console.log(err);
-                        }
-                        $('<pre class="debug-message-type-string"></pre>').text(stringEncoding).appendTo(sr);
-                        var bufferOpts = $('<span class="debug-message-buffer-opts"></span>').appendTo(headerHead);
-                        var switchFormat = $('<a href="#"></a>').addClass('selected').html('raw').appendTo(bufferOpts).click(function(e) {
-                            e.preventDefault();
-                            e.stopPropagation();
-                            formatBuffer(element,$(this),sourceId,path,true);
-                        });
-                        formatBuffer(element,switchFormat,sourceId,path,false);
-
-                    }
-                    var row;
-                    if (fullLength <= 10) {
-                        for (i=0;i<fullLength;i++) {
-                            row = $('<div class="debug-message-object-entry collapsed"></div>').appendTo(arrayRows);
-                            subElements[path+"["+i+"]"] = buildMessageElement(
-                                data[i],
-                                {
-                                    key: ""+i,
-                                    typeHint: type==='buffer'?'hex':false,
-                                    hideKey: false,
-                                    path: path+"["+i+"]",
-                                    sourceId: sourceId,
-                                    rootPath: rootPath,
-                                    expandPaths: expandPaths,
-                                    ontoggle: ontoggle,
-                                    exposeApi: exposeApi
-                                }
-                            ).appendTo(row);
-                        }
-                    } else {
-                        for (i=0;i<fullLength;i+=10) {
-                            var minRange = i;
-                            row = $('<div class="debug-message-object-entry collapsed"></div>').appendTo(arrayRows);
-                            header = $('<span></span>').appendTo(row);
-                            $('<i class="fa fa-caret-right debug-message-object-handle"></i> ').appendTo(header);
-                            makeExpandable(header, (function() {
-                                var min = minRange;
-                                var max = Math.min(fullLength-1,(minRange+9));
-                                var parent = row;
-                                return function() {
-                                    for (var i=min;i<=max;i++) {
-                                        var row = $('<div class="debug-message-object-entry collapsed"></div>').appendTo(parent);
-                                        subElements[path+"["+i+"]"] = buildMessageElement(
-                                            data[i],
-                                            {
-                                                key: ""+i,
-                                                typeHint: type==='buffer'?'hex':false,
-                                                hideKey: false,
-                                                path: path+"["+i+"]",
-                                                sourceId: sourceId,
-                                                rootPath: rootPath,
-                                                expandPaths: expandPaths,
-                                                ontoggle: ontoggle,
-                                                exposeApi: exposeApi
-
-                                            }
-                                        ).appendTo(row);
-                                    }
-                                }
-                            })(),
-                            (function() { var path = path+"["+i+"]"; return function(state) {if (ontoggle) { ontoggle(path,state);}}})(),
-                            checkExpanded(strippedKey,expandPaths,minRange,Math.min(fullLength-1,(minRange+9))));
-                            $('<span class="debug-message-object-key"></span>').html("["+minRange+" &hellip; "+Math.min(fullLength-1,(minRange+9))+"]").appendTo(header);
-                        }
-                        if (fullLength < originalLength) {
-                             $('<div class="debug-message-object-entry collapsed"><span class="debug-message-object-key">['+fullLength+' &hellip; '+originalLength+']</span></div>').appendTo(arrayRows);
-                        }
-                    }
-                },
-                function(state) {if (ontoggle) { ontoggle(path,state);}},
-                checkExpanded(strippedKey,expandPaths));
-            }
-        } else if (typeof obj === 'object') {
-            element.addClass('collapsed');
-            var keys = Object.keys(obj);
-            if (key || keys.length > 0) {
-                $('<i class="fa fa-caret-right debug-message-object-handle"></i> ').prependTo(header);
-                makeExpandable(header, function() {
-                    if (!key) {
-                        $('<span class="debug-message-type-meta debug-message-object-type-header"></span>').html('object').appendTo(header);
-                    }
-                    for (i=0;i<keys.length;i++) {
-                        var row = $('<div class="debug-message-object-entry collapsed"></div>').appendTo(element);
-                        var newPath = path;
-                        if (newPath) {
-                            if (/^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(keys[i])) {
-                                newPath += (newPath.length > 0?".":"")+keys[i];
-                            } else {
-                                newPath += "[\""+keys[i].replace(/"/,"\\\"")+"\"]"
-                            }
-                        }
-                        subElements[newPath] = buildMessageElement(
-                            obj[keys[i]],
-                            {
-                                key: keys[i],
-                                typeHint: false,
-                                hideKey: false,
-                                path: newPath,
-                                sourceId: sourceId,
-                                rootPath: rootPath,
-                                expandPaths: expandPaths,
-                                ontoggle: ontoggle,
-                                exposeApi: exposeApi
-
-                            }
-                        ).appendTo(row);
-                    }
-                    if (keys.length === 0) {
-                        $('<div class="debug-message-object-entry debug-message-type-meta collapsed"></div>').text("empty").appendTo(element);
-                    }
-                },
-                function(state) {if (ontoggle) { ontoggle(path,state);}},
-                checkExpanded(strippedKey,expandPaths));
-            }
-            if (key) {
-                $('<span class="debug-message-type-meta"></span>').html('object').appendTo(entryObj);
-            } else {
-                headerHead = $('<span class="debug-message-object-header"></span>').appendTo(entryObj);
-                $('<span>{ </span>').appendTo(headerHead);
-                var keysLength = Math.min(keys.length,5);
-                for (i=0;i<keysLength;i++) {
-                    $('<span class="debug-message-object-key"></span>').text(keys[i]).appendTo(headerHead);
-                    $('<span>: </span>').appendTo(headerHead);
-                    buildMessageSummaryValue(obj[keys[i]]).appendTo(headerHead);
-                    if (i < keysLength-1) {
-                        $('<span>, </span>').appendTo(headerHead);
-                    }
-                }
-                if (keys.length > keysLength) {
-                    $('<span> &hellip;</span>').appendTo(headerHead);
-                }
-                if (keysLength === 0) {
-                    $('<span class="debug-message-type-meta">empty</span>').appendTo(headerHead);
-                }
-                $('<span> }</span>').appendTo(headerHead);
-            }
-        } else {
-            $('<span class="debug-message-type-other"></span>').text(""+obj).appendTo(entryObj);
-        }
-        if (exposeApi) {
-            element.prop('expand', function() { return function(targetPath, state) {
-                if (path === targetPath) {
-                    if (header.prop('toggle')) {
-                        header.prop('toggle')(state);
-                    }
-                } else if (subElements[targetPath] && subElements[targetPath].prop('expand') ) {
-                    subElements[targetPath].prop('expand')(targetPath,state);
-                } else {
-                    for (var p in subElements) {
-                        if (subElements.hasOwnProperty(p)) {
-                            if (targetPath.indexOf(p) === 0) {
-                                if (subElements[p].prop('expand') ) {
-                                    subElements[p].prop('expand')(targetPath,state);
-                                }
-                                break;
-                            }
-                        }
-                    }
-                }
-            }});
-        }
-        return element;
-    }
-
-    function normalisePropertyExpression(str) {
-        // This must be kept in sync with validatePropertyExpression
-        // in editor/js/ui/utils.js
-
-        var length = str.length;
-        if (length === 0) {
-            throw new Error("Invalid property expression: zero-length");
-        }
-        var parts = [];
-        var start = 0;
-        var inString = false;
-        var inBox = false;
-        var quoteChar;
-        var v;
-        for (var i=0;i<length;i++) {
-            var c = str[i];
-            if (!inString) {
-                if (c === "'" || c === '"') {
-                    if (i != start) {
-                        throw new Error("Invalid property expression: unexpected "+c+" at position "+i);
-                    }
-                    inString = true;
-                    quoteChar = c;
-                    start = i+1;
-                } else if (c === '.') {
-                    if (i===0) {
-                        throw new Error("Invalid property expression: unexpected . at position 0");
-                    }
-                    if (start != i) {
-                        v = str.substring(start,i);
-                        if (/^\d+$/.test(v)) {
-                            parts.push(parseInt(v));
-                        } else {
-                            parts.push(v);
-                        }
-                    }
-                    if (i===length-1) {
-                        throw new Error("Invalid property expression: unterminated expression");
-                    }
-                    // Next char is first char of an identifier: a-z 0-9 $ _
-                    if (!/[a-z0-9\$\_]/i.test(str[i+1])) {
-                        throw new Error("Invalid property expression: unexpected "+str[i+1]+" at position "+(i+1));
-                    }
-                    start = i+1;
-                } else if (c === '[') {
-                    if (i === 0) {
-                        throw new Error("Invalid property expression: unexpected "+c+" at position "+i);
-                    }
-                    if (start != i) {
-                        parts.push(str.substring(start,i));
-                    }
-                    if (i===length-1) {
-                        throw new Error("Invalid property expression: unterminated expression");
-                    }
-                    // Next char is either a quote or a number
-                    if (!/["'\d]/.test(str[i+1])) {
-                        throw new Error("Invalid property expression: unexpected "+str[i+1]+" at position "+(i+1));
-                    }
-                    start = i+1;
-                    inBox = true;
-                } else if (c === ']') {
-                    if (!inBox) {
-                        throw new Error("Invalid property expression: unexpected "+c+" at position "+i);
-                    }
-                    if (start != i) {
-                        v = str.substring(start,i);
-                        if (/^\d+$/.test(v)) {
-                            parts.push(parseInt(v));
-                        } else {
-                            throw new Error("Invalid property expression: unexpected array expression at position "+start);
-                        }
-                    }
-                    start = i+1;
-                    inBox = false;
-                } else if (c === ' ') {
-                    throw new Error("Invalid property expression: unexpected ' ' at position "+i);
-                }
-            } else {
-                if (c === quoteChar) {
-                    if (i-start === 0) {
-                        throw new Error("Invalid property expression: zero-length string at position "+start);
-                    }
-                    parts.push(str.substring(start,i));
-                    // If inBox, next char must be a ]. Otherwise it may be [ or .
-                    if (inBox && !/\]/.test(str[i+1])) {
-                        throw new Error("Invalid property expression: unexpected array expression at position "+start);
-                    } else if (!inBox && i+1!==length && !/[\[\.]/.test(str[i+1])) {
-                        throw new Error("Invalid property expression: unexpected "+str[i+1]+" expression at position "+(i+1));
-                    }
-                    start = i+1;
-                    inString = false;
-                }
-            }
-
-        }
-        if (inBox || inString) {
-            throw new Error("Invalid property expression: unterminated expression");
-        }
-        if (start < length) {
-            parts.push(str.substring(start));
-        }
-        return parts;
-    }
-
-    function validatePropertyExpression(str) {
-        try {
-            var parts = normalisePropertyExpression(str);
-            return true;
-        } catch(err) {
-            return false;
-        }
-    }
-
-    function getMessageProperty(msg,expr) {
-        var result = null;
-        var msgPropParts;
-
-        if (typeof expr === 'string') {
-            if (expr.indexOf('msg.')===0) {
-                expr = expr.substring(4);
-            }
-            msgPropParts = normalisePropertyExpression(expr);
-        } else {
-            msgPropParts = expr;
-        }
-        var m;
-        msgPropParts.reduce(function(obj, key) {
-            result = (typeof obj[key] !== "undefined" ? obj[key] : undefined);
-            if (result === undefined && obj.hasOwnProperty('type') && obj.hasOwnProperty('data')&& obj.hasOwnProperty('length')) {
-                result = (typeof obj.data[key] !== "undefined" ? obj.data[key] : undefined);
-            }
-            return result;
-        }, msg);
-        return result;
-    }
-
-    function getNodeIcon(def,node) {
-        if (def.category === 'config') {
-            return "icons/node-red/cog.png"
-        } else if (node && node.type === 'tab') {
-            return "icons/node-red/subflow.png"
-        } else if (node && node.type === 'unknown') {
-            return "icons/node-red/alert.png"
-        } else if (node && node.type === 'subflow') {
-            return "icons/node-red/subflow.png"
-        }
-        var icon_url;
-        if (typeof def.icon === "function") {
-            try {
-                icon_url = def.icon.call(node);
-            } catch(err) {
-                console.log("Definition error: "+def.type+".icon",err);
-                icon_url = "arrow-in.png";
-            }
-        } else {
-            icon_url = def.icon;
-        }
-        return "icons/"+def.set.module+"/"+icon_url;
-    }
-
-    function getNodeLabel(node,defaultLabel) {
-        defaultLabel = defaultLabel||"";
-        var l;
-        if (node.type === 'tab') {
-            l = node.label || defaultLabel
-        } else {
-            l = node._def.label;
-            try {
-                l = (typeof l === "function" ? l.call(node) : l)||defaultLabel;
-            } catch(err) {
-                console.log("Definition error: "+node.type+".label",err);
-                l = defaultLabel;
-            }
-        }
-        return RED.text.bidi.enforceTextDirectionWithUCC(l);
-    }
-
-    return {
-        createObjectElement: buildMessageElement,
-        getMessageProperty: getMessageProperty,
-        normalisePropertyExpression: normalisePropertyExpression,
-        validatePropertyExpression: validatePropertyExpression,
-        getNodeIcon: getNodeIcon,
-        getNodeLabel: getNodeLabel,
-    }
-})();