@bonsae/nrg-runtime 0.22.0

package/internal/client/components.mjs

@@ -0,0 +1,1287 @@
+(function(){"use strict";try{if(typeof document<"u"){var e=document.createElement("style");e.appendChild(document.createTextNode('.nrg-label[data-v-6a6f1d01]{display:inline-block;width:100%;margin-bottom:4px;cursor:default}.nrg-label i[data-v-6a6f1d01]{margin-right:5px}.nrg-required[data-v-6a6f1d01]{color:var(--red-ui-text-color-error);margin-left:2px}.editor-wrapper[data-v-9e324115]{position:relative}.expand-button[data-v-9e324115]{position:absolute;top:-23px;right:0;z-index:10;transition:color .3s ease;cursor:pointer}.nrg-toggle-wrapper[data-v-c6353798]{display:inline-flex;align-items:center}.nrg-toggle[data-v-c6353798]{position:relative;display:inline-flex!important;flex-direction:column;align-items:flex-start;cursor:pointer;gap:4px;-webkit-user-select:none;user-select:none}.nrg-toggle__input[data-v-c6353798]{position:absolute;opacity:0;width:0;height:0}.nrg-toggle__slider[data-v-c6353798]{position:relative;display:inline-block;width:36px;min-width:36px;height:20px;background-color:var(--red-ui-secondary-border-color, #ccc);border-radius:10px;transition:background-color .2s ease}.nrg-toggle__slider[data-v-c6353798]:after{content:"";position:absolute;top:2px;left:2px;width:16px;height:16px;background-color:#fff;border-radius:50%;transition:transform .2s ease}.nrg-toggle--checked .nrg-toggle__slider[data-v-c6353798]{background-color:var(--red-ui-text-color-link, #0070d2)}.nrg-toggle--checked .nrg-toggle__slider[data-v-c6353798]:after{transform:translate(16px)}.nrg-toggle__label[data-v-c6353798]{cursor:default;white-space:nowrap}.nrg-toggle__label i[data-v-c6353798]{margin-right:2px}')),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
+import { defineComponent as v, openBlock as a, createElementBlock as u, normalizeClass as E, createCommentVNode as p, renderSlot as I, createTextVNode as _, toDisplayString as g, resolveComponent as h, createBlock as m, createElementVNode as c, shallowRef as V, withDirectives as O, vShow as A, Teleport as W, Fragment as R, renderList as q, createVNode as w } from "vue";
+const D = v({
+  name: "NodeRedInputLabel",
+  props: {
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  computed: {
+    iconClass() {
+      return this.icon ? `fa ${this.icon.startsWith("fa-") ? this.icon : `fa-${this.icon}`}` : "";
+    }
+  }
+}), b = (e, t) => {
+  const o = e.__vccOpts || e;
+  for (const [i, l] of t)
+    o[i] = l;
+  return o;
+}, B = { class: "nrg-label" }, U = {
+  key: 1,
+  class: "nrg-required"
+};
+function F(e, t, o, i, l, s) {
+  return a(), u("span", B, [
+    e.icon ? (a(), u(
+      "i",
+      {
+        key: 0,
+        class: E(e.iconClass)
+      },
+      null,
+      2
+      /* CLASS */
+    )) : p("v-if", !0),
+    I(e.$slots, "default", {}, () => [
+      _(
+        g(e.label),
+        1
+        /* TEXT */
+      )
+    ], !0),
+    e.required ? (a(), u("span", U, "*")) : p("v-if", !0)
+  ]);
+}
+const T = /* @__PURE__ */ b(D, [["render", F], ["__scopeId", "data-v-6a6f1d01"]]), N = "*************", P = v({
+  components: { NodeRedInputLabel: T },
+  props: {
+    modelValue: {
+      type: [String, Number],
+      default: void 0
+    },
+    value: {
+      type: [String, Number],
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "text"
+    },
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value", "input"],
+  data() {
+    return {
+      internalValue: ""
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  beforeMount() {
+    this.internalValue = this.effectiveValue, this.onBlur();
+  },
+  methods: {
+    onInput(e) {
+      this.internalValue = e.target.value, this.$emit("update:modelValue", this.internalValue), this.$emit("update:value", this.internalValue), this.$emit("input", this.internalValue);
+    },
+    onFocus() {
+      this.type === "password" && this.internalValue === N && (this.internalValue = "");
+    },
+    onBlur() {
+      this.type === "password" && this.effectiveValue === "__PWD__" && (this.internalValue = N);
+    }
+  }
+}), z = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, M = ["type", "value", "placeholder"], J = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function K(e, t, o, i, l, s) {
+  const r = h("NodeRedInputLabel");
+  return a(), u("div", z, [
+    I(e.$slots, "label", {}, () => [
+      e.label ? (a(), m(r, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : p("v-if", !0)
+    ]),
+    c("input", {
+      ref: "inputField",
+      type: e.type,
+      value: e.internalValue,
+      placeholder: e.placeholder,
+      style: { width: "100%" },
+      onInput: t[0] || (t[0] = (...f) => e.onInput && e.onInput(...f)),
+      onFocus: t[1] || (t[1] = (...f) => e.onFocus && e.onFocus(...f)),
+      onBlur: t[2] || (t[2] = (...f) => e.onBlur && e.onBlur(...f))
+    }, null, 40, M),
+    e.error ? (a(), u(
+      "div",
+      J,
+      g(e.error),
+      1
+      /* TEXT */
+    )) : p("v-if", !0)
+  ]);
+}
+const Y = /* @__PURE__ */ b(P, [["render", K]]), H = [
+  "msg",
+  "flow",
+  "global",
+  "str",
+  "num",
+  "bool",
+  "json",
+  "bin",
+  "re",
+  "jsonata",
+  "date",
+  "env",
+  "node",
+  "cred"
+], Z = ["errorPort", "completePort", "statusPort"], G = v({
+  components: { NodeRedInputLabel: T },
+  props: {
+    modelValue: {
+      type: Object,
+      default: void 0,
+      validator: function(e) {
+        if (e === void 0) return !0;
+        if (typeof e != "object" || e === null)
+          return console.warn(
+            "[WARN] Invalid modelValue for TypedInput. It must be an object."
+          ), !1;
+        const t = typeof e.value == "string" && typeof e.type == "string";
+        return t || console.warn(
+          "[WARN] Invalid modelValue for TypedInput. It must be an object with 'value' and 'type' properties being strings.",
+          e
+        ), t;
+      }
+    },
+    value: {
+      type: Object,
+      default: void 0,
+      validator: function(e) {
+        if (e === void 0) return !0;
+        if (typeof e != "object" || e === null)
+          return console.warn(
+            "[WARN] Invalid value for TypedInput. It must be an object."
+          ), !1;
+        const t = typeof e.value == "string" && typeof e.type == "string";
+        return t || console.warn(
+          "[WARN] Invalid value for TypedInput. It must be an object with 'value' and 'type' properties being strings.",
+          e
+        ), t;
+      }
+    },
+    types: {
+      type: Array,
+      default: () => H
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value"],
+  setup() {
+    return {
+      inputWidget: V(null),
+      mutationObserver: V(null)
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    },
+    isProvidedValueTypeValid() {
+      const e = this.effectiveValue.type;
+      return this.types.includes(e);
+    }
+  },
+  watch: {
+    isProvidedValueTypeValid: {
+      handler(e) {
+        e || console.warn(
+          `Validation failed: type (${this.effectiveValue.type}) must be one of the provided types (${this.types}).`
+        );
+      },
+      immediate: !0
+    },
+    error(e) {
+      this.$nextTick(() => {
+        const t = this.$el.querySelector(
+          ".red-ui-typedInput-container"
+        );
+        t && (e ? t.classList.add("input-error") : t.classList.remove("input-error"));
+      });
+    }
+  },
+  mounted() {
+    const e = this.$refs.typedInput;
+    this.inputWidget = $(e), this.inputWidget.typedInput({
+      default: this.effectiveValue.type || this.types[0],
+      types: this.types
+    }), this.inputWidget.typedInput("value", this.effectiveValue.value || ""), this.inputWidget.typedInput(
+      "type",
+      this.effectiveValue.type || this.types[0]
+    ), this.$nextTick(() => {
+      const t = new MutationObserver((o) => {
+        for (const i of o)
+          i.attributeName === "value" && this.onChange();
+      });
+      t.observe(e, {
+        attributes: !0,
+        attributeFilter: ["value"]
+      }), this.mutationObserver = t;
+    }), this.inputWidget.on("change", () => {
+      this.onChange();
+    });
+  },
+  beforeUnmount() {
+    this.mutationObserver && (this.mutationObserver.disconnect(), this.mutationObserver = null);
+  },
+  methods: {
+    onChange() {
+      const e = this.inputWidget.typedInput("value"), t = this.inputWidget.typedInput("type");
+      if (this.effectiveValue.value !== e || this.effectiveValue.type !== t) {
+        const o = { value: e, type: t };
+        this.$emit("update:modelValue", o), this.$emit("update:value", o);
+      }
+    }
+  }
+}), Q = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, X = {
+  ref: "typedInput",
+  type: "text",
+  class: "node-red-typed-input",
+  style: { flex: "1", width: "100%" }
+}, x = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function ee(e, t, o, i, l, s) {
+  const r = h("NodeRedInputLabel");
+  return a(), u("div", Q, [
+    I(e.$slots, "label", {}, () => [
+      e.label ? (a(), m(r, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : p("v-if", !0)
+    ]),
+    c(
+      "input",
+      X,
+      null,
+      512
+      /* NEED_PATCH */
+    ),
+    e.error ? (a(), u(
+      "div",
+      x,
+      g(e.error),
+      1
+      /* TEXT */
+    )) : p("v-if", !0)
+  ]);
+}
+const te = /* @__PURE__ */ b(G, [["render", ee]]), ne = v({
+  components: { NodeRedInputLabel: T },
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    value: {
+      type: String,
+      default: ""
+    },
+    type: {
+      type: String,
+      required: !0
+    },
+    node: {
+      type: Object,
+      required: !0
+    },
+    propName: {
+      type: String,
+      required: !0
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value"],
+  setup() {
+    return {
+      jqInput: V(null)
+    };
+  },
+  computed: {
+    inputId() {
+      return "node-input-" + this.propName;
+    },
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  mounted() {
+    RED.editor.prepareConfigNodeSelect(
+      this.node,
+      this.propName,
+      this.type,
+      "node-input"
+    );
+    const e = $("#" + this.inputId);
+    this.jqInput = e, e.on("change", () => {
+      const t = e.val(), o = t === "_ADD_" ? "" : t;
+      this.$emit("update:modelValue", o), this.$emit("update:value", o);
+    }), e.val(this.effectiveValue || "_ADD_");
+  },
+  beforeUnmount() {
+    this.jqInput && (this.jqInput.off("change"), this.jqInput = null);
+  }
+}), oe = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, re = ["id"], ie = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function ae(e, t, o, i, l, s) {
+  const r = h("NodeRedInputLabel");
+  return a(), u("div", oe, [
+    I(e.$slots, "label", {}, () => [
+      e.label ? (a(), m(r, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : p("v-if", !0)
+    ]),
+    c("input", {
+      id: e.inputId,
+      type: "text",
+      style: { width: "100%" }
+    }, null, 8, re),
+    e.error ? (a(), u(
+      "div",
+      ie,
+      g(e.error),
+      1
+      /* TEXT */
+    )) : p("v-if", !0)
+  ]);
+}
+const le = /* @__PURE__ */ b(ne, [["render", ae]]), se = v({
+  components: { NodeRedInputLabel: T },
+  props: {
+    modelValue: {
+      type: [String, Array],
+      default: void 0
+    },
+    value: {
+      type: [String, Array],
+      default: () => ""
+    },
+    options: {
+      type: Array,
+      required: !0,
+      validator: function(e) {
+        if (!Array.isArray(e))
+          return console.warn(
+            "[WARN] Invalid value for 'options' property. It must be an array."
+          ), !1;
+        const t = e.every(
+          (o) => typeof o == "object" && o !== null && typeof o.value == "string" && typeof o.label == "string" && Object.prototype.hasOwnProperty.call(o, "value") && Object.prototype.hasOwnProperty.call(o, "label")
+        );
+        return t || console.warn(
+          "[WARN] Invalid value for 'options' property. Each item must be an object with 'value' and 'label' properties being strings.",
+          e
+        ), t;
+      }
+    },
+    multiple: {
+      type: Boolean,
+      default: !1
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue", "update:value"],
+  setup() {
+    return {
+      selectWidget: V(null)
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  mounted() {
+    const e = this.$refs.selectInput, t = $(e);
+    this.selectWidget = t, t.typedInput({
+      types: [
+        {
+          multiple: this.multiple,
+          options: this.options
+        }
+      ]
+    }), t.typedInput(
+      "value",
+      Array.isArray(this.effectiveValue) ? this.effectiveValue.join(",") : this.effectiveValue
+    ), t.on("change", () => {
+      var i;
+      const o = this.multiple ? ((i = t.typedInput("value")) == null ? void 0 : i.split(",").filter(Boolean)) ?? [] : t.typedInput("value");
+      this.$emit("update:modelValue", o), this.$emit("update:value", o);
+    });
+  },
+  beforeUnmount() {
+    this.selectWidget && (this.selectWidget.off("change"), this.selectWidget = null);
+  }
+}), ue = { style: { display: "flex", "flex-direction": "column", width: "100%" } }, de = {
+  ref: "selectInput",
+  type: "text",
+  class: "node-input-select",
+  style: { width: "100%" }
+}, pe = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function ce(e, t, o, i, l, s) {
+  const r = h("NodeRedInputLabel");
+  return a(), u("div", ue, [
+    I(e.$slots, "label", {}, () => [
+      e.label ? (a(), m(r, {
+        key: 0,
+        label: e.label,
+        icon: e.icon,
+        required: e.required
+      }, null, 8, ["label", "icon", "required"])) : p("v-if", !0)
+    ]),
+    c(
+      "input",
+      de,
+      null,
+      512
+      /* NEED_PATCH */
+    ),
+    e.error ? (a(), u(
+      "div",
+      pe,
+      g(e.error),
+      1
+      /* TEXT */
+    )) : p("v-if", !0)
+  ]);
+}
+const ye = /* @__PURE__ */ b(se, [["render", ce]]), he = v({
+  components: { NodeRedInputLabel: T },
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    value: {
+      type: String,
+      default: ""
+    },
+    language: {
+      type: String,
+      default: "json",
+      validator: function(e) {
+        const t = [
+          "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"
+        ], o = t.includes(e);
+        return o || console.warn(
+          `[WARN]: Invalid value for 'type' property: "${e}". Expected one of: ${t.join(", ")}`
+        ), o;
+      }
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    required: {
+      type: Boolean,
+      default: !1
+    },
+    error: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: [
+    "update:modelValue",
+    "update:value",
+    "editor-ready",
+    "tray-open",
+    "tray-close"
+  ],
+  setup() {
+    return {
+      // NOTE: must not be named "editor" — the template's ref="editor" would
+      // overwrite this with the DOM element on every re-render.
+      editorInstance: V(null),
+      expandedEditorTray: V(null)
+    };
+  },
+  data() {
+    const e = Math.random().toString(36).substring(2, 9);
+    return {
+      editorId: "node-red-editor-" + e,
+      stateId: e,
+      trayElement: null
+    };
+  },
+  computed: {
+    effectiveValue() {
+      return this.modelValue !== void 0 ? this.modelValue : this.value;
+    }
+  },
+  mounted() {
+    const e = $(this.$refs["expand-button"]);
+    RED.popover.tooltip(e, RED._("node-red:common.label.expand")), this.mountEditor(), this.createExpandeEditorTray();
+  },
+  beforeUnmount() {
+    if (this.editorInstance) {
+      try {
+        this.editorInstance.destroy();
+      } catch (e) {
+        console.error(`Error destroying editor for ID ${this.editorId}:`, e);
+      }
+      this.editorInstance = null;
+    }
+  },
+  methods: {
+    mountEditor() {
+      this.$nextTick(() => {
+        const e = this.$refs.container, t = this.$refs.editor;
+        if (e && t)
+          try {
+            const o = e.style.height, i = e.style.width;
+            o ? t.style.height = o : t.style.height = "200px", i ? t.style.width = i : t.style.width = "100%", this.createEditorInstance();
+          } catch (o) {
+            console.error(
+              "[NodeRedEditorInput] Error setting initial editor style:",
+              o
+            ), 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.effectiveValue
+      }), this.editorInstance.getSession().on("change", () => {
+        const e = this.editorInstance.getValue();
+        e !== this.effectiveValue && (this.$emit("update:modelValue", e), this.$emit("update:value", e));
+      }), this.$emit("editor-ready", this.editorInstance);
+    },
+    createExpandeEditorTray() {
+      let e;
+      const t = () => {
+        setTimeout(() => {
+          var i;
+          (i = this.editorInstance) == null || i.focus();
+        }, 250), RED.tray.close();
+      }, o = () => {
+        var i;
+        e.saveView(), (i = this.editorInstance) == null || i.setValue(e.getValue(), -1), setTimeout(() => {
+          var l, s;
+          (l = this.editorInstance) == null || l.restoreView(), (s = this.editorInstance) == null || s.focus();
+        }, 250), RED.tray.close();
+      };
+      this.expandedEditorTray = {
+        title: "Editor",
+        focusElement: !0,
+        width: "Infinity",
+        buttons: [
+          {
+            id: "node-dialog-cancel",
+            text: RED._("common.label.cancel"),
+            click: t
+          },
+          {
+            id: "node-dialog-ok",
+            text: RED._("common.label.done"),
+            class: "primary",
+            click: o
+          }
+        ],
+        open: (i) => {
+          const l = $(
+            '<form id="dialog-form" class="form-horizontal" autocomplete="off"></form>'
+          ).appendTo(i.find(".red-ui-tray-body"));
+          l.html(
+            '<div id="expanded-editor-input" style="height: 100%"></div>'
+          ), e = RED.editor.createEditor({
+            id: "expanded-editor-input",
+            stateId: this.stateId,
+            mode: this.language,
+            focus: !0,
+            value: this.effectiveValue
+          }), l.i18n();
+          const s = i.find(".red-ui-tray-body")[0], r = document.createElement("div");
+          r.className = "red-ui-tray-footer", s.insertAdjacentElement("afterend", r), this.trayElement = r, this.$emit("tray-open", this.trayElement);
+        },
+        close: () => {
+          this.$emit("tray-close"), this.trayElement && (this.trayElement.remove(), this.trayElement = null), e.destroy();
+        }
+      };
+    },
+    onClickExpand() {
+      RED.tray.show(this.expandedEditorTray);
+    }
+  }
+}), me = {
+  ref: "container",
+  class: "container"
+}, fe = { class: "editor-wrapper" }, ve = ["id"];
+function ge(e, t, o, i, l, s) {
+  const r = h("NodeRedInputLabel");
+  return a(), u(
+    "div",
+    me,
+    [
+      I(e.$slots, "label", {}, () => [
+        e.label ? (a(), m(r, {
+          key: 0,
+          label: e.label,
+          icon: e.icon,
+          required: e.required
+        }, null, 8, ["label", "icon", "required"])) : p("v-if", !0)
+      ], !0),
+      c("div", fe, [
+        c(
+          "button",
+          {
+            ref: "expand-button",
+            class: "red-ui-button red-ui-button-small expand-button",
+            onClick: t[0] || (t[0] = (...f) => e.onClickExpand && e.onClickExpand(...f))
+          },
+          [...t[1] || (t[1] = [
+            c(
+              "i",
+              { class: "fa fa-expand" },
+              null,
+              -1
+              /* CACHED */
+            )
+          ])],
+          512
+          /* NEED_PATCH */
+        ),
+        c("div", {
+          id: e.editorId,
+          ref: "editor"
+        }, null, 8, ve)
+      ]),
+      O(c(
+        "div",
+        { class: "node-red-vue-input-error-message" },
+        g(e.error),
+        513
+        /* TEXT, NEED_PATCH */
+      ), [
+        [A, e.error]
+      ]),
+      e.trayElement ? (a(), m(W, {
+        key: 0,
+        to: e.trayElement
+      }, [
+        I(e.$slots, "tray-footer", {}, void 0, !0)
+      ], 8, ["to"])) : p("v-if", !0)
+    ],
+    512
+    /* NEED_PATCH */
+  );
+}
+const be = /* @__PURE__ */ b(he, [["render", ge], ["__scopeId", "data-v-9e324115"]]), $e = v({
+  name: "NodeRedToggle",
+  props: {
+    modelValue: {
+      type: Boolean,
+      default: !1
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    icon: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue"],
+  computed: {
+    iconClass() {
+      return this.icon ? `fa ${this.icon.startsWith("fa-") ? this.icon : `fa-${this.icon}`}` : "";
+    }
+  }
+}), Ie = { class: "nrg-toggle-wrapper" }, Ve = ["checked"], Te = {
+  key: 0,
+  class: "nrg-toggle__label"
+};
+function ke(e, t, o, i, l, s) {
+  return a(), u("div", Ie, [
+    c(
+      "label",
+      {
+        class: E(["nrg-toggle", { "nrg-toggle--checked": e.modelValue }])
+      },
+      [
+        c("input", {
+          type: "checkbox",
+          checked: e.modelValue,
+          class: "nrg-toggle__input",
+          onChange: t[0] || (t[0] = (r) => e.$emit(
+            "update:modelValue",
+            r.target.checked
+          ))
+        }, null, 40, Ve),
+        e.icon || e.label ? (a(), u("span", Te, [
+          e.icon ? (a(), u(
+            "i",
+            {
+              key: 0,
+              class: E(e.iconClass)
+            },
+            null,
+            2
+            /* CLASS */
+          )) : p("v-if", !0),
+          _(
+            " " + g(e.label),
+            1
+            /* TEXT */
+          )
+        ])) : p("v-if", !0),
+        t[1] || (t[1] = c(
+          "span",
+          { class: "nrg-toggle__slider" },
+          null,
+          -1
+          /* CACHED */
+        ))
+      ],
+      2
+      /* CLASS */
+    )
+  ]);
+}
+const we = /* @__PURE__ */ b($e, [["render", ke], ["__scopeId", "data-v-c6353798"]]), Ee = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "x",
+  "y",
+  "z",
+  "g",
+  "wires",
+  "credentials",
+  "_users",
+  "validateInput",
+  "validateOutputs",
+  "outputs",
+  "outputContextModes",
+  "outputReturnProperties",
+  ...Z
+]);
+function Re(e) {
+  return e.replace(/([A-Z])/g, " $1").replace(/^./, (t) => t.toUpperCase()).trim();
+}
+function qe(e) {
+  var t, o;
+  return e.type === "object" && !!((t = e.properties) != null && t.value) && !!((o = e.properties) != null && o.type);
+}
+function S(e, t, o, i) {
+  var k;
+  const l = i || t.title || Re(e), s = t["x-nrg-form"] ?? {}, r = s.icon || "";
+  if (t["x-nrg-node-type"])
+    return {
+      key: e,
+      label: l,
+      icon: r,
+      inputType: "config",
+      required: o,
+      configType: t["x-nrg-node-type"]
+    };
+  if (qe(t))
+    return {
+      key: e,
+      label: l,
+      icon: r,
+      inputType: "typed",
+      required: o,
+      // serialized schemas carry plain strings; trust them as typed-input type names
+      types: s.typedInputTypes
+    };
+  if (t.type === "array" && ((k = t.items) != null && k.enum))
+    return {
+      key: e,
+      label: l,
+      icon: r,
+      inputType: "select",
+      required: o,
+      multiple: !0,
+      options: t.items.enum.map((y) => ({
+        value: String(y),
+        label: String(y)
+      }))
+    };
+  if (t.enum)
+    return {
+      key: e,
+      label: l,
+      icon: r,
+      inputType: "select",
+      required: o,
+      multiple: !1,
+      options: t.enum.map((y) => ({
+        value: String(y),
+        label: String(y)
+      }))
+    };
+  if (t.anyOf && t.anyOf.every((y) => y.const !== void 0))
+    return {
+      key: e,
+      label: l,
+      icon: r,
+      inputType: "select",
+      required: o,
+      multiple: !1,
+      options: t.anyOf.map((y) => ({
+        value: String(y.const),
+        label: String(y.const)
+      }))
+    };
+  switch (Array.isArray(t.type) ? t.type[0] : t.type) {
+    case "boolean":
+      return {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "boolean",
+        required: o,
+        toggle: s.toggle
+      };
+    case "number":
+    case "integer":
+      return {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "number",
+        required: o,
+        htmlType: "number"
+      };
+    case "array":
+      return s.editorLanguage ? {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "editor",
+        required: o,
+        language: s.editorLanguage
+      } : { key: e, label: l, icon: r, inputType: "array-text", required: o };
+    case "object":
+      return s.editorLanguage ? {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "editor",
+        required: o,
+        language: s.editorLanguage
+      } : {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "text",
+        required: o,
+        htmlType: "text"
+      };
+    default:
+      return s.editorLanguage ? {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "editor",
+        required: o,
+        language: s.editorLanguage
+      } : {
+        key: e,
+        label: l,
+        icon: r,
+        inputType: "text",
+        required: o,
+        htmlType: t.format === "password" ? "password" : "text"
+      };
+  }
+}
+const Ne = v({
+  name: "NodeRedJsonSchemaForm",
+  components: {
+    NodeRedInputLabel: T,
+    NodeRedToggle: we,
+    NodeRedInput: Y,
+    NodeRedSelectInput: ye,
+    NodeRedTypedInput: te,
+    NodeRedConfigInput: le,
+    NodeRedEditorInput: be
+  },
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    schema: {
+      type: Object,
+      required: !0
+    },
+    errors: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  computed: {
+    configFields() {
+      var t;
+      if (!((t = this.schema) != null && t.properties)) return [];
+      const e = new Set(this.schema.required ?? []);
+      return Object.entries(this.schema.properties).filter(([o]) => !Ee.has(o)).map(
+        ([o, i]) => S(
+          o,
+          i,
+          e.has(o),
+          this.resolveI18n("configs", o)
+        )
+      );
+    },
+    credentialFields() {
+      var o, i;
+      const e = (i = (o = this.schema) == null ? void 0 : o.properties) == null ? void 0 : i.credentials;
+      if (!(e != null && e.properties)) return [];
+      const t = new Set(e.required ?? []);
+      return Object.entries(e.properties).map(([l, s]) => {
+        const r = S(
+          l,
+          s,
+          t.has(l),
+          this.resolveI18n("credentials", l)
+        );
+        return r.inputType !== "text" ? {
+          ...r,
+          inputType: "text",
+          htmlType: s.format === "password" ? "password" : "text"
+        } : r;
+      });
+    }
+  },
+  methods: {
+    resolveI18n(e, t) {
+      const o = this.$i18n(`${e}.${t}`), i = `${this.node.type}.${e}.${t}`;
+      if (o && o !== i && o !== `${e}.${t}`)
+        return o;
+    }
+  }
+}), Se = { key: 1 }, _e = { key: 2 }, je = ["checked", "onChange"], Ce = { key: 6 }, Le = ["value", "onInput"], Oe = {
+  key: 0,
+  class: "node-red-vue-input-error-message"
+};
+function Ae(e, t, o, i, l, s) {
+  const r = h("NodeRedInput"), f = h("NodeRedToggle"), k = h("NodeRedInputLabel"), y = h("NodeRedSelectInput"), j = h("NodeRedTypedInput"), C = h("NodeRedConfigInput"), L = h("NodeRedEditorInput");
+  return a(), u("div", null, [
+    (a(!0), u(
+      R,
+      null,
+      q(e.configFields, (n) => (a(), u("div", {
+        key: n.key,
+        class: "form-row"
+      }, [
+        n.inputType === "text" || n.inputType === "number" ? (a(), m(r, {
+          key: 0,
+          value: e.node[n.key],
+          "onUpdate:value": (d) => e.node[n.key] = d,
+          type: n.htmlType,
+          label: n.label,
+          icon: n.icon,
+          required: n.required,
+          error: e.errors[`node.${n.key}`]
+        }, null, 8, ["value", "onUpdate:value", "type", "label", "icon", "required", "error"])) : n.inputType === "boolean" && n.toggle ? (a(), u("div", Se, [
+          w(f, {
+            "model-value": e.node[n.key],
+            label: n.label,
+            icon: n.icon,
+            "onUpdate:modelValue": (d) => e.node[n.key] = d
+          }, null, 8, ["model-value", "label", "icon", "onUpdate:modelValue"])
+        ])) : n.inputType === "boolean" ? (a(), u("div", _e, [
+          w(k, {
+            label: n.label,
+            icon: n.icon,
+            required: n.required
+          }, null, 8, ["label", "icon", "required"]),
+          c("input", {
+            type: "checkbox",
+            checked: e.node[n.key],
+            style: { width: "auto", margin: "0" },
+            onChange: (d) => {
+              e.node[n.key] = d.target.checked;
+            }
+          }, null, 40, je)
+        ])) : n.inputType === "select" ? (a(), m(y, {
+          key: 3,
+          value: e.node[n.key],
+          "onUpdate:value": (d) => e.node[n.key] = d,
+          options: n.options,
+          multiple: n.multiple,
+          label: n.label,
+          icon: n.icon,
+          required: n.required,
+          error: e.errors[`node.${n.key}`]
+        }, null, 8, ["value", "onUpdate:value", "options", "multiple", "label", "icon", "required", "error"])) : n.inputType === "typed" ? (a(), m(j, {
+          key: 4,
+          value: e.node[n.key],
+          "onUpdate:value": (d) => e.node[n.key] = d,
+          types: n.types,
+          label: n.label,
+          icon: n.icon,
+          required: n.required,
+          error: e.errors[`node.${n.key}`]
+        }, null, 8, ["value", "onUpdate:value", "types", "label", "icon", "required", "error"])) : n.inputType === "config" ? (a(), m(C, {
+          key: 5,
+          value: e.node[n.key],
+          "onUpdate:value": (d) => e.node[n.key] = d,
+          type: n.configType,
+          node: e.node,
+          "prop-name": n.key,
+          label: n.label,
+          icon: n.icon,
+          required: n.required,
+          error: e.errors[`node.${n.key}`]
+        }, null, 8, ["value", "onUpdate:value", "type", "node", "prop-name", "label", "icon", "required", "error"])) : n.inputType === "array-text" ? (a(), u("div", Ce, [
+          w(k, {
+            label: n.label,
+            icon: n.icon,
+            required: n.required
+          }, null, 8, ["label", "icon", "required"]),
+          t[0] || (t[0] = c(
+            "span",
+            { style: { display: "block", "font-size": "11px", color: "var(--red-ui-text-color-disabled, #999)", "margin-bottom": "4px" } },
+            " One entry per line ",
+            -1
+            /* CACHED */
+          )),
+          c("textarea", {
+            value: Array.isArray(e.node[n.key]) ? e.node[n.key].join(`
+`) : e.node[n.key] ?? "",
+            rows: "4",
+            style: { width: "100%", resize: "vertical", "font-family": "monospace", "font-size": "13px" },
+            onInput: (d) => e.node[n.key] = d.target.value.split(`
+`).filter(Boolean)
+          }, null, 40, Le),
+          e.errors[`node.${n.key}`] ? (a(), u(
+            "span",
+            Oe,
+            g(e.errors[`node.${n.key}`]),
+            1
+            /* TEXT */
+          )) : p("v-if", !0)
+        ])) : n.inputType === "editor" ? (a(), m(L, {
+          key: 7,
+          value: e.node[n.key],
+          "onUpdate:value": (d) => e.node[n.key] = d,
+          language: n.language,
+          label: n.label,
+          icon: n.icon,
+          required: n.required,
+          error: e.errors[`node.${n.key}`]
+        }, null, 8, ["value", "onUpdate:value", "language", "label", "icon", "required", "error"])) : p("v-if", !0)
+      ]))),
+      128
+      /* KEYED_FRAGMENT */
+    )),
+    (a(!0), u(
+      R,
+      null,
+      q(e.credentialFields, (n) => (a(), u("div", {
+        key: `cred-${n.key}`,
+        class: "form-row"
+      }, [
+        w(r, {
+          value: e.node.credentials[n.key],
+          "onUpdate:value": (d) => e.node.credentials[n.key] = d,
+          type: n.htmlType,
+          label: n.label,
+          icon: n.icon,
+          required: n.required,
+          error: e.errors[`node.credentials.${n.key}`]
+        }, null, 8, ["value", "onUpdate:value", "type", "label", "icon", "required", "error"])
+      ]))),
+      128
+      /* KEYED_FRAGMENT */
+    ))
+  ]);
+}
+const De = /* @__PURE__ */ b(Ne, [["render", Ae]]);
+export {
+  le as NodeRedConfigInput,
+  be as NodeRedEditorInput,
+  Y as NodeRedInput,
+  T as NodeRedInputLabel,
+  De as NodeRedJsonSchemaForm,
+  ye as NodeRedSelectInput,
+  we as NodeRedToggle,
+  te as NodeRedTypedInput
+};