Plugin Configuration

/**
 * Main ESLint Plugin Unicorn export containing all rules and configurations
 */
interface ESLintPluginUnicorn {
  meta: {
    name: string;        // "eslint-plugin-unicorn"
    version: string;     // Current package version
  };
  rules: Record<string, ESLintRule>;
  configs: {
    recommended: ESLintFlatConfig;
    all: ESLintFlatConfig;
    'flat/recommended': ESLintFlatConfig; // deprecated
    'flat/all': ESLintFlatConfig;         // deprecated
  };
}

import eslintPluginUnicorn from 'eslint-plugin-unicorn';

// Access plugin metadata
console.log(eslintPluginUnicorn.meta.name);    // "eslint-plugin-unicorn"
console.log(eslintPluginUnicorn.meta.version); // "60.0.0"

// Access individual rules
const betterRegexRule = eslintPluginUnicorn.rules['better-regex'];

// Use pre-built configurations
export default [
  eslintPluginUnicorn.configs.recommended,
  // ... other configs
];

/**
 * Recommended configuration with essential rules enabled
 * Includes only rules marked as recommended in their metadata
 */
interface RecommendedConfig extends ESLintFlatConfig {
  name: 'unicorn/recommended';
  plugins: {
    unicorn: ESLintPluginUnicorn;
  };
  rules: Record<string, 'error' | 'off'>;
  languageOptions: {
    globals: Record<string, boolean>; // From globals.builtin
  };
}

import eslintPluginUnicorn from 'eslint-plugin-unicorn';

// Use recommended configuration directly
export default [
  eslintPluginUnicorn.configs.recommended,
];

// Extend recommended configuration
export default [
  eslintPluginUnicorn.configs.recommended,
  {
    rules: {
      // Override specific rules
      'unicorn/prevent-abbreviations': 'off',
      'unicorn/filename-case': ['error', { case: 'camelCase' }],
    },
  },
];

/**
 * All rules configuration with every rule enabled as error
 * Includes all 134 rules provided by the plugin
 */
interface AllConfig extends ESLintFlatConfig {
  name: 'unicorn/all';
  plugins: {
    unicorn: ESLintPluginUnicorn;
  };
  rules: Record<string, 'error'>;
  languageOptions: {
    globals: Record<string, boolean>; // From globals.builtin
  };
}

import eslintPluginUnicorn from 'eslint-plugin-unicorn';

// Use all rules configuration (strict mode)
export default [
  eslintPluginUnicorn.configs.all,
  {
    rules: {
      // Disable specific rules that don't fit your project
      'unicorn/no-null': 'off',
      'unicorn/prevent-abbreviations': 'off',
    },
  },
];

/**
 * Deprecated configuration names - use 'recommended' and 'all' instead
 * @deprecated Use configs.recommended instead
 */
interface DeprecatedConfigs {
  'flat/recommended': ESLintFlatConfig; // Same as configs.recommended
  'flat/all': ESLintFlatConfig;         // Same as configs.all
}

/**
 * Deprecated rules included in the plugin for backward compatibility
 * These rules are replaced by newer, more comprehensive alternatives
 */
interface DeprecatedRules {
  'no-instanceof-array': {
    message: 'Replaced by `unicorn/no-instanceof-builtins` which covers more cases.';
    replacedBy: ['unicorn/no-instanceof-builtins'];
  };
  'no-length-as-slice-end': {
    message: 'Replaced by `unicorn/no-unnecessary-slice-end` which covers more cases.';
    replacedBy: ['unicorn/no-unnecessary-slice-end'];
  };
  'no-array-push-push': {
    message: 'Replaced by `unicorn/prefer-single-call` which covers more cases.';
    replacedBy: ['unicorn/prefer-single-call'];
  };
}

import eslintPluginUnicorn from 'eslint-plugin-unicorn';

// Check if rule is deprecated
const rule = eslintPluginUnicorn.rules['no-instanceof-array'];
if (rule.meta.deprecated) {
  console.warn(`Rule is deprecated: ${rule.meta.deprecated.message}`);
  console.log(`Use instead: ${rule.meta.deprecated.replacedBy.join(', ')}`);
}

// Avoid using deprecated rules in new configurations
export default [
  {
    plugins: { unicorn: eslintPluginUnicorn },
    rules: {
      // ❌ Deprecated - don't use
      // 'unicorn/no-instanceof-array': 'error',
      
      // ✅ Use the replacement instead  
      'unicorn/no-instanceof-builtins': 'error',
    },
  },
];

/**
 * Manual plugin configuration pattern
 */
interface CustomConfig {
  languageOptions: {
    globals: Record<string, boolean>;
  };
  plugins: {
    unicorn: ESLintPluginUnicorn;
  };
  rules: Record<string, RuleConfiguration>;
}

type RuleConfiguration = 
  | 'off' 
  | 'warn' 
  | 'error' 
  | ['off'] 
  | ['warn'] 
  | ['error'] 
  | ['error', RuleOptions]
  | ['warn', RuleOptions];

interface RuleOptions {
  [key: string]: any;
}

import eslintPluginUnicorn from 'eslint-plugin-unicorn';
import globals from 'globals';

// Custom configuration with specific rules
export default [
  {
    languageOptions: {
      globals: globals.builtin,
    },
    plugins: {
      unicorn: eslintPluginUnicorn,
    },
    rules: {
      // Enable specific rules
      'unicorn/better-regex': 'error',
      'unicorn/catch-error-name': 'error',
      'unicorn/consistent-function-scoping': 'error',
      
      // Rules with options
      'unicorn/filename-case': [
        'error',
        {
          case: 'kebabCase',
          ignore: [/^[A-Z]+\.md$/]
        }
      ],
      'unicorn/prevent-abbreviations': [
        'error',
        {
          replacements: {
            btn: { button: true },
            props: { properties: false },
          }
        }
      ],
    },
  },
];

/**
 * Individual rule access pattern
 */
interface RuleAccess {
  rules: {
    [ruleName: string]: ESLintRule;
  };
}

interface ESLintRule {
  create(context: ESLint.RuleContext): ESLint.RuleListener;
  meta: {
    type: 'problem' | 'suggestion' | 'layout';
    docs: {
      description: string;
      recommended: boolean;
      url: string;
    };
    fixable?: 'code' | 'whitespace';
    schema: JSONSchema[];
    messages: Record<string, string>;
  };
}

import eslintPluginUnicorn from 'eslint-plugin-unicorn';

// Access individual rules
const availableRules = Object.keys(eslintPluginUnicorn.rules);
console.log(availableRules.length); // 134

// Check rule metadata
const betterRegexRule = eslintPluginUnicorn.rules['better-regex'];
console.log(betterRegexRule.meta.docs.description);
console.log(betterRegexRule.meta.docs.recommended);

// Create custom rule set based on metadata
const recommendedRules = Object.entries(eslintPluginUnicorn.rules)
  .filter(([name, rule]) => rule.meta.docs.recommended)
  .reduce((rules, [name]) => {
    rules[`unicorn/${name}`] = 'error';
    return rules;
  }, {});

/**
 * Required language options for proper plugin functionality
 */
interface RequiredLanguageOptions {
  languageOptions: {
    globals: Record<string, boolean>; // Must include globals.builtin
  };
}

import globals from 'globals';

// Required language options
const requiredLanguageOptions = {
  languageOptions: {
    globals: globals.builtin, // Essential for many rules
  },
};

// Alternative globals setup
const alternativeGlobals = {
  languageOptions: {
    globals: {
      ...globals.builtin,
      ...globals.browser, // Add browser globals if needed
      ...globals.node,    // Add Node.js globals if needed
    },
  },
};