@bonsae/nrg 0.2.0 → 0.4.0

package/build/index.js

@@ -0,0 +1,7 @@
+// src/utils.ts
+function defineRuntimeSettings(settings) {
+  return settings;
+}
+export {
+  defineRuntimeSettings
+};

package/build/vite/index.js

@@ -111,9 +111,6 @@ function mergeOptions(defaults, overrides) {
   }
   return result;
 }
-function defineRuntimeSettings(settings) {
-  return settings;
-}
 
 // src/vite/node-red-launcher.ts
 import { spawn } from "child_process";
@@ -1917,6 +1914,5 @@ function nodeRed(options = {}) {
   ];
 }
 export {
-  defineRuntimeSettings,
   nodeRed
 };

package/build/vite/utils.js

@@ -48,13 +48,9 @@ function mergeOptions(defaults, overrides) {
   }
   return result;
 }
-function defineRuntimeSettings(settings) {
-  return settings;
-}
 export {
   cleanDir,
   copyFiles,
-  defineRuntimeSettings,
   getPackageName,
   mergeOptions
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -33,6 +33,10 @@
     "build/"
   ],
   "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./build/index.js"
+    },
     "./server": {
       "types": "./src/core/server/index.ts",
       "require": "./build/server/index.cjs",
@@ -94,6 +98,7 @@
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
     "@types/express": "^5.0.1",
+    "@types/jquery": "^4.0.0",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^22.15.18",
     "@typescript-eslint/eslint-plugin": "^8.32.1",

package/src/core/client/globals.d.ts

@@ -1,17 +1,320 @@
 /**
  * Global type declarations for the Node-RED editor environment.
  * These are provided by Node-RED at runtime, not imported.
+ *
+ * Based on: https://github.com/GogoVega/node-red/blob/33d83d016a0c990c/packages/node_modules/%40node-red/editor-client/types/index.d.ts
  */
 
-// jQuery — injected by Node-RED editor
-declare const $: any;
+/// <reference types="jquery" />
+
+// ---------------------------------------------------------------------------
+// jQuery Node-RED widget extensions
+// ---------------------------------------------------------------------------
+
+interface JQuery<TElement = HTMLElement> {
+  // Node-RED TypedInput widget
+  typedInput(options: NodeRED.TypedInputOptions): this;
+  typedInput(action: "value"): string;
+  typedInput(action: "value", value: string): void;
+  typedInput(action: "type"): string;
+  typedInput(action: "type", value: string): void;
+  typedInput(action: "types", value: any[]): void;
+  typedInput(action: "validate"): boolean;
+  typedInput(
+    action: "validate",
+    options: { returnErrorMessage: boolean },
+  ): string | boolean;
+  typedInput(action: "disable", value?: boolean): void;
+  typedInput(action: "enable"): void;
+  typedInput(action: "focus"): void;
+  typedInput(action: "hide"): void;
+  typedInput(action: "show"): void;
+  typedInput(action: "width", value: string | number): void;
+
+  // Node-RED i18n
+  i18n(): this;
+}
+
+// ---------------------------------------------------------------------------
+// Node-RED editor types
+// ---------------------------------------------------------------------------
+
+declare namespace NodeRED {
+  type UID = string;
+
+  // -- Nodes --
+
+  interface BaseNode {
+    id: UID;
+    type: string;
+    changed: boolean;
+    z?: string;
+    _def: any;
+    [key: string]: any;
+  }
+
+  interface Node extends BaseNode {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    name: string;
+    wires: UID[][];
+    inputs: number;
+    outputs: number;
+    g?: string;
+    _: (key: string) => string;
+  }
+
+  interface ConfigNode extends BaseNode {
+    name: string;
+    credentials?: Record<string, any>;
+    users: BaseNode[];
+    _def: {
+      category: "config";
+      [key: string]: any;
+    };
+  }
+
+  interface Link {
+    source: BaseNode;
+    target: BaseNode;
+    sourcePort: number;
+  }
+
+  interface Workspace {
+    id: UID;
+    type: "tab";
+    label: string;
+    disabled: boolean;
+    info: string;
+  }
+
+  // -- Editor --
+
+  interface EditorOptions {
+    id: string;
+    stateId?: string;
+    mode?: string;
+    value?: string;
+    focus?: boolean;
+    globals?: Record<string, boolean>;
+  }
+
+  interface TrayButton {
+    id?: string;
+    class?: string;
+    click?: (event: JQuery.ClickEvent) => void;
+    text?: string;
+  }
+
+  interface TrayOptions {
+    title?: string;
+    buttons?: TrayButton[];
+    focusElement?: boolean;
+    maximized?: boolean;
+    width?: "inherit" | number | string;
+    overlay?: boolean;
+    open?: (tray: JQuery, done?: () => void) => void;
+    close?: () => void;
+    resize?: (options: { width: number; height?: number }) => void;
+    show?: () => void;
+  }
+
+  // -- Popover --
+
+  interface PopoverOptions {
+    target: JQuery;
+    direction?: string;
+    trigger?: "hover" | "click" | "modal";
+    content: string | JQuery | (() => string | JQuery);
+    delay?: { show: number; hide: number };
+    autoClose?: number;
+    width?: number | string;
+    maxWidth?: number | string;
+    tooltip?: boolean;
+    interactive?: boolean;
+    class?: string;
+  }
+
+  interface PopoverInstance {
+    readonly element: JQuery | null;
+    close(instant?: boolean): PopoverInstance;
+    open(instant?: boolean): PopoverInstance;
+    setContent(content: PopoverOptions["content"]): PopoverInstance;
+    move(options: Partial<PopoverOptions>): void;
+  }
+
+  interface TooltipInstance extends PopoverInstance {
+    delete(): void;
+    setAction(action: string): void;
+  }
+
+  // -- Notifications --
+
+  interface NotificationOptions {
+    type?: "warning" | "compact" | "success" | "error";
+    fixed?: boolean;
+    modal?: boolean;
+    timeout?: number;
+    buttons?: Array<{
+      text: string;
+      class?: string;
+      click?: (event: JQuery.ClickEvent) => void;
+    }>;
+    id?: string;
+  }
+
+  interface NotificationElement {
+    update(msg: string | JQuery, options?: NotificationOptions): void;
+    close(): void;
+  }
+
+  // -- TypedInput --
+
+  type DefaultTypedInputType =
+    (typeof import("../constants").TYPED_INPUT_TYPES)[number];
+
+  interface TypedInputTypeDefinition {
+    value: string;
+    label?: string;
+    icon?: string;
+    hasValue?: boolean;
+    multiple?: boolean;
+    options?: string[] | Array<{ value: string; label: string }>;
+    validate?: ((value: string) => boolean) | RegExp;
+    valueLabel?: (container: JQuery, value: string) => void;
+    autoComplete?: (
+      value: string,
+      done: (result?: Array<{ value: string; label: string | JQuery }>) => void,
+    ) => void;
+  }
+
+  interface TypedInputOptions {
+    default?: DefaultTypedInputType | string;
+    types: Array<DefaultTypedInputType | TypedInputTypeDefinition>;
+    typeField?: JQuery.Selector | JQuery;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// RED global object
+// ---------------------------------------------------------------------------
 
-// Node-RED editor API — injected by Node-RED editor
 declare const RED: {
+  /** Internationalization / translation function */
+  _: (key: string, substitutions?: Record<string, string>) => string;
+
+  /** Node management */
   nodes: {
     registerType(type: string, definition: any): void;
-    node(id: string): any;
+    node(id: NodeRED.UID): NodeRED.BaseNode | null;
     dirty(): boolean;
+    dirty(dirty: boolean): void;
+    eachNode(callback: (node: NodeRED.Node) => void | false): void;
+    eachConfig(callback: (node: NodeRED.ConfigNode) => void | false): void;
+    filterNodes(filter: { z?: NodeRED.UID; type?: string }): NodeRED.BaseNode[];
+    filterLinks(filter: {
+      source?: NodeRED.BaseNode;
+      target?: NodeRED.BaseNode;
+    }): NodeRED.Link[];
+    getType(type: string): any;
+    id(): NodeRED.UID;
+    add(node: any): NodeRED.BaseNode;
+    remove(id: NodeRED.UID): {
+      links: NodeRED.Link[];
+      nodes: NodeRED.BaseNode[];
+    };
+  };
+
+  /** Code editor (ACE/Monaco) */
+  editor: {
+    createEditor(options: NodeRED.EditorOptions): any;
+    edit(node: NodeRED.Node, defaultTab?: any): void;
+    editConfig(
+      name: string,
+      type: string,
+      id: string,
+      prefix?: string,
+      editContext?: NodeRED.Node,
+    ): void;
+    prepareConfigNodeSelect(
+      node: NodeRED.BaseNode,
+      property: string,
+      type: string,
+      prefix?: string,
+      filter?: (configNode: NodeRED.ConfigNode) => boolean,
+    ): void;
+    validateNode(node: NodeRED.BaseNode): boolean;
+  };
+
+  /** Side panel tray */
+  tray: {
+    show(options: NodeRED.TrayOptions): void;
+    close(): void;
+  };
+
+  /** Popover / tooltip */
+  popover: {
+    create(options: NodeRED.PopoverOptions): NodeRED.PopoverInstance;
+    tooltip(
+      target: JQuery,
+      text: string,
+      direction?: string,
+    ): NodeRED.TooltipInstance;
+  };
+
+  /** Toast notifications */
+  notify(
+    message: string | JQuery,
+    options?: NodeRED.NotificationOptions,
+  ): NodeRED.NotificationElement;
+
+  /** Event system */
+  events: {
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+  };
+
+  /** Undo/redo */
+  history: {
+    push(event: any): void;
+    pop(): any;
+    peek(): any;
+    list(): any[];
+  };
+
+  /** Keyboard shortcuts */
+  keyboard: {
+    add(scope: string, key: string, callback: () => void): void;
+    remove(key: string): void;
+  };
+
+  /** Runtime communication (WebSocket) */
+  comms: {
+    subscribe(topic: string, callback: (topic: string, msg: any) => void): void;
+    unsubscribe(
+      topic: string,
+      callback: (topic: string, msg: any) => void,
+    ): void;
+  };
+
+  /** Editor settings */
+  settings: {
+    get(key: string): any;
+    set(key: string, value: any): any;
+    remove(key: string): any;
+    [key: string]: any;
   };
+
+  /** Canvas view */
+  view: {
+    focus(): void;
+    selection(): { nodes?: NodeRED.Node[] };
+    redraw(updateActive?: boolean): void;
+  };
+
+  /** Catch-all for untyped properties */
   [key: string]: any;
 };

package/src/core/server/nodes/node.ts

@@ -1,5 +1,5 @@
 import type { Schema } from "../schemas/types";
-import { type RED } from "../../server/types";
+import { type RED, type NodeRedNode } from "../../server/types";
 import type {
   ConfigNodeContext,
   IONodeContext,
@@ -80,7 +80,7 @@ abstract class Node<TConfig = any, TCredentials = any, TSettings = any> {
     RED.log.info("Settings are valid");
   }
   protected readonly RED: RED;
-  protected readonly node: any;
+  protected readonly node: NodeRedNode;
   protected readonly context!: ConfigNodeContext | IONodeContext;
   public readonly config!: NodeConfig<TConfig>;
 
@@ -89,7 +89,7 @@ abstract class Node<TConfig = any, TCredentials = any, TSettings = any> {
 
   constructor(
     RED: RED,
-    node: any,
+    node: NodeRedNode,
     config: NodeConfig<TConfig>,
     credentials: NodeCredentials<TCredentials>,
   ) {

package/src/core/server/types/index.ts

@@ -1,38 +1,204 @@
-import type { TObject } from "@sinclair/typebox";
+import type { EventEmitter } from "events";
+import type { NodeRedRuntimeSettings } from "../../../types";
 
-interface RED {
-  _: (key: string, substitutions?: Record<string, string>) => string;
-  log: {
-    info(msg: any): void;
-    warn(msg: any): void;
-    error(message: string, error: any): void;
-    debug(msg: any): void;
-    trace(msg: any): void;
-  };
-  nodes: {
-    registerType: (type: string, def: any, opts?: any) => void;
-    getNode: <T = any>(id: string) => T | undefined;
-    createNode: (node: any, config: Record<string, any>) => void;
-    getCredentials: (id: string) => Record<string, any> | undefined;
-  };
-  httpAdmin: {
-    get(path: string, handler: (req: any, res: any) => void): void;
-    post(path: string, handler: (req: any, res: any) => void): void;
-    put(path: string, handler: (req: any, res: any) => void): void;
-    delete(path: string, handler: (req: any, res: any) => void): void;
-  };
-  util: {
-    evaluateNodeProperty(
-      value: any,
-      type: string,
-      node: any,
-      msg: Record<string, any> | undefined,
-      callback: (err: Error | null, result: any) => void,
-    ): void;
+// ---------------------------------------------------------------------------
+// RED.log
+// ---------------------------------------------------------------------------
+
+interface NodeRedLog {
+  info(msg: any): void;
+  warn(msg: any): void;
+  error(msg: any, error?: any): void;
+  debug(msg: any): void;
+  trace(msg: any): void;
+  log(msg: { level: number; msg: string }): void;
+  metric(): boolean;
+  audit(msg: Record<string, any>, req?: any): void;
+  addHandler(handler: (msg: any) => void): void;
+  removeHandler(handler: (msg: any) => void): void;
+  FATAL: 10;
+  ERROR: 20;
+  WARN: 30;
+  INFO: 40;
+  DEBUG: 50;
+  TRACE: 60;
+  AUDIT: 98;
+  METRIC: 99;
+}
+
+// ---------------------------------------------------------------------------
+// Node-RED runtime node (the raw node object from RED.nodes.createNode)
+// ---------------------------------------------------------------------------
+
+interface NodeRedNode {
+  id: string;
+  type: string;
+  name?: string;
+  z?: string;
+  x: number;
+  y: number;
+  g?: string;
+  wires: string[][];
+  credentials: any;
+  _node?: any;
+  send(msg: any): void;
+  receive(msg: any): void;
+  status(
+    status: string | { fill?: string; shape?: string; text?: string },
+  ): void;
+  updateWires(wires: string[][]): void;
+  on(event: string, callback: (...args: any[]) => void): void;
+  log(msg: any): void;
+  warn(msg: any): void;
+  error(msg: any, errorMsg?: any): void;
+  context(): NodeRedNodeContext;
+  [key: string]: any;
+}
+
+interface NodeRedNodeContext extends NodeRedContextStore {
+  flow: NodeRedContextStore;
+  global: NodeRedContextStore;
+}
+
+// ---------------------------------------------------------------------------
+// RED.nodes
+// ---------------------------------------------------------------------------
+
+interface NodeRedNodes {
+  registerType(type: string, constructor: any, opts?: any): void;
+  getNode(id: string): (NodeRedNode & { _node?: any }) | undefined;
+  createNode(node: NodeRedNode, config: Record<string, any>): void;
+  getCredentials(id: string): Record<string, any> | undefined;
+  eachNode(callback: (node: any) => void): void;
+  getType(type: string): any;
+  getNodeInfo(type: string): any;
+  getNodeList(filter?: any): any[];
+  getModuleInfo(module: string): any;
+  installModule(module: string, version?: string): Promise<any>;
+  uninstallModule(module: string): Promise<any>;
+  enableNode(id: string): Promise<any>;
+  disableNode(id: string): Promise<any>;
+}
+
+// ---------------------------------------------------------------------------
+// RED.util
+// ---------------------------------------------------------------------------
+
+interface NodeRedUtil {
+  evaluateNodeProperty(
+    value: any,
+    type: string,
+    node: any,
+    msg: Record<string, any> | undefined,
+    callback: (err: Error | null, result: any) => void,
+  ): void;
+  generateId(): string;
+  cloneMessage<T = any>(msg: T): T;
+  ensureString(o: any): string;
+  ensureBuffer(o: any): Buffer;
+  compareObjects(obj1: any, obj2: any): boolean;
+  getMessageProperty(msg: any, expr: string): any;
+  setMessageProperty(
+    msg: any,
+    prop: string,
+    value: any,
+    createMissing?: boolean,
+  ): void;
+  getObjectProperty(obj: any, expr: string): any;
+  setObjectProperty(
+    obj: any,
+    prop: string,
+    value: any,
+    createMissing?: boolean,
+  ): void;
+  normalisePropertyExpression(
+    str: string,
+    msg?: any,
+    toString?: boolean,
+  ): string[];
+  normaliseNodeTypeName(name: string): string;
+  prepareJSONataExpression(value: string, node: any): any;
+  evaluateJSONataExpression(
+    expr: any,
+    msg: any,
+    callback: (err: Error | null, result: any) => void,
+  ): void;
+  parseContextStore(key: string): {
+    store: string | undefined;
+    key: string;
   };
-  settings: Record<string, any>;
+  getSetting(node: any, name: string, flow?: any): any;
+  encodeObject(obj: any): any;
+}
+
+// ---------------------------------------------------------------------------
+// RED.hooks
+// ---------------------------------------------------------------------------
+
+interface NodeRedHooks {
+  add(hookId: string, callback: (event: any) => void | Promise<void>): void;
+  remove(hookId: string): void;
+  trigger(
+    hookId: string,
+    event: any,
+    callback?: (err?: Error) => void,
+  ): void | Promise<void>;
+  has(hookId: string): boolean;
+  clear(): void;
+}
+
+// ---------------------------------------------------------------------------
+// Express-like HTTP app (httpAdmin / httpNode)
+// ---------------------------------------------------------------------------
+
+type NodeRedRequestHandler = (req: any, res: any, next?: () => void) => void;
+
+interface NodeRedExpressApp {
+  get(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  post(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  put(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  delete(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  patch(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  options(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  head(path: string, ...handlers: NodeRedRequestHandler[]): void;
+  use(
+    path: string | NodeRedRequestHandler,
+    ...handlers: NodeRedRequestHandler[]
+  ): void;
+  all(path: string, ...handlers: NodeRedRequestHandler[]): void;
+}
+
+// ---------------------------------------------------------------------------
+// RED (main interface)
+// ---------------------------------------------------------------------------
+
+interface RED {
+  /** Internationalization function */
+  _(key: string, substitutions?: Record<string, string>): string;
+  /** Logging API */
+  log: NodeRedLog;
+  /** Node registry and management */
+  nodes: NodeRedNodes;
+  /** Utility functions */
+  util: NodeRedUtil;
+  /** Hook system for message lifecycle and module events */
+  hooks: NodeRedHooks;
+  /** Runtime event emitter */
+  events: EventEmitter;
+  /** Express app for admin HTTP endpoints */
+  httpAdmin: NodeRedExpressApp;
+  /** Express app for node HTTP endpoints */
+  httpNode: NodeRedExpressApp;
+  /** Runtime settings (user-provided settings plus node-registered settings) */
+  settings: NodeRedRuntimeSettings & Record<string, any>;
+  /** Node-RED version string */
+  version(): string;
 }
 
+// ---------------------------------------------------------------------------
+// Context store (internal)
+// ---------------------------------------------------------------------------
+
 interface NodeRedContextStore {
   get(
     key: string,
@@ -51,23 +217,4 @@ interface NodeRedContextStore {
   ): void;
 }
 
-interface NodeDefinitionApiResponse {
-  type: string;
-  align?: "left" | "right";
-  category?: "config" | string;
-  color?: `#${string}`;
-  icon?: string;
-  labelStyle?: "node_label" | "node_label_italic" | string;
-  paletteLabel?: string;
-  inputs?: number;
-  outputs?: number;
-  inputLabels?: string | string[];
-  outputLabels?: string | string[];
-  configSchema: TObject | null;
-  credentialsSchema: TObject | null;
-  inputSchema?: TObject | null;
-  outputsSchema?: TObject | null;
-  settingsSchema?: TObject | null;
-}
-
-export { RED, NodeDefinitionApiResponse, NodeRedContextStore };
+export { RED, NodeRedNode, NodeRedNodeContext, NodeRedContextStore };

package/src/index.ts

@@ -0,0 +1,2 @@
+export { defineRuntimeSettings } from "./utils";
+export type { NodeRedRuntimeSettings } from "./types";

package/src/types.ts

@@ -0,0 +1,189 @@
+import type { Http2ServerRequest } from "http2";
+
+export interface NodeRedRuntimeSettings {
+  userDir?: string;
+  nodesDir?: string | string[];
+  flowFile?: string;
+  flowFilePretty?: boolean;
+  credentialSecret?: string | false;
+  requireHttps?: boolean;
+  https?:
+    | { key: string; cert: string }
+    | (() =>
+        | Promise<{ key: string; cert: string }>
+        | { key: string; cert: string });
+  httpsRefreshInterval?: number;
+  httpAdminRoot?: string;
+  httpNodeRoot?: string;
+  httpNodeCors?: { origin: string; methods: string };
+  httpStatic?: string | { path: string; root: string }[];
+  httpStaticRoot?: string;
+  httpAdminMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
+  httpNodeMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
+  httpServerOptions?: Record<string, unknown>;
+  adminAuth?: {
+    type?: "credentials" | "strategy";
+    users?: {
+      username: string;
+      password: string;
+      permissions?: string | string[];
+    }[];
+    default?: {
+      permissions?: string | string[];
+    };
+    tokens?: (
+      token: string,
+    ) => Promise<{ user: string; permissions: string | string[] } | null>;
+    tokenHeader: "string";
+    sessionExpiryTime?: number;
+    [key: string]: unknown;
+  };
+  httpNodeAuth?: {
+    user?: string;
+    pass?: string;
+  };
+  httpStaticAuth?: {
+    user?: string;
+    pass?: string;
+  };
+  lang?:
+    | "en-US"
+    | "de"
+    | "es-ES"
+    | "fr"
+    | "ko"
+    | "pt-BR"
+    | "ru"
+    | "ja"
+    | "zh-CN"
+    | "zh-TW";
+  diagnostics?: {
+    enabled?: boolean;
+    ui?: boolean;
+  };
+  runtimeState?: {
+    enabled?: boolean;
+    ui?: boolean;
+  };
+  disableEditor?: boolean;
+  editorTheme?: {
+    page?: {
+      title?: string;
+      favicon?: string;
+      css?: string | string[];
+      scripts?: string | string[];
+    };
+    header?: {
+      title?: string;
+      image?: string;
+      url?: string;
+    };
+    deployButton?: {
+      type?: "simple" | "default";
+      label?: string;
+      icon?: string;
+    };
+    menu?: {
+      "menu-item-import-library"?: boolean;
+      "menu-item-export-library"?: boolean;
+      "menu-item-keyboard-shortcuts"?: boolean;
+      "menu-item-help"?: {
+        label?: string;
+        url?: string;
+      };
+      [menuItem: string]:
+        | boolean
+        | { label?: string; url?: string }
+        | undefined;
+    };
+    userMenu?: boolean;
+    login?: {
+      image?: string;
+    };
+    logout?: {
+      redirect?: string;
+    };
+    palette?: {
+      catalogues?: string[];
+      categories?: string[];
+      theme?: { category: string; type: string; color: string }[];
+    };
+    projects?: {
+      enabled?: boolean;
+      workflow?: {
+        mode: "manual" | "auto";
+      };
+    };
+    codeEditor?: {
+      lib?: "monaco" | "ace";
+      options?: Record<string, unknown>;
+    };
+    mermaid?: {
+      theme?: string;
+    };
+    tours?: boolean;
+    theme?: string;
+    [key: string]: unknown;
+  };
+  contextStorage?: {
+    default?: {
+      module?: "memory" | "localfilesystem" | object;
+      config?: Record<string, unknown>;
+    };
+    [store: string]:
+      | {
+          module?: "memory" | "localfilesystem" | object;
+          config?: Record<string, unknown>;
+        }
+      | undefined;
+  };
+  exportGlobalContextKeys?: boolean;
+  logging?: {
+    console?: {
+      level?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "off";
+      metrics?: boolean;
+      audit?: boolean;
+    };
+  };
+  fileWorkingDirectory?: string;
+  functionExternalModules?: boolean;
+  functionGlobalContext?: Record<string, unknown>;
+  nodeMessageBufferMaxLength?: number;
+  functionTimeout?: number;
+  externalModules?: {
+    autoInstall?: boolean;
+    autoInstallRetry?: number;
+    palette?: {
+      allowInstall?: boolean;
+      allowUpdate?: boolean;
+      allowUpload?: boolean;
+      allowList?: string[];
+      denyList?: string[];
+      allowUpdateList?: string[];
+      denyUpdateList?: string[];
+    };
+    modules?: {
+      allowInstall?: boolean;
+      allowList?: string[];
+      denyList?: string[];
+    };
+  };
+  execMaxBufferSize?: number;
+  debugMaxLength?: number;
+  debugUseColors?: boolean;
+  httpRequestTimeout?: number;
+  mqttReconnectTime?: number;
+  serialReconnectTime?: number;
+  socketReconnectTime?: number;
+  socketTimeout?: number;
+  tcpMsgQueueSize?: number;
+  inboundWebSocketTimeout?: number;
+  tlsConfigDisableLocalFiles?: boolean;
+  webSocketNodeVerifyClient?: (info: {
+    origin: string;
+    req: Http2ServerRequest;
+    secure: boolean;
+  }) => boolean;
+  apiMaxLength?: string;
+  [key: string]: unknown;
+}

package/src/utils.ts

@@ -0,0 +1,20 @@
+import type { NodeRedRuntimeSettings } from "./types";
+
+/**
+ * Type-safe helper for defining Node-RED runtime settings.
+ *
+ * @example
+ * ```typescript
+ * import { defineRuntimeSettings } from "@bonsae/nrg";
+ *
+ * export default defineRuntimeSettings({
+ *   flowFile: "flows.json",
+ *   flowFilePretty: true,
+ * });
+ * ```
+ */
+export function defineRuntimeSettings(
+  settings: NodeRedRuntimeSettings,
+): NodeRedRuntimeSettings {
+  return settings;
+}

package/src/vite/index.ts

@@ -1,3 +1,2 @@
 export { nodeRed } from "./plugin";
-export { defineRuntimeSettings } from "./utils";
-export type { NodeRedPluginOptions, NodeRedRuntimeSettings } from "./types";
+export type { NodeRedPluginOptions } from "./types";

package/src/vite/types.ts

@@ -1,6 +1,5 @@
 import type { Plugin } from "vite";
 import type { NodeRedLauncher } from "./node-red-launcher";
-import type { Http2ServerRequest } from "http2";
 
 interface BuildContext {
   outDir: string;
@@ -105,199 +104,6 @@ interface NodeRedPluginOptions {
   extraFilesCopyTargets?: CopyTarget[];
 }
 
-interface NodeRedRuntimeSettings {
-  // NOTE: commented out because the preferred port must be set using NodeRedLauncherOptions.runtime.port
-  // uiPort?: number;
-  // NOTE: commented out because the plugin set it to 127.0.0.1
-  // uiHost?: string;
-  userDir?: string;
-  nodesDir?: string | string[];
-  flowFile?: string;
-  flowFilePretty?: boolean;
-  credentialSecret?: string | false;
-  requireHttps?: boolean;
-  https?:
-    | { key: string; cert: string }
-    | (() =>
-        | Promise<{ key: string; cert: string }>
-        | { key: string; cert: string });
-  httpsRefreshInterval?: number;
-  httpAdminRoot?: string;
-  httpNodeRoot?: string;
-  httpNodeCors?: { origin: string; methods: string };
-  httpStatic?: string | { path: string; root: string }[];
-  httpStaticRoot?: string;
-  httpAdminMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
-  httpNodeMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
-  httpServerOptions?: Record<string, unknown>;
-  adminAuth?: {
-    type?: "credentials" | "strategy";
-    users?: {
-      username: string;
-      password: string;
-      permissions?: string | string[];
-    }[];
-    default?: {
-      permissions?: string | string[];
-    };
-    tokens?: (
-      token: string,
-    ) => Promise<{ user: string; permissions: string | string[] } | null>;
-    tokenHeader: "string";
-    sessionExpiryTime?: number;
-    [key: string]: unknown;
-  };
-  httpNodeAuth?: {
-    user?: string;
-    pass?: string;
-  };
-  httpStaticAuth?: {
-    user?: string;
-    pass?: string;
-  };
-  lang?:
-    | "en-US"
-    | "de"
-    | "es-ES"
-    | "fr"
-    | "ko"
-    | "pt-BR"
-    | "ru"
-    | "ja"
-    | "zh-CN"
-    | "zh-TW";
-  diagnostics?: {
-    enabled?: boolean;
-    ui?: boolean;
-  };
-  runtimeState?: {
-    enabled?: boolean;
-    ui?: boolean;
-  };
-  disableEditor?: boolean;
-  editorTheme?: {
-    page?: {
-      title?: string;
-      favicon?: string;
-      css?: string | string[];
-      scripts?: string | string[];
-    };
-    header?: {
-      title?: string;
-      image?: string;
-      url?: string;
-    };
-    deployButton?: {
-      type?: "simple" | "default";
-      label?: string;
-      icon?: string;
-    };
-    menu?: {
-      "menu-item-import-library"?: boolean;
-      "menu-item-export-library"?: boolean;
-      "menu-item-keyboard-shortcuts"?: boolean;
-      "menu-item-help"?: {
-        label?: string;
-        url?: string;
-      };
-      [menuItem: string]:
-        | boolean
-        | { label?: string; url?: string }
-        | undefined;
-    };
-    userMenu?: boolean;
-    login?: {
-      image?: string;
-    };
-    logout?: {
-      redirect?: string;
-    };
-    palette?: {
-      catalogues?: string[];
-      categories?: string[];
-      theme?: { category: string; type: string; color: string }[];
-    };
-    projects?: {
-      enabled?: boolean;
-      workflow?: {
-        mode: "manual" | "auto";
-      };
-    };
-    codeEditor?: {
-      lib?: "monaco" | "ace";
-      // TODO: add monaco option types
-      options?: Record<string, unknown>;
-    };
-    mermaid?: {
-      theme?: string;
-    };
-    tours?: boolean;
-    theme?: string;
-    [key: string]: unknown;
-  };
-  contextStorage?: {
-    default?: {
-      module?: "memory" | "localfilesystem" | object;
-      config?: Record<string, unknown>;
-    };
-    [store: string]:
-      | {
-          module?: "memory" | "localfilesystem" | object;
-          config?: Record<string, unknown>;
-        }
-      | undefined;
-  };
-  exportGlobalContextKeys?: boolean;
-  logging?: {
-    console?: {
-      level?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "off";
-      metrics?: boolean;
-      audit?: boolean;
-    };
-  };
-  fileWorkingDirectory?: string;
-  functionExternalModules?: boolean;
-  functionGlobalContext?: Record<string, unknown>;
-  nodeMessageBufferMaxLength?: number;
-  functionTimeout?: number;
-  externalModules?: {
-    autoInstall?: boolean;
-    autoInstallRetry?: number;
-    palette?: {
-      allowInstall?: boolean;
-      allowUpdate?: boolean;
-      allowUpload?: boolean;
-      allowList?: string[];
-      denyList?: string[];
-      allowUpdateList?: string[];
-      denyUpdateList?: string[];
-    };
-    modules?: {
-      allowInstall?: boolean;
-      allowList?: string[];
-      denyList?: string[];
-    };
-  };
-  execMaxBufferSize?: number;
-  debugMaxLength?: number;
-  debugUseColors?: boolean;
-  httpRequestTimeout?: number;
-  mqttReconnectTime?: number;
-  serialReconnectTime?: number;
-  socketReconnectTime?: number;
-  socketTimeout?: number;
-  tcpMsgQueueSize?: number;
-  inboundWebSocketTimeout?: number;
-  tlsConfigDisableLocalFiles?: boolean;
-  webSocketNodeVerifyClient?: (info: {
-    origin: string;
-    req: Http2ServerRequest;
-    secure: boolean;
-  }) => boolean;
-  apiMaxLength?: string;
-  [key: string]: unknown;
-}
-
 interface PackageJson {
   name: string;
   version: string;
@@ -362,7 +168,6 @@ export {
   LoggerOptions,
   NodeRedLauncherOptions,
   NodeRedPluginOptions,
-  NodeRedRuntimeSettings,
   PackageJson,
   ServerBuildOptions,
   ServerPluginOptions,

package/src/vite/utils.ts

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import type { NodeRedRuntimeSettings, PackageJson } from "./types";
+import type { PackageJson } from "./types";
 
 function cleanDir(dir: string) {
   if (fs.existsSync(dir)) {
@@ -69,35 +69,4 @@ function mergeOptions<T extends Record<string, unknown>>(
   return result;
 }
 
-/**
- * Define Node-RED runtime settings with full type support.
- *
- * Note: All paths should be absolute. Use `import.meta.dirname` or `__dirname` to resolve relative paths.
- *
- * @example
- * ```typescript
- * import { defineRuntimeSettings } from "./vite/utils";
- * import path from "path";
- *
- * const __dirname = import.meta.dirname;
- *
- * export default defineRuntimeSettings({
- *   userDir: path.resolve(__dirname, ".node-red"),
- *   flowFile: "flows.json",
- *   httpStatic: path.resolve(__dirname, "public"),
- * });
- * ```
- */
-function defineRuntimeSettings(
-  settings: NodeRedRuntimeSettings,
-): NodeRedRuntimeSettings {
-  return settings;
-}
-
-export {
-  cleanDir,
-  copyFiles,
-  defineRuntimeSettings,
-  getPackageName,
-  mergeOptions,
-};
+export { cleanDir, copyFiles, getPackageName, mergeOptions };

package/src/core/client/api/index.ts

@@ -1,17 +0,0 @@
-import { type NodeDefinitionApiResponse } from "../../server/types";
-
-async function fetchNodeDefinition(
-  type: string,
-): Promise<NodeDefinitionApiResponse> {
-  const response = await fetch(`/nrg/nodes/${type}`);
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch node definition for "${type}": ${response.status}`,
-    );
-  }
-
-  return response.json() as Promise<NodeDefinitionApiResponse>;
-}
-
-export { fetchNodeDefinition };

package/src/core/client/virtual.d.ts

@@ -1,5 +0,0 @@
-declare module "virtual:nrg/node-definitions" {
-  import type { NodeDefinitionApiResponse } from "../server/types";
-  const definitions: Record<string, NodeDefinitionApiResponse>;
-  export default definitions;
-}