@bonsae/nrg 0.6.0 → 0.6.2

package/types/vite.d.ts

@@ -0,0 +1,12 @@
+
+import type { Plugin } from "vite";
+
+export interface NodeRedPluginOptions {
+  outDir?: string;
+  serverBuildOptions?: Record<string, any>;
+  clientBuildOptions?: Record<string, any>;
+  nodeRedLauncherOptions?: Record<string, any>;
+  extraFilesCopyTargets?: Array<{ src: string; dest: string }>;
+}
+
+export declare function nodeRed(options?: NodeRedPluginOptions): Plugin[];

package/{build/vite → vite}/index.js

@@ -619,6 +619,87 @@ function getNodeTypeExports(filePath) {
   }
   return result;
 }
+var SCHEMA_PROP_SEMANTICS = {
+  configSchema: "ConfigSchema",
+  credentialsSchema: "CredentialsSchema",
+  inputSchema: "InputSchema",
+  outputsSchema: "OutputsSchema",
+  settingsSchema: "SettingsSchema"
+};
+function getSchemaReferences(filePath) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const source = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const importMap = /* @__PURE__ */ new Map();
+  for (const stmt of source.statements) {
+    if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+      const moduleSpecifier = stmt.moduleSpecifier.text;
+      const namedBindings = stmt.importClause.namedBindings;
+      if (namedBindings && ts.isNamedImports(namedBindings)) {
+        for (const el of namedBindings.elements) {
+          importMap.set(el.name.text, moduleSpecifier);
+        }
+      }
+    }
+  }
+  const schemaRefs = /* @__PURE__ */ new Map();
+  function extractIdentifiers(node) {
+    if (ts.isIdentifier(node)) return [node.text];
+    if (ts.isArrayLiteralExpression(node)) {
+      return node.elements.filter(ts.isIdentifier).map((el) => el.text);
+    }
+    return [];
+  }
+  for (const stmt of source.statements) {
+    if (ts.isClassDeclaration(stmt)) {
+      for (const member of stmt.members) {
+        if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && member.name.text in SCHEMA_PROP_SEMANTICS && member.initializer) {
+          const ids = extractIdentifiers(member.initializer);
+          if (ids.length > 0) {
+            schemaRefs.set(member.name.text, ids);
+          }
+        }
+      }
+    }
+    if (ts.isExportAssignment(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+      const callee = stmt.expression.expression;
+      if (ts.isIdentifier(callee) && (callee.text === "defineIONode" || callee.text === "defineConfigNode")) {
+        const arg = stmt.expression.arguments[0];
+        if (arg && ts.isObjectLiteralExpression(arg)) {
+          for (const prop of arg.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text in SCHEMA_PROP_SEMANTICS) {
+              const ids = extractIdentifiers(prop.initializer);
+              if (ids.length > 0) {
+                schemaRefs.set(prop.name.text, ids);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const result = [];
+  for (const [propName, identifiers] of schemaRefs) {
+    const semanticName = SCHEMA_PROP_SEMANTICS[propName];
+    const isArray = identifiers.length > 1;
+    for (const identifier of identifiers) {
+      const importSource = importMap.get(identifier);
+      if (importSource) {
+        result.push({
+          localName: identifier,
+          semanticName: isArray ? identifier : semanticName,
+          importSource,
+          tupleProp: isArray ? semanticName : void 0
+        });
+      }
+    }
+  }
+  return result;
+}
 function buildNodeReexports(srcDir, entryFile) {
   const nodesDir = path3.join(srcDir, "nodes");
   const nodeFiles = collectTsFiles(nodesDir);
@@ -635,6 +716,20 @@ function buildNodeReexports(srcDir, entryFile) {
       ).join(", ");
       lines.push(`export type { ${prefixed} } from "${specifier}";`);
     }
+    const schemaRefs = getSchemaReferences(file);
+    const bySource = /* @__PURE__ */ new Map();
+    for (const ref of schemaRefs) {
+      const resolvedSource = path3.relative(
+        path3.dirname(entryFile),
+        path3.resolve(path3.dirname(file), ref.importSource)
+      ).replace(/\\/g, "/");
+      const sourceSpecifier = resolvedSource.startsWith(".") ? resolvedSource : `./${resolvedSource}`;
+      if (!bySource.has(sourceSpecifier)) bySource.set(sourceSpecifier, []);
+      bySource.get(sourceSpecifier).push(`${ref.localName} as ${ns}${ref.semanticName}`);
+    }
+    for (const [source, names] of bySource) {
+      lines.push(`export { ${names.join(", ")} } from "${source}";`);
+    }
     return lines.join("\n");
   }).join("\n");
 }

package/build/vite/utils.js

@@ -1,56 +0,0 @@
-// src/vite/utils.ts
-import fs from "fs";
-import path from "path";
-function cleanDir(dir) {
-  if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true });
-  }
-  fs.mkdirSync(dir, { recursive: true });
-}
-function copyFiles(targets, outDir) {
-  for (const { src, dest } of targets) {
-    const srcPath = path.resolve(src);
-    const destPath = path.join(outDir, dest);
-    if (!fs.existsSync(srcPath)) {
-      continue;
-    }
-    const stat = fs.statSync(srcPath);
-    if (stat.isDirectory()) {
-      fs.cpSync(srcPath, destPath, { recursive: true });
-    } else {
-      fs.mkdirSync(path.dirname(destPath), { recursive: true });
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-function getPackageName() {
-  const pkgPath = path.resolve("./package.json");
-  if (fs.existsSync(pkgPath)) {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    return pkg.name;
-  }
-  return "node-red-nodes";
-}
-function mergeOptions(defaults, overrides) {
-  if (!overrides) return { ...defaults };
-  const result = { ...defaults };
-  for (const key of Object.keys(overrides)) {
-    const overrideVal = overrides[key];
-    const defaultVal = defaults[key];
-    if (overrideVal !== void 0 && !Array.isArray(overrideVal) && !Array.isArray(defaultVal) && typeof overrideVal === "object" && typeof defaultVal === "object" && overrideVal !== null && defaultVal !== null) {
-      result[key] = mergeOptions(
-        defaultVal,
-        overrideVal
-      );
-    } else if (overrideVal !== void 0) {
-      result[key] = overrideVal;
-    }
-  }
-  return result;
-}
-export {
-  cleanDir,
-  copyFiles,
-  getPackageName,
-  mergeOptions
-};

package/src/core/client/app.vue

@@ -1,185 +0,0 @@
-<template>
-  <div
-    v-if="features.hasInputSchema || features.hasOutputSchema"
-    class="form-row"
-    style="display: flex; align-items: center; gap: 12px"
-  >
-    <NodeRedToggle
-      v-if="features.hasInputSchema"
-      :model-value="localNode.validateInput"
-      label="Validate Input"
-      style="flex: 1"
-      @update:model-value="localNode.validateInput = $event"
-    />
-    <NodeRedToggle
-      v-if="features.hasOutputSchema"
-      :model-value="localNode.validateOutput"
-      label="Validate Output"
-      style="flex: 1"
-      @update:model-value="localNode.validateOutput = $event"
-    />
-  </div>
-  <div style="width: 100%; padding-bottom: 12px">
-    <NodeRedNodeForm
-      :node="localNode"
-      :schema="schema"
-      :errors="errors"
-      style="width: 100%"
-    />
-  </div>
-</template>
-
-<script lang="ts">
-import jsonpointer from "jsonpointer";
-import { type JSONSchemaType } from "ajv";
-import type { PropType } from "vue";
-import { defineComponent } from "vue";
-import { validator } from "../validator";
-
-export default defineComponent({
-  name: "NodeRedVueApp",
-  props: {
-    node: {
-      type: Object,
-      required: true,
-    },
-    schema: {
-      type: Object as PropType<JSONSchemaType<any>>,
-      required: true,
-    },
-    features: {
-      type: Object as PropType<{
-        hasInputSchema: boolean;
-        hasOutputSchema: boolean;
-      }>,
-      required: true,
-    },
-  },
-  data() {
-    return {
-      localNode: this.node,
-      errors: {},
-    };
-  },
-  beforeMount() {
-    // Normalize array-typed properties to actual arrays. Nodes saved with an
-    // older version of the code may have stored array values as comma-separated
-    // strings; this ensures validation and future saves always see real arrays.
-    if (this.schema?.properties) {
-      for (const [prop, propSchema] of Object.entries(this.schema.properties)) {
-        if (
-          (propSchema as any).type === "array" &&
-          !Array.isArray(this.localNode[prop])
-        ) {
-          const val = this.localNode[prop];
-          this.localNode[prop] = val
-            ? String(val).split(",").filter(Boolean)
-            : [];
-        }
-      }
-    }
-
-    // Set __PWD__ for existing password fields before the first validation so
-    // the password-skip logic in validate() sees the sentinel value correctly.
-    if (this.localNode._def.credentials) {
-      Object.keys(this.localNode._def.credentials).forEach((prop) => {
-        if (
-          this.localNode._def.credentials[prop].type === "password" &&
-          this.localNode.credentials[`has_${prop}`]
-        ) {
-          this.localNode.credentials[prop] = "__PWD__";
-        }
-      });
-    }
-
-    this.validate();
-
-    if (this.localNode._def.defaults) {
-      Object.keys(this.localNode._def.defaults).forEach((prop) => {
-        this.$watch(
-          () => this.localNode[prop],
-          () => {
-            this.validate();
-          },
-          { deep: true },
-        );
-      });
-    }
-
-    if (this.localNode._def.credentials) {
-      Object.keys(this.localNode._def.credentials).forEach((prop) => {
-        this.$watch(
-          () => this.localNode.credentials[prop],
-          (newVal, oldVal) => {
-            this.validate();
-
-            if (
-              this.localNode._def.credentials[prop].type === "password" &&
-              newVal !== oldVal
-            ) {
-              this.localNode.credentials[`has_${prop}`] = !!newVal;
-            }
-          },
-          { deep: true },
-        );
-      });
-    }
-  },
-  beforeUnmount() {
-    // NOTE: must set credentials prop to undefined to avoid updating it to __PWD__ in the server
-    if (this.localNode._def.credentials) {
-      Object.keys(this.localNode._def.credentials).forEach((prop) => {
-        if (
-          this.localNode._def.credentials[prop].type === "password" &&
-          this.localNode.credentials?.[`has_${prop}`] &&
-          this.localNode.credentials?.[prop] === "__PWD__"
-        ) {
-          this.localNode.credentials[prop] = undefined;
-        }
-      });
-    }
-  },
-  methods: {
-    validate() {
-      const result = validator.validate(this.localNode, this.schema, {
-        cacheKey: `node-schema-${this.node.type}`,
-      });
-
-      if (!result.valid) {
-        this.errors = result.errors.reduce((acc, error) => {
-          const errorValue = jsonpointer.get(
-            this.localNode,
-            error.instancePath,
-          );
-          if (
-            error.parentSchema?.format === "password" &&
-            errorValue === "__PWD__"
-          ) {
-            return acc;
-          } else {
-            const key = `node${error.instancePath.replaceAll("/", ".")}`;
-            acc[key] = error.message;
-            return acc;
-          }
-        }, {});
-      } else {
-        this.errors = {};
-      }
-    },
-  },
-});
-</script>
-
-<style scoped>
-:deep(.node-red-vue-input-error-message) {
-  color: var(--red-ui-text-color-error);
-}
-
-:deep(.form-row input[type="text"]),
-:deep(.form-row input[type="number"]),
-:deep(.form-row input[type="password"]) {
-  height: 34px;
-  padding: 0 8px;
-  box-sizing: border-box;
-}
-</style>

package/src/core/client/components/node-red-config-input.vue

@@ -1,79 +0,0 @@
-<template>
-  <div style="display: flex; flex-direction: column; width: 100%">
-    <slot name="label">
-      <NodeRedInputLabel
-        v-if="label"
-        :label="label"
-        :icon="icon"
-        :required="required"
-      />
-    </slot>
-    <input :id="inputId" type="text" style="width: 100%" />
-    <div v-if="error" class="node-red-vue-input-error-message">
-      {{ error }}
-    </div>
-  </div>
-</template>
-
-<script lang="ts">
-import { defineComponent } from "vue";
-import NodeRedInputLabel from "./node-red-input-label.vue";
-export default defineComponent({
-  components: { NodeRedInputLabel },
-  props: {
-    value: {
-      type: String,
-      default: "",
-    },
-    type: {
-      type: String,
-      required: true,
-    },
-    node: {
-      type: Object,
-      required: true,
-    },
-    propName: {
-      type: String,
-      required: true,
-    },
-    label: {
-      type: String,
-      default: "",
-    },
-    icon: {
-      type: String,
-      default: "",
-    },
-    required: {
-      type: Boolean,
-      default: false,
-    },
-    error: {
-      type: String,
-      default: "",
-    },
-  },
-  emits: ["update:value"],
-  computed: {
-    inputId() {
-      return "node-input-" + this.propName;
-    },
-  },
-  mounted() {
-    RED.editor.prepareConfigNodeSelect(
-      this.node,
-      this.propName,
-      this.type,
-      "node-input",
-    );
-
-    const input = $("#" + this.inputId);
-    input.on("change", () => {
-      this.$emit("update:value", input.val());
-    });
-
-    input.val(this.value || "_ADD_");
-  },
-});
-</script>