@bonsae/nrg 0.6.1 → 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/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>

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

@@ -1,307 +0,0 @@
-<template>
-  <div ref="container" class="container">
-    <slot name="label">
-      <NodeRedInputLabel
-        v-if="label"
-        :label="label"
-        :icon="icon"
-        :required="required"
-      />
-    </slot>
-    <div class="editor-wrapper">
-      <button
-        ref="expand-button"
-        class="red-ui-button red-ui-button-small expand-button"
-        @click="onClickExpand"
-      >
-        <i class="fa fa-expand"></i>
-      </button>
-      <div :id="editorId" ref="editor"></div>
-    </div>
-    <div v-show="error" class="node-red-vue-input-error-message">
-      {{ error }}
-    </div>
-  </div>
-</template>
-
-<script lang="ts">
-// TODO: expose editor apis
-import { defineComponent } from "vue";
-import NodeRedInputLabel from "./node-red-input-label.vue";
-export default defineComponent({
-  components: { NodeRedInputLabel },
-  props: {
-    value: {
-      type: String,
-      default: "",
-    },
-    language: {
-      type: String,
-      default: "json",
-      validator: function (value) {
-        const allowedLanguages = [
-          "abap",
-          "apex",
-          "azcli",
-          "bat",
-          "bicep",
-          "cameligo",
-          "clojure",
-          "coffee",
-          "cpp",
-          "csharp",
-          "csp",
-          "css",
-          "cypher",
-          "dart",
-          "dockerfile",
-          "ecl",
-          "elixir",
-          "flow9",
-          "freemarker2",
-          "fsharp",
-          "go",
-          "graphql",
-          "handlebars",
-          "hcl",
-          "html",
-          "ini",
-          "java",
-          "javascript",
-          "json",
-          "julia",
-          "kotlin",
-          "less",
-          "lexon",
-          "liquid",
-          "lua",
-          "m3",
-          "markdown",
-          "mdx",
-          "mips",
-          "msdax",
-          "mysql",
-          "objective-c",
-          "pascal",
-          "pascaligo",
-          "perl",
-          "pgsql",
-          "php",
-          "pla",
-          "postiats",
-          "powerquery",
-          "powershell",
-          "protobuf",
-          "pub",
-          "python",
-          "qsharp",
-          "r",
-          "razor",
-          "redis",
-          "redshift",
-          "restructuredtext",
-          "ruby",
-          "rust",
-          "sb",
-          "scala",
-          "scheme",
-          "scss",
-          "shell",
-          "solidity",
-          "sophia",
-          "sparql",
-          "sql",
-          "st",
-          "swift",
-          "systemverilog",
-          "tcl",
-          "twig",
-          "typescript",
-          "typespec",
-          "vb",
-          "wgsl",
-          "xml",
-          "yaml",
-        ];
-        const isValid = allowedLanguages.includes(value);
-        if (!isValid) {
-          console.warn(
-            `[WARN]: Invalid value for 'type' property: "${value}". ` +
-              `Expected one of: ${allowedLanguages.join(", ")}`,
-          );
-        }
-        return isValid;
-      },
-    },
-    label: {
-      type: String,
-      default: "",
-    },
-    icon: {
-      type: String,
-      default: "",
-    },
-    required: {
-      type: Boolean,
-      default: false,
-    },
-    error: {
-      type: String,
-      default: "",
-    },
-  },
-  emits: ["update:value"],
-  editor: null,
-  data() {
-    const stateId = Math.random().toString(36).substring(2, 9);
-    return {
-      editorId: "node-red-editor-" + stateId,
-      stateId,
-    };
-  },
-  mounted() {
-    // NOTE: jquery wrapper is used because RED.popover.tooltip needs it
-    const expandButton = $(this.$refs["expand-button"]);
-    RED.popover.tooltip(expandButton, RED._("node-red:common.label.expand"));
-    this.mountEditor();
-    this.createExpandeEditorTray();
-  },
-  beforeUnmount() {
-    if (this.editorInstance) {
-      try {
-        this.editorInstance.destroy();
-      } catch (err) {
-        console.error(`Error destroying editor for ID ${this.editorId}:`, err);
-      }
-      this.editorInstance = null;
-    }
-  },
-  methods: {
-    mountEditor() {
-      this.$nextTick(() => {
-        const containerEl = this.$refs.container;
-        const editorEl = this.$refs.editor;
-
-        if (containerEl && editorEl) {
-          try {
-            const inlineHeight = containerEl.style.height;
-            const inlineWidth = containerEl.style.width;
-            if (inlineHeight) {
-              editorEl.style.height = inlineHeight;
-            } else {
-              editorEl.style.height = "200px";
-            }
-
-            if (inlineWidth) {
-              editorEl.style.width = inlineWidth;
-            } else {
-              editorEl.style.width = "100%";
-            }
-
-            this.createEditorInstance();
-          } catch (e) {
-            console.error(
-              "[NodeRedEditorInput] Error setting initial editor style:",
-              e,
-            );
-            this.createEditorInstance();
-          }
-        } else {
-          console.error(
-            "[NodeRedEditorInput] Container or Editor div refs not found on mount.",
-          );
-        }
-      });
-    },
-    createEditorInstance() {
-      this.editorInstance = RED.editor.createEditor({
-        id: this.editorId,
-        mode: this.language,
-        value: this.value,
-      });
-      this.editorInstance.getSession().on("change", () => {
-        const currentValue = this.editorInstance.getValue();
-        if (currentValue !== this.value) {
-          this.$emit("update:value", currentValue);
-        }
-      });
-    },
-    createExpandeEditorTray() {
-      let expandedEditor;
-
-      const onCancel = () => {
-        setTimeout(() => {
-          this.editorInstance.focus();
-        }, 250);
-        RED.tray.close();
-      };
-
-      const onDone = () => {
-        expandedEditor.saveView();
-        this.editorInstance.setValue(expandedEditor.getValue(), -1);
-        setTimeout(() => {
-          this.editorInstance.restoreView();
-          this.editorInstance.focus();
-        }, 250);
-        RED.tray.close();
-      };
-
-      this.expandedEditorTray = {
-        title: "Editor",
-        focusElement: true,
-        width: "Infinity",
-        buttons: [
-          {
-            id: "node-dialog-cancel",
-            text: RED._("common.label.cancel"),
-            click: onCancel,
-          },
-          {
-            id: "node-dialog-ok",
-            text: RED._("common.label.done"),
-            class: "primary",
-            click: onDone,
-          },
-        ],
-        open: (tray) => {
-          const dialogForm = $(
-            '<form id="dialog-form" class="form-horizontal" autocomplete="off"></form>',
-          ).appendTo(tray.find(".red-ui-tray-body"));
-          dialogForm.html(
-            '<div id="expanded-editor-input" style="height: 100%"></div>',
-          );
-
-          expandedEditor = RED.editor.createEditor({
-            id: "expanded-editor-input",
-            stateId: this.stateId,
-            mode: this.language,
-            focus: true,
-            value: this.value,
-          });
-          dialogForm.i18n();
-        },
-        close: function () {
-          expandedEditor.destroy();
-        },
-      };
-    },
-    onClickExpand() {
-      RED.tray.show(this.expandedEditorTray);
-    },
-  },
-});
-</script>
-<style scoped>
-.editor-wrapper {
-  position: relative;
-}
-
-.expand-button {
-  position: absolute;
-  top: -23px;
-  right: 0px;
-  z-index: 10;
-  transition: color 0.3s ease;
-  cursor: pointer;
-}
-</style>

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

@@ -1,53 +0,0 @@
-<template>
-  <span class="nrg-label">
-    <i v-if="icon" :class="iconClass"></i>
-    <slot>{{ label }}</slot>
-    <span v-if="required" class="nrg-required">*</span>
-  </span>
-</template>
-
-<script lang="ts">
-import { defineComponent } from "vue";
-
-export default defineComponent({
-  name: "NodeRedInputLabel",
-  props: {
-    label: {
-      type: String,
-      default: "",
-    },
-    icon: {
-      type: String,
-      default: "",
-    },
-    required: {
-      type: Boolean,
-      default: false,
-    },
-  },
-  computed: {
-    iconClass(): string {
-      if (!this.icon) return "";
-      const name = this.icon.startsWith("fa-") ? this.icon : `fa-${this.icon}`;
-      return `fa ${name}`;
-    },
-  },
-});
-</script>
-
-<style scoped>
-.nrg-label {
-  display: inline-block;
-  width: 100%;
-  cursor: default;
-}
-
-.nrg-label i {
-  margin-right: 5px;
-}
-
-.nrg-required {
-  color: var(--red-ui-text-color-error);
-  margin-left: 2px;
-}
-</style>