js-code-detector 0.0.1

package/dist/cjs/util/ast_util/FileUtil.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/util/ast_util/FileUtil.ts
+var FileUtil_exports = {};
+__export(FileUtil_exports, {
+  default: () => FileUtil,
+  extensions: () => extensions,
+  extensionsOfJs: () => extensionsOfJs
+});
+module.exports = __toCommonJS(FileUtil_exports);
+var babelParse = __toESM(require("@babel/parser"));
+var vueParse = __toESM(require("vue-eslint-parser"));
+var extensionsOfJs = [".js", ".jsx", ".ts", ".tsx"];
+var extensions = [...extensionsOfJs, ".vue"];
+var commonParsePlugins = [
+  "jsx",
+  "typescript",
+  "asyncDoExpressions",
+  "decimal",
+  "decorators",
+  "decoratorAutoAccessors",
+  "deferredImportEvaluation",
+  "destructuringPrivate",
+  "doExpressions",
+  "explicitResourceManagement",
+  "exportDefaultFrom",
+  "functionBind",
+  "functionSent",
+  "importAttributes",
+  "importReflection",
+  "moduleBlocks",
+  ["optionalChainingAssign", {
+    version: "2023-07"
+  }],
+  "partialApplication",
+  ["pipelineOperator", {
+    proposal: "hack",
+    topicToken: "^^"
+  }],
+  "recordAndTuple",
+  "sourcePhaseImports",
+  "throwExpressions"
+];
+var FileUtil = class {
+  static parseVue(filePath, fileContent) {
+    return vueParse.parse(fileContent, {
+      vueFeatures: {
+        styleCSSVariableInjection: false,
+        filter: false
+      },
+      parser: {
+        parse: (...arg) => {
+          const ast = babelParse.parse(...arg);
+          return ast.program;
+        }
+      },
+      range: true,
+      ranges: true,
+      sourceType: "module",
+      // 指定源代码类型，这里是模块
+      filePath,
+      ecmaVersion: "latest",
+      "ecmaFeatures": {
+        "globalReturn": true,
+        "impliedStrict": true,
+        "jsx": true,
+        "tsx": true
+      },
+      plugins: commonParsePlugins
+    });
+  }
+  static parseJsxLike(filePath, fileContent) {
+    return babelParse.parse(fileContent, {
+      ranges: true,
+      allowReturnOutsideFunction: true,
+      allowImportExportEverywhere: true,
+      sourceType: "module",
+      sourceFilename: filePath,
+      plugins: commonParsePlugins
+    });
+  }
+  static createMapFilePathToDetail(list) {
+    return new Map(list.map(({ filePath, fileContent }) => {
+      const lines = fileContent.split("\n");
+      return [
+        filePath,
+        {
+          lines,
+          filePath,
+          fileContent
+        }
+      ];
+    }));
+  }
+  static parseFile(filePath, fileContent) {
+    try {
+      if (filePath.endsWith(".vue")) {
+        return ["", this.parseVue(filePath, fileContent)];
+      } else if (extensionsOfJs.some((ext) => filePath.endsWith(ext))) {
+        return ["", this.parseJsxLike(filePath, fileContent)];
+      }
+    } catch (e) {
+      return [filePath + "解析AST出错: " + e.message, null];
+    }
+    return ["", null];
+  }
+  static getASTByFilePath(filePath) {
+    const fileContent = require("fs").readFileSync(filePath, "utf8");
+    return this.parseFile(filePath, fileContent)[1];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extensions,
+  extensionsOfJs
+});

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

@@ -0,0 +1,5 @@
+import { AstNode } from "./AstUtil";
+export default function getAstKitByFilePath(filePath: string, absPathPrefix: string): {
+    mapFileLineToNodeSet: Map<number, Set<AstNode>>;
+    mapUuidToNode: Map<string, AstNode>;
+};

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

@@ -0,0 +1,52 @@
+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/getAstKitByFilePath.ts
+var getAstKitByFilePath_exports = {};
+__export(getAstKitByFilePath_exports, {
+  default: () => getAstKitByFilePath
+});
+module.exports = __toCommonJS(getAstKitByFilePath_exports);
+var import_AstUtil = __toESM(require("./AstUtil"));
+var import_FileUtil = __toESM(require("./FileUtil"));
+var mapFilePathToTools = /* @__PURE__ */ new Map();
+var createMapFileLineToNodeSet = (file, absPathPrefix) => {
+  const ast = import_FileUtil.default.getASTByFilePath(file);
+  const mapUuidToNode = /* @__PURE__ */ new Map();
+  const mapFileLineToNodeSet = /* @__PURE__ */ new Map();
+  const filePathRelative = file.replace(absPathPrefix, "");
+  import_AstUtil.default.deepFirstTravel(ast, filePathRelative, mapUuidToNode, mapFileLineToNodeSet);
+  return { mapFileLineToNodeSet, mapUuidToNode };
+};
+function getAstKitByFilePath(filePath, absPathPrefix) {
+  let tools = mapFilePathToTools.get(filePath);
+  if (!tools) {
+    mapFilePathToTools.set(filePath, tools = createMapFileLineToNodeSet(filePath, absPathPrefix));
+  }
+  return tools;
+}

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

@@ -0,0 +1 @@
+export declare const windowProperties: string[];

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

@@ -0,0 +1,228 @@
+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/windowProperties.ts
+var windowProperties_exports = {};
+__export(windowProperties_exports, {
+  windowProperties: () => windowProperties
+});
+module.exports = __toCommonJS(windowProperties_exports);
+var windowProperties = [
+  "close",
+  "stop",
+  "focus",
+  "blur",
+  "open",
+  "alert",
+  "confirm",
+  "prompt",
+  "print",
+  "postMessage",
+  "captureEvents",
+  "releaseEvents",
+  "getSelection",
+  "getComputedStyle",
+  "matchMedia",
+  "moveTo",
+  "moveBy",
+  "resizeTo",
+  "resizeBy",
+  "scroll",
+  "scrollTo",
+  "scrollBy",
+  "find",
+  "requestIdleCallback",
+  "cancelIdleCallback",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "reportError",
+  "btoa",
+  "atob",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "queueMicrotask",
+  "createImageBitmap",
+  "structuredClone",
+  "fetch",
+  "self",
+  "name",
+  "history",
+  "customElements",
+  "locationbar",
+  "menubar",
+  "personalbar",
+  "scrollbars",
+  "statusbar",
+  "toolbar",
+  "status",
+  "closed",
+  "event",
+  "frames",
+  "length",
+  "opener",
+  "parent",
+  "frameElement",
+  "navigator",
+  "clientInformation",
+  "external",
+  "screen",
+  "innerWidth",
+  "innerHeight",
+  "scrollX",
+  "pageXOffset",
+  "scrollY",
+  "pageYOffset",
+  "screenLeft",
+  "screenTop",
+  "screenX",
+  "screenY",
+  "outerWidth",
+  "outerHeight",
+  "performance",
+  "devicePixelRatio",
+  "ondevicemotion",
+  "ondeviceorientation",
+  "ondeviceorientationabsolute",
+  "visualViewport",
+  "crypto",
+  "onabort",
+  "onblur",
+  "onfocus",
+  "oncancel",
+  "onauxclick",
+  "onbeforeinput",
+  "onbeforetoggle",
+  "oncanplay",
+  "oncanplaythrough",
+  "onchange",
+  "onclick",
+  "onclose",
+  "oncontentvisibilityautostatechange",
+  "oncontextlost",
+  "oncontextmenu",
+  "oncontextrestored",
+  "oncuechange",
+  "ondblclick",
+  "ondrag",
+  "ondragend",
+  "ondragenter",
+  "ondragleave",
+  "ondragover",
+  "ondragstart",
+  "ondrop",
+  "ondurationchange",
+  "onemptied",
+  "onended",
+  "onformdata",
+  "oninput",
+  "oninvalid",
+  "onkeydown",
+  "onkeypress",
+  "onkeyup",
+  "onload",
+  "onloadeddata",
+  "onloadedmetadata",
+  "onloadstart",
+  "onmousedown",
+  "onmouseenter",
+  "onmouseleave",
+  "onmousemove",
+  "onmouseout",
+  "onmouseover",
+  "onmouseup",
+  "onwheel",
+  "onpause",
+  "onplay",
+  "onplaying",
+  "onprogress",
+  "onratechange",
+  "onreset",
+  "onresize",
+  "onscroll",
+  "onscrollend",
+  "onsecuritypolicyviolation",
+  "onseeked",
+  "onseeking",
+  "onselect",
+  "onslotchange",
+  "onstalled",
+  "onsubmit",
+  "onsuspend",
+  "ontimeupdate",
+  "onvolumechange",
+  "onwaiting",
+  "onselectstart",
+  "onselectionchange",
+  "ontoggle",
+  "onpointercancel",
+  "onpointerdown",
+  "onpointerup",
+  "onpointermove",
+  "onpointerout",
+  "onpointerover",
+  "onpointerenter",
+  "onpointerleave",
+  "ongotpointercapture",
+  "onlostpointercapture",
+  "onanimationend",
+  "onanimationiteration",
+  "onanimationstart",
+  "ontransitioncancel",
+  "ontransitionend",
+  "ontransitionrun",
+  "ontransitionstart",
+  "onwebkitanimationend",
+  "onwebkitanimationiteration",
+  "onwebkitanimationstart",
+  "onwebkittransitionend",
+  "onerror",
+  "speechSynthesis",
+  "onafterprint",
+  "onbeforeprint",
+  "onbeforeunload",
+  "onhashchange",
+  "onlanguagechange",
+  "onmessage",
+  "onmessageerror",
+  "onoffline",
+  "ononline",
+  "onpagehide",
+  "onpageshow",
+  "onpopstate",
+  "onrejectionhandled",
+  "onstorage",
+  "onunhandledrejection",
+  "onunload",
+  "localStorage",
+  "origin",
+  "crossOriginIsolated",
+  "isSecureContext",
+  "indexedDB",
+  "caches",
+  "sessionStorage",
+  "window",
+  "document",
+  "location",
+  "top"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  windowProperties
+});

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

@@ -0,0 +1,11 @@
+export type GitDiffDetail = {
+    filePath: string;
+    type: "add" | "delete" | "modify";
+    subType: "add" | "delete" | "modify";
+    startLineOfNew: string;
+    oldBranchLineScope: string;
+    startLineOfOld: string;
+    newBranchLineScope: string;
+    items: string[];
+};
+export declare function formatGitDiffContent(modifyContent: string): GitDiffDetail[];

package/dist/cjs/util/format_git_diff_content.js

@@ -0,0 +1,70 @@
+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/format_git_diff_content.ts
+var format_git_diff_content_exports = {};
+__export(format_git_diff_content_exports, {
+  formatGitDiffContent: () => formatGitDiffContent
+});
+module.exports = __toCommonJS(format_git_diff_content_exports);
+function formatGitDiffContent(modifyContent) {
+  const detailList = [];
+  if (typeof modifyContent !== "string") {
+    return detailList;
+  }
+  const lines = modifyContent.split(/\n/);
+  let filePath = "";
+  let mainType = "modify";
+  let subType = "modify";
+  lines.forEach((line, index) => {
+    var _a, _b;
+    if (line.startsWith("diff --git")) {
+      filePath = line.split(/\s+/)[2].slice(2);
+      mainType = ((_a = lines[index + 1]) == null ? void 0 : _a.startsWith("new file")) ? "add" : ((_b = lines[index + 1]) == null ? void 0 : _b.startsWith("deleted")) ? "delete" : "modify";
+    }
+    if (line.startsWith("@@")) {
+      const [, startLineOfOld, oldBranchLineScope, startLineOfNew, newBranchLineScope] = line.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*)/) || [];
+      if (newBranchLineScope === "0") {
+        subType = "delete";
+      } else if (oldBranchLineScope === "0") {
+        subType = "add";
+      } else {
+        subType = "modify";
+      }
+      detailList.push({
+        filePath,
+        type: mainType,
+        subType,
+        startLineOfNew,
+        newBranchLineScope: newBranchLineScope ? newBranchLineScope : "1",
+        startLineOfOld,
+        oldBranchLineScope: oldBranchLineScope ? oldBranchLineScope : "1",
+        items: []
+      });
+    }
+    if (line.startsWith("+") && !line.startsWith("+++") || line.startsWith("-") && !line.startsWith("---")) {
+      const lastItem = detailList[detailList.length - 1];
+      lastItem.type !== "delete" && lastItem.items.push(line);
+    }
+  });
+  return detailList;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatGitDiffContent
+});

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

@@ -0,0 +1,12 @@
+import { MadgeInstance } from "madge";
+interface IMadgeInstance extends MadgeInstance {
+    tree: Record<string, string[]>;
+}
+export default function (api: any): Promise<{
+    usingFiles: {
+        filePath: string;
+        name: string;
+    }[];
+    madgeInstance: IMadgeInstance;
+} | undefined>;
+export {};

package/dist/cjs/util/madge_util.js

@@ -0,0 +1,120 @@
+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/madge_util.ts
+var madge_util_exports = {};
+__export(madge_util_exports, {
+  default: () => madge_util_default
+});
+module.exports = __toCommonJS(madge_util_exports);
+var import_path = require("path");
+var import_utils = require("@umijs/utils");
+var MADGE_NAME = "madge";
+async function madge_util_default(api) {
+  var _a, _b;
+  const userAlias = api.config.alias;
+  if (!userAlias) {
+    console.log("userAlias -> null");
+    return;
+  }
+  const cwd = api.cwd;
+  const tsconfig = await import_utils.tsconfigPaths.loadConfig(cwd);
+  const exclude = [/node_modules/, /\.d\.ts$/, /\.umi/];
+  const isExclude = (path) => {
+    return exclude.some((reg) => reg.test(path));
+  };
+  const parsedAlias = import_utils.aliasUtils.parseCircleAlias({
+    alias: userAlias
+  });
+  const filteredAlias = Object.keys(parsedAlias).reduce(
+    (acc, key) => {
+      var _a2, _b2;
+      const value = parsedAlias[key];
+      if (isExclude(value)) {
+        return acc;
+      }
+      if ((_a2 = tsconfig.paths) == null ? void 0 : _a2[key]) {
+        return acc;
+      }
+      const tsconfigValue = [(0, import_path.join)((0, import_path.relative)(cwd, value), "/*")];
+      const tsconfigKey = `${key}/*`;
+      if ((_b2 = tsconfig.paths) == null ? void 0 : _b2[tsconfigKey]) {
+        return acc;
+      }
+      acc[tsconfigKey] = tsconfigValue;
+      return acc;
+    },
+    {}
+  );
+  const devTmpDir = (0, import_path.join)(api.paths.absSrcPath, ".umi");
+  const entryFile = (0, import_path.join)(devTmpDir, "umi.ts");
+  const exportsFile = (0, import_path.join)(devTmpDir, "exports.ts");
+  const madgePkg = (0, import_path.dirname)(
+    import_utils.resolve.sync(`${MADGE_NAME}/package.json`, {
+      basedir: cwd
+    })
+  );
+  const madge = require(madgePkg);
+  const madgeConfig = {
+    tsConfig: {
+      compilerOptions: {
+        baseUrl: tsconfig.baseUrl,
+        paths: {
+          ...filteredAlias,
+          ...tsconfig.paths,
+          umi: [exportsFile],
+          "@umijs/max": [exportsFile],
+          // 适配 bigfish
+          ...((_b = (_a = api.appData) == null ? void 0 : _a.umi) == null ? void 0 : _b.importSource) ? {
+            [api.appData.umi.importSource]: [exportsFile]
+          } : {}
+        },
+        target: "esnext",
+        module: "esnext",
+        moduleResolution: "node",
+        importHelpers: true,
+        jsx: "react-jsx",
+        esModuleInterop: true,
+        strict: true,
+        resolveJsonModule: true,
+        allowSyntheticDefaultImports: true
+      }
+    },
+    fileExtensions: ["ts", "tsx", "js", "jsx"],
+    excludeRegExp: exclude,
+    baseDir: cwd
+  };
+  const res = await madge(entryFile, madgeConfig);
+  const treeMap = res.tree;
+  const dependenceMap = Object.keys(treeMap).reduce(
+    (acc, key) => {
+      const path = (0, import_utils.winPath)((0, import_path.join)(api.paths.cwd, key));
+      acc[path] = true;
+      return acc;
+    },
+    {}
+  );
+  const usingFiles = (0, import_utils.readDirFiles)({
+    dir: api.paths.absSrcPath,
+    exclude
+  }).filter(({ filePath }) => dependenceMap[filePath]);
+  return {
+    usingFiles,
+    madgeInstance: res
+  };
+}

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

@@ -0,0 +1,27 @@
+import { AstNode } from "../ast_util/AstUtil";
+import { GitDiffDetail } from "../format_git_diff_content";
+type BlockReportKind = "Import" | "Declaration" | "Assignment" | "SelfUpdate" | "Invoke" | "Other" | "Never";
+type EffectItem = {
+    causeBy: AstNode;
+    effects: AstNode[];
+};
+export type BlockReport = {
+    kind: BlockReportKind;
+    diff_txt: string[];
+    topAdded: AstNode[];
+    topRemoved: AstNode[];
+    added: string[];
+    addedNotUsed: string[];
+    addedNotFound: string[];
+    addedEffects: EffectItem[];
+    removed: string[];
+    removedStillUsing: string[];
+    removedEffects: EffectItem[];
+};
+type Arg = {
+    gitDiffItem: GitDiffDetail;
+    absPathPrefix: string;
+    blockReports: BlockReport[];
+};
+export default function codeBlockDetect(arg: Arg): void;
+export {};