Configuration Presets

/**
 * Base configuration providing essential parser setup for Vue files
 * Required foundation for all other Vue configurations
 */
const base: LegacyConfig;

/**
 * Essential rules for Vue 3 development (alias for vue3-essential)
 * Prevents errors and enforces critical Vue 3 patterns
 * Includes: component naming, template syntax validation, directive usage
 */
const essential: LegacyConfig;

/**
 * Strongly recommended rules for Vue 3 (alias for vue3-strongly-recommended)
 * Improves code readability and maintainability beyond essential rules
 * Adds: component structure, prop validation, event handling best practices
 */
const "strongly-recommended": LegacyConfig;

/**
 * Recommended rules for Vue 3 (alias for vue3-recommended)
 * Complete best practices including style and formatting rules
 * Most comprehensive rule set for Vue 3 projects
 */
const recommended: LegacyConfig;

/**
 * Essential rules for Vue 2 development
 * Prevents errors and enforces critical Vue 2 patterns
 * Includes Vue 2-specific directive and lifecycle validations
 */
const "vue2-essential": LegacyConfig;

/**
 * Strongly recommended rules for Vue 2
 * Improves code readability for Vue 2 projects
 * Includes deprecated API detection and migration guidance
 */
const "vue2-strongly-recommended": LegacyConfig;

/**
 * Recommended rules for Vue 2
 * Complete best practices for Vue 2 development
 * Most comprehensive rule set for legacy Vue 2 projects
 */
const "vue2-recommended": LegacyConfig;

/**
 * Configuration excluding layout and formatting rules
 * Focuses purely on logic and structure validation
 * Useful when using separate formatting tools like Prettier
 */
const "no-layout-rules": LegacyConfig;

// Using essential Vue 3 preset
module.exports = {
  extends: ["plugin:vue/vue3-essential"],
  plugins: ["vue"],
};

// Using Vue 2 recommended preset
module.exports = {
  extends: ["plugin:vue/vue2-recommended"],
  plugins: ["vue"],
};

// Combining with other presets
module.exports = {
  extends: [
    "eslint:recommended",
    "plugin:vue/vue3-strongly-recommended",
    "@vue/typescript/recommended",
  ],
  plugins: ["vue"],
};

/**
 * Base flat configuration for Vue file parsing
 * Sets up vue-eslint-parser and basic plugin registration
 */
const "flat/base": FlatConfig[];

/**
 * Essential rules for Vue 3 in flat config format
 * Prevents errors and enforces critical Vue 3 patterns
 */
const "flat/essential": FlatConfig[];

/**
 * Strongly recommended rules for Vue 3 in flat config format
 * Improves code readability and maintainability
 */
const "flat/strongly-recommended": FlatConfig[];

/**
 * Recommended rules for Vue 3 in flat config format
 * Complete best practices including style and formatting
 */
const "flat/recommended": FlatConfig[];

/**
 * Essential rules for Vue 2 in flat config format
 * Vue 2-specific error prevention and pattern enforcement
 */
const "flat/vue2-essential": FlatConfig[];

/**
 * Strongly recommended rules for Vue 2 in flat config format
 * Enhanced readability and best practices for Vue 2
 */
const "flat/vue2-strongly-recommended": FlatConfig[];

/**
 * Recommended rules for Vue 2 in flat config format
 * Comprehensive rule set for Vue 2 projects
 */
const "flat/vue2-recommended": FlatConfig[];

import eslintPluginVue from "eslint-plugin-vue";

// Using essential Vue 3 flat config
export default [
  ...eslintPluginVue.configs["flat/essential"],
];

// Combining multiple flat configs
export default [
  ...eslintPluginVue.configs["flat/base"],
  ...eslintPluginVue.configs["flat/strongly-recommended"],
  {
    rules: {
      "vue/multi-word-component-names": "off", // Override specific rules
    },
  },
];

// Targeting specific file patterns
export default [
  {
    files: ["*.vue"],
    ...eslintPluginVue.configs["flat/recommended"][0],
  },
  {
    files: ["**/*.spec.vue", "**/*.test.vue"],
    rules: {
      "vue/multi-word-component-names": "off",
    },
  },
];

/**
 * Rule categories used in configurations
 * Each preset includes rules from specific categories
 */
interface RuleCategories {
  /** Error prevention rules - included in essential configs */
  "vue3-essential": string[];
  "vue2-essential": string[];
  
  /** Code quality rules - included in strongly-recommended configs */
  "vue3-strongly-recommended": string[];
  "vue2-strongly-recommended": string[];
  
  /** Style and formatting rules - included in recommended configs */
  "vue3-recommended": string[];
  "vue2-recommended": string[];
}

/**
 * Base configuration structure
 * Provides essential parser and plugin setup for Vue files
 */
interface BaseConfig {
  /** Parser options for JavaScript/TypeScript compatibility */
  parserOptions: {
    ecmaVersion: "latest";
    sourceType: "module";
  };
  /** Plugin registration */
  plugins: ["vue"];
  /** Essential rules for comment directives and JSX support */
  rules: {
    "vue/comment-directive": "error";
    "vue/jsx-uses-vars": "error";
  };
  /** File-specific parser override for .vue files */
  overrides: [
    {
      files: "*.vue";
      parser: "vue-eslint-parser";
    }
  ];
}

// Manually configuring without presets
module.exports = {
  parserOptions: {
    ecmaVersion: "latest",
    sourceType: "module",
  },
  plugins: ["vue"],
  rules: {
    // Essential rules
    "vue/comment-directive": "error",
    "vue/jsx-uses-vars": "error",
    "vue/multi-word-component-names": "error",
    "vue/no-unused-vars": "error",
    
    // Custom rule configuration
    "vue/attribute-hyphenation": ["error", "always"],
    "vue/component-name-in-template-casing": ["error", "PascalCase"],
    "vue/html-self-closing": ["error", {
      html: { void: "never", normal: "always" },
      svg: "always",
      math: "always",
    }],
  },
  overrides: [
    {
      files: "*.vue",
      parser: "vue-eslint-parser",
    },
  ],
};

interface LegacyConfig {
  /** Parser for JavaScript/TypeScript files */
  parser?: string;
  /** Parser configuration options */
  parserOptions?: {
    ecmaVersion?: string | number;
    sourceType?: "script" | "module";
    ecmaFeatures?: Record<string, boolean>;
  };
  /** List of ESLint plugins to use */
  plugins?: string[];
  /** Rule configuration object */
  rules?: Record<string, RuleConfig>;
  /** File-specific configuration overrides */
  overrides?: ConfigOverride[];
  /** Extended configurations */
  extends?: string | string[];
  /** Environment settings */
  env?: Record<string, boolean>;
  /** Global variable definitions */
  globals?: Record<string, boolean | "readonly" | "writable">;
}

interface FlatConfig {
  /** File patterns this configuration applies to */
  files?: string[];
  /** File patterns to ignore */
  ignores?: string[];
  /** Language-specific options including parser */
  languageOptions?: {
    parser?: ESLintParser;
    parserOptions?: Record<string, any>;
    ecmaVersion?: string | number;
    sourceType?: "script" | "module";
    globals?: Record<string, boolean | "readonly" | "writable">;
  };
  /** Plugin registrations by name */
  plugins?: Record<string, ESLintPlugin>;
  /** Rule configurations */
  rules?: Record<string, RuleConfig>;
  /** File processor */
  processor?: string | ESLintProcessor;
  /** Configuration settings */
  settings?: Record<string, any>;
}

interface ConfigOverride {
  files: string | string[];
  excludedFiles?: string | string[];
  parser?: string;
  parserOptions?: Record<string, any>;
  plugins?: string[];
  rules?: Record<string, RuleConfig>;
  extends?: string | string[];
  env?: Record<string, boolean>;
  globals?: Record<string, boolean>;
}

type RuleConfig = 
  | "off" | "warn" | "error" 
  | 0 | 1 | 2 
  | [RuleLevel]
  | [RuleLevel, ...RuleOptions[]];

type RuleLevel = "off" | "warn" | "error" | 0 | 1 | 2;
type RuleOptions = any;

interface ESLintParser {
  parse(code: string, options: any): any;
  parseForESLint?(code: string, options: any): any;
}

interface ESLintPlugin {
  meta?: PluginMeta;
  configs?: Record<string, any>;
  rules?: Record<string, ESLintRule>;
  processors?: Record<string, ESLintProcessor>;
}