xshell 1.3.40 → 1.3.41

package/xlint.js

@@ -1,24 +1,27 @@
+import fs from 'node:fs';
+import { builtinModules } from 'node:module';
 import { AST_TOKEN_TYPES, ASTUtils, TSESTree } from '@typescript-eslint/utils';
 import TSParser from '@typescript-eslint/parser';
 import ts_plugin from '@typescript-eslint/eslint-plugin';
 import react_plugin from 'eslint-plugin-react';
-import import_plugin from 'eslint-plugin-import';
 import stylistic_plugin from '@stylistic/eslint-plugin';
-const line_break_pattern = /\r\n|[\r\n\u2028\u2029]/u;
+import { check } from "./utils.js";
+import { path } from "./path.js";
+// 用 ast explorer 选 esprima 来看
+// 或者 https://explorer.eslint.org/
+// node.loc.start.line 下标从 1 开始
 const meta = {
     fixable: 'whitespace',
     type: 'layout',
 };
-const UNIONS = ['|', '&'];
-// 用 ast explorer 选 esprima 来看
-// node.loc.start.line 下标从 1 开始
 export const xlint_plugin = {
     rules: {
         'fold-jsdoc-comments': {
             meta,
-            create: context => ({
+            // @ts-ignore
+            create: (context) => ({
                 Program() {
-                    for (const comment of context.sourceCode.getAllComments())
+                    for (const comment of context.sourceCode.ast.comments)
                         if (comment.type === 'Block') {
                             const lines = comment.value.split(line_break_pattern);
                             if (lines.length >= 3 &&
@@ -30,7 +33,8 @@ export const xlint_plugin = {
                                         start: comment.loc.start,
                                         end: comment.loc.end
                                     },
-                                    message: 'Redundant jsdoc comment.',
+                                    // @ts-ignore
+                                    message: 'jsdoc 注释格式错误',
                                     fix(fixer) {
                                         const indent = ' '.repeat(comment.loc.start.column);
                                         const indenter = (line) => line.replace(/^\s*\*\s?/u, `${indent}    `);
@@ -55,11 +59,13 @@ export const xlint_plugin = {
         //     body
         'nonblock-statement-body-position-with-indentation': {
             meta,
+            // @ts-ignore
             create(context) {
                 const source = context.sourceCode;
                 const lines = source.getLines();
                 function lint(body, node) {
                     if (body.type !== 'BlockStatement') {
+                        // @ts-ignore
                         const token_before = source.getTokenBefore(body);
                         let indent = 0;
                         const line = lines[node.loc.start.line - 1];
@@ -73,6 +79,7 @@ export const xlint_plugin = {
                         if (token_before.loc.end.line === body.loc.start.line ||
                             body.loc.start.column !== indent + 4)
                             context.report({
+                                // @ts-ignore
                                 node: body,
                                 message: 'Expected a linebreak before this statement.',
                                 fix: fixer => fixer.replaceTextRange([token_before.range[1], body.range[0]], '\n' + ' '.repeat(indent + 4))
@@ -99,6 +106,7 @@ export const xlint_plugin = {
         // function foo () { }
         'empty-bracket-spacing': {
             meta,
+            // @ts-ignore
             create(context) {
                 const source = context.sourceCode;
                 return {
@@ -107,6 +115,7 @@ export const xlint_plugin = {
                         if (node.properties.length === 0 && source.getText(node) === '{}')
                             context.report({
                                 node,
+                                // @ts-ignore
                                 message: 'Expected a space in this empty object.',
                                 fix: fixer => fixer.replaceText(node, '{ }')
                             });
@@ -116,6 +125,7 @@ export const xlint_plugin = {
                         if (node.elements.length === 0 && source.getText(node) === '[]')
                             context.report({
                                 node,
+                                // @ts-ignore
                                 message: 'Expected a space in this empty array.',
                                 fix: fixer => fixer.replaceText(node, '[ ]')
                             });
@@ -124,6 +134,7 @@ export const xlint_plugin = {
                         if (node.body.length === 0 && source.getText(node) === '{}')
                             context.report({
                                 node,
+                                // @ts-ignore
                                 message: 'Expected a space in this empty block.',
                                 fix: fixer => fixer.replaceText(node, '{ }')
                             });
@@ -318,7 +329,7 @@ export const xlint_plugin = {
                     types.forEach(type => {
                         const skipFunctionParenthesis = type.type === TSESTree.AST_NODE_TYPES.TSFunctionType ? ASTUtils.isNotOpeningBraceToken : 0;
                         const operator = sourceCode.getTokenBefore(type, skipFunctionParenthesis);
-                        if (operator && UNIONS.includes(operator.value)) {
+                        if (operator && unions.includes(operator.value)) {
                             const prev = sourceCode.getTokenBefore(operator);
                             const next = sourceCode.getTokenAfter(operator);
                             if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next))
@@ -354,11 +365,12 @@ export const xlint_plugin = {
             }
         },
         // for (;;)
-        //     1;
+        //     1
         // for (let i = 0;  i < 10;  i++)
         // for (  ;  i < 10;  )
         'space-in-for-statement': {
             meta,
+            // @ts-ignore
             create(context) {
                 const source = context.sourceCode;
                 return {
@@ -382,6 +394,7 @@ export const xlint_plugin = {
                                             start: semi0_prev.loc.end,
                                             end: semi0.loc.start
                                         },
+                                        // @ts-ignore
                                         message: 'for 语句第一个分号前面应该没有多余空格',
                                         node,
                                         fix: fixer => fixer.removeRange([semi0_prev.range[1], semi0.range[0]])
@@ -395,6 +408,7 @@ export const xlint_plugin = {
                                         start: semi0_prev.loc.end,
                                         end: semi0.loc.start
                                     },
+                                    // @ts-ignore
                                     message: 'for 语句第一个分号前面应该为 2 个空格',
                                     node,
                                     fix: fixer => fixer.replaceTextRange([semi0_prev.range[1], semi0.range[0]], '  ')
@@ -407,6 +421,7 @@ export const xlint_plugin = {
                                         start: semi0.loc.end,
                                         end: semi0_next.loc.start
                                     },
+                                    // @ts-ignore
                                     message: 'for 语句第一个分号后面应为 2 个空格',
                                     node,
                                     fix: fixer => fixer.replaceTextRange([semi0.range[1], semi0_next.range[0]], '  ')
@@ -421,6 +436,7 @@ export const xlint_plugin = {
                                             start: test_end.loc.end,
                                             end: semi1.loc.start,
                                         },
+                                        // @ts-ignore
                                         message: 'for 语句第二个分号前面没有多余的空格',
                                         node,
                                         fix: fixer => fixer.removeRange([test_end.range[1], semi1.range[0]])
@@ -433,6 +449,7 @@ export const xlint_plugin = {
                                         start: semi1.loc.end,
                                         end: semi1_next.loc.start
                                     },
+                                    // @ts-ignore
                                     message: 'for 语句第二个分号后面应为 2 个空格',
                                     node,
                                     fix: fixer => fixer.replaceTextRange([semi1.range[1], semi1_next.range[0]], '  ')
@@ -446,6 +463,7 @@ export const xlint_plugin = {
                                         start: semi0_prev.loc.end,
                                         end: semi0.loc.start
                                     },
+                                    // @ts-ignore
                                     message: '无条件 for 语句第一个分号前面应该没有空格',
                                     node,
                                     fix: fixer => fixer.removeRange([semi0_prev.range[1], semi0.range[0]])
@@ -457,6 +475,7 @@ export const xlint_plugin = {
                                         start: semi0.loc.end,
                                         end: semi0_next.loc.start
                                     },
+                                    // @ts-ignore
                                     message: '无条件 for 语句第一个分号后面应该没有空格',
                                     node,
                                     fix: fixer => fixer.removeRange([semi0.range[1], semi0_next.range[0]])
@@ -468,12 +487,13 @@ export const xlint_plugin = {
                                         start: semi1.loc.end,
                                         end: semi1_next.loc.start
                                     },
+                                    // @ts-ignore
                                     message: '无条件 for 语句第二个分号后面应该没有空格',
                                     node,
                                     fix: fixer => fixer.removeRange([semi1.range[1], semi1_next.range[0]])
                                 });
                         }
-                    },
+                    }
                 };
             }
         },
@@ -484,6 +504,7 @@ export const xlint_plugin = {
         // return <div>1234</div>
         'jsx-no-redundant-parenthesis-in-return': {
             meta,
+            // @ts-ignore
             create(context) {
                 const source = context.sourceCode;
                 return {
@@ -500,6 +521,7 @@ export const xlint_plugin = {
                                         start: paren0.loc.start,
                                         end: paren1.loc.end
                                     },
+                                    // @ts-ignore
                                     message: 'return jsx 表达式不应该有多余的括号',
                                     node,
                                     fix: fixer => ([
@@ -523,6 +545,7 @@ export const xlint_plugin = {
                                         start: paren0.loc.start,
                                         end: paren1.loc.end
                                     },
+                                    // @ts-ignore
                                     message: 'return jsx 表达式不应该有多余的括号',
                                     node,
                                     fix: fixer => ([
@@ -538,6 +561,7 @@ export const xlint_plugin = {
         },
         'keep-indent': {
             meta,
+            // @ts-ignore
             create(context) {
                 const source = context.sourceCode;
                 const lines = source.getLines();
@@ -554,6 +578,7 @@ export const xlint_plugin = {
                                     const node = source.getNodeByRangeIndex(index);
                                     if (node && node.type !== 'Program')
                                         context.report({
+                                            // @ts-ignore
                                             message: '空行应保留与上一个区块相同的缩进',
                                             loc: { start: pos, end: pos },
                                             fix: fixer => fixer.replaceTextRange([index, index], ' '.repeat(last_line.indent))
@@ -568,15 +593,20 @@ export const xlint_plugin = {
         },
         'func-style': {
             meta,
+            // @ts-ignore
             create(context) {
                 const source = context.sourceCode;
                 let stack = [];
-                const fix = (fixer, node) => fixer.replaceText(node.parent.parent, `${node.async ? 'async ' : ''}function ${node.generator ? '* ' : ''}` +
+                const fix = (fixer, node) => fixer.replaceText(
+                // @ts-ignore
+                node.parent.parent, `${node.async ? 'async ' : ''}function ${node.generator ? '* ' : ''}` +
                     // todo: 丢失了泛型参数 const foo = <D = Zippable> (xxx: D) => { }，如何加回来？
                     node.parent.id.name +
                     ' (' +
+                    // @ts-ignore
                     node.params.map(param => source.getText(param)).join(', ') +
                     ') ' +
+                    // @ts-ignore
                     source.getText(node.body));
                 return {
                     FunctionDeclaration(node) {
@@ -592,6 +622,7 @@ export const xlint_plugin = {
                             node.parent.parent.declarations.length === 1)
                             context.report({
                                 node: node.parent.parent,
+                                // @ts-ignore
                                 message: '函数应该使用 function foo { } 这样来声明而不是 const foo = function () { }',
                                 loc: node.parent.parent.loc,
                                 fix: fixer => fix(fixer, node)
@@ -616,6 +647,7 @@ export const xlint_plugin = {
                             node.body.type === 'BlockStatement' && node.body.body.length)
                             context.report({
                                 node: node.parent.parent,
+                                // @ts-ignore
                                 message: '多条语句的函数应该使用 function foo { } 这样来声明而不是 const foo = () => { }',
                                 loc: node.parent.parent.loc,
                                 fix: fixer => fix(fixer, node)
@@ -624,6 +656,109 @@ export const xlint_plugin = {
                 };
             }
         },
+        // 读取文件中所有的 ImportDeclaration，每个 decl 包括前面的注释，收集起来
+        // 检查这些 decl 是连续的，即中间没有其他语句（中间有语句分割的，需要手动修复）
+        // 检查、解析 decl 中的 source (from '...' 中的 ...) 做解析和替换:
+        //      处理 alias, 相对路径，区分外部包，解析 .ts, .tsx
+        // 排序 decl
+        // 在 Program:exit 的时候，检查是否有顺序不一致的，一旦有，就通过 replaceTextRange 用已排序的 decls 重新生成替换
+        import: {
+            meta,
+            // @ts-ignore
+            create(context) {
+                let imports = [];
+                // 检查、解析 decl 中的 source (from '...' 中的 ...) 做解析和替换
+                // 这里不能用异步操作，很恶心
+                const cwd = context.cwd.fpd;
+                const pkgs = get_packages(cwd);
+                const aliases = get_tsconfig_aliases(cwd);
+                // console.log('pkgs:', pkgs)
+                // console.log('aliases:', aliases)
+                let need_fix_source = false;
+                return {
+                    // 格式化 source, 收集 decl
+                    ImportDeclaration(node) {
+                        const source = node.source.value;
+                        const [type, source_] = format_source(pkgs, aliases, cwd, context.filename.fp, source);
+                        if (!source_ || source_ === source) {
+                            imports.push({
+                                node,
+                                type,
+                                style: style_fexts.has(source.fext)
+                            });
+                            return;
+                        }
+                        need_fix_source = true;
+                        console.log(`自动修复 ${source} -> ${source_}`);
+                        context.report({
+                            // @ts-ignore
+                            message: `import source ${source} 应该改为 ${source_}`,
+                            node,
+                            loc: node.source.loc,
+                            fix: fixer => fixer.replaceTextRange(node.source.range, source_.quote())
+                        });
+                    },
+                    // 排序 decl 整体替换修复
+                    'Program:exit'() {
+                        if (need_fix_source || imports.length <= 1)
+                            return;
+                        const { sourceCode: source } = context;
+                        const { body } = source.ast;
+                        const first = imports[0].node;
+                        const ifirst = body.indexOf(first);
+                        if (body.indexOf(imports.last.node, ifirst + 1) - ifirst !== imports.length - 1) {
+                            context.report({
+                                // @ts-ignore
+                                message: 'import 语句不连续，中间有其他语句，无法自动排序修复，需手动修复',
+                                node: first
+                            });
+                            return;
+                        }
+                        // 检查顺序并修复: 样式 xxx.sass < nodejs builtin < package < alias < subpath
+                        // 如果为样式，则放前面，其他的就按照数组来
+                        let imports_ = imports.toSorted((a, b) => {
+                            if (a.style !== b.style)
+                                return a.style ? -1 : 1;
+                            return imtypes.indexOf(a.type) - imtypes.indexOf(b.type);
+                        });
+                        for (let i = 0; i < imports.length; i++) {
+                            let im = imports[i];
+                            let im_ = imports_[i];
+                            if (im.node === im_.node)
+                                continue;
+                            context.report({
+                                // @ts-ignore
+                                message: `第 ${i} 个 import 顺序不对`,
+                                node: im.node,
+                                fix(fixer) {
+                                    let _start = Number.MAX_SAFE_INTEGER, _end = 0;
+                                    let type;
+                                    // 收集所有排序后的 import 文本
+                                    const texts = imports_.map((im, i) => {
+                                        const [start, end] = get_range_with_comments(source, im.node);
+                                        if (start < _start)
+                                            _start = start;
+                                        if (end > _end)
+                                            _end = end;
+                                        let text = source.text.slice(start, end);
+                                        // 分组之间空一行
+                                        if (im.type !== type) {
+                                            if (type)
+                                                text = '\n' + text;
+                                            type = im.type;
+                                        }
+                                        return text;
+                                    });
+                                    // 一次性替换所有 import
+                                    return fixer.replaceTextRange([_start, _end], texts.join_lines());
+                                }
+                            });
+                            break;
+                        }
+                    }
+                };
+            }
+        }
         // 规则太复杂了，暂时写不出来
         // ... color ? [ ] : [
         //     '-c', 'color.status=false', 
@@ -755,7 +890,6 @@ export const xlint_config = {
     plugins: {
         '@typescript-eslint': ts_plugin,
         react: react_plugin,
-        import: import_plugin,
         '@stylistic': stylistic_plugin,
         xlint: xlint_plugin,
     },
@@ -889,6 +1023,9 @@ export const xlint_config = {
         ]
     }
 };
+const line_break_pattern = /\r\n|[\r\n\u2028\u2029]/u;
+const style_fexts = new Set(['sass', 'css', 'scss', 'less', 'styl']);
+const unions = ['|', '&'];
 function split_indent(line) {
     let i = 0;
     let indent = 0;
@@ -910,4 +1047,157 @@ function not_opening_paren(token) {
 function not_closing_paren(token) {
     return !([')', ']', '}'].includes(token.value) && token.type === 'Punctuator');
 }
+function all_space(str, len = str.length) {
+    for (let i = 0; i < len; ++i)
+        if (str[i] !== ' ')
+            return false;
+    return true;
+}
+/** 获取节点前面的注释，并计算包含注释的范围 */
+function get_range_with_comments(source, node) {
+    let [start, end] = node.range;
+    // 获取节点前的所有注释
+    let comments = source.getCommentsBefore(node);
+    if (comments.length !== 0) {
+        // 从最后一个注释往前找，遇到属于上一条语句的行尾注释或非注释时退出
+        // 判断标准：独立注释以多个空格 + // 或者 /* 开头
+        // 行尾注释：// 前面含有非空格
+        let valid_comment;
+        for (let i = comments.length - 1; i >= 0; --i) {
+            let comment = comments[i];
+            // 获取 comment 所在行的内容
+            let line = source.lines[comment.loc.start.line - 1];
+            // 找到注释开始标记 // 或 /* 在行中的位置
+            let istart;
+            if (comment.type === 'Line')
+                istart = line.indexOf('//');
+            else // Block
+                istart = line.indexOf('/*');
+            // 注释标记之前是否全是空格
+            if (!all_space(line.slice(0, istart)))
+                break;
+            valid_comment = comment;
+        }
+        // 如果有有效的注释，更新 start
+        if (valid_comment)
+            start = valid_comment.range[0];
+    }
+    let comments_ = source.getCommentsAfter(node);
+    // 和导入在同一行，在尾部的注释
+    if (comments_[0]?.loc.start.line === node.loc.end.line)
+        end = comments_[0].range[1];
+    return [start, end];
+}
+let cache_alias_cwd;
+let cache_alias;
+/** 解析 tsconfig.json 中的 paths 配置
+    返回 `{ alias: string, fp: string }[]`
+    - alias: 导入别名前缀（如 `@lib/`）
+    - fp: 对应的路径前缀（如 `./lib/`）
+    
+    处理规则：
+    - value 数组必须只有一项
+    - 如果 key 和 value 都以 `/*` 结尾，去掉 `*`
+    - 否则 value 就是具体文件路径 */
+function get_tsconfig_aliases(cwd) {
+    if (cwd === cache_alias_cwd)
+        return cache_alias;
+    // 读取文件内容，移除 // 行注释
+    const { compilerOptions } = JSON.parse(fs.readFileSync(`${cwd}tsconfig.json`, 'utf-8')
+        .split_lines()
+        .filter(line => !line.trimStart().startsWith('//'))
+        .join_lines());
+    const paths = compilerOptions?.paths;
+    if (!paths)
+        return [];
+    const aliases = Object.entries(paths).map(([key, values]) => {
+        // 检查 value 数组只有一项
+        check(values?.length === 1, `paths 的 value 数组必须只有一项`);
+        const value = values[0];
+        // key 和 value 都以 /* 结尾，去掉 *
+        if (key.endsWith('/*') && value.endsWith('/*'))
+            return {
+                alias: key.slice(0, -1), // @lib/* -> @lib/
+                fp: value.slice(0, -1).strip_if_start('./') // ./lib/* -> lib/
+            };
+        // 具体文件路径的情况
+        return {
+            alias: key,
+            fp: value.strip_if_start('./')
+        };
+    });
+    cache_alias_cwd = cwd;
+    return cache_alias = aliases;
+}
+let cache_pkgs_cwd;
+let cache_pkgs;
+function get_packages(cwd) {
+    if (cache_pkgs_cwd === cwd)
+        return cache_pkgs;
+    const { dependencies = {}, devDependencies = {} } = JSON.parse(fs.readFileSync(`${cwd}package.json`, 'utf-8'));
+    const pkgs = [...Object.keys(dependencies), ...Object.keys(devDependencies)];
+    cache_pkgs_cwd = cwd;
+    return cache_pkgs = pkgs;
+}
+/** import types */
+const imtypes = ['builtin', 'package', 'alias', 'subpath'];
+/** 将一个有后缀或无后缀的文件，解析到实际文件，并通过 alias 简化 */
+function format_source(pkgs, aliases, cwd, fp, source) {
+    check(path.isAbsolute(fp), 'fp 应该是绝对路径');
+    if (source.startsWith('node:'))
+        return ['builtin'];
+    if (builtins.has(source))
+        return ['builtin', `node:${source}`];
+    const pkg = pkgs.find(p => source === p || source.startsWith(p) && source[p.length] === '/');
+    if (pkg) {
+        if (pkgs.includes(pkg) || source.fext)
+            return ['package'];
+        // package.json 中有 exports 的，也允许无后缀（可能 .js 没有导出）
+        const pkg_json = JSON.parse(fs.readFileSync(`${cwd}node_modules/${pkg}/package.json`, 'utf-8'));
+        if (pkg_json.exports)
+            return ['package'];
+        return ['package', `${source}.js`];
+    }
+    // 剩下的全是内部路径
+    // 相对子路径
+    if (source.startsWith('./')) {
+        const { fext } = source;
+        // 已经完美了
+        if (fext && fext !== 'js')
+            return ['subpath'];
+        source = source.strip_if_end('.js');
+        return ['subpath', `${source}.${resolve_suffix(path.resolve(fp.fdir, source))}`];
+    }
+    // ../ 父级路径，或者 @/... 等 alias 路径
+    // 先 resolve 到完整路径，再修复后缀，最后通过 alias 简化
+    const alias = aliases.find(({ alias }) => source.startsWith(alias));
+    if (alias)
+        source = cwd + alias.fp + source.strip_start(alias.alias);
+    // 是完整路径了
+    source = path.resolve(fp.fdir, source);
+    const { fext } = source;
+    if (!fext || fext === 'js') {
+        source = source.strip_if_end('.js');
+        source = `${source}.${resolve_suffix(source)}`;
+    }
+    const relative = source.strip_start(cwd, true);
+    const alias_ = aliases.find(({ fp }) => relative.startsWith(fp));
+    check(alias_, '一定能找到匹配的 alias');
+    return ['alias', alias_.alias + relative.strip_start(alias_.fp)];
+}
+let cache_exists = new Map();
+function resolve_suffix(fp_base) {
+    for (const suffix of ['ts', 'tsx']) {
+        const fp = `${fp_base}.${suffix}`;
+        const c = cache_exists.get(fp);
+        if (c !== undefined)
+            return suffix;
+        const e = fs.existsSync(fp);
+        cache_exists.set(fp, e);
+        if (e)
+            return suffix;
+    }
+    throw new Error(`无法解析 ${fp_base} 到文件`);
+}
+const builtins = new Set(builtinModules);
 //# sourceMappingURL=xlint.js.map