@macroforge/vite-plugin 0.1.4

package/README.md

@@ -0,0 +1,35 @@
+# @macroforge/vite-plugin
+
+> **Warning:** This is a work in progress and probably won't work for you. Use at your own risk!
+
+Vite plugin for macroforge compile-time TypeScript macros.
+
+Part of the [macroforge](https://github.com/rymskip/macroforge-ts) project.
+
+## Installation
+
+```bash
+npm install @macroforge/vite-plugin
+```
+
+## Usage
+
+```typescript
+// vite.config.ts
+import macroforge from "@macroforge/vite-plugin";
+
+export default defineConfig({
+  plugins: [
+    macroforge({
+      typesOutputDir: ".macroforge/types",
+      metadataOutputDir: ".macroforge/meta",
+      generateTypes: true,
+      emitMetadata: true,
+    }),
+  ],
+});
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from "vite";
+export interface NapiMacrosPluginOptions {
+    include?: string | RegExp | (string | RegExp)[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    generateTypes?: boolean;
+    typesOutputDir?: string;
+    emitMetadata?: boolean;
+    metadataOutputDir?: string;
+}
+declare function napiMacrosPlugin(options?: NapiMacrosPluginOptions): Plugin;
+export default napiMacrosPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAsC9B,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAChD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AA6LD,iBAAS,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,MAAM,CA0LvE;AAED,eAAe,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,291 @@
+import { createRequire } from "module";
+import * as fs from "fs";
+import * as path from "path";
+const moduleRequire = createRequire(import.meta.url);
+let tsModule;
+try {
+    tsModule = moduleRequire("typescript");
+}
+catch (error) {
+    tsModule = undefined;
+    console.warn("[@macroforge/vite-plugin] TypeScript not found. Generated .d.ts files will be skipped.");
+}
+const compilerOptionsCache = new Map();
+let cachedRequire;
+async function ensureRequire() {
+    if (typeof require !== "undefined") {
+        return require;
+    }
+    if (!cachedRequire) {
+        const { createRequire } = await import("module");
+        cachedRequire = createRequire(process.cwd() + "/");
+        // Expose on globalThis so native runtime loaders can use it
+        globalThis.require = cachedRequire;
+    }
+    return cachedRequire;
+}
+function loadMacroConfig(projectRoot) {
+    let current = projectRoot;
+    const fallback = { keepDecorators: false };
+    while (true) {
+        const candidate = path.join(current, "macroforge.json");
+        if (fs.existsSync(candidate)) {
+            try {
+                const raw = fs.readFileSync(candidate, "utf8");
+                const parsed = JSON.parse(raw);
+                return { keepDecorators: Boolean(parsed.keepDecorators) };
+            }
+            catch {
+                return fallback;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return fallback;
+}
+function getCompilerOptions(projectRoot) {
+    if (!tsModule) {
+        return undefined;
+    }
+    const cached = compilerOptionsCache.get(projectRoot);
+    if (cached) {
+        return cached;
+    }
+    let configPath;
+    try {
+        configPath = tsModule.findConfigFile(projectRoot, tsModule.sys.fileExists, "tsconfig.json");
+    }
+    catch {
+        configPath = undefined;
+    }
+    let options;
+    if (configPath) {
+        const configFile = tsModule.readConfigFile(configPath, tsModule.sys.readFile);
+        if (configFile.error) {
+            const formatted = tsModule.formatDiagnosticsWithColorAndContext([configFile.error], {
+                getCurrentDirectory: () => projectRoot,
+                getCanonicalFileName: (fileName) => fileName,
+                getNewLine: () => tsModule.sys.newLine,
+            });
+            console.warn(`[@macroforge/vite-plugin] Failed to read tsconfig at ${configPath}\n${formatted}`);
+            options = {};
+        }
+        else {
+            const parsed = tsModule.parseJsonConfigFileContent(configFile.config, tsModule.sys, path.dirname(configPath));
+            options = parsed.options;
+        }
+    }
+    else {
+        options = {};
+    }
+    const normalized = {
+        ...options,
+        declaration: true,
+        emitDeclarationOnly: true,
+        noEmitOnError: false,
+        incremental: false,
+    };
+    delete normalized.outDir;
+    delete normalized.outFile;
+    normalized.moduleResolution ??= tsModule.ModuleResolutionKind.Bundler;
+    normalized.module ??= tsModule.ModuleKind.ESNext;
+    normalized.target ??= tsModule.ScriptTarget.ESNext;
+    normalized.strict ??= true;
+    normalized.skipLibCheck ??= true;
+    compilerOptionsCache.set(projectRoot, normalized);
+    return normalized;
+}
+function emitDeclarationsFromCode(code, fileName, projectRoot) {
+    if (!tsModule) {
+        return undefined;
+    }
+    const compilerOptions = getCompilerOptions(projectRoot);
+    if (!compilerOptions) {
+        return undefined;
+    }
+    const normalizedFileName = path.resolve(fileName);
+    const sourceText = code;
+    const compilerHost = tsModule.createCompilerHost(compilerOptions, true);
+    compilerHost.getSourceFile = (requestedFileName, languageVersion) => {
+        if (path.resolve(requestedFileName) === normalizedFileName) {
+            return tsModule.createSourceFile(requestedFileName, sourceText, languageVersion, true);
+        }
+        const text = tsModule.sys.readFile(requestedFileName);
+        return text !== undefined
+            ? tsModule.createSourceFile(requestedFileName, text, languageVersion, true)
+            : undefined;
+    };
+    compilerHost.readFile = (requestedFileName) => {
+        return path.resolve(requestedFileName) === normalizedFileName
+            ? sourceText
+            : tsModule.sys.readFile(requestedFileName);
+    };
+    compilerHost.fileExists = (requestedFileName) => {
+        return (path.resolve(requestedFileName) === normalizedFileName ||
+            tsModule.sys.fileExists(requestedFileName));
+    };
+    let output;
+    const writeFile = (outputName, text) => {
+        if (outputName.endsWith(".d.ts")) {
+            output = text;
+        }
+    };
+    const program = tsModule.createProgram([normalizedFileName], compilerOptions, compilerHost);
+    const emitResult = program.emit(undefined, writeFile, undefined, true);
+    if (emitResult.emitSkipped && emitResult.diagnostics.length > 0) {
+        const formatted = tsModule.formatDiagnosticsWithColorAndContext(emitResult.diagnostics, {
+            getCurrentDirectory: () => projectRoot,
+            getCanonicalFileName: (fileName) => fileName,
+            getNewLine: () => tsModule.sys.newLine,
+        });
+        console.warn(`[@macroforge/vite-plugin] Declaration emit failed for ${path.relative(projectRoot, fileName)}\n${formatted}`);
+        return undefined;
+    }
+    return output;
+}
+function napiMacrosPlugin(options = {}) {
+    let rustTransformer;
+    let projectRoot;
+    let macroConfig = { keepDecorators: false };
+    const generateTypes = options.generateTypes !== false; // Default to true
+    const typesOutputDir = options.typesOutputDir || "src/macros/generated";
+    const emitMetadata = options.emitMetadata !== false;
+    const metadataOutputDir = options.metadataOutputDir || typesOutputDir;
+    // Ensure directory exists
+    function ensureDir(dir) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    function writeTypeDefinitions(id, types) {
+        const relativePath = path.relative(projectRoot, id);
+        const parsed = path.parse(relativePath);
+        const outputBase = path.join(projectRoot, typesOutputDir, parsed.dir);
+        ensureDir(outputBase);
+        const targetPath = path.join(outputBase, `${parsed.name}.d.ts`);
+        try {
+            const existing = fs.existsSync(targetPath)
+                ? fs.readFileSync(targetPath, "utf-8")
+                : null;
+            if (existing !== types) {
+                fs.writeFileSync(targetPath, types, "utf-8");
+                console.log(`[@macroforge/vite-plugin] Wrote types for ${relativePath} -> ${path.relative(projectRoot, targetPath)}`);
+            }
+        }
+        catch (error) {
+            console.error(`[@macroforge/vite-plugin] Failed to write type definitions for ${id}:`, error);
+        }
+    }
+    function writeMetadata(id, metadata) {
+        const relativePath = path.relative(projectRoot, id);
+        const parsed = path.parse(relativePath);
+        const outputBase = path.join(projectRoot, metadataOutputDir, parsed.dir);
+        ensureDir(outputBase);
+        const targetPath = path.join(outputBase, `${parsed.name}.macro-ir.json`);
+        try {
+            const existing = fs.existsSync(targetPath)
+                ? fs.readFileSync(targetPath, "utf-8")
+                : null;
+            if (existing !== metadata) {
+                fs.writeFileSync(targetPath, metadata, "utf-8");
+                console.log(`[@macroforge/vite-plugin] Wrote metadata for ${relativePath} -> ${path.relative(projectRoot, targetPath)}`);
+            }
+        }
+        catch (error) {
+            console.error(`[@macroforge/vite-plugin] Failed to write metadata for ${id}:`, error);
+        }
+    }
+    function formatTransformError(error, id) {
+        const relative = projectRoot ? path.relative(projectRoot, id) || id : id;
+        if (error instanceof Error) {
+            const details = error.stack && error.stack.includes(error.message)
+                ? error.stack
+                : `${error.message}\n${error.stack ?? ""}`;
+            return `[@macroforge/vite-plugin] Failed to transform ${relative}\n${details}`.trim();
+        }
+        return `[@macroforge/vite-plugin] Failed to transform ${relative}: ${String(error)}`;
+    }
+    return {
+        name: "@macroforge/vite-plugin",
+        enforce: "pre",
+        configResolved(config) {
+            projectRoot = config.root;
+            macroConfig = loadMacroConfig(projectRoot);
+            // Load the Rust binary
+            try {
+                rustTransformer = moduleRequire("macroforge");
+            }
+            catch (error) {
+                console.warn("[@macroforge/vite-plugin] Rust binary not found. Please run `npm run build:rust` first.");
+                console.warn(error);
+            }
+        },
+        async transform(code, id) {
+            await ensureRequire();
+            // Only transform TypeScript files
+            if (!id.endsWith(".ts") && !id.endsWith(".tsx")) {
+                return null;
+            }
+            // Skip node_modules by default
+            if (id.includes("node_modules")) {
+                return null;
+            }
+            // Check if Rust transformer is available
+            if (!rustTransformer || !rustTransformer.expandSync) {
+                // Return unchanged if transformer not available
+                return null;
+            }
+            try {
+                const result = rustTransformer.expandSync(code, id, {
+                    keepDecorators: macroConfig.keepDecorators,
+                });
+                // Report diagnostics
+                for (const diag of result.diagnostics) {
+                    if (diag.level === "error") {
+                        const message = `Macro error at ${id}:${diag.start ?? "?"}-${diag.end ?? "?"}: ${diag.message}`;
+                        this.error(message);
+                    }
+                    else {
+                        // Log warnings and info messages
+                        console.warn(`[@macroforge/vite-plugin] ${diag.level}: ${diag.message}`);
+                    }
+                }
+                if (result && result.code) {
+                    // TODO: Needs complete overhaul and dynamic attribute removal NO HARDCODING
+                    // if (!macroConfig.keepDecorators) {
+                    //   result.code = result.code
+                    //     .replace(/\/\*\*\s*@derive[\s\S]*?\*\/\s*/gi, "")
+                    //     .replace(/\/\*\*\s*@debug[\s\S]*?\*\/\s*/gi, "");
+                    // }
+                    // Remove macro-only imports so SSR output doesn't load native bindings
+                    result.code = result.code.replace(/\/\*\*\s*import\s+macro[\s\S]*?\*\/\s*/gi, "");
+                    if (generateTypes) {
+                        const emitted = emitDeclarationsFromCode(result.code, id, projectRoot);
+                        if (emitted) {
+                            writeTypeDefinitions(id, emitted);
+                        }
+                    }
+                    if (emitMetadata && result.metadata) {
+                        writeMetadata(id, result.metadata);
+                    }
+                    return {
+                        code: result.code,
+                        map: null, // expandSync does not generate source maps yet
+                    };
+                }
+            }
+            catch (error) {
+                if (error && typeof error === "object" && "plugin" in error) {
+                    throw error;
+                }
+                const message = formatTransformError(error, id);
+                this.error(message);
+            }
+            return null;
+        },
+    };
+}
+export default napiMacrosPlugin;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@macroforge/vite-plugin",
+  "version": "0.1.4",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rymskip/macroforge-ts.git"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "test": "npm run build && node --test tests/**/*.test.js"
+  },
+  "dependencies": {
+    "macroforge": "^0.1.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vite": "^7.2.4"
+  }
+}