@hirrao/rollup-virtual-app-plugins 1.0.0

package/dist/config.plugin.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "rollup";
+export interface ConfigVirtualPluginOptions {
+    configDir: string;
+    dataDir?: string;
+    moduleId?: string;
+    dtsOutputPath?: string;
+}
+declare const configVirtualPlugin: (options: ConfigVirtualPluginOptions) => Plugin;
+export default configVirtualPlugin;

package/dist/config.plugin.js

@@ -0,0 +1,218 @@
+import fs from "fs";
+import path from "path";
+import { Node, Project } from "ts-morph";
+import { ensureArray, normalizeFsPath, normalizeImportPath, } from "./shared.utils.js";
+const isObjectExportDeclaration = (decl) => {
+    if (!Node.isVariableDeclaration(decl))
+        return false;
+    const initializer = decl.getInitializer();
+    if (!initializer)
+        return false;
+    return Node.isObjectLiteralExpression(initializer);
+};
+const writeConfigDts = (dtsOutputPath, moduleId, configEntries) => {
+    const dtsOutputAbs = path.resolve(dtsOutputPath);
+    const dtsDir = path.dirname(dtsOutputAbs);
+    if (!fs.existsSync(dtsDir))
+        fs.mkdirSync(dtsDir, { recursive: true });
+    const configShape = configEntries
+        .map((entry) => {
+        const rel = normalizeImportPath(dtsDir, entry.filePath);
+        return `    '${entry.key}': typeof import('${rel}').${entry.exportName};`;
+    })
+        .join("\n");
+    const dtsContent = `// Auto-generated. Do not edit.
+declare module '${moduleId}' {
+  interface ConfigShape {
+${configShape || "    [key: string]: never;"}
+  }
+
+  export const config: ConfigShape;
+  export function reloadConfig(): void;
+  export function saveConfig(): boolean;
+  export default config;
+}
+`;
+    fs.writeFileSync(dtsOutputAbs, dtsContent, "utf8");
+};
+const configVirtualPlugin = (options) => {
+    const moduleId = options.moduleId ?? "virtual:app-config";
+    const dataDir = options.dataDir ?? "./config";
+    const resolvedModuleId = `\0${moduleId}`;
+    const sourceIdMap = new Map();
+    const configEntries = [];
+    return {
+        name: "rollup-plugin-config-virtual-module",
+        buildStart() {
+            sourceIdMap.clear();
+            configEntries.length = 0;
+            const project = new Project();
+            const configDirAbs = path.resolve(options.configDir);
+            const normalizedConfigDir = normalizeFsPath(configDirAbs);
+            project.addSourceFilesAtPaths(path.join(configDirAbs, "**/*.ts"));
+            let configFileIndex = 0;
+            const configKeySourceMap = new Map();
+            for (const sourceFile of project.getSourceFiles()) {
+                const sourcePath = sourceFile.getFilePath();
+                const normalizedSourcePath = normalizeFsPath(sourcePath);
+                if (!normalizedSourcePath.startsWith(normalizedConfigDir))
+                    continue;
+                const internalId = `virtual:generated:config:${configFileIndex}`;
+                sourceIdMap.set(internalId, sourcePath);
+                configFileIndex += 1;
+                const exportedMap = sourceFile.getExportedDeclarations();
+                for (const [exportName, declarations] of exportedMap.entries()) {
+                    if (exportName === "default")
+                        continue;
+                    const declarationList = ensureArray(declarations);
+                    const hasObjectExport = declarationList.some((decl) => isObjectExportDeclaration(decl));
+                    if (!hasObjectExport)
+                        continue;
+                    const existingSource = configKeySourceMap.get(exportName);
+                    if (existingSource) {
+                        this.error(`[Config] Duplicate config key "${exportName}" found.\nFirst: ${existingSource}\nDuplicate: ${sourcePath}`);
+                    }
+                    configKeySourceMap.set(exportName, sourcePath);
+                    configEntries.push({
+                        key: exportName,
+                        exportName,
+                        filePath: sourcePath,
+                        internalId,
+                        importAlias: `__configDefault_${exportName}`,
+                    });
+                }
+            }
+            if (options.dtsOutputPath) {
+                writeConfigDts(options.dtsOutputPath, moduleId, configEntries);
+            }
+        },
+        resolveId(id) {
+            if (id === moduleId)
+                return resolvedModuleId;
+            const sourcePath = sourceIdMap.get(id);
+            if (sourcePath)
+                return sourcePath;
+            return null;
+        },
+        load(id) {
+            if (id !== resolvedModuleId)
+                return null;
+            const groupedByInternalId = new Map();
+            for (const entry of configEntries) {
+                const list = groupedByInternalId.get(entry.internalId) ?? [];
+                list.push(entry);
+                groupedByInternalId.set(entry.internalId, list);
+            }
+            const importLines = Array.from(groupedByInternalId.entries())
+                .map(([internalId, entries]) => {
+                const namedImports = entries
+                    .map((entry) => `${entry.exportName} as ${entry.importAlias}`)
+                    .join(", ");
+                return `import { ${namedImports} } from ${JSON.stringify(internalId)};`;
+            })
+                .join("\n");
+            const defaultObjectLines = configEntries
+                .map((entry) => `  '${entry.key}': ${entry.importAlias},`)
+                .join("\n");
+            const runtimeKeys = JSON.stringify(configEntries.map((entry) => entry.key));
+            return `${importLines}
+import fs from "fs";
+import path from "path";
+import toml from "smol-toml";
+
+const DATA_DIR = path.resolve(process.cwd(), ${JSON.stringify(dataDir)});
+const CONFIG_KEYS = ${runtimeKeys};
+
+const deepClone = (value) => {
+  if (Array.isArray(value)) return value.map((item) => deepClone(item));
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = deepClone(value[key]);
+    }
+    return result;
+  }
+  return value;
+};
+
+const deepMerge = (base, override) => {
+  if (!override || typeof override !== "object" || Array.isArray(override)) {
+    return override === undefined ? base : override;
+  }
+  const result = Array.isArray(base) ? [...base] : { ...(base ?? {}) };
+  for (const key of Object.keys(override)) {
+    const baseValue = result[key];
+    const overrideValue = override[key];
+    if (
+      baseValue &&
+      typeof baseValue === "object" &&
+      !Array.isArray(baseValue) &&
+      overrideValue &&
+      typeof overrideValue === "object" &&
+      !Array.isArray(overrideValue)
+    ) {
+      result[key] = deepMerge(baseValue, overrideValue);
+      continue;
+    }
+    result[key] = deepClone(overrideValue);
+  }
+  return result;
+};
+
+const configDefaults = {
+${defaultObjectLines}
+};
+
+const configModules = {
+${configEntries
+                .map((entry) => `  '${entry.key}': deepClone(configDefaults['${entry.key}']),`)
+                .join("\n")}
+};
+
+export const config = configModules;
+
+export const reloadConfig = () => {
+  for (const key of CONFIG_KEYS) {
+    const filePath = path.join(DATA_DIR, \`\${key}.toml\`);
+    const defaults = deepClone(configDefaults[key]);
+    if (!fs.existsSync(filePath)) {
+      configModules[key] = defaults;
+      continue;
+    }
+    try {
+      const raw = fs.readFileSync(filePath, "utf8");
+      const parsed = toml.parse(raw);
+      configModules[key] = deepMerge(defaults, parsed);
+    } catch (error) {
+      console.error(\`[Config] Failed to parse \${key}.toml, fallback to defaults:\`, error);
+      configModules[key] = defaults;
+    }
+  }
+};
+
+export const saveConfig = () => {
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+    }
+    for (const key of CONFIG_KEYS) {
+      const filePath = path.join(DATA_DIR, \`\${key}.toml\`);
+      const value = fs.existsSync(filePath)
+        ? (configModules[key] ?? configDefaults[key])
+        : configDefaults[key];
+      fs.writeFileSync(filePath, toml.stringify(value), "utf8");
+    }
+    return true;
+  } catch (error) {
+    console.error("[Config] saveConfig failed:", error);
+    return false;
+  }
+};
+
+reloadConfig();
+export default config;
+`;
+        },
+    };
+};
+export default configVirtualPlugin;

package/dist/generated.plugin.d.ts

@@ -0,0 +1,4 @@
+export { default as configVirtualPlugin } from "./config.plugin.js";
+export type { ConfigVirtualPluginOptions } from "./config.plugin.js";
+export { default as libsVirtualPlugin } from "./libs.plugin.js";
+export type { LibsVirtualPluginOptions } from "./libs.plugin.js";

package/dist/generated.plugin.js

@@ -0,0 +1,2 @@
+export { default as configVirtualPlugin } from "./config.plugin.js";
+export { default as libsVirtualPlugin } from "./libs.plugin.js";

package/dist/libs.plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "rollup";
+export interface LibsVirtualPluginOptions {
+    libsDir: string;
+    moduleId?: string;
+    dtsOutputPath?: string;
+}
+declare const libsVirtualPlugin: (options: LibsVirtualPluginOptions) => Plugin;
+export default libsVirtualPlugin;

package/dist/libs.plugin.js

@@ -0,0 +1,128 @@
+import fs from "fs";
+import path from "path";
+import { Node, Project } from "ts-morph";
+import { ensureArray, normalizeFsPath, normalizeImportPath, } from "./shared.utils.js";
+const isFunctionExportDeclaration = (decl) => {
+    if (Node.isFunctionDeclaration(decl))
+        return true;
+    if (!Node.isVariableDeclaration(decl))
+        return false;
+    const initializer = decl.getInitializer();
+    if (!initializer)
+        return false;
+    return (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer));
+};
+const writeLibsDts = (dtsOutputPath, moduleId, libFunctionEntries) => {
+    const dtsOutputAbs = path.resolve(dtsOutputPath);
+    const dtsDir = path.dirname(dtsOutputAbs);
+    if (!fs.existsSync(dtsDir))
+        fs.mkdirSync(dtsDir, { recursive: true });
+    const libShape = libFunctionEntries
+        .map((entry) => {
+        const rel = normalizeImportPath(dtsDir, entry.filePath);
+        return `    '${entry.exportName}': typeof import('${rel}').${entry.exportName};`;
+    })
+        .join("\n");
+    const dtsContent = `// Auto-generated. Do not edit.
+declare module '${moduleId}' {
+  export const libFunctionMap: {
+${libShape || "    [key: string]: never;"}
+  };
+
+  export default libFunctionMap;
+}
+`;
+    fs.writeFileSync(dtsOutputAbs, dtsContent, "utf8");
+};
+const libsVirtualPlugin = (options) => {
+    const moduleId = options.moduleId ?? "virtual:app-libs";
+    const resolvedModuleId = `\0${moduleId}`;
+    const sourceIdMap = new Map();
+    const libFunctionEntries = [];
+    return {
+        name: "rollup-plugin-libs-virtual-module",
+        buildStart() {
+            sourceIdMap.clear();
+            libFunctionEntries.length = 0;
+            const project = new Project();
+            const libsDirAbs = path.resolve(options.libsDir);
+            const normalizedLibsDir = normalizeFsPath(libsDirAbs);
+            project.addSourceFilesAtPaths(path.join(libsDirAbs, "**/*.ts"));
+            let libFileIndex = 0;
+            const functionNameSourceMap = new Map();
+            for (const sourceFile of project.getSourceFiles()) {
+                const sourcePath = sourceFile.getFilePath();
+                const normalizedSourcePath = normalizeFsPath(sourcePath);
+                if (!normalizedSourcePath.startsWith(normalizedLibsDir))
+                    continue;
+                const internalId = `virtual:generated:libs:${libFileIndex}`;
+                sourceIdMap.set(internalId, sourcePath);
+                libFileIndex += 1;
+                const exportedMap = sourceFile.getExportedDeclarations();
+                for (const [exportName, declarations] of exportedMap.entries()) {
+                    if (exportName === "default")
+                        continue;
+                    const declarationList = ensureArray(declarations);
+                    const hasFunctionExport = declarationList.some((decl) => isFunctionExportDeclaration(decl));
+                    if (!hasFunctionExport)
+                        continue;
+                    const existingSource = functionNameSourceMap.get(exportName);
+                    if (existingSource) {
+                        this.error(`[Libs] Duplicate lib export "${exportName}" found.\nFirst: ${existingSource}\nDuplicate: ${sourcePath}`);
+                    }
+                    functionNameSourceMap.set(exportName, sourcePath);
+                    libFunctionEntries.push({
+                        filePath: sourcePath,
+                        exportName,
+                        internalId,
+                        importAlias: `__libFn_${exportName}`,
+                    });
+                }
+            }
+            if (options.dtsOutputPath) {
+                writeLibsDts(options.dtsOutputPath, moduleId, libFunctionEntries);
+            }
+        },
+        resolveId(id) {
+            if (id === moduleId)
+                return resolvedModuleId;
+            const sourcePath = sourceIdMap.get(id);
+            if (sourcePath)
+                return sourcePath;
+            return null;
+        },
+        load(id) {
+            if (id !== resolvedModuleId)
+                return null;
+            const groupedByInternalId = new Map();
+            for (const entry of libFunctionEntries) {
+                const list = groupedByInternalId.get(entry.internalId) ?? [];
+                list.push({
+                    exportName: entry.exportName,
+                    importAlias: entry.importAlias,
+                });
+                groupedByInternalId.set(entry.internalId, list);
+            }
+            const importLines = Array.from(groupedByInternalId.entries())
+                .map(([internalId, exportsList]) => {
+                const namedImports = exportsList
+                    .map((item) => `${item.exportName} as ${item.importAlias}`)
+                    .join(", ");
+                return `import { ${namedImports} } from ${JSON.stringify(internalId)};`;
+            })
+                .join("\n");
+            const objectLines = libFunctionEntries
+                .map((entry) => `  '${entry.exportName}': ${entry.importAlias},`)
+                .join("\n");
+            return `${importLines}
+
+export const libFunctionMap = {
+${objectLines}
+};
+
+export default libFunctionMap;
+`;
+        },
+    };
+};
+export default libsVirtualPlugin;

package/dist/shared.utils.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeImportPath: (fromDir: string, targetFile: string) => string;
+export declare const normalizeFsPath: (filePath: string) => string;
+export declare const ensureArray: <T>(value: T | T[]) => T[];

package/dist/shared.utils.js

@@ -0,0 +1,15 @@
+import path from "path";
+export const normalizeImportPath = (fromDir, targetFile) => {
+    let result = path.relative(fromDir, targetFile).replace(/\\/g, "/");
+    result = result.replace(/\.(ts|tsx|mts|cts)$/, "");
+    if (!result.startsWith("."))
+        result = `./${result}`;
+    return result;
+};
+export const normalizeFsPath = (filePath) => {
+    const normalized = path.normalize(filePath);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+};
+export const ensureArray = (value) => {
+    return Array.isArray(value) ? value : [value];
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@hirrao/rollup-virtual-app-plugins",
+  "version": "1.0.0",
+  "description": "Rollup plugins for generating virtual app config and libs modules.",
+  "license": "LGPL-3.0-or-later",
+  "author": "hirrao",
+  "type": "module",
+  "main": "./dist/generated.plugin.js",
+  "types": "./dist/generated.plugin.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/generated.plugin.d.ts",
+      "import": "./dist/generated.plugin.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "rollup",
+    "plugin",
+    "virtual-module",
+    "config",
+    "typescript"
+  ],
+  "peerDependencies": {
+    "rollup": "^4.0.0"
+  },
+  "dependencies": {
+    "smol-toml": "^1.6.0",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../node_modules/typescript/bin/tsc generated.plugin.ts config.plugin.ts libs.plugin.ts --outDir dist --module esnext --target esnext --moduleResolution bundler --skipLibCheck --declaration --declarationMap false",
+    "clean": "node -e \"import('node:fs').then(fs=>fs.rmSync('dist',{recursive:true,force:true}))\""
+  }
+}