@bonsae/nrg 0.6.1 → 0.6.2

package/src/vite/client/build.ts

@@ -1,227 +0,0 @@
-import type { Plugin, InlineConfig } from "vite";
-import { build as viteBuild } from "vite";
-import vue from "@vitejs/plugin-vue";
-import fs from "fs";
-import path from "path";
-import { BuildError } from "../errors";
-import { logger } from "../logger";
-import type { ClientBuildOptions, BuildContext, CopyTarget } from "../types";
-import {
-  htmlGenerator,
-  localesGenerator,
-  minifier,
-  nodeDefinitionsInliner,
-  staticCopy,
-} from "./plugins";
-
-async function build(
-  clientBuildOptions: ClientBuildOptions,
-  buildContext: BuildContext,
-): Promise<void> {
-  const {
-    srcDir = "./client",
-    entry = "index.ts",
-    name = "NodeRedNodes",
-    format = "es",
-    licensePath = "./LICENSE",
-    locales,
-    staticDirs = {},
-    external = ["jquery", "node-red", "vue"],
-    globals = { jquery: "$", "node-red": "RED", vue: "Vue" },
-    manualChunks,
-    plugins: userPlugins = [],
-  } = clientBuildOptions;
-
-  const physicalEntryPath = path.resolve(srcDir, entry);
-  let entryPath: string;
-  let generatedEntry = false;
-
-  if (fs.existsSync(physicalEntryPath)) {
-    entryPath = physicalEntryPath;
-  } else {
-    // 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(cachedEntryPath, "// auto-generated entry\n");
-    entryPath = cachedEntryPath;
-    generatedEntry = true;
-  }
-
-  const iconsDir = path.resolve(
-    staticDirs.icons ?? path.join(path.dirname(path.resolve(srcDir)), "icons"),
-  );
-
-  const plugins: Plugin[] = [
-    vue(),
-    nodeDefinitionsInliner(
-      buildContext.outDir,
-      entryPath,
-      fs.existsSync(iconsDir) ? iconsDir : undefined,
-      path.resolve(srcDir, "components"),
-      path.resolve(srcDir, "nodes"),
-      !generatedEntry,
-    ),
-    ...userPlugins,
-  ];
-
-  plugins.push(
-    htmlGenerator({
-      packageName: buildContext.packageName,
-      licensePath: licensePath ? path.resolve(licensePath) : undefined,
-    }),
-  );
-
-  if (locales) {
-    const {
-      docsDir = "./locales/docs",
-      labelsDir = "./locales/labels",
-      languages = [
-        "en-US",
-        "de",
-        "es-ES",
-        "fr",
-        "ko",
-        "pt-BR",
-        "ru",
-        "ja",
-        "zh-CN",
-        "zh-TW",
-      ],
-    } = locales;
-
-    plugins.push(
-      localesGenerator({
-        outDir: path.join(buildContext.outDir, "locales"),
-        docsDir: path.resolve(docsDir),
-        labelsDir: path.resolve(labelsDir),
-        languages,
-      }),
-    );
-  }
-
-  const copyTargets: CopyTarget[] = [];
-
-  const publicDir = path.resolve(
-    staticDirs.public ?? path.join(srcDir, "public"),
-  );
-  if (fs.existsSync(publicDir)) {
-    copyTargets.push({
-      src: publicDir,
-      dest: path.join(buildContext.outDir, "resources"),
-    });
-  }
-
-  if (fs.existsSync(iconsDir)) {
-    copyTargets.push({
-      src: iconsDir,
-      dest: path.join(buildContext.outDir, "icons"),
-    });
-  }
-
-  if (copyTargets.length > 0) {
-    plugins.push(staticCopy({ targets: copyTargets }));
-  }
-
-  if (!buildContext.isDev && format === "es") {
-    plugins.push(minifier());
-  }
-
-  // Intercept '@bonsae/nrg/client' before Vite's resolver so it stays external.
-  // Rollup's string-array external check runs against the *resolved* file path,
-  // which wouldn't match the original specifier. 'vue' is handled by the
-  // external array directly (Vite keeps the bare specifier for known packages).
-  plugins.unshift({
-    name: "nrg-client-external",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === "@bonsae/nrg/client")
-        return { id: "@bonsae/nrg/client", external: true };
-    },
-  } as Plugin);
-
-  const defaultManualChunks = (id: string): string | undefined => {
-    if (!id.includes("node_modules")) return undefined;
-
-    const parts = id
-      .substring(id.lastIndexOf("node_modules/") + "node_modules/".length)
-      .split("/");
-
-    const pkgName = parts[0].startsWith("@")
-      ? `${parts[0]}/${parts[1]}`
-      : parts[0];
-
-    if (["jsonpointer", "es-toolkit"].includes(pkgName)) return "vendor-utils";
-    return "vendor";
-  };
-
-  const config: InlineConfig = {
-    configFile: false,
-    logLevel: "warn",
-    base: `/${path.join("resources", buildContext.packageName)}`,
-    publicDir: path.resolve(srcDir, "public"),
-    resolve: {
-      alias: {
-        "@": path.resolve(srcDir),
-      },
-    },
-    plugins,
-    css: {
-      devSourcemap: buildContext.isDev,
-    },
-    build: {
-      outDir: buildContext.outDir,
-      emptyOutDir: false,
-      sourcemap: buildContext.isDev ? "inline" : false,
-      minify: !buildContext.isDev && format !== "es",
-      copyPublicDir: false,
-      lib: {
-        entry: entryPath,
-        name,
-        fileName: "index",
-        formats: [format],
-      },
-      rollupOptions: {
-        external,
-        treeshake: false,
-        output: {
-          entryFileNames: path.join("resources", "index.[hash].js"),
-          chunkFileNames: path.join("resources", "vendor.[hash].js"),
-          assetFileNames: path.join("resources", "[name].[hash].[ext]"),
-          globals,
-          paths: {
-            vue: "/nrg/assets/vue.esm-browser.prod.js",
-            "@bonsae/nrg/client": "/nrg/assets/nrg-client.js",
-          },
-          sourcemapPathTransform: (relativeSourcePath) => {
-            return relativeSourcePath.replace(/\/client\//g, "/");
-          },
-          manualChunks: manualChunks ?? defaultManualChunks,
-        },
-      },
-    },
-    define: {
-      "process.env.NODE_ENV": JSON.stringify(
-        buildContext.isDev ? "development" : "production",
-      ),
-      "process.env": {},
-    },
-  };
-
-  try {
-    await viteBuild(config);
-  } catch (error) {
-    throw new BuildError("client", error as Error);
-  } finally {
-    if (generatedEntry) {
-      if (fs.existsSync(entryPath)) {
-        fs.unlinkSync(entryPath);
-      }
-    }
-  }
-}
-
-export { build };

package/src/vite/client/index.ts

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

package/src/vite/client/plugins/html-generator.ts

@@ -1,75 +0,0 @@
-import type { Plugin } from "vite";
-import mime from "mime-types";
-import fs from "fs";
-import path from "path";
-
-function htmlGenerator(options: {
-  packageName: string;
-  licensePath?: string;
-}): Plugin {
-  const { packageName, licensePath } = options;
-
-  return {
-    name: "vite-plugin-node-red:client:html-generator",
-    apply: "build",
-    enforce: "post",
-
-    generateBundle(_, bundle) {
-      const resourcesTags = Object.keys(bundle)
-        .map((fileName) => {
-          const asset = bundle[fileName];
-          const srcPath = path.join(
-            "resources",
-            packageName,
-            fileName.replace(/^resources\/?/, ""),
-          );
-
-          const content =
-            asset.type === "asset"
-              ? asset.source
-              : asset.type === "chunk"
-                ? asset.code
-                : null;
-
-          if (typeof content !== "string" && !(content instanceof Uint8Array))
-            return null;
-
-          const mimeType = mime.lookup(fileName);
-
-          switch (mimeType) {
-            case "application/javascript":
-            case "text/javascript":
-              return `<script type="module" src="${srcPath}" defer></script>`;
-            case "text/css":
-              return `<link rel="stylesheet" href="${srcPath}">`;
-            case "font/woff":
-            case "font/woff2":
-            case "application/font-woff":
-            case "application/font-woff2":
-            case "application/x-font-ttf":
-            case "application/x-font-opentype":
-            case "font/ttf":
-            case "font/otf":
-              return `<link rel="preload" as="font" href="${srcPath}" type="${mimeType}">`;
-            default:
-              return null;
-          }
-        })
-        .filter(Boolean)
-        .join("\n");
-
-      const licenseBanner =
-        licensePath && fs.existsSync(licensePath)
-          ? `<!--\n${fs.readFileSync(licensePath, "utf-8")}\n-->`
-          : "";
-
-      this.emitFile({
-        type: "asset",
-        fileName: "index.html",
-        source: `${licenseBanner}\n${resourcesTags}`,
-      });
-    },
-  };
-}
-
-export { htmlGenerator };

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

@@ -1,5 +0,0 @@
-export { htmlGenerator } from "./html-generator";
-export { localesGenerator } from "./locales-generator";
-export { minifier } from "./minifier";
-export { nodeDefinitionsInliner } from "./node-definitions-inliner";
-export { staticCopy } from "./static-copy";

package/src/vite/client/plugins/locales-generator.ts

@@ -1,126 +0,0 @@
-import type { Plugin } from "vite";
-import fs from "fs";
-import path from "path";
-
-function localesGenerator(options: {
-  outDir: string;
-  docsDir: string;
-  labelsDir: string;
-  languages: string[];
-}): Plugin {
-  const { outDir, docsDir, labelsDir, languages } = options;
-
-  return {
-    name: "vite-plugin-node-red:client:locales-generator",
-    apply: "build",
-    enforce: "post",
-
-    closeBundle() {
-      function validateLanguage(lang: string, filePath: string) {
-        if (!languages.includes(lang)) {
-          throw new Error(
-            `[locales] Invalid language "${lang}" in "${filePath}".\n` +
-              `Supported: ${languages.join(", ")}`,
-          );
-        }
-      }
-
-      function forEachFile<T>(
-        baseDir: string,
-        fileExtensions: string[],
-        processFile: (params: {
-          ext: string;
-          filePath: string;
-          nodeType: string;
-        }) => T | null,
-      ): Map<string, T extends unknown[] ? T : Record<string, T>> {
-        const langMap = new Map();
-
-        if (!fs.existsSync(baseDir)) return langMap;
-
-        const nodeDirs = fs
-          .readdirSync(baseDir, { withFileTypes: true })
-          .filter((d) => d.isDirectory());
-
-        for (const nodeDir of nodeDirs) {
-          const nodeType = nodeDir.name;
-          const nodePath = path.join(baseDir, nodeType);
-          const files = fs.readdirSync(nodePath);
-
-          for (const file of files) {
-            const ext = path.extname(file);
-            if (!fileExtensions.includes(ext)) continue;
-
-            const lang = path.basename(file, ext);
-            const filePath = path.join(nodePath, file);
-            validateLanguage(lang, filePath);
-
-            const value = processFile({ ext, filePath, nodeType });
-            if (value == null) continue;
-
-            if (!langMap.has(lang)) {
-              langMap.set(lang, Array.isArray(value) ? [] : {});
-            }
-
-            if (Array.isArray(value)) {
-              langMap.get(lang).push(...value);
-            } else {
-              langMap.get(lang)[nodeType] = value;
-            }
-          }
-        }
-
-        return langMap;
-      }
-
-      function writeOutput<T>(
-        langMap: Map<string, T>,
-        fileName: string,
-        serialize: (value: T) => string,
-      ) {
-        for (const [lang, data] of langMap.entries()) {
-          const langOutDir = path.join(outDir, lang);
-          fs.mkdirSync(langOutDir, { recursive: true });
-          fs.writeFileSync(
-            path.join(langOutDir, fileName),
-            serialize(data),
-            "utf-8",
-          );
-        }
-      }
-
-      const docLangs = forEachFile(
-        docsDir,
-        [".html", ".md"],
-        ({ ext, filePath, nodeType }) => {
-          const type =
-            ext === ".html"
-              ? "text/html"
-              : ext === ".md"
-                ? "text/markdown"
-                : null;
-          if (!type) return null;
-
-          const content = fs.readFileSync(filePath, "utf-8");
-          return [
-            `<script type="${type}" data-help-name="${nodeType}">\n${content}\n</script>`,
-          ];
-        },
-      );
-
-      writeOutput(docLangs, "index.html", (value: string[]) =>
-        value.join("\n"),
-      );
-
-      const labelLangs = forEachFile(labelsDir, [".json"], ({ filePath }) =>
-        JSON.parse(fs.readFileSync(filePath, "utf-8")),
-      );
-
-      writeOutput(labelLangs, "index.json", (value) =>
-        JSON.stringify(value, null, 2),
-      );
-    },
-  };
-}
-
-export { localesGenerator };

package/src/vite/client/plugins/minifier.ts

@@ -1,23 +0,0 @@
-import type { Plugin } from "vite";
-import { transform } from "esbuild";
-
-function minifier(): Plugin {
-  return {
-    name: "vite-plugin-node-red:client:minifier",
-    apply: "build",
-
-    async generateBundle(_options, bundle) {
-      for (const [fileName, chunk] of Object.entries(bundle)) {
-        if (chunk.type === "chunk" && fileName.endsWith(".js")) {
-          const result = await transform(chunk.code, {
-            minify: true,
-          });
-          chunk.code = result.code;
-          chunk.map = null as any;
-        }
-      }
-    },
-  };
-}
-
-export { minifier };