mirror of
https://github.com/node-red/node-red.git
synced 2025-03-01 10:36:34 +00:00
pull out editor-client and editor-api
This commit is contained in:
Nick O'Leary
49
packages/node_modules/@node-red/registry/lib/deprecated.js
generated
vendored
Normal file
49
packages/node_modules/@node-red/registry/lib/deprecated.js
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
var nodes = {
|
||||
"irc in": {module:"node-red-node-irc"},
|
||||
"irc out": {module:"node-red-node-irc"},
|
||||
"irc-server": {module:"node-red-node-irc"},
|
||||
|
||||
"arduino in": {module:"node-red-node-arduino"},
|
||||
"arduino out": {module:"node-red-node-arduino"},
|
||||
"arduino-board": {module:"node-red-node-arduino"},
|
||||
|
||||
"redis out": {module:"node-red-node-redis"},
|
||||
|
||||
"mongodb": {module:"node-red-node-mongodb"},
|
||||
"mongodb out": {module:"node-red-node-mongodb"},
|
||||
|
||||
"serial in": {module:"node-red-node-serialport"},
|
||||
"serial out": {module:"node-red-node-serialport"},
|
||||
"serial-port": {module:"node-red-node-serialport"},
|
||||
|
||||
"twitter-credentials": {module:"node-red-node-twitter"},
|
||||
"twitter in": {module:"node-red-node-twitter"},
|
||||
"twitter out": {module:"node-red-node-twitter"},
|
||||
|
||||
"e-mail": {module:"node-red-node-email"},
|
||||
"e-mail in": {module:"node-red-node-email"},
|
||||
|
||||
"feedparse": {module:"node-red-node-feedparser"}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
get: function(id) {
|
||||
return nodes[id];
|
||||
}
|
||||
}
|
||||
91
packages/node_modules/@node-red/registry/lib/index.js
generated
vendored
Normal file
91
packages/node_modules/@node-red/registry/lib/index.js
generated
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
var registry = require("./registry");
|
||||
var loader = require("./loader");
|
||||
var installer = require("./installer");
|
||||
var library = require("./library");
|
||||
|
||||
var settings;
|
||||
|
||||
function init(runtime) {
|
||||
settings = runtime.settings;
|
||||
installer.init(runtime);
|
||||
loader.init(runtime);
|
||||
registry.init(settings,loader,runtime.events);
|
||||
library.init();
|
||||
}
|
||||
|
||||
function load() {
|
||||
registry.load();
|
||||
return installer.checkPrereq().then(loader.load);
|
||||
}
|
||||
|
||||
function addModule(module) {
|
||||
return loader.addModule(module).then(function() {
|
||||
return registry.getModuleInfo(module);
|
||||
});
|
||||
}
|
||||
|
||||
function enableNodeSet(typeOrId) {
|
||||
return registry.enableNodeSet(typeOrId).then(function() {
|
||||
var nodeSet = registry.getNodeInfo(typeOrId);
|
||||
if (!nodeSet.loaded) {
|
||||
return loader.loadNodeSet(registry.getFullNodeInfo(typeOrId)).then(function() {
|
||||
return registry.getNodeInfo(typeOrId);
|
||||
});
|
||||
}
|
||||
return Promise.resolve(nodeSet);
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
init:init,
|
||||
load:load,
|
||||
clear: registry.clear,
|
||||
registerType: registry.registerNodeConstructor,
|
||||
|
||||
get: registry.getNodeConstructor,
|
||||
getNodeInfo: registry.getNodeInfo,
|
||||
getNodeList: registry.getNodeList,
|
||||
|
||||
getModuleInfo: registry.getModuleInfo,
|
||||
getModuleList: registry.getModuleList,
|
||||
|
||||
getNodeConfigs: registry.getAllNodeConfigs,
|
||||
getNodeConfig: registry.getNodeConfig,
|
||||
getNodeIconPath: registry.getNodeIconPath,
|
||||
getNodeIcons: registry.getNodeIcons,
|
||||
|
||||
enableNode: enableNodeSet,
|
||||
disableNode: registry.disableNodeSet,
|
||||
|
||||
addModule: addModule,
|
||||
removeModule: registry.removeModule,
|
||||
|
||||
installModule: installer.installModule,
|
||||
uninstallModule: installer.uninstallModule,
|
||||
|
||||
cleanModuleList: registry.cleanModuleList,
|
||||
|
||||
paletteEditorEnabled: installer.paletteEditorEnabled,
|
||||
|
||||
getNodeExampleFlows: library.getExampleFlows,
|
||||
getNodeExampleFlowPath: library.getExampleFlowPath,
|
||||
|
||||
deprecated: require("./deprecated")
|
||||
|
||||
};
|
||||
270
packages/node_modules/@node-red/registry/lib/installer.js
generated
vendored
Normal file
270
packages/node_modules/@node-red/registry/lib/installer.js
generated
vendored
Normal file
@@ -0,0 +1,270 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
|
||||
var path = require("path");
|
||||
var fs = require("fs");
|
||||
|
||||
var registry = require("./registry");
|
||||
var library = require("./library");
|
||||
var log;
|
||||
|
||||
var events;
|
||||
|
||||
var child_process = require('child_process');
|
||||
var npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
|
||||
var paletteEditorEnabled = false;
|
||||
|
||||
var settings;
|
||||
var moduleRe = /^(@[^/]+?[/])?[^/]+?$/;
|
||||
var slashRe = process.platform === "win32" ? /\\|[/]/ : /[/]/;
|
||||
|
||||
function init(runtime) {
|
||||
events = runtime.events;
|
||||
settings = runtime.settings;
|
||||
log = runtime.log;
|
||||
}
|
||||
|
||||
var activePromise = Promise.resolve();
|
||||
|
||||
function checkModulePath(folder) {
|
||||
var moduleName;
|
||||
var err;
|
||||
var fullPath = path.resolve(folder);
|
||||
var packageFile = path.join(fullPath,'package.json');
|
||||
try {
|
||||
var pkg = require(packageFile);
|
||||
moduleName = pkg.name;
|
||||
if (!pkg['node-red']) {
|
||||
// TODO: nls
|
||||
err = new Error("Invalid Node-RED module");
|
||||
err.code = 'invalid_module';
|
||||
throw err;
|
||||
}
|
||||
} catch(err2) {
|
||||
err = new Error("Module not found");
|
||||
err.code = 404;
|
||||
throw err;
|
||||
}
|
||||
return moduleName;
|
||||
}
|
||||
|
||||
function checkExistingModule(module,version) {
|
||||
var info = registry.getModuleInfo(module);
|
||||
if (info) {
|
||||
if (!version || info.version === version) {
|
||||
var err = new Error("Module already loaded");
|
||||
err.code = "module_already_loaded";
|
||||
throw err;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function installModule(module,version) {
|
||||
activePromise = activePromise.then(() => {
|
||||
//TODO: ensure module is 'safe'
|
||||
return new Promise((resolve,reject) => {
|
||||
var installName = module;
|
||||
var isUpgrade = false;
|
||||
try {
|
||||
if (moduleRe.test(module)) {
|
||||
// Simple module name - assume it can be npm installed
|
||||
if (version) {
|
||||
installName += "@"+version;
|
||||
}
|
||||
} else if (slashRe.test(module)) {
|
||||
// A path - check if there's a valid package.json
|
||||
installName = module;
|
||||
module = checkModulePath(module);
|
||||
}
|
||||
isUpgrade = checkExistingModule(module,version);
|
||||
} catch(err) {
|
||||
return reject(err);
|
||||
}
|
||||
if (!isUpgrade) {
|
||||
log.info(log._("server.install.installing",{name: module,version: version||"latest"}));
|
||||
} else {
|
||||
log.info(log._("server.install.upgrading",{name: module,version: version||"latest"}));
|
||||
}
|
||||
|
||||
var installDir = settings.userDir || process.env.NODE_RED_HOME || ".";
|
||||
var args = ['install','--save','--save-prefix="~"','--production',installName];
|
||||
log.trace(npmCommand + JSON.stringify(args));
|
||||
var child = child_process.spawn(npmCommand,args,{
|
||||
cwd: installDir,
|
||||
shell: true
|
||||
});
|
||||
var output = "";
|
||||
child.stdout.on('data', (data) => {
|
||||
output += data;
|
||||
});
|
||||
child.stderr.on('data', (data) => {
|
||||
output += data;
|
||||
});
|
||||
child.on('close', (code) => {
|
||||
if (code !== 0) {
|
||||
var e;
|
||||
var lookFor404 = new RegExp(" 404 .*"+module,"m");
|
||||
var lookForVersionNotFound = new RegExp("version not found: "+module+"@"+version,"m");
|
||||
if (lookFor404.test(output)) {
|
||||
log.warn(log._("server.install.install-failed-not-found",{name:module}));
|
||||
e = new Error("Module not found");
|
||||
e.code = 404;
|
||||
reject(e);
|
||||
} else if (isUpgrade && lookForVersionNotFound.test(output)) {
|
||||
log.warn(log._("server.install.upgrade-failed-not-found",{name:module}));
|
||||
e = new Error("Module not found");
|
||||
e.code = 404;
|
||||
reject(e);
|
||||
} else {
|
||||
log.warn(log._("server.install.install-failed-long",{name:module}));
|
||||
log.warn("------------------------------------------");
|
||||
log.warn(output);
|
||||
log.warn("------------------------------------------");
|
||||
reject(new Error(log._("server.install.install-failed")));
|
||||
}
|
||||
} else {
|
||||
if (!isUpgrade) {
|
||||
log.info(log._("server.install.installed",{name:module}));
|
||||
resolve(require("./index").addModule(module).then(reportAddedModules));
|
||||
} else {
|
||||
log.info(log._("server.install.upgraded",{name:module, version:version}));
|
||||
events.emit("runtime-event",{id:"restart-required",payload:{type:"warning",text:"notification.warnings.restartRequired"},retain:true});
|
||||
resolve(require("./registry").setModulePendingUpdated(module,version));
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
}).catch(err => {
|
||||
// In case of error, reset activePromise to be resolvable
|
||||
activePromise = Promise.resolve();
|
||||
throw err;
|
||||
});
|
||||
return activePromise;
|
||||
}
|
||||
|
||||
|
||||
function reportAddedModules(info) {
|
||||
//comms.publish("node/added",info.nodes,false);
|
||||
if (info.nodes.length > 0) {
|
||||
log.info(log._("server.added-types"));
|
||||
for (var i=0;i<info.nodes.length;i++) {
|
||||
for (var j=0;j<info.nodes[i].types.length;j++) {
|
||||
log.info(" - "+
|
||||
(info.nodes[i].module?info.nodes[i].module+":":"")+
|
||||
info.nodes[i].types[j]+
|
||||
(info.nodes[i].err?" : "+info.nodes[i].err:"")
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
return info;
|
||||
}
|
||||
|
||||
function reportRemovedModules(removedNodes) {
|
||||
//comms.publish("node/removed",removedNodes,false);
|
||||
log.info(log._("server.removed-types"));
|
||||
for (var j=0;j<removedNodes.length;j++) {
|
||||
for (var i=0;i<removedNodes[j].types.length;i++) {
|
||||
log.info(" - "+(removedNodes[j].module?removedNodes[j].module+":":"")+removedNodes[j].types[i]);
|
||||
}
|
||||
}
|
||||
return removedNodes;
|
||||
}
|
||||
|
||||
function uninstallModule(module) {
|
||||
activePromise = activePromise.then(() => {
|
||||
return new Promise((resolve,reject) => {
|
||||
if (/[\s;]/.test(module)) {
|
||||
reject(new Error(log._("server.install.invalid")));
|
||||
return;
|
||||
}
|
||||
var installDir = settings.userDir || process.env.NODE_RED_HOME || ".";
|
||||
var moduleDir = path.join(installDir,"node_modules",module);
|
||||
|
||||
try {
|
||||
fs.statSync(moduleDir);
|
||||
} catch(err) {
|
||||
return reject(new Error(log._("server.install.uninstall-failed",{name:module})));
|
||||
}
|
||||
|
||||
var list = registry.removeModule(module);
|
||||
log.info(log._("server.install.uninstalling",{name:module}));
|
||||
|
||||
var args = ['remove','--save',module];
|
||||
log.trace(npmCommand + JSON.stringify(args));
|
||||
|
||||
var child = child_process.execFile(npmCommand,args,
|
||||
{
|
||||
cwd: installDir
|
||||
},
|
||||
function(err, stdin, stdout) {
|
||||
if (err) {
|
||||
log.warn(log._("server.install.uninstall-failed-long",{name:module}));
|
||||
log.warn("------------------------------------------");
|
||||
log.warn(err.toString());
|
||||
log.warn("------------------------------------------");
|
||||
reject(new Error(log._("server.install.uninstall-failed",{name:module})));
|
||||
} else {
|
||||
log.info(log._("server.install.uninstalled",{name:module}));
|
||||
reportRemovedModules(list);
|
||||
library.removeExamplesDir(module);
|
||||
resolve(list);
|
||||
}
|
||||
}
|
||||
);
|
||||
});
|
||||
}).catch(err => {
|
||||
// In case of error, reset activePromise to be resolvable
|
||||
activePromise = Promise.resolve();
|
||||
throw err;
|
||||
});
|
||||
return activePromise;
|
||||
}
|
||||
|
||||
function checkPrereq() {
|
||||
if (settings.hasOwnProperty('editorTheme') &&
|
||||
settings.editorTheme.hasOwnProperty('palette') &&
|
||||
settings.editorTheme.palette.hasOwnProperty('editable') &&
|
||||
settings.editorTheme.palette.editable === false
|
||||
) {
|
||||
log.info(log._("server.palette-editor.disabled"));
|
||||
paletteEditorEnabled = false;
|
||||
return Promise.resolve();
|
||||
} else {
|
||||
return new Promise(resolve => {
|
||||
child_process.execFile(npmCommand,['-v'],function(err) {
|
||||
if (err) {
|
||||
log.info(log._("server.palette-editor.npm-not-found"));
|
||||
paletteEditorEnabled = false;
|
||||
} else {
|
||||
paletteEditorEnabled = true;
|
||||
}
|
||||
resolve();
|
||||
});
|
||||
})
|
||||
}
|
||||
}
|
||||
module.exports = {
|
||||
init: init,
|
||||
checkPrereq: checkPrereq,
|
||||
installModule: installModule,
|
||||
uninstallModule: uninstallModule,
|
||||
paletteEditorEnabled: function() {
|
||||
return paletteEditorEnabled
|
||||
}
|
||||
}
|
||||
102
packages/node_modules/@node-red/registry/lib/library.js
generated
vendored
Normal file
102
packages/node_modules/@node-red/registry/lib/library.js
generated
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
var fs = require('fs');
|
||||
var fspath = require('path');
|
||||
var when = require('when');
|
||||
|
||||
var runtime;
|
||||
|
||||
var exampleRoots = {};
|
||||
var exampleFlows = null;
|
||||
|
||||
function getFlowsFromPath(path) {
|
||||
return when.promise(function(resolve,reject) {
|
||||
var result = {};
|
||||
fs.readdir(path,function(err,files) {
|
||||
var promises = [];
|
||||
var validFiles = [];
|
||||
files.forEach(function(file) {
|
||||
var fullPath = fspath.join(path,file);
|
||||
var stats = fs.lstatSync(fullPath);
|
||||
if (stats.isDirectory()) {
|
||||
validFiles.push(file);
|
||||
promises.push(getFlowsFromPath(fullPath));
|
||||
} else if (/\.json$/.test(file)){
|
||||
validFiles.push(file);
|
||||
promises.push(when.resolve(file.split(".")[0]))
|
||||
}
|
||||
})
|
||||
var i=0;
|
||||
when.all(promises).then(function(results) {
|
||||
results.forEach(function(r) {
|
||||
if (typeof r === 'string') {
|
||||
result.f = result.f||[];
|
||||
result.f.push(r);
|
||||
} else {
|
||||
result.d = result.d||{};
|
||||
result.d[validFiles[i]] = r;
|
||||
}
|
||||
i++;
|
||||
})
|
||||
|
||||
resolve(result);
|
||||
})
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
function addNodeExamplesDir(module,path) {
|
||||
exampleRoots[module] = path;
|
||||
return getFlowsFromPath(path).then(function(result) {
|
||||
exampleFlows = exampleFlows||{d:{}};
|
||||
exampleFlows.d[module] = result;
|
||||
});
|
||||
}
|
||||
function removeNodeExamplesDir(module) {
|
||||
delete exampleRoots[module];
|
||||
if (exampleFlows && exampleFlows.d) {
|
||||
delete exampleFlows.d[module];
|
||||
}
|
||||
if (exampleFlows && Object.keys(exampleFlows.d).length === 0) {
|
||||
exampleFlows = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function init() {
|
||||
exampleRoots = {};
|
||||
exampleFlows = null;
|
||||
}
|
||||
|
||||
function getExampleFlows() {
|
||||
return exampleFlows;
|
||||
}
|
||||
|
||||
function getExampleFlowPath(module,path) {
|
||||
if (exampleRoots[module]) {
|
||||
return fspath.join(exampleRoots[module],path)+".json";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
init: init,
|
||||
addExamplesDir: addNodeExamplesDir,
|
||||
removeExamplesDir: removeNodeExamplesDir,
|
||||
getExampleFlows: getExampleFlows,
|
||||
getExampleFlowPath: getExampleFlowPath
|
||||
}
|
||||
458
packages/node_modules/@node-red/registry/lib/loader.js
generated
vendored
Normal file
458
packages/node_modules/@node-red/registry/lib/loader.js
generated
vendored
Normal file
@@ -0,0 +1,458 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
var when = require("when");
|
||||
var fs = require("fs");
|
||||
var path = require("path");
|
||||
var semver = require("semver");
|
||||
|
||||
var localfilesystem = require("./localfilesystem");
|
||||
var registry = require("./registry");
|
||||
|
||||
var i18n = require("@node-red/util").i18n; // TODO: separate module
|
||||
|
||||
var settings;
|
||||
var runtime;
|
||||
|
||||
function init(_runtime) {
|
||||
runtime = _runtime;
|
||||
settings = runtime.settings;
|
||||
localfilesystem.init(runtime);
|
||||
}
|
||||
|
||||
function load(defaultNodesDir,disableNodePathScan) {
|
||||
// To skip node scan, the following line will use the stored node list.
|
||||
// We should expose that as an option at some point, although the
|
||||
// performance gains are minimal.
|
||||
//return loadNodeFiles(registry.getModuleList());
|
||||
runtime.log.info(runtime.log._("server.loading"));
|
||||
|
||||
var nodeFiles = localfilesystem.getNodeFiles(defaultNodesDir,disableNodePathScan);
|
||||
return loadNodeFiles(nodeFiles);
|
||||
}
|
||||
|
||||
function copyObjectProperties(src,dst,copyList,blockList) {
|
||||
if (!src) {
|
||||
return;
|
||||
}
|
||||
if (copyList && !blockList) {
|
||||
copyList.forEach(function(i) {
|
||||
if (src.hasOwnProperty(i)) {
|
||||
var propDescriptor = Object.getOwnPropertyDescriptor(src,i);
|
||||
Object.defineProperty(dst,i,propDescriptor);
|
||||
}
|
||||
});
|
||||
} else if (!copyList && blockList) {
|
||||
for (var i in src) {
|
||||
if (src.hasOwnProperty(i) && blockList.indexOf(i) === -1) {
|
||||
var propDescriptor = Object.getOwnPropertyDescriptor(src,i);
|
||||
Object.defineProperty(dst,i,propDescriptor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function requireModule(name) {
|
||||
var moduleInfo = registry.getModuleInfo(name);
|
||||
if (moduleInfo && moduleInfo.path) {
|
||||
var relPath = path.relative(__dirname, moduleInfo.path);
|
||||
return require(relPath);
|
||||
} else {
|
||||
var err = new Error(`Cannot find module '${name}'`);
|
||||
err.code = "MODULE_NOT_FOUND";
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
function createNodeApi(node) {
|
||||
var red = {
|
||||
nodes: {},
|
||||
log: {},
|
||||
settings: {},
|
||||
events: runtime.events,
|
||||
util: runtime.util,
|
||||
version: runtime.version,
|
||||
require: requireModule,
|
||||
comms: {
|
||||
publish: function(topic,data,retain) {
|
||||
runtime.events.emit("comms",{
|
||||
topic: topic,
|
||||
data: data,
|
||||
retain: retain
|
||||
})
|
||||
}
|
||||
},
|
||||
library: {
|
||||
register: function(type) {
|
||||
return runtime.library.register(node.id,type);
|
||||
}
|
||||
}
|
||||
}
|
||||
copyObjectProperties(runtime.nodes,red.nodes,["createNode","getNode","eachNode","addCredentials","getCredentials","deleteCredentials" ]);
|
||||
red.nodes.registerType = function(type,constructor,opts) {
|
||||
runtime.nodes.registerType(node.id,type,constructor,opts);
|
||||
}
|
||||
copyObjectProperties(runtime.log,red.log,null,["init"]);
|
||||
copyObjectProperties(runtime.settings,red.settings,null,["init","load","reset"]);
|
||||
if (runtime.adminApi) {
|
||||
red.auth = runtime.adminApi.auth;
|
||||
red.httpAdmin = runtime.adminApi.adminApp;
|
||||
red.httpNode = runtime.nodeApp;
|
||||
red.server = runtime.server;
|
||||
} else {
|
||||
//TODO: runtime.adminApi is always stubbed if not enabled, so this block
|
||||
// is unused - but may be needed for the unit tests
|
||||
red.auth = {
|
||||
needsPermission: function() {}
|
||||
};
|
||||
// TODO: stub out httpAdmin/httpNode/server
|
||||
}
|
||||
red["_"] = function() {
|
||||
var args = Array.prototype.slice.call(arguments, 0);
|
||||
if (args[0].indexOf(":") === -1) {
|
||||
args[0] = node.namespace+":"+args[0];
|
||||
}
|
||||
return i18n._.apply(null,args);
|
||||
}
|
||||
return red;
|
||||
}
|
||||
|
||||
|
||||
function loadNodeFiles(nodeFiles) {
|
||||
var promises = [];
|
||||
var nodes = [];
|
||||
for (var module in nodeFiles) {
|
||||
/* istanbul ignore else */
|
||||
if (nodeFiles.hasOwnProperty(module)) {
|
||||
if (nodeFiles[module].redVersion &&
|
||||
!semver.satisfies(runtime.version().replace(/(\-[1-9A-Za-z-][0-9A-Za-z-\.]*)?(\+[0-9A-Za-z-\.]+)?$/,""), nodeFiles[module].redVersion)) {
|
||||
//TODO: log it
|
||||
runtime.log.warn("["+module+"] "+runtime.log._("server.node-version-mismatch",{version:nodeFiles[module].redVersion}));
|
||||
nodeFiles[module].err = "version_mismatch";
|
||||
continue;
|
||||
}
|
||||
if (module == "node-red" || !registry.getModuleInfo(module)) {
|
||||
var first = true;
|
||||
for (var node in nodeFiles[module].nodes) {
|
||||
/* istanbul ignore else */
|
||||
if (nodeFiles[module].nodes.hasOwnProperty(node)) {
|
||||
if (module != "node-red" && first) {
|
||||
// Check the module directory exists
|
||||
first = false;
|
||||
var fn = nodeFiles[module].nodes[node].file;
|
||||
var parts = fn.split("/");
|
||||
var i = parts.length-1;
|
||||
for (;i>=0;i--) {
|
||||
if (parts[i] == "node_modules") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
var moduleFn = parts.slice(0,i+2).join("/");
|
||||
|
||||
try {
|
||||
var stat = fs.statSync(moduleFn);
|
||||
} catch(err) {
|
||||
// Module not found, don't attempt to load its nodes
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
promises.push(loadNodeConfig(nodeFiles[module].nodes[node]).then((function() {
|
||||
var m = module;
|
||||
var n = node;
|
||||
return function(nodeSet) {
|
||||
nodeFiles[m].nodes[n] = nodeSet;
|
||||
nodes.push(nodeSet);
|
||||
}
|
||||
})()));
|
||||
} catch(err) {
|
||||
//
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return when.settle(promises).then(function(results) {
|
||||
for (var module in nodeFiles) {
|
||||
if (nodeFiles.hasOwnProperty(module)) {
|
||||
if (!nodeFiles[module].err) {
|
||||
registry.addModule(nodeFiles[module]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return loadNodeSetList(nodes);
|
||||
});
|
||||
}
|
||||
|
||||
function loadNodeConfig(fileInfo) {
|
||||
return new Promise(function(resolve) {
|
||||
var file = fileInfo.file;
|
||||
var module = fileInfo.module;
|
||||
var name = fileInfo.name;
|
||||
var version = fileInfo.version;
|
||||
|
||||
var id = module + "/" + name;
|
||||
var info = registry.getNodeInfo(id);
|
||||
var isEnabled = true;
|
||||
if (info) {
|
||||
if (info.hasOwnProperty("loaded")) {
|
||||
throw new Error(file+" already loaded");
|
||||
}
|
||||
isEnabled = info.enabled;
|
||||
}
|
||||
|
||||
var node = {
|
||||
id: id,
|
||||
module: module,
|
||||
name: name,
|
||||
file: file,
|
||||
template: file.replace(/\.js$/,".html"),
|
||||
enabled: isEnabled,
|
||||
loaded:false,
|
||||
version: version,
|
||||
local: fileInfo.local
|
||||
};
|
||||
if (fileInfo.hasOwnProperty("types")) {
|
||||
node.types = fileInfo.types;
|
||||
}
|
||||
|
||||
fs.readFile(node.template,'utf8', function(err,content) {
|
||||
if (err) {
|
||||
node.types = [];
|
||||
if (err.code === 'ENOENT') {
|
||||
if (!node.types) {
|
||||
node.types = [];
|
||||
}
|
||||
node.err = "Error: "+node.template+" does not exist";
|
||||
} else {
|
||||
node.types = [];
|
||||
node.err = err.toString();
|
||||
}
|
||||
resolve(node);
|
||||
} else {
|
||||
var types = [];
|
||||
|
||||
var regExp = /<script (?:[^>]*)data-template-name\s*=\s*['"]([^'"]*)['"]/gi;
|
||||
var match = null;
|
||||
|
||||
while ((match = regExp.exec(content)) !== null) {
|
||||
types.push(match[1]);
|
||||
}
|
||||
node.types = types;
|
||||
|
||||
var langRegExp = /^<script[^>]* data-lang\s*=\s*['"](.+?)['"]/i;
|
||||
regExp = /(<script[^>]* data-help-name=[\s\S]*?<\/script>)/gi;
|
||||
match = null;
|
||||
var mainContent = "";
|
||||
var helpContent = {};
|
||||
var index = 0;
|
||||
while ((match = regExp.exec(content)) !== null) {
|
||||
mainContent += content.substring(index,regExp.lastIndex-match[1].length);
|
||||
index = regExp.lastIndex;
|
||||
var help = content.substring(regExp.lastIndex-match[1].length,regExp.lastIndex);
|
||||
|
||||
var lang = i18n.defaultLang;
|
||||
if ((match = langRegExp.exec(help)) !== null) {
|
||||
lang = match[1];
|
||||
}
|
||||
if (!helpContent.hasOwnProperty(lang)) {
|
||||
helpContent[lang] = "";
|
||||
}
|
||||
|
||||
helpContent[lang] += help;
|
||||
}
|
||||
mainContent += content.substring(index);
|
||||
|
||||
node.config = mainContent;
|
||||
node.help = helpContent;
|
||||
// TODO: parse out the javascript portion of the template
|
||||
//node.script = "";
|
||||
for (var i=0;i<node.types.length;i++) {
|
||||
if (registry.getTypeId(node.types[i])) {
|
||||
node.err = node.types[i]+" already registered";
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (node.module === 'node-red') {
|
||||
// do not look up locales directory for core nodes
|
||||
node.namespace = node.module;
|
||||
resolve(node);
|
||||
return;
|
||||
}
|
||||
fs.stat(path.join(path.dirname(file),"locales"),function(err,stat) {
|
||||
if (!err) {
|
||||
node.namespace = node.id;
|
||||
i18n.registerMessageCatalog(node.id,
|
||||
path.join(path.dirname(file),"locales"),
|
||||
path.basename(file,".js")+".json")
|
||||
.then(function() {
|
||||
resolve(node);
|
||||
});
|
||||
} else {
|
||||
node.namespace = node.module;
|
||||
resolve(node);
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the specified node into the runtime
|
||||
* @param node a node info object - see loadNodeConfig
|
||||
* @return a promise that resolves to an update node info object. The object
|
||||
* has the following properties added:
|
||||
* err: any error encountered whilst loading the node
|
||||
*
|
||||
*/
|
||||
function loadNodeSet(node) {
|
||||
var nodeDir = path.dirname(node.file);
|
||||
var nodeFn = path.basename(node.file);
|
||||
if (!node.enabled) {
|
||||
return Promise.resolve(node);
|
||||
} else {
|
||||
}
|
||||
try {
|
||||
var loadPromise = null;
|
||||
var r = require(node.file);
|
||||
if (typeof r === "function") {
|
||||
|
||||
var red = createNodeApi(node);
|
||||
var promise = r(red);
|
||||
if (promise != null && typeof promise.then === "function") {
|
||||
loadPromise = promise.then(function() {
|
||||
node.enabled = true;
|
||||
node.loaded = true;
|
||||
return node;
|
||||
}).catch(function(err) {
|
||||
node.err = err;
|
||||
return node;
|
||||
});
|
||||
}
|
||||
}
|
||||
if (loadPromise == null) {
|
||||
node.enabled = true;
|
||||
node.loaded = true;
|
||||
loadPromise = Promise.resolve(node);
|
||||
}
|
||||
return loadPromise;
|
||||
} catch(err) {
|
||||
node.err = err;
|
||||
var stack = err.stack;
|
||||
var message;
|
||||
if (stack) {
|
||||
var i = stack.indexOf(node.file);
|
||||
if (i > -1) {
|
||||
var excerpt = stack.substring(i+node.file.length+1,i+node.file.length+20);
|
||||
var m = /^(\d+):(\d+)/.exec(excerpt);
|
||||
if (m) {
|
||||
node.err = err+" (line:"+m[1]+")";
|
||||
}
|
||||
}
|
||||
}
|
||||
return Promise.resolve(node);
|
||||
}
|
||||
}
|
||||
|
||||
function loadNodeSetList(nodes) {
|
||||
var promises = [];
|
||||
nodes.forEach(function(node) {
|
||||
if (!node.err) {
|
||||
promises.push(loadNodeSet(node));
|
||||
} else {
|
||||
promises.push(node);
|
||||
}
|
||||
});
|
||||
|
||||
return when.settle(promises).then(function() {
|
||||
if (settings.available()) {
|
||||
return registry.saveNodeList();
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function addModule(module) {
|
||||
if (!settings.available()) {
|
||||
throw new Error("Settings unavailable");
|
||||
}
|
||||
var nodes = [];
|
||||
if (registry.getModuleInfo(module)) {
|
||||
// TODO: nls
|
||||
var e = new Error("module_already_loaded");
|
||||
e.code = "module_already_loaded";
|
||||
return Promise.reject(e);
|
||||
}
|
||||
try {
|
||||
var moduleFiles = localfilesystem.getModuleFiles(module);
|
||||
return loadNodeFiles(moduleFiles);
|
||||
} catch(err) {
|
||||
return Promise.reject(err);
|
||||
}
|
||||
}
|
||||
|
||||
function loadNodeHelp(node,lang) {
|
||||
var base = path.basename(node.template);
|
||||
var localePath;
|
||||
if (node.module === 'node-red') {
|
||||
var cat_dir = path.dirname(node.template);
|
||||
var cat = path.basename(cat_dir);
|
||||
var dir = path.dirname(cat_dir);
|
||||
localePath = path.join(dir, "locales", lang, cat, base)
|
||||
}
|
||||
else {
|
||||
var dir = path.dirname(node.template);
|
||||
localePath = path.join(dir,"locales",lang,base);
|
||||
}
|
||||
try {
|
||||
// TODO: make this async
|
||||
var content = fs.readFileSync(localePath, "utf8")
|
||||
return content;
|
||||
} catch(err) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function getNodeHelp(node,lang) {
|
||||
if (!node.help[lang]) {
|
||||
var help = loadNodeHelp(node,lang);
|
||||
if (help == null) {
|
||||
var langParts = lang.split("-");
|
||||
if (langParts.length == 2) {
|
||||
help = loadNodeHelp(node,langParts[0]);
|
||||
}
|
||||
}
|
||||
if (help) {
|
||||
node.help[lang] = help;
|
||||
} else if (lang === i18n.defaultLang) {
|
||||
return null;
|
||||
} else {
|
||||
node.help[lang] = getNodeHelp(node, i18n.defaultLang);
|
||||
}
|
||||
}
|
||||
return node.help[lang];
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
init: init,
|
||||
load: load,
|
||||
addModule: addModule,
|
||||
loadNodeSet: loadNodeSet,
|
||||
getNodeHelp: getNodeHelp
|
||||
}
|
||||
368
packages/node_modules/@node-red/registry/lib/localfilesystem.js
generated
vendored
Normal file
368
packages/node_modules/@node-red/registry/lib/localfilesystem.js
generated
vendored
Normal file
@@ -0,0 +1,368 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
var fs = require("fs");
|
||||
var path = require("path");
|
||||
|
||||
var events;
|
||||
var log;
|
||||
|
||||
var i18n = require("@node-red/util").i18n; // TODO: separate module
|
||||
|
||||
var settings;
|
||||
var disableNodePathScan = false;
|
||||
var iconFileExtensions = [".png", ".gif"];
|
||||
|
||||
function init(runtime) {
|
||||
settings = runtime.settings;
|
||||
events = runtime.events;
|
||||
log = runtime.log;
|
||||
}
|
||||
|
||||
function isIncluded(name) {
|
||||
if (settings.nodesIncludes) {
|
||||
for (var i=0;i<settings.nodesIncludes.length;i++) {
|
||||
if (settings.nodesIncludes[i] == name) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function isExcluded(name) {
|
||||
if (settings.nodesExcludes) {
|
||||
for (var i=0;i<settings.nodesExcludes.length;i++) {
|
||||
if (settings.nodesExcludes[i] == name) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function getLocalFile(file) {
|
||||
if (!isIncluded(path.basename(file)) || isExcluded(path.basename(file))) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
fs.statSync(file.replace(/\.js$/,".html"));
|
||||
return {
|
||||
file: file,
|
||||
module: "node-red",
|
||||
name: path.basename(file).replace(/^\d+-/,"").replace(/\.js$/,""),
|
||||
version: settings.version
|
||||
};
|
||||
} catch(err) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Synchronously walks the directory looking for node files.
|
||||
* Emits 'node-icon-dir' events for an icon dirs found
|
||||
* @param dir the directory to search
|
||||
* @return an array of fully-qualified paths to .js files
|
||||
*/
|
||||
function getLocalNodeFiles(dir) {
|
||||
dir = path.resolve(dir);
|
||||
|
||||
var result = [];
|
||||
var files = [];
|
||||
var icons = [];
|
||||
try {
|
||||
files = fs.readdirSync(dir);
|
||||
} catch(err) {
|
||||
return {files: [], icons: []};
|
||||
}
|
||||
files.sort();
|
||||
files.forEach(function(fn) {
|
||||
var stats = fs.statSync(path.join(dir,fn));
|
||||
if (stats.isFile()) {
|
||||
if (/\.js$/.test(fn)) {
|
||||
var info = getLocalFile(path.join(dir,fn));
|
||||
if (info) {
|
||||
result.push(info);
|
||||
}
|
||||
}
|
||||
} else if (stats.isDirectory()) {
|
||||
// Ignore /.dirs/, /lib/ /node_modules/
|
||||
if (!/^(\..*|lib|icons|node_modules|test|locales)$/.test(fn)) {
|
||||
var subDirResults = getLocalNodeFiles(path.join(dir,fn));
|
||||
result = result.concat(subDirResults.files);
|
||||
icons = icons.concat(subDirResults.icons);
|
||||
} else if (fn === "icons") {
|
||||
var iconList = scanIconDir(path.join(dir,fn));
|
||||
icons.push({path:path.join(dir,fn),icons:iconList});
|
||||
}
|
||||
}
|
||||
});
|
||||
return {files: result, icons: icons}
|
||||
}
|
||||
|
||||
function scanDirForNodesModules(dir,moduleName) {
|
||||
var results = [];
|
||||
var scopeName;
|
||||
try {
|
||||
var files = fs.readdirSync(dir);
|
||||
if (moduleName) {
|
||||
var m = /^(?:(@[^/]+)[/])?([^@/]+)/.exec(moduleName);
|
||||
if (m) {
|
||||
scopeName = m[1];
|
||||
moduleName = m[2];
|
||||
}
|
||||
}
|
||||
for (var i=0;i<files.length;i++) {
|
||||
var fn = files[i];
|
||||
if (/^@/.test(fn)) {
|
||||
if (scopeName && scopeName === fn) {
|
||||
// Looking for a specific scope/module
|
||||
results = results.concat(scanDirForNodesModules(path.join(dir,fn),moduleName));
|
||||
break;
|
||||
} else {
|
||||
results = results.concat(scanDirForNodesModules(path.join(dir,fn),moduleName));
|
||||
}
|
||||
} else {
|
||||
if (isIncluded(fn) && !isExcluded(fn) && (!moduleName || fn == moduleName)) {
|
||||
var pkgfn = path.join(dir,fn,"package.json");
|
||||
try {
|
||||
var pkg = require(pkgfn);
|
||||
if (pkg['node-red']) {
|
||||
var moduleDir = path.join(dir,fn);
|
||||
results.push({dir:moduleDir,package:pkg});
|
||||
}
|
||||
} catch(err) {
|
||||
if (err.code != "MODULE_NOT_FOUND") {
|
||||
// TODO: handle unexpected error
|
||||
}
|
||||
}
|
||||
if (fn == moduleName) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch(err) {
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans the node_modules path for nodes
|
||||
* @param moduleName the name of the module to be found
|
||||
* @return a list of node modules: {dir,package}
|
||||
*/
|
||||
function scanTreeForNodesModules(moduleName) {
|
||||
var dir = settings.coreNodesDir;
|
||||
var results = [];
|
||||
var userDir;
|
||||
|
||||
if (settings.userDir) {
|
||||
userDir = path.join(settings.userDir,"node_modules");
|
||||
results = scanDirForNodesModules(userDir,moduleName);
|
||||
results.forEach(function(r) { r.local = true; });
|
||||
}
|
||||
|
||||
if (dir) {
|
||||
var up = path.resolve(path.join(dir,".."));
|
||||
while (up !== dir) {
|
||||
var pm = path.join(dir,"node_modules");
|
||||
if (pm != userDir) {
|
||||
results = results.concat(scanDirForNodesModules(pm,moduleName));
|
||||
}
|
||||
dir = up;
|
||||
up = path.resolve(path.join(dir,".."));
|
||||
}
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
function getModuleNodeFiles(module) {
|
||||
|
||||
var moduleDir = module.dir;
|
||||
var pkg = module.package;
|
||||
|
||||
var nodes = pkg['node-red'].nodes||{};
|
||||
var results = [];
|
||||
var iconDirs = [];
|
||||
var iconList = [];
|
||||
for (var n in nodes) {
|
||||
/* istanbul ignore else */
|
||||
if (nodes.hasOwnProperty(n)) {
|
||||
var file = path.join(moduleDir,nodes[n]);
|
||||
results.push({
|
||||
file: file,
|
||||
module: pkg.name,
|
||||
name: n,
|
||||
version: pkg.version
|
||||
});
|
||||
var iconDir = path.join(moduleDir,path.dirname(nodes[n]),"icons");
|
||||
if (iconDirs.indexOf(iconDir) == -1) {
|
||||
try {
|
||||
fs.statSync(iconDir);
|
||||
var icons = scanIconDir(iconDir);
|
||||
iconList.push({path:iconDir,icons:icons});
|
||||
iconDirs.push(iconDir);
|
||||
} catch(err) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
var result = {files:results,icons:iconList};
|
||||
|
||||
var examplesDir = path.join(moduleDir,"examples");
|
||||
try {
|
||||
fs.statSync(examplesDir)
|
||||
result.examples = {path:examplesDir};
|
||||
// events.emit("node-examples-dir",{name:pkg.name,path:examplesDir});
|
||||
} catch(err) {
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function getNodeFiles(disableNodePathScan) {
|
||||
var dir;
|
||||
// Find all of the nodes to load
|
||||
var nodeFiles = [];
|
||||
var results;
|
||||
|
||||
var dir;
|
||||
var iconList = [];
|
||||
if (settings.coreNodesDir) {
|
||||
results = getLocalNodeFiles(path.resolve(settings.coreNodesDir));
|
||||
nodeFiles = nodeFiles.concat(results.files);
|
||||
iconList = iconList.concat(results.icons);
|
||||
var defaultLocalesPath = path.join(settings.coreNodesDir,"core","locales");
|
||||
i18n.registerMessageCatalog("node-red",defaultLocalesPath,"messages.json");
|
||||
}
|
||||
|
||||
if (settings.userDir) {
|
||||
dir = path.join(settings.userDir,"lib","icons");
|
||||
var icons = scanIconDir(dir);
|
||||
if (icons.length > 0) {
|
||||
iconList.push({path:dir,icons:icons});
|
||||
}
|
||||
|
||||
dir = path.join(settings.userDir,"nodes");
|
||||
results = getLocalNodeFiles(path.resolve(dir));
|
||||
nodeFiles = nodeFiles.concat(results.files);
|
||||
iconList = iconList.concat(results.icons);
|
||||
}
|
||||
if (settings.nodesDir) {
|
||||
dir = settings.nodesDir;
|
||||
if (typeof settings.nodesDir == "string") {
|
||||
dir = [dir];
|
||||
}
|
||||
for (var i=0;i<dir.length;i++) {
|
||||
results = getLocalNodeFiles(dir[i]);
|
||||
nodeFiles = nodeFiles.concat(results.files);
|
||||
iconList = iconList.concat(results.icons);
|
||||
}
|
||||
}
|
||||
|
||||
var nodeList = {
|
||||
"node-red": {
|
||||
name: "node-red",
|
||||
version: settings.version,
|
||||
nodes: {},
|
||||
icons: iconList
|
||||
}
|
||||
}
|
||||
nodeFiles.forEach(function(node) {
|
||||
nodeList["node-red"].nodes[node.name] = node;
|
||||
});
|
||||
|
||||
if (!disableNodePathScan) {
|
||||
var moduleFiles = scanTreeForNodesModules();
|
||||
moduleFiles.forEach(function(moduleFile) {
|
||||
var nodeModuleFiles = getModuleNodeFiles(moduleFile);
|
||||
nodeList[moduleFile.package.name] = {
|
||||
name: moduleFile.package.name,
|
||||
version: moduleFile.package.version,
|
||||
path: moduleFile.dir,
|
||||
local: moduleFile.local||false,
|
||||
nodes: {},
|
||||
icons: nodeModuleFiles.icons,
|
||||
examples: nodeModuleFiles.examples
|
||||
};
|
||||
if (moduleFile.package['node-red'].version) {
|
||||
nodeList[moduleFile.package.name].redVersion = moduleFile.package['node-red'].version;
|
||||
}
|
||||
nodeModuleFiles.files.forEach(function(node) {
|
||||
node.local = moduleFile.local||false;
|
||||
nodeList[moduleFile.package.name].nodes[node.name] = node;
|
||||
});
|
||||
nodeFiles = nodeFiles.concat(nodeModuleFiles.files);
|
||||
});
|
||||
} else {
|
||||
// console.log("node path scan disabled");
|
||||
}
|
||||
return nodeList;
|
||||
}
|
||||
|
||||
function getModuleFiles(module) {
|
||||
var nodeList = {};
|
||||
|
||||
var moduleFiles = scanTreeForNodesModules(module);
|
||||
if (moduleFiles.length === 0) {
|
||||
var err = new Error(log._("nodes.registry.localfilesystem.module-not-found", {module:module}));
|
||||
err.code = 'MODULE_NOT_FOUND';
|
||||
throw err;
|
||||
}
|
||||
|
||||
moduleFiles.forEach(function(moduleFile) {
|
||||
var nodeModuleFiles = getModuleNodeFiles(moduleFile);
|
||||
nodeList[moduleFile.package.name] = {
|
||||
name: moduleFile.package.name,
|
||||
version: moduleFile.package.version,
|
||||
nodes: {},
|
||||
icons: nodeModuleFiles.icons,
|
||||
examples: nodeModuleFiles.examples
|
||||
};
|
||||
if (moduleFile.package['node-red'].version) {
|
||||
nodeList[moduleFile.package.name].redVersion = moduleFile.package['node-red'].version;
|
||||
}
|
||||
nodeModuleFiles.files.forEach(function(node) {
|
||||
nodeList[moduleFile.package.name].nodes[node.name] = node;
|
||||
nodeList[moduleFile.package.name].nodes[node.name].local = moduleFile.local || false;
|
||||
});
|
||||
});
|
||||
return nodeList;
|
||||
}
|
||||
|
||||
function scanIconDir(dir) {
|
||||
var iconList = [];
|
||||
try {
|
||||
var files = fs.readdirSync(dir);
|
||||
files.forEach(function(file) {
|
||||
var stats = fs.statSync(path.join(dir, file));
|
||||
if (stats.isFile() && iconFileExtensions.indexOf(path.extname(file)) !== -1) {
|
||||
iconList.push(file);
|
||||
}
|
||||
});
|
||||
} catch(err) {
|
||||
}
|
||||
return iconList;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
init: init,
|
||||
getNodeFiles: getNodeFiles,
|
||||
getLocalFile: getLocalFile,
|
||||
getModuleFiles: getModuleFiles
|
||||
}
|
||||
640
packages/node_modules/@node-red/registry/lib/registry.js
generated
vendored
Normal file
640
packages/node_modules/@node-red/registry/lib/registry.js
generated
vendored
Normal file
@@ -0,0 +1,640 @@
|
||||
/**
|
||||
* 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.
|
||||
**/
|
||||
|
||||
//var UglifyJS = require("uglify-js");
|
||||
var path = require("path");
|
||||
var fs = require("fs");
|
||||
|
||||
var library = require("./library");
|
||||
|
||||
var events;
|
||||
var settings;
|
||||
var loader;
|
||||
|
||||
var nodeConfigCache = null;
|
||||
var moduleConfigs = {};
|
||||
var nodeList = [];
|
||||
var nodeConstructors = {};
|
||||
var nodeTypeToId = {};
|
||||
var moduleNodes = {};
|
||||
|
||||
function init(_settings,_loader, _events) {
|
||||
settings = _settings;
|
||||
loader = _loader;
|
||||
events = _events;
|
||||
moduleNodes = {};
|
||||
nodeTypeToId = {};
|
||||
nodeConstructors = {};
|
||||
nodeList = [];
|
||||
nodeConfigCache = null;
|
||||
}
|
||||
|
||||
function load() {
|
||||
if (settings.available()) {
|
||||
moduleConfigs = loadNodeConfigs();
|
||||
} else {
|
||||
moduleConfigs = {};
|
||||
}
|
||||
}
|
||||
|
||||
function filterNodeInfo(n) {
|
||||
var r = {
|
||||
id: n.id||n.module+"/"+n.name,
|
||||
name: n.name,
|
||||
types: n.types,
|
||||
enabled: n.enabled,
|
||||
local: n.local||false
|
||||
};
|
||||
if (n.hasOwnProperty("module")) {
|
||||
r.module = n.module;
|
||||
}
|
||||
if (n.hasOwnProperty("err")) {
|
||||
r.err = n.err;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
|
||||
function getModule(id) {
|
||||
var parts = id.split("/");
|
||||
return parts.slice(0,parts.length-1).join("/");
|
||||
}
|
||||
|
||||
function getNode(id) {
|
||||
var parts = id.split("/");
|
||||
return parts[parts.length-1];
|
||||
}
|
||||
|
||||
function saveNodeList() {
|
||||
var moduleList = {};
|
||||
var hadPending = false;
|
||||
var hasPending = false;
|
||||
for (var module in moduleConfigs) {
|
||||
/* istanbul ignore else */
|
||||
if (moduleConfigs.hasOwnProperty(module)) {
|
||||
if (Object.keys(moduleConfigs[module].nodes).length > 0) {
|
||||
if (!moduleList[module]) {
|
||||
moduleList[module] = {
|
||||
name: module,
|
||||
version: moduleConfigs[module].version,
|
||||
local: moduleConfigs[module].local||false,
|
||||
nodes: {}
|
||||
};
|
||||
if (moduleConfigs[module].hasOwnProperty('pending_version')) {
|
||||
hadPending = true;
|
||||
if (moduleConfigs[module].pending_version !== moduleConfigs[module].version) {
|
||||
moduleList[module].pending_version = moduleConfigs[module].pending_version;
|
||||
hasPending = true;
|
||||
} else {
|
||||
delete moduleConfigs[module].pending_version;
|
||||
}
|
||||
}
|
||||
}
|
||||
var nodes = moduleConfigs[module].nodes;
|
||||
for(var node in nodes) {
|
||||
/* istanbul ignore else */
|
||||
if (nodes.hasOwnProperty(node)) {
|
||||
var config = nodes[node];
|
||||
var n = filterNodeInfo(config);
|
||||
delete n.err;
|
||||
delete n.file;
|
||||
delete n.id;
|
||||
n.file = config.file;
|
||||
moduleList[module].nodes[node] = n;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (hadPending && !hasPending) {
|
||||
events.emit("runtime-event",{id:"restart-required",retain: true});
|
||||
}
|
||||
if (settings.available()) {
|
||||
return settings.set("nodes",moduleList);
|
||||
} else {
|
||||
return Promise.reject("Settings unavailable");
|
||||
}
|
||||
}
|
||||
|
||||
function loadNodeConfigs() {
|
||||
var configs = settings.get("nodes");
|
||||
|
||||
if (!configs) {
|
||||
return {};
|
||||
} else if (configs['node-red']) {
|
||||
return configs;
|
||||
} else {
|
||||
// Migrate from the 0.9.1 format of settings
|
||||
var newConfigs = {};
|
||||
for (var id in configs) {
|
||||
/* istanbul ignore else */
|
||||
if (configs.hasOwnProperty(id)) {
|
||||
var nodeConfig = configs[id];
|
||||
var moduleName;
|
||||
var nodeSetName;
|
||||
|
||||
if (nodeConfig.module) {
|
||||
moduleName = nodeConfig.module;
|
||||
nodeSetName = nodeConfig.name.split(":")[1];
|
||||
} else {
|
||||
moduleName = "node-red";
|
||||
nodeSetName = nodeConfig.name.replace(/^\d+-/,"").replace(/\.js$/,"");
|
||||
}
|
||||
|
||||
if (!newConfigs[moduleName]) {
|
||||
newConfigs[moduleName] = {
|
||||
name: moduleName,
|
||||
nodes:{}
|
||||
};
|
||||
}
|
||||
newConfigs[moduleName].nodes[nodeSetName] = {
|
||||
name: nodeSetName,
|
||||
types: nodeConfig.types,
|
||||
enabled: nodeConfig.enabled,
|
||||
module: moduleName
|
||||
};
|
||||
}
|
||||
}
|
||||
settings.set("nodes",newConfigs);
|
||||
return newConfigs;
|
||||
}
|
||||
}
|
||||
|
||||
function addModule(module) {
|
||||
moduleNodes[module.name] = [];
|
||||
moduleConfigs[module.name] = module;
|
||||
for (var setName in module.nodes) {
|
||||
if (module.nodes.hasOwnProperty(setName)) {
|
||||
var set = module.nodes[setName];
|
||||
moduleNodes[module.name].push(set.name);
|
||||
nodeList.push(set.id);
|
||||
if (!set.err) {
|
||||
set.types.forEach(function(t) {
|
||||
if (nodeTypeToId.hasOwnProperty(t)) {
|
||||
set.err = "Type already registered";
|
||||
set.err.code = "type_already_registered";
|
||||
set.err.details = {
|
||||
type: t,
|
||||
moduleA: getNodeInfo(t).module,
|
||||
moduleB: set.module
|
||||
}
|
||||
|
||||
}
|
||||
});
|
||||
if (!set.err) {
|
||||
set.types.forEach(function(t) {
|
||||
nodeTypeToId[t] = set.id;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (module.icons) {
|
||||
icon_paths[module.name] = icon_paths[module.name] || [];
|
||||
module.icons.forEach(icon=>icon_paths[module.name].push(path.resolve(icon.path)) )
|
||||
}
|
||||
if (module.examples) {
|
||||
library.addExamplesDir(module.name,module.examples.path);
|
||||
}
|
||||
nodeConfigCache = null;
|
||||
}
|
||||
|
||||
|
||||
function removeNode(id) {
|
||||
var config = moduleConfigs[getModule(id)].nodes[getNode(id)];
|
||||
if (!config) {
|
||||
throw new Error("Unrecognised id: "+id);
|
||||
}
|
||||
delete moduleConfigs[getModule(id)].nodes[getNode(id)];
|
||||
var i = nodeList.indexOf(id);
|
||||
if (i > -1) {
|
||||
nodeList.splice(i,1);
|
||||
}
|
||||
config.types.forEach(function(t) {
|
||||
var typeId = nodeTypeToId[t];
|
||||
if (typeId === id) {
|
||||
delete nodeConstructors[t];
|
||||
delete nodeTypeToId[t];
|
||||
}
|
||||
});
|
||||
config.enabled = false;
|
||||
config.loaded = false;
|
||||
nodeConfigCache = null;
|
||||
return filterNodeInfo(config);
|
||||
}
|
||||
|
||||
function removeModule(module) {
|
||||
if (!settings.available()) {
|
||||
throw new Error("Settings unavailable");
|
||||
}
|
||||
var nodes = moduleNodes[module];
|
||||
if (!nodes) {
|
||||
throw new Error("Unrecognised module: "+module);
|
||||
}
|
||||
var infoList = [];
|
||||
for (var i=0;i<nodes.length;i++) {
|
||||
infoList.push(removeNode(module+"/"+nodes[i]));
|
||||
}
|
||||
delete moduleNodes[module];
|
||||
delete moduleConfigs[module];
|
||||
saveNodeList();
|
||||
return infoList;
|
||||
}
|
||||
|
||||
function getNodeInfo(typeOrId) {
|
||||
var id = typeOrId;
|
||||
if (nodeTypeToId.hasOwnProperty(typeOrId)) {
|
||||
id = nodeTypeToId[typeOrId];
|
||||
}
|
||||
/* istanbul ignore else */
|
||||
if (id) {
|
||||
var module = moduleConfigs[getModule(id)];
|
||||
if (module) {
|
||||
var config = module.nodes[getNode(id)];
|
||||
if (config) {
|
||||
var info = filterNodeInfo(config);
|
||||
if (config.hasOwnProperty("loaded")) {
|
||||
info.loaded = config.loaded;
|
||||
}
|
||||
info.version = module.version;
|
||||
return info;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function getFullNodeInfo(typeOrId) {
|
||||
// Used by index.enableNodeSet so that .file can be retrieved to pass
|
||||
// to loader.loadNodeSet
|
||||
var id = typeOrId;
|
||||
if (nodeTypeToId.hasOwnProperty(typeOrId)) {
|
||||
id = nodeTypeToId[typeOrId];
|
||||
}
|
||||
/* istanbul ignore else */
|
||||
if (id) {
|
||||
var module = moduleConfigs[getModule(id)];
|
||||
if (module) {
|
||||
return module.nodes[getNode(id)];
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function getNodeList(filter) {
|
||||
var list = [];
|
||||
for (var module in moduleConfigs) {
|
||||
/* istanbul ignore else */
|
||||
if (moduleConfigs.hasOwnProperty(module)) {
|
||||
var nodes = moduleConfigs[module].nodes;
|
||||
for (var node in nodes) {
|
||||
/* istanbul ignore else */
|
||||
if (nodes.hasOwnProperty(node)) {
|
||||
var nodeInfo = filterNodeInfo(nodes[node]);
|
||||
nodeInfo.version = moduleConfigs[module].version;
|
||||
if (moduleConfigs[module].pending_version) {
|
||||
nodeInfo.pending_version = moduleConfigs[module].pending_version;
|
||||
}
|
||||
if (!filter || filter(nodes[node])) {
|
||||
list.push(nodeInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
function getModuleList() {
|
||||
//var list = [];
|
||||
//for (var module in moduleNodes) {
|
||||
// /* istanbul ignore else */
|
||||
// if (moduleNodes.hasOwnProperty(module)) {
|
||||
// list.push(registry.getModuleInfo(module));
|
||||
// }
|
||||
//}
|
||||
//return list;
|
||||
return moduleConfigs;
|
||||
|
||||
}
|
||||
|
||||
function getModuleInfo(module) {
|
||||
if (moduleNodes[module]) {
|
||||
var nodes = moduleNodes[module];
|
||||
var m = {
|
||||
name: module,
|
||||
version: moduleConfigs[module].version,
|
||||
local: moduleConfigs[module].local,
|
||||
path: moduleConfigs[module].path,
|
||||
nodes: []
|
||||
};
|
||||
for (var i = 0; i < nodes.length; ++i) {
|
||||
var nodeInfo = filterNodeInfo(moduleConfigs[module].nodes[nodes[i]]);
|
||||
nodeInfo.version = m.version;
|
||||
m.nodes.push(nodeInfo);
|
||||
}
|
||||
return m;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function getCaller(){
|
||||
var orig = Error.prepareStackTrace;
|
||||
Error.prepareStackTrace = function(_, stack){ return stack; };
|
||||
var err = new Error();
|
||||
Error.captureStackTrace(err, arguments.callee);
|
||||
var stack = err.stack;
|
||||
Error.prepareStackTrace = orig;
|
||||
stack.shift();
|
||||
stack.shift();
|
||||
return stack[0].getFileName();
|
||||
}
|
||||
|
||||
function registerNodeConstructor(nodeSet,type,constructor) {
|
||||
if (nodeConstructors.hasOwnProperty(type)) {
|
||||
throw new Error(type+" already registered");
|
||||
}
|
||||
//TODO: Ensure type is known - but doing so will break some tests
|
||||
// that don't have a way to register a node template ahead
|
||||
// of registering the constructor
|
||||
|
||||
var nodeSetInfo = getFullNodeInfo(nodeSet);
|
||||
if (nodeSetInfo) {
|
||||
if (nodeSetInfo.types.indexOf(type) === -1) {
|
||||
// A type is being registered for a known set, but for some reason
|
||||
// we didn't spot it when parsing the HTML file.
|
||||
// Registered a type is the definitive action - not the presence
|
||||
// of an edit template. Ensure it is on the list of known types.
|
||||
nodeSetInfo.types.push(type);
|
||||
}
|
||||
}
|
||||
|
||||
nodeConstructors[type] = constructor;
|
||||
events.emit("type-registered",type);
|
||||
}
|
||||
|
||||
function getAllNodeConfigs(lang) {
|
||||
if (!nodeConfigCache) {
|
||||
var result = "";
|
||||
var script = "";
|
||||
for (var i=0;i<nodeList.length;i++) {
|
||||
var id = nodeList[i];
|
||||
var config = moduleConfigs[getModule(id)].nodes[getNode(id)];
|
||||
if (config.enabled && !config.err) {
|
||||
result += "\n<!-- --- [red-module:"+id+"] --- -->\n";
|
||||
result += config.config;
|
||||
result += loader.getNodeHelp(config,lang||"en-US")||"";
|
||||
//script += config.script;
|
||||
}
|
||||
}
|
||||
//if (script.length > 0) {
|
||||
// result += '<script type="text/javascript">';
|
||||
// result += UglifyJS.minify(script, {fromString: true}).code;
|
||||
// result += '</script>';
|
||||
//}
|
||||
nodeConfigCache = result;
|
||||
}
|
||||
return nodeConfigCache;
|
||||
}
|
||||
|
||||
function getNodeConfig(id,lang) {
|
||||
var config = moduleConfigs[getModule(id)];
|
||||
if (!config) {
|
||||
return null;
|
||||
}
|
||||
config = config.nodes[getNode(id)];
|
||||
if (config) {
|
||||
var result = "<!-- --- [red-module:"+id+"] --- -->\n"+config.config;
|
||||
result += loader.getNodeHelp(config,lang||"en-US")
|
||||
|
||||
//if (config.script) {
|
||||
// result += '<script type="text/javascript">'+config.script+'</script>';
|
||||
//}
|
||||
return result;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function getNodeConstructor(type) {
|
||||
var id = nodeTypeToId[type];
|
||||
|
||||
var config;
|
||||
if (typeof id === "undefined") {
|
||||
config = undefined;
|
||||
} else {
|
||||
config = moduleConfigs[getModule(id)].nodes[getNode(id)];
|
||||
}
|
||||
|
||||
if (!config || (config.enabled && !config.err)) {
|
||||
return nodeConstructors[type];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function clear() {
|
||||
nodeConfigCache = null;
|
||||
moduleConfigs = {};
|
||||
nodeList = [];
|
||||
nodeConstructors = {};
|
||||
nodeTypeToId = {};
|
||||
}
|
||||
|
||||
function getTypeId(type) {
|
||||
if (nodeTypeToId.hasOwnProperty(type)) {
|
||||
return nodeTypeToId[type];
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function enableNodeSet(typeOrId) {
|
||||
if (!settings.available()) {
|
||||
throw new Error("Settings unavailable");
|
||||
}
|
||||
|
||||
var id = typeOrId;
|
||||
if (nodeTypeToId.hasOwnProperty(typeOrId)) {
|
||||
id = nodeTypeToId[typeOrId];
|
||||
}
|
||||
var config;
|
||||
try {
|
||||
config = moduleConfigs[getModule(id)].nodes[getNode(id)];
|
||||
delete config.err;
|
||||
config.enabled = true;
|
||||
nodeConfigCache = null;
|
||||
settings.enableNodeSettings(config.types);
|
||||
return saveNodeList().then(function() {
|
||||
return filterNodeInfo(config);
|
||||
});
|
||||
} catch (err) {
|
||||
throw new Error("Unrecognised id: "+typeOrId);
|
||||
}
|
||||
}
|
||||
|
||||
function disableNodeSet(typeOrId) {
|
||||
if (!settings.available()) {
|
||||
throw new Error("Settings unavailable");
|
||||
}
|
||||
var id = typeOrId;
|
||||
if (nodeTypeToId.hasOwnProperty(typeOrId)) {
|
||||
id = nodeTypeToId[typeOrId];
|
||||
}
|
||||
var config;
|
||||
try {
|
||||
config = moduleConfigs[getModule(id)].nodes[getNode(id)];
|
||||
// TODO: persist setting
|
||||
config.enabled = false;
|
||||
nodeConfigCache = null;
|
||||
settings.disableNodeSettings(config.types);
|
||||
return saveNodeList().then(function() {
|
||||
return filterNodeInfo(config);
|
||||
});
|
||||
} catch (err) {
|
||||
throw new Error("Unrecognised id: "+id);
|
||||
}
|
||||
}
|
||||
|
||||
function cleanModuleList() {
|
||||
var removed = false;
|
||||
for (var mod in moduleConfigs) {
|
||||
/* istanbul ignore else */
|
||||
if (moduleConfigs.hasOwnProperty(mod)) {
|
||||
var nodes = moduleConfigs[mod].nodes;
|
||||
var node;
|
||||
if (mod == "node-red") {
|
||||
// For core nodes, look for nodes that are enabled, !loaded and !errored
|
||||
for (node in nodes) {
|
||||
/* istanbul ignore else */
|
||||
if (nodes.hasOwnProperty(node)) {
|
||||
var n = nodes[node];
|
||||
if (n.enabled && !n.err && !n.loaded) {
|
||||
removeNode(mod+"/"+node);
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (moduleConfigs[mod] && !moduleNodes[mod]) {
|
||||
// For node modules, look for missing ones
|
||||
for (node in nodes) {
|
||||
/* istanbul ignore else */
|
||||
if (nodes.hasOwnProperty(node)) {
|
||||
removeNode(mod+"/"+node);
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
delete moduleConfigs[mod];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (removed) {
|
||||
saveNodeList();
|
||||
}
|
||||
}
|
||||
function setModulePendingUpdated(module,version) {
|
||||
moduleConfigs[module].pending_version = version;
|
||||
return saveNodeList().then(function() {
|
||||
return getModuleInfo(module);
|
||||
});
|
||||
}
|
||||
|
||||
var icon_paths = { };
|
||||
var iconCache = {};
|
||||
|
||||
function getNodeIconPath(module,icon) {
|
||||
if (/\.\./.test(icon)) {
|
||||
throw new Error();
|
||||
}
|
||||
var iconName = module+"/"+icon;
|
||||
if (iconCache[iconName]) {
|
||||
return iconCache[iconName];
|
||||
} else {
|
||||
var paths = icon_paths[module];
|
||||
if (paths) {
|
||||
for (var p=0;p<paths.length;p++) {
|
||||
var iconPath = path.join(paths[p],icon);
|
||||
try {
|
||||
fs.statSync(iconPath);
|
||||
iconCache[iconName] = iconPath;
|
||||
return iconPath;
|
||||
} catch(err) {
|
||||
// iconPath doesn't exist
|
||||
}
|
||||
}
|
||||
}
|
||||
if (module !== "node-red") {
|
||||
return getNodeIconPath("node-red", icon);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function getNodeIcons() {
|
||||
var iconList = {};
|
||||
|
||||
for (var module in moduleConfigs) {
|
||||
if (moduleConfigs.hasOwnProperty(module)) {
|
||||
if (moduleConfigs[module].icons) {
|
||||
iconList[module] = [];
|
||||
moduleConfigs[module].icons.forEach(icon=>{ iconList[module] = iconList[module].concat(icon.icons)})
|
||||
}
|
||||
}
|
||||
}
|
||||
return iconList;
|
||||
}
|
||||
|
||||
var registry = module.exports = {
|
||||
init: init,
|
||||
load: load,
|
||||
clear: clear,
|
||||
|
||||
registerNodeConstructor: registerNodeConstructor,
|
||||
getNodeConstructor: getNodeConstructor,
|
||||
|
||||
|
||||
addModule: addModule,
|
||||
|
||||
enableNodeSet: enableNodeSet,
|
||||
disableNodeSet: disableNodeSet,
|
||||
|
||||
setModulePendingUpdated: setModulePendingUpdated,
|
||||
removeModule: removeModule,
|
||||
|
||||
getNodeInfo: getNodeInfo,
|
||||
getFullNodeInfo: getFullNodeInfo,
|
||||
getNodeList: getNodeList,
|
||||
getModuleList: getModuleList,
|
||||
getModuleInfo: getModuleInfo,
|
||||
|
||||
getNodeIconPath: getNodeIconPath,
|
||||
getNodeIcons: getNodeIcons,
|
||||
/**
|
||||
* Gets all of the node template configs
|
||||
* @return all of the node templates in a single string
|
||||
*/
|
||||
getAllNodeConfigs: getAllNodeConfigs,
|
||||
getNodeConfig: getNodeConfig,
|
||||
|
||||
getTypeId: getTypeId,
|
||||
|
||||
saveNodeList: saveNodeList,
|
||||
|
||||
cleanModuleList: cleanModuleList
|
||||
};
|
||||
Reference in New Issue
Block a user