@santi020k/eslint-config-basic 0.1.0

package/packages/tests/src/composition.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from 'vitest'
+
+import { ConfigOption, eslintConfig, OptionalOption, SettingOption } from '@santi020k/eslint-config-basic'
+
+describe('eslintConfig Function', () => {
+  it('should return an array when called with minimal options', () => {
+    const config = eslintConfig({ config: [] })
+
+    expect(Array.isArray(config)).toBe(true)
+  })
+
+  it('should return config with TypeScript when Ts option is specified', () => {
+    const config = eslintConfig({ config: [ConfigOption.Ts] })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should return config with React when React option is specified', () => {
+    const config = eslintConfig({ config: [ConfigOption.React] })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should return config with Next when Next option is specified', () => {
+    const config = eslintConfig({ config: [ConfigOption.Next] })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should return config with Nest when Nest option is specified', () => {
+    const config = eslintConfig({ config: [ConfigOption.Nest] })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should include gitignore when setting is specified', () => {
+    const config = eslintConfig({
+      config: [],
+      settings: [SettingOption.Gitignore]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+  })
+
+  it('should handle multiple framework configs', () => {
+    const config = eslintConfig({
+      config: [ConfigOption.Ts, ConfigOption.React]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should handle optionals', () => {
+    const config = eslintConfig({
+      config: [ConfigOption.Ts],
+      optionals: [OptionalOption.Tailwind]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+  })
+
+  it('should return a valid config when called with no arguments', () => {
+    const config = eslintConfig()
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should handle all framework configs combined', () => {
+    const config = eslintConfig({
+      config: [
+        ConfigOption.Ts,
+        ConfigOption.React,
+        ConfigOption.Next,
+        ConfigOption.Astro,
+        ConfigOption.Expo,
+        ConfigOption.Nest
+      ]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should handle all optionals combined', () => {
+    const config = eslintConfig({
+      config: [ConfigOption.Ts],
+      optionals: [
+        OptionalOption.Cspell,
+        OptionalOption.Tailwind,
+        OptionalOption.Vitest,
+        OptionalOption.I18next,
+        OptionalOption.Mdx,
+        OptionalOption.Markdown,
+        OptionalOption.Stencil
+      ]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should handle duplicate config entries without crashing', () => {
+    const config = eslintConfig({
+      config: [ConfigOption.Ts, ConfigOption.Ts, ConfigOption.React, ConfigOption.React]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+
+  it('should not crash with unknown enum values', () => {
+    const config = eslintConfig({
+      config: ['unknown-config' as ConfigOption]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+  })
+
+  it('should handle full kitchen-sink configuration', () => {
+    const config = eslintConfig({
+      config: [ConfigOption.Ts, ConfigOption.React, ConfigOption.Next],
+      optionals: [OptionalOption.Tailwind, OptionalOption.Vitest, OptionalOption.Cspell],
+      settings: [SettingOption.Gitignore]
+    })
+
+    expect(Array.isArray(config)).toBe(true)
+
+    expect(config.length).toBeGreaterThan(0)
+  })
+})
+
+describe('Type Exports', () => {
+  it('should have all ConfigOption values', () => {
+    const options = Object.values(ConfigOption)
+
+    expect(options).toContain('ts')
+
+    expect(options).toContain('react')
+
+    expect(options).toContain('next')
+  })
+
+  it('should have all OptionalOption values', () => {
+    const options = Object.values(OptionalOption)
+
+    expect(options).toContain('tailwind')
+
+    expect(options).toContain('vitest')
+  })
+
+  it('should have all SettingOption values', () => {
+    const options = Object.values(SettingOption)
+
+    expect(options).toContain('gitignore')
+  })
+})

package/packages/tests/src/configs.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest'
+
+import { astroConfig } from '@santi020k/eslint-config-astro'
+import {
+  ConfigOption,
+  coreConfig,
+  OptionalOption,
+  SettingOption
+} from '@santi020k/eslint-config-core'
+import { expoConfig } from '@santi020k/eslint-config-expo'
+import { nestConfig } from '@santi020k/eslint-config-nest'
+import { nextConfig } from '@santi020k/eslint-config-next'
+import { reactConfig } from '@santi020k/eslint-config-react'
+import { typescriptConfig } from '@santi020k/eslint-config-typescript'
+
+describe('Core Config', () => {
+  it('should export coreConfig as an array', () => {
+    expect(Array.isArray(coreConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(coreConfig.length).toBeGreaterThan(0)
+  })
+
+  it('should have named config entries', () => {
+    const hasNames = coreConfig.every(config => typeof config.name === 'string')
+
+    expect(hasNames).toBe(true)
+  })
+})
+
+describe('TypeScript Config', () => {
+  it('should export typescriptConfig as an array', () => {
+    expect(Array.isArray(typescriptConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(typescriptConfig.length).toBeGreaterThan(0)
+  })
+})
+
+describe('React Config', () => {
+  it('should export reactConfig as an array', () => {
+    expect(Array.isArray(reactConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(reactConfig.length).toBeGreaterThan(0)
+  })
+})
+
+describe('Next.js Config', () => {
+  it('should export nextConfig as an array', () => {
+    expect(Array.isArray(nextConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(nextConfig.length).toBeGreaterThan(0)
+  })
+})
+
+describe('Astro Config', () => {
+  it('should export astroConfig as an array', () => {
+    expect(Array.isArray(astroConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(astroConfig.length).toBeGreaterThan(0)
+  })
+})
+
+describe('Expo Config', () => {
+  it('should export expoConfig as an array', () => {
+    expect(Array.isArray(expoConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(expoConfig.length).toBeGreaterThan(0)
+  })
+})
+
+describe('NestJS Config', () => {
+  it('should export nestConfig as an array', () => {
+    expect(Array.isArray(nestConfig)).toBe(true)
+  })
+
+  it('should have at least one config entry', () => {
+    expect(nestConfig.length).toBeGreaterThan(0)
+  })
+})
+
+describe('Config Enums', () => {
+  it('should export ConfigOption enum with expected values', () => {
+    expect(ConfigOption.Ts).toBeDefined()
+
+    expect(ConfigOption.React).toBeDefined()
+
+    expect(ConfigOption.Next).toBeDefined()
+
+    expect(ConfigOption.Astro).toBeDefined()
+
+    expect(ConfigOption.Expo).toBeDefined()
+
+    expect(ConfigOption.Nest).toBeDefined()
+  })
+
+  it('should export OptionalOption enum with expected values', () => {
+    expect(OptionalOption.Tailwind).toBeDefined()
+
+    expect(OptionalOption.Vitest).toBeDefined()
+
+    expect(OptionalOption.Cspell).toBeDefined()
+  })
+
+  it('should export SettingOption enum with expected values', () => {
+    expect(SettingOption.Gitignore).toBeDefined()
+  })
+})

package/packages/tests/src/rules.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest'
+
+import { coreConfig, rules } from '@santi020k/eslint-config-core'
+import { reactConfig } from '@santi020k/eslint-config-react'
+import { typescriptConfig } from '@santi020k/eslint-config-typescript'
+
+describe('Core Rules', () => {
+  it('should export rules object', () => {
+    expect(typeof rules).toBe('object')
+  })
+
+  it('should include expected core rules', () => {
+    // Check for actual rules exported from the core package
+    expect(rules['@stylistic/indent']).toBeDefined()
+
+    expect(rules['@stylistic/quotes']).toBeDefined()
+  })
+
+  it('should have config with stylistic rules', () => {
+    const stylisticConfig = coreConfig.find(c => c.name === 'eslint-config/stylistic')
+
+    expect(stylisticConfig).toBeDefined()
+  })
+
+  it('should have config with plugins', () => {
+    const pluginsConfig = coreConfig.find(c => c.name === 'eslint-config/plugins')
+
+    expect(pluginsConfig).toBeDefined()
+
+    expect(pluginsConfig?.plugins).toBeDefined()
+  })
+})
+
+describe('TypeScript Rules', () => {
+  it('should include TypeScript parser configuration', () => {
+    const tsConfig = typescriptConfig.find(c => c.languageOptions?.parser)
+
+    expect(tsConfig).toBeDefined()
+  })
+
+  it('should target TypeScript files', () => {
+    const hasTypeScriptFiles = typescriptConfig.some(c => c.files?.some(pattern => typeof pattern === 'string' && pattern.includes('.ts')))
+
+    expect(hasTypeScriptFiles).toBe(true)
+  })
+})
+
+describe('React Rules', () => {
+  it('should include React plugin configuration', () => {
+    const hasReactPlugin = reactConfig.some(c => c.plugins && ('react' in c.plugins || 'react-hooks' in c.plugins))
+
+    expect(hasReactPlugin).toBe(true)
+  })
+
+  it('should have React version detection setting', () => {
+    const hasReactSettings = reactConfig.some(c => (c.settings?.react as { version?: string } | undefined)?.version === 'detect')
+
+    expect(hasReactSettings).toBe(true)
+  })
+})

package/packages/tests/src/snapshots.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest'
+
+import { astroConfig } from '@santi020k/eslint-config-astro'
+import { coreConfig } from '@santi020k/eslint-config-core'
+import { expoConfig } from '@santi020k/eslint-config-expo'
+import { nestConfig } from '@santi020k/eslint-config-nest'
+import { nextConfig } from '@santi020k/eslint-config-next'
+import { reactConfig } from '@santi020k/eslint-config-react'
+import { typescriptConfig } from '@santi020k/eslint-config-typescript'
+
+/**
+ * Extract rule names from a config array for snapshot comparison.
+ * This captures the "shape" of each config — when plugin updates
+ * add or remove rules, these snapshots will catch it.
+ */
+const extractRuleNames = (config: Record<string, unknown>[]): string[] => {
+  const ruleNames = new Set<string>()
+
+  for (const entry of config) {
+    const rules = entry.rules as Record<string, unknown> | undefined
+
+    if (rules) {
+      for (const ruleName of Object.keys(rules)) {
+        ruleNames.add(ruleName)
+      }
+    }
+  }
+
+  return [...ruleNames].sort()
+}
+
+/**
+ * Extract config entry names from a config array.
+ */
+const extractConfigNames = (config: Record<string, unknown>[]): string[] => config
+  .map(entry => entry.name as string | undefined)
+  .filter((name): name is string => typeof name === 'string')
+  .sort()
+
+describe('Config Snapshots — Rule Names', () => {
+  it('core config rules should match snapshot', () => {
+    const rules = extractRuleNames(coreConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+
+  it('typescript config rules should match snapshot', () => {
+    const rules = extractRuleNames(typescriptConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+
+  it('react config rules should match snapshot', () => {
+    const rules = extractRuleNames(reactConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+
+  it('next config rules should match snapshot', () => {
+    const rules = extractRuleNames(nextConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+
+  it('astro config rules should match snapshot', () => {
+    const rules = extractRuleNames(astroConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+
+  it('expo config rules should match snapshot', () => {
+    const rules = extractRuleNames(expoConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+
+  it('nest config rules should match snapshot', () => {
+    const rules = extractRuleNames(nestConfig as Record<string, unknown>[])
+
+    expect(rules).toMatchSnapshot()
+  })
+})
+
+describe('Config Snapshots — Entry Names', () => {
+  it('core config entries should match snapshot', () => {
+    const names = extractConfigNames(coreConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+
+  it('typescript config entries should match snapshot', () => {
+    const names = extractConfigNames(typescriptConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+
+  it('react config entries should match snapshot', () => {
+    const names = extractConfigNames(reactConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+
+  it('next config entries should match snapshot', () => {
+    const names = extractConfigNames(nextConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+
+  it('astro config entries should match snapshot', () => {
+    const names = extractConfigNames(astroConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+
+  it('expo config entries should match snapshot', () => {
+    const names = extractConfigNames(expoConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+
+  it('nest config entries should match snapshot', () => {
+    const names = extractConfigNames(nestConfig as Record<string, unknown>[])
+
+    expect(names).toMatchSnapshot()
+  })
+})

package/packages/tests/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["vitest/globals"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/tests/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node'
+  }
+})

package/packages/typescript/README.md

@@ -0,0 +1,14 @@
+# @santi020k/eslint-config-typescript
+
+TypeScript specific ESLint rules and configurations.
+
+## Description
+
+This package provides:
+- TypeScript parser configuration.
+- `@typescript-eslint` recommended rules.
+- Proper file globbing for `.ts` and `.tsx` files.
+
+## Usage
+
+This package is used automatically when `ConfigOption.Ts` is selected in the main configuration.

package/packages/typescript/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@santi020k/eslint-config-typescript",
+  "version": "0.0.0",
+  "description": "TypeScript ESLint configuration",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@santi020k/eslint-config-core": "*",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "typescript-eslint": "^8.54.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/utils": "^8.54.0",
+    "tsup": "^8.5.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "santi020k",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/santi020k/eslint-config.git",
+    "directory": "packages/typescript"
+  }
+}

package/packages/typescript/src/index.ts

@@ -0,0 +1,32 @@
+import tsEslint from 'typescript-eslint'
+
+import { rules } from './rules.js'
+
+import tsParser from '@typescript-eslint/parser'
+import type { TSESLint } from '@typescript-eslint/utils'
+
+/**
+ * TypeScript ESLint configuration
+ * Extends typescript-eslint stylistic config with custom rules
+ */
+export const typescriptConfig: TSESLint.FlatConfig.ConfigArray = [
+  ...tsEslint.configs.stylistic as TSESLint.FlatConfig.ConfigArray,
+  {
+    name: 'eslint-config-typescript/rules',
+    files: ['**/*.{ts,tsx,mts,cts}'],
+    rules,
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        project: true
+      },
+      ecmaVersion: 'latest'
+    }
+  }
+]
+
+// Legacy export for backwards compatibility
+export { typescriptConfig as tsConfig }
+
+// Re-export rules for direct access
+export { rules }

package/packages/typescript/src/rules.ts

@@ -0,0 +1,36 @@
+import { rules as coreRules } from '@santi020k/eslint-config-core'
+import type { TSESLint } from '@typescript-eslint/utils'
+
+export const rules: TSESLint.Linter.RulesRecord = {
+  // Include core JS rules for TS files
+  ...coreRules,
+  // Disable conflicting rules
+  semi: 'off',
+  'no-unused-vars': 'off',
+  '@typescript-eslint/indent': 'off',
+  // TypeScript-specific rules
+  '@typescript-eslint/no-unused-vars': [
+    'warn',
+    {
+      vars: 'all',
+      varsIgnorePattern: '^_',
+      args: 'after-used',
+      argsIgnorePattern: '^_',
+      destructuredArrayIgnorePattern: '^_',
+      ignoreRestSiblings: true
+    }
+  ],
+  '@typescript-eslint/no-explicit-any': 'warn',
+  '@typescript-eslint/no-empty-function': 'warn',
+  '@typescript-eslint/no-empty-object-type': 'warn',
+  '@typescript-eslint/no-unsafe-function-type': 'warn',
+  '@typescript-eslint/no-wrapper-object-types': 'warn',
+  '@typescript-eslint/no-var-requires': 'warn',
+  '@typescript-eslint/ban-ts-comment': 'warn',
+  '@typescript-eslint/no-non-null-assertion': 'warn',
+  '@typescript-eslint/no-invalid-void-type': 'warn',
+  '@typescript-eslint/no-dynamic-delete': 'warn',
+  '@typescript-eslint/no-useless-constructor': 'warn',
+  '@typescript-eslint/prefer-for-of': 'warn',
+  '@typescript-eslint/no-duplicate-enum-values': 'warn'
+}

package/packages/typescript/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/typescript/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  splitting: false,
+  sourcemap: true
+})

package/tsconfig.base.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "lib": ["ES2023"],
+    "declaration": true,
+    "declarationMap": true,
+    "moduleResolution": "Node16",
+    "esModuleInterop": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.docs.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": [
+    "packages/core/src/**/*.ts",
+    "packages/typescript/src/**/*.ts",
+    "packages/react/src/**/*.ts",
+    "packages/next/src/**/*.ts",
+    "packages/astro/src/**/*.ts",
+    "packages/expo/src/**/*.ts",
+    "packages/nest/src/**/*.ts",
+    "packages/optionals/src/**/*.ts",
+    "packages/basic/src/**/*.ts"
+  ],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}