stacks 0.58.73 → 0.59.2

package/core/eslint-config/src/configs/svelte.ts

@@ -1,107 +0,0 @@
-import { ensurePackages, interopDefault } from '../utils'
-import type { FlatConfigItem, OptionsFiles, OptionsHasTypeScript, OptionsOverrides, OptionsStylistic } from '../types'
-import { GLOB_SVELTE } from '../globs'
-
-export async function svelte(
-  options: OptionsHasTypeScript & OptionsOverrides & OptionsStylistic & OptionsFiles = {},
-): Promise<FlatConfigItem[]> {
-  const {
-    files = [GLOB_SVELTE],
-    overrides = {},
-    stylistic = true,
-  } = options
-
-  const {
-    indent = 2,
-    quotes = 'single',
-  } = typeof stylistic === 'boolean' ? {} : stylistic
-
-  await ensurePackages([
-    'eslint-plugin-svelte',
-  ])
-
-  const [
-    pluginSvelte,
-    parserSvelte,
-  ] = await Promise.all([
-    interopDefault(import('eslint-plugin-svelte')),
-    interopDefault(import('svelte-eslint-parser')),
-  ] as const)
-
-  return [
-    {
-      name: 'antfu:svelte:setup',
-      plugins: {
-        svelte: pluginSvelte,
-      },
-    },
-    {
-      files,
-      languageOptions: {
-        parser: parserSvelte,
-        parserOptions: {
-          extraFileExtensions: ['.svelte'],
-          parser: options.typescript
-            ? await interopDefault(import('@typescript-eslint/parser')) as any
-            : null,
-        },
-      },
-      name: 'antfu:svelte:rules',
-      processor: pluginSvelte.processors['.svelte'],
-      rules: {
-        'import/no-mutable-exports': 'off',
-        'no-undef': 'off', // incompatible with most recent (attribute-form) generic types RFC
-        'no-unused-vars': ['error', {
-          args: 'none',
-          caughtErrors: 'none',
-          ignoreRestSiblings: true,
-          vars: 'all',
-          varsIgnorePattern: '^\\$\\$Props$',
-        }],
-
-        'svelte/comment-directive': 'error',
-        'svelte/no-at-debug-tags': 'warn',
-        'svelte/no-at-html-tags': 'error',
-        'svelte/no-dupe-else-if-blocks': 'error',
-        'svelte/no-dupe-style-properties': 'error',
-        'svelte/no-dupe-use-directives': 'error',
-        'svelte/no-dynamic-slot-name': 'error',
-        'svelte/no-export-load-in-svelte-module-in-kit-pages': 'error',
-        'svelte/no-inner-declarations': 'error',
-        'svelte/no-not-function-handler': 'error',
-        'svelte/no-object-in-text-mustaches': 'error',
-        'svelte/no-reactive-functions': 'error',
-        'svelte/no-reactive-literals': 'error',
-        'svelte/no-shorthand-style-property-overrides': 'error',
-        'svelte/no-unknown-style-directive-property': 'error',
-        'svelte/no-unused-svelte-ignore': 'error',
-        'svelte/no-useless-mustaches': 'error',
-        'svelte/require-store-callbacks-use-set-param': 'error',
-        'svelte/system': 'error',
-        'svelte/valid-compile': 'error',
-        'svelte/valid-each-key': 'error',
-
-        'unused-imports/no-unused-vars': [
-          'error',
-          { args: 'after-used', argsIgnorePattern: '^_', vars: 'all', varsIgnorePattern: '^(_|\\$\\$Props$)' },
-        ],
-
-        ...stylistic
-          ? {
-              'style/no-trailing-spaces': 'off', // superseded by svelte/no-trailing-spaces
-              'svelte/derived-has-same-inputs-outputs': 'error',
-              'svelte/html-closing-bracket-spacing': 'error',
-              'svelte/html-quotes': ['error', { prefer: quotes }],
-              'svelte/indent': ['error', { alignAttributesVertically: true, indent }],
-              'svelte/mustache-spacing': 'error',
-              'svelte/no-spaces-around-equal-signs-in-attribute': 'error',
-              'svelte/no-trailing-spaces': 'error',
-              'svelte/spaced-html-comment': 'error',
-            }
-          : {},
-
-        ...overrides,
-      },
-    },
-  ]
-}

package/core/eslint-config/src/configs/test.ts

@@ -1,54 +0,0 @@
-import { interopDefault } from '../utils'
-import type { FlatConfigItem, OptionsFiles, OptionsIsInEditor, OptionsOverrides } from '../types'
-import { GLOB_TESTS } from '../globs'
-
-export async function test(
-  options: OptionsFiles & OptionsIsInEditor & OptionsOverrides = {},
-): Promise<FlatConfigItem[]> {
-  const {
-    files = GLOB_TESTS,
-    isInEditor = false,
-    overrides = {},
-  } = options
-
-  const [
-    pluginVitest,
-    pluginNoOnlyTests,
-  ] = await Promise.all([
-    interopDefault(import('eslint-plugin-vitest')),
-    // @ts-expect-error missing types
-    interopDefault(import('eslint-plugin-no-only-tests')),
-  ] as const)
-
-  return [
-    {
-      name: 'antfu:test:setup',
-      plugins: {
-        test: {
-          ...pluginVitest,
-          rules: {
-            ...pluginVitest.rules,
-            // extend `test/no-only-tests` rule
-            ...pluginNoOnlyTests.rules,
-          },
-        },
-      },
-    },
-    {
-      files,
-      name: 'antfu:test:rules',
-      rules: {
-        'node/prefer-global/process': 'off',
-
-        'test/consistent-test-it': ['error', { fn: 'it', withinDescribe: 'it' }],
-        'test/no-identical-title': 'error',
-        'test/no-import-node-test': 'error',
-        'test/no-only-tests': isInEditor ? 'off' : 'error',
-        'test/prefer-hooks-in-order': 'error',
-        'test/prefer-lowercase-title': 'error',
-
-        ...overrides,
-      },
-    },
-  ]
-}

package/core/eslint-config/src/configs/toml.ts

@@ -1,72 +0,0 @@
-import type { FlatConfigItem, OptionsFiles, OptionsOverrides, OptionsStylistic } from '../types'
-import { GLOB_TOML } from '../globs'
-import { interopDefault } from '../utils'
-
-export async function toml(
-  options: OptionsOverrides & OptionsStylistic & OptionsFiles = {},
-): Promise<FlatConfigItem[]> {
-  const {
-    files = [GLOB_TOML],
-    overrides = {},
-    stylistic = true,
-  } = options
-
-  const {
-    indent = 2,
-  } = typeof stylistic === 'boolean' ? {} : stylistic
-
-  const [
-    pluginToml,
-    parserToml,
-  ] = await Promise.all([
-    interopDefault(import('eslint-plugin-toml')),
-    interopDefault(import('toml-eslint-parser')),
-  ] as const)
-
-  return [
-    {
-      name: 'antfu:toml:setup',
-      plugins: {
-        toml: pluginToml,
-      },
-    },
-    {
-      files,
-      languageOptions: {
-        parser: parserToml,
-      },
-      name: 'antfu:toml:rules',
-      rules: {
-        'style/spaced-comment': 'off',
-
-        'toml/comma-style': 'error',
-        'toml/keys-order': 'error',
-        'toml/no-space-dots': 'error',
-        'toml/no-unreadable-number-separator': 'error',
-        'toml/precision-of-fractional-seconds': 'error',
-        'toml/precision-of-integer': 'error',
-        'toml/tables-order': 'error',
-
-        'toml/vue-custom-block/no-parsing-error': 'error',
-
-        ...stylistic
-          ? {
-              'toml/array-bracket-newline': 'error',
-              'toml/array-bracket-spacing': 'error',
-              'toml/array-element-newline': 'error',
-              'toml/indent': ['error', indent === 'tab' ? 2 : indent],
-              'toml/inline-table-curly-spacing': 'error',
-              'toml/key-spacing': 'error',
-              'toml/padding-line-between-pairs': 'error',
-              'toml/padding-line-between-tables': 'error',
-              'toml/quoted-keys': 'error',
-              'toml/spaced-comment': 'error',
-              'toml/table-bracket-spacing': 'error',
-            }
-          : {},
-
-        ...overrides,
-      },
-    },
-  ]
-}

package/core/eslint-config/src/configs/typescript.ts

@@ -1,157 +0,0 @@
-import process from 'node:process'
-import { GLOB_SRC, GLOB_TS, GLOB_TSX } from '../globs'
-import type { FlatConfigItem, OptionsComponentExts, OptionsFiles, OptionsOverrides, OptionsTypeScriptParserOptions, OptionsTypeScriptWithTypes } from '../types'
-import { pluginAntfu } from '../plugins'
-import { interopDefault, renameRules, toArray } from '../utils'
-
-export async function typescript(
-  options: OptionsFiles & OptionsComponentExts & OptionsOverrides & OptionsTypeScriptWithTypes & OptionsTypeScriptParserOptions = {},
-): Promise<FlatConfigItem[]> {
-  const {
-    componentExts = [],
-    overrides = {},
-    parserOptions = {},
-  } = options
-
-  const files = options.files ?? [
-    GLOB_SRC,
-    ...componentExts.map(ext => `**/*.${ext}`),
-  ]
-
-  const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX]
-
-  const typeAwareRules: FlatConfigItem['rules'] = {
-    'dot-notation': 'off',
-    'no-implied-eval': 'off',
-    'no-throw-literal': 'off',
-    'ts/await-thenable': 'error',
-    'ts/dot-notation': ['error', { allowKeywords: true }],
-    'ts/no-floating-promises': 'error',
-    'ts/no-for-in-array': 'error',
-    'ts/no-implied-eval': 'error',
-    'ts/no-misused-promises': 'error',
-    'ts/no-throw-literal': 'error',
-    'ts/no-unnecessary-type-assertion': 'error',
-    'ts/no-unsafe-argument': 'error',
-    'ts/no-unsafe-assignment': 'error',
-    'ts/no-unsafe-call': 'error',
-    'ts/no-unsafe-member-access': 'error',
-    'ts/no-unsafe-return': 'error',
-    'ts/restrict-plus-operands': 'error',
-    'ts/restrict-template-expressions': 'error',
-    'ts/unbound-method': 'error',
-  }
-
-  const tsconfigPath = options?.tsconfigPath
-    ? toArray(options.tsconfigPath)
-    : undefined
-
-  const [
-    pluginTs,
-    parserTs,
-  ] = await Promise.all([
-    interopDefault(import('@typescript-eslint/eslint-plugin')),
-    interopDefault(import('@typescript-eslint/parser')),
-  ] as const)
-
-  return [
-    {
-      // Install the plugins without globs, so they can be configured separately.
-      name: 'antfu:typescript:setup',
-      plugins: {
-        antfu: pluginAntfu,
-        ts: pluginTs as any,
-      },
-    },
-    {
-      files,
-      languageOptions: {
-        parser: parserTs,
-        parserOptions: {
-          extraFileExtensions: componentExts.map(ext => `.${ext}`),
-          sourceType: 'module',
-          ...tsconfigPath
-            ? {
-                project: tsconfigPath,
-                tsconfigRootDir: process.cwd(),
-              }
-            : {},
-          ...parserOptions as any,
-        },
-      },
-      name: 'antfu:typescript:rules',
-      rules: {
-        ...renameRules(
-          pluginTs.configs['eslint-recommended'].overrides![0].rules!,
-          '@typescript-eslint/',
-          'ts/',
-        ),
-        ...renameRules(
-          pluginTs.configs.strict.rules!,
-          '@typescript-eslint/',
-          'ts/',
-        ),
-        'no-dupe-class-members': 'off',
-        'no-loss-of-precision': 'off',
-        'no-redeclare': 'off',
-        'no-use-before-define': 'off',
-        'no-useless-constructor': 'off',
-        'ts/ban-ts-comment': ['error', { 'ts-ignore': 'allow-with-description' }],
-        'ts/ban-types': ['error', { types: { Function: false } }],
-        'ts/consistent-type-definitions': ['error', 'interface'],
-        'ts/consistent-type-imports': ['error', { disallowTypeAnnotations: false, prefer: 'type-imports' }],
-        'ts/method-signature-style': ['error', 'property'], // https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful
-        'ts/no-dupe-class-members': 'error',
-        'ts/no-dynamic-delete': 'off',
-        'ts/no-explicit-any': 'off',
-        'ts/no-extraneous-class': 'off',
-        'ts/no-import-type-side-effects': 'error',
-        'ts/no-invalid-void-type': 'off',
-        'ts/no-loss-of-precision': 'error',
-        'ts/no-non-null-assertion': 'off',
-        'ts/no-redeclare': 'error',
-        'ts/no-require-imports': 'error',
-        'ts/no-unused-vars': 'off',
-        'ts/no-use-before-define': ['error', { classes: false, functions: false, variables: true }],
-        'ts/no-useless-constructor': 'off',
-        'ts/prefer-ts-expect-error': 'error',
-        'ts/triple-slash-reference': 'off',
-        'ts/unified-signatures': 'off',
-        ...overrides,
-      },
-    },
-    {
-      files: filesTypeAware,
-      name: 'antfu:typescript:rules-type-aware',
-      rules: {
-        ...tsconfigPath ? typeAwareRules : {},
-        ...overrides,
-      },
-    },
-    {
-      files: ['**/*.d.ts'],
-      name: 'antfu:typescript:dts-overrides',
-      rules: {
-        'eslint-comments/no-unlimited-disable': 'off',
-        'import/no-duplicates': 'off',
-        'no-restricted-syntax': 'off',
-        'unused-imports/no-unused-vars': 'off',
-      },
-    },
-    {
-      files: ['**/*.{test,spec}.ts?(x)'],
-      name: 'antfu:typescript:tests-overrides',
-      rules: {
-        'no-unused-expressions': 'off',
-      },
-    },
-    {
-      files: ['**/*.js', '**/*.cjs'],
-      name: 'antfu:typescript:javascript-overrides',
-      rules: {
-        'ts/no-require-imports': 'off',
-        'ts/no-var-requires': 'off',
-      },
-    },
-  ]
-}

package/core/eslint-config/src/configs/unicorn.ts

@@ -1,41 +0,0 @@
-import type { FlatConfigItem } from '../types'
-import { pluginUnicorn } from '../plugins'
-
-export async function unicorn(): Promise<FlatConfigItem[]> {
-  return [
-    {
-      name: 'antfu:unicorn',
-      plugins: {
-        unicorn: pluginUnicorn,
-      },
-      rules: {
-        // Pass error message when throwing errors
-        'unicorn/error-message': 'error',
-        // Uppercase regex escapes
-        'unicorn/escape-case': 'error',
-        // Array.isArray instead of instanceof
-        'unicorn/no-instanceof-array': 'error',
-        // Ban `new Array` as `Array` constructor's params are ambiguous
-        'unicorn/no-new-array': 'error',
-        // Prevent deprecated `new Buffer()`
-        'unicorn/no-new-buffer': 'error',
-        // Lowercase number formatting for octal, hex, binary (0x1'error' instead of 0X1'error')
-        'unicorn/number-literal-case': 'error',
-        // textContent instead of innerText
-        'unicorn/prefer-dom-node-text-content': 'error',
-        // includes over indexOf when checking for existence
-        'unicorn/prefer-includes': 'error',
-        // Prefer using the node: protocol
-        'unicorn/prefer-node-protocol': 'error',
-        // Prefer using number properties like `Number.isNaN` rather than `isNaN`
-        'unicorn/prefer-number-properties': 'error',
-        // String methods startsWith/endsWith instead of more complicated stuff
-        'unicorn/prefer-string-starts-ends-with': 'error',
-        // Enforce throwing type error when throwing error while checking typeof
-        'unicorn/prefer-type-error': 'error',
-        // Use new when throwing error
-        'unicorn/throw-new-error': 'error',
-      },
-    },
-  ]
-}

package/core/eslint-config/src/configs/unocss.ts

@@ -1,43 +0,0 @@
-import { ensurePackages, interopDefault } from '../utils'
-import type { FlatConfigItem, OptionsUnoCSS } from '../types'
-
-export async function unocss(
-  options: OptionsUnoCSS = {},
-): Promise<FlatConfigItem[]> {
-  const {
-    attributify = true,
-    strict = false,
-  } = options
-
-  await ensurePackages([
-    '@unocss/eslint-plugin',
-  ])
-
-  const [
-    pluginUnoCSS,
-  ] = await Promise.all([
-    interopDefault(import('@unocss/eslint-plugin')),
-  ] as const)
-
-  return [
-    {
-      name: 'antfu:unocss',
-      plugins: {
-        unocss: pluginUnoCSS,
-      },
-      rules: {
-        'unocss/order': 'warn',
-        ...attributify
-          ? {
-              'unocss/order-attributify': 'warn',
-            }
-          : {},
-        ...strict
-          ? {
-              'unocss/blocklist': 'error',
-            }
-          : {},
-      },
-    },
-  ]
-}

package/core/eslint-config/src/configs/vue.ts

@@ -1,168 +0,0 @@
-import { mergeProcessors } from 'eslint-merge-processors'
-import { interopDefault } from '../utils'
-import type { FlatConfigItem, OptionsFiles, OptionsHasTypeScript, OptionsOverrides, OptionsStylistic, OptionsVue } from '../types'
-import { GLOB_STACKS, GLOB_VUE } from '../globs'
-
-export async function vue(
-  options: OptionsVue & OptionsHasTypeScript & OptionsOverrides & OptionsStylistic & OptionsFiles = {},
-): Promise<FlatConfigItem[]> {
-  const {
-    files = [GLOB_VUE, GLOB_STACKS],
-    overrides = {},
-    stylistic = true,
-    vueVersion = 3,
-  } = options
-
-  const sfcBlocks = options.sfcBlocks === true
-    ? {}
-    : options.sfcBlocks ?? {}
-
-  const {
-    indent = 2,
-  } = typeof stylistic === 'boolean' ? {} : stylistic
-
-  const [
-    pluginVue,
-    parserVue,
-    processorVueBlocks,
-  ] = await Promise.all([
-    // @ts-expect-error missing types
-    interopDefault(import('eslint-plugin-vue')),
-    interopDefault(import('vue-eslint-parser')),
-    interopDefault(import('eslint-processor-vue-blocks')),
-  ] as const)
-
-  return [
-    {
-      name: 'antfu:vue:setup',
-      plugins: {
-        vue: pluginVue,
-      },
-    },
-    {
-      files,
-      languageOptions: {
-        parser: parserVue,
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-          extraFileExtensions: ['.vue', '.stx'],
-          parser: options.typescript
-            ? await interopDefault(import('@typescript-eslint/parser')) as any
-            : null,
-          sourceType: 'module',
-        },
-      },
-      name: 'antfu:vue:rules',
-      processor: sfcBlocks === false
-        ? pluginVue.processors['.vue']
-        : mergeProcessors([
-          pluginVue.processors['.vue'],
-          processorVueBlocks({
-            ...sfcBlocks,
-            blocks: {
-              styles: true,
-              ...sfcBlocks.blocks,
-            },
-          }),
-        ]),
-      rules: {
-        ...pluginVue.configs.base.rules as any,
-
-        ...vueVersion === 2
-          ? {
-              ...pluginVue.configs.essential.rules as any,
-              ...pluginVue.configs['strongly-recommended'].rules as any,
-              ...pluginVue.configs.recommended.rules as any,
-            }
-          : {
-              ...pluginVue.configs['vue3-essential'].rules as any,
-              ...pluginVue.configs['vue3-strongly-recommended'].rules as any,
-              ...pluginVue.configs['vue3-recommended'].rules as any,
-            },
-
-        'node/prefer-global/process': 'off',
-
-        'vue/block-order': ['error', {
-          order: ['script', 'template', 'style'],
-        }],
-        'vue/component-name-in-template-casing': ['error', 'PascalCase'],
-        'vue/component-options-name-casing': ['error', 'PascalCase'],
-        'vue/custom-event-name-casing': ['error', 'camelCase'],
-        'vue/define-macros-order': ['error', {
-          order: ['defineOptions', 'defineProps', 'defineEmits', 'defineSlots'],
-        }],
-        'vue/dot-location': ['error', 'property'],
-        'vue/dot-notation': ['error', { allowKeywords: true }],
-        'vue/eqeqeq': ['error', 'smart'],
-        'vue/html-indent': ['error', 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 }],
-
-        ...stylistic
-          ? {
-              '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', { allowMultiplePropertiesPerLine: 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',
-            }
-          : {},
-
-        ...overrides,
-      },
-    },
-  ]
-}