mirror of
https://github.com/node-red/node-red.git
synced 2025-03-01 10:36:34 +00:00
Merge branch 'dev' into 4219-missing-error-logging-for-config-nodes
This commit is contained in:
bvmensvoort
@@ -89,10 +89,16 @@ var api = module.exports = {
|
||||
|
||||
if (!runtime.settings.disableEditor) {
|
||||
safeSettings.context = runtime.nodes.listContextStores();
|
||||
if (runtime.settings.editorTheme && runtime.settings.editorTheme.codeEditor) {
|
||||
safeSettings.codeEditor = runtime.settings.editorTheme.codeEditor || {};
|
||||
safeSettings.codeEditor.lib = safeSettings.codeEditor.lib || "monaco";
|
||||
safeSettings.codeEditor.options = safeSettings.codeEditor.options || {};
|
||||
if (runtime.settings.editorTheme) {
|
||||
if (runtime.settings.editorTheme.codeEditor) {
|
||||
safeSettings.codeEditor = runtime.settings.editorTheme.codeEditor || {};
|
||||
safeSettings.codeEditor.lib = safeSettings.codeEditor.lib || "monaco";
|
||||
safeSettings.codeEditor.options = safeSettings.codeEditor.options || {};
|
||||
}
|
||||
if (runtime.settings.editorTheme.markdownEditor) {
|
||||
safeSettings.markdownEditor = runtime.settings.editorTheme.markdownEditor || {};
|
||||
safeSettings.markdownEditor.mermaid = safeSettings.markdownEditor.mermaid || { enabled: true };
|
||||
}
|
||||
}
|
||||
safeSettings.libraries = runtime.library.getLibraries();
|
||||
if (util.isArray(runtime.settings.paletteCategories)) {
|
||||
|
||||
@@ -416,23 +416,50 @@ class Flow {
|
||||
return this.activeNodes;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Get value of environment variable defined in group node.
|
||||
* @param {String} group - group node
|
||||
* @param {String} name - name of variable
|
||||
* @return {Object} object containing the value in val property or null if not defined
|
||||
|
||||
/**
|
||||
* Group callback signature
|
||||
*
|
||||
* @callback GroupEnvCallback
|
||||
* @param {Error} err The error object (or null)
|
||||
* @param {[result: {val:Any}, name: String]} result The result of the callback
|
||||
* @returns {void}
|
||||
*/
|
||||
getGroupEnvSetting(node, group, name) {
|
||||
|
||||
/**
|
||||
* @function getGroupEnvSetting
|
||||
* Get a group setting value synchronously.
|
||||
* This currently automatically defers to the parent
|
||||
* @overload
|
||||
* @param {Object} node
|
||||
* @param {Object} group
|
||||
* @param {String} name
|
||||
* @returns {Any}
|
||||
*
|
||||
* Get a group setting value asynchronously.
|
||||
* @overload
|
||||
* @param {Object} node
|
||||
* @param {Object} group
|
||||
* @param {String} name
|
||||
* @param {GroupEnvCallback} callback
|
||||
* @returns {void}
|
||||
*/
|
||||
|
||||
getGroupEnvSetting(node, group, name, callback) {
|
||||
/** @type {GroupEnvCallback} */
|
||||
const returnOrCallback = (err, [result, newName]) => {
|
||||
if (callback) {
|
||||
callback(err, [result, newName]);
|
||||
return
|
||||
}
|
||||
return [result, newName];
|
||||
}
|
||||
if (group) {
|
||||
if (name === "NR_GROUP_NAME") {
|
||||
return [{
|
||||
val: group.name
|
||||
}, null];
|
||||
return returnOrCallback(null, [{ val: group.name }, null]);
|
||||
}
|
||||
if (name === "NR_GROUP_ID") {
|
||||
return [{
|
||||
val: group.id
|
||||
}, null];
|
||||
return returnOrCallback(null, [{ val: group.id }, null]);
|
||||
}
|
||||
|
||||
if (group.credentials === undefined) {
|
||||
@@ -457,33 +484,32 @@ class Flow {
|
||||
if (env) {
|
||||
let value = env.value;
|
||||
const type = env.type;
|
||||
if ((type !== "env") ||
|
||||
(value !== name)) {
|
||||
if ((type !== "env") || (value !== name)) {
|
||||
if (type === "env") {
|
||||
value = value.replace(new RegExp("\\${"+name+"}","g"),"${$parent."+name+"}");
|
||||
}
|
||||
if (type === "bool") {
|
||||
const val
|
||||
= ((value === "true") ||
|
||||
(value === true));
|
||||
return [{
|
||||
val: val
|
||||
}, null];
|
||||
} else if (type === "bool") {
|
||||
const val = ((value === "true") || (value === true));
|
||||
return returnOrCallback(null, [{ val: val }, null])
|
||||
}
|
||||
if (type === "cred") {
|
||||
return [{
|
||||
val: value
|
||||
}, null];
|
||||
return returnOrCallback(null, [{ val: value }, null])
|
||||
}
|
||||
try {
|
||||
var val = redUtil.evaluateNodeProperty(value, type, node, null, null);
|
||||
return [{
|
||||
val: val
|
||||
}, null];
|
||||
if (!callback) {
|
||||
var val = redUtil.evaluateNodeProperty(value, type, node, null, null);
|
||||
return [{ val: val }, null];
|
||||
} else {
|
||||
redUtil.evaluateNodeProperty(value, type, node, null, (err, value) => {
|
||||
return returnOrCallback(err, [{ val: value }, null])
|
||||
});
|
||||
return
|
||||
}
|
||||
}
|
||||
catch (e) {
|
||||
this.error(e);
|
||||
return [null, null];
|
||||
if (!callback) {
|
||||
this.error(e);
|
||||
}
|
||||
return returnOrCallback(e, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -494,27 +520,47 @@ class Flow {
|
||||
}
|
||||
if (group.g) {
|
||||
const parent = this.getGroupNode(group.g);
|
||||
return this.getGroupEnvSetting(node, parent, name);
|
||||
const gVal = this.getGroupEnvSetting(node, parent, name, callback);
|
||||
if (callback) {
|
||||
return;
|
||||
}
|
||||
return gVal;
|
||||
}
|
||||
}
|
||||
return [null, name];
|
||||
return returnOrCallback(null, [null, name]);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Settings callback signature
|
||||
*
|
||||
* @callback SettingsCallback
|
||||
* @param {Error} err The error object (or null)
|
||||
* @param {Any} result The result of the callback
|
||||
* @returns {void}
|
||||
*/
|
||||
/**
|
||||
* Get a flow setting value. This currently automatically defers to the parent
|
||||
* flow which, as defined in ./index.js returns `process.env[key]`.
|
||||
* This lays the groundwork for Subflow to have instance-specific settings
|
||||
* @param {[type]} key [description]
|
||||
* @return {[type]} [description]
|
||||
* @param {String} key The settings key
|
||||
* @param {SettingsCallback} callback Optional callback function
|
||||
* @return {Any}
|
||||
*/
|
||||
getSetting(key) {
|
||||
getSetting(key, callback) {
|
||||
/** @type {SettingsCallback} */
|
||||
const returnOrCallback = (err, result) => {
|
||||
if (callback) {
|
||||
callback(err, result);
|
||||
return
|
||||
}
|
||||
return result;
|
||||
}
|
||||
const flow = this.flow;
|
||||
if (key === "NR_FLOW_NAME") {
|
||||
return flow.label;
|
||||
return returnOrCallback(null, flow.label);
|
||||
}
|
||||
if (key === "NR_FLOW_ID") {
|
||||
return flow.id;
|
||||
return returnOrCallback(null, flow.id);
|
||||
}
|
||||
if (flow.credentials === undefined) {
|
||||
flow.credentials = credentials.get(flow.id) || {};
|
||||
@@ -544,15 +590,14 @@ class Flow {
|
||||
}
|
||||
try {
|
||||
if (type === "bool") {
|
||||
const val = ((value === "true") ||
|
||||
(value === true));
|
||||
return val;
|
||||
const val = ((value === "true") || (value === true));
|
||||
return returnOrCallback(null, val);
|
||||
}
|
||||
if (type === "cred") {
|
||||
return value;
|
||||
return returnOrCallback(null, value);
|
||||
}
|
||||
var val = redUtil.evaluateNodeProperty(value, type, null, null, null);
|
||||
return val;
|
||||
return returnOrCallback(null, val);
|
||||
}
|
||||
catch (e) {
|
||||
this.error(e);
|
||||
@@ -564,7 +609,11 @@ class Flow {
|
||||
key = key.substring(8);
|
||||
}
|
||||
}
|
||||
return this.parent.getSetting(key);
|
||||
const pVal = this.parent.getSetting(key, callback);
|
||||
if (callback) {
|
||||
return;
|
||||
}
|
||||
return pVal;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -605,10 +654,36 @@ class Flow {
|
||||
}
|
||||
}
|
||||
} else {
|
||||
this.statusNodes.forEach(function(targetStatusNode) {
|
||||
if (targetStatusNode.scope && targetStatusNode.scope.indexOf(reportingNode.id) === -1) {
|
||||
const candidateNodes = [];
|
||||
this.statusNodes.forEach(targetStatusNode => {
|
||||
if (targetStatusNode.g && targetStatusNode.scope === 'group' && !reportingNode.g) {
|
||||
// Status node inside a group, reporting node not in a group - skip it
|
||||
return
|
||||
}
|
||||
if (Array.isArray(targetStatusNode.scope) && targetStatusNode.scope.indexOf(reportingNode.id) === -1) {
|
||||
return;
|
||||
}
|
||||
let distance = 0
|
||||
if (reportingNode.g) {
|
||||
// Reporting node inside a group. Calculate the distance between it and the status node
|
||||
let containingGroup = this.global.groups[reportingNode.g]
|
||||
while (containingGroup && containingGroup.id !== targetStatusNode.g) {
|
||||
distance++
|
||||
containingGroup = this.global.groups[containingGroup.g]
|
||||
}
|
||||
if (!containingGroup && targetStatusNode.g && targetStatusNode.scope === 'group') {
|
||||
// This status node is in a group, but not in the same hierachy
|
||||
// the reporting node is in
|
||||
return
|
||||
}
|
||||
}
|
||||
candidateNodes.push({ d: distance, n: targetStatusNode })
|
||||
})
|
||||
candidateNodes.sort((A,B) => {
|
||||
return A.d - B.d
|
||||
})
|
||||
candidateNodes.forEach(candidate => {
|
||||
const targetStatusNode = candidate.n
|
||||
var message = {
|
||||
status: clone(statusMessage)
|
||||
}
|
||||
@@ -665,21 +740,46 @@ class Flow {
|
||||
}
|
||||
}
|
||||
} else {
|
||||
var handledByUncaught = false;
|
||||
|
||||
this.catchNodes.forEach(function(targetCatchNode) {
|
||||
if (targetCatchNode.scope && targetCatchNode.scope.indexOf(reportingNode.id) === -1) {
|
||||
const candidateNodes = [];
|
||||
this.catchNodes.forEach(targetCatchNode => {
|
||||
if (targetCatchNode.g && targetCatchNode.scope === 'group' && !reportingNode.g) {
|
||||
// Catch node inside a group, reporting node not in a group - skip it
|
||||
return
|
||||
}
|
||||
if (Array.isArray(targetCatchNode.scope) && targetCatchNode.scope.indexOf(reportingNode.id) === -1) {
|
||||
// Catch node has a scope set and it doesn't include the reporting node
|
||||
return;
|
||||
}
|
||||
if (!targetCatchNode.scope && targetCatchNode.uncaught && !handledByUncaught) {
|
||||
if (handled) {
|
||||
// This has been handled by a !uncaught catch node
|
||||
return;
|
||||
let distance = 0
|
||||
if (reportingNode.g) {
|
||||
// Reporting node inside a group. Calculate the distance between it and the catch node
|
||||
let containingGroup = this.global.groups[reportingNode.g]
|
||||
while (containingGroup && containingGroup.id !== targetCatchNode.g) {
|
||||
distance++
|
||||
containingGroup = this.global.groups[containingGroup.g]
|
||||
}
|
||||
if (!containingGroup && targetCatchNode.g && targetCatchNode.scope === 'group') {
|
||||
// This catch node is in a group, but not in the same hierachy
|
||||
// the reporting node is in
|
||||
return
|
||||
}
|
||||
// This is an uncaught error
|
||||
handledByUncaught = true;
|
||||
}
|
||||
var errorMessage;
|
||||
candidateNodes.push({ d: distance, n: targetCatchNode })
|
||||
})
|
||||
candidateNodes.sort((A,B) => {
|
||||
return A.d - B.d
|
||||
})
|
||||
let handledByUncaught = false
|
||||
candidateNodes.forEach(candidate => {
|
||||
const targetCatchNode = candidate.n
|
||||
if (targetCatchNode.uncaught && !handledByUncaught) {
|
||||
// This node only wants errors that haven't already been handled
|
||||
if (handled) {
|
||||
return
|
||||
}
|
||||
handledByUncaught = true
|
||||
}
|
||||
let errorMessage;
|
||||
if (msg) {
|
||||
errorMessage = redUtil.cloneMessage(msg);
|
||||
} else {
|
||||
|
||||
@@ -474,7 +474,7 @@ class Subflow extends Flow {
|
||||
*/
|
||||
function createNodeInSubflow(subflowInstanceId, def) {
|
||||
let node = clone(def);
|
||||
let nid = redUtil.generateId();
|
||||
let nid = `${subflowInstanceId}-${node.id}` //redUtil.generateId();
|
||||
// console.log("Create Node In subflow",node._alias, "--->",nid, "(",node.type,")")
|
||||
// node_map[node.id] = node;
|
||||
node._alias = node.id;
|
||||
|
||||
@@ -780,11 +780,21 @@ const flowAPI = {
|
||||
getNode: getNode,
|
||||
handleError: () => false,
|
||||
handleStatus: () => false,
|
||||
getSetting: k => flowUtil.getEnvVar(k),
|
||||
getSetting: (k, callback) => flowUtil.getEnvVar(k, callback),
|
||||
log: m => log.log(m)
|
||||
}
|
||||
|
||||
|
||||
function getGlobalConfig() {
|
||||
let gconf = null;
|
||||
eachNode((n) => {
|
||||
if (n.type === "global-config") {
|
||||
gconf = n;
|
||||
}
|
||||
});
|
||||
return gconf;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
init: init,
|
||||
|
||||
@@ -798,6 +808,9 @@ module.exports = {
|
||||
get:getNode,
|
||||
eachNode: eachNode,
|
||||
|
||||
|
||||
getGlobalConfig: getGlobalConfig,
|
||||
|
||||
/**
|
||||
* Gets the current flow configuration
|
||||
*/
|
||||
|
||||
@@ -18,7 +18,9 @@ var redUtil = require("@node-red/util").util;
|
||||
var Log = require("@node-red/util").log;
|
||||
var subflowInstanceRE = /^subflow:(.+)$/;
|
||||
var typeRegistry = require("@node-red/registry");
|
||||
const credentials = require("../nodes/credentials");
|
||||
|
||||
let _runtime = null;
|
||||
|
||||
var envVarExcludes = {};
|
||||
|
||||
@@ -267,15 +269,73 @@ function parseConfig(config) {
|
||||
return flow;
|
||||
}
|
||||
|
||||
function getGlobalEnv(name) {
|
||||
const nodes = _runtime.nodes;
|
||||
if (!nodes) {
|
||||
return null;
|
||||
}
|
||||
const gconf = nodes.getGlobalConfig();
|
||||
const env = gconf ? gconf.env : null;
|
||||
|
||||
if (env) {
|
||||
const cred = (gconf ? credentials.get(gconf.id) : null) || {
|
||||
map: {}
|
||||
};
|
||||
const map = cred.map;
|
||||
|
||||
for (let i = 0; i < env.length; i++) {
|
||||
const item = env[i];
|
||||
if (item.name === name) {
|
||||
if (item.type === "cred") {
|
||||
return {
|
||||
name: name,
|
||||
value: map[name],
|
||||
type: "cred"
|
||||
};
|
||||
}
|
||||
return item;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
init: function(runtime) {
|
||||
_runtime = runtime;
|
||||
envVarExcludes = {};
|
||||
if (runtime.settings.hasOwnProperty('envVarExcludes') && Array.isArray(runtime.settings.envVarExcludes)) {
|
||||
runtime.settings.envVarExcludes.forEach(v => envVarExcludes[v] = true);
|
||||
}
|
||||
},
|
||||
getEnvVar: function(k) {
|
||||
return !envVarExcludes[k]?process.env[k]:undefined
|
||||
/**
|
||||
* Get the value of an environment variable
|
||||
* Call with a callback to get the value asynchronously
|
||||
* or without to get the value synchronously
|
||||
* @param {String} key The name of the environment variable
|
||||
* @param {(err: Error, val: Any)} [callback] Optional callback for asynchronous call
|
||||
* @returns {Any | void} The value of the environment variable or undefined if not found
|
||||
*/
|
||||
getEnvVar: function(key, callback) {
|
||||
const returnOrCallback = function(err, val) {
|
||||
if (callback) {
|
||||
callback(err, val);
|
||||
return;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
if (!envVarExcludes[key]) {
|
||||
const item = getGlobalEnv(key);
|
||||
if (item) {
|
||||
const val = redUtil.evaluateNodeProperty(item.value, item.type, null, null, callback);
|
||||
if (callback) {
|
||||
return;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
return returnOrCallback(null, process.env[key]);
|
||||
}
|
||||
return returnOrCallback(undefined);
|
||||
},
|
||||
diffNodes: diffNodes,
|
||||
mapEnvVarProperties: mapEnvVarProperties,
|
||||
|
||||
@@ -89,6 +89,15 @@ function init(userSettings,httpServer,_adminApi) {
|
||||
|
||||
nodeApp = express();
|
||||
adminApp = express();
|
||||
const defaultServerSettings = {
|
||||
"x-powered-by": false
|
||||
}
|
||||
const serverSettings = Object.assign({},defaultServerSettings,userSettings.httpServerOptions||{});
|
||||
for (let eOption in serverSettings) {
|
||||
nodeApp.set(eOption, serverSettings[eOption]);
|
||||
adminApp.set(eOption, serverSettings[eOption]);
|
||||
}
|
||||
|
||||
|
||||
if (_adminApi) {
|
||||
adminApi = _adminApi;
|
||||
|
||||
@@ -589,17 +589,28 @@ function deleteContext(id,flowId) {
|
||||
* If flowConfig is undefined, all flow/node contexts will be removed
|
||||
**/
|
||||
function clean(flowConfig) {
|
||||
flowConfig = flowConfig || { allNodes: {} };
|
||||
var promises = [];
|
||||
for(var plugin in stores){
|
||||
if(stores.hasOwnProperty(plugin)){
|
||||
promises.push(stores[plugin].clean(Object.keys(flowConfig.allNodes)));
|
||||
}
|
||||
flowConfig = flowConfig || { allNodes: {}, subflows: {} };
|
||||
const knownNodes = new Set(Object.keys(flowConfig.allNodes))
|
||||
|
||||
// We need to alias all of the subflow instance contents
|
||||
for (const subflow of Object.values(flowConfig.subflows || {})) {
|
||||
subflow.instances.forEach(instance => {
|
||||
for (const nodeId of Object.keys(subflow.nodes || {})) {
|
||||
knownNodes.add(`${instance.id}-${nodeId}`)
|
||||
}
|
||||
for (const nodeId of Object.keys(subflow.configs || {})) {
|
||||
knownNodes.add(`${instance.id}-${nodeId}`)
|
||||
}
|
||||
})
|
||||
}
|
||||
for (var id in contexts) {
|
||||
if (contexts.hasOwnProperty(id) && id !== "global") {
|
||||
var promises = [];
|
||||
for (const store of Object.values(stores)){
|
||||
promises.push(store.clean(Array.from(knownNodes)));
|
||||
}
|
||||
for (const id of Object.keys(contexts)) {
|
||||
if (id !== "global") {
|
||||
var idParts = id.split(":");
|
||||
if (!flowConfig.allNodes.hasOwnProperty(idParts[0])) {
|
||||
if (!knownNodes.has(idParts[0])) {
|
||||
delete contexts[id];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -383,6 +383,11 @@ var api = module.exports = {
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (nodeType === "global-config") {
|
||||
if (JSON.stringify(savedCredentials.map) !== JSON.stringify(newCreds.map)) {
|
||||
savedCredentials.map = newCreds.map;
|
||||
dirty = true;
|
||||
}
|
||||
} else {
|
||||
var dashedType = nodeType.replace(/\s+/g, '-');
|
||||
var definition = credentialsDef[dashedType];
|
||||
|
||||
@@ -205,6 +205,7 @@ module.exports = {
|
||||
getNode: flows.get,
|
||||
eachNode: flows.eachNode,
|
||||
getContext: context.get,
|
||||
getGlobalConfig: flows.getGlobalConfig,
|
||||
|
||||
clearContext: context.clear,
|
||||
|
||||
|
||||
193
packages/node_modules/@node-red/runtime/locales/fr/runtime.json
vendored
Normal file
193
packages/node_modules/@node-red/runtime/locales/fr/runtime.json
vendored
Normal file
@@ -0,0 +1,193 @@
|
||||
{
|
||||
"runtime": {
|
||||
"welcome": "Bienvenue sur Node-RED",
|
||||
"version": "__component__ version: __version__",
|
||||
"unsupported_version": "Version non prise en charge de __component__. Requiert : __requires__ Trouvé : __version__",
|
||||
"paths": {
|
||||
"settings": "Fichier de paramètres : __path__",
|
||||
"httpStatic": "HTTP Statique : __path__"
|
||||
}
|
||||
},
|
||||
"server": {
|
||||
"loading": "Chargement des noeuds de la palette",
|
||||
"palette-editor": {
|
||||
"disabled": "Éditeur de la palette désactivé : paramètres utilisateur",
|
||||
"npm-not-found": "Éditeur de la palette désactivé : commande npm introuvable",
|
||||
"npm-too-old": "Éditeur de la palette désactivé : version npm trop ancienne. Nécessite npm >= 3.x"
|
||||
},
|
||||
"errors": "Échec de l'enregistrement de __count__ type de noeud",
|
||||
"errors_plural": "Échec de l'enregistrement de __count__ types de noeud",
|
||||
"errors-help": "Exécuter avec -v pour plus de détails",
|
||||
"missing-modules": "Modules de noeud manquants :",
|
||||
"node-version-mismatch": "Le module de noeud ne peut pas être chargé sur cette version. Nécessite : __version__ ",
|
||||
"type-already-registered": "'__type__' déjà enregistré par le module __module__",
|
||||
"removing-modules": "Suppression de modules de la configuration",
|
||||
"added-types": "Types de noeuds ajoutés :",
|
||||
"removed-types": "Types de noeuds supprimés :",
|
||||
"install": {
|
||||
"invalid": "Nom de module invalide",
|
||||
"installing": "Installation du module : __nom__, version : __version__",
|
||||
"installed": "Module installé : __nom__",
|
||||
"install-failed": "L'installation a échoué",
|
||||
"install-failed-long": "L'installation du module __name__ a échoué :",
|
||||
"install-failed-not-found": "Module $t(server.install.install-failed-long) introuvable",
|
||||
"install-failed-name": "$t(server.install.install-failed-long) nom de module invalide : __name__",
|
||||
"install-failed-url": "URL invalide $t(server.install.install-failed-long) : __url__",
|
||||
"post-install-error": "Erreur lors de l'exécution du hook 'postInstall' :",
|
||||
"upgrading": "Mettre à jour le module : __name__ vers la version : __version__",
|
||||
"upgraded": "Module mis à jour : __name__. Redémarrer Node-RED pour utiliser la nouvelle version",
|
||||
"upgrade-failed-not-found": "Version $t(server.install.install-failed-long) introuvable",
|
||||
"uninstalling": "Désinstallation du module : __name__",
|
||||
"uninstall-failed": "La désinstallation a échoué",
|
||||
"uninstall-failed-long": "La désinstallation du module __name__ a échoué :",
|
||||
"uninstalled": "Module désinstallé : __name__",
|
||||
"old-ext-mod-dir-warning": "\n\n---------------------------------------------------------------------\nRépertoire des modules externes Node-RED 1.3 détecté :\n __oldDir__\nCe répertoire n'est plus utilisé. Les modules externes seront\nréinstallés dans votre répertoire utilisateur Node-RED :\n __newDir__\nSupprimer l'ancien répertoire externalModules pour arrêter ce message.\n---------------------------------------------------------------------\n"
|
||||
},
|
||||
"deprecatedOption": "L'utilisation de l'option __old__ est DÉCONSEILLÉE. Utiliser __new__ à la place",
|
||||
"unable-to-listen": "Impossible d'écouter sur __listenpath__",
|
||||
"port-in-use": "Erreur : port utilisé",
|
||||
"uncaught-exception": "Exception non reconnue :",
|
||||
"admin-ui-disabled": "Interface d'administration désactivée",
|
||||
"now-running": "Le serveur tourne maintenant sur __listenpath__",
|
||||
"failed-to-start": "Échec lors du démarrage du serveur :",
|
||||
"headless-mode": "Fonctionne en mode sans interface graphique (headless)",
|
||||
"httpadminauth-deprecated": "L'utilisation de httpAdminAuth est DÉCONSEILLÉE. Utiliser adminAuth à la place",
|
||||
"https": {
|
||||
"refresh-interval": "Actualisation des paramètres https toutes les __interval__ heures",
|
||||
"settings-refreshed": "Les paramètres https du serveur ont été actualisés",
|
||||
"refresh-failed": "Échec de l'actualisation des paramètres https : __message__",
|
||||
"nodejs-version": "httpsRefreshInterval nécessite Node.js 11 ou version ultérieure",
|
||||
"function-required": "httpsRefreshInterval nécessite que la propriété https soit une fonction"
|
||||
}
|
||||
},
|
||||
"api": {
|
||||
"flows": {
|
||||
"error-save": "Erreur lors de l'enregistrement des flux : __message__",
|
||||
"error-reload": "Erreur lors du rechargement des flux : __message__"
|
||||
},
|
||||
"library": {
|
||||
"error-load-entry": "Erreur lors du chargement de l'entrée de la bibliothèque '__path__' : __message__",
|
||||
"error-save-entry": "Erreur lors de l'enregistrement de l'entrée de la bibliothèque '__path__' : __message__",
|
||||
"error-load-flow": "Erreur lors du chargement du flux '__path__' : __message__",
|
||||
"error-save-flow": "Erreur lors de l'enregistrement du flux '__path__' : __message__"
|
||||
},
|
||||
"nodes": {
|
||||
"enabled": "Types de noeuds activés :",
|
||||
"disabled": "Types de noeuds désactivés :",
|
||||
"error-enable": "Échec de l'activation du noeud :"
|
||||
}
|
||||
},
|
||||
"comms": {
|
||||
"error": "Erreur de canal de communication: __message__",
|
||||
"error-server": "Erreur de communication avec le serveur : __message__",
|
||||
"error-send": "Erreur d'envoi de communication : __message__"
|
||||
},
|
||||
"settings": {
|
||||
"user-not-available": "Impossible d'enregistrer les paramètres utilisateur : __message__",
|
||||
"not-available": "Paramètres non disponibles",
|
||||
"property-read-only": "La propriété '__prop__' est en lecture seule",
|
||||
"readonly-mode": "Exécution en mode lecture seule. Les modifications ne seront pas enregistrées."
|
||||
},
|
||||
"library": {
|
||||
"unknownLibrary": "Bibliothèque inconnue : __library__",
|
||||
"unknownType": "Type de bibliothèque inconnu : __type__",
|
||||
"readOnly": "La bibliothèque __library__ est en lecture seule",
|
||||
"failedToInit": "Échec de l'initialisation de la bibliothèque __library__ : __error__",
|
||||
"invalidProperty": "Propriété invalide __prop__ : '__value__'"
|
||||
},
|
||||
"nodes": {
|
||||
"credentials": {
|
||||
"error": "Erreur lors du chargement des identifiants : __message__",
|
||||
"error-saving": "Erreur lors de l'enregistrement des identifiants : __message__",
|
||||
"not-registered": "Le type d'identifiant '__type__' n'a pas été enregistré",
|
||||
"system-key-warning": "\n\n---------------------------------------------------------------------\nVotre fichier contenant les identifiants de flux est chiffré à l'aide d'une clé générée par le système.\n\nSi la clé générée par le système est perdue pour une raison quelconque, votre fichier contenant\nles identifiants ne sera pas récupérable, vous devrez le supprimer et ressaisir vos identifiants.\n\nVous pouvez définir votre propre clé en utilisant l'option 'credentialSecret' dans\nvotre fichier de paramètres. Node-RED rechiffrera alors votre fichier contenant les identifiants\nà l'aide de la clé que vous avez choisie la prochaine fois que vous déploierez une modification.\n---------------------------------------------------------------------\n",
|
||||
"unencrypted": "Utilisation d'identifiants non chiffrés",
|
||||
"encryptedNotFound": "Identifiants chiffrés introuvables"
|
||||
},
|
||||
"flows": {
|
||||
"safe-mode": "Les flux se sont arrêtés en mode sans échec. Déployer les pour commencer.",
|
||||
"registered-missing": "Type manquant enregistré : __type__",
|
||||
"error": "Erreur lors du chargement des flux : __message__",
|
||||
"starting-modified-nodes": "Démarrage des noeuds modifiés",
|
||||
"starting-modified-flows": "Démarrage des flux modifiés",
|
||||
"starting-flows": "Démarrage des flux",
|
||||
"started-modified-nodes": "Noeuds modifiés démarrés",
|
||||
"started-modified-flows": "Flux modifiés démarrés",
|
||||
"started-flows": "Flux démarrés",
|
||||
"stopping-modified-nodes": "Arrêt des noeuds modifiés",
|
||||
"stopping-modified-flows": "Arrêt des flux modifiés",
|
||||
"stopping-flows": "Arrêt des flux",
|
||||
"stopped-modified-nodes": "Noeuds modifiés arrêtés",
|
||||
"stopped-modified-flows": "Flux modifiés arrêtés",
|
||||
"stopped-flows": "Flux arrêtés",
|
||||
"stopped": "Arrêté",
|
||||
"stopping-error": "Erreur lors de l'arrêt du noeud : __message__",
|
||||
"updated-flows": "Flux mis à jour",
|
||||
"added-flow": "Ajout du flux : __label__",
|
||||
"updated-flow": "Flux mis à jour : __label__",
|
||||
"removed-flow": "Flux supprimé : __label__",
|
||||
"missing-types": "En attente d'enregistrement des types manquants :",
|
||||
"missing-type-provided": " - __type__ (fourni par le module npm __module__)",
|
||||
"missing-type-install-1": "Pour installer l'un des modules manquants, exécuter :",
|
||||
"missing-type-install-2": "dans le répertoire :"
|
||||
},
|
||||
"flow": {
|
||||
"unknown-type": "Type inconnu : __type__",
|
||||
"missing-types": "Types manquants",
|
||||
"error-loop": "Le message a dépassé le nombre maximum de captures (catches)"
|
||||
},
|
||||
"index": {
|
||||
"unrecognised-id": "Identifiant non reconnu : __id__",
|
||||
"type-in-use": "Type en cours d'utilisation : __msg__",
|
||||
"unrecognised-module": "Module non reconnu : __module__"
|
||||
},
|
||||
"registry": {
|
||||
"localfilesystem": {
|
||||
"module-not-found": "Impossible de trouver le module '__module__'"
|
||||
}
|
||||
}
|
||||
},
|
||||
"storage": {
|
||||
"index": {
|
||||
"forbidden-flow-name": "Nom du flux interdit"
|
||||
},
|
||||
"localfilesystem": {
|
||||
"user-dir": "Répertoire utilisateur : __path__",
|
||||
"flows-file": "Fichier des flux : __path__",
|
||||
"create": "Création d'un nouveau fichier __type__",
|
||||
"empty": "Le fichier __type__ existant est vide",
|
||||
"invalid": "Le fichier __type__ existant n'est pas un JSON valide",
|
||||
"restore": "Restauration de la sauvegarde du fichier __type__ : __path__",
|
||||
"restore-fail": "La restauration de la sauvegarde du fichier __type__ a échoué : __message__",
|
||||
"fsync-fail": "Échec du vidage du fichier __path__ sur le disque : __message__",
|
||||
"warn_name": "Le nom du fichier de flux n'est pas défini. Génération du nom à l'aide du nom d'hôte.",
|
||||
"projects": {
|
||||
"changing-project": "Définition du projet actif : __project__",
|
||||
"active-project": "Projet actif : __project__",
|
||||
"projects-directory": "Répertoire des projets : __projectsDirectory__",
|
||||
"project-not-found": "Projet introuvable : __project__",
|
||||
"no-active-project": "Aucun projet actif : utilisation du fichier de flux par défaut",
|
||||
"disabled": "Projets désactivés : editorTheme.projects.enabled=false",
|
||||
"disabledNoFlag": "Projets désactivés : définir editorTheme.projects.enabled=true pour activer",
|
||||
"git-not-found": "Projets désactivés : commande git introuvable",
|
||||
"git-version-old": "Projets désactivés : git __version__ non pris en charge. Nécessite 2.x",
|
||||
"summary": "Un projet Node-RED",
|
||||
"readme": "### À propos\n\nCeci est le fichier README.md de votre projet. Il aide les utilisateurs à comprendre ce que fait votre\nprojet, comment l'utiliser et tout ce qu'il est utile de savoir."
|
||||
}
|
||||
}
|
||||
},
|
||||
"context": {
|
||||
"log-store-init": "Stockage contextuel : '__name__' [__info__]",
|
||||
"error-loading-module": "Erreur lors du chargement du stockage contextuel : __message__",
|
||||
"error-loading-module2": "Erreur lors du chargement du stockage contextuel '__module__' : __message__",
|
||||
"error-module-not-defined": "Option 'module' manquante dans le stockage contextuel '__storage__'",
|
||||
"error-invalid-module-name": "Nom du stockage contextuel invalide : '__name__'",
|
||||
"error-invalid-default-module": "Stockage contextuel par défaut inconnu : '__storage__'",
|
||||
"unknown-store": "Stockage contextuel inconnu '__name__' spécifié. Utilisation du stockage par défaut.",
|
||||
"localfilesystem": {
|
||||
"invalid-json": "JSON non valide dans le fichier de contexte '__file__'",
|
||||
"error-circular": "Le contexte __scope__ contient une référence circulaire qui ne peut pas être persistante",
|
||||
"error-write": "Erreur d'écriture du contexte : __message__"
|
||||
}
|
||||
}
|
||||
}
|
||||
199
packages/node_modules/@node-red/runtime/locales/pt-BR/runtime.json
vendored
Normal file
199
packages/node_modules/@node-red/runtime/locales/pt-BR/runtime.json
vendored
Normal file
@@ -0,0 +1,199 @@
|
||||
{
|
||||
"runtime": {
|
||||
"welcome": "Bem vindo ao Node-RED",
|
||||
"version": "__component__ versão: __version__",
|
||||
"unsupported_version": "Versão não suportada de __component__. Requer: __requires__ Encontrado: __version__",
|
||||
"paths": {
|
||||
"settings": "Arquivo de configurações : __path__",
|
||||
"httpStatic": "HTTP Estático : __path__"
|
||||
}
|
||||
},
|
||||
|
||||
"server": {
|
||||
"loading": "Carregando paletá de nós",
|
||||
"palette-editor": {
|
||||
"disabled": "Editor de paletas desativado : configurações do usuário",
|
||||
"npm-not-found": "Editor de paleta desativado : comando npm não encontrado",
|
||||
"npm-too-old": "Editor de paleta desativado : versão npm muito antiga. Requer npm> = 3.x"
|
||||
},
|
||||
"errors": "Falha ao registrar __count__ tipo de nó",
|
||||
"errors_plural": "Falha ao registrar __count__ tipos de nós",
|
||||
"errors-help": "Execute com -v para obter detalhes",
|
||||
"missing-modules": "Módulos de nó que estão faltando:",
|
||||
"node-version-mismatch": "O módulo de nó não pode ser carregado nesta versão. Requer: __version__",
|
||||
"type-already-registered": "'__type__' já registrado pelo módulo __module__",
|
||||
"removing-modules": "Removendo os módulos da configuração",
|
||||
"added-types": "Tipos de nós adicionados:",
|
||||
"removed-types": "Tipos de nós removidos:",
|
||||
"install": {
|
||||
"invalid": "Nome de módulo inválido",
|
||||
"installing": "Módulo de instalação: __name__, versão: __version__",
|
||||
"installed": "Módulo instalado: __name__",
|
||||
"install-failed": "Instalação falhou",
|
||||
"install-failed-long": "Instalação do módulo __name__ falhou:",
|
||||
"install-failed-not-found": "Módulo $t(server.install.install-failed-long) não encontrado",
|
||||
"install-failed-name": "$t(server.install.install-failed-long) nome do módulo inválido: __name__",
|
||||
"install-failed-url": "$t(server.install.install-failed-long) url inválido: __url__",
|
||||
"post-install-error": "Erro ao executar o gancho 'postInstall':",
|
||||
"upgrading": "Módulo de atualização: __name__ para a versão: __version__",
|
||||
"upgraded": "Módulo atualizado: __name__. Reinicie o Node-RED para usar a nova versão",
|
||||
"upgrade-failed-not-found": "$t(server.install.install-failed-long) versão não encontrada",
|
||||
"uninstalling": "Desinstalando módulo: __name__",
|
||||
"uninstall-failed": "Desinstalação falhou",
|
||||
"uninstall-failed-long": "A desinstalação do módulo __name__ falhou:",
|
||||
"uninstalled": "Módulo desinstalado: __name__",
|
||||
"old-ext-mod-dir-warning": "\n\n---------------------------------------------------------------------\ndetectado diretório de módulos externos do Node-RED 1.3:\n __oldDir__\nEste diretório não é mais usado. Módulos externos serão\nreinstalados em seu diretório de usuário Node-RED:\n __newDir__\nExclua o diretório 'externalModules' antigo para interromper esta mensagem.\n---------------------------------------------------------------------\n"
|
||||
},
|
||||
"deprecatedOption": "O uso de __old__ está DESCONTINUADO. Use __new__ em seu lugar",
|
||||
"unable-to-listen": "Incapaz de ouvir em __listenpath__",
|
||||
"port-in-use": "Erro: porta em uso",
|
||||
"uncaught-exception": "Exceção não capturada:",
|
||||
"admin-ui-disabled": "Admin UI desativada",
|
||||
"now-running": "servidor rodando agora em __listenpath__",
|
||||
"failed-to-start": "Falhou ao iniciar o servidor:",
|
||||
"headless-mode": "Executando no modo sem interface gráfica",
|
||||
"httpadminauth-deprecated": "O uso de 'httpAdminAuth' está DESCONTINUADO. Use 'adminAuth' em seu lugar",
|
||||
"https": {
|
||||
"refresh-interval": "Atualizando as configurações de https a cada __interval__ hora(s)",
|
||||
"settings-refreshed": "As configurações https do servidor foram atualizadas",
|
||||
"refresh-failed": "Falha ao atualizar as configurações https: __message__",
|
||||
"nodejs-version": "httpsRefreshInterval requer Node.js 11 ou posterior",
|
||||
"function-required": "httpsRefreshInterval requer que a propriedade https seja uma função"
|
||||
}
|
||||
},
|
||||
|
||||
"api": {
|
||||
"flows": {
|
||||
"error-save": "Erro ao salvar fluxos: __message__",
|
||||
"error-reload": "Erro ao recarregar fluxos: __message__"
|
||||
},
|
||||
"library": {
|
||||
"error-load-entry": "Erro ao carregar a entrada da biblioteca '__path__': __message__",
|
||||
"error-save-entry": "Erro ao salvar a entrada da biblioteca '__path__': __message__",
|
||||
"error-load-flow": "Erro ao carregar o fluxo '__path__': __message__",
|
||||
"error-save-flow": "Erro ao salvar o fluxo '__path__': __message__"
|
||||
},
|
||||
"nodes": {
|
||||
"enabled": "Tipos de nós habilitados:",
|
||||
"disabled": "Tipos de nós desabilitados:",
|
||||
"error-enable": "Falha ao habilitar o nó:"
|
||||
}
|
||||
},
|
||||
"comms": {
|
||||
"error": "Erro do canal de comunicação: __message__",
|
||||
"error-server": "Erro do servidor de comunicação: __message__",
|
||||
"error-send": "Erro de envio de comunicação: __message__"
|
||||
},
|
||||
"settings": {
|
||||
"user-not-available": "Não é possível salvar as configurações do usuário: __message__",
|
||||
"not-available": "Configurações não disponíveis",
|
||||
"property-read-only": "A propriedade '__prop__' é somente leitura",
|
||||
"readonly-mode": "Execução em modo leitura somente. As alterações não serão salvas."
|
||||
},
|
||||
"library": {
|
||||
"unknownLibrary": "Biblioteca desconhecida: __library__",
|
||||
"unknownType": "Tipo de biblioteca desconhecido: __type__",
|
||||
"readOnly": "A biblioteca __library__ é somente de leitura",
|
||||
"failedToInit": "Falha ao inicializar a biblioteca __library__: __error__",
|
||||
"invalidProperty": "Propriedade inválida __prop__: '__value__'"
|
||||
},
|
||||
"nodes": {
|
||||
"credentials": {
|
||||
"error": "Erro ao carregar credenciais: __message__",
|
||||
"error-saving": "Erro ao salvar credenciais: __message__",
|
||||
"not-registered": "O tipo de credencial '__type__' não está registrado",
|
||||
"system-key-warning": "\n\n------------------------------------- --------------------------------\nSeu arquivo de credenciais de fluxo é criptografado usando uma chave gerada pelo sistema.\n\nSe a chave gerada pelo sistema foi perdida por qualquer motivo, seu arquivo de credenciais \nnão será recuperável; você terá que excluí-lo e inserir novamente \nsuas credenciais. \n\nVocê deve definir sua própria chave usando a opção 'credentialSecret' em \n seu arquivo de configurações. O Node-RED irá então criptografar novamente o arquivo de credenciais \n usando a chave escolhida na próxima vez que você implantar uma alteração. \n ------------------- -------------------------------------------------- \n ",
|
||||
"unencrypted": "Usando credenciais não criptografadas",
|
||||
"encryptedNotFound": "Credenciais criptografadas não encontradas"
|
||||
},
|
||||
"flows": {
|
||||
"safe-mode": "Fluxos interrompidos no modo de segurança. Implementar para iniciar.",
|
||||
"registered-missing": "Tipo ausente registrado: __type__",
|
||||
"error": "Erro ao carregar fluxos: __message__",
|
||||
"starting-modified-nodes": "Iniciando nós modificados",
|
||||
"starting-modified-flows": "Iniciando fluxos modificados",
|
||||
"starting-flows": "Iniciando fluxos",
|
||||
"started-modified-nodes": "Nós modificados iniciados",
|
||||
"started-modified-flows": "Fluxos modificados iniciados",
|
||||
"started-flows": "Fluxos iniciados",
|
||||
"stopping-modified-nodes": "Parando nós modificados",
|
||||
"stopping-modified-flows": "Parando fluxos modificados",
|
||||
"stopping-flows": "Parando fluxos",
|
||||
"stopped-modified-nodes": "Nós modificados interrompidos",
|
||||
"stopped-modified-flows": "Fluxos modificados interrompidos",
|
||||
"stopped-flows": "Fluxos interrompidos",
|
||||
"stopped": "Parado",
|
||||
"stopping-error": "Erro ao parar o nó: __message__",
|
||||
"updated-flows": "Fluxos atualizados",
|
||||
"added-flow": "Adicionando fluxo: __label__",
|
||||
"updated-flow": "Fluxo atualizado: __label__",
|
||||
"removed-flow": "Fluxo removido: __label__",
|
||||
"missing-types": "Esperando que os tipos ausentes sejam registrados:",
|
||||
"missing-type-provided": "- __type__ (fornecido pelo módulo npm __module__)",
|
||||
"missing-type-install-1": "Para instalar qualquer um desses módulos ausentes, execute:",
|
||||
"missing-type-install-2": "no diretório:"
|
||||
},
|
||||
"flow": {
|
||||
"unknown-type": "Tipo desconhecido: __type__",
|
||||
"missing-types": "tipos ausentes",
|
||||
"error-loop": "A mensagem excedeu o número máximo de capturas"
|
||||
|
||||
},
|
||||
"index": {
|
||||
"unrecognised-id": "Não reconhecido id: __id__",
|
||||
"type-in-use": "Tipo em uso: __msg__",
|
||||
"unrecognised-module": "Módulo não reconhecido: __module__"
|
||||
},
|
||||
"registry": {
|
||||
"localfilesystem": {
|
||||
"module-not-found": "Não é possível encontrar o módulo '__module__'"
|
||||
}
|
||||
}
|
||||
},
|
||||
"storage": {
|
||||
"index": {
|
||||
"forbidden-flow-name": "nome do fluxo proibido"
|
||||
},
|
||||
"localfilesystem": {
|
||||
"user-dir": "Diretório do usuário: __path__",
|
||||
"flows-file": "Arquivo de fluxos: __path__",
|
||||
"create": "Criando novo arquivo __type__",
|
||||
"empty": "O arquivo __type__ existente está vazio",
|
||||
"invalid": "O arquivo __type__ existente não é json válido",
|
||||
"restore": "Restaurando backup de arquivo __type__: __path__",
|
||||
"restore-fail": "Falha ao restaurar o backup do arquivo __type__: __message__",
|
||||
"fsync-fail": "A liberação do arquivo __path__ para o disco falhou: __message__",
|
||||
"warn_name": "Nome do arquivo de fluxo não definido. Gerando nome usando o nome do servidor.",
|
||||
"projects": {
|
||||
"changing-project": "Configurando projeto ativo: __project__",
|
||||
"active-project": "Projeto ativo: __projeto__",
|
||||
"projects-directory": "Diretório de projetos: __projectsDirectory__",
|
||||
"project-not-found": "Projeto não encontrado: __project__",
|
||||
"no-active-project": "Nenhum projeto ativo: usando arquivo de fluxos padrão",
|
||||
"disabled": "Projetos desativados: editorTheme.projects.enabled = false",
|
||||
"disabledNoFlag": "Projetos desativados: defina editorTheme.projects.enabled = true para ativar",
|
||||
"git-not-found": "Projetos desativados: comando git não encontrado",
|
||||
"git-version-old": "Projetos desativados: git __version__ não é compatível. Requer 2.x",
|
||||
"summary": "Um Projeto Node-RED",
|
||||
"readme": "### Sobre\n\nEste é o arquivo README.md do seu projeto. O Arquivo ajuda usuários a entender o que seu \nprojeto faz, como usá-lo e qualquer outra coisa que eles precisem saber."
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
"context": {
|
||||
"log-store-init": "Armazenamento de contexto: '__name__' [__info__]",
|
||||
"error-loading-module": "Erro ao carregar armazenamento de contexto: __message__",
|
||||
"error-loading-module2": "Erro ao carregar o armazenamento de contexto '__module__': __message__",
|
||||
"error-module-not-defined": "Armazenamento de contexto '__storage__' opção de 'módulo' ausente",
|
||||
"error-invalid-module-name": "Nome de armazenamento de contexto inválido: '__name__'",
|
||||
"error-invalid-default-module": "Armazenamento de contexto padrão desconhecido: '__storage__'",
|
||||
"unknown-store": "Armazenamento de contexto desconhecido '__name__' especificado. Usando armazenamento padrão.",
|
||||
|
||||
"localfilesystem": {
|
||||
"invalid-json": "JSON inválido no arquivo de contexto '__file__'",
|
||||
"error-circular": "O contexto __scope__ contém uma referência circular que não pode ser continuada",
|
||||
"error-write": "Erro ao escrever o contexto: __message__"
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@node-red/runtime",
|
||||
"version": "3.0.2",
|
||||
"version": "3.1.0-beta.3",
|
||||
"license": "Apache-2.0",
|
||||
"main": "./lib/index.js",
|
||||
"repository": {
|
||||
@@ -16,12 +16,12 @@
|
||||
}
|
||||
],
|
||||
"dependencies": {
|
||||
"@node-red/registry": "3.0.2",
|
||||
"@node-red/util": "3.0.2",
|
||||
"async-mutex": "0.3.2",
|
||||
"@node-red/registry": "3.1.0-beta.3",
|
||||
"@node-red/util": "3.1.0-beta.3",
|
||||
"async-mutex": "0.4.0",
|
||||
"clone": "2.1.2",
|
||||
"express": "4.18.1",
|
||||
"fs-extra": "10.1.0",
|
||||
"express": "4.18.2",
|
||||
"fs-extra": "11.1.1",
|
||||
"json-stringify-safe": "5.0.1"
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user