@bonsae/nrg 0.16.0 → 0.18.0

package/test/client/unit/index.js

@@ -0,0 +1,200 @@
+// src/test/client/mocks.ts
+function createRED() {
+  return {
+    _: (key) => key,
+    editor: {
+      createEditor(options) {
+        let currentValue = options.value || "";
+        const session = {
+          on(_event, _cb) {
+          }
+        };
+        return {
+          getValue: () => currentValue,
+          setValue: (val) => {
+            currentValue = val;
+          },
+          getSession: () => session,
+          focus: () => {
+          },
+          destroy: () => {
+          },
+          saveView: () => {
+          },
+          restoreView: () => {
+          }
+        };
+      },
+      prepareConfigNodeSelect: () => {
+      },
+      validateNode: () => true
+    },
+    tray: {
+      show: () => {
+      },
+      close: () => {
+      }
+    },
+    popover: {
+      tooltip: () => ({ delete: () => {
+      }, setAction: () => {
+      } })
+    },
+    nodes: {
+      registerType: () => {
+      },
+      node: () => null,
+      dirty: () => false
+    },
+    events: {
+      on: () => {
+      },
+      off: () => {
+      },
+      emit: () => {
+      }
+    },
+    settings: {},
+    notify: () => {
+    }
+  };
+}
+function ensureState(el) {
+  if (el && !el.__jqState) {
+    el.__jqState = {
+      typedInput: { value: "", type: "" },
+      listeners: {}
+    };
+  }
+  return el ? el.__jqState : { typedInput: { value: "", type: "" }, listeners: {} };
+}
+function createJQ(el) {
+  const state = ensureState(el);
+  const jq = {
+    0: el,
+    length: el ? 1 : 0,
+    typedInput(action, value) {
+      if (typeof action === "object") {
+        state.typedInput = { value: "", type: action.default || "" };
+        return jq;
+      }
+      if (action === "value") {
+        if (value !== void 0) {
+          state.typedInput.value = String(value);
+          if (el) el.setAttribute("value", String(value));
+          return void 0;
+        }
+        return state.typedInput.value;
+      }
+      if (action === "type") {
+        if (value !== void 0) {
+          state.typedInput.type = String(value);
+          return void 0;
+        }
+        return state.typedInput.type;
+      }
+      return jq;
+    },
+    on(event, cb) {
+      if (!state.listeners[event]) state.listeners[event] = [];
+      state.listeners[event].push(cb);
+      return jq;
+    },
+    off(event) {
+      if (event) {
+        delete state.listeners[event];
+      } else {
+        for (const key of Object.keys(state.listeners)) {
+          delete state.listeners[key];
+        }
+      }
+      return jq;
+    },
+    val(value) {
+      if (value !== void 0) {
+        if (el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) {
+          el.value = String(value);
+        }
+        return jq;
+      }
+      if (el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) {
+        return el.value;
+      }
+      return "";
+    },
+    find(selector) {
+      return createJQ(el?.querySelector(selector) ?? null);
+    },
+    append(child) {
+      const childEl = child?.[0] || child;
+      if (el && childEl instanceof Element) el.appendChild(childEl);
+      return jq;
+    },
+    appendTo(target) {
+      const t = target?.[0] || target;
+      if (t instanceof Element && el) t.appendChild(el);
+      return jq;
+    },
+    html(content) {
+      if (el) el.innerHTML = content;
+      return jq;
+    },
+    empty() {
+      if (el) el.innerHTML = "";
+      return jq;
+    },
+    i18n() {
+      return jq;
+    },
+    addClass(cls) {
+      el?.classList.add(cls);
+      return jq;
+    },
+    removeClass(cls) {
+      el?.classList.remove(cls);
+      return jq;
+    },
+    __trigger(event) {
+      (state.listeners[event] || []).forEach((cb) => cb());
+    }
+  };
+  return jq;
+}
+function createJQuery() {
+  return function $(selector, attrs) {
+    if (typeof selector === "string") {
+      if (selector.trim().startsWith("<")) {
+        const tpl = document.createElement("template");
+        tpl.innerHTML = selector.trim();
+        const el = tpl.content.firstElementChild;
+        if (el && attrs) {
+          for (const [key, value] of Object.entries(attrs)) {
+            if (key === "html") {
+              el.innerHTML = String(value);
+            } else {
+              el.setAttribute(key, String(value));
+            }
+          }
+        }
+        return createJQ(el);
+      }
+      return createJQ(document.querySelector(selector));
+    }
+    if (selector instanceof Element) return createJQ(selector);
+    if (selector && typeof selector === "object" && selector.nodeType)
+      return createJQ(selector);
+    return createJQ(null);
+  };
+}
+
+// src/test/client/unit/index.ts
+var defaultConfig = {
+  testTimeout: 3e4,
+  environment: "happy-dom",
+  setupFiles: ["@bonsae/nrg/test/client/unit/setup"]
+};
+export {
+  createJQuery,
+  createRED,
+  defaultConfig
+};

package/test/client/unit/setup.js

@@ -0,0 +1,199 @@
+// src/test/client/unit/setup.ts
+import { beforeEach } from "vitest";
+
+// src/test/client/mocks.ts
+function createRED() {
+  return {
+    _: (key) => key,
+    editor: {
+      createEditor(options) {
+        let currentValue = options.value || "";
+        const session = {
+          on(_event, _cb) {
+          }
+        };
+        return {
+          getValue: () => currentValue,
+          setValue: (val) => {
+            currentValue = val;
+          },
+          getSession: () => session,
+          focus: () => {
+          },
+          destroy: () => {
+          },
+          saveView: () => {
+          },
+          restoreView: () => {
+          }
+        };
+      },
+      prepareConfigNodeSelect: () => {
+      },
+      validateNode: () => true
+    },
+    tray: {
+      show: () => {
+      },
+      close: () => {
+      }
+    },
+    popover: {
+      tooltip: () => ({ delete: () => {
+      }, setAction: () => {
+      } })
+    },
+    nodes: {
+      registerType: () => {
+      },
+      node: () => null,
+      dirty: () => false
+    },
+    events: {
+      on: () => {
+      },
+      off: () => {
+      },
+      emit: () => {
+      }
+    },
+    settings: {},
+    notify: () => {
+    }
+  };
+}
+function ensureState(el) {
+  if (el && !el.__jqState) {
+    el.__jqState = {
+      typedInput: { value: "", type: "" },
+      listeners: {}
+    };
+  }
+  return el ? el.__jqState : { typedInput: { value: "", type: "" }, listeners: {} };
+}
+function createJQ(el) {
+  const state = ensureState(el);
+  const jq = {
+    0: el,
+    length: el ? 1 : 0,
+    typedInput(action, value) {
+      if (typeof action === "object") {
+        state.typedInput = { value: "", type: action.default || "" };
+        return jq;
+      }
+      if (action === "value") {
+        if (value !== void 0) {
+          state.typedInput.value = String(value);
+          if (el) el.setAttribute("value", String(value));
+          return void 0;
+        }
+        return state.typedInput.value;
+      }
+      if (action === "type") {
+        if (value !== void 0) {
+          state.typedInput.type = String(value);
+          return void 0;
+        }
+        return state.typedInput.type;
+      }
+      return jq;
+    },
+    on(event, cb) {
+      if (!state.listeners[event]) state.listeners[event] = [];
+      state.listeners[event].push(cb);
+      return jq;
+    },
+    off(event) {
+      if (event) {
+        delete state.listeners[event];
+      } else {
+        for (const key of Object.keys(state.listeners)) {
+          delete state.listeners[key];
+        }
+      }
+      return jq;
+    },
+    val(value) {
+      if (value !== void 0) {
+        if (el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) {
+          el.value = String(value);
+        }
+        return jq;
+      }
+      if (el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) {
+        return el.value;
+      }
+      return "";
+    },
+    find(selector) {
+      return createJQ(el?.querySelector(selector) ?? null);
+    },
+    append(child) {
+      const childEl = child?.[0] || child;
+      if (el && childEl instanceof Element) el.appendChild(childEl);
+      return jq;
+    },
+    appendTo(target) {
+      const t = target?.[0] || target;
+      if (t instanceof Element && el) t.appendChild(el);
+      return jq;
+    },
+    html(content) {
+      if (el) el.innerHTML = content;
+      return jq;
+    },
+    empty() {
+      if (el) el.innerHTML = "";
+      return jq;
+    },
+    i18n() {
+      return jq;
+    },
+    addClass(cls) {
+      el?.classList.add(cls);
+      return jq;
+    },
+    removeClass(cls) {
+      el?.classList.remove(cls);
+      return jq;
+    },
+    __trigger(event) {
+      (state.listeners[event] || []).forEach((cb) => cb());
+    }
+  };
+  return jq;
+}
+function createJQuery() {
+  return function $(selector, attrs) {
+    if (typeof selector === "string") {
+      if (selector.trim().startsWith("<")) {
+        const tpl = document.createElement("template");
+        tpl.innerHTML = selector.trim();
+        const el = tpl.content.firstElementChild;
+        if (el && attrs) {
+          for (const [key, value] of Object.entries(attrs)) {
+            if (key === "html") {
+              el.innerHTML = String(value);
+            } else {
+              el.setAttribute(key, String(value));
+            }
+          }
+        }
+        return createJQ(el);
+      }
+      return createJQ(document.querySelector(selector));
+    }
+    if (selector instanceof Element) return createJQ(selector);
+    if (selector && typeof selector === "object" && selector.nodeType)
+      return createJQ(selector);
+    return createJQ(null);
+  };
+}
+
+// src/test/client/unit/setup.ts
+var RED = createRED();
+window.$ = createJQuery();
+window.RED = RED;
+beforeEach(() => {
+  RED.settings = {};
+});

package/test/{index.js → server/unit/index.js}

@@ -1,9 +1,9 @@
-// src/test/index.ts
+// src/test/server/unit/index.ts
 import { vi as vi2 } from "vitest";
 
-// src/test/mocks.ts
+// src/test/server/unit/mocks.ts
 import { vi } from "vitest";
-function createNodeRedRuntime(options = {}) {
+function createRED(options = {}) {
   const { settings = {} } = options;
   const nodes = {};
   const red = {
@@ -398,7 +398,8 @@ function initValidator(RED) {
 // src/core/server/nodes/symbols.ts
 var WIRE_HANDLERS = Symbol.for("nrg.wireHandlers");
 
-// src/test/index.ts
+// src/test/server/unit/index.ts
+import { Kind } from "@sinclair/typebox";
 function buildConfig(NodeClass, userConfig = {}) {
   const defaults = {};
   if (NodeClass.configSchema?.properties) {
@@ -413,7 +414,7 @@ function buildConfig(NodeClass, userConfig = {}) {
   }
   return { ...defaults, ...userConfig };
 }
-function attachHelpers(node, nodeRedNode) {
+function attachHelpers(node, nodeRedNode, NodeClass) {
   const sentMessages = [];
   const statusCalls = [];
   nodeRedNode.send.mockImplementation((msg) => {
@@ -449,6 +450,15 @@ function attachHelpers(node, nodeRedNode) {
     },
     sent(port) {
       if (port === void 0) return [...sentMessages];
+      if (typeof port === "string") {
+        const schema = NodeClass.outputsSchema;
+        if (!schema || Array.isArray(schema) || typeof schema === "object" && Kind in schema) {
+          return [];
+        }
+        const idx = Object.keys(schema).indexOf(port);
+        if (idx === -1) return [];
+        return sentMessages.map((msg) => Array.isArray(msg) ? msg[idx] : void 0).filter((msg) => msg != null);
+      }
       return sentMessages.map(
         (msg) => Array.isArray(msg) ? msg[port] : port === 0 ? msg : void 0
       ).filter((msg) => msg != null);
@@ -497,7 +507,7 @@ async function createNode(NodeClass, options = {}) {
       resolvedConfig[key] = value;
     }
   }
-  const RED = createNodeRedRuntime({ settings });
+  const RED = createRED({ settings });
   initValidator(RED);
   for (const [id, value] of Object.entries(configNodes)) {
     RED.registerNrgNode(id, value);
@@ -523,12 +533,17 @@ async function createNode(NodeClass, options = {}) {
   NodeClass.validateSettings(RED);
   await Promise.resolve(NodeClass.registered?.(RED));
   const node = new NodeClass(RED, nodeRedNode, config, credentials);
-  const augmented = attachHelpers(node, nodeRedNode);
+  const augmented = attachHelpers(
+    node,
+    nodeRedNode,
+    NodeClass
+  );
   const createdPromise = Promise.resolve(node.created?.());
   node[WIRE_HANDLERS](nodeRedNode, createdPromise);
   await createdPromise;
   return { node: augmented, RED };
 }
 export {
-  createNode
+  createNode,
+  createRED
 };

package/tsconfig/core/client.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../base.json",
+  "compilerOptions": {
+    "lib": ["ES2022", "DOM", "DOM.Iterable"]
+  },
+  "files": [
+    "../../types/shims/shims-vue.d.ts",
+    "../../types/shims/components.d.ts",
+    "../../types/shims/globals.d.ts"
+  ]
+}

package/tsconfig/{server.json → core/server.json}

@@ -1,5 +1,5 @@
 {
-  "extends": "./base.json",
+  "extends": "../base.json",
   "compilerOptions": {
     "lib": ["ES2022"]
   }

package/tsconfig/test/client/component.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../base.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"]
+  },
+  "files": [
+    "../../../types/shims/shims-vue.d.ts",
+    "../../../types/shims/components.d.ts",
+    "../../../types/shims/globals.d.ts"
+  ]
+}

package/tsconfig/test/client/e2e.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../base.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"]
+  }
+}

package/tsconfig/test/client/unit.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../base.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"]
+  }
+}

package/tsconfig/test/server/unit.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../base.json",
+  "compilerOptions": {
+    "lib": ["ESNext"]
+  }
+}

package/types/client.d.ts

@@ -1,7 +1,12 @@
 // Generated by dts-bundle-generator v9.5.1
 
+import { SchemaOptions, Static, TSchema } from '@sinclair/typebox';
 import { App, Component } from 'vue';
 
+interface NodeRefResolved<T = any> {
+	readonly __nrg_node_ref: true;
+	readonly __instance: T;
+}
 export interface NodeStateCredentials {
 	[key: string]: any;
 }
@@ -87,13 +92,74 @@ export interface NodeDefinition {
 	onPaletteRemove?: (this: NodeRedNode) => void;
 	form?: NodeFormDefinition;
 }
+export interface NodeDefaults {
+	[key: string]: {
+		value: any;
+		type?: string;
+		label?: string;
+		required?: boolean;
+		validate?: (this: NodeRedNode, value: any, opt: any) => any;
+	};
+}
+export interface NodeCredentials {
+	[key: string]: {
+		value?: string;
+		type?: "password" | "text";
+		label?: string;
+		required?: boolean;
+	};
+}
+export interface MergedNodeDefinition extends NodeDefinition {
+	defaults?: NodeDefaults;
+	credentials?: NodeCredentials;
+	configSchema?: Record<string, any>;
+	credentialsSchema?: {
+		properties?: Record<string, any>;
+	};
+	outputsSchema?: Record<string, any>;
+	inputSchema?: Record<string, any>;
+}
 export interface NodeFeatures {
 	hasInputSchema: boolean;
 	hasOutputSchema: boolean;
 }
+/** Client-side representation of a TypedInput field: the raw value string and its type selector. */
+export interface TypedInputValue {
+	value: string;
+	type: string;
+}
+type _ToClient<T> = T extends NodeRefResolved<any> ? string : T extends {
+	resolve(...args: any[]): any;
+	value: unknown;
+	type: string;
+} ? TypedInputValue : T extends (...args: any[]) => any ? T : T extends Array<infer I> ? _ToClient<I>[] : T extends object ? {
+	[K in keyof T]: _ToClient<T[K]>;
+} : T;
+/**
+ * Infers the client-side TypeScript type from a TypeBox schema.
+ *
+ * Resolves schema types to their client form representations:
+ * - `NodeRef<T>` → `string` (node ID in the editor)
+ * - `TypedInput<T>` → `{ value: string; type: string }`
+ * - All other types resolve via TypeBox's `Static<T>`
+ *
+ * @example
+ * ```ts
+ * import type { Infer } from "@bonsae/nrg/client";
+ * import type { ConfigSchema } from "../schemas/my-node";
+ *
+ * type Config = Infer<typeof ConfigSchema>;
+ * ```
+ */
+export type Infer<T extends TSchema> = _ToClient<Static<T>>;
 
 export {};
 
 export declare function defineNode<T extends NodeDefinition>(options: T): T;
 export declare function registerType(definition: NodeDefinition): Promise<void>;
 export declare function registerTypes(nodes: NodeDefinition[]): Promise<void>;
+export declare function useFormNode<TConfig extends TSchema = TSchema, TCredentials extends TSchema = TSchema>(): {
+  node: NodeRedNode & Infer<TConfig> & { credentials: Infer<TCredentials> & Record<string, any> };
+  schema: Record<string, any>;
+  errors: Record<string, string>;
+};