@bonsae/nrg 0.6.0 → 0.6.2

package/src/vite/plugins/server.ts

@@ -1,267 +0,0 @@
-import type { Plugin, FSWatcher, ViteDevServer } from "vite";
-import chokidar from "chokidar";
-import path from "path";
-const color = {
-  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
-  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
-  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
-  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
-};
-import type { ServerPluginOptions } from "../types";
-import { debounce } from "../async-utils";
-import { BuildError, NodeRedStartError } from "../errors";
-import { logger } from "../logger";
-import { cleanDir, copyFiles } from "../utils";
-import { build as buildServer } from "../server";
-import { build as buildClient } from "../client";
-
-function serverPlugin(options: ServerPluginOptions): Plugin {
-  const {
-    nodeRedLauncher,
-    serverBuildOptions,
-    clientBuildOptions,
-    extraFilesCopyTargets,
-    buildContext,
-  } = options;
-
-  let nodeRedPort: number;
-  let initialStartDone = false;
-  let isStarting = false;
-  let isShuttingDown = false;
-  let shutdownStartTime = 0;
-  let pendingStart = false;
-  let server: ViteDevServer;
-  let watcher: FSWatcher | null = null;
-
-  const build = async (clean: boolean = false) => {
-    if (clean) {
-      logger.startSpinner("Cleaning");
-      cleanDir(buildContext.outDir);
-      logger.stopSpinner("Cleaned");
-    }
-
-    logger.startSpinner("Building");
-    await buildServer(serverBuildOptions, buildContext);
-    await buildClient(clientBuildOptions, buildContext);
-    logger.stopSpinner("Built");
-
-    if (extraFilesCopyTargets.length) {
-      logger.startSpinner("Copying extra files");
-      copyFiles(extraFilesCopyTargets, buildContext.outDir);
-      logger.stopSpinner("Copied extra files");
-    }
-  };
-
-  const start = async (clean: boolean = false) => {
-    if (isStarting) {
-      pendingStart = true;
-      return;
-    }
-
-    isStarting = true;
-    pendingStart = false;
-
-    try {
-      await nodeRedLauncher.stop();
-      await build(clean);
-
-      logger.startSpinner("Starting Node-RED");
-      nodeRedPort = await nodeRedLauncher.start();
-      logger.stopSpinner("Node-RED started");
-
-      const proxyConfig = server.config.server.proxy;
-      if (proxyConfig && typeof proxyConfig === "object") {
-        const rule = proxyConfig["^/.*"];
-        if (rule && typeof rule === "object") {
-          (rule as any).target = `http://127.0.0.1:${nodeRedPort}`;
-        }
-      }
-      logger.success("Ready");
-    } catch (error) {
-      if (error instanceof BuildError) {
-        logger.error(`Rebuild failed: ${error.message}`);
-      } else if (error instanceof NodeRedStartError) {
-        logger.error("Failed to restart Node-RED");
-      } else {
-        logger.error(`Unexpected error: ${(error as Error).message}`);
-      }
-
-      throw error;
-    } finally {
-      isStarting = false;
-
-      if (pendingStart) {
-        start(false);
-      }
-    }
-  };
-
-  const printServerUrls = (
-    vitePort: number,
-    nodeRedPorts: {
-      actual: number;
-      preferred: number;
-    },
-  ) => {
-    console.log();
-    console.log(
-      `  ${color.cyan("Vite")}      ${color.dim("➜")}  ${color.cyan(`http://127.0.0.1:${vitePort}/`)}`,
-    );
-    if (nodeRedPorts.actual != nodeRedPorts.preferred) {
-      console.log(
-        `  ${color.green("Node-RED")}  ${color.dim("➜")}  ${color.green(`http://127.0.0.1:${nodeRedPorts.actual}/`)} ${color.yellow(`(port ${nodeRedPorts.preferred} was in use)`)}`,
-      );
-    } else {
-      console.log(
-        `  ${color.green("Node-RED")}  ${color.dim("➜")}  ${color.green(`http://127.0.0.1:${nodeRedPorts.actual}/`)}`,
-      );
-    }
-    console.log();
-  };
-
-  return {
-    name: "vite-plugin-node-red:server",
-    apply: "serve",
-
-    config() {
-      return {
-        appType: "custom",
-        server: {
-          host: "127.0.0.1",
-          proxy: {
-            "^/.*": {
-              target: `http://127.0.0.1:${nodeRedLauncher.preferredPort}`,
-              changeOrigin: true,
-              ws: true,
-              configure: (proxy) => {
-                proxy.on("error", () => {
-                  if (nodeRedPort) {
-                    (proxy as any).options.target =
-                      `http://127.0.0.1:${nodeRedPort}`;
-                  }
-                });
-              },
-            },
-          },
-          watch: {
-            // NOTE: this is necessary to avoid default hmr in .html files. Watcher is configured manually
-            ignored: ["**/*"],
-          },
-        },
-        customLogger: {
-          ...console,
-          info: () => {},
-          warn: console.warn,
-          error: console.error,
-          warnOnce: () => {},
-          hasWarned: false,
-          clearScreen: () => {},
-          hasErrorLogged: () => false,
-        },
-      };
-    },
-
-    async configureServer(viteServer) {
-      server = viteServer;
-
-      logger.intro();
-      await start(true);
-      initialStartDone = true;
-
-      printServerUrls(server.config.server.port ?? 5173, {
-        actual: nodeRedPort,
-        preferred: nodeRedLauncher.preferredPort,
-      });
-
-      logger.startGroup("Node-RED");
-      nodeRedLauncher.flushLogs();
-
-      const serverSrcDir = path.resolve(
-        serverBuildOptions.srcDir ?? "./server",
-      );
-      const clientSrcDir = path.resolve(
-        clientBuildOptions.srcDir ?? "./client",
-      );
-      const localesDocsDir = path.resolve(
-        clientBuildOptions.locales?.docsDir ?? "./locales/docs",
-      );
-      const localesLabelsDir = path.resolve(
-        clientBuildOptions.locales?.labelsDir ?? "./locales/labels",
-      );
-      const iconsDir = path.resolve(
-        clientBuildOptions.staticDirs?.icons ??
-          path.join(path.dirname(clientSrcDir), "icons"),
-      );
-
-      const watchPaths = [
-        serverSrcDir,
-        clientSrcDir,
-        localesDocsDir,
-        localesLabelsDir,
-        iconsDir,
-      ];
-
-      watcher = chokidar.watch(watchPaths, {
-        ignoreInitial: true,
-        persistent: true,
-        ignored: ["**/node_modules/**", "**/dist/**", "**/.node-red/**"],
-      });
-
-      const debounceBeforeStart = debounce(
-        () => start(false),
-        nodeRedLauncher.restartDelay ?? 1000,
-      );
-
-      const handleFileChange = (file: string, event: string) => {
-        if (!initialStartDone) return;
-        logger.info(`${event}: ${path.relative(process.cwd(), file)}`);
-        debounceBeforeStart();
-      };
-
-      watcher.on("change", (file) => handleFileChange(file, "Changed"));
-      watcher.on("add", (file) => handleFileChange(file, "Added"));
-      watcher.on("unlink", (file) => handleFileChange(file, "Deleted"));
-
-      process.on("SIGINT", () => {
-        const now = Date.now();
-
-        // NOTE: enable force exit only if more than 1 second has passed since first Ctrl+C because multiple SIGINT are triggered at once
-        if (isShuttingDown && now - shutdownStartTime > 1000) {
-          const pid = nodeRedLauncher.pid;
-          if (pid) {
-            try {
-              treeKill(pid, "SIGKILL");
-            } catch {
-              /* empty */
-            }
-          }
-          logger.endGroup("Node-RED Stopped");
-          process.exit(1);
-        }
-
-        if (isShuttingDown) {
-          // NOTE: ignoring sequential SIGNINT when it is already shutting down
-          return;
-        }
-
-        isShuttingDown = true;
-        shutdownStartTime = now;
-
-        logger.warn("Shutting down gracefully... (Ctrl+C again to force)");
-
-        nodeRedLauncher
-          .stop(true)
-          .then(() => {
-            nodeRedLauncher.cleanup();
-            logger.endGroup("Node-RED Stopped");
-            process.exit(0);
-          })
-          .catch(() => {
-            process.exit(1);
-          });
-      });
-    },
-  };
-}
-
-export { serverPlugin };

package/src/vite/server/build.ts

@@ -1,124 +0,0 @@
-import type { InlineConfig } from "vite";
-import { build as viteBuild } from "vite";
-import fs from "fs";
-import path from "path";
-import { BuildError } from "../errors";
-import { logger } from "../logger";
-import type { ServerBuildOptions, BuildContext } from "../types";
-import {
-  packageJsonGenerator,
-  typeGenerator,
-  cjsWrapper,
-  esmWrapper,
-} from "./plugins";
-
-async function build(
-  serverOpts: ServerBuildOptions,
-  buildContext: BuildContext,
-): Promise<void> {
-  const {
-    srcDir = "./server",
-    entry = "index.ts",
-    format = "esm",
-    bundled = [],
-    types = true,
-    nodeTarget = "node22",
-    plugins: userPlugins = [],
-  } = serverOpts;
-
-  const entries = Array.isArray(entry) ? entry : [entry];
-  const resolvedSrcDir = path.resolve(srcDir);
-  const entryPoints = {};
-  for (const entry of entries) {
-    const entryFilePath = path.join(resolvedSrcDir, entry);
-    if (fs.existsSync(entryFilePath)) {
-      const fileName = entry.replace(/\.ts$/, "");
-      entryPoints[fileName] = entryFilePath;
-    }
-  }
-  if (Object.keys(entryPoints).length === 0) {
-    logger.warn("No server entry points found");
-    return;
-  }
-
-  const isEsm = format === "esm";
-
-  const plugins = [
-    packageJsonGenerator({
-      outDir: buildContext.outDir,
-      bundled,
-      types: types && !buildContext.isDev,
-      entryNames: Object.keys(entryPoints),
-      format,
-    }),
-    isEsm ? esmWrapper() : cjsWrapper(),
-    ...userPlugins,
-  ];
-
-  if (types && !buildContext.isDev) {
-    plugins.push(
-      ...typeGenerator({
-        srcDir: resolvedSrcDir,
-        outDir: buildContext.outDir,
-        entryFiles: Object.values(entryPoints),
-      }),
-    );
-  }
-
-  const config: InlineConfig = {
-    configFile: false,
-    logLevel: "warn",
-    plugins,
-    build: {
-      outDir: buildContext.outDir,
-      emptyOutDir: false,
-      sourcemap: buildContext.isDev ? "inline" : true,
-      minify: !buildContext.isDev,
-      lib: {
-        entry: entryPoints,
-        formats: [isEsm ? "es" : "cjs"],
-      },
-      rollupOptions: {
-        output: {
-          entryFileNames: isEsm ? "[name].mjs" : "[name].js",
-          exports: isEsm ? undefined : "auto",
-          preserveModules: false,
-        },
-      },
-    },
-    esbuild: {
-      platform: "node",
-      target: nodeTarget,
-      keepNames: true,
-    },
-  };
-
-  try {
-    await viteBuild(config);
-
-    // Generate CJS bridge so Node-RED can require() the ESM bundle
-    if (isEsm) {
-      const bridgeCode = `\
-'use strict';
-// CJS bridge — auto-generated by @bonsae/nrg/vite
-// Node-RED uses require() to load packages. This bridge delegates to the ESM bundle.
-module.exports = function (RED) {
-    (async () => {
-        const mod = await import("./index.mjs");
-        if (typeof mod.default !== 'function') {
-            throw new Error('ESM bundle must export a default function(RED)');
-        }
-        await mod.default(RED);
-    })().catch(function (err) {
-        RED.log.error('Failed to load ESM bundle: ' + err.message);
-    });
-};
-`;
-      fs.writeFileSync(path.join(buildContext.outDir, "index.js"), bridgeCode);
-    }
-  } catch (error) {
-    throw new BuildError("server", error as Error);
-  }
-}
-
-export { build };

package/src/vite/server/index.ts

@@ -1 +0,0 @@
-export { build } from "./build";

package/src/vite/server/plugins/index.ts

@@ -1,3 +0,0 @@
-export { typeGenerator } from "./type-generator";
-export { cjsWrapper, esmWrapper } from "./output-wrapper";
-export { packageJsonGenerator } from "./package-json-generator";

package/src/vite/server/plugins/output-wrapper.ts

@@ -1,109 +0,0 @@
-import type { Plugin } from "vite";
-
-/**
- * Appends a CJS footer so Node-RED can load the package.
- *
- * esbuild CJS output for `export default value` can take two forms:
- *   (a) module.exports = value          (no __esModule flag)
- *   (b) exports.__esModule=true; exports.default = value
- * Both are normalised into `_exp` before branching:
- *
- *   - Declarative manifest { nodes }: calls registerTypes(nodes)
- *   - Callable function with .nodes:  attaches class properties
- *
- * Must be added to the server build in both dev and production modes.
- */
-function cjsWrapper(): Plugin {
-  return {
-    name: "vite-plugin-node-red:server:cjs-wrapper",
-    renderChunk(code, chunk, outputOptions) {
-      if (!chunk.isEntry || outputOptions.format !== "cjs") return null;
-      const footer =
-        `(function(){` +
-        `var _exp=module.exports&&module.exports.__esModule?module.exports.default:module.exports;` +
-        `if(_exp&&typeof _exp==="object"&&Array.isArray(_exp.nodes)){` +
-        `var _nrg=require("@bonsae/nrg/server");` +
-        `module.exports=_nrg.registerTypes(_exp.nodes);` +
-        `}` +
-        `else if(typeof _exp==="function"&&Array.isArray(_exp.nodes)){` +
-        `module.exports=_exp;` +
-        `_exp.nodes.forEach(function(cls){` +
-        `if(cls&&cls.type){` +
-        `_exp[cls.type.replace(/(?:^|[-_])(\\w)/g,function(_,c){return c.toUpperCase();})] = cls;` +
-        `}` +
-        `});` +
-        `}` +
-        `})();`;
-      return { code: `${code}\n${footer}`, map: null };
-    },
-  };
-}
-
-/**
- * Transforms the ESM bundle so its default export is the Node-RED package
- * function (result of registerTypes), not the raw { nodes: [...] } object.
- *
- * Also injects __dirname/__filename shims so user code that references them
- * works in ESM.
- *
- * The ESM bundle is loaded in two contexts:
- *   - At runtime: CJS bridge does `import("./index.mjs")` then `mod.default(RED)`
- *   - At build time: node-definitions-inliner does `import("./index.mjs")` then `mod.default.nodes`
- *
- * Both work because registerTypes() returns an async function with a `.nodes` property.
- *
- * Must be added to the server build in both dev and production modes.
- */
-function esmWrapper(): Plugin {
-  return {
-    name: "vite-plugin-node-red:server:esm-wrapper",
-    renderChunk(code, chunk, outputOptions) {
-      if (!chunk.isEntry || outputOptions.format !== "es") return null;
-
-      // Rollup ES output uses one of these forms:
-      //   export { something as default };
-      //   export default something;
-      // Replace with a wrapper that pipes through registerTypes.
-      const reNamed = /export\s*\{\s*(\w+)\s+as\s+default\s*\}\s*;?/;
-      const reDefault = /export\s+default\s+(\w+)\s*;?/;
-
-      let match = code.match(reNamed);
-      let varName: string | undefined;
-      let matchStr: string | undefined;
-
-      if (match) {
-        varName = match[1];
-        matchStr = match[0];
-      } else {
-        match = code.match(reDefault);
-        if (match) {
-          varName = match[1];
-          matchStr = match[0];
-        }
-      }
-
-      if (!varName || !matchStr) return null;
-
-      const header = [
-        `import { fileURLToPath as __nrgFileURLToPath } from "url";`,
-        `import { dirname as __nrgDirname } from "path";`,
-        `var __filename = __nrgFileURLToPath(import.meta.url);`,
-        `var __dirname = __nrgDirname(__filename);`,
-        `import { registerTypes as __nrgRegisterTypes } from "@bonsae/nrg/server";`,
-        ``,
-      ].join("\n");
-      const replacement = [
-        `var __nrgExport = ${varName};`,
-        `if (__nrgExport && typeof __nrgExport === "object" && Array.isArray(__nrgExport.nodes)) {`,
-        `  __nrgExport = __nrgRegisterTypes(__nrgExport.nodes);`,
-        `}`,
-        `export { __nrgExport as default };`,
-      ].join("\n");
-
-      const newCode = header + code.replace(matchStr, replacement);
-      return { code: newCode, map: null };
-    },
-  };
-}
-
-export { cjsWrapper, esmWrapper };

package/src/vite/server/plugins/package-json-generator.ts

@@ -1,203 +0,0 @@
-import type { Plugin } from "vite";
-import fs from "fs";
-import path from "path";
-import { builtinModules } from "node:module";
-import { logger } from "../../logger";
-import type { PackageJson } from "../../types";
-
-// NOTE: don't want to recreate it every time resolveId runs
-const nodeBuiltins = new Set([
-  ...builtinModules,
-  ...builtinModules.map((m) => `node:${m}`),
-]);
-
-function buildTypesPath(entryName: string): string {
-  return `./${entryName}.d.ts`;
-}
-
-function buildOutputPath(entryName: string): string {
-  return `./${entryName}.js`;
-}
-
-function buildExportKey(entryName: string): string {
-  return entryName === "index" ? "." : `./${entryName}`;
-}
-
-function buildEsmOutputPath(entryName: string): string {
-  return `./${entryName}.mjs`;
-}
-
-function generateExports(
-  entryNames: string[],
-  format: "cjs" | "esm" = "cjs",
-): Record<string, unknown> {
-  const exports: Record<string, unknown> = {};
-  for (const name of entryNames) {
-    const key = buildExportKey(name);
-    if (format === "esm") {
-      exports[key] = {
-        types: buildTypesPath(name),
-        import: buildEsmOutputPath(name),
-        require: buildOutputPath(name),
-        default: buildOutputPath(name),
-      };
-    } else {
-      exports[key] = {
-        types: buildTypesPath(name),
-        require: buildOutputPath(name),
-        default: buildOutputPath(name),
-      };
-    }
-  }
-  return exports;
-}
-
-function patchExportsWithTypes(
-  existingExports: Record<string, unknown>,
-  entryNames: string[],
-): Record<string, unknown> {
-  const patched: Record<string, unknown> = { ...existingExports };
-  for (const [key, value] of Object.entries(patched)) {
-    const entryName = key === "." ? "index" : key.replace(/^\.\//, "");
-    if (!entryNames.includes(entryName)) continue;
-    const typesPath = buildTypesPath(entryName);
-    if (typeof value === "string") {
-      patched[key] = { types: typesPath, require: value, default: value };
-    } else if (typeof value === "object" && value !== null) {
-      const condition = value as Record<string, unknown>;
-      if (!condition.types) {
-        patched[key] = { types: typesPath, ...condition };
-      }
-    }
-  }
-  return patched;
-}
-
-export function packageJsonGenerator(options: {
-  outDir: string;
-  bundled?: string[];
-  types?: boolean;
-  entryNames?: string[];
-  format?: "cjs" | "esm";
-}): Plugin {
-  const {
-    outDir,
-    bundled = [],
-    types = false,
-    entryNames = [],
-    format = "cjs",
-  } = options;
-
-  const trackedDependencies = new Set<string>();
-  return {
-    name: "vite-plugin-node-red:server:package-json-generator",
-    enforce: "pre",
-
-    buildStart() {
-      trackedDependencies.clear();
-    },
-
-    resolveId: {
-      order: "pre",
-      handler(source, importer) {
-        if (!importer || source.startsWith(".") || source.startsWith("/")) {
-          return null;
-        }
-
-        if (nodeBuiltins.has(source)) {
-          return { id: source, external: true };
-        }
-
-        const packageName = source.startsWith("@")
-          ? source.split("/").slice(0, 2).join("/")
-          : source.split("/")[0];
-
-        if (bundled.includes(packageName)) {
-          return null;
-        }
-
-        trackedDependencies.add(packageName);
-        return { id: source, external: true };
-      },
-    },
-
-    closeBundle() {
-      const rootPackageJsonPath = path.resolve("./package.json");
-      if (!fs.existsSync(rootPackageJsonPath)) {
-        logger.warn(`package.json not found: ${rootPackageJsonPath}`);
-        return;
-      }
-
-      const rootPackageJson = JSON.parse(
-        fs.readFileSync(rootPackageJsonPath, "utf-8"),
-      ) as PackageJson;
-
-      const sourceDeps: Record<string, string> =
-        rootPackageJson.dependencies ?? {};
-      const peerDeps: Record<string, string> =
-        rootPackageJson.peerDependencies ?? {};
-      let distDependencies: Record<string, string> | undefined = {};
-      for (const dep of trackedDependencies) {
-        if (peerDeps[dep]) {
-          continue;
-        }
-        if (sourceDeps[dep]) {
-          distDependencies[dep] = sourceDeps[dep];
-        } else {
-          const dependencyPackageJsonPath = path.resolve(
-            `./node_modules/${dep}/package.json`,
-          );
-          if (fs.existsSync(dependencyPackageJsonPath)) {
-            const dependencyPackageJson = JSON.parse(
-              fs.readFileSync(dependencyPackageJsonPath, "utf-8"),
-            ) as PackageJson;
-            distDependencies[dep] = `^${dependencyPackageJson.version}`;
-          }
-        }
-      }
-
-      if (Object.keys(distDependencies).length === 0) {
-        distDependencies = undefined;
-      }
-
-      const distPackageJson: PackageJson = {
-        ...rootPackageJson,
-        main: "index.js",
-        type: "commonjs",
-        devDependencies: undefined,
-        scripts: undefined,
-        dependencies: distDependencies,
-        keywords: [
-          ...new Set([...(rootPackageJson.keywords ?? []), "node-red"]),
-        ],
-        "node-red": {
-          nodes: { nodes: "index.js" },
-        },
-      };
-
-      if (types && entryNames.length > 0) {
-        const userExports = rootPackageJson.exports;
-        if (userExports && Object.keys(userExports).length > 0) {
-          distPackageJson.exports = patchExportsWithTypes(
-            userExports,
-            entryNames,
-          );
-        } else {
-          distPackageJson.exports = generateExports(entryNames, format);
-          if (entryNames.includes("index")) {
-            distPackageJson.types = "index.d.ts";
-          }
-        }
-      }
-
-      if (!fs.existsSync(outDir)) {
-        fs.mkdirSync(outDir, { recursive: true });
-      }
-
-      fs.writeFileSync(
-        path.join(outDir, "package.json"),
-        JSON.stringify(distPackageJson, null, 2),
-      );
-    },
-  };
-}