@unlockable/vite-plugin-unlock 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -35,12 +35,12 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/plugin.ts
-var import_path5 = __toESM(require("path"), 1);
-var import_fs4 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
 
 // src/config.ts
-var import_path = __toESM(require("path"), 1);
-var import_fs = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 var import_module = require("module");
 
 // src/constants.ts
@@ -60,6 +60,8 @@ var MAX_SCAN_DEPTH = 20;
 var PLUGIN_NAME = "vite-plugin-unlock";
 
 // src/utils.ts
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
 var PREFIX = `[${PLUGIN_NAME}]`;
 function createLogger(debug) {
   return {
@@ -85,33 +87,85 @@ function generateAlias(packageName) {
   const lastPart = parts[parts.length - 1];
   return `~${lastPart}`;
 }
+function collectCjsDeps(packageDir) {
+  const pkgJsonPath = import_path.default.join(packageDir, "package.json");
+  if (!import_fs.default.existsSync(pkgJsonPath)) return [];
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(import_fs.default.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 = [
+      import_path.default.join(packageDir, "node_modules", ...depParts, "package.json"),
+      import_path.default.join(process.cwd(), "node_modules", ...depParts, "package.json")
+    ];
+    let depPkgJson = null;
+    for (const candidate of candidates) {
+      if (import_fs.default.existsSync(candidate)) {
+        try {
+          depPkgJson = JSON.parse(import_fs.default.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 exports2 = pkgJson.exports;
+  if (exports2 !== void 0) {
+    if (exports2 === null) return false;
+    if (typeof exports2 === "string") return true;
+    if (typeof exports2 === "object" && !Array.isArray(exports2)) {
+      return "." in exports2;
+    }
+    return Array.isArray(exports2);
+  }
+  if (pkgJson.main || pkgJson.module) return true;
+  return false;
+}
 
 // src/config.ts
 function findPackageSrcPath(packageName, srcDir) {
   const cwd = process.cwd();
   try {
-    const req = (0, import_module.createRequire)(import_path.default.join(cwd, "package.json"));
-    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
-    const pkgRoot = import_path.default.dirname(pkgJsonPath);
-    const srcPath = import_path.default.join(pkgRoot, srcDir);
-    if (import_fs.default.existsSync(srcPath)) return srcPath;
+    const req = (0, import_module.createRequire)(import_path2.default.join(cwd, "package.json"));
+    const pkgJsonPath = import_fs2.default.realpathSync(
+      req.resolve(`${packageName}/package.json`)
+    );
+    const pkgRoot = import_path2.default.dirname(pkgJsonPath);
+    const srcPath = import_path2.default.join(pkgRoot, srcDir);
+    if (import_fs2.default.existsSync(srcPath)) return srcPath;
     return pkgRoot;
   } catch {
   }
   const parts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
   const candidates = [
-    import_path.default.join(cwd, "node_modules", ...parts, srcDir),
-    import_path.default.join(cwd, ".yalc", ...parts, srcDir)
+    import_path2.default.join(cwd, "node_modules", ...parts, srcDir),
+    import_path2.default.join(cwd, ".yalc", ...parts, srcDir)
   ];
   for (const dir of candidates) {
-    if (import_fs.default.existsSync(dir)) return dir;
+    if (import_fs2.default.existsSync(dir)) return import_fs2.default.realpathSync(dir);
   }
   const rootCandidates = [
-    import_path.default.join(cwd, "node_modules", ...parts),
-    import_path.default.join(cwd, ".yalc", ...parts)
+    import_path2.default.join(cwd, "node_modules", ...parts),
+    import_path2.default.join(cwd, ".yalc", ...parts)
   ];
   for (const dir of rootCandidates) {
-    if (import_fs.default.existsSync(dir)) return dir;
+    if (import_fs2.default.existsSync(dir)) return import_fs2.default.realpathSync(dir);
   }
   return null;
 }
@@ -120,22 +174,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(import_path2.default.sep + target.srcDir) ? import_path2.default.resolve(srcPath, "..") : srcPath;
   if (target.entryRedirect && target.hmr) {
-    const pkgDir = import_path.default.dirname(srcPath);
-    const entryFile = import_path.default.resolve(pkgDir, target.entryRedirect.to);
-    if (import_fs.default.existsSync(entryFile)) {
+    const entryFile = import_path2.default.resolve(target.packageDir, target.entryRedirect.to);
+    if (import_fs2.default.existsSync(entryFile)) {
       target.entryFilePath = entryFile;
     }
   }
@@ -145,8 +201,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 = import_path.default.resolve(dir, `${basename}${ext}`);
-      if (import_fs.default.existsSync(p)) return p;
+      const p = import_path2.default.resolve(dir, `${basename}${ext}`);
+      if (import_fs2.default.existsSync(p)) return p;
     }
   }
   return null;
@@ -154,7 +210,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) => import_path.default.resolve(process.cwd(), dir));
+  const overrideDirs = (Array.isArray(overrideInput) ? overrideInput : [overrideInput]).map((dir) => import_path2.default.resolve(process.cwd(), dir));
   const targets = [];
   for (const input of options.targets) {
     const resolved = resolveTarget(input);
@@ -177,29 +233,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
-var import_path2 = __toESM(require("path"), 1);
-var import_fs2 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 function collectFiles(dir, extensionSet, depth = 0) {
   if (depth > MAX_SCAN_DEPTH) return [];
   const results = [];
   let entries;
   try {
-    entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_fs3.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const fullPath = import_path2.default.resolve(dir, entry.name);
+    const fullPath = import_path3.default.resolve(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectFiles(fullPath, extensionSet, depth + 1));
     } else if (entry.isFile()) {
-      const ext = import_path2.default.extname(entry.name);
+      const ext = import_path3.default.extname(entry.name);
       if (extensionSet.has(ext)) {
         results.push(fullPath);
       }
@@ -217,7 +277,7 @@ function getOverrideKey(filePath, baseDir, match) {
   if (match === "path") {
     const normalizedBase = normalizePath(baseDir);
     const relative = normalizePath(
-      import_path2.default.relative(normalizedBase, normalized)
+      import_path3.default.relative(normalizedBase, normalized)
     );
     return stripExtension(relative);
   }
@@ -248,7 +308,7 @@ function scanAllTargets(opts, logger) {
   return combined;
 }
 function detectNamespace(filePath, overrideDir) {
-  const relative = normalizePath(import_path2.default.relative(overrideDir, filePath));
+  const relative = normalizePath(import_path3.default.relative(overrideDir, filePath));
   const scopedMatch = relative.match(/^(@[^/]+\/[^/]+)\//);
   if (scopedMatch) return scopedMatch[1];
   return null;
@@ -258,13 +318,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 (!import_fs2.default.existsSync(dir)) continue;
+    if (!import_fs3.default.existsSync(dir)) continue;
     for (const fullPath of collectFiles(dir, opts.extensionSet).sort()) {
-      const relative = normalizePath(import_path2.default.relative(dir, fullPath));
+      const relative = normalizePath(import_path3.default.relative(dir, fullPath));
       if (relative.split("/").some((part) => part.startsWith("_"))) continue;
       const ns = detectNamespace(fullPath, dir);
       if (ns && targetPackages.has(ns)) {
-        const nsDir = import_path2.default.join(dir, ns);
+        const nsDir = import_path3.default.join(dir, ns);
         const key = getOverrideKey(fullPath, nsDir, opts.match);
         if (key && key !== "index") {
           if (!namespaced.has(ns)) namespaced.set(ns, /* @__PURE__ */ new Map());
@@ -284,8 +344,8 @@ function scanOverrides(opts, logger) {
 }
 
 // src/resolver.ts
-var import_path3 = __toESM(require("path"), 1);
-var import_fs3 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
 function findImporterTarget(importer, opts) {
   const norm = normalizePath(importer);
   for (const target of opts.targets) {
@@ -293,7 +353,7 @@ function findImporterTarget(importer, opts) {
     if (norm.startsWith(normSrc + "/") || norm === normSrc) {
       return target;
     }
-    const pkgDir = normalizePath(import_path3.default.dirname(target.srcPath));
+    const pkgDir = normalizePath(import_path4.default.dirname(target.srcPath));
     if (norm.startsWith(pkgDir + "/")) {
       return target;
     }
@@ -306,11 +366,11 @@ function resolveEntryRedirect(resolvedId, opts, logger) {
     if (target.entryRedirect) {
       const fromPattern = normalizePath(target.entryRedirect.from);
       if (norm.endsWith(`/${fromPattern}`) || norm.includes(`/${fromPattern}`)) {
-        const pkgDir = import_path3.default.dirname(target.srcPath);
-        const srcEntry = import_path3.default.join(pkgDir, target.entryRedirect.to);
-        if (import_fs3.default.existsSync(srcEntry)) {
+        const pkgDir = import_path4.default.dirname(target.srcPath);
+        const srcEntry = import_path4.default.join(pkgDir, target.entryRedirect.to);
+        if (import_fs4.default.existsSync(srcEntry)) {
           logger.info(
-            `Entry redirect: ${import_path3.default.basename(resolvedId)} -> ${target.entryRedirect.to}`
+            `Entry redirect: ${import_path4.default.basename(resolvedId)} -> ${target.entryRedirect.to}`
           );
           return srcEntry;
         }
@@ -324,7 +384,7 @@ function resolveEntryRedirect(resolvedId, opts, logger) {
           /\/dist\/app\.(mjs|js)$/,
           "/src/app.tsx"
         );
-        if (import_fs3.default.existsSync(srcEntry)) {
+        if (import_fs4.default.existsSync(srcEntry)) {
           logger.info(`Entry redirect (auto): dist/app -> src/app.tsx`);
           return srcEntry;
         }
@@ -335,11 +395,11 @@ function resolveEntryRedirect(resolvedId, opts, logger) {
 }
 
 // src/watcher.ts
-var import_path4 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 function setupWatcher(server, state, opts, logger) {
   let debounceTimer = null;
   const handleStructuralChange = (filePath) => {
-    const ext = import_path4.default.extname(filePath);
+    const ext = import_path5.default.extname(filePath);
     if (!opts.extensionSet.has(ext)) return;
     const normFile = normalizePath(filePath);
     const isOverrideFile = opts.overrideDirs.some(
@@ -405,14 +465,14 @@ function setupWatcher(server, state, opts, logger) {
   server.watcher.on("add", handleStructuralChange);
   server.watcher.on("unlink", handleStructuralChange);
   server.watcher.on("change", (filePath) => {
-    const ext = import_path4.default.extname(filePath);
+    const ext = import_path5.default.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(import_path4.default.basename(filePath));
+    const basename = stripExtension(import_path5.default.basename(filePath));
     if (!basename) return;
     const isTrackedOverride = state.flatOverrides.has(basename) || [...state.namespacedOverrides.values()].some((m) => m.has(basename));
     if (!isTrackedOverride) return;
@@ -434,7 +494,7 @@ function setupWatcher(server, state, opts, logger) {
   });
   if (opts.patches.length > 0) {
     const handlePatchConfigStructural = (filePath) => {
-      const basename = stripExtension(import_path4.default.basename(filePath));
+      const basename = stripExtension(import_path5.default.basename(filePath));
       if (!basename) return;
       const normFile = normalizePath(filePath);
       const isOverrideFile = opts.overrideDirs.some(
@@ -482,7 +542,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: ${import_path4.default.basename(mod.file)}`);
+      logger.info(`Invalidated patch target: ${import_path5.default.basename(mod.file)}`);
     }
   }
   const seen = /* @__PURE__ */ new Set();
@@ -591,6 +651,7 @@ function unlock(userOptions) {
       logger.info(`Patch: ${patch.configFile} (no config file found)`);
     }
   }
+  let hasExternalReactPlugin = false;
   return {
     name: PLUGIN_NAME,
     enforce: "pre",
@@ -599,7 +660,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(import_path5.default.resolve(dir));
+        config.server.fs.allow.push(import_path6.default.resolve(dir));
       }
       config.optimizeDeps = config.optimizeDeps || {};
       config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
@@ -611,6 +672,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) {
@@ -625,8 +710,8 @@ function unlock(userOptions) {
         }
       }
       for (const target of opts.targets) {
-        const entryFile = import_path5.default.join(target.srcPath, "app.tsx");
-        if (import_fs4.default.existsSync(entryFile)) {
+        const entryFile = import_path6.default.join(target.srcPath, "app.tsx");
+        if (import_fs5.default.existsSync(entryFile)) {
           const existing = config.optimizeDeps.entries;
           if (Array.isArray(existing)) {
             existing.push(entryFile);
@@ -638,24 +723,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(import_path5.default.basename(source));
+        const basename = stripExtension(import_path6.default.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} -> ${import_path5.default.basename(p)}`
+              `Override [${target.package}]: ${basename} -> ${import_path6.default.basename(p)}`
             );
             return p;
           }
           if (state.flatOverrides.has(basename)) {
             const p = state.flatOverrides.get(basename);
-            logger.info(`Override: ${basename} -> ${import_path5.default.basename(p)}`);
+            logger.info(`Override: ${basename} -> ${import_path6.default.basename(p)}`);
             return p;
           }
         }
@@ -690,15 +785,15 @@ function unlock(userOptions) {
     load(id) {
       const target = findImporterTarget(id, opts);
       if (!target) return null;
-      const basename = stripExtension(import_path5.default.basename(id));
+      const basename = stripExtension(import_path6.default.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 && import_fs4.default.existsSync(overridePath)) {
+      if (overridePath && import_fs5.default.existsSync(overridePath)) {
         this.addWatchFile(overridePath);
         const normalizedPath = normalizePath(overridePath).replace(/"/g, '\\"');
         logger.info(
-          `Load override: ${basename} -> ${import_path5.default.basename(overridePath)}`
+          `Load override: ${basename} -> ${import_path6.default.basename(overridePath)}`
         );
         return `export { default } from "${normalizedPath}"
 export * from "${normalizedPath}"`;
@@ -706,18 +801,18 @@ export * from "${normalizedPath}"`;
       const normalizedId = normalizePath(id);
       for (const patch of opts.patches) {
         if (!patch.target.test(normalizedId)) continue;
-        if (!patch.configPath || !import_fs4.default.existsSync(patch.configPath)) continue;
+        if (!patch.configPath || !import_fs5.default.existsSync(patch.configPath)) continue;
         this.addWatchFile(patch.configPath);
         let original;
         try {
-          original = import_fs4.default.readFileSync(id, "utf-8");
+          original = import_fs5.default.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: ${import_path5.default.basename(id)} via ${patch.configFile}`
+          `Patch applied: ${import_path6.default.basename(id)} via ${patch.configFile}`
         );
         return { code: patched, map: null };
       }
@@ -748,7 +843,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(
@@ -756,7 +851,7 @@ export * from "${normalizedPath}"`;
           );
           if (needsBoundary) {
             logger.info(
-              `HMR boundary injected: ${import_path5.default.basename(id)}`
+              `HMR boundary injected: ${import_path6.default.basename(id)}`
             );
             return {
               code: code + "\nif (import.meta.hot) { import.meta.hot.accept() }",
@@ -771,7 +866,7 @@ export * from "${normalizedPath}"`;
       const fsConfig = server.config.server?.fs;
       if (fsConfig && Array.isArray(fsConfig.allow)) {
         for (const dir of opts.overrideDirs) {
-          const resolved = import_path5.default.resolve(dir);
+          const resolved = import_path6.default.resolve(dir);
           if (!fsConfig.allow.includes(resolved)) {
             fsConfig.allow.push(resolved);
           }