@modern-js/app-tools 2.58.1-alpha.0 → 2.58.1-alpha.2

package/dist/cjs/plugins/deploy/dependencies/index.js

@@ -41,11 +41,13 @@ var import_nft = require("@vercel/nft");
 const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = import_utils2.traceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions = {
   cacheDir: ".modern-js/deploy",
   fileCache: true,
-  analysisCache: true
+  analysisCache: true,
+  symlinkCache: true
 }, traceOptions }) => {
   const base = "/";
   const startTime = Date.now();
   const entryFiles = await (0, import_utils2.findEntryFiles)(serverRootDir, entryFilter);
+  console.time("traceFiles");
   const fileTrace = await traceFiles({
     entryFiles: entryFiles.concat(includeEntries),
     serverRootDir,
@@ -56,6 +58,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
     base,
     traceOptions
   });
+  console.timeEnd("traceFiles");
   const currentProjectModules = import_node_path.default.join(appDir, "node_modules");
   const dependencySearchRoot = import_node_path.default.resolve(appDir, "../../../../../../");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -238,7 +241,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
   const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
   await import_utils.fs.writeJSON(outputPkgPath, finalPkgJson);
   const endTime = Date.now();
-  console.log("handleDependencies cost:", endTime - startTime);
+  console.log("handleDependencies cost:", `${endTime - startTime}ms`);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/plugins/deploy/dependencies/utils.js

@@ -145,6 +145,9 @@ async function serializeMap(map) {
     resolvedMap.set(key, value instanceof Promise ? await Promise.resolve(value) : value);
   }));
   return JSON.stringify(resolvedMap, (key, value) => {
+    if (value === null) {
+      return void 0;
+    }
     if (value instanceof Map) {
       return {
         dataType: "Map",
@@ -172,9 +175,10 @@ function deserializeMap(serializedData) {
   });
 }
 const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
-  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache } = cacheOptions;
+  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache, symlinkCache: enableSymlinkCache } = cacheOptions;
   const analysisCacheFile = import_path.default.join(cacheDir, "analysis-cache.json");
   const fileCacheFile = import_path.default.join(cacheDir, "file-cache.json");
+  const symlinkCacheFile = import_path.default.join(cacheDir, "symlink-cache.json");
   const cache = /* @__PURE__ */ Object.create(null);
   if (enableAnalysisCache && await import_utils.fs.pathExists(analysisCacheFile)) {
     const analysisCache2 = (await import_utils.fs.readFile(analysisCacheFile)).toString();
@@ -184,14 +188,18 @@ const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions,
     const fileCache2 = (await import_utils.fs.readFile(fileCacheFile)).toString();
     cache.fileCache = deserializeMap(fileCache2);
   }
+  if (enableSymlinkCache && await import_utils.fs.pathExists(symlinkCacheFile)) {
+    const symlinkCache2 = (await import_utils.fs.readFile(symlinkCacheFile)).toString();
+    cache.symlinkCache = deserializeMap(symlinkCache2);
+  }
   const res = await (0, import_nft.nodeFileTrace)(entryFiles, {
     base,
     processCwd: serverRootDir,
     cache,
     ...traceOptions
   });
-  const { analysisCache, fileCache } = cache;
-  if (analysisCache || fileCache) {
+  const { analysisCache, fileCache, symlinkCache } = cache;
+  if (analysisCache || fileCache || symlinkCache) {
     await import_utils.fs.ensureDir(cacheDir);
     if (analysisCache) {
       const newAnalysisCache = new Map(analysisCache);
@@ -200,7 +208,10 @@ const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions,
           newAnalysisCache.delete(key);
         }
       }
-      import_utils.fs.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
+      (async () => {
+        await import_utils.fs.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
+        console.log("write analysis cache finish");
+      })();
     }
     if (fileCache) {
       const newFileCache = new Map(fileCache);
@@ -209,9 +220,22 @@ const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions,
           newFileCache.delete(key);
         }
       }
-      console.time("111");
-      import_utils.fs.writeFile(fileCacheFile, await serializeMap(newFileCache));
-      console.timeEnd("111");
+      (async () => {
+        await import_utils.fs.writeFile(fileCacheFile, await serializeMap(newFileCache));
+        console.log("write file cache finish");
+      })();
+    }
+    if (symlinkCache) {
+      const newSymlinkCache = new Map(symlinkCache);
+      for (const key of newSymlinkCache.keys()) {
+        if (!key.includes("node_modules/")) {
+          newSymlinkCache.delete(key);
+        }
+      }
+      (async () => {
+        await import_utils.fs.writeFile(symlinkCacheFile, await serializeMap(newSymlinkCache));
+        console.log("write symlink cache finish");
+      })();
     }
   }
   console.log("ffffffff", __filename);

package/dist/esm/plugins/deploy/dependencies/index.js

@@ -20,7 +20,8 @@ var handleDependencies = function() {
           appDir = param.appDir, serverRootDir = param.serverRootDir, includeEntries = param.includeEntries, _param_traceFiles = param.traceFiles, traceFiles = _param_traceFiles === void 0 ? defaultTraceFiles : _param_traceFiles, entryFilter = param.entryFilter, modifyPackageJson = param.modifyPackageJson, copyWholePackage = param.copyWholePackage, _param_cacheOptions = param.cacheOptions, cacheOptions = _param_cacheOptions === void 0 ? {
             cacheDir: ".modern-js/deploy",
             fileCache: true,
-            analysisCache: true
+            analysisCache: true,
+            symlinkCache: true
           } : _param_cacheOptions, traceOptions = param.traceOptions;
           base = "/";
           startTime = Date.now();
@@ -30,6 +31,7 @@ var handleDependencies = function() {
           ];
         case 1:
           entryFiles = _state.sent();
+          console.time("traceFiles");
           return [
             4,
             traceFiles({
@@ -44,6 +46,7 @@ var handleDependencies = function() {
           ];
         case 2:
           fileTrace = _state.sent();
+          console.timeEnd("traceFiles");
           currentProjectModules = path.join(appDir, "node_modules");
           dependencySearchRoot = path.resolve(appDir, "../../../../../../");
           _ = Object.fromEntries;
@@ -609,7 +612,7 @@ var handleDependencies = function() {
         case 24:
           _state.sent();
           endTime = Date.now();
-          console.log("handleDependencies cost:", endTime - startTime);
+          console.log("handleDependencies cost:", "".concat(endTime - startTime, "ms"));
           return [
             2
           ];

package/dist/esm/plugins/deploy/dependencies/utils.js

@@ -415,6 +415,9 @@ function _serializeMap() {
           return [
             2,
             JSON.stringify(resolvedMap, function(key, value) {
+              if (value === null) {
+                return void 0;
+              }
               if (_instanceof(value, Map)) {
                 return {
                   dataType: "Map",
@@ -448,14 +451,15 @@ function deserializeMap(serializedData) {
 }
 var traceFiles = function() {
   var _ref = _async_to_generator(function(param) {
-    var entryFiles, serverRootDir, _param_base, base, cacheOptions, traceOptions, cacheDir, enableFileCache, enableAnalysisCache, analysisCacheFile, fileCacheFile, cache, _tmp, analysisCache, _tmp1, fileCache, res, analysisCache1, fileCache1, newAnalysisCache, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, _, _tmp2, newFileCache, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, key1, _1, _tmp3;
+    var entryFiles, serverRootDir, _param_base, base, cacheOptions, traceOptions, cacheDir, enableFileCache, enableAnalysisCache, enableSymlinkCache, analysisCacheFile, fileCacheFile, symlinkCacheFile, cache, _tmp, analysisCache, _tmp1, fileCache, _tmp2, symlinkCache, res, analysisCache1, fileCache1, symlinkCache1, newAnalysisCache, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, newFileCache, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, key1, newSymlinkCache, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, key2;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           entryFiles = param.entryFiles, serverRootDir = param.serverRootDir, _param_base = param.base, base = _param_base === void 0 ? "/" : _param_base, cacheOptions = param.cacheOptions, traceOptions = param.traceOptions;
-          cacheDir = cacheOptions.cacheDir, enableFileCache = cacheOptions.fileCache, enableAnalysisCache = cacheOptions.analysisCache;
+          cacheDir = cacheOptions.cacheDir, enableFileCache = cacheOptions.fileCache, enableAnalysisCache = cacheOptions.analysisCache, enableSymlinkCache = cacheOptions.symlinkCache;
           analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
           fileCacheFile = path.join(cacheDir, "file-cache.json");
+          symlinkCacheFile = path.join(cacheDir, "symlink-cache.json");
           cache = /* @__PURE__ */ Object.create(null);
           _tmp = enableAnalysisCache;
           if (!_tmp)
@@ -513,6 +517,34 @@ var traceFiles = function() {
           cache.fileCache = deserializeMap(fileCache);
           _state.label = 8;
         case 8:
+          _tmp2 = enableSymlinkCache;
+          if (!_tmp2)
+            return [
+              3,
+              10
+            ];
+          return [
+            4,
+            fse.pathExists(symlinkCacheFile)
+          ];
+        case 9:
+          _tmp2 = _state.sent();
+          _state.label = 10;
+        case 10:
+          if (!_tmp2)
+            return [
+              3,
+              12
+            ];
+          return [
+            4,
+            fse.readFile(symlinkCacheFile)
+          ];
+        case 11:
+          symlinkCache = _state.sent().toString();
+          cache.symlinkCache = deserializeMap(symlinkCache);
+          _state.label = 12;
+        case 12:
           return [
             4,
             nodeFileTrace(entryFiles, _object_spread({
@@ -521,106 +553,184 @@ var traceFiles = function() {
               cache
             }, traceOptions))
           ];
-        case 9:
+        case 13:
           res = _state.sent();
-          analysisCache1 = cache.analysisCache, fileCache1 = cache.fileCache;
-          if (!(analysisCache1 || fileCache1))
+          analysisCache1 = cache.analysisCache, fileCache1 = cache.fileCache, symlinkCache1 = cache.symlinkCache;
+          if (!(analysisCache1 || fileCache1 || symlinkCache1))
             return [
               3,
-              14
+              15
             ];
           return [
             4,
             fse.ensureDir(cacheDir)
           ];
-        case 10:
+        case 14:
           _state.sent();
-          if (!analysisCache1)
-            return [
-              3,
-              12
-            ];
-          newAnalysisCache = new Map(analysisCache1);
-          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-          try {
-            for (_iterator = newAnalysisCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-              key = _step.value;
-              if (!key.includes("node_modules/")) {
-                newAnalysisCache.delete(key);
-              }
-            }
-          } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-          } finally {
+          if (analysisCache1) {
+            newAnalysisCache = new Map(analysisCache1);
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
             try {
-              if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
+              for (_iterator = newAnalysisCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                key = _step.value;
+                if (!key.includes("node_modules/")) {
+                  newAnalysisCache.delete(key);
+                }
               }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
             } finally {
-              if (_didIteratorError) {
-                throw _iteratorError;
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
               }
             }
+            _async_to_generator(function() {
+              var _, _tmp3;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    _ = fse.writeFile;
+                    _tmp3 = [
+                      analysisCacheFile
+                    ];
+                    return [
+                      4,
+                      serializeMap(newAnalysisCache)
+                    ];
+                  case 1:
+                    return [
+                      4,
+                      _.apply(fse, _tmp3.concat([
+                        _state2.sent()
+                      ]))
+                    ];
+                  case 2:
+                    _state2.sent();
+                    console.log("write analysis cache finish");
+                    return [
+                      2
+                    ];
+                }
+              });
+            })();
           }
-          _ = fse.writeFile;
-          _tmp2 = [
-            analysisCacheFile
-          ];
-          return [
-            4,
-            serializeMap(newAnalysisCache)
-          ];
-        case 11:
-          _.apply(fse, _tmp2.concat([
-            _state.sent()
-          ]));
-          _state.label = 12;
-        case 12:
-          if (!fileCache1)
-            return [
-              3,
-              14
-            ];
-          newFileCache = new Map(fileCache1);
-          _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
-          try {
-            for (_iterator1 = newFileCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
-              key1 = _step1.value;
-              if (!key1.includes("node_modules/")) {
-                newFileCache.delete(key1);
+          if (fileCache1) {
+            newFileCache = new Map(fileCache1);
+            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+            try {
+              for (_iterator1 = newFileCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                key1 = _step1.value;
+                if (!key1.includes("node_modules/")) {
+                  newFileCache.delete(key1);
+                }
+              }
+            } catch (err) {
+              _didIteratorError1 = true;
+              _iteratorError1 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                  _iterator1.return();
+                }
+              } finally {
+                if (_didIteratorError1) {
+                  throw _iteratorError1;
+                }
               }
             }
-          } catch (err) {
-            _didIteratorError1 = true;
-            _iteratorError1 = err;
-          } finally {
+            _async_to_generator(function() {
+              var _, _tmp3;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    _ = fse.writeFile;
+                    _tmp3 = [
+                      fileCacheFile
+                    ];
+                    return [
+                      4,
+                      serializeMap(newFileCache)
+                    ];
+                  case 1:
+                    return [
+                      4,
+                      _.apply(fse, _tmp3.concat([
+                        _state2.sent()
+                      ]))
+                    ];
+                  case 2:
+                    _state2.sent();
+                    console.log("write file cache finish");
+                    return [
+                      2
+                    ];
+                }
+              });
+            })();
+          }
+          if (symlinkCache1) {
+            newSymlinkCache = new Map(symlinkCache1);
+            _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
             try {
-              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
+              for (_iterator2 = newSymlinkCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                key2 = _step2.value;
+                if (!key2.includes("node_modules/")) {
+                  newSymlinkCache.delete(key2);
+                }
               }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
             } finally {
-              if (_didIteratorError1) {
-                throw _iteratorError1;
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
               }
             }
+            _async_to_generator(function() {
+              var _, _tmp3;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    _ = fse.writeFile;
+                    _tmp3 = [
+                      symlinkCacheFile
+                    ];
+                    return [
+                      4,
+                      serializeMap(newSymlinkCache)
+                    ];
+                  case 1:
+                    return [
+                      4,
+                      _.apply(fse, _tmp3.concat([
+                        _state2.sent()
+                      ]))
+                    ];
+                  case 2:
+                    _state2.sent();
+                    console.log("write symlink cache finish");
+                    return [
+                      2
+                    ];
+                }
+              });
+            })();
           }
-          console.time("111");
-          _1 = fse.writeFile;
-          _tmp3 = [
-            fileCacheFile
-          ];
-          return [
-            4,
-            serializeMap(newFileCache)
-          ];
-        case 13:
-          _1.apply(fse, _tmp3.concat([
-            _state.sent()
-          ]));
-          console.timeEnd("111");
-          _state.label = 14;
-        case 14:
+          _state.label = 15;
+        case 15:
           console.log("ffffffff", __filename);
           return [
             2,

package/dist/esm-node/plugins/deploy/dependencies/index.js

@@ -7,11 +7,13 @@ import { nodeFileTrace } from "@vercel/nft";
 const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions = {
   cacheDir: ".modern-js/deploy",
   fileCache: true,
-  analysisCache: true
+  analysisCache: true,
+  symlinkCache: true
 }, traceOptions }) => {
   const base = "/";
   const startTime = Date.now();
   const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
+  console.time("traceFiles");
   const fileTrace = await traceFiles({
     entryFiles: entryFiles.concat(includeEntries),
     serverRootDir,
@@ -22,6 +24,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
     base,
     traceOptions
   });
+  console.timeEnd("traceFiles");
   const currentProjectModules = path.join(appDir, "node_modules");
   const dependencySearchRoot = path.resolve(appDir, "../../../../../../");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -204,7 +207,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
   const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
   await fse.writeJSON(outputPkgPath, finalPkgJson);
   const endTime = Date.now();
-  console.log("handleDependencies cost:", endTime - startTime);
+  console.log("handleDependencies cost:", `${endTime - startTime}ms`);
 };
 export {
   handleDependencies,

package/dist/esm-node/plugins/deploy/dependencies/utils.js

@@ -104,6 +104,9 @@ async function serializeMap(map) {
     resolvedMap.set(key, value instanceof Promise ? await Promise.resolve(value) : value);
   }));
   return JSON.stringify(resolvedMap, (key, value) => {
+    if (value === null) {
+      return void 0;
+    }
     if (value instanceof Map) {
       return {
         dataType: "Map",
@@ -131,9 +134,10 @@ function deserializeMap(serializedData) {
   });
 }
 const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
-  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache } = cacheOptions;
+  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache, symlinkCache: enableSymlinkCache } = cacheOptions;
   const analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
   const fileCacheFile = path.join(cacheDir, "file-cache.json");
+  const symlinkCacheFile = path.join(cacheDir, "symlink-cache.json");
   const cache = /* @__PURE__ */ Object.create(null);
   if (enableAnalysisCache && await fse.pathExists(analysisCacheFile)) {
     const analysisCache2 = (await fse.readFile(analysisCacheFile)).toString();
@@ -143,14 +147,18 @@ const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions,
     const fileCache2 = (await fse.readFile(fileCacheFile)).toString();
     cache.fileCache = deserializeMap(fileCache2);
   }
+  if (enableSymlinkCache && await fse.pathExists(symlinkCacheFile)) {
+    const symlinkCache2 = (await fse.readFile(symlinkCacheFile)).toString();
+    cache.symlinkCache = deserializeMap(symlinkCache2);
+  }
   const res = await nodeFileTrace(entryFiles, {
     base,
     processCwd: serverRootDir,
     cache,
     ...traceOptions
   });
-  const { analysisCache, fileCache } = cache;
-  if (analysisCache || fileCache) {
+  const { analysisCache, fileCache, symlinkCache } = cache;
+  if (analysisCache || fileCache || symlinkCache) {
     await fse.ensureDir(cacheDir);
     if (analysisCache) {
       const newAnalysisCache = new Map(analysisCache);
@@ -159,7 +167,10 @@ const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions,
           newAnalysisCache.delete(key);
         }
       }
-      fse.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
+      (async () => {
+        await fse.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
+        console.log("write analysis cache finish");
+      })();
     }
     if (fileCache) {
       const newFileCache = new Map(fileCache);
@@ -168,9 +179,22 @@ const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions,
           newFileCache.delete(key);
         }
       }
-      console.time("111");
-      fse.writeFile(fileCacheFile, await serializeMap(newFileCache));
-      console.timeEnd("111");
+      (async () => {
+        await fse.writeFile(fileCacheFile, await serializeMap(newFileCache));
+        console.log("write file cache finish");
+      })();
+    }
+    if (symlinkCache) {
+      const newSymlinkCache = new Map(symlinkCache);
+      for (const key of newSymlinkCache.keys()) {
+        if (!key.includes("node_modules/")) {
+          newSymlinkCache.delete(key);
+        }
+      }
+      (async () => {
+        await fse.writeFile(symlinkCacheFile, await serializeMap(newSymlinkCache));
+        console.log("write symlink cache finish");
+      })();
     }
   }
   console.log("ffffffff", __filename);

package/dist/types/plugins/deploy/dependencies/utils.d.ts

@@ -36,6 +36,7 @@ export declare const findPackageParents: (pkg: TracedPackage, version: string, t
 export interface CacheOptions {
     fileCache: boolean;
     analysisCache: boolean;
+    symlinkCache: boolean;
     cacheDir: string;
 }
 export declare const traceFiles: ({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.58.1-alpha.0",
+  "version": "2.58.1-alpha.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -92,16 +92,16 @@
     "@modern-js/core": "2.58.0",
     "@modern-js/node-bundle-require": "2.58.0",
     "@modern-js/plugin": "2.58.0",
+    "@modern-js/prod-server": "2.58.0",
     "@modern-js/plugin-i18n": "2.58.0",
     "@modern-js/plugin-lint": "2.58.0",
     "@modern-js/server-core": "2.58.0",
-    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
-    "@modern-js/types": "2.58.0",
     "@modern-js/server": "2.58.0",
-    "@modern-js/utils": "2.58.0",
-    "@modern-js/uni-builder": "2.58.0",
-    "@modern-js/prod-server": "2.58.0",
     "@modern-js/server-utils": "2.58.0",
+    "@modern-js/uni-builder": "2.58.0",
+    "@modern-js/types": "2.58.0",
+    "@modern-js/utils": "2.58.0",
+    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
     "@modern-js/plugin-data-loader": "2.58.0"
   },
   "devDependencies": {