@bonsae/nrg 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",

package/server/index.cjs

@@ -236,6 +236,40 @@ var NrgError = class _NrgError extends Error {
   }
 };
 
+// src/core/server/typed-input.ts
+var TypedInput = class {
+  constructor(RED, node, input) {
+    this.RED = RED;
+    this.node = node;
+    this.input = input;
+  }
+  resolvers = {
+    // NOTE: NRG nodes are wrapped — surface the NRG instance, fall back to raw NodeRedNode
+    node: (raw) => raw?._node ?? raw
+  };
+  get type() {
+    return this.input.type;
+  }
+  get value() {
+    return this.input.value;
+  }
+  resolve(msg) {
+    return new Promise((resolve, reject) => {
+      this.RED.util.evaluateNodeProperty(
+        this.input.value,
+        this.input.type,
+        this.node,
+        msg,
+        (err, raw) => {
+          if (err) return reject(err);
+          const post = this.resolvers[this.input.type];
+          resolve(post ? post(raw) : raw);
+        }
+      );
+    });
+  }
+};
+
 // src/core/server/nodes/utils.ts
 function setupContext(context, store) {
   return {
@@ -259,14 +293,16 @@ function setupContext(context, store) {
     )
   };
 }
-function setupConfigProxy(RED, config, schema) {
+function setupConfigProxy(opts) {
+  const { RED, node, config, schema } = opts;
   const SKIP_PROPS = /* @__PURE__ */ new Set(["id", "_id", "_users"]);
   const nodeRefProps = /* @__PURE__ */ new Set();
+  const typedInputProps = /* @__PURE__ */ new Set();
   if (schema?.properties) {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
-      if (propSchema?.["x-nrg-node-type"]) {
-        nodeRefProps.add(key);
-      }
+      const s = propSchema;
+      if (s?.["x-nrg-node-type"]) nodeRefProps.add(key);
+      if (s?.["x-nrg-typed-input"]) typedInputProps.add(key);
     }
   }
   const cache = /* @__PURE__ */ new WeakMap();
@@ -274,12 +310,9 @@ function setupConfigProxy(RED, config, schema) {
     const cached = cache.get(obj);
     if (cached) return cached;
     if (Array.isArray(obj)) {
-      const mapped = obj.map((item) => {
-        if (item && typeof item === "object") {
-          return createProxy(item);
-        }
-        return item;
-      });
+      const mapped = obj.map(
+        (item) => item && typeof item === "object" ? createProxy(item) : item
+      );
       cache.set(obj, mapped);
       return mapped;
     }
@@ -291,6 +324,14 @@ function setupConfigProxy(RED, config, schema) {
         if (typeof value === "string" && value.length > 0 && nodeRefProps.has(prop)) {
           return RED.nodes.getNode(value)?._node ?? value;
         }
+        if (typedInputProps.has(prop) && value && typeof value === "object" && "type" in value && "value" in value) {
+          let ref = cache.get(value);
+          if (!ref) {
+            ref = new TypedInput(RED, node, value);
+            cache.set(value, ref);
+          }
+          return ref;
+        }
         if (value && typeof value === "object") {
           return createProxy(value);
         }
@@ -385,11 +426,12 @@ var Node = class {
         );
       }
     }
-    this.config = setupConfigProxy(
+    this.config = setupConfigProxy({
       RED,
+      node,
       config,
-      constructor.configSchema
-    );
+      schema: constructor.configSchema
+    });
     if (constructor.credentialsSchema && credentials) {
       this.log("Validating credentials");
       const credResult = validator.validate(
@@ -432,28 +474,6 @@ var Node = class {
     clearInterval(interval);
     this.intervals.delete(interval);
   }
-  // NOTE: typing msg isnt necessary in this case
-  resolveTypedInput(typedInput, msg) {
-    return new Promise((resolve, reject) => {
-      this.RED.util.evaluateNodeProperty(
-        typedInput.value,
-        typedInput.type,
-        this.node,
-        msg,
-        (error, result) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-          if (typedInput.type === "node" && result) {
-            resolve(result._node ?? result);
-            return;
-          }
-          resolve(result);
-        }
-      );
-    });
-  }
   // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's closed again
   /** @internal */
   async _closed(removed) {
@@ -795,16 +815,17 @@ function NodeRef(nodeClass, options) {
     [import_typebox.Kind]: "NodeRef"
   };
 }
-function TypedInput(options) {
+function TypedInput2(options) {
   return {
     ...TypedInputSchema,
+    "x-nrg-typed-input": true,
     ...options,
     [import_typebox.Kind]: "TypedInput"
   };
 }
 var SchemaType = Object.assign({}, import_typebox.Type, {
   NodeRef,
-  TypedInput
+  TypedInput: TypedInput2
 });
 function markNonValidatable(schema) {
   const type = schema.type;

package/types/server.d.ts

@@ -1716,33 +1716,6 @@ declare const TYPED_INPUT_TYPES: readonly [
 	"node",
 	"cred"
 ];
-export interface TNodeRef<T = any> extends TSchema {
-	[Kind]: "NodeRef";
-	static: T;
-	type: "string";
-	"x-nrg-node-type"?: string;
-}
-export type ResolveNodeRefs<T> = T extends TNodeRef<infer N> ? N : T extends (...args: any[]) => any ? T : T extends Array<infer Item> ? ResolveNodeRefs<Item>[] : T extends object ? {
-	[K in keyof T]: ResolveNodeRefs<T[K]>;
-} : T;
-export type Infer<T extends TSchema> = ResolveNodeRefs<Static<T>>;
-export type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
-export interface TTypedInput extends TSchema {
-	[Kind]: "TypedInput";
-	static: {
-		value: string | number | boolean | null;
-		type: TypedInputType;
-	};
-}
-export interface NrgFormOptions {
-	icon?: string;
-	typedInputTypes?: string[];
-	editorLanguage?: string;
-	toggle?: boolean;
-}
-export interface Schema<T extends TProperties = TProperties> extends TObject<T> {
-	$id: string;
-}
 export interface NodeRedRuntimeSettings {
 	userDir?: string;
 	nodesDir?: string | string[];
@@ -2072,6 +2045,48 @@ export interface NodeRedContextStore {
 	set(key: string, value: any, store: string | undefined, callback: (err: Error | null) => void): void;
 	keys(store: string | undefined, callback: (err: Error | null, keys: string[]) => void): void;
 }
+declare class TypedInput<T = unknown> {
+	private readonly RED;
+	private readonly node;
+	private readonly input;
+	private readonly resolvers;
+	constructor(RED: RED, node: NodeRedNode, input: {
+		value: unknown;
+		type: TypedInputType;
+	});
+	get type(): TypedInputType;
+	get value(): unknown;
+	resolve(msg?: Record<string, any>): Promise<T>;
+}
+export interface TNodeRef<T = any> extends TSchema {
+	[Kind]: "NodeRef";
+	static: T;
+	type: "string";
+	"x-nrg-node-type"?: string;
+}
+export type ResolveNodeRefs<T> = T extends TypedInput<any> ? T : T extends (...args: any[]) => any ? T : T extends Array<infer Item> ? ResolveNodeRefs<Item>[] : T extends object ? {
+	[K in keyof T]: ResolveNodeRefs<T[K]>;
+} : T;
+export type Infer<T extends TSchema> = ResolveNodeRefs<Static<T>>;
+export type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
+export interface TTypedInput<T = unknown> extends TSchema {
+	[Kind]: "TypedInput";
+	static: TypedInput<T>;
+}
+export interface NrgFormOptions {
+	icon?: string;
+	typedInputTypes?: string[];
+	editorLanguage?: string;
+	toggle?: boolean;
+}
+export interface NrgSchemaOptions extends SchemaOptions {
+	exportable?: boolean;
+	"x-nrg-node-type"?: string;
+	"x-nrg-form"?: NrgFormOptions;
+}
+export interface Schema<T extends TProperties = TProperties> extends TObject<T> {
+	$id: string;
+}
 declare const NodeConfigSchema: TObject<{
 	id: TString;
 	type: TString;
@@ -2095,11 +2110,11 @@ declare const IONodeConfigSchema: TObject<{
 	name: TString;
 	z: TOptional<TString>;
 }>;
-declare function NodeRef<T extends new (...args: any[]) => any>(nodeClass: T, options?: SchemaOptions): TNodeRef<InstanceType<T>>;
-declare function TypedInput(options?: SchemaOptions): TTypedInput;
+declare function NodeRef<T extends new (...args: any[]) => any>(nodeClass: T, options?: NrgSchemaOptions): TNodeRef<InstanceType<T>>;
+declare function TypedInput$1<T = unknown>(options?: NrgSchemaOptions): TTypedInput<T>;
 export declare const SchemaType: JavaScriptTypeBuilder & {
 	NodeRef: typeof NodeRef;
-	TypedInput: typeof TypedInput;
+	TypedInput: typeof TypedInput$1;
 };
 export declare function defineSchema<T extends TProperties>(properties: T, options: ObjectOptions & {
 	$id: string;
@@ -2112,7 +2127,6 @@ export interface NodeContextStore {
 }
 export type NodeConfig<TConfig = any> = TConfig & Static<typeof NodeConfigSchema>;
 export type NodeCredentials<TCredentials = any> = TCredentials;
-type TypedInput$1 = Static<TTypedInput>;
 export type IONodeContextScope = NodeContextScope;
 export type IONodeConfig<TConfig = any> = NodeConfig<TConfig> & Static<typeof IONodeConfigSchema> & {
 	validateInput?: boolean;
@@ -2257,7 +2271,6 @@ declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any
 	clearInterval(interval: NodeJS.Timeout): void;
 	created?(): void | Promise<void>;
 	closed?(removed?: boolean): void | Promise<void>;
-	resolveTypedInput<T = any>(typedInput: TypedInput$1, msg?: Record<string, any>): Promise<T>;
 	on(event: string, callback: (...args: any[]) => void): void;
 	log(msg: any): void;
 	warn(message: string): void;