Code Quality Rules

/**
 * Optimizes regular expressions using clean-regexp
 * Suggests improvements for regex patterns
 */
'unicorn/better-regex': 'error' | 'warn' | 'off' | [
  'error' | 'warn',
  {
    sortCharacterClasses?: boolean; // Default: true
  }
];

// ❌ Bad - inefficient regex
const regex1 = /[0-9]/;
const regex2 = /[a-zA-Z0-9_]/;

// ✅ Good - optimized regex
const regex1 = /\d/;
const regex2 = /\w/;

/**
 * Ensures catch block error parameters follow naming conventions
 * Default name is 'error', customizable via options
 */
'unicorn/catch-error-name': 'error' | 'warn' | 'off' | [
  'error' | 'warn',
  {
    name?: string; // Default: 'error'
    ignore?: string[]; // Default: []
  }
];

// ❌ Bad - inconsistent error naming
try {
  riskyOperation();
} catch (e) {
  console.log(e.message);
}

// ✅ Good - consistent error naming
try {
  riskyOperation();
} catch (error) {
  console.log(error.message);
}

/**
 * Moves functions to higher scope when they don't reference local variables
 * Improves performance and readability
 */
'unicorn/consistent-function-scoping': 'error' | 'warn' | 'off' | [
  'error' | 'warn',
  {
    checkArrowFunctions?: boolean; // Default: true
  }
];

// ❌ Bad - function can be moved to module scope
function processData() {
  function helper(item) {
    return item.toString();
  }
  
  return data.map(helper);
}

// ✅ Good - helper function moved to module scope
function helper(item) {
  return item.toString();
}

function processData() {
  return data.map(helper);
}

/**
 * Ensures custom error classes extend Error correctly
 * Validates proper error constructor implementation
 */
'unicorn/custom-error-definition': 'error' | 'warn' | 'off';

// ❌ Bad - incomplete custom error
class CustomError {
  constructor(message) {
    this.message = message;
  }
}

// ✅ Good - proper custom error
class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomError';
  }
}

/**
 * Validates error message format and suggests improvements
 * Encourages descriptive error messages
 */
'unicorn/error-message': 'error' | 'warn' | 'off';

// ❌ Bad - generic error message
throw new Error('Error');

// ✅ Good - descriptive error message
throw new Error('Invalid user ID: expected positive integer, received ' + userId);

/**
 * Requires 'new' keyword when throwing Error constructors
 * Ensures proper error instantiation
 */
'unicorn/throw-new-error': 'error' | 'warn' | 'off';

// ❌ Bad - missing 'new' keyword
throw Error('Something went wrong');

// ✅ Good - using 'new' keyword
throw new Error('Something went wrong');

/**
 * Ensures consistent assertion message patterns
 * Validates assert.ok, assert.equal, and similar calls
 */
'unicorn/consistent-assert': 'error' | 'warn' | 'off' | [
  'error' | 'warn',
  {
    assertionStyle?: 'always' | 'never'; // Default: 'always'
  }
];

import assert from 'assert';

// ❌ Bad - inconsistent assertion style
assert(condition);
assert.equal(actual, expected, 'Values should be equal');

// ✅ Good - consistent assertion style
assert(condition, 'Condition should be true');
assert.equal(actual, expected, 'Values should be equal');

/**
 * Ensures consistent patterns for cloning Date objects
 * Prefers new Date(date) over other cloning methods
 */
'unicorn/consistent-date-clone': 'error' | 'warn' | 'off';

// ❌ Bad - inconsistent date cloning
const cloned1 = new Date(date.getTime());
const cloned2 = new Date(+date);

// ✅ Good - consistent date cloning
const cloned = new Date(date);

/**
 * Promotes consistent destructuring usage
 * Suggests destructuring when accessing multiple properties
 */
'unicorn/consistent-destructuring': 'error' | 'warn' | 'off';

// ❌ Bad - repeated property access
function processUser(user) {
  console.log(user.name);
  console.log(user.email);
  console.log(user.age);
}

// ✅ Good - consistent destructuring
function processUser(user) {
  const { name, email, age } = user;
  console.log(name);
  console.log(email);
  console.log(age);
}

/**
 * Ensures consistent patterns when spreading empty arrays
 * Prevents unnecessary empty array spreads
 */
'unicorn/consistent-empty-array-spread': 'error' | 'warn' | 'off';

// ❌ Bad - unnecessary empty array spread
const result = [...[], ...items];

// ✅ Good - clean array spread
const result = [...items];

/**
 * Promotes consistent array index existence checking
 * Suggests .includes() over indexOf() !== -1 patterns
 */
'unicorn/consistent-existence-index-check': 'error' | 'warn' | 'off';

// ❌ Bad - inconsistent existence check
if (array.indexOf(item) !== -1) {
  // handle found item
}

// ✅ Good - consistent existence check
if (array.includes(item)) {
  // handle found item
}

/**
 * Requires explicit length checks for arrays and strings
 * Improves code clarity and prevents subtle bugs
 */
'unicorn/explicit-length-check': 'error' | 'warn' | 'off' | [
  'error' | 'warn',
  {
    'non-zero'?: 'greater-than' | 'not-equal'; // Default: 'greater-than'
  }
];

// ❌ Bad - implicit length check
if (array) {
  // Process array
}

// ✅ Good - explicit length check
if (array.length > 0) {
  // Process array
}

/**
 * Detects potential infinite recursion in accessor methods
 * Prevents common getter/setter implementation mistakes
 */
'unicorn/no-accessor-recursion': 'error' | 'warn' | 'off';

class Example {
  // ❌ Bad - infinite recursion
  get value() {
    return this.value;
  }
  
  // ✅ Good - proper getter implementation
  get value() {
    return this._value;
  }
  
  set value(newValue) {
    this._value = newValue;
  }
}

/**
 * Identifies unnecessary Error.captureStackTrace usage
 * Prevents redundant stack trace manipulation
 */
'unicorn/no-useless-error-capture-stack-trace': 'error' | 'warn' | 'off';

// ❌ Bad - unnecessary captureStackTrace
class CustomError extends Error {
  constructor(message) {
    super(message);
    Error.captureStackTrace(this, CustomError); // Unnecessary
  }
}

// ✅ Good - clean error class
class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomError';
  }
}

export default [
  {
    plugins: {
      unicorn: eslintPluginUnicorn,
    },
    rules: {
      // Error prevention
      'unicorn/better-regex': 'error',
      'unicorn/catch-error-name': 'error',
      'unicorn/custom-error-definition': 'error',
      'unicorn/throw-new-error': 'error',
      
      // Code consistency
      'unicorn/consistent-function-scoping': 'error',
      'unicorn/consistent-destructuring': 'error',
      'unicorn/explicit-length-check': 'error',
      
      // Error handling best practices
      'unicorn/error-message': 'error',
      'unicorn/no-accessor-recursion': 'error',
      'unicorn/no-useless-error-capture-stack-trace': 'error',
    },
  },
];

export default [
  {
    plugins: {
      unicorn: eslintPluginUnicorn,
    },
    rules: {
      // Custom error naming convention
      'unicorn/catch-error-name': ['error', { name: 'err' }],
      
      // Custom assertion style
      'unicorn/consistent-assert': ['error', { assertionStyle: 'never' }],
      
      // Custom length check style
      'unicorn/explicit-length-check': ['error', { 'non-zero': 'not-equal' }],
      
      // Disable function scoping for arrow functions
      'unicorn/consistent-function-scoping': ['error', { checkArrowFunctions: false }],
    },
  },
];