@macroforge/vite-plugin 0.1.40 → 0.1.42

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAqJ9B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAEhD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAEhD;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AA6TD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,iBAAS,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,MAAM,CAuTvE;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AA4D9B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAEhD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAEhD;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AA0OD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,iBAAS,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,MAAM,CAwUvE;AAED,eAAe,gBAAgB,CAAC"}

package/dist/index.js

@@ -29,6 +29,7 @@
 import { createRequire } from "module";
 import * as fs from "fs";
 import * as path from "path";
+import { collectExternalDecoratorModules, loadMacroConfig, } from "@macroforge/shared";
 const moduleRequire = createRequire(import.meta.url);
 let tsModule;
 try {
@@ -40,92 +41,6 @@ catch (error) {
 }
 const compilerOptionsCache = new Map();
 let cachedRequire;
-/**
- * Cache for external macro package manifests.
- * Maps package path to its manifest (or null if failed to load).
- */
-const externalManifestCache = new Map();
-/**
- * Parses macro import comments from TypeScript code.
- *
- * @remarks
- * Extracts macro names mapped to their source module paths from
- * `/** import macro { ... } from "package" * /` comments.
- *
- * @param text - The TypeScript source code to parse
- * @returns Map of macro names to their module paths
- *
- * @example
- * ```typescript
- * const text = `/** import macro {JSON, FieldController} from "@playground/macro"; * /`;
- * parseMacroImportComments(text);
- * // => Map { "JSON" => "@playground/macro", "FieldController" => "@playground/macro" }
- * ```
- *
- * @internal
- */
-function parseMacroImportComments(text) {
-    const imports = new Map();
-    const pattern = /\/\*\*\s*import\s+macro\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/gi;
-    let match;
-    while ((match = pattern.exec(text)) !== null) {
-        const names = match[1]
-            .split(",")
-            .map((n) => n.trim())
-            .filter(Boolean);
-        const modulePath = match[2];
-        for (const name of names) {
-            imports.set(name, modulePath);
-        }
-    }
-    return imports;
-}
-/**
- * Attempts to load the manifest from an external macro package.
- *
- * External macro packages (like `@playground/macro`) export their own
- * `__macroforgeGetManifest()` function that provides macro metadata
- * including descriptions.
- *
- * @param modulePath - The package path (e.g., "@playground/macro")
- * @returns The macro manifest, or null if loading failed
- *
- * @internal
- */
-function getExternalManifest(modulePath) {
-    if (externalManifestCache.has(modulePath)) {
-        return externalManifestCache.get(modulePath) ?? null;
-    }
-    try {
-        const pkg = moduleRequire(modulePath);
-        if (typeof pkg.__macroforgeGetManifest === "function") {
-            const manifest = pkg.__macroforgeGetManifest();
-            externalManifestCache.set(modulePath, manifest);
-            return manifest;
-        }
-    }
-    catch {
-        // Package not found or doesn't export manifest
-    }
-    externalManifestCache.set(modulePath, null);
-    return null;
-}
-/**
- * Collects decorator modules from external macro packages referenced in the code.
- *
- * @param code - The TypeScript source code to scan
- * @returns Array of decorator module names from external packages
- *
- * @internal
- */
-function collectExternalDecoratorModules(code) {
-    const imports = parseMacroImportComments(code);
-    const modulePaths = [...new Set(imports.values())];
-    return modulePaths.flatMap((modulePath) => {
-        const manifest = getExternalManifest(modulePath);
-        return manifest?.decorators.map((d) => d.module) ?? [];
-    });
-}
 /**
  * Ensures that `require()` is available in the current execution context.
  *
@@ -155,53 +70,6 @@ async function ensureRequire() {
     }
     return cachedRequire;
 }
-/**
- * Loads Macroforge configuration from `macroforge.json`.
- *
- * @remarks
- * Searches for `macroforge.json` starting from `projectRoot` and traversing up the
- * directory tree until found or the filesystem root is reached. This allows monorepo
- * setups where the config may be at the workspace root rather than the package root.
- *
- * If the config file is found but cannot be parsed (invalid JSON), returns the
- * default configuration rather than throwing an error.
- *
- * @param projectRoot - The directory to start searching from (usually Vite's resolved root)
- *
- * @returns The loaded configuration, or a default config if no file is found
- *
- * @example
- * ```typescript
- * // macroforge.json
- * {
- *   "keepDecorators": true
- * }
- * ```
- *
- * @internal
- */
-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;
-}
 /**
  * Retrieves and normalizes TypeScript compiler options for declaration emission.
  *
@@ -576,8 +444,7 @@ function napiMacrosPlugin(options = {}) {
          */
         configResolved(config) {
             projectRoot = config.root;
-            macroConfig = loadMacroConfig(projectRoot);
-            // Load the Rust binary
+            // Load the Rust binary first
             try {
                 rustTransformer = moduleRequire("macroforge");
             }
@@ -585,6 +452,11 @@ function napiMacrosPlugin(options = {}) {
                 console.warn("[@macroforge/vite-plugin] Rust binary not found. Please run `npm run build:rust` first.");
                 console.warn(error);
             }
+            // Load config (passing Rust transformer for foreign type parsing)
+            macroConfig = loadMacroConfig(projectRoot, rustTransformer?.loadConfig);
+            if (macroConfig.hasForeignTypes) {
+                console.log("[@macroforge/vite-plugin] Loaded config with foreign types from:", macroConfig.configPath);
+            }
         },
         /**
          * Transform hook for processing TypeScript files through the macro expander.
@@ -631,11 +503,12 @@ function napiMacrosPlugin(options = {}) {
             }
             try {
                 // Collect external decorator modules from macro imports
-                const externalDecoratorModules = collectExternalDecoratorModules(code);
+                const externalDecoratorModules = collectExternalDecoratorModules(code, moduleRequire);
                 // Perform macro expansion via the Rust binary
                 const result = rustTransformer.expandSync(code, id, {
                     keepDecorators: macroConfig.keepDecorators,
                     externalDecoratorModules,
+                    configPath: macroConfig.configPath,
                 });
                 // Report diagnostics from macro expansion
                 for (const diag of result.diagnostics) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@macroforge/vite-plugin",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,8 @@
     "test": "npm run build && node --test tests/**/*.test.js"
   },
   "dependencies": {
-    "macroforge": "^0.1.40"
+    "@macroforge/shared": "^0.1.42",
+    "macroforge": "^0.1.42"
   },
   "devDependencies": {
     "typescript": "^5.9.3",