@bonsae/nrg 0.21.1 → 0.22.0

package/test/client/unit/index.js

@@ -1,4 +1,4 @@
-// src/test/client/mocks.ts
+// src/test/client/mocks/red.ts
 function createSettings() {
   const settings = {
     get(key) {
@@ -213,17 +213,19 @@ function createRED() {
   });
   return red;
 }
-function ensureState(el) {
+
+// src/test/client/mocks/jquery.ts
+function emptyState() {
+  return { typedInput: { value: "", type: "" }, listeners: {} };
+}
+function ensureJQueryState(el) {
   if (el && !el.__jqState) {
-    el.__jqState = {
-      typedInput: { value: "", type: "" },
-      listeners: {}
-    };
+    el.__jqState = emptyState();
   }
-  return el ? el.__jqState : { typedInput: { value: "", type: "" }, listeners: {} };
+  return el ? el.__jqState : emptyState();
 }
-function createJQ(el) {
-  const state = ensureState(el);
+function createJQueryElement(el) {
+  const state = ensureJQueryState(el);
   const jq = {
     0: el,
     length: el ? 1 : 0,
@@ -311,7 +313,7 @@ function createJQ(el) {
       return "";
     },
     find(selector) {
-      return createJQ(el?.querySelector(selector) ?? null);
+      return createJQueryElement(el?.querySelector(selector) ?? null);
     },
     append(child) {
       const childEl = child?.[0] || child;
@@ -364,34 +366,19 @@ function createJQuery() {
             }
           }
         }
-        return createJQ(el);
+        return createJQueryElement(el);
       }
-      return createJQ(document.querySelector(selector));
+      return createJQueryElement(document.querySelector(selector));
     }
-    if (selector instanceof Element) return createJQ(selector);
+    if (selector instanceof Element) return createJQueryElement(selector);
     if (selector && typeof selector === "object" && selector.nodeType)
-      return createJQ(selector);
-    return createJQ(null);
+      return createJQueryElement(selector);
+    return createJQueryElement(null);
   };
 }
 
-// src/core/client/use-form-node.ts
-import { inject } from "vue";
-function useFormNode() {
-  const node = inject("__nrg_form_node");
-  const schema = inject("__nrg_form_schema");
-  const errors = inject("__nrg_form_errors");
-  if (!node) {
-    throw new Error(
-      "useFormNode() must be called inside a form component mounted by NRG."
-    );
-  }
-  return {
-    node,
-    schema,
-    errors
-  };
-}
+// src/test/client/unit/index.ts
+import { useFormNode } from "@bonsae/nrg-runtime/internal/client";
 export {
   createJQuery,
   createRED,

package/test/client/unit/setup.js

@@ -1,7 +1,7 @@
-// src/test/client/unit/setup.ts
+// src/test/client/install-mocks.ts
 import { beforeEach } from "vitest";
 
-// src/test/client/mocks.ts
+// src/test/client/mocks/red.ts
 function createSettings() {
   const settings = {
     get(key) {
@@ -219,17 +219,19 @@ function createRED() {
   });
   return red;
 }
-function ensureState(el) {
+
+// src/test/client/mocks/jquery.ts
+function emptyState() {
+  return { typedInput: { value: "", type: "" }, listeners: {} };
+}
+function ensureJQueryState(el) {
   if (el && !el.__jqState) {
-    el.__jqState = {
-      typedInput: { value: "", type: "" },
-      listeners: {}
-    };
+    el.__jqState = emptyState();
   }
-  return el ? el.__jqState : { typedInput: { value: "", type: "" }, listeners: {} };
+  return el ? el.__jqState : emptyState();
 }
-function createJQ(el) {
-  const state = ensureState(el);
+function createJQueryElement(el) {
+  const state = ensureJQueryState(el);
   const jq = {
     0: el,
     length: el ? 1 : 0,
@@ -317,7 +319,7 @@ function createJQ(el) {
       return "";
     },
     find(selector) {
-      return createJQ(el?.querySelector(selector) ?? null);
+      return createJQueryElement(el?.querySelector(selector) ?? null);
     },
     append(child) {
       const childEl = child?.[0] || child;
@@ -370,20 +372,25 @@ function createJQuery() {
             }
           }
         }
-        return createJQ(el);
+        return createJQueryElement(el);
       }
-      return createJQ(document.querySelector(selector));
+      return createJQueryElement(document.querySelector(selector));
     }
-    if (selector instanceof Element) return createJQ(selector);
+    if (selector instanceof Element) return createJQueryElement(selector);
     if (selector && typeof selector === "object" && selector.nodeType)
-      return createJQ(selector);
-    return createJQ(null);
+      return createJQueryElement(selector);
+    return createJQueryElement(null);
   };
 }
 
+// src/test/client/install-mocks.ts
+function installEditorMocks() {
+  window.$ = createJQuery();
+  window.RED = createRED();
+  beforeEach(() => {
+    resetRED(window.RED);
+  });
+}
+
 // src/test/client/unit/setup.ts
-window.$ = createJQuery();
-window.RED = createRED();
-beforeEach(() => {
-  resetRED(window.RED);
-});
+installEditorMocks();

package/test/server/integration/index.js

@@ -4,7 +4,7 @@ import os from "os";
 import fs from "fs";
 import path from "path";
 import { createRequire } from "module";
-import { registerTypes } from "@bonsae/nrg/server";
+import { registerTypes } from "@bonsae/nrg-runtime/server";
 
 // src/test/server/integration/recorder.ts
 var Recorder = class {
@@ -78,32 +78,8 @@ var Recorder = class {
   }
 };
 
-// src/core/server/nodes/utils.ts
-import { Kind } from "@sinclair/typebox";
-function setupContext(context, store) {
-  return {
-    get: (key) => new Promise(
-      (resolve, reject) => context.get(
-        key,
-        store,
-        (error, value) => error ? reject(error) : resolve(value)
-      )
-    ),
-    set: (key, value) => new Promise(
-      (resolve, reject) => context.set(
-        key,
-        value,
-        store,
-        (error) => error ? reject(error) : resolve()
-      )
-    ),
-    keys: () => new Promise(
-      (resolve, reject) => context.keys(store, (error, k) => error ? reject(error) : resolve(k))
-    )
-  };
-}
-
 // src/test/server/integration/flow.ts
+import { setupContext } from "@bonsae/nrg-runtime/internal/server";
 var seq = 0;
 function genId(prefix) {
   seq += 1;

package/test/server/unit/index.js

@@ -235,191 +235,9 @@ function createNodeRedNode(options = {}) {
   };
 }
 
-// src/core/validator.ts
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-import addErrors from "ajv-errors";
-var Validator = class {
-  ajv;
-  constructor(options) {
-    const { customKeywords, customFormats, ...ajvOptions } = options || {};
-    this.ajv = new Ajv({
-      allErrors: true,
-      code: {
-        source: false
-      },
-      coerceTypes: true,
-      removeAdditional: false,
-      strict: false,
-      strictSchema: false,
-      useDefaults: true,
-      validateFormats: true,
-      // NOTE: typebox handles validation via typescript
-      // NOTE: if true, types that are not serializable JSON, like Function, would not work
-      validateSchema: false,
-      verbose: true,
-      ...ajvOptions
-    });
-    addFormats(this.ajv);
-    addErrors(this.ajv);
-    this.addCustomKeywords(customKeywords || []);
-    this.addCustomFormats(customFormats || {});
-  }
-  /**
-   * Add custom keywords to the validator
-   */
-  addCustomKeywords(keywords) {
-    if (!keywords) return;
-    keywords.forEach((keyword) => {
-      this.ajv.addKeyword(keyword);
-    });
-  }
-  /**
-   * Add custom formats to the validator
-   */
-  addCustomFormats(formats) {
-    if (!formats) return;
-    Object.entries(formats).forEach(([name, validator]) => {
-      if (validator instanceof RegExp) {
-        this.ajv.addFormat(name, validator);
-      } else {
-        this.ajv.addFormat(name, { validate: validator });
-      }
-    });
-  }
-  /**
-   * Create a validator function with caching
-   * @param schema - JSON Schema to validate against
-   * @param cacheKey - Optional cache key for reusing validators
-   */
-  createValidator(schema, cacheKey) {
-    if (cacheKey && !schema.$id) {
-      schema.$id = cacheKey;
-    }
-    if (schema.$id) {
-      const cached = this.ajv.getSchema(schema.$id);
-      if (cached) return cached;
-    }
-    const validator = this.ajv.compile(schema);
-    return validator;
-  }
-  /**
-   * Validate data against a schema and return a structured result
-   */
-  validate(data, schema, options) {
-    const validator = this.createValidator(schema, options?.cacheKey);
-    const valid = validator(data);
-    if (!valid) {
-      const errorMessage = this.formatErrors(validator.errors);
-      if (options?.throwOnError) {
-        throw new ValidationError(errorMessage, validator.errors || []);
-      }
-      return {
-        valid: false,
-        errors: validator.errors || void 0,
-        errorMessage
-      };
-    }
-    return {
-      valid: true,
-      data
-    };
-  }
-  /**
-   * Format errors into a human-readable string
-   */
-  formatErrors(errors, options) {
-    if (!errors || errors.length === 0) {
-      return "No errors";
-    }
-    return this.ajv.errorsText(errors, {
-      separator: "; ",
-      dataVar: "data",
-      ...options
-    });
-  }
-  /**
-   * Get detailed error information
-   */
-  getDetailedErrors(errors) {
-    if (!errors || errors.length === 0) return [];
-    return errors.map((error) => ({
-      field: error.instancePath || "/",
-      message: error.message || "Validation failed",
-      keyword: error.keyword,
-      params: error.params,
-      schemaPath: error.schemaPath
-    }));
-  }
-  /**
-   * Add a schema to the validator for reference
-   */
-  addSchema(schema, key) {
-    this.ajv.addSchema(schema, key);
-    return this;
-  }
-  /**
-   * Remove a schema from the validator
-   */
-  removeSchema(key) {
-    this.ajv.removeSchema(key);
-    return this;
-  }
-};
-var ValidationError = class _ValidationError extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
-  }
-};
-
-// src/core/server/validation.ts
-function initValidator(RED) {
-  if (RED.validator) return;
-  const nrg = {
-    validator: new Validator({
-      customKeywords: [
-        {
-          keyword: "x-nrg-skip-validation",
-          schemaType: "boolean",
-          valid: true
-        },
-        {
-          keyword: "x-nrg-node-type",
-          type: "string",
-          validate: (schemaValue, dataValue) => {
-            if (!dataValue) return true;
-            const node = RED.nodes.getNode(dataValue);
-            return node?.type === schemaValue;
-          }
-        }
-      ],
-      customFormats: {
-        "node-id": /^[a-zA-Z0-9-_]+$/,
-        "flow-id": /^[a-f0-9]{16}$/,
-        "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
-      }
-    })
-  };
-  Object.defineProperty(RED, "_nrg", {
-    value: nrg,
-    writable: false,
-    enumerable: false,
-    configurable: false
-  });
-  Object.defineProperty(RED, "validator", {
-    get: () => nrg.validator,
-    enumerable: false,
-    configurable: false
-  });
-}
-
-// src/core/server/nodes/symbols.ts
-var WIRE_HANDLERS = Symbol.for("nrg.wireHandlers");
-
 // src/test/server/unit/index.ts
+import { initValidator } from "@bonsae/nrg-runtime/internal/server";
+import { WIRE_HANDLERS } from "@bonsae/nrg-runtime/internal/server";
 import { Kind } from "@sinclair/typebox";
 function buildConfig(NodeClass, userConfig = {}) {
   const defaults = {};

package/types/client.d.ts

@@ -1,259 +1 @@
-// Generated by dts-bundle-generator v9.5.1
-
-import { Static, TSchema } from '@sinclair/typebox';
-import { SchemaObject } from 'ajv';
-import { App, Component } from 'vue';
-
-interface NodeRefResolved<T = any> {
-	readonly __nrg_node_ref: true;
-	readonly __instance: T;
-}
-interface TypedInputResolved {
-	resolve(...args: any[]): any;
-	value: unknown;
-	type: string;
-}
-interface JsonSchemaObjectExtensions {
-	format?: "node-id" | "flow-id" | "topic-path" | (string & {});
-	/** expose this settings property to the editor via RED.settings */
-	exportable?: boolean;
-	/** set by SchemaType.NodeRef — the referenced config node type */
-	"x-nrg-node-type"?: string;
-	/** set by SchemaType.TypedInput — marks a TypedInput value/type pair */
-	"x-nrg-typed-input"?: boolean;
-	/** set by markNonValidatable — ajv skips this property */
-	"x-nrg-skip-validation"?: boolean;
-	/** form rendering hints consumed by the auto-generated editor form */
-	"x-nrg-form"?: {
-		icon?: string;
-		typedInputTypes?: string[];
-		editorLanguage?: string;
-		toggle?: boolean;
-	};
-}
-export interface NodeStateCredentials {
-	[key: string]: any;
-}
-export interface NodeState {
-	credentials: NodeStateCredentials;
-	[key: string]: any;
-}
-export interface NodeButtonDefinition {
-	toggle: string;
-	onClick: () => void;
-	enabled?: () => boolean;
-	visible?: () => boolean;
-}
-export interface NodeRedNodeButtonDefinition {
-	toggle: string;
-	onclick: () => void;
-	enabled?: () => boolean;
-	visible?: () => boolean;
-}
-export interface NodeFormDefinition {
-	component?: Component;
-}
-export interface NodeRedNode {
-	id: string;
-	type: string;
-	name: string;
-	category: string;
-	x: string;
-	y: string;
-	g: string;
-	z: string;
-	credentials: Record<string, any>;
-	_def: {
-		defaults: Record<string, {
-			value: string;
-			type?: string;
-			label?: string;
-			required?: boolean;
-		}>;
-		credentials: Record<string, {
-			value: string;
-			type?: "password" | "text";
-			label?: string;
-			required?: boolean;
-		}>;
-		category: string;
-		color?: string;
-		icon?: string;
-		label?: ((this: NodeRedNode) => string) | string;
-		inputs?: number;
-		outputs?: number;
-		paletteLabel?: ((this: NodeRedNode) => string) | string;
-		labelStyle?: ((this: NodeRedNode) => string) | string;
-		inputLabels?: ((this: NodeRedNode, index: number) => string) | string;
-		outputLabels?: ((this: NodeRedNode, index: number) => string) | string;
-		align?: "left" | "right";
-		button?: NodeRedNodeButtonDefinition;
-	};
-	_newState?: NodeRedNode;
-	_app?: App | null;
-	_: (str: string) => string;
-	/** dynamic port count (base outputs + enabled built-in ports) */
-	outputs?: number;
-	/** injected when the node has an inputSchema */
-	validateInput?: boolean;
-	/** built-in port toggles, present when declared in the configSchema */
-	errorPort?: boolean;
-	completePort?: boolean;
-	statusPort?: boolean;
-	/**
-	 * Per-port output settings, indexed by base-output port. `validateOutputs` is
-	 * injected (empty) when the node has an outputsSchema; `outputReturnProperties`
-	 * and `outputContextModes` are author-declared (SchemaType.*) — present only
-	 * when the node opts into per-port return keys / context modes. Read at
-	 * runtime by IONode.
-	 */
-	validateOutputs?: Record<number, boolean>;
-	outputContextModes?: Record<number, "carry" | "trace" | "reset">;
-	outputReturnProperties?: Record<number, string>;
-	[key: string]: any;
-}
-export interface NodeDefinition {
-	type: string;
-	category?: string;
-	color?: string;
-	icon?: ((this: NodeRedNode) => string) | string;
-	label?: ((this: NodeRedNode) => string) | string;
-	inputs?: number;
-	outputs?: number;
-	paletteLabel?: ((this: NodeRedNode) => string) | string;
-	labelStyle?: ((this: NodeRedNode) => string) | string;
-	inputLabels?: ((this: NodeRedNode, index: number) => string) | string;
-	outputLabels?: ((this: NodeRedNode, index: number) => string) | string;
-	align?: "left" | "right";
-	button?: NodeButtonDefinition;
-	onEditResize?: (this: NodeRedNode, size: {
-		width: number;
-		height: number;
-	}) => void;
-	onPaletteAdd?: (this: NodeRedNode) => void;
-	onPaletteRemove?: (this: NodeRedNode) => void;
-	form?: NodeFormDefinition;
-}
-/** Form rendering hints carried by the `x-nrg-form` schema keyword. */
-export type NrgFormOptions = NonNullable<JsonSchemaObjectExtensions["x-nrg-form"]>;
-/**
- * A serialized property schema inside {@link JsonSchemaObject} `properties`,
- * including NRG's custom keywords (shared vocabulary in core/schema-options)
- * that drive form rendering and NodeRef/TypedInput identification.
- */
-export interface JsonPropertySchema extends JsonSchemaObjectExtensions {
-	type?: string | string[];
-	properties?: Record<string, JsonPropertySchema>;
-	required?: string[];
-	enum?: unknown[];
-	anyOf?: JsonPropertySchema[];
-	const?: unknown;
-	items?: JsonPropertySchema;
-	title?: string;
-	description?: string;
-	default?: unknown;
-}
-/**
- * A serialized JSON Schema object as the build pipeline emits it (never a
- * live TypeBox instance). Extends ajv's `SchemaObject` so it flows into
- * validator APIs without casts, while keeping the `type: "object"`
- * discriminant and structured `properties`/`required` that ajv's open
- * `[x: string]: any` shape does not provide.
- */
-export interface JsonSchemaObject extends SchemaObject {
-	type: "object";
-	properties?: Record<string, JsonPropertySchema>;
-	required?: string[];
-}
-/**
- * A node definition as it exists at editor runtime, after the build pipeline
- * merged in the schema-derived artifacts (defaults, credentials, serialized
- * schemas). Authors write {@link NodeDefinition}; the inliner provides the
- * rest.
- */
-export interface RuntimeNodeDefinition extends NodeDefinition {
-	defaults?: NodeDefaults;
-	credentials?: NodeCredentials;
-	configSchema?: JsonSchemaObject;
-	credentialsSchema?: JsonSchemaObject;
-	inputSchema?: JsonSchemaObject;
-	/**
-	 * Single port, positional ports, or named ports (key = port name).
-	 * Not constrained to object schemas: with returnProperty the raw sent
-	 * value is validated, so results may be any schema shape.
-	 */
-	outputsSchema?: JsonPropertySchema | JsonPropertySchema[] | Record<string, JsonPropertySchema>;
-}
-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 NodeFeatures {
-	hasInputSchema: boolean;
-	hasOutputSchema: boolean;
-	/**
-	 * Base output ports (excludes built-in error/complete/status), in port-index
-	 * order. Drives the per-port context-mode rows in the Outputs subsection.
-	 */
-	outputPorts: {
-		index: number;
-		label: string;
-	}[];
-}
-/** Client-side representation of a TypedInput field: the raw value string and its type selector. */
-export interface TypedInputValue {
-	value: string;
-	type: string;
-}
-/**
- * Maps a schema's static type to the raw values the editor form holds.
- * The server counterpart (`ResolvedStatic` in server/schemas/types) maps the
- * same brands — shared via core/brands — to resolved runtime values instead.
- * - `NodeRef<T>` → `string` (the referenced node's id)
- * - `TypedInput<T>` → `TypedInputValue` (raw value + type pair)
- * - Functions pass through, arrays and objects map recursively
- */
-export type EditorStatic<T> = T extends NodeRefResolved<any> ? string : T extends TypedInputResolved ? TypedInputValue : T extends (...args: any[]) => any ? T : T extends Array<infer I> ? EditorStatic<I>[] : T extends object ? {
-	[K in keyof T]: EditorStatic<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> = EditorStatic<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>;
-};
+export * from "@bonsae/nrg-runtime/client";