js-code-detector 0.0.52 → 0.0.54

package/dist/cjs/index.d.ts

@@ -20,7 +20,7 @@ export declare function gitDiffDetect(): Promise<{
                 effectsDownstream: string[];
             }[];
         }[];
-        type: "add" | "delete" | "modify";
+        type: "modify" | "add" | "delete";
         filesDependsOnMe: string[];
         undefinedIdentifiers: string[];
         filePath: string;

package/dist/cjs/services/DetectService.js

@@ -44,6 +44,7 @@ var import_UmiProjectService = __toESM(require("./projectServiceClass/UmiProject
 var import_perf_hooks = require("perf_hooks");
 var import_cloneRepoWithBranchAndDefault = __toESM(require("../util/git_util/cloneRepoWithBranchAndDefault"));
 var import_VueProjectService = __toESM(require("./projectServiceClass/VueProjectService"));
+var import_ViteProjectService = __toESM(require("./projectServiceClass/ViteProjectService"));
 var DetectService = class {
   constructor(option) {
     this.directoryInfo = {
@@ -158,7 +159,7 @@ var DetectService = class {
     await (0, import_execGitDiff.default)(targetDirPath, baseBranch, targetBranch);
     const repoType = await (0, import_getRepoSupportFlag.getRepoType)((0, import_path.join)(targetDirPath, "package.json"));
     this.gitInfo.repoType = repoType;
-    import_utils.logger.info("克隆仓库成功");
+    import_utils.logger.info(`克隆仓库成功, repoType: ${repoType}`);
   }
   async move() {
     const repoType = this.gitInfo.repoType;
@@ -172,7 +173,9 @@ var DetectService = class {
   async projectHandle() {
     var _a;
     const { repoType } = this.gitInfo;
+    import_utils.logger.info("开始处理项目" + repoType);
     if (!(0, import_getRepoSupportFlag.isRepoTypeSupported)(repoType)) {
+      import_utils.logger.info("不支持的 repoType:" + repoType);
       return;
     }
     if (repoType === "umi") {
@@ -181,6 +184,9 @@ var DetectService = class {
     if (repoType === "vue2") {
       this.projectService = new import_VueProjectService.default(this);
     }
+    if (repoType === "vite") {
+      this.projectService = new import_ViteProjectService.default(this);
+    }
     await ((_a = this.projectService) == null ? void 0 : _a.run());
   }
   formatResult() {

package/dist/cjs/services/projectServiceClass/ViteProjectService.d.ts

@@ -0,0 +1,23 @@
+import { GitDiffDetail } from "../../util/format_git_diff_content";
+import { ProjectService } from "../ProjectService";
+import { DetectService } from "../DetectService";
+import { IMadgeInstance } from "../../util/report_util/getMadgeInstance";
+export default class ViteProjectService implements ProjectService {
+    detectService: DetectService;
+    gitDiffDetail: GitDiffDetail[];
+    helpInfo: ProjectService['helpInfo'];
+    outputResult: ProjectService['outputResult'];
+    viteHelpInfo: {
+        madgeResult: IMadgeInstance | null;
+        tsConfigPath: string;
+        entryFiles: string[];
+        extensions: string[];
+    };
+    constructor(detectService: DetectService);
+    run(): Promise<void>;
+    parseGitDiffContent(): Promise<void>;
+    setAlias(): Promise<void>;
+    readSrcDirFilesAndSetEntries(): Promise<void>;
+    getMadgeResult(): Promise<void>;
+    collectEffectedFiles(): Promise<void>;
+}

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

@@ -0,0 +1,142 @@
+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/services/projectServiceClass/ViteProjectService.ts
+var ViteProjectService_exports = {};
+__export(ViteProjectService_exports, {
+  default: () => ViteProjectService
+});
+module.exports = __toCommonJS(ViteProjectService_exports);
+var import_format_git_diff_content = require("../../util/format_git_diff_content");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../../util/constants");
+var import_utils = require("@umijs/utils");
+var import_madge = __toESM(require("madge"));
+var import_collectUpstreamFiles = __toESM(require("../../util/shared/collectUpstreamFiles"));
+var import_createDependenceMap = require("../../util/report_util/createDependenceMap");
+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 ViteProjectService = class {
+  constructor(detectService) {
+    this.detectService = detectService;
+    this.gitDiffDetail = [];
+    this.helpInfo = {
+      projectFileList: [],
+      parsedAlias: {}
+    };
+    this.outputResult = {
+      effectedImportUsage: [],
+      error: null
+    };
+    this.viteHelpInfo = {
+      madgeResult: null,
+      tsConfigPath: "",
+      entryFiles: [],
+      extensions: []
+    };
+    this.detectService = detectService;
+  }
+  async run() {
+    import_utils.logger.info("格式化 git diff 内容...");
+    await this.parseGitDiffContent();
+    import_utils.logger.info("获取 Alias 配置...");
+    await this.setAlias();
+    import_utils.logger.info("读取 src 目录文件...");
+    await this.readSrcDirFilesAndSetEntries();
+    import_utils.logger.info("获取 madge 结果...");
+    await this.getMadgeResult();
+    import_utils.logger.info("收集受影响的文件...");
+    await this.collectEffectedFiles();
+  }
+  async parseGitDiffContent() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import_constants.gitDiffFileName), "utf-8");
+    this.gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
+  }
+  async setAlias() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    this.helpInfo.parsedAlias = await (0, import_tsConfigPathsToWebpackAlias.tsConfigPathsToWebpackAlias)({
+      tsconfigPath: (0, import_path.join)(targetDirPath, "tsconfig.json"),
+      projectRoot: targetDirPath,
+      excludeTypeOnly: false
+    });
+  }
+  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"));
+    this.viteHelpInfo.entryFiles = projectFileList.filter((file) => (0, import_isVueEntryFile.default)(file.filePath)).map((e) => e.filePath);
+  }
+  async getMadgeResult() {
+    const targetBranchDir = this.detectService.directoryInfo.targetBranchDir;
+    const entryFilePath = this.viteHelpInfo.entryFiles;
+    const tsConfig = (0, import_path.join)(targetBranchDir, "tsconfig.json");
+    const madgeConfig = {
+      baseDir: targetBranchDir,
+      fileExtensions: ["vue", "ts", "js"],
+      tsConfig,
+      excludeRegExp: [/node_modules/, /\.d\.ts$/]
+    };
+    const res = await (0, import_madge.default)(entryFilePath, madgeConfig);
+    this.viteHelpInfo.madgeResult = res;
+    this.helpInfo.projectFileList = Object.keys(res.tree);
+  }
+  async collectEffectedFiles() {
+    const { parsedAlias } = this.helpInfo;
+    const { madgeResult } = this.viteHelpInfo;
+    const projectFileList = this.helpInfo.projectFileList;
+    const targetBranchDir = this.detectService.directoryInfo.targetBranchDir;
+    const absPathPrefix = (0, import_path.join)(targetBranchDir, "/");
+    const validModifiedFiles = this.gitDiffDetail.reduce((acc, item) => {
+      const { filePath } = item;
+      this.helpInfo.projectFileList.includes(filePath) && acc.push(filePath);
+      return acc;
+    }, []);
+    const possibleEffectedFiles = (0, import_collectUpstreamFiles.default)(madgeResult, validModifiedFiles);
+    const possibleEffectedFilesFullPath = possibleEffectedFiles.map((file) => (0, import_path.join)(absPathPrefix, file));
+    const mapRef = (0, import_createDependenceMap.createExportedNameToReferenceLocalSet)(possibleEffectedFilesFullPath, parsedAlias, absPathPrefix, projectFileList);
+    const { import2export, indirectExportMembers } = mapRef;
+    const gitDiffDetail = this.gitDiffDetail;
+    const validGitDiffDetail = gitDiffDetail.filter((item) => possibleEffectedFiles.includes(item.filePath));
+    const effectedExportNames = validGitDiffDetail.map((item) => {
+      const { filePath, newBranchLineScope, startLineOfNew } = item;
+      const exportedNames = (0, import_filterEffectedExportMember.default)((0, import_path.join)(absPathPrefix, filePath), absPathPrefix, Number(startLineOfNew), Number(startLineOfNew) + Number(newBranchLineScope));
+      return exportedNames.map((name) => [filePath, name].join("#"));
+    }).flat();
+    const effectedImportUsage = [...Object.entries(import2export), ...Object.entries(indirectExportMembers)].filter(([_, value]) => {
+      return effectedExportNames.includes(value);
+    });
+    this.outputResult.effectedImportUsage = effectedImportUsage;
+    const token = this.detectService.gitInfo.token;
+    if (!token) {
+      const pwd = (0, import_path.join)(this.detectService.directoryInfo.tmpWorkDir, "..");
+      (0, import_fs.writeFileSync)((0, import_path.join)(pwd, "effectedImportUsage.json"), JSON.stringify({ tree: madgeResult == null ? void 0 : madgeResult.tree, projectFileList, possibleEffectedFiles, gitDiffDetailFiles: gitDiffDetail.map((e) => e.filePath), validGitDiffDetail, effectedImportUsage, ...mapRef }, null, 2));
+    }
+  }
+};

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

@@ -176,7 +176,7 @@ var VueProjectService = class {
       baseDir: this.detectService.directoryInfo.targetBranchDir,
       fileExtensions: this.vueHelpInfo.extensions.map((ext) => ext.replace(/^\./, "")),
       webpackConfig: this.vueHelpInfo.webpackConfigPath,
-      excludeRegExp: [/node_modules/]
+      excludeRegExp: [/node_modules/, /\.d\.ts$/]
     };
     const res = await (0, import_madge.default)(entryFilePath, madgeConfig);
     this.vueHelpInfo.madgeResult = res;

package/dist/cjs/util/ast_util/AstKit.d.ts

@@ -1,30 +1,14 @@
 import { AstNode } from "./AstUtil";
 export declare class AstUtil {
-    static invalidNodeKey: string[];
     static EXPORT_DECLARATION_TYPES: readonly ["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration", "ClassDeclaration"];
     static windowProperties: string[];
     static intrinsicElements: string[];
-    static standardAttributes: string[];
-    static FUNCTION_TYPES: string[];
+    static isUntrackedId(id: AstNode): boolean;
     static getNodePath(node: AstNode): string;
     static getShortNodeMsg(node: AstNode, hideParentProperty?: boolean): string;
+    static findExportedMembersNameFromAncestors(node: AstNode | undefined | null): string[];
+    static getAncestorsFromBirth(occupationId: AstNode, sourceId: AstNode): AstNode[];
+    static getNearestImpactedNode(ancestors: AstNode[]): AstNode | undefined;
     static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet: Map<number, Set<AstNode>>, lineNumberStart: number, lineNumberEnd: number, loose?: boolean): AstNode[];
-    private static isValidNodeCollect;
-    private static isValidArrayNodeCollect;
-    private static collectEffectId;
-    private static findOrCreateImportedMember;
-    private static findOrCreateExportedMember;
-    private static updateImportedAndExportedMember;
-    private static deepSearchParamsIdentifier;
-    private static collectDependenceIdsOfExportMembers;
-    private static collectExpressionIdentifiersShallow;
-    private static _collectExpressionIdentifiersShallow;
-    private static collectDependenceIds;
-    private static updateLoc;
-    private static collectVariableDeclarationIdentifiers;
-    private static collectDeclarationIdentifiers;
-    private static collectImportDeclarationIdentifiers;
-    private static collectHoldingIds;
-    static deepFirstTravel(node: AstNode, filePath: string, mapUuidToNode: Map<string, AstNode>, mapFileLineToNodeSet: Map<number, Set<AstNode>>, mapPathToNodeSet: Map<string, Set<AstNode>>, stopTravelCallback?: (node: AstNode) => boolean | void): AstNode | undefined;
-    private static _deepFirstTravel;
+    static deepFirstTravel(node: AstNode, filePath: string, mapUuidToNode: Map<string, AstNode>, mapFileLineToNodeSet: Map<number, Set<AstNode>>, mapPathToNodeSet: Map<string, Set<AstNode>>, stopTravelCallback?: (node: AstNode) => boolean | void): void;
 }