@modern-js/app-tools 2.49.3-alpha.9 → 2.49.4

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

@@ -1,725 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
-import path, { isAbsolute } from "node:path";
-import { nodeFileTrace, resolve } from "@vercel/nft";
-import { fs as fse, pkgUp, semver } from "@modern-js/utils";
-import { readPackageJSON } from "pkg-types";
-import { parseNodeModulePath } from "mlly";
-import { linkPackage, writePackage } from "./utils";
-var readDirRecursive = function() {
-  var _ref = _async_to_generator(function(dir) {
-    var files, filesAndDirs;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            fse.readdir(dir, {
-              withFileTypes: true
-            })
-          ];
-        case 1:
-          files = _state.sent();
-          return [
-            4,
-            Promise.all(files.map(function() {
-              var _ref2 = _async_to_generator(function(file) {
-                var resPath;
-                return _ts_generator(this, function(_state2) {
-                  resPath = path.resolve(dir, file.name);
-                  return [
-                    2,
-                    file.isDirectory() ? readDirRecursive(resPath) : resPath
-                  ];
-                });
-              });
-              return function(file) {
-                return _ref2.apply(this, arguments);
-              };
-            }()))
-          ];
-        case 2:
-          filesAndDirs = _state.sent();
-          return [
-            2,
-            filesAndDirs.flat()
-          ];
-      }
-    });
-  });
-  return function readDirRecursive2(dir) {
-    return _ref.apply(this, arguments);
-  };
-}();
-function isFile(file) {
-  return _isFile.apply(this, arguments);
-}
-function _isFile() {
-  _isFile = _async_to_generator(function(file) {
-    var stat, error;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          _state.trys.push([
-            0,
-            2,
-            ,
-            3
-          ]);
-          return [
-            4,
-            fse.stat(file)
-          ];
-        case 1:
-          stat = _state.sent();
-          return [
-            2,
-            stat.isFile()
-          ];
-        case 2:
-          error = _state.sent();
-          if (error.code === "ENOENT") {
-            return [
-              2,
-              false
-            ];
-          }
-          throw error;
-        case 3:
-          return [
-            2
-          ];
-      }
-    });
-  });
-  return _isFile.apply(this, arguments);
-}
-var findEntryFiles = function() {
-  var _ref = _async_to_generator(function(rootDir) {
-    var files;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            readDirRecursive(rootDir)
-          ];
-        case 1:
-          files = _state.sent();
-          return [
-            2,
-            files
-          ];
-      }
-    });
-  });
-  return function findEntryFiles2(rootDir) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var handleDependencies = function() {
-  var _ref = _async_to_generator(function(appDir, serverRootDir, include) {
-    var base, entryFiles, includeEntries, _fileTrace, currentProjectModules, _resolveTracedPath, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, err, findPackageParents, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, projectPkg, outputPkgPath;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          base = "/";
-          return [
-            4,
-            findEntryFiles(serverRootDir)
-          ];
-        case 1:
-          entryFiles = _state.sent();
-          includeEntries = include.map(function(item) {
-            if (isAbsolute(item)) {
-              return item;
-            }
-            try {
-              return require.resolve(item);
-            } catch (error) {
-            }
-            return item;
-          });
-          return [
-            4,
-            nodeFileTrace(entryFiles.concat(includeEntries), {
-              base,
-              processCwd: serverRootDir,
-              resolve: function() {
-                var _ref2 = _async_to_generator(function(id, parent, job, isCjs) {
-                  return _ts_generator(this, function(_state2) {
-                    if (id.startsWith("@modern-js/prod-server")) {
-                      return [
-                        2,
-                        require.resolve(id, {
-                          paths: [
-                            require.resolve("@modern-js/app-tools")
-                          ]
-                        })
-                      ];
-                    } else {
-                      return [
-                        2,
-                        resolve(id, parent, job, isCjs)
-                      ];
-                    }
-                    return [
-                      2
-                    ];
-                  });
-                });
-                return function(id, parent, job, isCjs) {
-                  return _ref2.apply(this, arguments);
-                };
-              }()
-            })
-          ];
-        case 2:
-          _fileTrace = _state.sent();
-          currentProjectModules = path.join(appDir, "node_modules");
-          _resolveTracedPath = function(p) {
-            return fse.realpath(path.resolve(base, p));
-          };
-          _ = Object.fromEntries;
-          return [
-            4,
-            Promise.all(_to_consumable_array(_fileTrace.reasons.entries()).map(function() {
-              var _ref2 = _async_to_generator(function(param) {
-                var _param, _path, reasons, filePath, baseDir, pkgName2, subpath, pkgPath, parsed, MODERN_UTILS_PATH, MODERN_UTILS_PATH_REGEX, match, packageJsonPath, _tmp, packageJson, parents, tracedFile2;
-                return _ts_generator(this, function(_state2) {
-                  switch (_state2.label) {
-                    case 0:
-                      _param = _sliced_to_array(param, 2), _path = _param[0], reasons = _param[1];
-                      if (reasons.ignored) {
-                        return [
-                          2
-                        ];
-                      }
-                      return [
-                        4,
-                        _resolveTracedPath(_path)
-                      ];
-                    case 1:
-                      filePath = _state2.sent();
-                      if (filePath.startsWith(serverRootDir) || filePath.startsWith(appDir) && !filePath.startsWith(currentProjectModules)) {
-                        return [
-                          2
-                        ];
-                      }
-                      return [
-                        4,
-                        isFile(filePath)
-                      ];
-                    case 2:
-                      if (!_state2.sent()) {
-                        return [
-                          2
-                        ];
-                      }
-                      if (!filePath.includes("node_modules"))
-                        return [
-                          3,
-                          3
-                        ];
-                      parsed = parseNodeModulePath(filePath);
-                      baseDir = parsed.dir;
-                      pkgName2 = parsed.name;
-                      subpath = parsed.subpath;
-                      pkgPath = path.join(baseDir, pkgName2);
-                      return [
-                        3,
-                        8
-                      ];
-                    case 3:
-                      MODERN_UTILS_PATH = "packages/toolkit/utils";
-                      MODERN_UTILS_PATH_REGEX = new RegExp("(.*".concat(MODERN_UTILS_PATH, ")"));
-                      match = filePath.match(MODERN_UTILS_PATH_REGEX);
-                      if (!match)
-                        return [
-                          3,
-                          4
-                        ];
-                      _tmp = path.join(match[0], "package.json");
-                      return [
-                        3,
-                        6
-                      ];
-                    case 4:
-                      return [
-                        4,
-                        pkgUp({
-                          cwd: path.dirname(filePath)
-                        })
-                      ];
-                    case 5:
-                      _tmp = _state2.sent();
-                      _state2.label = 6;
-                    case 6:
-                      packageJsonPath = _tmp;
-                      if (!packageJsonPath)
-                        return [
-                          3,
-                          8
-                        ];
-                      return [
-                        4,
-                        fse.readJSON(packageJsonPath)
-                      ];
-                    case 7:
-                      packageJson = _state2.sent();
-                      pkgPath = baseDir = path.dirname(packageJsonPath);
-                      subpath = path.relative(baseDir, filePath);
-                      pkgName2 = packageJson.name;
-                      _state2.label = 8;
-                    case 8:
-                      if (!baseDir) {
-                        return [
-                          2
-                        ];
-                      }
-                      return [
-                        4,
-                        Promise.all(_to_consumable_array(reasons.parents).map(function(p) {
-                          return _resolveTracedPath(p);
-                        }))
-                      ];
-                    case 9:
-                      parents = _state2.sent();
-                      tracedFile2 = {
-                        path: filePath,
-                        parents,
-                        subpath,
-                        pkgName: pkgName2,
-                        pkgPath
-                      };
-                      return [
-                        2,
-                        [
-                          filePath,
-                          tracedFile2
-                        ]
-                      ];
-                  }
-                });
-              });
-              return function(_2) {
-                return _ref2.apply(this, arguments);
-              };
-            }())).then(function(r) {
-              return r.filter(Boolean);
-            })
-          ];
-        case 3:
-          tracedFiles = _.apply(Object, [
-            _state.sent()
-          ]);
-          tracedPackages = {};
-          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-          _state.label = 4;
-        case 4:
-          _state.trys.push([
-            4,
-            9,
-            10,
-            11
-          ]);
-          _iterator = Object.values(tracedFiles)[Symbol.iterator]();
-          _state.label = 5;
-        case 5:
-          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
-            return [
-              3,
-              8
-            ];
-          tracedFile = _step.value;
-          pkgName = tracedFile.pkgName;
-          tracedPackage = tracedPackages[pkgName];
-          return [
-            4,
-            readPackageJSON(tracedFile.pkgPath, {
-              cache: true
-            }).catch(function() {
-            })
-          ];
-        case 6:
-          pkgJSON = _state.sent();
-          if (!pkgJSON) {
-            pkgJSON = {
-              name: pkgName,
-              version: "0.0.0"
-            };
-          }
-          if (!tracedPackage) {
-            tracedPackage = {
-              name: pkgName,
-              versions: {}
-            };
-            tracedPackages[pkgName] = tracedPackage;
-          }
-          tracedPackageVersion = tracedPackage.versions[pkgJSON.version];
-          if (!tracedPackageVersion) {
-            tracedPackageVersion = {
-              path: tracedFile.pkgPath,
-              files: [],
-              pkgJSON
-            };
-            tracedPackage.versions[pkgJSON.version] = tracedPackageVersion;
-          }
-          tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.path === tracedFile.pkgPath && tracedPackageVersion.files.push(tracedFile.path);
-          tracedFile.pkgName = pkgName;
-          tracedFile.pkgVersion = pkgJSON.version;
-          _state.label = 7;
-        case 7:
-          _iteratorNormalCompletion = true;
-          return [
-            3,
-            5
-          ];
-        case 8:
-          return [
-            3,
-            11
-          ];
-        case 9:
-          err = _state.sent();
-          _didIteratorError = true;
-          _iteratorError = err;
-          return [
-            3,
-            11
-          ];
-        case 10:
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-          return [
-            7
-          ];
-        case 11:
-          findPackageParents = function(pkg, version2) {
-            var versionFiles = pkg.versions[version2].files.map(function(path2) {
-              return tracedFiles[path2];
-            });
-            var parentPkgs = _to_consumable_array(new Set(versionFiles.flatMap(function(file) {
-              return file.parents.map(function(parentPath) {
-                var parentFile = tracedFiles[parentPath];
-                if (parentFile.pkgName === pkg.name) {
-                  return null;
-                }
-                return "".concat(parentFile.pkgName, "@").concat(parentFile.pkgVersion);
-              }).filter(Boolean);
-            })));
-            return parentPkgs;
-          };
-          multiVersionPkgs = {};
-          singleVersionPackages = [];
-          _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
-          try {
-            for (_iterator1 = Object.values(tracedPackages)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
-              tracedPackage1 = _step1.value;
-              versions = Object.keys(tracedPackage1.versions);
-              if (versions.length === 1) {
-                singleVersionPackages.push(tracedPackage1.name);
-                continue;
-              }
-              multiVersionPkgs[tracedPackage1.name] = {};
-              _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
-              try {
-                for (_iterator2 = versions[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-                  version = _step2.value;
-                  multiVersionPkgs[tracedPackage1.name][version] = findPackageParents(tracedPackage1, version);
-                }
-              } catch (err2) {
-                _didIteratorError2 = true;
-                _iteratorError2 = err2;
-              } finally {
-                try {
-                  if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                    _iterator2.return();
-                  }
-                } finally {
-                  if (_didIteratorError2) {
-                    throw _iteratorError2;
-                  }
-                }
-              }
-            }
-          } catch (err2) {
-            _didIteratorError1 = true;
-            _iteratorError1 = err2;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
-              }
-            } finally {
-              if (_didIteratorError1) {
-                throw _iteratorError1;
-              }
-            }
-          }
-          return [
-            4,
-            Promise.all(singleVersionPackages.map(function(pkgName2) {
-              var pkg = tracedPackages[pkgName2];
-              var version2 = Object.keys(pkg.versions)[0];
-              return writePackage(pkg, version2, serverRootDir);
-            }))
-          ];
-        case 12:
-          _state.sent();
-          console.log("multiVersionPkgs111111111", multiVersionPkgs);
-          _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = void 0;
-          _state.label = 13;
-        case 13:
-          _state.trys.push([
-            13,
-            18,
-            19,
-            20
-          ]);
-          _loop = function() {
-            var _step_value, pkgName2, pkgVersions, versionEntires, _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, _step_value1, version2, parentPkgs, pkg, pkgDestPath, _iteratorNormalCompletion12, _didIteratorError12, _iteratorError12, _iterator12, _step12, parentPkg, parentPkgName, err2, err2;
-            return _ts_generator(this, function(_state2) {
-              switch (_state2.label) {
-                case 0:
-                  _step_value = _sliced_to_array(_step3.value, 2), pkgName2 = _step_value[0], pkgVersions = _step_value[1];
-                  versionEntires = Object.entries(pkgVersions).sort(function(param, param1) {
-                    var _param = _sliced_to_array(param, 2), v1 = _param[0], p1 = _param[1], _param1 = _sliced_to_array(param1, 2), v2 = _param1[0], p2 = _param1[1];
-                    if (p1.length === 0) {
-                      return -1;
-                    }
-                    if (p2.length === 0) {
-                      return 1;
-                    }
-                    return semver.lt(v1, v2, {
-                      loose: true
-                    }) ? 1 : -1;
-                  });
-                  _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = void 0;
-                  _state2.label = 1;
-                case 1:
-                  _state2.trys.push([
-                    1,
-                    14,
-                    15,
-                    16
-                  ]);
-                  _iterator4 = versionEntires[Symbol.iterator]();
-                  _state2.label = 2;
-                case 2:
-                  if (!!(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done))
-                    return [
-                      3,
-                      13
-                    ];
-                  _step_value1 = _sliced_to_array(_step4.value, 2), version2 = _step_value1[0], parentPkgs = _step_value1[1];
-                  pkg = tracedPackages[pkgName2];
-                  pkgDestPath = ".modernjs/".concat(pkgName2, "@").concat(version2, "/node_modules/").concat(pkgName2);
-                  return [
-                    4,
-                    writePackage(pkg, version2, serverRootDir, pkgDestPath)
-                  ];
-                case 3:
-                  _state2.sent();
-                  return [
-                    4,
-                    linkPackage(pkgDestPath, "".concat(pkgName2), serverRootDir)
-                  ];
-                case 4:
-                  _state2.sent();
-                  _iteratorNormalCompletion12 = true, _didIteratorError12 = false, _iteratorError12 = void 0;
-                  _state2.label = 5;
-                case 5:
-                  _state2.trys.push([
-                    5,
-                    10,
-                    11,
-                    12
-                  ]);
-                  _iterator12 = parentPkgs[Symbol.iterator]();
-                  _state2.label = 6;
-                case 6:
-                  if (!!(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done))
-                    return [
-                      3,
-                      9
-                    ];
-                  parentPkg = _step12.value;
-                  parentPkgName = parentPkg.replace(/@[^@]+$/, "");
-                  return [
-                    4,
-                    multiVersionPkgs[parentPkgName] ? linkPackage(pkgDestPath, ".modernjs/".concat(parentPkg, "/node_modules/").concat(pkgName2), serverRootDir) : linkPackage(pkgDestPath, "".concat(parentPkgName, "/node_modules/").concat(pkgName2), serverRootDir)
-                  ];
-                case 7:
-                  _state2.sent();
-                  _state2.label = 8;
-                case 8:
-                  _iteratorNormalCompletion12 = true;
-                  return [
-                    3,
-                    6
-                  ];
-                case 9:
-                  return [
-                    3,
-                    12
-                  ];
-                case 10:
-                  err2 = _state2.sent();
-                  _didIteratorError12 = true;
-                  _iteratorError12 = err2;
-                  return [
-                    3,
-                    12
-                  ];
-                case 11:
-                  try {
-                    if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-                      _iterator12.return();
-                    }
-                  } finally {
-                    if (_didIteratorError12) {
-                      throw _iteratorError12;
-                    }
-                  }
-                  return [
-                    7
-                  ];
-                case 12:
-                  _iteratorNormalCompletion4 = true;
-                  return [
-                    3,
-                    2
-                  ];
-                case 13:
-                  return [
-                    3,
-                    16
-                  ];
-                case 14:
-                  err2 = _state2.sent();
-                  _didIteratorError4 = true;
-                  _iteratorError4 = err2;
-                  return [
-                    3,
-                    16
-                  ];
-                case 15:
-                  try {
-                    if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                      _iterator4.return();
-                    }
-                  } finally {
-                    if (_didIteratorError4) {
-                      throw _iteratorError4;
-                    }
-                  }
-                  return [
-                    7
-                  ];
-                case 16:
-                  return [
-                    2
-                  ];
-              }
-            });
-          };
-          _iterator3 = Object.entries(multiVersionPkgs)[Symbol.iterator]();
-          _state.label = 14;
-        case 14:
-          if (!!(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done))
-            return [
-              3,
-              17
-            ];
-          return [
-            5,
-            _ts_values(_loop())
-          ];
-        case 15:
-          _state.sent();
-          _state.label = 16;
-        case 16:
-          _iteratorNormalCompletion3 = true;
-          return [
-            3,
-            14
-          ];
-        case 17:
-          return [
-            3,
-            20
-          ];
-        case 18:
-          err = _state.sent();
-          _didIteratorError3 = true;
-          _iteratorError3 = err;
-          return [
-            3,
-            20
-          ];
-        case 19:
-          try {
-            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-              _iterator3.return();
-            }
-          } finally {
-            if (_didIteratorError3) {
-              throw _iteratorError3;
-            }
-          }
-          return [
-            7
-          ];
-        case 20:
-          return [
-            4,
-            readPackageJSON(serverRootDir).catch(function() {
-              return {};
-            })
-          ];
-        case 21:
-          projectPkg = _state.sent();
-          outputPkgPath = path.join(serverRootDir, "package.json");
-          return [
-            4,
-            fse.writeJSON(outputPkgPath, {
-              name: "".concat(projectPkg.name || "modernjs-project", "-prod"),
-              version: projectPkg.version || "0.0.0",
-              private: true,
-              dependencies: Object.fromEntries(_to_consumable_array(Object.values(tracedPackages).map(function(pkg) {
-                return [
-                  pkg.name,
-                  Object.keys(pkg.versions)[0]
-                ];
-              })).sort(function(param, param1) {
-                var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
-                return a.localeCompare(b);
-              }))
-            })
-          ];
-        case 22:
-          _state.sent();
-          return [
-            2
-          ];
-      }
-    });
-  });
-  return function handleDependencies2(appDir, serverRootDir, include) {
-    return _ref.apply(this, arguments);
-  };
-}();
-export {
-  handleDependencies
-};