js-code-detector 0.0.1

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

@@ -0,0 +1,277 @@
+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/report_util/code_block_detect.ts
+var code_block_detect_exports = {};
+__export(code_block_detect_exports, {
+  default: () => codeBlockDetect
+});
+module.exports = __toCommonJS(code_block_detect_exports);
+var import_path = require("path");
+var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
+var import_AstUtil = __toESM(require("../ast_util/AstUtil"));
+var createBlockReport = (kind) => ({
+  kind,
+  diff_txt: [],
+  topAdded: [],
+  topRemoved: [],
+  added: [],
+  addedNotUsed: [],
+  addedNotFound: [],
+  addedEffects: [],
+  removed: [],
+  removedStillUsing: [],
+  removedEffects: []
+});
+var findOrCreateBlockReport = (blockReports, kind, fromHead) => {
+  var _a, _b;
+  if (fromHead) {
+    for (let i = blockReports.length - 1; i >= 0; i--) {
+      if (blockReports[i].kind === kind) {
+        return blockReports[i];
+      }
+    }
+  }
+  if (((_a = blockReports.at(-1)) == null ? void 0 : _a.kind) === kind || kind === "Other" && ((_b = blockReports.at(-1)) == null ? void 0 : _b.kind.startsWith("Other:"))) {
+    return blockReports.at(-1);
+  }
+  return createBlockReport(kind);
+};
+function codeBlockDetect(arg) {
+  const { gitDiffItem, absPathPrefix, blockReports } = arg;
+  const { filePath, startLineOfNew, items, startLineOfOld } = gitDiffItem;
+  const { mapFileLineToNodeSet, mapUuidToNode } = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
+  const filePathOfOld = (0, import_path.join)(process.cwd(), "..", "source", filePath);
+  const { mapFileLineToNodeSet: mapFileLineToNodeSetOld } = (0, import_getAstKitByFilePath.default)(filePathOfOld, absPathPrefix);
+  const programNode = mapUuidToNode.get("Program");
+  const lineNumberStartNew = Number(startLineOfNew);
+  const lineNumberEndNew = lineNumberStartNew + items.filter((item) => item.startsWith("+")).length - 1;
+  const lineNumberStartOld = Number(startLineOfOld);
+  const lineNumberEndOld = lineNumberStartOld + items.filter((item) => item.startsWith("-")).length - 1;
+  const addNodes = import_AstUtil.default.getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStartNew, lineNumberEndNew);
+  const removeNodes = import_AstUtil.default.getTopScopeNodesByLineNumberRange(mapFileLineToNodeSetOld, lineNumberStartOld, lineNumberEndOld);
+  iterateNodes(addNodes, "add", { blockReports, programNode });
+  iterateNodes(removeNodes, "remove", { blockReports, programNode });
+  const lastReport = blockReports.at(-1);
+  if (lastReport) {
+    lastReport.diff_txt = items;
+    lastReport.topAdded = addNodes;
+    lastReport.topRemoved = removeNodes;
+  }
+  blockReports.push(createBlockReport("Never"));
+}
+function getPathsOfNode(topScopeNodes) {
+  const paths = [];
+  for (const topScopeNode of topScopeNodes) {
+    const nodeCollection = topScopeNode._util.nodeCollection;
+    for (const nodeItem of nodeCollection) {
+      if (nodeItem.type.endsWith("Identifier") || nodeItem.type.endsWith("Literal")) {
+        paths.push(import_AstUtil.default.getNodePath(nodeItem));
+      }
+    }
+  }
+  return [...new Set(paths)];
+}
+function mapNodePath(list) {
+  return list.map((item) => ({ ...item, effects: item.effects.map((ele) => ({ ele, path: import_AstUtil.default.getNodePath(ele) })) }));
+}
+function filterBySamePathAndLen(list, sameEffectsPaths) {
+  return list.map((e) => ({ ...e, effects: e.effects.filter((item) => !sameEffectsPaths.includes(item.path)) })).filter((e) => e.effects.length);
+}
+function extractEffectItem(list) {
+  return list.map((e) => ({ ...e, effects: e.effects.map((item) => item.ele) }));
+}
+function pushBlockReport(blockReports, blockReport, programNode) {
+  const sameNames = blockReport.added.filter((path) => blockReport.removed.includes(path));
+  if (sameNames.length) {
+    ["added", "removed"].forEach((key) => {
+      blockReport[key] = blockReport[key].filter((path) => !sameNames.includes(path));
+    });
+  }
+  const addedEffectsList = mapNodePath(blockReport.addedEffects);
+  const removedEffectsList = mapNodePath(blockReport.removedEffects);
+  const addedEffectsPaths = addedEffectsList.map((item) => item.effects.map(({ path }) => path)).flat();
+  const removedEffectsPaths = removedEffectsList.map((item) => item.effects.map(({ path }) => path)).flat();
+  const sameEffectsPaths = addedEffectsPaths.filter((path) => removedEffectsPaths.includes(path));
+  if (sameEffectsPaths.length) {
+    const addedEffects = filterBySamePathAndLen(addedEffectsList, sameEffectsPaths);
+    const removedEffects = filterBySamePathAndLen(removedEffectsList, sameEffectsPaths);
+    blockReport.addedEffects = extractEffectItem(addedEffects);
+    blockReport.removedEffects = extractEffectItem(removedEffects);
+  }
+  if (!blockReports.includes(blockReport) && Object.entries(blockReport).filter((e) => e[0] !== "kind").some((e) => e[1].length)) {
+    blockReports.push(blockReport);
+  }
+}
+function iterateNodes(topScopeNodes, operation, extra) {
+  for (const topScopeNode of topScopeNodes) {
+    if (["ImportDeclaration", "ImportSpecifier", "ImportDefaultSpecifier"].includes(topScopeNode.type)) {
+      detectImport({ topScopeNode, operation, extra });
+    } else if (["VariableDeclaration", "VariableDeclarator"].includes(topScopeNode.type) || import_AstUtil.default.isSubNodeOfVariableDeclarator(topScopeNode)) {
+      detectVariableDeclaration({ topScopeNode, operation, extra });
+    } else if (["FunctionDeclaration", "ClassDeclaration"].includes(topScopeNode.type)) {
+      detectFnClsDeclaration({ topScopeNode, operation, extra });
+    } else if (["UnaryExpression", "UpdateExpression"].includes(topScopeNode.type)) {
+      detectUpdateEffectExp({ topScopeNode, operation, extra });
+    } else if (["CallExpression"].includes(topScopeNode.type)) {
+      detectFnCallExp({ topScopeNode, operation, extra });
+    } else if (["AssignmentExpression"].includes(topScopeNode.type)) {
+      detectAssignmentEffectExp({ topScopeNode, operation, extra });
+    } else if (["ExpressionStatement"].includes(topScopeNode.type)) {
+      const { expression } = topScopeNode;
+      iterateNodes([expression], operation, extra);
+    } else {
+      detectOther({ topScopeNode, operation, extra });
+    }
+  }
+}
+function detectOther(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "Other");
+  const { added, removed } = blockReport;
+  const nodePaths = getPathsOfNode(topScopeNode._util.nodeCollection);
+  (operation === "add" ? added : removed).push(...nodePaths);
+  blockReport.kind = "Other:" + topScopeNode.type;
+  pushBlockReport(blockReports, blockReport, programNode);
+}
+function detectImport(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "Import");
+  const { added, removed, addedEffects, removedEffects } = blockReport;
+  const specifiers = topScopeNode.type === "ImportDeclaration" ? topScopeNode.specifiers : [topScopeNode];
+  if (Array.isArray(specifiers)) {
+    specifiers.forEach((s) => {
+      const { local } = s;
+      (operation === "add" ? added : removed).push(local.name);
+      (operation === "add" ? addedEffects : removedEffects).push({ causeBy: local, effects: [...local._util.effectIds] });
+    });
+  }
+  pushBlockReport(blockReports, blockReport, programNode);
+}
+function detectFnClsDeclaration(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "Declaration");
+  const { added, removed, addedEffects, removedEffects } = blockReport;
+  const { id } = topScopeNode;
+  (operation === "add" ? added : removed).push(id.name);
+  (operation === "add" ? addedEffects : removedEffects).push({ causeBy: id, effects: [...id._util.effectIds] });
+  pushBlockReport(blockReports, blockReport, programNode);
+}
+function insertPrefix(n, prefix, sep = ":") {
+  return [prefix, n].join(sep);
+}
+function detectVariableDeclaration(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "Declaration");
+  const { added, removed, addedEffects, removedEffects } = blockReport;
+  if (["VariableDeclaration", "VariableDeclarator"].includes(topScopeNode.type)) {
+    let declarations = [];
+    if (topScopeNode.type === "VariableDeclarator") {
+      declarations = [topScopeNode];
+    } else {
+      declarations = topScopeNode.declarations;
+    }
+    if (Array.isArray(declarations)) {
+      for (const declaration of declarations) {
+        const { id, init } = declaration;
+        if (id) {
+          id._util.nodeCollection.forEach((item) => {
+            if (item.type === "Identifier") {
+              (operation === "add" ? added : removed).push(insertPrefix(item.name, "id"));
+              (operation === "add" ? addedEffects : removedEffects).push({ causeBy: item, effects: [...item._util.effectIds] });
+            }
+          });
+        }
+        const initIdSet = /* @__PURE__ */ new Set();
+        if (init && !["ArrowFunctionExpression", "FunctionExpression"].includes(init.type)) {
+          ["Identifier"].includes(init.type) ? initIdSet.add(init) : import_AstUtil.default.deepFindIdOfExpression(init, (id2) => initIdSet.add(id2));
+          for (const initId of initIdSet) {
+            operation === "add" ? blockReport.added.push(insertPrefix(initId.name, "init")) : blockReport.removed.push(insertPrefix(initId.name, "init"));
+          }
+        }
+      }
+    }
+  } else {
+    topScopeNode._util.nodeCollection.forEach((item) => {
+      if (item.type === "Identifier") {
+        (operation === "add" ? added : removed).push(insertPrefix(item.name, "id"));
+        (operation === "add" ? addedEffects : removedEffects).push({ causeBy: item, effects: [...item._util.effectIds] });
+      }
+    });
+  }
+  pushBlockReport(blockReports, blockReport, programNode);
+}
+function detectUpdateEffectExp(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "SelfUpdate");
+  const { added, removed, addedEffects, removedEffects } = blockReport;
+  const { argument: args } = topScopeNode;
+  const createdExpIdSet = /* @__PURE__ */ new Set();
+  import_AstUtil.default.deepFindIdOfExpression(args, (id) => createdExpIdSet.add(id));
+  for (const createdExpId of createdExpIdSet) {
+    (operation === "add" ? added : removed).push(createdExpId.name);
+    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: createdExpId, effects: [...createdExpId._util.effectIds] });
+  }
+  pushBlockReport(blockReports, blockReport, programNode);
+}
+function detectFnCallExp(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "Invoke");
+  const { added, removed, addedEffects, removedEffects } = blockReport;
+  const { callee, arguments: args } = topScopeNode;
+  const argsIds = args.map((arg2) => arg2._util.nodeCollection.filter((n) => n.type === "Identifier")).flat();
+  for (const argsId of argsIds) {
+    (operation === "add" ? added : removed).push(argsId.name);
+    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: argsId, effects: [...argsId._util.effectIds] });
+  }
+  const createdExpIdSet = /* @__PURE__ */ new Set();
+  import_AstUtil.default.deepFindIdOfExpression(callee, (id) => createdExpIdSet.add(id));
+  for (const createdExpId of createdExpIdSet) {
+    (operation === "add" ? added : removed).push(createdExpId.name);
+    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: createdExpId, effects: [...createdExpId._util.effectIds] });
+  }
+  pushBlockReport(blockReports, blockReport, programNode);
+}
+function detectAssignmentEffectExp(arg) {
+  const { topScopeNode, operation, extra: { blockReports, programNode } } = arg;
+  const blockReport = findOrCreateBlockReport(blockReports, "Assignment");
+  const { added, removed, addedEffects, removedEffects } = blockReport;
+  const { left, right } = topScopeNode;
+  const idSetLeft = /* @__PURE__ */ new Set();
+  ["Identifier"].includes(left.type) ? idSetLeft.add(left) : import_AstUtil.default.deepFindIdOfExpression(left, (id) => idSetLeft.add(id));
+  for (const createdExp of idSetLeft) {
+    (operation === "add" ? added : removed).push(insertPrefix(createdExp.name, "left"));
+    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: createdExp, effects: [...createdExp._util.effectIds] });
+  }
+  const idSetRight = /* @__PURE__ */ new Set();
+  ["Identifier", "ArrowFunctionExpression", "FunctionExpression"].includes(right.type) ? idSetRight.add(right) : import_AstUtil.default.deepFindIdOfExpression(right, (id) => idSetRight.add(id));
+  for (const createdExp of idSetRight) {
+    (operation === "add" ? added : removed).push(insertPrefix(createdExp.name, "right"));
+  }
+  pushBlockReport(blockReports, blockReport, programNode);
+}

package/dist/cjs/util/report_util.d.ts

@@ -0,0 +1,29 @@
+import { GitDiffDetail } from "./format_git_diff_content";
+type Arg = {
+    groupGitDiffLines: GitDiffDetail[];
+    tree: Record<string, string[]>;
+    absPathPrefix: string;
+};
+export declare function createDetectReport(arg: Arg): {
+    blockReports: {
+        addedEffects: {
+            causeBy: string;
+            effects: string[];
+        }[];
+        removedEffects: {
+            causeBy: string;
+            effects: (string | undefined)[];
+        }[];
+        diff_txt: string[];
+        added: string[];
+        addedNotUsed: string[];
+        addedNotFound: string[];
+        removed: string[];
+        removedStillUsing: string[];
+        kind: "Import" | "Declaration" | "Assignment" | "SelfUpdate" | "Invoke" | "Other" | "Never";
+    }[];
+    filePath: string;
+    type: "add" | "delete" | "modify";
+    filesDependsOnMe: string[];
+}[];
+export {};

package/dist/cjs/util/report_util.js

@@ -0,0 +1,99 @@
+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/report_util.ts
+var report_util_exports = {};
+__export(report_util_exports, {
+  createDetectReport: () => createDetectReport
+});
+module.exports = __toCommonJS(report_util_exports);
+var import_code_block_detect = __toESM(require("./report_util/code_block_detect"));
+var import_getAstKitByFilePath = __toESM(require("./ast_util/getAstKitByFilePath"));
+var import_AstUtil = __toESM(require("./ast_util/AstUtil"));
+function createDetectReport(arg) {
+  const { groupGitDiffLines, tree, absPathPrefix } = arg;
+  const reports = [];
+  const entries = Object.entries(tree);
+  groupGitDiffLines.forEach((item) => {
+    const { filePath, type } = item;
+    const filesDependsOnMe = entries.filter((entry) => entry[1].includes(filePath)).map((e) => e[0]);
+    let reportItem = reports.find((e) => e.filePath === filePath);
+    if (!reportItem) {
+      reportItem = {
+        filePath,
+        type,
+        filesDependsOnMe,
+        blockReports: []
+      };
+      reports.push(reportItem);
+    }
+    if (type === "modify") {
+      (0, import_code_block_detect.default)({ gitDiffItem: item, absPathPrefix, blockReports: reportItem.blockReports });
+    }
+  });
+  return reports.map((report) => {
+    const filePath = report.filePath;
+    const astKit = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
+    const allNodes = new Map([...astKit.mapUuidToNode.values()].map((ele) => [import_AstUtil.default.getNodePath(ele), ele]));
+    return {
+      ...report,
+      blockReports: report.blockReports.filter((e) => e.kind !== "Never").map((blockReport) => {
+        const { kind, addedEffects, removedEffects, topAdded, topRemoved, ...rest } = blockReport;
+        const removedEffectsInfos = removedEffects.map((item) => {
+          const tmpList = item.effects.map((ele) => {
+            const nodePath = import_AstUtil.default.getNodePath(ele);
+            const item2 = allNodes.get(nodePath);
+            return item2 && import_AstUtil.default.createScopeContent(item2);
+          }).filter(Boolean);
+          const effects = [...new Set(tmpList)];
+          return {
+            causeBy: item.causeBy.name || item.causeBy.type,
+            effects
+          };
+        }).filter((item) => item.effects.length > 0);
+        const addedEffectsInfos = addedEffects.map((item) => {
+          const effects = [...new Set(item.effects.map(import_AstUtil.default.createScopeContent))];
+          return {
+            causeBy: item.causeBy.name || item.causeBy.type,
+            effects
+          };
+        }).filter((item) => item.effects.length > 0);
+        return {
+          kind,
+          ...rest,
+          addedEffects: addedEffectsInfos,
+          removedEffects: removedEffectsInfos
+        };
+      })
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDetectReport
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "js-code-detector",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "scripts": {
+    "dev": "father dev",
+    "build": "father build",
+    "build:deps": "father prebundle",
+    "prepublishOnly": "father doctor && npm run build"
+  },
+  "keywords": [],
+  "authors": [
+    "John <944268503@qq.com>"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "compiled",
+    "bin"
+  ],
+  "bin": {
+    "detect": "bin/detect.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/madge": "^5.0.3",
+    "father": "^4.6.3"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.3",
+    "@umijs/utils": "^4.4.12",
+    "dayjs": "^1.11.13",
+    "madge": "^8.0.0",
+    "vue-eslint-parser": "^10.2.0"
+  }
+}