@bonsae/nrg 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",

package/schemas/labels.schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://unpkg.com/@bonsae/nrg/schemas/labels.schema.json",
+  "title": "NRG Node Labels",
+  "description": "Label file for NRG Node-RED nodes. Provides human-readable labels for the editor UI and auto-generated help docs.",
+  "type": "object",
+  "required": ["label"],
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "JSON Schema reference for IDE validation"
+    },
+    "label": {
+      "type": "string",
+      "description": "Display name shown in the palette and workspace"
+    },
+    "description": {
+      "type": "string",
+      "description": "Node description for this language. Overrides the class-level description in auto-generated help docs."
+    },
+    "configs": {
+      "$ref": "#/$defs/labelMap",
+      "description": "Labels for config properties"
+    },
+    "credentials": {
+      "$ref": "#/$defs/labelMap",
+      "description": "Labels for credential properties"
+    },
+    "input": {
+      "$ref": "#/$defs/labelMap",
+      "description": "Labels for input schema properties"
+    },
+    "outputs": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/labelMap"
+      },
+      "description": "Per-port output labels, matching outputsSchema order. Single output uses an array with one element."
+    },
+    "errors": {
+      "$ref": "#/$defs/labelMap",
+      "description": "Custom error messages. Use __field__ for placeholder substitution."
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "labelMap": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      },
+      "description": "Maps property keys to human-readable labels"
+    }
+  }
+}

package/server/index.cjs

@@ -244,8 +244,16 @@ var TypedInput = class {
     this.input = input;
   }
   resolvers = {
-    // NOTE: NRG nodes are wrapped — surface the NRG instance, fall back to raw NodeRedNode
-    node: (raw) => raw?._node ?? raw
+    // evaluateNodeProperty returns the node ID string for "node" type —
+    // resolve it to the actual node instance via RED.nodes.getNode,
+    // then surface the NRG wrapper if available.
+    node: (raw) => {
+      if (typeof raw === "string") {
+        const node = this.RED.nodes.getNode(raw);
+        return node?._node ?? node ?? raw;
+      }
+      return raw?._node ?? raw;
+    }
   };
   get type() {
     return this.input.type;

package/tsconfig/client.json

@@ -4,8 +4,8 @@
     "lib": ["ES2022", "DOM", "DOM.Iterable"]
   },
   "files": [
-    "../shims/shims-vue.d.ts",
-    "../shims/components.d.ts",
-    "../shims/globals.d.ts"
+    "../types/shims/shims-vue.d.ts",
+    "../types/shims/components.d.ts",
+    "../types/shims/globals.d.ts"
   ]
 }

package/vite/index.js

@@ -1,5 +1,5 @@
 // src/vite/plugin.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/vite/defaults.ts
 var DEFAULT_OUTPUT_DIR = "./dist";
@@ -18,19 +18,7 @@ var DEFAULT_CLIENT_BUILD_OPTIONS = {
   },
   locales: {
     docsDir: "./src/locales/docs",
-    labelsDir: "./src/locales/labels",
-    languages: [
-      "en-US",
-      "de",
-      "es-ES",
-      "fr",
-      "ko",
-      "pt-BR",
-      "ru",
-      "ja",
-      "zh-CN",
-      "zh-TW"
-    ]
+    labelsDir: "./src/locales/labels"
   },
   staticDirs: {
     icons: "./src/icons",
@@ -535,7 +523,7 @@ module.exports = settings;
 
 // src/vite/plugins/server.ts
 import chokidar from "chokidar";
-import path11 from "path";
+import path12 from "path";
 
 // src/vite/server/build.ts
 import { build as viteBuild } from "vite";
@@ -1122,13 +1110,230 @@ module.exports = function (RED) {
 // src/vite/client/build.ts
 import { build as viteBuild2 } from "vite";
 import vue from "@vitejs/plugin-vue";
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 
-// src/vite/client/plugins/html-generator.ts
-import mime from "mime-types";
+// src/vite/client/plugins/help-generator.ts
 import fs6 from "fs";
 import path6 from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+function buildPropertyRow(name, schema, required, label) {
+  let type = "";
+  if (schema["x-nrg-node-type"]) {
+    type = `NodeRef \u2192 ${schema["x-nrg-node-type"]}`;
+  } else if (schema["x-nrg-typed-input"]) {
+    type = "TypedInput";
+  } else if (schema.type) {
+    type = String(schema.type);
+  }
+  if (schema.enum) type += ` (${schema.enum.join(", ")})`;
+  const constraints = [];
+  if (schema.minLength !== void 0)
+    constraints.push(`min: ${schema.minLength}`);
+  if (schema.maxLength !== void 0)
+    constraints.push(`max: ${schema.maxLength}`);
+  if (schema.minimum !== void 0) constraints.push(`min: ${schema.minimum}`);
+  if (schema.maximum !== void 0) constraints.push(`max: ${schema.maximum}`);
+  if (schema.pattern) constraints.push(`pattern: \`${schema.pattern}\``);
+  if (schema.format && schema.format !== "password")
+    constraints.push(`format: ${schema.format}`);
+  if (constraints.length) type += ` [${constraints.join(", ")}]`;
+  const defaultVal = schema.default !== void 0 ? JSON.stringify(schema.default) : "";
+  const description = schema.description ?? "";
+  return { name, label: label ?? "", type, required, defaultVal, description };
+}
+var SKIP_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "z",
+  "name",
+  "wires",
+  "x",
+  "y",
+  "g",
+  "_users"
+]);
+function generateSchemaSection(title, schema, labels, heading = "###") {
+  if (!schema?.properties) return "";
+  const required = new Set(schema.required ?? []);
+  const rows = Object.entries(schema.properties).filter(([key]) => !SKIP_FIELDS.has(key)).map(
+    ([key, propSchema]) => buildPropertyRow(
+      key,
+      propSchema,
+      required.has(key),
+      labels?.[key]
+    )
+  );
+  if (rows.length === 0) return "";
+  const hasLabels = rows.some((r) => r.label);
+  const headerCells = hasLabels ? '<th>Property</th><th>Label</th><th>Type</th><th>Required</th><th>Default</th><th style="width:35%">Description</th>' : '<th>Property</th><th>Type</th><th>Required</th><th>Default</th><th style="width:40%">Description</th>';
+  const tableRows = rows.map(
+    (r) => hasLabels ? `<tr><td>${r.name}</td><td>${r.label}</td><td>${r.type}</td><td>${r.required ? "Yes" : "No"}</td><td>${r.defaultVal ? `<code>${r.defaultVal}</code>` : ""}</td><td>${r.description}</td></tr>` : `<tr><td>${r.name}</td><td>${r.type}</td><td>${r.required ? "Yes" : "No"}</td><td>${r.defaultVal ? `<code>${r.defaultVal}</code>` : ""}</td><td>${r.description}</td></tr>`
+  ).join("\n");
+  const table = `<div style="overflow-x:auto">
+<table width="100%" style="min-width:500px">
+<thead><tr>${headerCells}</tr></thead>
+<tbody>
+${tableRows}
+</tbody>
+</table>
+</div>`;
+  return `${heading} ${title}
+
+${table}
+`;
+}
+function loadNodeLabels(labelPath) {
+  if (!fs6.existsSync(labelPath)) return {};
+  try {
+    const raw = JSON.parse(fs6.readFileSync(labelPath, "utf-8"));
+    return {
+      description: raw.description,
+      configs: raw.configs,
+      credentials: raw.credentials,
+      input: raw.input,
+      outputs: raw.outputs
+    };
+  } catch {
+    return {};
+  }
+}
+function generateHelpDoc(nodeClass, labels) {
+  const lines = [];
+  if (labels.description) {
+    lines.push(labels.description);
+    lines.push("");
+  }
+  const configSection = generateSchemaSection(
+    "Properties",
+    nodeClass.configSchema,
+    labels.configs
+  );
+  if (configSection) lines.push(configSection);
+  const credsSection = generateSchemaSection(
+    "Credentials",
+    nodeClass.credentialsSchema,
+    labels.credentials
+  );
+  if (credsSection) lines.push(credsSection);
+  if (nodeClass.inputSchema) {
+    const inputLabels = nodeClass.inputLabels;
+    const inputLabel = typeof inputLabels === "string" ? inputLabels : Array.isArray(inputLabels) ? inputLabels[0] : void 0;
+    const inputTitle = inputLabel ? `Input (${inputLabel})` : "Input";
+    const inputSection = generateSchemaSection(
+      inputTitle,
+      nodeClass.inputSchema,
+      labels.input
+    );
+    if (inputSection) lines.push(inputSection);
+  }
+  if (nodeClass.outputsSchema) {
+    const outputLabels = nodeClass.outputLabels;
+    if (Array.isArray(nodeClass.outputsSchema)) {
+      const portSections = [];
+      nodeClass.outputsSchema.forEach((schema, i) => {
+        const portLabel = Array.isArray(outputLabels) ? outputLabels[i] : void 0;
+        const title = portLabel ? `Port ${i + 1} \u2014 ${portLabel}` : `Port ${i + 1}`;
+        const portPropLabels = labels.outputs?.[i];
+        const section = generateSchemaSection(
+          title,
+          schema,
+          portPropLabels,
+          "####"
+        );
+        if (section) portSections.push(section);
+      });
+      if (portSections.length) {
+        lines.push(`### Outputs
+
+${portSections.join("\n")}`);
+      }
+    } else {
+      const label = typeof outputLabels === "string" ? outputLabels : Array.isArray(outputLabels) ? outputLabels[0] : void 0;
+      const title = label ? `Output (${label})` : "Output";
+      const outputPropLabels = labels.outputs?.[0];
+      const section = generateSchemaSection(
+        title,
+        nodeClass.outputsSchema,
+        outputPropLabels
+      );
+      if (section) lines.push(section);
+    }
+  }
+  return lines.join("\n").trim();
+}
+function discoverLanguages(labelsDir, nodeType) {
+  const nodeLabelsDir = path6.join(labelsDir, nodeType);
+  if (!fs6.existsSync(nodeLabelsDir)) return [];
+  return fs6.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path6.basename(f, ".json"));
+}
+function helpGenerator(options) {
+  const { outDir, localesOutDir, docsDir, labelsDir } = options;
+  return {
+    name: "vite-plugin-node-red:client:help-generator",
+    apply: "build",
+    enforce: "post",
+    async closeBundle() {
+      const esmPath = path6.resolve(outDir, "index.mjs");
+      const cjsPath = path6.resolve(outDir, "index.js");
+      let packageFn;
+      try {
+        if (fs6.existsSync(esmPath)) {
+          const fileUrl = pathToFileURL(esmPath).href + `?t=${Date.now()}`;
+          const mod = await import(fileUrl);
+          packageFn = mod?.default ?? mod;
+        } else if (fs6.existsSync(cjsPath)) {
+          const require2 = createRequire(import.meta.url);
+          delete require2.cache[cjsPath];
+          const rawMod = require2(cjsPath);
+          packageFn = rawMod?.default ?? rawMod;
+        }
+      } catch {
+        return;
+      }
+      const nodeClasses = packageFn?.nodes ?? [];
+      const helpByLang = /* @__PURE__ */ new Map();
+      for (const NodeClass of nodeClasses) {
+        const type = NodeClass.type;
+        if (!type) continue;
+        const languages = discoverLanguages(labelsDir, type);
+        if (!languages.includes("en-US")) languages.push("en-US");
+        for (const lang of languages) {
+          const manualMd = path6.join(docsDir, type, `${lang}.md`);
+          const manualHtml = path6.join(docsDir, type, `${lang}.html`);
+          if (fs6.existsSync(manualMd) || fs6.existsSync(manualHtml)) continue;
+          const labelPath = path6.join(labelsDir, type, `${lang}.json`);
+          const labels = loadNodeLabels(labelPath);
+          const content = generateHelpDoc(NodeClass, labels);
+          if (!content) continue;
+          if (!helpByLang.has(lang)) helpByLang.set(lang, []);
+          helpByLang.get(lang).push(
+            `<script type="text/markdown" data-help-name="${type}">
+${content}
+</script>`
+          );
+        }
+      }
+      for (const [lang, scripts] of helpByLang) {
+        const langDir = path6.join(localesOutDir, lang);
+        fs6.mkdirSync(langDir, { recursive: true });
+        const indexPath = path6.join(langDir, "index.html");
+        const existing = fs6.existsSync(indexPath) ? fs6.readFileSync(indexPath, "utf-8") : "";
+        fs6.writeFileSync(
+          indexPath,
+          existing + (existing ? "\n" : "") + scripts.join("\n"),
+          "utf-8"
+        );
+      }
+    }
+  };
+}
+
+// src/vite/client/plugins/html-generator.ts
+import mime from "mime-types";
+import fs7 from "fs";
+import path7 from "path";
 function htmlGenerator(options) {
   const { packageName, licensePath } = options;
   return {
@@ -1138,7 +1343,7 @@ function htmlGenerator(options) {
     generateBundle(_, bundle) {
       const resourcesTags = Object.keys(bundle).map((fileName) => {
         const asset = bundle[fileName];
-        const srcPath = path6.join(
+        const srcPath = path7.join(
           "resources",
           packageName,
           fileName.replace(/^resources\/?/, "")
@@ -1166,8 +1371,8 @@ function htmlGenerator(options) {
             return null;
         }
       }).filter(Boolean).join("\n");
-      const licenseBanner = licensePath && fs6.existsSync(licensePath) ? `<!--
-${fs6.readFileSync(licensePath, "utf-8")}
+      const licenseBanner = licensePath && fs7.existsSync(licensePath) ? `<!--
+${fs7.readFileSync(licensePath, "utf-8")}
 -->` : "";
       this.emitFile({
         type: "asset",
@@ -1180,10 +1385,22 @@ ${resourcesTags}`
 }
 
 // src/vite/client/plugins/locales-generator.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 function localesGenerator(options) {
-  const { outDir, docsDir, labelsDir, languages } = options;
+  const { outDir, docsDir, labelsDir } = options;
+  const languages = [
+    "en-US",
+    "de",
+    "es-ES",
+    "fr",
+    "ko",
+    "pt-BR",
+    "ru",
+    "ja",
+    "zh-CN",
+    "zh-TW"
+  ];
   return {
     name: "vite-plugin-node-red:client:locales-generator",
     apply: "build",
@@ -1199,17 +1416,17 @@ Supported: ${languages.join(", ")}`
       }
       function forEachFile(baseDir, fileExtensions, processFile) {
         const langMap = /* @__PURE__ */ new Map();
-        if (!fs7.existsSync(baseDir)) return langMap;
-        const nodeDirs = fs7.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+        if (!fs8.existsSync(baseDir)) return langMap;
+        const nodeDirs = fs8.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
         for (const nodeDir of nodeDirs) {
           const nodeType = nodeDir.name;
-          const nodePath = path7.join(baseDir, nodeType);
-          const files = fs7.readdirSync(nodePath);
+          const nodePath = path8.join(baseDir, nodeType);
+          const files = fs8.readdirSync(nodePath);
           for (const file of files) {
-            const ext = path7.extname(file);
+            const ext = path8.extname(file);
             if (!fileExtensions.includes(ext)) continue;
-            const lang = path7.basename(file, ext);
-            const filePath = path7.join(nodePath, file);
+            const lang = path8.basename(file, ext);
+            const filePath = path8.join(nodePath, file);
             validateLanguage(lang, filePath);
             const value = processFile({ ext, filePath, nodeType });
             if (value == null) continue;
@@ -1227,10 +1444,10 @@ Supported: ${languages.join(", ")}`
       }
       function writeOutput(langMap, fileName, serialize) {
         for (const [lang, data] of langMap.entries()) {
-          const langOutDir = path7.join(outDir, lang);
-          fs7.mkdirSync(langOutDir, { recursive: true });
-          fs7.writeFileSync(
-            path7.join(langOutDir, fileName),
+          const langOutDir = path8.join(outDir, lang);
+          fs8.mkdirSync(langOutDir, { recursive: true });
+          fs8.writeFileSync(
+            path8.join(langOutDir, fileName),
             serialize(data),
             "utf-8"
           );
@@ -1242,7 +1459,7 @@ Supported: ${languages.join(", ")}`
         ({ ext, filePath, nodeType }) => {
           const type = ext === ".html" ? "text/html" : ext === ".md" ? "text/markdown" : null;
           if (!type) return null;
-          const content = fs7.readFileSync(filePath, "utf-8");
+          const content = fs8.readFileSync(filePath, "utf-8");
           return [
             `<script type="${type}" data-help-name="${nodeType}">
 ${content}
@@ -1258,7 +1475,15 @@ ${content}
       const labelLangs = forEachFile(
         labelsDir,
         [".json"],
-        ({ filePath }) => JSON.parse(fs7.readFileSync(filePath, "utf-8"))
+        ({ filePath, nodeType }) => {
+          const parsed = JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+          if (parsed[nodeType] && typeof parsed[nodeType] === "object") {
+            console.warn(
+              `[locales] Warning: "${filePath}" uses nested format (root key "${nodeType}"). Label files should be flat \u2014 the node type is added automatically. See https://bonsaedev.github.io/nrg/guide/building-and-running`
+            );
+          }
+          return parsed;
+        }
       );
       writeOutput(
         labelLangs,
@@ -1290,10 +1515,10 @@ function minifier() {
 }
 
 // src/vite/client/plugins/node-definitions-inliner.ts
-import { createRequire } from "module";
-import { pathToFileURL } from "url";
-import path8 from "path";
-import fs8 from "fs";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import path9 from "path";
+import fs9 from "fs";
 import mime2 from "mime-types";
 var VIRTUAL_ID = "virtual:nrg/node-definitions";
 var RESOLVED_ID = "\0" + VIRTUAL_ID;
@@ -1324,9 +1549,9 @@ function getCredentialsFromSchema(schema) {
   return result;
 }
 function resolveIcon(iconsDir, type) {
-  if (!fs8.existsSync(iconsDir)) return void 0;
-  return fs8.readdirSync(iconsDir).find((f) => {
-    if (path8.basename(f, path8.extname(f)) !== type) return false;
+  if (!fs9.existsSync(iconsDir)) return void 0;
+  return fs9.readdirSync(iconsDir).find((f) => {
+    if (path9.basename(f, path9.extname(f)) !== type) return false;
     const mimeType = mime2.lookup(f);
     return mimeType !== false && mimeType.startsWith("image/");
   });
@@ -1334,7 +1559,7 @@ function resolveIcon(iconsDir, type) {
 function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir, nodesDir, hasUserEntry = true) {
   let _nodeTypes = [];
   let _definitions = {};
-  const cacheDir = path8.resolve("node_modules", ".nrg", "client");
+  const cacheDir = path9.resolve("node_modules", ".nrg", "client");
   return {
     name: "vite-plugin-node-red:client:node-definitions-inliner",
     enforce: "pre",
@@ -1343,15 +1568,15 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     async buildStart() {
       _nodeTypes = [];
       _definitions = {};
-      const esmEntryPath = path8.resolve(serverOutDir, "index.mjs");
-      const cjsEntryPath = path8.resolve(serverOutDir, "index.js");
+      const esmEntryPath = path9.resolve(serverOutDir, "index.mjs");
+      const cjsEntryPath = path9.resolve(serverOutDir, "index.js");
       let packageFn;
-      if (fs8.existsSync(esmEntryPath)) {
-        const fileUrl = pathToFileURL(esmEntryPath).href + `?t=${Date.now()}`;
+      if (fs9.existsSync(esmEntryPath)) {
+        const fileUrl = pathToFileURL2(esmEntryPath).href + `?t=${Date.now()}`;
         const mod = await import(fileUrl);
         packageFn = mod?.default ?? mod;
-      } else if (fs8.existsSync(cjsEntryPath)) {
-        const require2 = createRequire(import.meta.url);
+      } else if (fs9.existsSync(cjsEntryPath)) {
+        const require2 = createRequire2(import.meta.url);
         delete require2.cache[cjsEntryPath];
         const rawMod = require2(cjsEntryPath);
         packageFn = rawMod?.default ?? rawMod;
@@ -1395,14 +1620,14 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
         };
       }
       if (!hasUserEntry) {
-        const nodesCache = path8.resolve(cacheDir, "nodes");
-        if (fs8.existsSync(nodesCache)) {
-          fs8.rmSync(nodesCache, { recursive: true });
+        const nodesCache = path9.resolve(cacheDir, "nodes");
+        if (fs9.existsSync(nodesCache)) {
+          fs9.rmSync(nodesCache, { recursive: true });
         }
-        fs8.mkdirSync(nodesCache, { recursive: true });
+        fs9.mkdirSync(nodesCache, { recursive: true });
         for (const type of _nodeTypes) {
-          const userTsPath = nodesDir ? path8.resolve(nodesDir, `${type}.ts`) : null;
-          if (userTsPath && fs8.existsSync(userTsPath)) continue;
+          const userTsPath = nodesDir ? path9.resolve(nodesDir, `${type}.ts`) : null;
+          if (userTsPath && fs9.existsSync(userTsPath)) continue;
           const content = [
             `// auto-generated by nrg`,
             `import { defineNode } from "@bonsae/nrg/client";`,
@@ -1412,13 +1637,13 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
             `});`,
             ``
           ].join("\n");
-          fs8.writeFileSync(path8.resolve(nodesCache, `${type}.ts`), content);
+          fs9.writeFileSync(path9.resolve(nodesCache, `${type}.ts`), content);
         }
         const entryContent = generateEntryCode("");
-        fs8.mkdirSync(path8.dirname(path8.resolve(cacheDir, "index.ts")), {
+        fs9.mkdirSync(path9.dirname(path9.resolve(cacheDir, "index.ts")), {
           recursive: true
         });
-        fs8.writeFileSync(path8.resolve(cacheDir, "index.ts"), entryContent);
+        fs9.writeFileSync(path9.resolve(cacheDir, "index.ts"), entryContent);
       }
     },
     resolveId(id) {
@@ -1441,12 +1666,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     const nrgImports = /* @__PURE__ */ new Set(["__setSchemas"]);
     const lines = [`import __nrgSchemas from "${VIRTUAL_ID}";`];
     const postLines = [`__setSchemas(__nrgSchemas);`];
-    if (componentsDir && fs8.existsSync(componentsDir)) {
+    if (componentsDir && fs9.existsSync(componentsDir)) {
       const formImports = [];
       const formEntries = [];
       for (const type of _nodeTypes) {
-        const componentPath = path8.resolve(componentsDir, `${type}.vue`);
-        if (fs8.existsSync(componentPath)) {
+        const componentPath = path9.resolve(componentsDir, `${type}.vue`);
+        if (fs9.existsSync(componentPath)) {
           const varName = `__nrgForm_${type.replace(/-/g, "_")}`;
           formImports.push(
             `import ${varName} from ${JSON.stringify(componentPath)};`
@@ -1461,12 +1686,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
       }
     }
     if (!hasUserEntry) {
-      const nodesCache = path8.resolve(cacheDir, "nodes");
+      const nodesCache = path9.resolve(cacheDir, "nodes");
       const defVarNames = [];
       for (const type of _nodeTypes) {
         const varName = `__nrgNodeDef_${type.replace(/-/g, "_")}`;
-        const userTsPath = nodesDir ? path8.resolve(nodesDir, `${type}.ts`) : null;
-        const tsPath = userTsPath && fs8.existsSync(userTsPath) ? userTsPath : path8.resolve(nodesCache, `${type}.ts`);
+        const userTsPath = nodesDir ? path9.resolve(nodesDir, `${type}.ts`) : null;
+        const tsPath = userTsPath && fs9.existsSync(userTsPath) ? userTsPath : path9.resolve(nodesCache, `${type}.ts`);
         lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
         defVarNames.push(varName);
       }
@@ -1484,8 +1709,8 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
 }
 
 // src/vite/client/plugins/static-copy.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 function staticCopy(options) {
   const { targets } = options;
   return {
@@ -1494,23 +1719,23 @@ function staticCopy(options) {
     enforce: "post",
     closeBundle() {
       for (const { src, dest } of targets) {
-        if (!fs9.existsSync(src)) continue;
-        fs9.mkdirSync(dest, { recursive: true });
-        const stat = fs9.statSync(src);
+        if (!fs10.existsSync(src)) continue;
+        fs10.mkdirSync(dest, { recursive: true });
+        const stat = fs10.statSync(src);
         if (stat.isDirectory()) {
-          const files = fs9.readdirSync(src);
+          const files = fs10.readdirSync(src);
           for (const file of files) {
-            const srcFile = path9.join(src, file);
-            const destFile = path9.join(dest, file);
-            const fileStat = fs9.statSync(srcFile);
+            const srcFile = path10.join(src, file);
+            const destFile = path10.join(dest, file);
+            const fileStat = fs10.statSync(srcFile);
             if (fileStat.isDirectory()) {
-              fs9.cpSync(srcFile, destFile, { recursive: true });
+              fs10.cpSync(srcFile, destFile, { recursive: true });
             } else {
-              fs9.copyFileSync(srcFile, destFile);
+              fs10.copyFileSync(srcFile, destFile);
             }
           }
         } else {
-          fs9.copyFileSync(src, dest);
+          fs10.copyFileSync(src, dest);
         }
       }
     }
@@ -1532,32 +1757,32 @@ async function build2(clientBuildOptions, buildContext) {
     manualChunks,
     plugins: userPlugins = []
   } = clientBuildOptions;
-  const physicalEntryPath = path10.resolve(srcDir, entry);
+  const physicalEntryPath = path11.resolve(srcDir, entry);
   let entryPath;
   let generatedEntry = false;
-  if (fs10.existsSync(physicalEntryPath)) {
+  if (fs11.existsSync(physicalEntryPath)) {
     entryPath = physicalEntryPath;
   } else {
-    const cacheDir = path10.resolve("node_modules", ".nrg", "client");
-    const cachedEntryPath = path10.resolve(cacheDir, entry);
-    if (!fs10.existsSync(cacheDir)) {
-      fs10.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path11.resolve("node_modules", ".nrg", "client");
+    const cachedEntryPath = path11.resolve(cacheDir, entry);
+    if (!fs11.existsSync(cacheDir)) {
+      fs11.mkdirSync(cacheDir, { recursive: true });
     }
-    fs10.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    fs11.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
     entryPath = cachedEntryPath;
     generatedEntry = true;
   }
-  const iconsDir = path10.resolve(
-    staticDirs.icons ?? path10.join(path10.dirname(path10.resolve(srcDir)), "icons")
+  const iconsDir = path11.resolve(
+    staticDirs.icons ?? path11.join(path11.dirname(path11.resolve(srcDir)), "icons")
   );
   const plugins = [
     vue(),
     nodeDefinitionsInliner(
       buildContext.outDir,
       entryPath,
-      fs10.existsSync(iconsDir) ? iconsDir : void 0,
-      path10.resolve(srcDir, "components"),
-      path10.resolve(srcDir, "nodes"),
+      fs11.existsSync(iconsDir) ? iconsDir : void 0,
+      path11.resolve(srcDir, "components"),
+      path11.resolve(srcDir, "nodes"),
       !generatedEntry
     ),
     ...userPlugins
@@ -1565,49 +1790,42 @@ async function build2(clientBuildOptions, buildContext) {
   plugins.push(
     htmlGenerator({
       packageName: buildContext.packageName,
-      licensePath: licensePath ? path10.resolve(licensePath) : void 0
+      licensePath: licensePath ? path11.resolve(licensePath) : void 0
     })
   );
   if (locales) {
-    const {
-      docsDir = "./locales/docs",
-      labelsDir = "./locales/labels",
-      languages = [
-        "en-US",
-        "de",
-        "es-ES",
-        "fr",
-        "ko",
-        "pt-BR",
-        "ru",
-        "ja",
-        "zh-CN",
-        "zh-TW"
-      ]
-    } = locales;
+    const { docsDir = "./locales/docs", labelsDir = "./locales/labels" } = locales;
+    const localesOutDir = path11.join(buildContext.outDir, "locales");
     plugins.push(
       localesGenerator({
-        outDir: path10.join(buildContext.outDir, "locales"),
-        docsDir: path10.resolve(docsDir),
-        labelsDir: path10.resolve(labelsDir),
-        languages
+        outDir: localesOutDir,
+        docsDir: path11.resolve(docsDir),
+        labelsDir: path11.resolve(labelsDir)
+      })
+    );
+    plugins.push(
+      helpGenerator({
+        outDir: buildContext.outDir,
+        localesOutDir,
+        docsDir: path11.resolve(docsDir),
+        labelsDir: path11.resolve(labelsDir)
       })
     );
   }
   const copyTargets = [];
-  const publicDir = path10.resolve(
-    staticDirs.public ?? path10.join(srcDir, "public")
+  const publicDir = path11.resolve(
+    staticDirs.public ?? path11.join(srcDir, "public")
   );
-  if (fs10.existsSync(publicDir)) {
+  if (fs11.existsSync(publicDir)) {
     copyTargets.push({
       src: publicDir,
-      dest: path10.join(buildContext.outDir, "resources")
+      dest: path11.join(buildContext.outDir, "resources")
     });
   }
-  if (fs10.existsSync(iconsDir)) {
+  if (fs11.existsSync(iconsDir)) {
     copyTargets.push({
       src: iconsDir,
-      dest: path10.join(buildContext.outDir, "icons")
+      dest: path11.join(buildContext.outDir, "icons")
     });
   }
   if (copyTargets.length > 0) {
@@ -1634,11 +1852,11 @@ async function build2(clientBuildOptions, buildContext) {
   const config = {
     configFile: false,
     logLevel: "warn",
-    base: `/${path10.join("resources", buildContext.packageName)}`,
-    publicDir: path10.resolve(srcDir, "public"),
+    base: `/${path11.join("resources", buildContext.packageName)}`,
+    publicDir: path11.resolve(srcDir, "public"),
     resolve: {
       alias: {
-        "@": path10.resolve(srcDir)
+        "@": path11.resolve(srcDir)
       }
     },
     plugins,
@@ -1661,9 +1879,9 @@ async function build2(clientBuildOptions, buildContext) {
         external,
         treeshake: false,
         output: {
-          entryFileNames: path10.join("resources", "index.[hash].js"),
-          chunkFileNames: path10.join("resources", "vendor.[hash].js"),
-          assetFileNames: path10.join("resources", "[name].[hash].[ext]"),
+          entryFileNames: path11.join("resources", "index.[hash].js"),
+          chunkFileNames: path11.join("resources", "vendor.[hash].js"),
+          assetFileNames: path11.join("resources", "[name].[hash].[ext]"),
           globals,
           paths: {
             vue: "/nrg/assets/vue.esm-browser.prod.js",
@@ -1689,8 +1907,8 @@ async function build2(clientBuildOptions, buildContext) {
     throw new BuildError("client", error);
   } finally {
     if (generatedEntry) {
-      if (fs10.existsSync(entryPath)) {
-        fs10.unlinkSync(entryPath);
+      if (fs11.existsSync(entryPath)) {
+        fs11.unlinkSync(entryPath);
       }
     }
   }
@@ -1841,20 +2059,20 @@ function serverPlugin(options) {
       });
       logger.startGroup("Node-RED");
       nodeRedLauncher.flushLogs();
-      const serverSrcDir = path11.resolve(
+      const serverSrcDir = path12.resolve(
         serverBuildOptions.srcDir ?? "./server"
       );
-      const clientSrcDir = path11.resolve(
+      const clientSrcDir = path12.resolve(
         clientBuildOptions.srcDir ?? "./client"
       );
-      const localesDocsDir = path11.resolve(
+      const localesDocsDir = path12.resolve(
         clientBuildOptions.locales?.docsDir ?? "./locales/docs"
       );
-      const localesLabelsDir = path11.resolve(
+      const localesLabelsDir = path12.resolve(
         clientBuildOptions.locales?.labelsDir ?? "./locales/labels"
       );
-      const iconsDir = path11.resolve(
-        clientBuildOptions.staticDirs?.icons ?? path11.join(path11.dirname(clientSrcDir), "icons")
+      const iconsDir = path12.resolve(
+        clientBuildOptions.staticDirs?.icons ?? path12.join(path12.dirname(clientSrcDir), "icons")
       );
       const watchPaths = [
         serverSrcDir,
@@ -1874,7 +2092,7 @@ function serverPlugin(options) {
       );
       const handleFileChange = (file, event) => {
         if (!initialStartDone) return;
-        logger.info(`${event}: ${path11.relative(process.cwd(), file)}`);
+        logger.info(`${event}: ${path12.relative(process.cwd(), file)}`);
         debounceBeforeStart();
       };
       watcher.on("change", (file) => handleFileChange(file, "Changed"));
@@ -1913,8 +2131,8 @@ function serverPlugin(options) {
 
 // src/vite/plugins/build.ts
 import { execSync } from "child_process";
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path13 from "path";
 function buildPlugin(options) {
   const {
     serverBuildOptions,
@@ -1929,16 +2147,16 @@ function buildPlugin(options) {
       try {
         logger.intro();
         logger.startSpinner("Type checking");
-        const serverTsconfig = path12.resolve(
+        const serverTsconfig = path13.resolve(
           serverBuildOptions.srcDir ?? "./src/server",
           "tsconfig.json"
         );
-        const clientTsconfig = path12.resolve(
+        const clientTsconfig = path13.resolve(
           clientBuildOptions.srcDir ?? "./src/client",
           "tsconfig.json"
         );
         const tsconfigsToCheck = [serverTsconfig, clientTsconfig].filter(
-          (p) => fs11.existsSync(p)
+          (p) => fs12.existsSync(p)
         );
         try {
           for (const tsconfig of tsconfigsToCheck) {
@@ -1998,7 +2216,7 @@ function nodeRed(options = {}) {
     options.nodeRedLauncherOptions
   );
   const extraFilesCopyTargets = options.extraFilesCopyTargets ?? DEFAULT_EXTRA_FILES_COPY_TARGETS;
-  const resolvedOutDir = path13.resolve(outDir);
+  const resolvedOutDir = path14.resolve(outDir);
   const buildContext = {
     outDir: resolvedOutDir,
     packageName: getPackageName(),