@modern-js/app-tools 2.49.0 → 2.49.1-alpha.1

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

@@ -0,0 +1,726 @@
+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 } 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(
+                    // TODO: remove ts-ignore
+                    // @ts-expect-error
+                    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;
+                      }
+                    }
+                  );
+                  _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, "@").concat(version2), path.join(serverRootDir, "node_modules")) : linkPackage(pkgDestPath, "".concat(parentPkgName, "/node_modules/").concat(pkgName2, "@").concat(version2), path.join(serverRootDir, "node_modules"))
+                  ];
+                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
+};