@bonsae/nrg 0.4.0 → 0.5.1

package/src/core/client/components/node-red-typed-input.vue

@@ -1,5 +1,13 @@
 <template>
   <div style="display: flex; flex-direction: column; width: 100%">
+    <slot name="label">
+      <NodeRedInputLabel
+        v-if="label"
+        :label="label"
+        :icon="icon"
+        :required="required"
+      />
+    </slot>
     <input
       ref="typedInput"
       type="text"
@@ -14,9 +22,11 @@
 
 <script lang="ts">
 import { defineComponent } from "vue";
+import NodeRedInputLabel from "./node-red-input-label.vue";
 import { TYPED_INPUT_TYPES } from "../../constants";
 
 export default defineComponent({
+  components: { NodeRedInputLabel },
   props: {
     value: {
       type: Object,
@@ -43,6 +53,18 @@ export default defineComponent({
       type: Array,
       default: () => TYPED_INPUT_TYPES,
     },
+    label: {
+      type: String,
+      default: "",
+    },
+    icon: {
+      type: String,
+      default: "",
+    },
+    required: {
+      type: Boolean,
+      default: false,
+    },
     error: {
       type: String,
       default: "",

package/src/core/client/index.ts

@@ -8,6 +8,7 @@ import NodeRedTypedInput from "./components/node-red-typed-input.vue";
 import NodeRedConfigInput from "./components/node-red-config-input.vue";
 import NodeRedSelectInput from "./components/node-red-select-input.vue";
 import NodeRedEditorInput from "./components/node-red-editor-input.vue";
+import NodeRedInputLabel from "./components/node-red-input-label.vue";
 import NodeRedJsonSchemaForm from "./components/node-red-json-schema-form.vue";
 
 const _schemas: Record<string, any> = {};
@@ -163,6 +164,7 @@ function createNodeRedVueApp(
     features,
   });
 
+  app.component("NodeRedInputLabel", NodeRedInputLabel);
   app.component("NodeRedInput", NodeRedInput);
   app.component("NodeRedTypedInput", NodeRedTypedInput);
   app.component("NodeRedConfigInput", NodeRedConfigInput);

package/src/core/server/schemas/type.ts

@@ -15,40 +15,26 @@ function NodeRef<T extends new (...args: any[]) => any>(
   options?: SchemaOptions,
 ): TNodeRef<InstanceType<T>> {
   return {
-    ...SchemaType.String({
+    ...BaseType.String({
       description:
         options?.description || `Reference to ${(nodeClass as any).type}`,
       format: "node-id",
     }),
-    "node-type": (nodeClass as any).type,
+    "x-nrg-node-type": (nodeClass as any).type,
     ...options,
     [Kind]: "NodeRef",
   } as unknown as TNodeRef<InstanceType<T>>;
 }
 
-function TypedInput(
-  options?: SchemaOptions & { types?: string[] },
-): TTypedInput {
-  const { types, ...rest } = options ?? {};
+function TypedInput(options?: SchemaOptions): TTypedInput {
   return {
     ...TypedInputSchema,
-    ...rest,
-    ...(types ? { "x-typed-types": types } : {}),
+    ...options,
     [Kind]: "TypedInput",
   } as unknown as TTypedInput;
 }
 
-const _OriginalString = BaseType.String.bind(BaseType);
-function StringWithLang(options?: SchemaOptions & { lang?: string }) {
-  const { lang, ...rest } = options ?? {};
-  return _OriginalString({
-    ...rest,
-    ...(lang ? { "x-editor-language": lang } : {}),
-  });
-}
-
 const SchemaType = Object.assign({}, BaseType, {
-  String: StringWithLang,
   NodeRef,
   TypedInput,
 });
@@ -62,7 +48,7 @@ function markNonValidatable<T extends TSchema>(schema: T): T {
 
   // NOTE: if the type is non serializable, like Functions or Constructor, we must skip validation and avoid applying defaults
   if (hasInvalidType) {
-    (schema as any)["skip-validation"] = true;
+    (schema as any)["x-nrg-skip-validation"] = true;
 
     if ((schema as any).default !== undefined) {
       (schema as any)._default = (schema as any).default;

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

@@ -11,7 +11,7 @@ interface TNodeRef<T = any> extends TSchema {
   [Kind]: "NodeRef";
   static: T;
   type: "string";
-  "node-type"?: string;
+  "x-nrg-node-type"?: string;
 }
 
 type ResolveNodeRefs<T> =
@@ -37,9 +37,17 @@ interface TTypedInput extends TSchema {
   };
 }
 
+interface NrgFormOptions {
+  icon?: string;
+  typedInputTypes?: string[];
+  editorLanguage?: string;
+}
+
 declare module "@sinclair/typebox" {
   interface SchemaOptions {
     exportable?: boolean;
+    "x-nrg-node-type"?: string;
+    "x-nrg-form"?: NrgFormOptions;
   }
 }
 

package/src/core/server/utils.ts

@@ -1,7 +1,7 @@
 import type { TObject, SchemaOptions } from "@sinclair/typebox";
 
 interface NodeSchemaOptions extends SchemaOptions {
-  "node-type"?: string;
+  "x-nrg-node-type"?: string;
   default?: any;
   format?: string;
 }
@@ -25,7 +25,7 @@ function getDefaultsFromSchema(
       required: false,
       value: property.default ?? undefined,
       // NOTE: I'm using a custom json schema keyword to determine the node type
-      type: property["node-type"],
+      type: property["x-nrg-node-type"],
     };
   }
 

package/src/core/server/validator.ts

@@ -5,9 +5,13 @@ class NodeRedValidator extends Validator {
   constructor(RED: RED) {
     super({
       customKeywords: [
-        { keyword: "skip-validation", schemaType: "boolean", valid: true },
         {
-          keyword: "node-type",
+          keyword: "x-nrg-skip-validation",
+          schemaType: "boolean",
+          valid: true,
+        },
+        {
+          keyword: "x-nrg-node-type",
           type: "string",
           validate: (schemaValue: string, dataValue: string) => {
             if (!dataValue) return true;

package/src/vite/client/build.ts

@@ -39,13 +39,15 @@ async function build(
   if (fs.existsSync(physicalEntryPath)) {
     entryPath = physicalEntryPath;
   } else {
-    // No physical entry — create a minimal empty file that the inliner
-    // will prepend auto-registration code into.
-    if (!fs.existsSync(path.dirname(physicalEntryPath))) {
-      fs.mkdirSync(path.dirname(physicalEntryPath), { recursive: true });
+    // No physical entry — create a minimal empty file in the cache directory
+    // so the file watcher on srcDir is not triggered by the create/delete cycle.
+    const cacheDir = path.resolve("node_modules", ".nrg", "client");
+    const cachedEntryPath = path.resolve(cacheDir, entry);
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
     }
-    fs.writeFileSync(physicalEntryPath, "// auto-generated entry\n");
-    entryPath = physicalEntryPath;
+    fs.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    entryPath = cachedEntryPath;
     generatedEntry = true;
   }
 
@@ -215,7 +217,7 @@ async function build(
     throw new BuildError("client", error as Error);
   } finally {
     if (generatedEntry) {
-      fs.unlinkSync(physicalEntryPath);
+      fs.unlinkSync(entryPath);
     }
   }
 }

package/src/vite/client/plugins/node-definitions-inliner.ts

@@ -28,7 +28,7 @@ function getDefaultsFromSchema(
     result[key] = {
       required: false,
       value: prop.default ?? undefined,
-      type: prop["node-type"],
+      type: prop["x-nrg-node-type"],
     };
   }
   return result;

package/src/vite/plugins/build.ts

@@ -37,10 +37,22 @@ function buildPlugin(options: BuildPluginOptions): Plugin {
         const tsconfigsToCheck = [serverTsconfig, clientTsconfig].filter((p) =>
           fs.existsSync(p),
         );
-        for (const tsconfig of tsconfigsToCheck) {
-          execSync(`npx tsc -p ${tsconfig} --noEmit`, { stdio: "inherit" });
+        try {
+          for (const tsconfig of tsconfigsToCheck) {
+            execSync(`npx tsc -p ${tsconfig} --noEmit`, {
+              stdio: ["inherit", "pipe", "pipe"],
+              encoding: "utf-8",
+            });
+          }
+          logger.stopSpinner("Type checked");
+        } catch (e: any) {
+          logger.stopSpinner("Type check failed");
+          const output = (e.stdout || "") + (e.stderr || "");
+          if (output) {
+            console.error(output);
+          }
+          throw new BuildError("type-check", e);
         }
-        logger.stopSpinner("Type checked");
 
         logger.startSpinner("Cleaning");
         cleanDir(buildContext.outDir);