astx/cjs/compileMatcher/Or.js

super powerful structural search and replace for JavaScript and TypeScript to automate your refactoring

'use strict'

var _interopRequireDefault = require('@babel/runtime/helpers/interopRequireDefault')

Object.defineProperty(exports, '__esModule', {
  value: true,
})
exports['default'] = compileOrMatcher

var _toConsumableArray2 = _interopRequireDefault(
  require('@babel/runtime/helpers/toConsumableArray')
)

var _ = _interopRequireDefault(require('.'))

function _createForOfIteratorHelper(o, allowArrayLike) {
  var it =
    (typeof Symbol !== 'undefined' && o[Symbol.iterator]) || o['@@iterator']

  if (!it) {
    if (
      Array.isArray(o) ||
      (it = _unsupportedIterableToArray(o)) ||
      (allowArrayLike && o && typeof o.length === 'number')
    ) {
      if (it) o = it
      var i = 0

      var F = function F() {}

      return {
        s: F,
        n: function n() {
          if (i >= o.length)
            return {
              done: true,
            }
          return {
            done: false,
            value: o[i++],
          }
        },
        e: function e(_e) {
          throw _e
        },
        f: F,
      }
    }

    throw new TypeError(
      'Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
    )
  }

  var normalCompletion = true,
    didErr = false,
    err
  return {
    s: function s() {
      it = it.call(o)
    },
    n: function n() {
      var step = it.next()
      normalCompletion = step.done
      return step
    },
    e: function e(_e2) {
      didErr = true
      err = _e2
    },
    f: function f() {
      try {
        if (!normalCompletion && it['return'] != null) it['return']()
      } finally {
        if (didErr) throw err
      }
    },
  }
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return
  if (typeof o === 'string') return _arrayLikeToArray(o, minLen)
  var n = Object.prototype.toString.call(o).slice(8, -1)
  if (n === 'Object' && o.constructor) n = o.constructor.name
  if (n === 'Map' || n === 'Set') return Array.from(o)
  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
    return _arrayLikeToArray(o, minLen)
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length

  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i]
  }

  return arr2
}

function compileOrMatcher(path, paths, compileOptions) {
  var matchers = paths.map(function (path) {
    return (0, _['default'])(path, compileOptions)
  })
  var nodeType = new Set()

  var _iterator = _createForOfIteratorHelper(matchers),
    _step

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done; ) {
      var m = _step.value
      if (Array.isArray(m.nodeType))
        m.nodeType.forEach(function (t) {
          return nodeType.add(t)
        })
      else if (m.nodeType) nodeType.add(m.nodeType)
    }
  } catch (err) {
    _iterator.e(err)
  } finally {
    _iterator.f()
  }

  return {
    pattern: path,
    nodeType: nodeType.size
      ? (0, _toConsumableArray2['default'])(nodeType)
      : undefined,
    optional: true,
    match: function match(path, matchSoFar) {
      var _iterator2 = _createForOfIteratorHelper(matchers),
        _step2

      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
          var matcher = _step2.value
          var result = matcher.match(path, matchSoFar)
          if (result) return result
        }
      } catch (err) {
        _iterator2.e(err)
      } finally {
        _iterator2.f()
      }

      return null
    },
  }
}