@unlockable/vite-plugin-unlock 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/plugin.ts
-import path5 from "path";
-import fs4 from "fs";
+import path6 from "path";
+import fs5 from "fs";
 
 // src/config.ts
-import path from "path";
-import fs from "fs";
+import path2 from "path";
+import fs2 from "fs";
 import { createRequire } from "module";
 
 // src/constants.ts
@@ -24,6 +24,8 @@ var MAX_SCAN_DEPTH = 20;
 var PLUGIN_NAME = "vite-plugin-unlock";
 
 // src/utils.ts
+import path from "path";
+import fs from "fs";
 var PREFIX = `[${PLUGIN_NAME}]`;
 function createLogger(debug) {
   return {
@@ -49,33 +51,85 @@ function generateAlias(packageName) {
   const lastPart = parts[parts.length - 1];
   return `~${lastPart}`;
 }
+function collectCjsDeps(packageDir) {
+  const pkgJsonPath = path.join(packageDir, "package.json");
+  if (!fs.existsSync(pkgJsonPath)) return [];
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const deps = pkgJson.dependencies;
+  if (!deps) return [];
+  const cjsDeps = [];
+  for (const depName of Object.keys(deps)) {
+    if (depName.startsWith("@types/")) continue;
+    const depParts = depName.startsWith("@") ? depName.split("/") : [depName];
+    const candidates = [
+      path.join(packageDir, "node_modules", ...depParts, "package.json"),
+      path.join(process.cwd(), "node_modules", ...depParts, "package.json")
+    ];
+    let depPkgJson = null;
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        try {
+          depPkgJson = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+        } catch {
+          continue;
+        }
+        break;
+      }
+    }
+    if (!depPkgJson) continue;
+    if (depPkgJson.type === "module") continue;
+    if (!hasRootEntry(depPkgJson)) continue;
+    cjsDeps.push(depName);
+  }
+  return cjsDeps;
+}
+function hasRootEntry(pkgJson) {
+  const exports = pkgJson.exports;
+  if (exports !== void 0) {
+    if (exports === null) return false;
+    if (typeof exports === "string") return true;
+    if (typeof exports === "object" && !Array.isArray(exports)) {
+      return "." in exports;
+    }
+    return Array.isArray(exports);
+  }
+  if (pkgJson.main || pkgJson.module) return true;
+  return false;
+}
 
 // src/config.ts
 function findPackageSrcPath(packageName, srcDir) {
   const cwd = process.cwd();
   try {
-    const req = createRequire(path.join(cwd, "package.json"));
-    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
-    const pkgRoot = path.dirname(pkgJsonPath);
-    const srcPath = path.join(pkgRoot, srcDir);
-    if (fs.existsSync(srcPath)) return srcPath;
+    const req = createRequire(path2.join(cwd, "package.json"));
+    const pkgJsonPath = fs2.realpathSync(
+      req.resolve(`${packageName}/package.json`)
+    );
+    const pkgRoot = path2.dirname(pkgJsonPath);
+    const srcPath = path2.join(pkgRoot, srcDir);
+    if (fs2.existsSync(srcPath)) return srcPath;
     return pkgRoot;
   } catch {
   }
   const parts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
   const candidates = [
-    path.join(cwd, "node_modules", ...parts, srcDir),
-    path.join(cwd, ".yalc", ...parts, srcDir)
+    path2.join(cwd, "node_modules", ...parts, srcDir),
+    path2.join(cwd, ".yalc", ...parts, srcDir)
   ];
   for (const dir of candidates) {
-    if (fs.existsSync(dir)) return dir;
+    if (fs2.existsSync(dir)) return fs2.realpathSync(dir);
   }
   const rootCandidates = [
-    path.join(cwd, "node_modules", ...parts),
-    path.join(cwd, ".yalc", ...parts)
+    path2.join(cwd, "node_modules", ...parts),
+    path2.join(cwd, ".yalc", ...parts)
   ];
   for (const dir of rootCandidates) {
-    if (fs.existsSync(dir)) return dir;
+    if (fs2.existsSync(dir)) return fs2.realpathSync(dir);
   }
   return null;
 }
@@ -84,22 +138,24 @@ function resolveTarget(input) {
     package: input,
     alias: generateAlias(input),
     srcDir: DEFAULT_SRC_DIR,
-    srcPath: ""
+    srcPath: "",
+    packageDir: ""
   } : {
     package: input.package,
     alias: input.alias ?? generateAlias(input.package),
     srcDir: input.srcDir ?? DEFAULT_SRC_DIR,
     srcPath: "",
+    packageDir: "",
     entryRedirect: input.entryRedirect,
     hmr: input.hmr
   };
   const srcPath = findPackageSrcPath(target.package, target.srcDir);
   if (!srcPath) return null;
   target.srcPath = srcPath;
+  target.packageDir = srcPath.endsWith(path2.sep + target.srcDir) ? path2.resolve(srcPath, "..") : srcPath;
   if (target.entryRedirect && target.hmr) {
-    const pkgDir = path.dirname(srcPath);
-    const entryFile = path.resolve(pkgDir, target.entryRedirect.to);
-    if (fs.existsSync(entryFile)) {
+    const entryFile = path2.resolve(target.packageDir, target.entryRedirect.to);
+    if (fs2.existsSync(entryFile)) {
       target.entryFilePath = entryFile;
     }
   }
@@ -109,8 +165,8 @@ var CONFIG_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
 function findConfigFile(basename, overrideDirs) {
   for (const dir of overrideDirs) {
     for (const ext of CONFIG_EXTENSIONS) {
-      const p = path.resolve(dir, `${basename}${ext}`);
-      if (fs.existsSync(p)) return p;
+      const p = path2.resolve(dir, `${basename}${ext}`);
+      if (fs2.existsSync(p)) return p;
     }
   }
   return null;
@@ -118,7 +174,7 @@ function findConfigFile(basename, overrideDirs) {
 function resolveOptions(options) {
   const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
   const overrideInput = options.overrides ?? DEFAULT_OVERRIDE_DIR;
-  const overrideDirs = (Array.isArray(overrideInput) ? overrideInput : [overrideInput]).map((dir) => path.resolve(process.cwd(), dir));
+  const overrideDirs = (Array.isArray(overrideInput) ? overrideInput : [overrideInput]).map((dir) => path2.resolve(process.cwd(), dir));
   const targets = [];
   for (const input of options.targets) {
     const resolved = resolveTarget(input);
@@ -141,29 +197,33 @@ function resolveOptions(options) {
     extensions,
     extensionSet: new Set(extensions),
     patches,
-    hmrBoundaries: options.hmrBoundaries ?? []
+    hmrBoundaries: options.hmrBoundaries ?? [],
+    optimizeDeps: {
+      include: options.optimizeDeps?.include ?? []
+    },
+    autoOptimizeDeps: options.autoOptimizeDeps ?? true
   };
 }
 
 // src/scanner.ts
-import path2 from "path";
-import fs2 from "fs";
+import path3 from "path";
+import fs3 from "fs";
 function collectFiles(dir, extensionSet, depth = 0) {
   if (depth > MAX_SCAN_DEPTH) return [];
   const results = [];
   let entries;
   try {
-    entries = fs2.readdirSync(dir, { withFileTypes: true });
+    entries = fs3.readdirSync(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const fullPath = path2.resolve(dir, entry.name);
+    const fullPath = path3.resolve(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectFiles(fullPath, extensionSet, depth + 1));
     } else if (entry.isFile()) {
-      const ext = path2.extname(entry.name);
+      const ext = path3.extname(entry.name);
       if (extensionSet.has(ext)) {
         results.push(fullPath);
       }
@@ -181,7 +241,7 @@ function getOverrideKey(filePath, baseDir, match) {
   if (match === "path") {
     const normalizedBase = normalizePath(baseDir);
     const relative = normalizePath(
-      path2.relative(normalizedBase, normalized)
+      path3.relative(normalizedBase, normalized)
     );
     return stripExtension(relative);
   }
@@ -212,7 +272,7 @@ function scanAllTargets(opts, logger) {
   return combined;
 }
 function detectNamespace(filePath, overrideDir) {
-  const relative = normalizePath(path2.relative(overrideDir, filePath));
+  const relative = normalizePath(path3.relative(overrideDir, filePath));
   const scopedMatch = relative.match(/^(@[^/]+\/[^/]+)\//);
   if (scopedMatch) return scopedMatch[1];
   return null;
@@ -222,13 +282,13 @@ function scanOverrides(opts, logger) {
   const namespaced = /* @__PURE__ */ new Map();
   const targetPackages = new Set(opts.targets.map((t) => t.package));
   for (const dir of opts.overrideDirs) {
-    if (!fs2.existsSync(dir)) continue;
+    if (!fs3.existsSync(dir)) continue;
     for (const fullPath of collectFiles(dir, opts.extensionSet).sort()) {
-      const relative = normalizePath(path2.relative(dir, fullPath));
+      const relative = normalizePath(path3.relative(dir, fullPath));
       if (relative.split("/").some((part) => part.startsWith("_"))) continue;
       const ns = detectNamespace(fullPath, dir);
       if (ns && targetPackages.has(ns)) {
-        const nsDir = path2.join(dir, ns);
+        const nsDir = path3.join(dir, ns);
         const key = getOverrideKey(fullPath, nsDir, opts.match);
         if (key && key !== "index") {
           if (!namespaced.has(ns)) namespaced.set(ns, /* @__PURE__ */ new Map());
@@ -248,8 +308,8 @@ function scanOverrides(opts, logger) {
 }
 
 // src/resolver.ts
-import path3 from "path";
-import fs3 from "fs";
+import path4 from "path";
+import fs4 from "fs";
 function findImporterTarget(importer, opts) {
   const norm = normalizePath(importer);
   for (const target of opts.targets) {
@@ -257,7 +317,7 @@ function findImporterTarget(importer, opts) {
     if (norm.startsWith(normSrc + "/") || norm === normSrc) {
       return target;
     }
-    const pkgDir = normalizePath(path3.dirname(target.srcPath));
+    const pkgDir = normalizePath(path4.dirname(target.srcPath));
     if (norm.startsWith(pkgDir + "/")) {
       return target;
     }
@@ -270,11 +330,11 @@ function resolveEntryRedirect(resolvedId, opts, logger) {
     if (target.entryRedirect) {
       const fromPattern = normalizePath(target.entryRedirect.from);
       if (norm.endsWith(`/${fromPattern}`) || norm.includes(`/${fromPattern}`)) {
-        const pkgDir = path3.dirname(target.srcPath);
-        const srcEntry = path3.join(pkgDir, target.entryRedirect.to);
-        if (fs3.existsSync(srcEntry)) {
+        const pkgDir = path4.dirname(target.srcPath);
+        const srcEntry = path4.join(pkgDir, target.entryRedirect.to);
+        if (fs4.existsSync(srcEntry)) {
           logger.info(
-            `Entry redirect: ${path3.basename(resolvedId)} -> ${target.entryRedirect.to}`
+            `Entry redirect: ${path4.basename(resolvedId)} -> ${target.entryRedirect.to}`
           );
           return srcEntry;
         }
@@ -288,7 +348,7 @@ function resolveEntryRedirect(resolvedId, opts, logger) {
           /\/dist\/app\.(mjs|js)$/,
           "/src/app.tsx"
         );
-        if (fs3.existsSync(srcEntry)) {
+        if (fs4.existsSync(srcEntry)) {
           logger.info(`Entry redirect (auto): dist/app -> src/app.tsx`);
           return srcEntry;
         }
@@ -299,11 +359,11 @@ function resolveEntryRedirect(resolvedId, opts, logger) {
 }
 
 // src/watcher.ts
-import path4 from "path";
+import path5 from "path";
 function setupWatcher(server, state, opts, logger) {
   let debounceTimer = null;
   const handleStructuralChange = (filePath) => {
-    const ext = path4.extname(filePath);
+    const ext = path5.extname(filePath);
     if (!opts.extensionSet.has(ext)) return;
     const normFile = normalizePath(filePath);
     const isOverrideFile = opts.overrideDirs.some(
@@ -369,14 +429,14 @@ function setupWatcher(server, state, opts, logger) {
   server.watcher.on("add", handleStructuralChange);
   server.watcher.on("unlink", handleStructuralChange);
   server.watcher.on("change", (filePath) => {
-    const ext = path4.extname(filePath);
+    const ext = path5.extname(filePath);
     if (!opts.extensionSet.has(ext)) return;
     const normFile = normalizePath(filePath);
     const isOverrideFile = opts.overrideDirs.some(
       (dir) => normFile.startsWith(normalizePath(dir) + "/")
     );
     if (!isOverrideFile) return;
-    const basename = stripExtension(path4.basename(filePath));
+    const basename = stripExtension(path5.basename(filePath));
     if (!basename) return;
     const isTrackedOverride = state.flatOverrides.has(basename) || [...state.namespacedOverrides.values()].some((m) => m.has(basename));
     if (!isTrackedOverride) return;
@@ -398,7 +458,7 @@ function setupWatcher(server, state, opts, logger) {
   });
   if (opts.patches.length > 0) {
     const handlePatchConfigStructural = (filePath) => {
-      const basename = stripExtension(path4.basename(filePath));
+      const basename = stripExtension(path5.basename(filePath));
       if (!basename) return;
       const normFile = normalizePath(filePath);
       const isOverrideFile = opts.overrideDirs.some(
@@ -446,7 +506,7 @@ function invalidatePatchTarget(patch, server, logger) {
     if (mod.file && patch.target.test(normalizePath(mod.file))) {
       moduleGraph.invalidateModule(mod, /* @__PURE__ */ new Set(), timestamp, true);
       roots.add(mod);
-      logger.info(`Invalidated patch target: ${path4.basename(mod.file)}`);
+      logger.info(`Invalidated patch target: ${path5.basename(mod.file)}`);
     }
   }
   const seen = /* @__PURE__ */ new Set();
@@ -555,6 +615,7 @@ function unlock(userOptions) {
       logger.info(`Patch: ${patch.configFile} (no config file found)`);
     }
   }
+  let hasExternalReactPlugin = false;
   return {
     name: PLUGIN_NAME,
     enforce: "pre",
@@ -563,7 +624,7 @@ function unlock(userOptions) {
       config.server.fs = config.server.fs || {};
       config.server.fs.allow = config.server.fs.allow || [];
       for (const dir of opts.overrideDirs) {
-        config.server.fs.allow.push(path5.resolve(dir));
+        config.server.fs.allow.push(path6.resolve(dir));
       }
       config.optimizeDeps = config.optimizeDeps || {};
       config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
@@ -575,6 +636,30 @@ function unlock(userOptions) {
           );
         }
       }
+      if (opts.autoOptimizeDeps) {
+        const autoDeps = [];
+        for (const target of opts.targets) {
+          const cjsDeps = collectCjsDeps(target.packageDir);
+          for (const dep of cjsDeps) {
+            if (opts.targets.some((t) => t.package === dep)) continue;
+            if (!autoDeps.includes(dep)) autoDeps.push(dep);
+          }
+        }
+        if (autoDeps.length > 0) {
+          config.optimizeDeps.include = config.optimizeDeps.include || [];
+          config.optimizeDeps.include.push(...autoDeps);
+          logger.info(
+            `Auto-included ${autoDeps.length} CJS deps for pre-bundling`
+          );
+        }
+      }
+      if (opts.optimizeDeps.include.length > 0) {
+        config.optimizeDeps.include = config.optimizeDeps.include || [];
+        config.optimizeDeps.include.push(...opts.optimizeDeps.include);
+      }
+      if (config.optimizeDeps.include) {
+        config.optimizeDeps.include = [...new Set(config.optimizeDeps.include)];
+      }
       config.resolve = config.resolve || {};
       config.resolve.alias = config.resolve.alias || {};
       for (const target of opts.targets) {
@@ -589,8 +674,8 @@ function unlock(userOptions) {
         }
       }
       for (const target of opts.targets) {
-        const entryFile = path5.join(target.srcPath, "app.tsx");
-        if (fs4.existsSync(entryFile)) {
+        const entryFile = path6.join(target.srcPath, "app.tsx");
+        if (fs5.existsSync(entryFile)) {
           const existing = config.optimizeDeps.entries;
           if (Array.isArray(existing)) {
             existing.push(entryFile);
@@ -602,24 +687,34 @@ function unlock(userOptions) {
         }
       }
     },
+    configResolved(resolvedConfig) {
+      hasExternalReactPlugin = resolvedConfig.plugins.some(
+        (p) => p.name === "vite:react-babel" || p.name === "vite:react-swc" || p.name === "vite:react-refresh"
+      );
+      if (hasExternalReactPlugin) {
+        logger.info(
+          "React plugin detected \u2014 handing over HMR to React Fast Refresh"
+        );
+      }
+    },
     async resolveId(source, importer) {
       if (source.startsWith("\0") || !importer || importer.startsWith("\0"))
         return null;
       const target = findImporterTarget(importer, opts);
       if (target) {
-        const basename = stripExtension(path5.basename(source));
+        const basename = stripExtension(path6.basename(source));
         if (basename && basename !== "index") {
           const nsOverrides = state.namespacedOverrides.get(target.package);
           if (nsOverrides?.has(basename)) {
             const p = nsOverrides.get(basename);
             logger.info(
-              `Override [${target.package}]: ${basename} -> ${path5.basename(p)}`
+              `Override [${target.package}]: ${basename} -> ${path6.basename(p)}`
             );
             return p;
           }
           if (state.flatOverrides.has(basename)) {
             const p = state.flatOverrides.get(basename);
-            logger.info(`Override: ${basename} -> ${path5.basename(p)}`);
+            logger.info(`Override: ${basename} -> ${path6.basename(p)}`);
             return p;
           }
         }
@@ -654,15 +749,15 @@ function unlock(userOptions) {
     load(id) {
       const target = findImporterTarget(id, opts);
       if (!target) return null;
-      const basename = stripExtension(path5.basename(id));
+      const basename = stripExtension(path6.basename(id));
       if (!basename || basename === "index") return null;
       const nsOverrides = state.namespacedOverrides.get(target.package);
       const overridePath = nsOverrides?.get(basename) ?? state.flatOverrides.get(basename);
-      if (overridePath && fs4.existsSync(overridePath)) {
+      if (overridePath && fs5.existsSync(overridePath)) {
         this.addWatchFile(overridePath);
         const normalizedPath = normalizePath(overridePath).replace(/"/g, '\\"');
         logger.info(
-          `Load override: ${basename} -> ${path5.basename(overridePath)}`
+          `Load override: ${basename} -> ${path6.basename(overridePath)}`
         );
         return `export { default } from "${normalizedPath}"
 export * from "${normalizedPath}"`;
@@ -670,18 +765,18 @@ export * from "${normalizedPath}"`;
       const normalizedId = normalizePath(id);
       for (const patch of opts.patches) {
         if (!patch.target.test(normalizedId)) continue;
-        if (!patch.configPath || !fs4.existsSync(patch.configPath)) continue;
+        if (!patch.configPath || !fs5.existsSync(patch.configPath)) continue;
         this.addWatchFile(patch.configPath);
         let original;
         try {
-          original = fs4.readFileSync(id, "utf-8");
+          original = fs5.readFileSync(id, "utf-8");
         } catch (err) {
           logger.error(`Failed to read file for patching: ${id}`);
           return null;
         }
         const patched = patch.apply(original, patch.configPath);
         logger.info(
-          `Patch applied: ${path5.basename(id)} via ${patch.configFile}`
+          `Patch applied: ${path6.basename(id)} via ${patch.configFile}`
         );
         return { code: patched, map: null };
       }
@@ -712,7 +807,7 @@ export * from "${normalizedPath}"`;
         }
         if (modified) return { code, map: null };
       }
-      if (opts.hmrBoundaries.length > 0) {
+      if (!hasExternalReactPlugin && opts.hmrBoundaries.length > 0) {
         const normId = normalizePath(id);
         if (!normId.includes("/node_modules/")) {
           const needsBoundary = opts.hmrBoundaries.some(
@@ -720,7 +815,7 @@ export * from "${normalizedPath}"`;
           );
           if (needsBoundary) {
             logger.info(
-              `HMR boundary injected: ${path5.basename(id)}`
+              `HMR boundary injected: ${path6.basename(id)}`
             );
             return {
               code: code + "\nif (import.meta.hot) { import.meta.hot.accept() }",
@@ -735,7 +830,7 @@ export * from "${normalizedPath}"`;
       const fsConfig = server.config.server?.fs;
       if (fsConfig && Array.isArray(fsConfig.allow)) {
         for (const dir of opts.overrideDirs) {
-          const resolved = path5.resolve(dir);
+          const resolved = path6.resolve(dir);
           if (!fsConfig.allow.includes(resolved)) {
             fsConfig.allow.push(resolved);
           }