@modern-js/server 2.14.0 → 2.15.1-alpha.0

package/dist/js/node/dev-tools/dev-middleware/socket-server.js

@@ -0,0 +1,159 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var socket_server_exports = {};
+__export(socket_server_exports, {
+  default: () => SocketServer
+});
+module.exports = __toCommonJS(socket_server_exports);
+var import_ws = __toESM(require("ws"));
+var import_utils = require("@modern-js/utils");
+class SocketServer {
+  constructor(options) {
+    this.sockets = [];
+    this.timer = null;
+    this.options = options;
+  }
+  prepare(app) {
+    var _a;
+    this.app = app;
+    this.wsServer = new import_ws.default.Server({
+      noServer: true,
+      path: (_a = this.options.client) == null ? void 0 : _a.path
+    });
+    this.app.on("upgrade", (req, sock, head) => {
+      if (!this.wsServer.shouldHandle(req)) {
+        return;
+      }
+      this.wsServer.handleUpgrade(req, sock, head, (connection) => {
+        this.wsServer.emit("connection", connection, req);
+      });
+    });
+    this.wsServer.on("error", (err) => {
+      import_utils.logger.error(err);
+    });
+    this.timer = setInterval(() => {
+      this.wsServer.clients.forEach((socket) => {
+        const extWs = socket;
+        if (!extWs.isAlive) {
+          extWs.terminate();
+        } else {
+          extWs.isAlive = false;
+          extWs.ping(() => {
+          });
+        }
+      });
+    }, 3e4);
+    this.wsServer.on("connection", (socket) => {
+      this.onConnect(socket);
+    });
+  }
+  updateStats(stats) {
+    this.stats = stats;
+    this.sendStats();
+  }
+  sockWrite(type, data) {
+    this.sockets.forEach((socket) => {
+      this.send(socket, JSON.stringify({ type, data }));
+    });
+  }
+  singleWrite(socket, type, data) {
+    this.send(socket, JSON.stringify({ type, data }));
+  }
+  close() {
+    this.sockets.forEach((socket) => {
+      socket.close();
+    });
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  onConnect(socket) {
+    const connection = socket;
+    connection.isAlive = true;
+    connection.on("pong", () => {
+      connection.isAlive = true;
+    });
+    if (!connection) {
+      return;
+    }
+    this.sockets.push(connection);
+    connection.on("close", () => {
+      const idx = this.sockets.indexOf(connection);
+      if (idx >= 0) {
+        this.sockets.splice(idx, 1);
+      }
+    });
+    if (this.options.hot || this.options.hot === "only") {
+      this.singleWrite(connection, "hot");
+    }
+    if (this.options.liveReload) {
+      this.singleWrite(connection, "liveReload");
+    }
+    if (this.stats) {
+      this.sendStats(true);
+    }
+  }
+  getStats() {
+    const curStats = this.stats;
+    if (!curStats) {
+      return null;
+    }
+    const defaultStats = {
+      all: false,
+      hash: true,
+      assets: true,
+      warnings: true,
+      errors: true,
+      errorDetails: false
+    };
+    return curStats.toJson(defaultStats);
+  }
+  sendStats(force = false) {
+    const stats = this.getStats();
+    if (!stats) {
+      return null;
+    }
+    const shouldEmit = !force && stats && (!stats.errors || stats.errors.length === 0) && stats.assets && stats.assets.every((asset) => !asset.emitted);
+    if (shouldEmit) {
+      return this.sockWrite("still-ok");
+    }
+    this.sockWrite("hash", stats.hash);
+    if (stats.errors && stats.errors.length > 0) {
+      return this.sockWrite("errors", stats.errors);
+    } else if (stats.warnings && stats.warnings.length > 0) {
+      return this.sockWrite("warnings", stats.warnings);
+    } else {
+      return this.sockWrite("ok");
+    }
+  }
+  send(connection, message) {
+    if (connection.readyState !== 1) {
+      return;
+    }
+    connection.send(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/dev-tools/https/index.js

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var https_exports = {};
+__export(https_exports, {
+  genHttpsOptions: () => genHttpsOptions
+});
+module.exports = __toCommonJS(https_exports);
+var import_utils = require("@modern-js/utils");
+const genHttpsOptions = (userOptions, pwd) => __async(void 0, null, function* () {
+  const httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
+  if (!httpsOptions.key || !httpsOptions.cert) {
+    let devcertPath;
+    try {
+      devcertPath = require.resolve("devcert", { paths: [pwd, __dirname] });
+    } catch (err) {
+      const packageManager = yield (0, import_utils.getPackageManager)(pwd);
+      const command = import_utils.chalk.yellow.bold(
+        `${packageManager} install devcert@1.2.2 -D`
+      );
+      import_utils.logger.error(
+        `You have enabled "dev.https" option, but the "devcert" package is not installed.`
+      );
+      import_utils.logger.error(
+        `Please run ${command} to install manually, otherwise the https can not work.`
+      );
+      throw new Error('[https] "devcert" is not found.');
+    }
+    const devcert = require(devcertPath);
+    const selfsign = yield devcert.certificateFor(["localhost"]);
+    return selfsign;
+  }
+  return httpsOptions;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genHttpsOptions
+});

package/dist/js/node/dev-tools/mock/getMockData.js

@@ -0,0 +1,135 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getMockData_exports = {};
+__export(getMockData_exports, {
+  default: () => getMockData_default,
+  getMatched: () => getMatched
+});
+module.exports = __toCommonJS(getMockData_exports);
+var import_utils = require("@modern-js/utils");
+var import_path_to_regexp = require("path-to-regexp");
+const VALID_METHODS = ["get", "post", "put", "delete", "patch"];
+const BODY_PARSED_METHODS = ["post", "put", "delete", "patch"];
+const createFunctionDataHandler = (method, handler) => (context, next) => __async(void 0, null, function* () {
+  const { req, res } = context;
+  return handler(req, res, next);
+});
+const createStaticDataHandler = (method, handler) => (context) => {
+  const { res } = context;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(handler));
+};
+const allowTypes = ["object", "function"];
+const normalizeConfig = (mockConfig) => Object.keys(mockConfig).reduce((acc, key) => {
+  const handler = mockConfig[key];
+  const type = typeof handler;
+  if (!allowTypes.includes(type)) {
+    throw new Error(
+      `mock value of ${key} should be object or function, but got ${type}`
+    );
+  }
+  const meta = parseKey(key);
+  if (type === "object") {
+    acc.push(__spreadProps(__spreadValues({}, meta), {
+      handler: createStaticDataHandler(meta.method, handler)
+    }));
+  } else {
+    acc.push(__spreadProps(__spreadValues({}, meta), {
+      handler: createFunctionDataHandler(meta.method, handler)
+    }));
+  }
+  return acc;
+}, []);
+const _blank = " ";
+const parseKey = (key) => {
+  const splitted = key.split(_blank).filter(Boolean);
+  if (splitted.length > 1) {
+    const [method, pathname] = splitted;
+    return {
+      method: method.toLowerCase(),
+      path: pathname
+    };
+  }
+  return {
+    method: "get",
+    path: key
+  };
+};
+var getMockData_default = (filepath) => {
+  const mockModule = (0, import_utils.compatRequire)(filepath);
+  if (!mockModule) {
+    throw new Error(`Mock file ${filepath} parsed failed!`);
+  }
+  const data = normalizeConfig(mockModule);
+  return data;
+};
+const getMatched = (context, mockApiList) => {
+  const { path: targetPathname, method: targetMethod } = context;
+  const matched = mockApiList.find((mockApi) => {
+    const { method, path: pathname } = mockApi;
+    if (method.toLowerCase() === targetMethod.toLowerCase()) {
+      return (0, import_path_to_regexp.match)(pathname, {
+        encode: encodeURI,
+        decode: decodeURIComponent
+      })(targetPathname);
+    }
+    return false;
+  });
+  return matched;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMatched
+});

package/dist/js/node/dev-tools/mock/index.js

@@ -0,0 +1,83 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var mock_exports = {};
+__export(mock_exports, {
+  createMockHandler: () => createMockHandler
+});
+module.exports = __toCommonJS(mock_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_prod_server = require("@modern-js/prod-server");
+var import_getMockData = __toESM(require("./getMockData"));
+const createMockHandler = ({ pwd }) => {
+  const exts = [".ts", ".js"];
+  let filepath = "";
+  for (const ext of exts) {
+    const maybeMatch = import_path.default.join(pwd, `${import_prod_server.AGGRED_DIR.mock}/index${ext}`);
+    if (import_utils.fs.existsSync(maybeMatch)) {
+      filepath = maybeMatch;
+      break;
+    }
+  }
+  if (!filepath) {
+    return null;
+  }
+  const apiList = (0, import_getMockData.default)(filepath);
+  if (!apiList || apiList.length === 0) {
+    return null;
+  }
+  return (context, next) => __async(void 0, null, function* () {
+    const { res } = context;
+    const matched = (0, import_getMockData.getMatched)(context, apiList);
+    if (!matched) {
+      return next();
+    }
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    return matched.handler(context, next);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMockHandler
+});

package/dist/js/node/dev-tools/register/index.js

@@ -0,0 +1,138 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var register_exports = {};
+__export(register_exports, {
+  enableRegister: () => enableRegister
+});
+module.exports = __toCommonJS(register_exports);
+var import_path = __toESM(require("path"));
+var import_server_utils = require("@modern-js/server-utils");
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("server");
+const checkDep = (depName, paths) => {
+  let packagePath = "";
+  try {
+    packagePath = require.resolve(depName, {
+      paths
+    });
+  } catch (error) {
+  }
+  return Boolean(packagePath);
+};
+const enableRegister = (projectRoot, config) => {
+  var _a, _b, _c;
+  const registerDirs = ["./api", "./server", "./config/mock", "./shared"];
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+  const tsconfigPath = import_path.default.resolve(projectRoot, TS_CONFIG_FILENAME);
+  const isTsProject = import_utils.fs.existsSync(tsconfigPath);
+  const existTsNode = checkDep("ts-node", [projectRoot]);
+  const existTsConfigPaths = checkDep("tsconfig-paths", [projectRoot]);
+  if (isTsProject && existTsNode && existTsConfigPaths) {
+    debug("use ts-node");
+    const distPath = ((_a = config.output.distPath) == null ? void 0 : _a.root) || "dist";
+    const tsNode = require("ts-node");
+    const tsConfigPaths = require("tsconfig-paths");
+    const { alias } = config.source;
+    const aliasConfig = (0, import_utils.getAliasConfig)(alias, {
+      appDirectory: projectRoot,
+      tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = "./" } = aliasConfig;
+    const tsPaths = Object.keys(paths).reduce((o, key) => {
+      let tsPath = paths[key];
+      if (typeof tsPath === "string" && import_path.default.isAbsolute(tsPath)) {
+        tsPath = import_path.default.relative(absoluteBaseUrl, tsPath);
+      }
+      if (typeof tsPath === "string") {
+        tsPath = [tsPath];
+      }
+      return __spreadProps(__spreadValues({}, o), {
+        [`${key}`]: tsPath
+      });
+    }, {});
+    tsConfigPaths.register({
+      baseUrl: absoluteBaseUrl || "./",
+      paths: tsPaths
+    });
+    tsNode.register({
+      project: tsconfigPath,
+      files: true,
+      transpileOnly: true,
+      ignore: ["(?:^|/)node_modules/", `(?:^|/)${distPath}/`]
+    });
+  } else {
+    debug("use @babel/register");
+    const babelConfig = (0, import_server_utils.resolveBabelConfig)(
+      projectRoot,
+      __spreadProps(__spreadValues({}, config.source), {
+        babelConfig: (_b = config.tools) == null ? void 0 : _b.babel,
+        server: {
+          compiler: (_c = config.server) == null ? void 0 : _c.compiler
+        }
+      }),
+      {
+        tsconfigPath,
+        syntax: "es6+",
+        type: "commonjs"
+      }
+    );
+    return require("@babel/register")(__spreadProps(__spreadValues({}, babelConfig), {
+      only: [
+        function(filePath) {
+          if (filePath.includes(`node_modules${import_path.default.sep}.modern-js`)) {
+            return true;
+          }
+          return registerDirs.some(
+            (registerDir) => filePath.startsWith(import_path.default.join(projectRoot, registerDir))
+          );
+        }
+      ],
+      extensions: [".js", ".ts"],
+      babelrc: false,
+      configFile: false,
+      root: projectRoot
+    }));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enableRegister
+});

package/dist/js/node/dev-tools/watcher/dependency-tree.js

@@ -0,0 +1,89 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dependency_tree_exports = {};
+__export(dependency_tree_exports, {
+  DependencyTree: () => DependencyTree,
+  defaultIgnores: () => defaultIgnores
+});
+module.exports = __toCommonJS(dependency_tree_exports);
+var import_minimatch = __toESM(require("minimatch"));
+const defaultIgnores = [
+  "**/bower_components/**",
+  "**/coverage/**",
+  "**/node_modules/**",
+  "**/.*/**",
+  "**/*.d.ts",
+  "**/*.log"
+];
+class DependencyTree {
+  constructor() {
+    this.tree = /* @__PURE__ */ new Map();
+    this.ignore = [...defaultIgnores];
+  }
+  getNode(path) {
+    return this.tree.get(path);
+  }
+  update(cache) {
+    this.tree.clear();
+    Object.keys(cache).forEach((path) => {
+      if (!this.shouldIgnore(path)) {
+        const module2 = cache[path];
+        this.tree.set(module2.filename, {
+          module: module2,
+          parent: /* @__PURE__ */ new Set(),
+          children: /* @__PURE__ */ new Set()
+        });
+      }
+    });
+    for (const treeNode of this.tree.values()) {
+      const { parent } = treeNode.module;
+      const { children } = treeNode.module;
+      if (parent && !this.shouldIgnore(parent.filename)) {
+        const parentTreeNode = this.tree.get(parent.filename);
+        if (parentTreeNode) {
+          treeNode.parent.add(parentTreeNode);
+        }
+      }
+      children.forEach((child) => {
+        if (!this.shouldIgnore(child.filename)) {
+          const childTreeNode = this.tree.get(child.filename);
+          if (childTreeNode) {
+            treeNode.children.add(childTreeNode);
+            childTreeNode.parent.add(treeNode);
+          }
+        }
+      });
+    }
+  }
+  shouldIgnore(path) {
+    return !path || Boolean(
+      this.ignore.find((rule) => import_minimatch.default.match([path], rule).length > 0)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DependencyTree,
+  defaultIgnores
+});