js-code-detector 0.0.4 → 0.0.5

package/README.md

@@ -1,4 +1,4 @@
-# code-detector
+# js-code-detector
 
 [![NPM version](https://img.shields.io/npm/v/code-detector.svg?style=flat)](https://npmjs.com/package/code-detector)
 [![NPM downloads](http://img.shields.io/npm/dm/code-detector.svg?style=flat)](https://npmjs.com/package/code-detector)

package/bin/sameCodeDetect.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const args = process.argv;
+require('../dist/cjs/index').sameCodeDetect(args[2]);

package/dist/cjs/index.d.ts

@@ -5,3 +5,4 @@ export declare function getGitRepositoryAndBranch(): Promise<{
     branchName: string;
 }>;
 export declare function generateReport(jsonStr: string): void;
+export declare function sameCodeDetect(dirOfCwd?: string): Promise<void>;

package/dist/cjs/index.js

@@ -31,6 +31,7 @@ var src_exports = {};
 __export(src_exports, {
   generateReport: () => generateReport,
   getGitRepositoryAndBranch: () => getGitRepositoryAndBranch,
+  sameCodeDetect: () => sameCodeDetect,
   umiPluginCallback: () => umiPluginCallback,
   writeGitDiffTxt: () => writeGitDiffTxt
 });
@@ -44,6 +45,8 @@ var import_report_util = require("./util/report_util");
 var import_utils = require("@umijs/utils");
 var import_dayjs = __toESM(require("dayjs"));
 var import_createMdByJson = require("./util/report_util/createMdByJson");
+var import_readDirFiles = require("./util/shared/readDirFiles");
+var import_Core = __toESM(require("./util/ast_util/Core"));
 var jsonName = "git_diff_report.md";
 async function umiPluginCallback(api) {
   const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(api.cwd, "git_diff.txt"), "utf-8");
@@ -108,10 +111,17 @@ async function getGitRepositoryAndBranch() {
 function generateReport(jsonStr) {
   (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), `${(0, import_dayjs.default)().format("YYYYMDD_HHmm")}_${jsonName}`), jsonStr, { encoding: "utf-8", flag: "w" });
 }
+async function sameCodeDetect(dirOfCwd) {
+  const filesAndContent = await (0, import_readDirFiles.readSrcFiles)(dirOfCwd);
+  const { nodeContentGroupList } = import_Core.default.investigate(filesAndContent);
+  const md = import_Core.default.createMarkdownFile(nodeContentGroupList.slice(0, 5));
+  (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), `${(0, import_dayjs.default)().format("YYYYMDD_HHmm")}_same_code.md`), md, { encoding: "utf-8", flag: "w" });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   generateReport,
   getGitRepositoryAndBranch,
+  sameCodeDetect,
   umiPluginCallback,
   writeGitDiffTxt
 });

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

@@ -0,0 +1,63 @@
+import { Comment, Node, Identifier } from "@babel/types";
+export type MapHashKeyToAstNodeSet = Map<string, Set<AstFeatNode>>;
+export interface AstFeatNode {
+    type: Node["type"];
+    name?: Identifier | string;
+    leadingComments?: Comment[] | null;
+    innerComments?: Comment[] | null;
+    trailingComments?: Comment[] | null;
+    start?: number | null;
+    end?: number | null;
+    loc?: Record<'start' | 'end', {
+        line: number;
+    }> | null;
+    range?: [number, number];
+    extra?: Record<string, unknown>;
+    _util: {
+        startLine: number;
+        endLine: number;
+        mapHashKeyToString: Map<string, string>;
+        mapDepthDiffToHashKey: Map<number, string>;
+        filePath: string;
+        hashKey: string;
+        nodeCollection: AstFeatNode[];
+        childrenNode: AstFeatNode[];
+        ancestors: AstFeatNode[];
+        depth: number;
+    };
+    [p: string]: any;
+}
+export default class AstFeatUtil {
+    static skipHashCreateTypes: string[];
+    static invalidNodeKey: string[];
+    static AstNodeTypeConf: Map<string, {
+        FEATURE_LEVEL: string[];
+    }>;
+    static validRuleListOfAstNodeType: {
+        test: (astNode: AstFeatNode) => boolean;
+        FEATURE_LEVEL: string[];
+    }[];
+    static isValidNodeCollect(astNode: AstFeatNode): boolean;
+    static isValidArrayNodeCollect(astNode: AstFeatNode): boolean;
+    static createHashSeed(nodeCollection: AstFeatNode[]): string;
+    static createHashKey(str: string): string;
+    static addAncestorForNode(nodeCollection: AstFeatNode[], ancestor: AstFeatNode): void;
+    static deepFirstTravel(node: AstFeatNode, mapRecord: {
+        mapHashKeyToTopLevelNode: MapHashKeyToAstNodeSet;
+        nodeTypeSet: Set<string>;
+    }, filePath: string): AstFeatNode | undefined;
+    static _deepFirstTravel(node: AstFeatNode, visitedNodeSet: Set<typeof node>, mapRecord: {
+        mapHashKeyToTopLevelNode: MapHashKeyToAstNodeSet;
+        nodeTypeSet: Set<string>;
+    }, filePath: string, depth: number): AstFeatNode;
+    static updateLoc(astNode: AstFeatNode): void;
+    static updateNodeSetOfDepth(mapHashKeyToTopLevelNode: MapHashKeyToAstNodeSet, rootNode: AstFeatNode, nodeCollection: AstFeatNode[]): void;
+    static updateNodeSetByHashKey(hashKey: string, node: AstFeatNode, mapHashKeyToNode: MapHashKeyToAstNodeSet): void;
+    static deleteSameSubSetPartial(mapHashKeyToTopLevelNode: MapHashKeyToAstNodeSet): void;
+    static spreadSubNode(nodeSet: Set<AstFeatNode>, depthDiff: number): {
+        rootNode: AstFeatNode;
+        edgeNodeCollection: AstFeatNode[];
+        commonHashKeyNodesOrdered: AstFeatNode[][];
+    }[];
+    static createNodeHashKey(nodeList: AstFeatNode[], mapHashKeyToString: Map<string, string>): string;
+}

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

@@ -0,0 +1,330 @@
+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/AstFeatUtil.ts
+var AstFeatUtil_exports = {};
+__export(AstFeatUtil_exports, {
+  default: () => AstFeatUtil
+});
+module.exports = __toCommonJS(AstFeatUtil_exports);
+var import_lodash_es = require("lodash-es");
+var import_sha1 = __toESM(require("crypto-js/sha1"));
+var import_enc_base64 = __toESM(require("crypto-js/enc-base64"));
+var import_featureLevel = require("../shared/featureLevel");
+var import_astNodeFeatureExtractorMap = require("../shared/astNodeFeatureExtractorMap");
+var AstFeatUtil = class {
+  // 单节点判断
+  static isValidNodeCollect(astNode) {
+    var _a;
+    const isTypeString = typeof (astNode == null ? void 0 : astNode.type) === "string";
+    if (!isTypeString) {
+      return false;
+    }
+    const ruleMatchAndPassed = this.validRuleListOfAstNodeType.find(({ test, FEATURE_LEVEL }) => {
+      return FEATURE_LEVEL.includes(import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT) && test(astNode);
+    });
+    if (ruleMatchAndPassed) {
+      return false;
+    }
+    if ((_a = this.AstNodeTypeConf.get(astNode.type)) == null ? void 0 : _a.FEATURE_LEVEL.includes(import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT)) {
+      return false;
+    }
+    return true;
+  }
+  // 数组节点 判断
+  static isValidArrayNodeCollect(astNode) {
+    return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
+  }
+  static createHashSeed(nodeCollection) {
+    const depthSet = /* @__PURE__ */ new Set();
+    nodeCollection.forEach((n) => depthSet.add(n._util.depth));
+    const astNodeFeatureExtractor = import_astNodeFeatureExtractorMap.astNodeFeatureExtractorMap.get(import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT);
+    return nodeCollection.map((n) => astNodeFeatureExtractor(n)).join(":");
+  }
+  static createHashKey(str) {
+    return import_enc_base64.default.stringify((0, import_sha1.default)(str));
+  }
+  static addAncestorForNode(nodeCollection, ancestor) {
+    nodeCollection.forEach((nodeItem) => {
+      nodeItem._util.ancestors.unshift(ancestor);
+    });
+  }
+  static deepFirstTravel(node, mapRecord, filePath) {
+    const visitedNodeSet = /* @__PURE__ */ new Set();
+    if (!node) {
+      return;
+    }
+    return this._deepFirstTravel(node, visitedNodeSet, mapRecord, filePath, 0);
+  }
+  static _deepFirstTravel(node, visitedNodeSet, mapRecord, filePath, depth) {
+    visitedNodeSet.add(node);
+    const { mapHashKeyToTopLevelNode, nodeTypeSet } = mapRecord;
+    nodeTypeSet.add(node.type);
+    const _util = {
+      startLine: NaN,
+      endLine: NaN,
+      mapHashKeyToString: /* @__PURE__ */ new Map(),
+      mapDepthDiffToHashKey: /* @__PURE__ */ new Map(),
+      filePath,
+      hashKey: "",
+      nodeCollection: [],
+      childrenNode: [],
+      ancestors: [],
+      depth
+    };
+    node._util = _util;
+    const { nodeCollection, childrenNode } = _util;
+    Object.keys(node).forEach((nodeKey) => {
+      if (this.invalidNodeKey.includes(nodeKey)) {
+        return;
+      }
+      const nodeValue = node[nodeKey];
+      if (visitedNodeSet.has(nodeValue) || !node) {
+        return;
+      }
+      if (this.isValidNodeCollect(nodeValue)) {
+        const childNode = this._deepFirstTravel(nodeValue, visitedNodeSet, mapRecord, filePath, depth + 1);
+        nodeCollection.push(childNode, ...childNode._util.nodeCollection);
+        childrenNode.push(childNode);
+      } else if (this.isValidArrayNodeCollect(nodeValue)) {
+        const validNodeArray = nodeValue.filter((nodeItem) => this.isValidNodeCollect(nodeItem)).map((v) => {
+          return this._deepFirstTravel(v, visitedNodeSet, mapRecord, filePath, depth + 1);
+        });
+        nodeCollection.push(...validNodeArray.map((n) => [n, ...n._util.nodeCollection]).flat());
+        childrenNode.push(...validNodeArray);
+      }
+    });
+    this.updateLoc(node);
+    this.addAncestorForNode(nodeCollection, node);
+    this.updateNodeSetOfDepth(mapHashKeyToTopLevelNode, node, nodeCollection);
+    return node;
+  }
+  static updateLoc(astNode) {
+    var _a, _b;
+    const { _util } = astNode;
+    const { nodeCollection } = _util;
+    _util.startLine = Math.min(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.line;
+    }), (_a = astNode.loc) == null ? void 0 : _a.start.line);
+    _util.endLine = Math.max(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.line;
+    }), (_b = astNode.loc) == null ? void 0 : _b.end.line);
+  }
+  static updateNodeSetOfDepth(mapHashKeyToTopLevelNode, rootNode, nodeCollection) {
+    if (this.skipHashCreateTypes.includes(rootNode.type)) {
+      return;
+    }
+    const { mapDepthDiffToHashKey, depth: baseDepth, mapHashKeyToString } = rootNode._util;
+    const maxDepth = Math.max(...nodeCollection.map((n) => n._util.depth));
+    if (!Number.isInteger(maxDepth)) {
+      return;
+    }
+    let tmp = nodeCollection;
+    for (let i = maxDepth; i > baseDepth; i--) {
+      tmp = tmp.filter((n) => n._util.depth <= i);
+      const hashKey = this.createNodeHashKey(tmp, mapHashKeyToString);
+      const depthDiff = i - baseDepth;
+      mapDepthDiffToHashKey.set(depthDiff, hashKey);
+      this.updateNodeSetByHashKey(`${depthDiff}:${hashKey}`, rootNode, mapHashKeyToTopLevelNode);
+    }
+  }
+  static updateNodeSetByHashKey(hashKey, node, mapHashKeyToNode) {
+    const oldSet = mapHashKeyToNode.get(hashKey);
+    if (oldSet) {
+      oldSet.add(node);
+    } else {
+      mapHashKeyToNode.set(hashKey, /* @__PURE__ */ new Set([node]));
+    }
+    ;
+  }
+  static deleteSameSubSetPartial(mapHashKeyToTopLevelNode) {
+    const shallowCopy = new Map(mapHashKeyToTopLevelNode);
+    for (const [hashKey, nodeSet] of shallowCopy) {
+      if (nodeSet.size > 1) {
+        const depthDiff = Number(hashKey.split(":")[0]);
+        const hasKeyList = [...nodeSet].map((item) => {
+          const parent = [...item._util.ancestors].pop();
+          if (parent) {
+            const { mapDepthDiffToHashKey } = parent._util;
+            const tmpHashKey = mapDepthDiffToHashKey.get(depthDiff + 1);
+            return tmpHashKey;
+          }
+          return void 0;
+        });
+        const only = new Set(hasKeyList).size === 1 && hasKeyList[0] !== void 0;
+        if (only) {
+          mapHashKeyToTopLevelNode.delete(hashKey);
+        }
+      }
+    }
+  }
+  static spreadSubNode(nodeSet, depthDiff) {
+    const listOfMaxDepthDiff = [];
+    const listOfNodeInfo = [...nodeSet].map((rootNode) => {
+      const baseDepth = rootNode._util.depth;
+      const edgeNodeCollection = rootNode._util.nodeCollection.filter((n) => n._util.depth - baseDepth === depthDiff);
+      const maxItemDepthDiff = Math.max(...edgeNodeCollection.map((node) => node._util.depth - baseDepth));
+      listOfMaxDepthDiff.push(maxItemDepthDiff);
+      return {
+        rootNode,
+        edgeNodeCollection,
+        commonHashKeyNodesOrdered: []
+      };
+    });
+    const maxDepth = Math.min(...listOfMaxDepthDiff);
+    let listOfCollection = listOfNodeInfo.map((e) => e.edgeNodeCollection);
+    for (let i = 1; i <= maxDepth; i++) {
+      const hashKeyList = listOfCollection.map((nodes) => nodes.map((node) => node._util.mapDepthDiffToHashKey.get(1)).filter(Boolean));
+      const commonHashKeyList = (0, import_lodash_es.intersection)(...hashKeyList);
+      listOfCollection = listOfCollection.map((nodes) => nodes.filter((node) => commonHashKeyList.includes(node._util.mapDepthDiffToHashKey.get(1))));
+      if (listOfCollection.every((collection) => collection.length > 0)) {
+        listOfCollection.forEach((col, index) => {
+          listOfNodeInfo[index].commonHashKeyNodesOrdered.push(col);
+        });
+      }
+    }
+    return listOfNodeInfo;
+  }
+  static createNodeHashKey(nodeList, mapHashKeyToString) {
+    const seed = this.createHashSeed(nodeList);
+    const hashKey = this.createHashKey(seed);
+    mapHashKeyToString.set(hashKey, seed);
+    return hashKey;
+  }
+};
+AstFeatUtil.skipHashCreateTypes = ["Program", "File", "ExportDeclaration"];
+AstFeatUtil.invalidNodeKey = [
+  "comments",
+  "tokens"
+];
+// 忽略的 节点类型
+AstFeatUtil.AstNodeTypeConf = /* @__PURE__ */ new Map([
+  ["ImportDeclaration", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT
+    ]
+  }],
+  ["TypeAlias", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["VExpressionContainer", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["VStartTag", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE
+    ]
+  }],
+  ["VEndTag", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE
+    ]
+  }],
+  ["VText", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["VDocumentFragment", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["CommentLine", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT
+    ]
+  }],
+  ["CommentBlock", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT
+    ]
+  }],
+  ["JSXIdentifier", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["JSXAttribute", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["EmptyStatement", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["JSXText", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }],
+  ["JSXClosingElement", {
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }]
+]);
+AstFeatUtil.validRuleListOfAstNodeType = [
+  {
+    test: (astNode) => /^TS\w+/.test(astNode.type),
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  },
+  {
+    test: (astNode) => /Literal$/.test(astNode.type),
+    FEATURE_LEVEL: [
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+      import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL
+    ]
+  }
+];

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

@@ -0,0 +1,70 @@
+import { FileSegment, MapFilePathToDetail } from "./FileUtil";
+import AstFeatUtil, { AstFeatNode, MapHashKeyToAstNodeSet } from "./AstFeatUtil";
+export default class Core {
+    static createMarkdownFile(result: {
+        list: {
+            content: string;
+            location: string;
+        }[];
+        hashKey: string;
+    }[]): string;
+    static investigate(fileList: FileSegment[]): {
+        errorList: string[];
+        nodeTypeSet: Set<string>;
+        nodeContentGroupList: {
+            list: {
+                astNode: AstFeatNode;
+                location: string;
+                content: string;
+            }[];
+            listOfNodeInfo: {
+                rootNode: AstFeatNode;
+                edgeNodeCollection: AstFeatNode[];
+                commonHashKeyNodesOrdered: AstFeatNode[][];
+            }[];
+            nodeCount: number;
+            depth: number;
+            hashKey: string;
+        }[];
+        nodeGroupList: {
+            list: AstFeatNode[];
+            listOfNodeInfo: {
+                rootNode: AstFeatNode;
+                edgeNodeCollection: AstFeatNode[];
+                commonHashKeyNodesOrdered: AstFeatNode[][];
+            }[];
+            nodeCount: number;
+            depth: number;
+            hashKey: string;
+        }[];
+        countList: number[];
+        depthList: number[];
+    };
+    static getFileContentByLine(map: MapFilePathToDetail, filePath: string, start: number, end: number): {
+        location: string;
+        content: string;
+    };
+    static getListOfGroup(mapFilePathToDetail: MapFilePathToDetail, validFullNodeList: ReturnType<typeof Core.getListOfNodeGroup>['nodeGroupList']): {
+        list: {
+            astNode: AstFeatNode;
+            location: string;
+            content: string;
+        }[];
+        listOfNodeInfo: (typeof validFullNodeList)[number]["listOfNodeInfo"];
+        nodeCount: number;
+        depth: number;
+        hashKey: string;
+    }[];
+    static createMapHashKeyToAstNodeSet(fileList: FileSegment[]): readonly [MapHashKeyToAstNodeSet, Set<string>, string[]];
+    static getListOfNodeGroup(mapHashKeyToNodeSet: MapHashKeyToAstNodeSet): {
+        nodeGroupList: {
+            list: AstFeatNode[];
+            listOfNodeInfo: ReturnType<typeof AstFeatUtil.spreadSubNode>;
+            nodeCount: number;
+            depth: number;
+            hashKey: string;
+        }[];
+        countList: number[];
+        depthList: number[];
+    };
+}

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

@@ -0,0 +1,193 @@
+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/Core.ts
+var Core_exports = {};
+__export(Core_exports, {
+  default: () => Core
+});
+module.exports = __toCommonJS(Core_exports);
+var import_lodash_es = require("lodash-es");
+var import_FileUtil = __toESM(require("./FileUtil"));
+var import_AstFeatUtil = __toESM(require("./AstFeatUtil"));
+var Core = class {
+  static createMarkdownFile(result) {
+    let str = "# 共找到" + result.length + "组相似内容\n";
+    result.forEach((item, i) => {
+      const { list, hashKey } = item;
+      const depth = hashKey.split(":")[0];
+      str += `## 第${i + 1}组, 共${list.length}段, 匹配深度 ${depth}
+`;
+      list.forEach(({ content, location }, index) => {
+        const filepath = location.split(/\s+/)[0];
+        let ext = import_FileUtil.extensions.find((e) => filepath.includes(e));
+        ext = (ext == null ? void 0 : ext.slice(1)) || "";
+        str += `### 第${index + 1}段
+> ${location}
+\`\`\`${ext}
+${content}
+\`\`\`
+
+`;
+      });
+    });
+    return str;
+  }
+  static investigate(fileList) {
+    const mapFilePathToDetail = import_FileUtil.default.createMapFilePathToDetail(fileList);
+    const [mapHashKeyToTopLevelNode, nodeTypeSet, errorList] = this.createMapHashKeyToAstNodeSet(fileList);
+    const { nodeGroupList } = this.getListOfNodeGroup(mapHashKeyToTopLevelNode);
+    const nodeContentGroupList = this.getListOfGroup(mapFilePathToDetail, nodeGroupList);
+    return {
+      errorList,
+      nodeTypeSet,
+      nodeContentGroupList,
+      nodeGroupList,
+      countList: nodeContentGroupList.map((e) => e.nodeCount).sort((a, b) => a - b),
+      depthList: nodeContentGroupList.map((e) => e.depth).sort((a, b) => a - b)
+    };
+  }
+  static getFileContentByLine(map, filePath, start, end) {
+    const fixedStart = Math.max(start - 1, 0);
+    const content = map.get(filePath).lines.slice(fixedStart, end).join("\n");
+    const location = `${filePath}: from line ${start} to line ${end}`;
+    return { location, content };
+  }
+  static getListOfGroup(mapFilePathToDetail, validFullNodeList) {
+    const listOfGroup = [];
+    const locationStrSet = /* @__PURE__ */ new Set();
+    for (const item of validFullNodeList) {
+      const { listOfNodeInfo } = item;
+      const newList = listOfNodeInfo.map(({ rootNode, edgeNodeCollection }) => {
+        var _a;
+        const { filePath, startLine, endLine } = rootNode._util;
+        const linesNums = (0, import_lodash_es.range)(startLine, endLine + 1);
+        const edgeNodesLines = edgeNodeCollection.map((edgeNode) => {
+          const { startLine: itemStartLine, endLine: itemEndLine } = edgeNode._util;
+          if (itemStartLine === startLine || itemEndLine === endLine) {
+            return [];
+          }
+          return itemStartLine + 1 >= itemEndLine ? [] : (0, import_lodash_es.range)(itemStartLine + 1, itemEndLine);
+        }).flat();
+        const listOfRatedContent = [
+          {
+            linesNums: [],
+            lines: [],
+            rate: 0
+          }
+        ];
+        const lines = ((_a = mapFilePathToDetail.get(filePath)) == null ? void 0 : _a.lines) || [];
+        if (edgeNodesLines.length > 0) {
+          for (let i = startLine; i <= endLine; i++) {
+            const flag = edgeNodesLines.includes(i);
+            const rate = flag ? 1 : 0;
+            let lastRatedContent = listOfRatedContent[listOfRatedContent.length - 1];
+            if (lastRatedContent.rate !== rate) {
+              listOfRatedContent.push(lastRatedContent = {
+                linesNums: [],
+                lines: [],
+                rate
+              });
+            }
+            lastRatedContent.lines.push(lines[i - 1]);
+            lastRatedContent.linesNums.push(i);
+          }
+        } else {
+          listOfRatedContent.push({ linesNums, lines: lines.slice(Math.max(startLine - 1, 0), endLine), rate: 0 });
+        }
+        const { location, content } = this.getFileContentByLine(mapFilePathToDetail, filePath, startLine, endLine);
+        return { location, content, astNode: rootNode, listOfRatedContent };
+      });
+      const locationStr = newList.map((e) => e.location).join();
+      if (!locationStrSet.has(locationStr)) {
+        locationStrSet.add(locationStr);
+        const { nodeCount, depth, hashKey, listOfNodeInfo: listOfNodeInfo2 } = item;
+        listOfGroup.push({
+          nodeCount,
+          depth,
+          hashKey,
+          listOfNodeInfo: listOfNodeInfo2,
+          list: newList
+        });
+      }
+    }
+    return listOfGroup;
+  }
+  static createMapHashKeyToAstNodeSet(fileList) {
+    const mapHashKeyToTopLevelNode = /* @__PURE__ */ new Map();
+    const nodeTypeSet = /* @__PURE__ */ new Set();
+    const errorList = [];
+    fileList.forEach((file) => {
+      const { filePath, fileContent } = file;
+      const [errorMsg, parsedNode] = import_FileUtil.default.parseFile(filePath, fileContent);
+      if (parsedNode) {
+        AstUtil.deepFirstTravel(parsedNode, {
+          mapHashKeyToTopLevelNode,
+          nodeTypeSet
+        }, filePath);
+      } else if (errorMsg) {
+        errorList.push(errorMsg);
+      }
+    });
+    import_AstFeatUtil.default.deleteSameSubSetPartial(mapHashKeyToTopLevelNode);
+    return [mapHashKeyToTopLevelNode, nodeTypeSet, errorList];
+  }
+  static getListOfNodeGroup(mapHashKeyToNodeSet) {
+    const nodeGroupList = [];
+    const countPartialSet = /* @__PURE__ */ new Set();
+    const depthSet = /* @__PURE__ */ new Set();
+    for (const [hashKey, nodeSet] of mapHashKeyToNodeSet) {
+      if (nodeSet.size < 2) {
+        continue;
+      }
+      const baseNode = [...nodeSet][0];
+      let nodeCount = 0;
+      const index = hashKey.indexOf(":");
+      const depth = Number(hashKey.slice(0, index));
+      depthSet.add(depth);
+      const baseDepth = baseNode._util.depth;
+      nodeCount = baseNode._util.nodeCollection.filter((n) => n._util.depth - baseDepth <= depth).length;
+      countPartialSet.add(nodeCount);
+      const listOfNodeInfo = import_AstFeatUtil.default.spreadSubNode(nodeSet, depth);
+      nodeGroupList.push({
+        list: [...nodeSet],
+        listOfNodeInfo,
+        nodeCount,
+        depth,
+        hashKey
+      });
+    }
+    const countList = [...countPartialSet].sort((a, b) => a - b);
+    const depthList = [...depthSet].sort((a, b) => a - b);
+    return {
+      nodeGroupList,
+      countList,
+      depthList
+    };
+  }
+};

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

@@ -1,6 +1,6 @@
 import * as babelParse from "@babel/parser";
 import * as vueParse from "vue-eslint-parser";
-import { AstNode } from "./AstUtil";
+import { AstFeatNode } from "./AstFeatUtil";
 export declare const extensionsOfJs: string[];
 export declare const extensions: string[];
 export type MapFilePathToDetail = Map<string, FileSegment & {
@@ -14,6 +14,6 @@ export default class FileUtil {
     static parseVue(filePath: string, fileContent: string): vueParse.AST.ESLintProgram;
     static parseJsxLike(filePath: string, fileContent: string): babelParse.ParseResult<import("@babel/types").File>;
     static createMapFilePathToDetail(list: FileSegment[]): MapFilePathToDetail;
-    static parseFile(filePath: string, fileContent: string): [string, Omit<AstNode, '_util'> | null];
-    static getASTByFilePath(filePath: string): Omit<AstNode, "_util"> | null;
+    static parseFile(filePath: string, fileContent: string): [string, Omit<AstFeatNode, '_util'> | null];
+    static getASTByFilePath(filePath: string): Omit<AstFeatNode, "_util"> | null;
 }

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

@@ -31,7 +31,7 @@ export declare function createDetectReport(arg: Arg): {
         kind: "Import" | "Declaration" | "Assignment" | "SelfUpdate" | "Invoke" | "Other" | "Never";
     }[];
     filePath: string;
-    type: "modify" | "add" | "delete";
+    type: "add" | "delete" | "modify";
     filesDependsOnMe: string[];
     dangerIdentifiers: string[];
 }[];

package/dist/cjs/util/shared/astNodeFeatureExtractorMap.d.ts

@@ -0,0 +1,2 @@
+import { AstFeatNode } from "../ast_util/AstFeatUtil";
+export declare const astNodeFeatureExtractorMap: Map<string, (a: AstFeatNode) => string>;

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

@@ -0,0 +1,59 @@
+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/shared/astNodeFeatureExtractorMap.ts
+var astNodeFeatureExtractorMap_exports = {};
+__export(astNodeFeatureExtractorMap_exports, {
+  astNodeFeatureExtractorMap: () => astNodeFeatureExtractorMap
+});
+module.exports = __toCommonJS(astNodeFeatureExtractorMap_exports);
+var import_featureLevel = require("./featureLevel");
+var astNodeFeatureExtractorMap = /* @__PURE__ */ new Map([
+  [
+    import_featureLevel.AST_NODE_FEATURE_LEVEL.LOOSE,
+    (a) => a.type
+  ],
+  [
+    import_featureLevel.AST_NODE_FEATURE_LEVEL.NORMAL,
+    (n) => {
+      if (typeof n.name === "object") {
+        return n.type + ":" + n.name.name;
+      } else if (typeof n.name === "string") {
+        return n.type + ":" + n.name;
+      }
+      return n.type;
+    }
+  ],
+  [
+    import_featureLevel.AST_NODE_FEATURE_LEVEL.EXACT,
+    (n) => {
+      if (typeof n.name === "object") {
+        return n.type + ":" + n.name.name;
+      } else if (typeof n.name === "string") {
+        return n.type + ":" + n.name;
+      } else if (n.extra && "raw" in n.extra) {
+        return n.type + ":" + n.extra.raw;
+      }
+      return n.type;
+    }
+  ]
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  astNodeFeatureExtractorMap
+});

package/dist/cjs/util/shared/featureLevel.d.ts

@@ -0,0 +1,5 @@
+export declare const AST_NODE_FEATURE_LEVEL: {
+    LOOSE: string;
+    NORMAL: string;
+    EXACT: string;
+};

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

@@ -0,0 +1,33 @@
+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/shared/featureLevel.ts
+var featureLevel_exports = {};
+__export(featureLevel_exports, {
+  AST_NODE_FEATURE_LEVEL: () => AST_NODE_FEATURE_LEVEL
+});
+module.exports = __toCommonJS(featureLevel_exports);
+var AST_NODE_FEATURE_LEVEL = {
+  LOOSE: "LOOSE",
+  NORMAL: "NORMAL",
+  EXACT: "EXACT"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AST_NODE_FEATURE_LEVEL
+});

package/dist/cjs/util/shared/readDirFiles.d.ts

@@ -0,0 +1,4 @@
+export declare function readSrcFiles(dirOfCwd?: string): Promise<{
+    filePath: string;
+    fileContent: string;
+}[]>;

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

@@ -0,0 +1,45 @@
+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/shared/readDirFiles.ts
+var readDirFiles_exports = {};
+__export(readDirFiles_exports, {
+  readSrcFiles: () => readSrcFiles
+});
+module.exports = __toCommonJS(readDirFiles_exports);
+var import_fs = require("fs");
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var exclude = [/node_modules/, /\.d\.ts$/, /\.umi/];
+function readSrcFiles(dirOfCwd) {
+  const dir = (0, import_path.join)(process.cwd(), dirOfCwd || "src");
+  const fileItems = (0, import_utils.readDirFiles)({
+    dir,
+    exclude
+  });
+  return Promise.all(fileItems.map((item) => {
+    return {
+      filePath: item.filePath,
+      fileContent: (0, import_fs.readFileSync)(item.filePath, "utf-8")
+    };
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readSrcFiles
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -21,19 +21,24 @@
     "bin"
   ],
   "bin": {
-    "detect": "bin/detect.js"
+    "detect": "bin/detect.js",
+    "sameCodeDetect": "bin/sameCodeDetect.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/lodash-es": "^4.17.12",
     "@types/madge": "^5.0.3",
     "father": "^4.6.3"
   },
   "dependencies": {
     "@babel/parser": "^7.28.3",
     "@umijs/utils": "^4.4.12",
+    "crypto-js": "^4.2.0",
     "dayjs": "^1.11.13",
+    "lodash-es": "^4.17.21",
     "madge": "^8.0.0",
     "vue-eslint-parser": "^10.2.0"
   }