@ithinkdt/lint 4.0.0-2 → 4.0.0-201

package/src/index.js

@@ -1,100 +1,255 @@
-import { config as tsconfig } from 'typescript-eslint'
-import vue from 'eslint-plugin-vue'
+import { env } from 'node:process'
 
-import base, { disableJsTypeChecked, tsparser, vueparser } from './base.js'
+import unocss from '@unocss/eslint-config/flat'
+import { mergeProcessors } from 'eslint-merge-processors'
+import tsdoc from 'eslint-plugin-tsdoc'
+import processorVueBlocks from 'eslint-processor-vue-blocks'
 
-export default tsconfig(
-    ...base,
-    ...vue.configs['flat/recommended'],
-    {
-        settings: {
-            'import-x/resolver': {
-                'custom-alias': {
-                    alias: { '@': './src' },
-                    extensions: ['.js', '.jsx', '.ts', 'tsx'],
+import { base, defaultEsFiles, defaultJsFiles, defaultTsFiles, disableTypeChecked, playwright, tsParser, vitest, vue, vueParser } from './base.js'
+import ithinkdt from './rules/index.js'
+
+export * from './base.js'
+
+export default function config({ unocss: withUnoCSS, stylistic: withStylistic, tsconfigRootDir } = {}) {
+    const extraFileExtensions = ['.vue']
+
+    withStylistic = withStylistic === true
+        ? {
+                indent: 4,
+                quotes: 'single',
+                semi: false,
+                jsx: true,
+                braceStyle: '1tbs',
+            }
+        : withStylistic
+
+    return base({ inCI: !!env.CI && env.CI !== 'false', stylistic: withStylistic })
+        .append(
+            ithinkdt.configs.recommended,
+            vue.configs['flat/recommended'].map((it) => {
+                return {
+                    ...it,
+                    files: defaultEsFiles,
+                }
+            }),
+            {
+                files: defaultEsFiles,
+                languageOptions: {
+                    parser: tsParser,
+                    parserOptions: {
+                        project: true,
+                        tsconfigRootDir,
+                        sourceType: 'module',
+                        ecmaVersion: 'latest',
+                    },
                 },
-                typescript: {
-                    project: true,
+                rules: {
+                    'vue/block-lang': ['warn', {
+                        script: {
+                            lang: ['ts', 'tsx'],
+                        },
+                    }],
+                    'vue/block-order': ['error', {
+                        order: ['script', 'template', 'style'],
+                    }],
+                    'vue/component-name-in-template-casing': ['error',
+                        'PascalCase',
+                    ],
+                    'vue/component-options-name-casing': ['error',
+                        'PascalCase',
+                    ],
+                    // this is deprecated
+                    'vue/component-tags-order': 'off',
+                    'vue/custom-event-name-casing': ['error',
+                        'camelCase',
+                    ],
+                    'vue/define-macros-order': ['warn', {
+                        order: ['definePage', 'defineOptions', 'defineModel', 'defineProps', 'defineEmits', 'defineSlots'],
+                    }],
+                    'vue/dot-location': ['error',
+                        'property',
+                    ],
+                    'vue/dot-notation': ['error', {
+                        allowKeywords: true,
+                    }],
+                    'vue/eqeqeq': ['error',
+                        'smart',
+                    ],
+                    'vue/no-mutating-props': ['error', {
+                        shallowOnly: true,
+                    }],
+                    'vue/html-indent': ['error',
+                        withStylistic?.indent,
+                    ],
+                    'vue/html-quotes': ['error',
+                        'double',
+                    ],
+                    'vue/max-attributes-per-line': 'off',
+                    'vue/multi-word-component-names': 'off',
+                    'vue/no-dupe-keys': 'off',
+                    'vue/no-empty-pattern': 'error',
+                    'vue/no-irregular-whitespace': 'error',
+                    'vue/no-loss-of-precision': 'error',
+                    'vue/no-restricted-syntax': ['error',
+                        'DebuggerStatement',
+                        'LabeledStatement',
+                        'WithStatement',
+                    ],
+                    'vue/no-restricted-v-bind': ['error',
+                        '/^v-/',
+                    ],
+                    'vue/no-setup-props-reactivity-loss': 'off',
+                    'vue/no-sparse-arrays': 'error',
+                    'vue/no-unused-refs': 'error',
+                    'vue/no-useless-v-bind': 'error',
+                    'vue/no-v-html': 'off',
+                    'vue/object-shorthand': ['error',
+                        'always',
+                        {
+                            avoidQuotes: true,
+                            ignoreConstructors: false,
+                        },
+                    ],
+                    'vue/prefer-separate-static-class': 'error',
+                    'vue/prefer-template': 'error',
+                    'vue/prop-name-casing': ['error',
+                        'camelCase',
+                    ],
+                    'vue/require-default-prop': 'off',
+                    'vue/require-prop-types': 'off',
+                    'vue/space-infix-ops': 'error',
+                    'vue/space-unary-ops': ['error', {
+                        nonwords: false,
+                        words: true,
+                    }],
+                    'vue/array-bracket-spacing': ['error',
+                        'never',
+                    ],
+                    'vue/arrow-spacing': ['error', {
+                        after: true,
+                        before: true,
+                    }],
+                    'vue/block-spacing': ['error',
+                        'always',
+                    ],
+                    'vue/block-tag-newline': ['error', {
+                        multiline: 'always',
+                        singleline: 'always',
+                    }],
+                    'vue/brace-style': ['error',
+                        'stroustrup',
+                        { allowSingleLine: true },
+                    ],
+                    'vue/comma-dangle': ['error',
+                        'always-multiline',
+                    ],
+                    'vue/comma-spacing': ['error', {
+                        after: true,
+                        before: false,
+                    }],
+                    'vue/comma-style': ['error',
+                        'last',
+                    ],
+                    'vue/html-comment-content-spacing': ['error',
+                        'always',
+                        { exceptions: ['-'] },
+                    ],
+                    'vue/key-spacing': ['error', {
+                        afterColon: true,
+                        beforeColon: false,
+                    }],
+                    'vue/keyword-spacing': ['error', {
+                        after: true,
+                        before: true,
+                    }],
+                    'vue/object-curly-newline': 'off',
+                    'vue/object-curly-spacing': ['error',
+                        'always',
+                    ],
+                    'vue/object-property-newline': ['error', {
+                        allowAllPropertiesOnSameLine: true,
+                    }],
+                    'vue/operator-linebreak': ['error',
+                        'before',
+                    ],
+                    'vue/padding-line-between-blocks': ['error',
+                        'always',
+                    ],
+                    'vue/quote-props': ['error',
+                        'consistent-as-needed',
+                    ],
+                    'vue/space-in-parens': ['error',
+                        'never',
+                    ],
+                    'vue/template-curly-spacing': 'error',
+                    'vue/singleline-html-element-content-newline': ['warn', {
+                        ignoreWhenNoAttributes: true,
+                        ignoreWhenEmpty: true,
+                    }],
                 },
             },
-        },
-        rules: {
-            // 关闭 vue 代码风格规则
-            'vue/html-self-closing': 'off',
-            'vue/max-len': 'off',
-            'vue/array-bracket-newline': 'off',
-            'vue/array-bracket-spacing': 'off',
-            'vue/array-element-newline': 'off',
-            'vue/arrow-spacing': 'off',
-            'vue/block-spacing': 'off',
-            'vue/block-tag-newline': 'off',
-            'vue/brace-style': 'off',
-            'vue/comma-dangle': 'off',
-            'vue/comma-spacing': 'off',
-            'vue/comma-style': 'off',
-            'vue/dot-location': 'off',
-            'vue/func-call-spacing': 'off',
-            'vue/html-closing-bracket-newline': 'off',
-            'vue/html-closing-bracket-spacing': 'off',
-            'vue/html-end-tags': 'off',
-            'vue/html-indent': 'off',
-            'vue/html-quotes': 'off',
-            'vue/key-spacing': 'off',
-            'vue/keyword-spacing': 'off',
-            'vue/max-attributes-per-line': 'off',
-            'vue/multiline-html-element-content-newline': 'off',
-            'vue/multiline-ternary': 'off',
-            'vue/mustache-interpolation-spacing': 'off',
-            'vue/no-extra-parens': 'off',
-            'vue/no-multi-spaces': 'off',
-            'vue/no-spaces-around-equal-signs-in-attribute': 'off',
-            'vue/object-curly-newline': 'off',
-            'vue/object-curly-spacing': 'off',
-            'vue/object-property-newline': 'off',
-            'vue/operator-linebreak': 'off',
-            'vue/quote-props': 'off',
-            'vue/script-indent': 'off',
-            'vue/singleline-html-element-content-newline': 'off',
-            'vue/space-in-parens': 'off',
-            'vue/space-infix-ops': 'off',
-            'vue/space-unary-ops': 'off',
-            'vue/template-curly-spacing': 'off',
-        },
-    },
 
-    {
-        languageOptions: {
-            parser: tsparser,
-            parserOptions: {
-                sourceType: 'module',
-                ecmaVersion: 'latest',
-                project: true,
+            {
+                files: [...defaultJsFiles, ...defaultTsFiles],
+                rules: {
+                    'vue/one-component-per-file': 'off',
+                },
             },
-        },
-    },
-    {
-        files: ['**/*.vue'],
-        languageOptions: {
-            parser: vueparser,
-            parserOptions: {
-                sourceType: 'module',
-                ecmaVersion: 'latest',
-                parser: {
-                    js: 'espree',
-                    jsx: 'espree',
-                    ts: tsparser,
-                    tsx: tsparser,
+
+            {
+                files: ['**/*.vue'],
+                processor: mergeProcessors([
+                    vue.processors['vue'],
+                    processorVueBlocks({
+                        blocks: {
+                            styles: true,
+                            customBlocks: false,
+                            // Usually it's not recommended to lint <script> and <template>
+                            // As eslint-plugin-vue already provides the support
+                            script: false,
+                            template: false,
+                        },
+                    }),
+                ]),
+                languageOptions: {
+                    parser: vueParser,
+                    parserOptions: {
+                        project: true,
+                        extraFileExtensions,
+                        sourceType: 'module',
+                        ecmaVersion: 'latest',
+                        parser: {
+                            js: 'espree',
+                            jsx: 'espree',
+                            ts: tsParser,
+                            tsx: tsParser,
+                        },
+                    },
                 },
-                project: true,
+                plugins: { tsdoc },
+                rules: {
+                    // 启用 tsdoc 扫描
+                    'tsdoc/syntax': 'warn',
+                    /** script setup 不能开启此规则 */
+                    'import-x/exports-last': 'off',
+                    // 不允许使用标记为 @deprecated 的代码
+                    'ts/no-deprecated': 'warn',
+                },
+            },
+
+            {
+                files: ['**/tests/unit/**'],
+                ...vitest.configs['recommended'],
+            },
+
+            {
+                files: ['**/tests/e2e/**'],
+                ...playwright.configs['flat/recommended'],
             },
-        },
-        rules: {
-            // 启用 tsdoc 扫描
-            'tsdoc/syntax': 'warn',
 
-            // 启用 已弃用API 扫描
-            'deprecation/deprecation': 'error',
-        },
-    },
-    disableJsTypeChecked,
-)
+            withUnoCSS ? unocss : {},
+            disableTypeChecked,
+        ).renamePlugins({
+            vitest: 'test',
+        })
+}

package/src/rules/index.js

@@ -0,0 +1,26 @@
+import { noRelativeParentImportRule } from './no-relative-parent-imports.js'
+import { preferImportAliasRule } from './prefer-import-alias.js'
+
+const rules = {
+    'no-relative-parent-imports': noRelativeParentImportRule,
+    'prefer-import-alias': preferImportAliasRule,
+}
+
+const configs = {
+    recommended: {
+        plugins: {
+            '@ithinkdt': { rules },
+        },
+        rules: {
+            '@ithinkdt/no-relative-parent-imports': 'warn',
+            '@ithinkdt/prefer-import-alias': 'warn',
+        },
+    },
+}
+
+const plugin = {
+    rules,
+    configs,
+}
+
+export default plugin

package/src/rules/no-relative-parent-imports.js

@@ -0,0 +1,54 @@
+import path from 'node:path'
+
+export const noRelativeParentImportRule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            description: 'Suggests import use project path',
+            category: 'Suggestions',
+            recommended: true,
+            suggestion: true,
+        },
+    },
+
+    create: (context) => {
+        const aliasModuleDeclarations = (node) => {
+            const importModuleName = node.source?.value
+            if (
+                !node.source?.range
+                || typeof importModuleName !== 'string'
+                || importModuleName[0] !== '.'
+                || importModuleName[1] !== '.'
+            )
+                return
+
+            const moduleFilename = path
+                .resolve(path.dirname(context.filename), importModuleName)
+                .slice(context.cwd.length + 1)
+
+            return context.report({
+                node,
+                message: `relative parent import not suggested`,
+                suggest: [
+                    {
+                        desc: `replace '${importModuleName}' with '${moduleFilename}'`,
+                        fix: (fixer) => {
+                            return fixer.replaceTextRange(
+                                [node.source.range[0] + 1, node.source.range[1] - 1],
+                                moduleFilename,
+                            )
+                        },
+                    },
+                ],
+            })
+        }
+
+        return {
+            ExportAllDeclaration: aliasModuleDeclarations,
+            ExportNamedDeclaration: aliasModuleDeclarations,
+            ImportDeclaration: aliasModuleDeclarations,
+            ImportExpression: aliasModuleDeclarations,
+        }
+    },
+}

package/src/rules/prefer-import-alias.js

@@ -0,0 +1,66 @@
+const getAliasSuggestion = (importModuleName, range, pathAlias) => {
+    if (!range || typeof importModuleName !== 'string' || importModuleName[0] === '.' || importModuleName[0] === '/')
+        return
+
+    let matchedAlias
+    for (const alias of pathAlias) {
+        if (
+            (importModuleName === alias[1] || importModuleName.startsWith(alias[1] + '/'))
+            && (!matchedAlias || matchedAlias.length < alias[0].length)
+        ) {
+            matchedAlias = alias
+        }
+    }
+    if (!matchedAlias) return
+
+    const aliasSuggestion = matchedAlias[0] + importModuleName.slice(matchedAlias[1].length)
+
+    if (aliasSuggestion) {
+        return {
+            message: `import ${importModuleName} can be written as ${aliasSuggestion}`,
+            suggest: [
+                {
+                    desc: `replace '${importModuleName}' with '${aliasSuggestion}'`,
+                    fix: (fixer) => {
+                        return fixer.replaceTextRange([range[0] + 1, range[1] - 1], aliasSuggestion)
+                    },
+                },
+            ],
+        }
+    }
+}
+
+export const preferImportAliasRule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            description: 'Suggests shortest matching alias',
+            category: 'Suggestions',
+            recommended: true,
+            suggestion: true,
+        },
+    },
+
+    create: (context) => {
+        const pathAlias = (context.settings['import/resolver'] ?? context.settings['import-x/resolver'])?.['custom-alias']?.alias
+
+        if (!pathAlias) {
+            return {}
+        }
+
+        const aliasModuleDeclarations = (node) => {
+            const problem = getAliasSuggestion(node.source?.value, node.source?.range, Object.entries(pathAlias))
+            if (problem) {
+                context.report({ ...problem, node })
+            }
+        }
+
+        return {
+            ExportAllDeclaration: aliasModuleDeclarations,
+            ExportNamedDeclaration: aliasModuleDeclarations,
+            ImportDeclaration: aliasModuleDeclarations,
+            ImportExpression: aliasModuleDeclarations,
+        }
+    },
+}

package/src/stylelint.d.ts

@@ -1,4 +1,4 @@
 import { Config } from 'stylelint'
 
-declare const config: Config
+declare const config: (config?: Config) => Config
 export default config

package/src/stylelint.js

@@ -1,49 +1,25 @@
-import order from 'stylelint-order'
-
-import scss from 'stylelint-config-standard-scss'
+import std from 'stylelint-config-standard'
 import vue from 'stylelint-config-standard-vue'
-import vuescss from 'stylelint-config-standard-vue/scss/index.js'
-
-import postcsshtml from 'postcss-html'
-import postcssscss from 'postcss-scss'
+import order from 'stylelint-order'
 
 /**
  * @type {import('stylelint').Config}
  */
-export default {
-    extends: [scss, vue, vuescss],
-    plugins: [...order],
-    overrides: [
-        {
-            files: ['**/*.(scss|css|vue|html)'],
-            customSyntax: postcssscss,
-        },
-        {
-            files: ['**/*.(html|vue)'],
-            customSyntax: postcsshtml(),
+export default function config(config = {}) {
+    return {
+        extends: [std, vue, config],
+        plugins: [...order],
+        ignoreFiles: ['**/*.js', '**/*.jsx', '**/*.tsx', '**/*.ts', '**/*.json', '**/*.md', '**/*.yaml'],
+        rules: {
+            'selector-class-pattern': [
+                /^([a-z][\da-z]*)((-{1,2}|_{1,2})[\da-z]+)*$/,
+                {
+                    message: selector => `Expected class selector "${selector}" to be kebab-case or bem`,
+                },
+            ],
+            'custom-property-empty-line-before': [
+                'never',
+            ],
         },
-    ],
-    ignoreFiles: ['**/*.js', '**/*.jsx', '**/*.tsx', '**/*.ts', '**/*.json', '**/*.md', '**/*.yaml'],
-    rules: {
-        'no-descending-specificity': [false],
-        'selector-pseudo-element-no-unknown': [
-            true,
-            {
-                ignorePseudoElements: ['v-deep'],
-            },
-        ],
-        'selector-pseudo-class-no-unknown': [
-            true,
-            {
-                ignorePseudoClasses: ['deep'],
-            },
-        ],
-
-        'selector-class-pattern': [
-            /^([a-z][\da-z]*)((-{1,2}|_{1,2})[\da-z]+)*$/,
-            {
-                message: (selector) => `Expected class selector "${selector}" to be kebab-case or bem`,
-            },
-        ],
-    },
+    }
 }

package/src/{typescript-eslint-parser-for-extra-files → tsparser-for-extra-files}/index.js

@@ -1,13 +1,12 @@
 import { parser as tsEslintParser } from 'typescript-eslint'
 
 import { TSServiceManager } from './ts.js'
-
 import { getProjectConfigFiles } from './utils/get-project-config-files.js'
 import { resolveProjectList } from './utils/resolve-project-list.js'
 
 export const meta = {
     name: 'typescript-eslint-parser-for-extra-files',
-    version: '0.7.0',
+    version: '0.8.0',
 }
 
 const DEFAULT_EXTRA_FILE_EXTENSIONS = ['.vue']
@@ -19,7 +18,7 @@ export function parseForESLint(code, options = {}) {
     }
     const extraFileExtensions = options.extraFileExtensions || DEFAULT_EXTRA_FILE_EXTENSIONS
     const programs = []
-    for (const option of iterateOptions(options)) {
+    for (const option of _iterateOptions(options)) {
         programs.push(tsServiceManager.getProgram(code, option))
     }
     const filePath = options.filePath
@@ -32,7 +31,7 @@ export function parseForESLint(code, options = {}) {
     return tsEslintParser.parseForESLint(code, parserOptions)
 }
 
-function* iterateOptions(options) {
+function* _iterateOptions(options) {
     if (!options) {
         throw new Error('`parserOptions` is required.')
     }

package/src/{typescript-eslint-parser-for-extra-files → tsparser-for-extra-files}/transform.js

@@ -1,20 +1,8 @@
 import path from 'node:path'
 
-import { parse, compileScript } from '@vue/compiler-sfc'
+import { compileScript, parse } from '@vue/compiler-sfc'
 
-export function transformExtraFile(code, context) {
-    const ext = path.extname(context.filePath)
-    const transform = ext === '.vue' ? transformForVue : () => code
-    try {
-        return transform(code, context)
-    } catch {
-        // ignore
-    }
-
-    return code
-}
-
-function transformForVue(code, context) {
+function _transformForVue(code, context) {
     if (context.current) {
         return code
     }
@@ -26,3 +14,15 @@ function transformForVue(code, context) {
 
     return compiled.content
 }
+
+export function transformExtraFile(code, context) {
+    const ext = path.extname(context.filePath)
+    const transform = ext === '.vue' ? _transformForVue : () => code
+    try {
+        return transform(code, context)
+    } catch {
+        // ignore
+    }
+
+    return code
+}