@bonsae/nrg 0.1.0

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

@@ -0,0 +1,203 @@
+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),
+      );
+    },
+  };
+}

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

@@ -0,0 +1,285 @@
+import type { Plugin } from "vite";
+import dts from "vite-plugin-dts";
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+/**
+ * Recursively collect all .ts files under a directory, excluding .d.ts files.
+ */
+function collectTsFiles(dir: string): string[] {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
+    const full = path.join(dir, dirent.name);
+    if (dirent.isDirectory()) return collectTsFiles(full);
+    if (
+      dirent.isFile() &&
+      dirent.name.endsWith(".ts") &&
+      !dirent.name.endsWith(".d.ts")
+    )
+      return [full];
+    return [];
+  });
+}
+
+/**
+ * Convert a file basename (without extension) to PascalCase.
+ * E.g. "your-node" → "YourNode", "remote_server" → "RemoteServer"
+ */
+function toPascalCase(name: string): string {
+  return name
+    .split(/[-_]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}
+
+/**
+ * Positional semantic names for each framework base class.
+ * Position i in the generic corresponds to the i-th semantic slot.
+ * Users can name their types anything — the position determines meaning.
+ */
+const BASE_CLASS_SLOTS: Record<string, string[]> = {
+  IONode: ["Config", "Credentials", "Input", "Output", "Settings"],
+  ConfigNode: ["Config", "Credentials", "Settings"],
+};
+
+/**
+ * Parse a node source file and return `{ localName, semanticName }` pairs for
+ * types that should be exported from the package.
+ *
+ * The semantic name is derived from the generic POSITION in the base class, so
+ * a user can name their types anything:
+ *
+ *   export default class MyNode extends IONode<Bananas, MyCreds, …>
+ *   export type Bananas = { … }   → exported as {Ns}Config  (position 0)
+ *   export type MyCreds = { … }   → exported as {Ns}Credentials (position 1)
+ *
+ * Only types that appear as generic args AND are exported from the file are
+ * included, so unrelated helper types are never leaked.
+ */
+function getNodeTypeExports(
+  filePath: string,
+): Array<{ localName: string; semanticName: string }> {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const source = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.ESNext,
+    /* setParentNodes */ true,
+  );
+
+  const hasModifier = (node: ts.HasModifiers, kind: ts.SyntaxKind) =>
+    (node.modifiers ?? []).some((m) => m.kind === kind);
+
+  // Collect names of exported type aliases and interfaces.
+  const exportedTypeNames = new Set<string>();
+  for (const stmt of source.statements) {
+    if (
+      ts.isTypeAliasDeclaration(stmt) &&
+      hasModifier(stmt, ts.SyntaxKind.ExportKeyword)
+    ) {
+      exportedTypeNames.add(stmt.name.text);
+    }
+    if (
+      ts.isInterfaceDeclaration(stmt) &&
+      hasModifier(stmt, ts.SyntaxKind.ExportKeyword)
+    ) {
+      exportedTypeNames.add(stmt.name.text);
+    }
+  }
+
+  if (exportedTypeNames.size === 0) return [];
+
+  // Find `export default class … extends BaseClass<T0, T1, …>` and extract
+  // the base class name and its generic type argument names by position.
+  let baseClassName = "";
+  const genericArgNames: string[] = [];
+
+  for (const stmt of source.statements) {
+    if (
+      !ts.isClassDeclaration(stmt) ||
+      !hasModifier(stmt, ts.SyntaxKind.DefaultKeyword)
+    ) {
+      continue;
+    }
+    for (const clause of stmt.heritageClauses ?? []) {
+      if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+      for (const type of clause.types) {
+        if (ts.isIdentifier(type.expression)) {
+          baseClassName = type.expression.text;
+        }
+        for (const arg of type.typeArguments ?? []) {
+          if (ts.isTypeReferenceNode(arg) && ts.isIdentifier(arg.typeName)) {
+            genericArgNames.push(arg.typeName.text);
+          } else {
+            // Unknown / complex type arg — push empty string to preserve positions.
+            genericArgNames.push("");
+          }
+        }
+      }
+    }
+    break;
+  }
+
+  const slots = BASE_CLASS_SLOTS[baseClassName];
+  if (!slots) return [];
+
+  // Build pairs: for each position, if the arg is exported AND we have a
+  // semantic name for that slot, include it.
+  const result: Array<{ localName: string; semanticName: string }> = [];
+  for (let i = 0; i < genericArgNames.length; i++) {
+    const localName = genericArgNames[i];
+    const semanticName = slots[i];
+    if (localName && semanticName && exportedTypeNames.has(localName)) {
+      result.push({ localName, semanticName });
+    }
+  }
+  return result;
+}
+
+/**
+ * Build re-export statements for every file in {srcDir}/nodes/, relative to
+ * the given entry file path.
+ *
+ * Per node file two kinds of statements are generated:
+ *
+ *   // 1. Class re-export — so api-extractor includes the class declaration
+ *   //    in the bundled .d.ts, enabling `import { YourNode }`, `instanceof`,
+ *   //    type assertions `as YourNode`, and `resolveTypedInput<YourNode>()`.
+ *   export { default as YourNode } from "./nodes/your-node";
+ *
+ *   // 2. Type-only exports — one per exported type alias/interface, prefixed
+ *   //    with the namespace name to avoid collisions across node files.
+ *   //    Enables `import type { YourNodeConfig, YourNodeCredentials }`.
+ *   export type { Config as YourNodeConfig, Credentials as YourNodeCredentials,
+ *                 Input as YourNodeInput, Output as YourNodeOutput,
+ *                 Settings as YourNodeSettings } from "./nodes/your-node";
+ *
+ * These statements are appended in memory to the entry file content served to
+ * the TypeScript compiler via a `ts.sys.readFile` patch, so api-extractor
+ * includes them in the final bundled `.d.ts` without touching any source file.
+ * Runtime class values are exposed by `cjsDefaultExportPlugin` dynamically
+ * via the `nodes` array on the package function.
+ */
+function buildNodeReexports(srcDir: string, entryFile: string): string {
+  const nodesDir = path.join(srcDir, "nodes");
+  const nodeFiles = collectTsFiles(nodesDir);
+  return nodeFiles
+    .map((file) => {
+      const rel = path
+        .relative(path.dirname(entryFile), file)
+        .replace(/\\/g, "/");
+      const relPath = rel.startsWith(".") ? rel : `./${rel}`;
+      const specifier = relPath.replace(/\.ts$/, "");
+      const ns = toPascalCase(path.basename(file, ".ts"));
+
+      const lines = [`export { default as ${ns} } from "${specifier}";`];
+
+      const typePairs = getNodeTypeExports(file);
+      if (typePairs.length > 0) {
+        const prefixed = typePairs
+          .map(
+            ({ localName, semanticName }) =>
+              `${localName} as ${ns}${semanticName}`,
+          )
+          .join(", ");
+        lines.push(`export type { ${prefixed} } from "${specifier}";`);
+      }
+
+      return lines.join("\n");
+    })
+    .join("\n");
+}
+
+function typeGenerator(options: {
+  srcDir: string;
+  outDir: string;
+  /** Absolute paths of entry files (values from the entryPoints record). */
+  entryFiles: string[];
+}): Plugin[] {
+  const { srcDir, outDir, entryFiles } = options;
+
+  // Prefer the server-specific tsconfig (inside srcDir) over the root one.
+  // The root tsconfig typically only includes vite.config.ts, while the server
+  // tsconfig includes the actual source files needed for declaration emit.
+  const serverTsconfig = path.resolve(srcDir, "tsconfig.json");
+  const rootTsconfig = path.resolve("tsconfig.json");
+  const userTsconfig = fs.existsSync(serverTsconfig)
+    ? serverTsconfig
+    : rootTsconfig;
+  // Exclude the user's client dir (sibling of srcDir), any nested client dirs,
+  // and the vite/ build-tooling dir — none of these should appear in the
+  // published type declarations.
+  const clientDir = path.relative(
+    process.cwd(),
+    path.join(path.dirname(srcDir), "client"),
+  );
+
+  // Absolute resolved path → augmented source content (in-memory only).
+  const augmentedContents = new Map<string, string>();
+  // Original ts.sys.readFile — restored in closeBundle.
+  let origReadFile: typeof ts.sys.readFile | null = null;
+
+  const nodeTypeExporter: Plugin = {
+    name: "vite-plugin-node-red:server:type-exporter",
+    enforce: "pre",
+    buildStart() {
+      augmentedContents.clear();
+      for (const entryFile of entryFiles) {
+        const reexports = buildNodeReexports(srcDir, entryFile);
+        if (!reexports) continue;
+        const original = fs.readFileSync(entryFile, "utf-8");
+        augmentedContents.set(
+          path.resolve(entryFile),
+          `${original}\n${reexports}\n`,
+        );
+      }
+      if (augmentedContents.size === 0) return;
+      origReadFile = ts.sys.readFile.bind(ts.sys);
+      ts.sys.readFile = (fileName, encoding) => {
+        const resolved = path.resolve(fileName);
+        return (
+          augmentedContents.get(resolved) ?? origReadFile!(fileName, encoding)
+        );
+      };
+    },
+    closeBundle() {
+      if (origReadFile) {
+        ts.sys.readFile = origReadFile;
+        origReadFile = null;
+      }
+      augmentedContents.clear();
+    },
+  };
+
+  return [
+    nodeTypeExporter,
+    dts({
+      rollupTypes: true,
+      rollupOptions: {
+        messageCallback(message) {
+          if (message.messageId === "console-preamble") {
+            message.logLevel = "none";
+          }
+        },
+      },
+      outDir,
+      ...(fs.existsSync(userTsconfig) && { tsconfigPath: userTsconfig }),
+      compilerOptions: {
+        noEmit: false,
+        declaration: true,
+        emitDeclarationOnly: true,
+        noCheck: true,
+      },
+      exclude: [
+        `${clientDir}/**`,
+        "**/client/**",
+        "vite/**",
+        "node_modules/**",
+        "dist/**",
+      ],
+    }),
+  ].flat();
+}
+
+export { typeGenerator };