js-code-detector 0.0.55 → 0.0.56

package/dist/cjs/index.d.ts

@@ -30,5 +30,5 @@ export { isRepoTypeSupported } from "./util/shared/getRepoSupportFlag";
 export declare function runDiffDetect(compareUrl?: string, token?: string): Promise<{
     error: Error | null;
     repoType: string;
-    effectedImportUsage: [string, string][];
+    effectedImportUsage: [string, string][] | never[];
 }>;

package/dist/cjs/services/DetectService.d.ts

@@ -32,6 +32,6 @@ export declare class DetectService {
     formatResult(): {
         error: Error | null;
         repoType: string;
-        effectedImportUsage: [string, string][];
+        effectedImportUsage: [string, string][] | never[];
     };
 }

package/dist/cjs/services/ProjectService.d.ts

@@ -1,5 +1,6 @@
 import { DetectService } from "./DetectService";
 import { formatGitDiffContent } from "../util/format_git_diff_content";
+import { RelateUsageOfExport } from "../util/ast_util/helper/findRelateUsageOfExport";
 export interface ProjectService {
     detectService: DetectService;
     gitDiffDetail: ReturnType<typeof formatGitDiffContent>;
@@ -10,6 +11,7 @@ export interface ProjectService {
     outputResult: {
         effectedImportUsage: [string, string][];
         error: Error | null;
+        relatedExportUsage: RelateUsageOfExport[];
     };
     run(): void;
 }

package/dist/cjs/services/projectServiceClass/UmiProjectService.js

@@ -40,6 +40,7 @@ var import_collectUpstreamFiles = __toESM(require("../../util/shared/collectUpst
 var import_createDependenceMap = require("../../util/report_util/createDependenceMap");
 var import_filterEffectedExportMember = __toESM(require("../../util/report_util/filterEffectedExportMember"));
 var import_constants = require("../../util/constants");
+var import_findRelateUsageOfExport = __toESM(require("../../util/ast_util/helper/findRelateUsageOfExport"));
 var UmiProjectService = class {
   constructor(detectService) {
     this.detectService = detectService;
@@ -49,6 +50,7 @@ var UmiProjectService = class {
       parsedAlias: {}
     };
     this.outputResult = {
+      relatedExportUsage: [],
       effectedImportUsage: [],
       error: null
     };
@@ -96,6 +98,8 @@ var UmiProjectService = class {
       return effectedExportNames.includes(value);
     });
     this.outputResult.effectedImportUsage = effectedImportUsage;
+    const effectedImportUsageUnique = [...new Set(effectedImportUsage.map((item) => item[0]))].map((importFileAndMember) => importFileAndMember.split("#"));
+    this.outputResult.relatedExportUsage = (0, import_findRelateUsageOfExport.default)(effectedImportUsageUnique, import2export, indirectExportMembers, absPathPrefix);
     const token = this.detectService.gitInfo.token;
     if (!token) {
       const pwd = (0, import_path.join)(this.detectService.directoryInfo.tmpWorkDir, "..");

package/dist/cjs/services/projectServiceClass/ViteProjectService.js

@@ -43,6 +43,7 @@ var import_createDependenceMap = require("../../util/report_util/createDependenc
 var import_filterEffectedExportMember = __toESM(require("../../util/report_util/filterEffectedExportMember"));
 var import_isVueEntryFile = __toESM(require("../../util/project_umi_util/isVueEntryFile"));
 var import_tsConfigPathsToWebpackAlias = require("../../util/project_umi_util/tsConfigPathsToWebpackAlias");
+var import_findRelateUsageOfExport = __toESM(require("../../util/ast_util/helper/findRelateUsageOfExport"));
 var ViteProjectService = class {
   constructor(detectService) {
     this.detectService = detectService;
@@ -52,6 +53,7 @@ var ViteProjectService = class {
       parsedAlias: {}
     };
     this.outputResult = {
+      relatedExportUsage: [],
       effectedImportUsage: [],
       error: null
     };
@@ -90,7 +92,7 @@ var ViteProjectService = class {
   }
   async readSrcDirFilesAndSetEntries() {
     const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
-    const projectFileList = (0, import_utils.readDirFiles)({ dir: (0, import_path.join)(targetDirPath, "src") }).filter((e) => e.filePath.endsWith(".ts") || e.filePath.endsWith(".js"));
+    const projectFileList = (0, import_utils.readDirFiles)({ dir: (0, import_path.join)(targetDirPath, "src") }).filter((e) => e.filePath.endsWith(".ts") && !e.filePath.endsWith(".d.ts") || e.filePath.endsWith(".js"));
     this.viteHelpInfo.entryFiles = projectFileList.filter((file) => (0, import_isVueEntryFile.default)(file.filePath)).map((e) => e.filePath);
   }
   async getMadgeResult() {
@@ -133,6 +135,8 @@ var ViteProjectService = class {
       return effectedExportNames.includes(value);
     });
     this.outputResult.effectedImportUsage = effectedImportUsage;
+    const effectedImportUsageUnique = [...new Set(effectedImportUsage.map((item) => item[0]))].map((importFileAndMember) => importFileAndMember.split("#"));
+    this.outputResult.relatedExportUsage = (0, import_findRelateUsageOfExport.default)(effectedImportUsageUnique, import2export, indirectExportMembers, absPathPrefix);
     const token = this.detectService.gitInfo.token;
     if (!token) {
       const pwd = (0, import_path.join)(this.detectService.directoryInfo.tmpWorkDir, "..");

package/dist/cjs/services/projectServiceClass/VueProjectService.js

@@ -42,6 +42,7 @@ var import_collectUpstreamFiles = __toESM(require("../../util/shared/collectUpst
 var import_createDependenceMap = require("../../util/report_util/createDependenceMap");
 var import_filterEffectedExportMember = __toESM(require("../../util/report_util/filterEffectedExportMember"));
 var import_await_to_js = __toESM(require("await-to-js"));
+var import_findRelateUsageOfExport = __toESM(require("../../util/ast_util/helper/findRelateUsageOfExport"));
 var VueProjectService = class {
   constructor(detectService) {
     this.detectService = detectService;
@@ -51,6 +52,7 @@ var VueProjectService = class {
       parsedAlias: {}
     };
     this.outputResult = {
+      relatedExportUsage: [],
       effectedImportUsage: [],
       error: null
     };
@@ -208,6 +210,8 @@ var VueProjectService = class {
       return effectedExportNames.includes(value);
     });
     this.outputResult.effectedImportUsage = effectedImportUsage;
+    const effectedImportUsageUnique = [...new Set(effectedImportUsage.map((item) => item[0]))].map((importFileAndMember) => importFileAndMember.split("#"));
+    this.outputResult.relatedExportUsage = (0, import_findRelateUsageOfExport.default)(effectedImportUsageUnique, import2export, indirectExportMembers, absPathPrefix);
     const token = this.detectService.gitInfo.token;
     if (!token) {
       const pwd = (0, import_path.join)(this.detectService.directoryInfo.tmpWorkDir, "..");

package/dist/cjs/util/ast_util/AstKit.js

@@ -70,8 +70,12 @@ var AstUtil = class {
     if (!node) {
       return;
     }
-    (0, import_syncTravel.default)(node, { filePath, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, visitedNodeSet, upstreamIdentifiers: [] }, () => {
-    });
+    try {
+      (0, import_syncTravel.default)(node, { filePath, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, visitedNodeSet, upstreamIdentifiers: [] }, () => {
+      });
+    } catch (e) {
+      console.log("syncTravel in " + filePath, e);
+    }
   }
 };
 AstUtil.EXPORT_DECLARATION_TYPES = import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES;

package/dist/cjs/util/ast_util/helper/convertAliasToLocal.d.ts

@@ -0,0 +1,3 @@
+export default function convertAliasToLocal(parsedAlias: Record<string, string>, systemAbsPathPrefix: string): {
+    [k: string]: string;
+};

package/dist/cjs/util/ast_util/helper/convertAliasToLocal.js

@@ -0,0 +1,27 @@
+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);
+
+// src/util/ast_util/helper/convertAliasToLocal.ts
+var convertAliasToLocal_exports = {};
+__export(convertAliasToLocal_exports, {
+  default: () => convertAliasToLocal
+});
+module.exports = __toCommonJS(convertAliasToLocal_exports);
+function convertAliasToLocal(parsedAlias, systemAbsPathPrefix) {
+  return Object.fromEntries(Object.entries(parsedAlias).map(([k, v]) => [k, v.startsWith(systemAbsPathPrefix) ? v.replace(systemAbsPathPrefix, "") : v]));
+}

package/dist/cjs/util/ast_util/helper/findImportUsageInExport.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export declare function findImportUsageInExport(programNode: AstNode | undefined, importedNames: string[]): (readonly [string, string[]])[];

package/dist/cjs/util/ast_util/helper/findImportUsageInExport.js

@@ -0,0 +1,119 @@
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/helper/findImportUsageInExport.ts
+var findImportUsageInExport_exports = {};
+__export(findImportUsageInExport_exports, {
+  findImportUsageInExport: () => findImportUsageInExport
+});
+module.exports = __toCommonJS(findImportUsageInExport_exports);
+var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+function findImportUsageInExport(programNode, importedNames) {
+  if (!programNode)
+    return [];
+  const importDeclarations = programNode._util.children.filter((node) => node.type === "ImportDeclaration");
+  const localIdentifiers = importDeclarations.map((node) => node.specifiers).flat().filter(Boolean).map((e) => e.local);
+  const targetSpecifiers = localIdentifiers.filter((item) => importedNames.includes(item.name));
+  return targetSpecifiers.map((item) => {
+    const members = wideDeepCollectNames([item]);
+    return [item.name, members];
+  });
+}
+function wideDeepCollectNames(nodes) {
+  const exportedNames = /* @__PURE__ */ new Set();
+  const identifierSet = /* @__PURE__ */ new Set();
+  const bodyMemberSet = /* @__PURE__ */ new Set();
+  const memberCallback = (n) => n && exportedNames.add(n);
+  wideHelper(nodes, bodyMemberSet, identifierSet, memberCallback);
+  return [...exportedNames];
+}
+function wideHelper(idNodes, bodyMemberSet, identifierSet, memberCallback) {
+  const identifierSetTmp = /* @__PURE__ */ new Set();
+  const bodyElements = idNodes.map((item) => [...item._util.provide].filter((e) => {
+    var _a;
+    return ((_a = e._util.parent) == null ? void 0 : _a.type) === "Program";
+  })).flat().filter((e) => !bodyMemberSet.has(e));
+  for (const node of bodyElements) {
+    bodyMemberSet.add(node);
+    collectIdentifiers(node, (id) => {
+      if (identifierSet.has(id) || !id)
+        return;
+      identifierSet.add(id);
+      identifierSetTmp.add(id);
+    });
+    collectExportIds(node, memberCallback, (id) => {
+      if (identifierSet.has(id) || !id)
+        return;
+      identifierSet.add(id);
+      identifierSetTmp.add(id);
+    });
+  }
+  if (identifierSetTmp.size) {
+    wideHelper([...identifierSetTmp], bodyMemberSet, identifierSet, memberCallback);
+  }
+}
+function collectIdentifiers(node, callback) {
+  if (node.type === "VariableDeclaration") {
+    const declarations = node.declarations;
+    for (const declaration of declarations) {
+      if (declaration.type === "VariableDeclarator") {
+        const id = declaration.id;
+        (0, import_deepSearchParamsIdentifier.default)(id, callback);
+      }
+    }
+  }
+  if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(node.type)) {
+    const id = node.id;
+    id && callback(id);
+  }
+}
+function collectExportIds(node, memberCallback, idCallback) {
+  var _a;
+  if (node.type === "ExportNamedDeclaration") {
+    const specifiers = node.specifiers;
+    for (const specifier of specifiers) {
+      if (specifier.type === "ExportSpecifier") {
+        memberCallback(specifier.local.name);
+      }
+    }
+    const declaration = node.declaration;
+    declaration && collectIdentifiers(declaration, (id) => {
+      idCallback(id);
+      memberCallback(id.name);
+    });
+  }
+  if (node.type === "ExportDefaultDeclaration") {
+    idCallback((_a = node.declaration) == null ? void 0 : _a.id);
+    memberCallback("default");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findImportUsageInExport
+});

package/dist/cjs/util/ast_util/helper/findRelateUsageOfExport.d.ts

@@ -0,0 +1,9 @@
+export type RelateUsageOfExport = {
+    filePath: string;
+    importMemberAndFile: {
+        fromFile: string;
+        localName: string;
+    }[];
+    exportMember: string;
+};
+export default function findRelateUsageOfExport(effectedImportUsage: [string, string][], import2export: Record<string, string>, indirectExportMembers: Record<string, string>, absPathPrefix: string): RelateUsageOfExport[];

package/dist/cjs/util/ast_util/helper/findRelateUsageOfExport.js

@@ -0,0 +1,76 @@
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/helper/findRelateUsageOfExport.ts
+var findRelateUsageOfExport_exports = {};
+__export(findRelateUsageOfExport_exports, {
+  default: () => findRelateUsageOfExport
+});
+module.exports = __toCommonJS(findRelateUsageOfExport_exports);
+var import_findImportUsageInExport = require("./findImportUsageInExport");
+var import_getAstKitByFilePath = __toESM(require("../getAstKitByFilePath"));
+function findRelateUsageOfExport(effectedImportUsage, import2export, indirectExportMembers, absPathPrefix) {
+  const result = [];
+  const ignoreList = [];
+  findRelateUsageOfExportHelper(effectedImportUsage, import2export, indirectExportMembers, absPathPrefix, result, ignoreList);
+  return result;
+}
+function findRelateUsageOfExportHelper(effectedImportUsage, import2export, indirectExportMembers, absPathPrefix, result, ignoreList, count = 0) {
+  const mapFileToImportMembers = effectedImportUsage.reduce((acc, [file, member]) => {
+    acc[file] = acc[file] || [];
+    acc[file].push(member);
+    return acc;
+  }, {});
+  const effectedExportUsage = Object.entries(mapFileToImportMembers).map(([filePath, members]) => {
+    const astKit = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
+    const programNode = astKit.mapUuidToNode.get("Program");
+    if (!programNode)
+      return [];
+    const list = (0, import_findImportUsageInExport.findImportUsageInExport)(programNode, members).map(([, exportMembers]) => exportMembers).flat();
+    result.push(...list.map((exportMember) => {
+      const importMemberAndFile = members.map((member) => {
+        var _a;
+        const fromFile = (_a = import2export[`${filePath}#${member}`]) == null ? void 0 : _a.split("#")[0];
+        return { fromFile, localName: member };
+      });
+      return { filePath, importMemberAndFile, exportMember };
+    }));
+    return list.map((item) => [filePath, item]);
+  }).flat();
+  const effectedExportUsageFileAndMember = effectedExportUsage.map(([f, m]) => `${f}#${m}`);
+  const effectedImportUsageList = [...Object.entries(import2export), ...Object.entries(indirectExportMembers)].filter(([, exportFileAndMember]) => {
+    return effectedExportUsageFileAndMember.includes(exportFileAndMember);
+  }).map(([_]) => _);
+  ignoreList.push(...effectedImportUsageList);
+  if (count > 10 || !effectedImportUsageList.length) {
+    console.log("findRelateUsageOfExportHelper", count, effectedImportUsageList);
+    return;
+  }
+  ;
+  findRelateUsageOfExportHelper(effectedImportUsageList.map((e) => e.split("#")), import2export, indirectExportMembers, absPathPrefix, result, ignoreList, count + 1);
+}

package/dist/cjs/util/ast_util/helper/getEffectedExportMembersOfLineRange.d.ts

@@ -0,0 +1,2 @@
+import { AstNode } from "../AstUtil";
+export default function getEffectedExportMembersOfLineRange(mapFileLineToNodeSet: Map<number, Set<AstNode>>, startLine: number, endLine: number, filePath: string): string[];

package/dist/cjs/util/ast_util/helper/getEffectedExportMembersOfLineRange.js

@@ -0,0 +1,124 @@
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/ast_util/helper/getEffectedExportMembersOfLineRange.ts
+var getEffectedExportMembersOfLineRange_exports = {};
+__export(getEffectedExportMembersOfLineRange_exports, {
+  default: () => getEffectedExportMembersOfLineRange
+});
+module.exports = __toCommonJS(getEffectedExportMembersOfLineRange_exports);
+var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
+var import_SHARED_CONSTANTS = require("../SHARED_CONSTANTS");
+var import_collectVariableDeclarationIdentifiers = __toESM(require("./collectVariableDeclarationIdentifiers"));
+function getEffectedExportMembersOfLineRange(mapFileLineToNodeSet, startLine, endLine, filePath) {
+  var _a;
+  const effectedExportMembers = /* @__PURE__ */ new Set();
+  const identifiers = /* @__PURE__ */ new Set();
+  const callback = (identifier) => identifiers.add(identifier);
+  const programChildSet = /* @__PURE__ */ new Set();
+  for (let i = startLine; i <= endLine; i++) {
+    const nodes = mapFileLineToNodeSet.get(i);
+    if (!nodes)
+      continue;
+    for (const node of nodes) {
+      const ancestors = node._util.ancestors;
+      const programChild = ancestors.find((ancestor) => {
+        var _a2;
+        return ((_a2 = ancestor._util.parent) == null ? void 0 : _a2.type) === "Program";
+      });
+      if (programChild)
+        programChildSet.add(programChild);
+    }
+  }
+  for (const programChild of programChildSet) {
+    const { type, _util } = programChild;
+    if (type === "VariableDeclaration") {
+      Array.from(new Set(programChild.declarations)).forEach((declaration) => {
+        const id = declaration.id;
+        if (id) {
+          (0, import_deepSearchParamsIdentifier.default)(id, callback);
+        }
+      });
+    }
+    if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(programChild.type)) {
+      const id = programChild.id;
+      if (id) {
+        callback(id);
+      }
+    }
+  }
+  for (const identifier of identifiers) {
+    const { _util } = identifier;
+    const { occupation } = _util;
+    for (const occ of occupation) {
+      const programElement = occ._util.ancestors.find((ancestor) => {
+        var _a2;
+        return ((_a2 = ancestor._util.parent) == null ? void 0 : _a2.type) === "Program";
+      });
+      if (programElement) {
+        programChildSet.add(programElement);
+      }
+    }
+  }
+  for (const programChild of programChildSet) {
+    const { type, specifiers, declaration } = programChild;
+    if (type === "ExportDefaultDeclaration") {
+      effectedExportMembers.add("default");
+    }
+    if (type === "ExportNamedDeclaration") {
+      Array.isArray(specifiers) && specifiers.forEach((specifier) => {
+        const { exported } = specifier;
+        if (exported) {
+          effectedExportMembers.add(exported.name);
+        }
+      });
+    }
+    if (type === "ExportNamedDeclaration" && import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(declaration == null ? void 0 : declaration.type)) {
+      const idName = (_a = declaration.id) == null ? void 0 : _a.name;
+      if (idName) {
+        effectedExportMembers.add(idName);
+      }
+    }
+    if (type === "ExportNamedDeclaration" && Array.isArray(declaration == null ? void 0 : declaration.declarations)) {
+      declaration == null ? void 0 : declaration.declarations.forEach((dec) => {
+        (0, import_collectVariableDeclarationIdentifiers.default)(dec, (identifier) => {
+          try {
+            const idName = identifier.name;
+            typeof idName === "string" && effectedExportMembers.add(idName);
+          } catch (e) {
+            console.log("getEffectedExportMembersOfLineRange", e.message);
+          }
+        });
+      });
+    }
+  }
+  if (effectedExportMembers.size === 0 && filePath.endsWith(".vue")) {
+    effectedExportMembers.add("default");
+  }
+  return Array.from(effectedExportMembers);
+}

package/dist/cjs/util/ast_util/helper/getExportedNameOfAncestor.js

@@ -37,7 +37,7 @@ var import_getExportedNameOfDeclarationIdentifier = __toESM(require("./getExport
 var import_collectVariableDeclarationIdentifiers = __toESM(require("./collectVariableDeclarationIdentifiers"));
 var import_deepSearchParamsIdentifier = __toESM(require("./deepSearchParamsIdentifier"));
 function getExportedNameOfAncestor(node) {
-  var _a, _b;
+  var _a, _b, _c;
   if (!node) {
     console.warn("获取 上级导出成员名字报错: node is null");
     return [];
@@ -61,7 +61,7 @@ function getExportedNameOfAncestor(node) {
       if (ancestor.type === "ExportNamedDeclaration") {
         const declarationType = (_a = ancestor.declaration) == null ? void 0 : _a.type;
         if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(declarationType)) {
-          const nameToAdd = ancestor.declaration.id.name;
+          const nameToAdd = (_b = ancestor.declaration.id) == null ? void 0 : _b.name;
           if (nameToAdd) {
             nameList.add(nameToAdd);
           }
@@ -84,7 +84,7 @@ function getExportedNameOfAncestor(node) {
         }
         break outer;
       }
-      if (["FunctionDeclaration", "ClassDeclaration"].includes(ancestor.type) && "Program" === ((_b = ancestor._util.parent) == null ? void 0 : _b.type)) {
+      if (["FunctionDeclaration", "ClassDeclaration"].includes(ancestor.type) && "Program" === ((_c = ancestor._util.parent) == null ? void 0 : _c.type)) {
         const ancestorId = ancestor.id;
         if (ancestorId) {
           const nameToAdd = (0, import_getExportedNameOfDeclarationIdentifier.default)(ancestorId);

package/dist/cjs/util/ast_util/helper/syncTravel.js

@@ -73,7 +73,8 @@ function wideTravel(wideTravelNodeList, extra, travelFn) {
           parent: wideTravelNode,
           parentProperty: childKey,
           indexOfProperty: null,
-          ancestors: [...wideTravelNode._util.ancestors, wideTravelNode]
+          ancestors: [...wideTravelNode._util.ancestors, wideTravelNode],
+          ...childValue._util
         });
         childrenOfChild.push(childValue);
         wideTravelNodes.push(childValue);
@@ -87,7 +88,8 @@ function wideTravel(wideTravelNodeList, extra, travelFn) {
             parent: wideTravelNode,
             parentProperty: childKey,
             indexOfProperty: index,
-            ancestors: [...wideTravelNode._util.ancestors, wideTravelNode]
+            ancestors: [...wideTravelNode._util.ancestors, wideTravelNode],
+            ...childInArray._util
           });
           childrenOfChild.push(childInArray);
           wideTravelNodes.push(childInArray);
@@ -95,14 +97,17 @@ function wideTravel(wideTravelNodeList, extra, travelFn) {
       }
     });
   }
-  const { hoistedNodeList, exportDeclarations, notHoistedNodes } = resortNodes(wideTravelNodes);
+  const { hoistedNodeList, notHoistedNodes } = resortNodes(wideTravelNodes);
   const holdingIdentifiers = [...extra.upstreamIdentifiers];
-  for (const ele of [...hoistedNodeList, ...exportDeclarations]) {
-    collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations);
+  const importIdentifiers = /* @__PURE__ */ new Set();
+  for (const ele of hoistedNodeList) {
+    collectHoldingIdentifiers(ele, (identifier) => {
+      holdingIdentifiers.push(identifier);
+    }, (identifier) => importIdentifiers.add(identifier));
   }
   for (const ele of wideTravelNodes) {
     if (notHoistedNodes.includes(ele)) {
-      collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations);
+      collectHoldingIdentifiers(ele, (identifier) => holdingIdentifiers.push(identifier), (identifier) => void 0);
     }
     const mergedExtra = { ...extra, upstreamIdentifiers: [...holdingIdentifiers] };
     const holdingIdentifierSet = new Set(holdingIdentifiers);
@@ -120,11 +125,23 @@ function wideTravel(wideTravelNodeList, extra, travelFn) {
     }
     addIdentifiersToAncestors([ele], ele._util.ancestors);
   }
+  importIdentifiers.forEach((identifier) => {
+    identifier._util.holdingIdType = "Import";
+  });
 }
 function deepTravel(deepTravelNode, extra, travelFn) {
   const { upstreamIdentifiers } = extra;
   const holdingIdentifiers = [...upstreamIdentifiers];
-  collectParamsIdentifier(deepTravelNode, holdingIdentifiers);
+  const paramIdentifierSet = /* @__PURE__ */ new Set();
+  if (import_SHARED_CONSTANTS.FUNCTION_TYPES.includes(deepTravelNode.type)) {
+    const params = deepTravelNode.params;
+    Array.isArray(params) && params.forEach((param) => {
+      (0, import_deepSearchParamsIdentifier.default)(param, (identifier) => {
+        holdingIdentifiers.push(identifier);
+        paramIdentifierSet.add(identifier);
+      });
+    });
+  }
   updateVariableScopeAndOccupation(deepTravelNode, holdingIdentifiers);
   const { visitedNodeSet, filePath } = extra;
   const { children } = deepTravelNode._util;
@@ -143,7 +160,8 @@ function deepTravel(deepTravelNode, extra, travelFn) {
       visitedNodeSet.add(childValue);
       childValue._util = (0, import_createAstNodeExt.default)({
         indexOfProperty: null,
-        ...commonNodeExt
+        ...commonNodeExt,
+        ...childValue._util
       });
       children.push(childValue);
     } else if ((0, import_isValidArrayNodeCollect.default)(childValue)) {
@@ -153,14 +171,14 @@ function deepTravel(deepTravelNode, extra, travelFn) {
         visitedNodeSet.add(childInArray);
         childInArray._util = (0, import_createAstNodeExt.default)({
           indexOfProperty: index,
-          ...commonNodeExt
+          ...commonNodeExt,
+          ...childInArray._util
         });
         children.push(childInArray);
       });
     }
   });
   const mergedExtra = { ...extra, upstreamIdentifiers: holdingIdentifiers };
-  travelFn(deepTravelNode);
   for (const child of children) {
     if (shouldWideTravel(child)) {
       wideTravel([child], mergedExtra, travelFn);
@@ -175,11 +193,22 @@ function deepTravel(deepTravelNode, extra, travelFn) {
     }
     addIdentifiersToAncestors([child], ancestors);
   }
+  paramIdentifierSet.forEach((paramIdentifier) => {
+    paramIdentifier._util.holdingIdType = "Param";
+  });
+  const injectSet = new Set([...deepTravelNode._util.dependenceIds].filter((e) => isValidIdentifierOrJSXIdentifier(e)).map((e) => e._util.variableScope[0]).filter(Boolean).filter((e) => upstreamIdentifiers.includes(e)));
+  deepTravelNode._util.inject = injectSet;
+  for (const injectNode of injectSet) {
+    if (!injectNode._util) {
+      injectNode._util = { provide: /* @__PURE__ */ new Set() };
+    }
+    injectNode._util.provide.add(deepTravelNode);
+  }
+  travelFn(deepTravelNode);
 }
 function resortNodes(nodes) {
   var _a, _b;
   const hoistedNodeList = [];
-  const exportDeclarations = [];
   for (const astNode of nodes) {
     if (["ImportDeclaration", "FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration"].includes(astNode.type)) {
       hoistedNodeList.push(astNode);
@@ -188,14 +217,13 @@ function resortNodes(nodes) {
       const decType = (_a = astNode.declaration) == null ? void 0 : _a.type;
       const decId = (_b = astNode.declaration) == null ? void 0 : _b.id;
       if (["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration"].includes(decType) && decId) {
-        exportDeclarations.push(astNode);
+        hoistedNodeList.push(astNode);
       }
     }
   }
-  const notHoistedNodes = nodes.filter((node) => ![...hoistedNodeList, ...exportDeclarations].includes(node));
+  const notHoistedNodes = nodes.filter((node) => !hoistedNodeList.includes(node));
   return {
     hoistedNodeList,
-    exportDeclarations,
     notHoistedNodes
   };
 }
@@ -212,47 +240,33 @@ function updateHoldingIdMap(holdingIdentifiers, holdingIdNameMap) {
     holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
   });
 }
-function collectParamsIdentifier(deepTravelNode, holdingIdentifiers) {
-  if (import_SHARED_CONSTANTS.FUNCTION_TYPES.includes(deepTravelNode.type)) {
-    const params = deepTravelNode.params;
-    Array.isArray(params) && params.forEach((param) => {
-      (0, import_deepSearchParamsIdentifier.default)(param, (identifier) => {
-        holdingIdentifiers.push(identifier);
-      });
-    });
-  }
-}
-function collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations) {
-  var _a, _b, _c;
+function collectHoldingIdentifiers(ele, callback, importCallback) {
+  var _a, _b;
   if (ele.type === "ImportDeclaration") {
     const specifiers = ele.specifiers;
     for (const specifier of specifiers) {
-      holdingIdentifiers.push(specifier.local);
+      const local = specifier.local;
+      callback(local);
+      importCallback(local);
     }
   }
   if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes(ele.type)) {
     const id = ele.id;
     if (id) {
-      holdingIdentifiers.push(id);
+      callback(id);
     }
   }
   if (import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES.includes((_a = ele.declaration) == null ? void 0 : _a.type)) {
     const id = (_b = ele.declaration) == null ? void 0 : _b.id;
     if (id) {
-      holdingIdentifiers.push(id);
-    }
-  }
-  if (exportDeclarations.includes(ele)) {
-    const id = (_c = ele == null ? void 0 : ele.declaration) == null ? void 0 : _c.id;
-    if (id) {
-      holdingIdentifiers.push(id);
+      callback(id);
     }
   }
   if (ele.type === "VariableDeclaration") {
     Array.from(new Set(ele.declarations)).forEach((declaration) => {
       const id = declaration.id;
       if (id) {
-        (0, import_deepSearchParamsIdentifier.default)(id, (identifier) => holdingIdentifiers.push(identifier));
+        (0, import_deepSearchParamsIdentifier.default)(id, callback);
       }
     });
   }
@@ -260,7 +274,7 @@ function collectHoldingIdentifiers(ele, holdingIdentifiers, exportDeclarations)
     Array.from(new Set(ele.declaration.declarations)).forEach((declaration) => {
       const id = declaration.id;
       if (id) {
-        (0, import_deepSearchParamsIdentifier.default)(id, (identifier) => holdingIdentifiers.push(identifier));
+        (0, import_deepSearchParamsIdentifier.default)(id, callback);
       }
     });
   }
@@ -296,6 +310,9 @@ function updateVariableScopeAndOccupation(deepTravelNode, holdingIdentifiers) {
   const firstPick = deepTravelNode._util.variableScope[0];
   if (firstPick && firstPick !== deepTravelNode) {
     if (firstPick._util) {
+      if (!firstPick._util.occupation) {
+        firstPick._util.occupation = /* @__PURE__ */ new Set();
+      }
       firstPick._util.occupation.add(deepTravelNode);
     } else {
       console.log(deepTravelNode._util.filePath, (_a = deepTravelNode.loc) == null ? void 0 : _a.start.line, deepTravelNode.type, deepTravelNode.name);

package/dist/cjs/util/report_util/filterEffectedExportMember.js

@@ -35,10 +35,11 @@ __export(filterEffectedExportMember_exports, {
 module.exports = __toCommonJS(filterEffectedExportMember_exports);
 var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
 var import_AstUtil = __toESM(require("../ast_util/AstUtil"));
+var import_getEffectedExportMembersOfLineRange = __toESM(require("../ast_util/helper/getEffectedExportMembersOfLineRange"));
 function filterEffectedExportMember(filePath, absPathPrefix, startLine, endLine) {
-  const astKit = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix, (travelNode) => ["VElement", "ImportDeclaration", "ExportAllDeclaration", "ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(travelNode.type));
+  const astKit = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
   const { mapFileLineToNodeSet } = astKit;
-  return extractEffectedExportMemberByLineRange(mapFileLineToNodeSet, startLine, endLine, filePath);
+  return (0, import_getEffectedExportMembersOfLineRange.default)(mapFileLineToNodeSet, startLine, endLine, filePath);
 }
 function extractEffectedExportMemberByLineRange(mapFileLineToNodeSet, startLine, endLine, filePath) {
   const topScopeNodes = import_AstUtil.default.getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, startLine, endLine);

package/dist/cjs/util/shared/collectUpstreamFiles.js

@@ -25,14 +25,13 @@ module.exports = __toCommonJS(collectUpstreamFiles_exports);
 function collectUpstreamFiles(madgeResult, modifiedFilePaths, maxCount = 30) {
   const changedFilePaths = [...modifiedFilePaths];
   let tmpFiles = [...modifiedFilePaths];
-  for (let i = 0; i < 3; i++) {
+  for (let i = 0; i < 9; i++) {
     tmpFiles = tmpFiles.map((file) => madgeResult.depends(file)).flat();
     if (tmpFiles.length === 0) {
       break;
     }
     changedFilePaths.push(...tmpFiles);
     if (changedFilePaths.length > maxCount) {
-      break;
     }
   }
   return [...new Set(changedFilePaths)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",