@bonsae/nrg 0.6.0 → 0.6.2

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

@@ -1,275 +0,0 @@
-import type { Plugin } from "vite";
-import { createRequire } from "module";
-import { pathToFileURL } from "url";
-import path from "path";
-import fs from "fs";
-import mime from "mime-types";
-
-const VIRTUAL_ID = "virtual:nrg/node-definitions";
-const RESOLVED_ID = "\0" + VIRTUAL_ID;
-
-const SKIP_DEFAULTS = new Set(["x", "y", "z", "g", "wires", "type", "id"]);
-
-function getDefaultsFromSchema(
-  schema: any,
-):
-  | Record<string, { type?: string; required: boolean; value: any }>
-  | undefined {
-  if (!schema?.properties) return undefined;
-  const result: Record<
-    string,
-    { type?: string; required: boolean; value: any }
-  > = {};
-  for (const [key, prop] of Object.entries(schema.properties) as [
-    string,
-    any,
-  ][]) {
-    if (SKIP_DEFAULTS.has(key)) continue;
-    result[key] = {
-      required: false,
-      value: prop.default ?? undefined,
-      type: prop["x-nrg-node-type"],
-    };
-  }
-  return result;
-}
-
-function getCredentialsFromSchema(
-  schema: any,
-): Record<string, { type: string; required: boolean; value: any }> | undefined {
-  if (!schema?.properties) return undefined;
-  const result: Record<
-    string,
-    { type: string; required: boolean; value: any }
-  > = {};
-  for (const [key, prop] of Object.entries(schema.properties) as [
-    string,
-    any,
-  ][]) {
-    result[key] = {
-      required: false,
-      type: prop.format === "password" ? "password" : "text",
-      value: prop.default ?? undefined,
-    };
-  }
-  return result;
-}
-
-function resolveIcon(iconsDir: string, type: string): string | undefined {
-  if (!fs.existsSync(iconsDir)) return undefined;
-  return fs.readdirSync(iconsDir).find((f) => {
-    if (path.basename(f, path.extname(f)) !== type) return false;
-    const mimeType = mime.lookup(f);
-    return mimeType !== false && mimeType.startsWith("image/");
-  });
-}
-
-function nodeDefinitionsInliner(
-  serverOutDir: string,
-  entryPath: string,
-  iconsDir?: string,
-  componentsDir?: string,
-  nodesDir?: string,
-  hasUserEntry: boolean = true,
-): Plugin {
-  let _nodeTypes: string[] = [];
-  let _definitions: Record<string, any> = {};
-  // Cache directory for generated files (inside node_modules, gitignored)
-  const cacheDir = path.resolve("node_modules", ".nrg", "client");
-
-  return {
-    name: "vite-plugin-node-red:client:node-definitions-inliner",
-    enforce: "pre",
-
-    // Load the server bundle in buildStart so _nodeTypes is populated
-    // before any load/transform hooks run.
-    async buildStart() {
-      _nodeTypes = [];
-      _definitions = {};
-
-      const esmEntryPath = path.resolve(serverOutDir, "index.mjs");
-      const cjsEntryPath = path.resolve(serverOutDir, "index.js");
-
-      let packageFn: any;
-      if (fs.existsSync(esmEntryPath)) {
-        const fileUrl = pathToFileURL(esmEntryPath).href + `?t=${Date.now()}`;
-        const mod = await import(fileUrl);
-        packageFn = mod?.default ?? mod;
-      } else if (fs.existsSync(cjsEntryPath)) {
-        const require = createRequire(import.meta.url);
-        delete require.cache[cjsEntryPath];
-        const rawMod = require(cjsEntryPath);
-        packageFn = rawMod?.default ?? rawMod;
-      }
-
-      const nodeClasses: any[] = packageFn?.nodes ?? [];
-
-      for (const NodeClass of nodeClasses) {
-        const type = NodeClass.type;
-        if (!type) continue;
-        _nodeTypes.push(type);
-        const configSchema = NodeClass.configSchema ?? null;
-        const credentialsSchema = NodeClass.credentialsSchema ?? null;
-        const inputSchema = NodeClass.inputSchema ?? null;
-        const outputsSchema = NodeClass.outputsSchema ?? null;
-
-        // Pre-compute defaults and credentials at build time
-        const defaults = getDefaultsFromSchema(configSchema);
-        if (defaults && inputSchema) {
-          defaults.validateInput = { required: false, value: false };
-        }
-        if (defaults && outputsSchema) {
-          defaults.validateOutput = { required: false, value: false };
-        }
-        const credentials = getCredentialsFromSchema(credentialsSchema);
-
-        _definitions[type] = {
-          type,
-          category: NodeClass.category,
-          configSchema,
-          credentialsSchema,
-          settingsSchema: NodeClass.settingsSchema ?? null,
-          defaults: defaults ?? undefined,
-          credentials: credentials ?? undefined,
-          align: NodeClass.align,
-          color: NodeClass.color,
-          icon: iconsDir ? resolveIcon(iconsDir, type) : undefined,
-          labelStyle: NodeClass.labelStyle,
-          paletteLabel: NodeClass.paletteLabel,
-          inputs: NodeClass.inputs,
-          outputs: NodeClass.outputs,
-          inputLabels: NodeClass.inputLabels,
-          outputLabels: NodeClass.outputLabels,
-          inputSchema,
-          outputsSchema,
-        };
-      }
-
-      // When no user entry, generate node definition files in cache
-      // so they appear as separate files in browser devtools.
-      if (!hasUserEntry) {
-        const nodesCache = path.resolve(cacheDir, "nodes");
-        if (fs.existsSync(nodesCache)) {
-          fs.rmSync(nodesCache, { recursive: true });
-        }
-        fs.mkdirSync(nodesCache, { recursive: true });
-
-        for (const type of _nodeTypes) {
-          // Skip if user has a physical node definition file
-          const userTsPath = nodesDir
-            ? path.resolve(nodesDir, `${type}.ts`)
-            : null;
-          if (userTsPath && fs.existsSync(userTsPath)) continue;
-
-          const content = [
-            `// auto-generated by nrg`,
-            `import { defineNode } from "@bonsae/nrg/client";`,
-            ``,
-            `export default defineNode({`,
-            `  type: ${JSON.stringify(type)},`,
-            `});`,
-            ``,
-          ].join("\n");
-          fs.writeFileSync(path.resolve(nodesCache, `${type}.ts`), content);
-        }
-
-        // Also write the entry file to cache
-        const entryContent = generateEntryCode("");
-        fs.mkdirSync(path.dirname(path.resolve(cacheDir, "index.ts")), {
-          recursive: true,
-        });
-        fs.writeFileSync(path.resolve(cacheDir, "index.ts"), entryContent);
-      }
-    },
-
-    resolveId(id) {
-      if (id === VIRTUAL_ID) return RESOLVED_ID;
-    },
-
-    load(id) {
-      if (id === RESOLVED_ID)
-        return `export default ${JSON.stringify(_definitions)};`;
-
-      // For auto-generated entries, return the generated code directly
-      // so the browser devtools shows the actual source instead of the
-      // placeholder comment on disk.
-      if (!hasUserEntry && id === entryPath) {
-        return generateEntryCode("");
-      }
-    },
-
-    transform(code, id) {
-      if (id !== entryPath) return;
-      // When the user provides their own entry, prepend the generated
-      // code to their source. For auto-generated entries, the load hook
-      // already returned the full code.
-      if (!hasUserEntry) return;
-
-      return { code: generateEntryCode(code), map: null };
-    },
-  };
-
-  function generateEntryCode(userCode: string): string {
-    const nrgImports = new Set<string>(["__setSchemas"]);
-    const lines = [`import __nrgSchemas from "${VIRTUAL_ID}";`];
-    const postLines: string[] = [`__setSchemas(__nrgSchemas);`];
-
-    // Auto-detect form components by convention: {componentsDir}/{type}.vue
-    if (componentsDir && fs.existsSync(componentsDir)) {
-      const formImports: string[] = [];
-      const formEntries: string[] = [];
-
-      for (const type of _nodeTypes) {
-        const componentPath = path.resolve(componentsDir, `${type}.vue`);
-        if (fs.existsSync(componentPath)) {
-          const varName = `__nrgForm_${type.replace(/-/g, "_")}`;
-          formImports.push(
-            `import ${varName} from ${JSON.stringify(componentPath)};`,
-          );
-          formEntries.push(`${JSON.stringify(type)}: ${varName}`);
-        }
-      }
-
-      if (formImports.length > 0) {
-        lines.push(...formImports);
-        nrgImports.add("__setForms");
-        postLines.push(`__setForms({ ${formEntries.join(", ")} });`);
-      }
-    }
-
-    // Auto-register only when no user entry was provided.
-    if (!hasUserEntry) {
-      const nodesCache = path.resolve(cacheDir, "nodes");
-      const defVarNames: string[] = [];
-
-      for (const type of _nodeTypes) {
-        const varName = `__nrgNodeDef_${type.replace(/-/g, "_")}`;
-        // Use physical file if user has one, otherwise use cached generated file
-        const userTsPath = nodesDir
-          ? path.resolve(nodesDir, `${type}.ts`)
-          : null;
-        const tsPath =
-          userTsPath && fs.existsSync(userTsPath)
-            ? userTsPath
-            : path.resolve(nodesCache, `${type}.ts`);
-        lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
-        defVarNames.push(varName);
-      }
-
-      if (defVarNames.length > 0) {
-        nrgImports.add("registerTypes");
-        postLines.push(`registerTypes([${defVarNames.join(", ")}]);`);
-      }
-    }
-
-    // Build the @bonsae/nrg/client import line
-    const importLine = `import { ${[...nrgImports].join(", ")} } from "@bonsae/nrg/client";`;
-    lines.splice(1, 0, importLine);
-
-    lines.push(...postLines);
-    lines.push("");
-    return lines.join("\n") + userCode;
-  }
-}
-
-export { nodeDefinitionsInliner };

package/src/vite/client/plugins/static-copy.ts

@@ -1,43 +0,0 @@
-import type { Plugin } from "vite";
-import fs from "fs";
-import path from "path";
-
-function staticCopy(options: {
-  targets: { src: string; dest: string }[];
-}): Plugin {
-  const { targets } = options;
-
-  return {
-    name: "vite-plugin-node-red:client:static-copy",
-    apply: "build",
-    enforce: "post",
-
-    closeBundle() {
-      for (const { src, dest } of targets) {
-        if (!fs.existsSync(src)) continue;
-
-        fs.mkdirSync(dest, { recursive: true });
-
-        const stat = fs.statSync(src);
-        if (stat.isDirectory()) {
-          const files = fs.readdirSync(src);
-          for (const file of files) {
-            const srcFile = path.join(src, file);
-            const destFile = path.join(dest, file);
-            const fileStat = fs.statSync(srcFile);
-
-            if (fileStat.isDirectory()) {
-              fs.cpSync(srcFile, destFile, { recursive: true });
-            } else {
-              fs.copyFileSync(srcFile, destFile);
-            }
-          }
-        } else {
-          fs.copyFileSync(src, dest);
-        }
-      }
-    },
-  };
-}
-
-export { staticCopy };

package/src/vite/defaults.ts

@@ -1,77 +0,0 @@
-import type {
-  CopyTarget,
-  ClientBuildOptions,
-  NodeRedLauncherOptions,
-  ServerBuildOptions,
-} from "./types";
-
-const DEFAULT_OUTPUT_DIR = "./dist";
-
-const DEFAULT_CLIENT_BUILD_OPTIONS: ClientBuildOptions = {
-  srcDir: "./src/client",
-  entry: "index.ts",
-  nodesSubdir: "nodes",
-  name: "NodeRedNodes",
-  format: "es",
-  licensePath: "./LICENSE",
-  external: ["jquery", "node-red", "vue", "@bonsae/nrg/client"],
-  globals: {
-    jquery: "$",
-    "node-red": "RED",
-    vue: "Vue",
-  },
-  locales: {
-    docsDir: "./src/locales/docs",
-    labelsDir: "./src/locales/labels",
-    languages: [
-      "en-US",
-      "de",
-      "es-ES",
-      "fr",
-      "ko",
-      "pt-BR",
-      "ru",
-      "ja",
-      "zh-CN",
-      "zh-TW",
-    ],
-  },
-  staticDirs: {
-    icons: "./src/icons",
-    public: "./src/client/public",
-  },
-};
-
-const DEFAULT_SERVER_BUILD_OPTIONS: ServerBuildOptions = {
-  srcDir: "./src/server",
-  entry: "index.ts",
-  format: "esm",
-  external: [],
-  bundled: [],
-  types: true,
-  nodeTarget: "node22",
-};
-
-const DEFAULT_NODE_RED_LAUNCHER_OPTIONS: NodeRedLauncherOptions = {
-  runtime: {
-    port: 1880,
-    settingsFilepath: "./node-red.settings.ts",
-    version: "latest",
-  },
-  restartDelay: 1000,
-  args: [],
-};
-
-const DEFAULT_EXTRA_FILES_COPY_TARGETS: CopyTarget[] = [
-  { src: "./LICENSE", dest: "LICENSE" },
-  { src: "./README.md", dest: "README.md" },
-  { src: "./src/examples", dest: "examples" },
-];
-
-export {
-  DEFAULT_CLIENT_BUILD_OPTIONS,
-  DEFAULT_SERVER_BUILD_OPTIONS,
-  DEFAULT_NODE_RED_LAUNCHER_OPTIONS,
-  DEFAULT_EXTRA_FILES_COPY_TARGETS,
-  DEFAULT_OUTPUT_DIR,
-};

package/src/vite/errors.ts

@@ -1,37 +0,0 @@
-class PluginError extends Error {
-  constructor(
-    message: string,
-    public readonly code: string,
-    public readonly cause?: Error,
-  ) {
-    super(message);
-    this.name = "PluginError";
-  }
-}
-
-class NodeRedStartError extends PluginError {
-  constructor(cause?: Error) {
-    super("Failed to start Node-RED", "NODE_RED_START_FAILED", cause);
-    this.name = "NodeRedStartError";
-  }
-}
-
-class BuildError extends PluginError {
-  constructor(phase: "server" | "client", cause?: Error) {
-    super(
-      `Failed to build ${phase}`,
-      `BUILD_${phase.toUpperCase()}_FAILED`,
-      cause,
-    );
-    this.name = "BuildError";
-  }
-}
-
-class ConfigError extends PluginError {
-  constructor(message: string) {
-    super(message, "CONFIG_INVALID");
-    this.name = "ConfigError";
-  }
-}
-
-export { PluginError, NodeRedStartError, BuildError, ConfigError };

package/src/vite/index.ts

@@ -1,2 +0,0 @@
-export { nodeRed } from "./plugin";
-export type { NodeRedPluginOptions } from "./types";

package/src/vite/logger.ts

@@ -1,94 +0,0 @@
-import * as clackLogger from "@clack/prompts";
-import type { LoggerOptions } from "./types";
-
-const color = {
-  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
-  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
-};
-
-export class Logger {
-  private readonly name: string;
-  private readonly prefix?: string;
-  private readonly spinner = clackLogger.spinner();
-
-  constructor(options: LoggerOptions) {
-    this.name = options.name;
-    this.prefix = options.prefix;
-  }
-
-  private format(message: string): string {
-    return this.prefix ? `[${this.prefix}] ${message}` : message;
-  }
-
-  intro(message?: string): void {
-    clackLogger.intro(message ?? this.name);
-  }
-
-  outro(message: string): void {
-    clackLogger.outro(this.format(message));
-  }
-
-  step(message: string): void {
-    clackLogger.log.step(this.format(message));
-  }
-
-  success(message: string): void {
-    clackLogger.log.success(this.format(message));
-  }
-
-  warn(message: string): void {
-    clackLogger.log.warn(this.format(message));
-  }
-
-  error(message: string, cause?: Error): void {
-    clackLogger.log.error(this.format(message));
-    if (cause) {
-      console.error(cause);
-    }
-  }
-
-  info(message: string): void {
-    clackLogger.log.info(this.format(message));
-  }
-
-  message(message: string): void {
-    clackLogger.log.message(this.format(message));
-  }
-
-  raw(message: string): void {
-    const prefix = this.prefix ? color.dim(`[${this.prefix}]`) : "";
-    console.log(`│  ${prefix} ${message}`);
-  }
-
-  startGroup(title?: string): void {
-    if (title) {
-      console.log(`│`);
-      console.log(`├─ ${color.cyan(title)}`);
-    }
-    console.log(`│`);
-  }
-
-  endGroup(message?: string): void {
-    console.log(`│`);
-    console.log(`└─ ${message ?? "Done"}`);
-    console.log();
-  }
-
-  startSpinner(message: string): void {
-    this.spinner.start(this.format(message));
-  }
-
-  stopSpinner(message: string): void {
-    this.spinner.stop(this.format(message));
-  }
-
-  child(prefix: string): Logger {
-    const newPrefix = this.prefix ? `${this.prefix}:${prefix}` : prefix;
-    return new Logger({ name: this.name, prefix: newPrefix });
-  }
-}
-
-// NOTE: global logger is still used by other vite messages
-const logger = new Logger({ name: "vite-plugin-node-red" });
-
-export { createLogger, logger };