eslint-plugin-de-morgan

The plugin transforms negated boolean expressions to improve clarity and reduce errors.

Example 1: Negated Conjunction

• Before: if (!(a && b))
• After: if (!a || !b)

Example 2: Complex Negated Disjunction

• Before: if (!(a || !b || c >= 10 || d !== e))
• After: if (!a && b && !(c >= 10) && d === e)

// Before
if (!(a && b)) {
  /* ... */
}

// After
if (!a || !b) {
  /* ... */
}

To use this plugin, you must first have ESLint installed. Then, install eslint-plugin-de-morgan as a development dependency.

npm install --save-dev eslint
npm install --save-dev eslint-plugin-de-morgan

For modern ESLint setups using Flat Config, import the plugin and use the deMorgan.configs.recommended object in your configuration array.

import deMorgan from 'eslint-plugin-de-morgan'

export default [
  deMorgan.configs.recommended,
]

For older ESLint setups, extend the plugin using the plugin:de-morgan/recommended-legacy string in your extends array.

module.exports = {
  extends: [
    'plugin:de-morgan/recommended-legacy',
  ],
}

The no-negated-conjunction rule is auto-fixable. When the rule detects a negated conjunction that meets the application criteria, it can automatically rewrite the expression into its disjunctive form.

// Input:
if (!(a && !b && c >= 10)) {
  /* ... */
}

// Auto-fixed output:
if (!a || b || !(c >= 10)) {
  /* ... */
}

The no-negated-disjunction rule is auto-fixable. When the ESLint fix command is run, it will automatically rewrite complex negated disjunctions into their equivalent conjunction forms.

// Before
if (!(a || !b || c >= 10)) {
  /* ... */
}

// After
if (!a && b && !(c >= 10)) {
  /* ... */
}

The plugin provides two pre-defined configurations to quickly enable its rules.

• For the modern Flat Config (eslint.config.js), use the recommended config.
• For the Legacy Config (.eslintrc.js), use the recommended-legacy config.

Both configurations enable all available rules with the 'error' severity level.

// Flat Config (eslint.config.js)
import deMorgan from 'eslint-plugin-de-morgan';

export default [
  deMorgan.configs.recommended,
];

// Legacy Config (.eslintrc.js)
module.exports = {
  plugins: ['de-morgan'],
  extends: ['plugin:de-morgan/recommended-legacy'],
};

The plugin provides two rules that enforce logical consistency by applying De Morgan's laws. Both rules are automatically fixable using the ESLint --fix CLI option.

The no-negated-conjunction rule enforces De Morgan's first law by transforming the negation of a conjunction into an equivalent disjunction of negations. This improves readability by making it explicit that at least one condition must be false, rather than wrapping a group of conditions in a negation.

Rule Application

The rule applies only when the operand of the negation is a pure conjunction (all operands are combined with && at the same nesting level). It will not apply if the expression inside the negation contains a mix of logical operators (e.g., !(a && b || c)).

// From this:
if (!(a && b)) {
  /* ... */
}

// To this:
if (!a || !b) {
  /* ... */
}

The no-negated-disjunction rule transforms the negation of a disjunction into an equivalent conjunction of negations, following De Morgan's second law.

Instead of using a negated disjunction (e.g., !(a || b)), the rule enforces the use of individual negations joined by AND (e.g., !a && !b). This makes boolean logic more explicit and easier to read by clearly indicating that all individual conditions must be false.

Application Criteria

• The rule only applies when the operand of the negation is a pure disjunction. This means all operands must be combined with || at the same nesting level.
• The rule will not apply if the expression inside the negation contains a mix of different logical operators (e.g., !(a || b && c)).

// Before
if (!(a || b)) {
  /* ... */
}

// After
if (!a && !b) {
  /* ... */
}

The plugin exports the following rules which can be used individually in your ESLint configuration:

• no-negated-conjunction: Detects and suggests simplification of negated conjunctions (e.g., !(a && b) to !a || !b).
• no-negated-disjunction: Detects and suggests simplification of negated disjunctions (e.g., !(a || b) to !a && !b).

When using these rules manually, prefix them with the plugin name: de-morgan/no-negated-conjunction or de-morgan/no-negated-disjunction.

// Example manual rule configuration
export default [
  {
    rules: {
      'de-morgan/no-negated-conjunction': 'error',
      'de-morgan/no-negated-disjunction': 'warn',
    },
  },
];