eslint-plugin-de-morgan/dist/utils/toggle-negation.js

ESLint plugin for transforming negated boolean expressions via De Morgan’s laws

'use strict'
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
const isLogicalExpression = require('./is-logical-expression.js')
const isBinaryExpression = require('./is-binary-expression.js')
const getNodeContent = require('./get-node-content.js')
const isBoolean = require('./is-boolean.js')
let toggleCode = code =>
  code.startsWith('!') ? code.replace(/^!/u, '') : `!${code}`
let toggleBinaryExpression = (node, context) => {
  let left = getNodeContent.getNodeContent(node.left, context).trim()
  let right = getNodeContent.getNodeContent(node.right, context).trim()
  let notTransformableOperators = [
    '<<',
    '>>',
    '>>>',
    '+',
    '-',
    '*',
    '/',
    '%',
    '**',
    '|',
    '^',
    '&',
    'in',
    'instanceof',
  ]
  if (notTransformableOperators.includes(node.operator)) {
    return `!(${left} ${node.operator} ${right})`
  }
  let operatorMap = {
    '===': '!==',
    '!==': '===',
    '==': '!=',
    '!=': '==',
    '<': '>=',
    '>': '<=',
    '<=': '>',
    '>=': '<',
  }
  let toggledOperator = operatorMap[node.operator]
  return `${left} ${toggledOperator} ${right}`
}
let toggleLogicalExpression = (node, context) => {
  let content = `(${getNodeContent.getNodeContent(node, context).trim()})`
  return toggleCode(content)
}
let toggleUnaryExpression = (node, context) => {
  let content = getNodeContent.getNodeContent(node, context).trim()
  return toggleCode(content)
}
let toggleBooleanLiteral = node => (node.value ? 'false' : 'true')
let toggleNegation = (node, context) => {
  let toggleStrategies = [
    {
      transformer: toggleBinaryExpression,
      predicate: isBinaryExpression.isBinaryExpression,
    },
    {
      transformer: toggleBooleanLiteral,
      predicate: isBoolean.isBoolean,
    },
    {
      transformer: toggleLogicalExpression,
      predicate: isLogicalExpression.isLogicalExpression,
    },
  ]
  for (let { transformer, predicate } of toggleStrategies) {
    if (predicate(node)) {
      return transformer(node, context)
    }
  }
  return toggleUnaryExpression(node, context)
}
exports.toggleCode = toggleCode
exports.toggleNegation = toggleNegation
exports.toggleUnaryExpression = toggleUnaryExpression