eslint-plugin-light 1.0.19 → 1.0.21

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## <small>1.0.21 (2026-01-04)</small>
+
+* feat(eslint-plugin-light): add no-src-imports-in-components rule ([b960951](https://github.com/novlan1/plugin-light/commits/b960951))
+
+
+
+## <small>1.0.20 (2025-12-18)</small>
+
+* feat(project-config-pixui): add try-catch for version-info ([775fb7b](https://github.com/novlan1/plugin-light/commits/775fb7b))
+
+
+
 ## <small>1.0.19 (2025-12-12)</small>
 
 * chore: update docs ([dc64df7](https://github.com/novlan1/plugin-light/commits/dc64df7))

package/README.md

@@ -592,6 +592,215 @@ module.exports = {
 | ------ | -------- | ----------------------------------- |
 | regexp | 匹配正则 | `/\[[^\](]*\.\d+[a-zA-Z]+[^\]]*\]/` |
 
+### 4.17. valid-pmd-import
+
+禁止在 `packages/xx` 目录下引入对应的 `pmd-xx` 包，需要使用相对路径。
+
+这个规则主要用于 monorepo 项目中，防止包内部引入自己的发布版本，而是使用相对路径引入源码，避免循环依赖和版本不一致问题。
+
+比如，在 `packages/components` 目录下：
+
+```js
+// ❌ 错误：引入自己的包名
+import { Button } from 'pmd-components';
+const utils = require('pmd-components/lib/utils');
+
+// ✅ 正确：使用相对路径
+import { Button } from '../src';
+const utils = require('../../src/utils');
+```
+
+如果加了 `--fix`，会被自动转换为相对路径。
+
+Usage:
+
+```js
+// .eslintrc.js
+
+module.exports = {
+  plugins: [
+    'light',
+  ],
+  rules: {
+    'light/valid-pmd-import': 2,
+  },
+}
+```
+
+配置选项：
+
+| 字段    | 说明             | 默认值  |
+| ------- | ---------------- | ------- |
+| baseDir | 包源码的基础目录 | `'src'` |
+
+例如，如果你的包源码不在 `src` 目录：
+
+```js
+// .eslintrc.js
+
+module.exports = {
+  plugins: [
+    'light',
+  ],
+  rules: {
+    'light/valid-pmd-import': [2, {
+      baseDir: 'lib'
+    }],
+  },
+}
+```
+
+该规则会检查以下导入方式：
+
+- ES6 `import` 语句
+- CommonJS `require()` 调用
+- 动态 `import()` 表达式
+- `export ... from` 语句
+
+### 4.18. no-src-imports-in-components
+
+#### 4.18.1. 规则说明
+
+禁止在指定目录下使用特定前缀的导入路径，强制使用相对路径。这个规则主要用于确保某些目录（如 `src/components`）中的代码可以被独立发布为 npm 包，不依赖项目的绝对路径导入。
+
+#### 4.18.2. 为什么需要这个规则？
+
+当你的项目中某些目录（如 `src/components`）需要被发布为独立的 npm 包时，这些目录中的代码不应该使用项目特定的绝对路径（如 `src/...`），而应该使用相对路径。这样可以确保：
+
+1. 代码的可移植性
+2. 包的独立性
+3. 避免发布后的路径解析问题
+
+#### 4.18.3. 配置选项
+
+```typescript
+{
+  restrictedPaths: string[],    // 需要限制的目录路径列表
+  bannedPrefixes: string[],     // 禁止使用的导入路径前缀列表
+  message?: string              // 自定义错误消息（可选）
+}
+```
+
+#### 4.18.4. 使用示例
+
+##### 4.18.4.1. 基本用法（使用默认配置）
+
+```typescript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'light/no-src-imports-in-components': 'error',
+  },
+};
+```
+
+默认配置：
+
+- `restrictedPaths`: `['src/components']`
+- `bannedPrefixes`: `['src']`
+
+##### 4.18.4.2. 自定义配置
+
+```typescript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'light/no-src-imports-in-components': ['error', {
+      // 指定多个需要限制的目录
+      restrictedPaths: ['src/components', 'src/lib', 'packages/ui'],
+      
+      // 指定多个禁止的导入前缀
+      bannedPrefixes: ['src', '@/', '~/'],
+      
+      // 可选：自定义错误消息
+      message: '该目录将被发布为独立包，请使用相对路径导入',
+    }],
+  },
+};
+```
+
+##### 4.18.4.3. 只检查特定目录
+
+```typescript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'light/no-src-imports-in-components': ['error', {
+      restrictedPaths: ['src/components'],
+      bannedPrefixes: ['src'],
+    }],
+  },
+};
+```
+
+#### 4.18.5. 错误示例
+
+假设配置为：
+
+```typescript
+{
+  restrictedPaths: ['src/components'],
+  bannedPrefixes: ['src']
+}
+```
+
+在 `src/components/Button/Button.tsx` 中：
+
+```typescript
+// ❌ 错误：使用了 src 开头的导入
+import { back } from 'src/app/route/route';
+import { utils } from 'src/utils/helper';
+
+// ✅ 正确：使用相对路径
+import { back } from '../../app/route/route';
+import { utils } from '../../utils/helper';
+
+// ✅ 正确：导入 npm 包
+import React from 'react';
+import { Button } from 'antd';
+```
+
+#### 4.18.6. 配置参数详解
+
+##### 4.18.6.1. restrictedPaths
+
+类型：`string[]`  
+默认值：`['src/components']`
+
+指定需要应用此规则的目录列表。规则会检查文件路径是否包含这些目录。
+
+示例：
+
+```typescript
+restrictedPaths: ['src/components', 'src/lib', 'packages/ui']
+```
+
+##### 4.18.6.2. bannedPrefixes
+
+类型：`string[]`  
+默认值：`['src']`
+
+指定禁止使用的导入路径前缀列表。任何以这些前缀开头的导入都会被标记为错误。
+
+示例：
+
+```typescript
+bannedPrefixes: ['src', '@/', '~/']
+```
+
+##### 4.18.6.3. message
+
+类型：`string`  
+默认值：无（使用默认错误消息）
+
+自定义错误消息。如果不设置，将使用默认消息模板。
+
+示例：
+
+```typescript
+message: '该目录将被发布为独立的 npm 包，请使用相对路径导入'
+```
+
 ## 5. 更新日志
 
 [点此查看](./CHANGELOG.md)

package/lib/rules/no-src-imports-in-components.js

@@ -0,0 +1,101 @@
+'use strict';
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '禁止在指定目录下使用特定前缀的导入路径，必须使用相对路径',
+      category: 'Best Practices',
+      recommended: true,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          restrictedPaths: {
+            type: 'array',
+            description: '需要限制的目录路径列表',
+            items: {
+              type: 'string',
+            },
+            default: ['src/components'],
+          },
+          bannedPrefixes: {
+            type: 'array',
+            description: '禁止使用的导入路径前缀列表',
+            items: {
+              type: 'string',
+            },
+            default: ['src', 'src/'],
+          },
+          message: {
+            type: 'string',
+            description: '自定义错误消息',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      noSrcImport: '在 {{directory}} 目录下不允许使用 "{{prefix}}" 开头的导入路径，请使用相对路径。该目录会被发布为独立的 npm 包。',
+      customMessage: '{{message}}',
+    },
+  },
+
+  create(context) {
+    // 获取配置选项
+    const options = context.options[0] || {};
+    const restrictedPaths = options.restrictedPaths || ['src/components'];
+    const bannedPrefixes = options.bannedPrefixes || ['src'];
+    const customMessage = options.message;
+
+    return {
+      ImportDeclaration(node) {
+        // 获取当前文件的绝对路径
+        const filename = context.getFilename();
+
+        // 标准化路径（统一使用正斜杠）
+        const normalizedPath = filename.replace(/\\/g, '/');
+
+        // 检查文件是否在任何受限目录下
+        const matchedDirectory = restrictedPaths.find((restrictedPath) => {
+          const normalizedRestrictedPath = restrictedPath.replace(/\\/g, '/');
+          return normalizedPath.includes(`/${normalizedRestrictedPath}/`)
+                 || normalizedPath.includes(`/${normalizedRestrictedPath}`);
+        });
+
+        if (!matchedDirectory) {
+          return;
+        }
+
+        // 获取导入路径
+        const importPath = node.source.value;
+
+        // 检查是否使用了任何被禁止的前缀
+        const matchedPrefix = bannedPrefixes.find(prefix => importPath === prefix || importPath.startsWith(`${prefix}/`));
+
+        if (matchedPrefix) {
+          if (customMessage) {
+            context.report({
+              node: node.source,
+              messageId: 'customMessage',
+              data: {
+                message: customMessage,
+              },
+            });
+          } else {
+            context.report({
+              node: node.source,
+              messageId: 'noSrcImport',
+              data: {
+                directory: matchedDirectory,
+                prefix: matchedPrefix,
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/valid-pmd-import.js

@@ -0,0 +1,170 @@
+const path = require('path');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '禁止在 packages/xx 目录下引入对应的 pmd-xx 包，需要使用相对路径',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          baseDir: {
+            type: 'string',
+            description: '基础目录，默认为 src',
+            default: 'src',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const baseDir = options.baseDir || 'src';
+
+    const filename = context.getFilename();
+    const absolutePath = path.resolve(filename);
+
+    // 提取当前包名
+    const getCurrentPackage = (filePath) => {
+      const normalizedPath = path.normalize(filePath);
+      const match = normalizedPath.match(/packages[\\/]([^\\/]+)/);
+      return match ? match[1] : null;
+    };
+
+    const currentPackage = getCurrentPackage(absolutePath);
+    if (!currentPackage) {
+      return {};
+    }
+
+    const pmdPackageName = `pmd-${currentPackage}`;
+
+    /**
+     * 获取应该使用的相对路径
+     */
+    const getRelativePath = (importPath, currentFilePath) => {
+      // 移除包名前缀
+      const subPath = importPath.replace(pmdPackageName, '').replace(/^\/lib/, '');
+
+      const currentDir = path.dirname(currentFilePath);
+
+      // 查找当前包的根目录
+      const parts = absolutePath.split(path.sep);
+      const packageIndex = parts.findIndex((part, index) => part === 'packages' && parts[index + 1] === currentPackage);
+
+      if (packageIndex === -1) {
+        return '.'; // 回退到当前目录
+      }
+
+      // 构建包的根路径
+      const packageRootParts = parts.slice(0, packageIndex + 2);
+      const packageRoot = packageRootParts.join(path.sep);
+
+      // 构建目标路径
+      const targetRelative = subPath ? `${baseDir}${subPath}` : baseDir;
+      const targetPath = path.join(packageRoot, targetRelative);
+
+      // 计算相对路径
+      let relativePath = path.relative(currentDir, targetPath);
+
+      // 处理特殊情况
+      if (relativePath === '') {
+        relativePath = '.';
+      } else if (!relativePath.startsWith('.')) {
+        relativePath = `./${relativePath}`;
+      }
+
+      // 标准化路径分隔符
+      relativePath = relativePath.replace(/\\/g, '/');
+
+      return relativePath;
+    };
+
+    /**
+     * 获取引号字符
+     */
+    const getQuoteChar = (node, sourceCode) => {
+      if (node.source) {
+        const text = sourceCode.getText(node.source);
+        return text[0]; // 第一个字符应该是引号
+      } if (node.arguments && node.arguments[0]) {
+        const text = sourceCode.getText(node.arguments[0]);
+        return text[0];
+      }
+      return '\''; // 默认使用单引号
+    };
+
+    /**
+     * 获取需要修复的节点
+     */
+    const getFixNode = (node) => {
+      if (node.source) return node.source;
+      if (node.arguments && node.arguments[0]) return node.arguments[0];
+      return node;
+    };
+
+    /**
+     * 检查并报告非法引入
+     */
+    const checkAndReport = (node, importPath) => {
+      if (importPath && importPath.startsWith(pmdPackageName)) {
+        const sourceCode = context.getSourceCode();
+        const fixNode = getFixNode(node);
+
+        context.report({
+          node: fixNode,
+          message: `禁止在 packages/${currentPackage} 目录下引入 ${pmdPackageName}，请使用相对路径`,
+          data: { importPath },
+          fix(fixer) {
+            const relativePath = getRelativePath(importPath, absolutePath);
+            const quoteChar = getQuoteChar(node, sourceCode);
+            return fixer.replaceText(fixNode, `${quoteChar}${relativePath}${quoteChar}`);
+          },
+        });
+      }
+    };
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source && node.source.value) {
+          checkAndReport(node, node.source.value);
+        }
+      },
+
+      CallExpression(node) {
+        if (
+          node.callee
+          && node.callee.name === 'require'
+          && node.arguments.length > 0
+          && node.arguments[0].type === 'Literal'
+        ) {
+          checkAndReport(node, node.arguments[0].value);
+        }
+      },
+
+      ImportExpression(node) {
+        if (node.source && node.source.type === 'Literal') {
+          checkAndReport(node, node.source.value);
+        }
+      },
+
+      ExportNamedDeclaration(node) {
+        if (node.source && node.source.value) {
+          checkAndReport(node, node.source.value);
+        }
+      },
+
+      ExportAllDeclaration(node) {
+        if (node.source && node.source.value) {
+          checkAndReport(node, node.source.value);
+        }
+      },
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-light",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Simple Eslint Plugin",
   "keywords": [
     "eslint",
@@ -27,7 +27,7 @@
   "dependencies": {
     "minimatch": "^10.0.1",
     "requireindex": "^1.2.0",
-    "t-comm": "^3.0.3"
+    "t-comm": "^3.0.22"
   },
   "devDependencies": {
     "@babel/core": "^7.18.9",