1
// config/eslint-rules/no-cross-module-deep-import.mjs (节选片段)
2
create(context) {
3
  const checkImport = (node, importPath, isTypeOnly = false) => {
4
    // 1. 纯类型导入直接豁免，不造成运行时耦合
5
    if (isTypeOnly) return;
6

7
    // 2. 解析与格式化路径
8
    const normalizedImportPath = targetImportPath.replace(/^@src\//, '');
9
    const importParts = normalizedImportPath.split('/').filter(Boolean);
10

11
    // 3. 动态配置各核心目录的合法深度阈值
12
    const protectedRoots = {
13
      views: { depth: 3 },       // e.g. zed/views/AF (允许的根深度为3)
14
      components: { depth: 3 },  // e.g. zed/components/Button
15
      mobx: { depth: 4, subName: 'stores' }, // e.g. zed/mobx/stores/FileStore
16
    };
17
    const config = protectedRoots[importParts[1]];
18
    if (!config) return;
19

20
    // 4. 判定引入是否越界（深度大于根目录深度）
21
    if (importParts.length <= config.depth) return;
22

23
    // 5. 白名单放行：允许深入引入暴露的公共出口
24
    const extraPath = importParts.slice(config.depth).join('/');
25
    const allowedDeepPaths = /^((index(\.(tsx|ts|js|jsx))?)|constants(\.(ts|js))?|types(\/.*)?)$/;
26
    if (allowedDeepPaths.test(extraPath)) return;
27

28
    // 6. 模块内同源放行：属于同一个模块内部的代码可以随意互相引入
29
    if (currentModuleName === importedModuleName) return;
30

31
    // 7. 越界且非同源，触发红牌警告！
32
    context.report({
33
      node,
34
      messageId: 'deepImportForbidden',
35
      data: { sourceModule: currentModuleName, targetModule: importedModuleName, internalPath: extraPath }
36
    });
37
  };
38

39
  return {
40
    ImportDeclaration(node) { checkImport(node.source, node.source.value, node.importKind === 'type'); },
41
    ExportNamedDeclaration(node) { /* ... */ },
42
    ImportExpression(node) { /* ... */ }
43
  };
44
}

1
// config/eslint-rules/no-reverse-dependency.mjs (节选片段)
2
create(context) {
3
  // 维护了一份硬编码的绝对秩序架构层级表
4
  const layerConfig = {
5
    views: 1,      App: 1,
6
    components: 2,
7
    mobx: 3,       models: 3,
8
    hooks: 4,      utils: 4,
9
    types: 5,      constants: 5,
10
  };
11

12
  return {
13
    ImportDeclaration(node) {
14
      // 1. 获取当前文件所在的层级
15
      const sourceLayer = layerConfig[sourceModule];
16

17
      // 2. 获取试图 import 的目标文件层级
18
      const targetLayer = layerConfig[targetModule];
19

20
      // 3. 防腐判定：一旦当前层级数字大于目标层级（意味着底层的低权限模块引入了高层级模块）
21
      if (sourceLayer > 0 && targetLayer > 0 && sourceLayer > targetLayer) {
22
        context.report({
23
          node,
24
          message: `💩 架构规范：禁止反向依赖。 [${sourceModule}] 属于底层模块，不能直接依赖上层的 [${targetModule}]。`,
25
        });
26
      }
27
    }
28
  };
29
}

1
// 核心攀爬探测器：向上寻找真正的 React 组件宿主
2
function findReactComponentHost(node) {
3
  let currentNode = node.parent;
4

5
  while (currentNode) {
6
    // 1. 如果爬到了一个函数声明 (FunctionDeclaration / ArrowFunctionExpression)
7
    if (currentNode.type === 'FunctionDeclaration' || currentNode.type === 'ArrowFunctionExpression') {
8

9
      // 获取函数的名称
10
      const funcName = getFunctionName(currentNode);
11

12
      // 2. 误报排雷：如果是以 use 开头的自定义 Hook，绝对安全，立刻放行！
13
      if (/^use[A-Z]/.test(funcName)) {
14
        return { type: 'HOOK', node: currentNode };
15
      }
16

17
      // 3. 命中目标：首字母大写，且有 return JSX 语句，确认为 React 组件！
18
      if (/^[A-Z]/.test(funcName) && hasJSXReturn(currentNode)) {
19
        return { type: 'COMPONENT', node: currentNode, name: funcName };
20
      }
21
    }
22

23
    // 继续向上爬一层
24
    currentNode = currentNode.parent;
25
  }
26

27
  return { type: 'UNKNOWN', node: null };
28
}