astx/cjs/backend/parse.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.parsePattern = parsePattern
exports.parsePatternToNodes = parsePatternToNodes

var _ensureArray = _interopRequireDefault(require('../util/ensureArray'))

var _forEachNode = _interopRequireDefault(require('../util/forEachNode'))

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 parse0(backend, strings) {
  var _backend$template3

  for (
    var _len = arguments.length,
      quasis = new Array(_len > 2 ? _len - 2 : 0),
      _key = 2;
    _key < _len;
    _key++
  ) {
    quasis[_key - 2] = arguments[_key]
  }

  try {
    var _backend$template, _backend$template2

    var result = (_backend$template = backend.template).statements.apply(
      _backend$template,
      [strings].concat(quasis)
    )

    if (result.length === 0)
      return (_backend$template2 = backend.template).expression.apply(
        _backend$template2,
        [strings].concat(quasis)
      )
    if (result.length > 1) return result
    var node = result[0]
    return node.type === 'ExpressionStatement' ? node.expression : node
  } catch (error) {
    // fallthrough
  }

  return (_backend$template3 = backend.template).expression.apply(
    _backend$template3,
    [strings].concat(quasis)
  )
}

function parsePattern(strings) {
  var _this = this

  for (
    var _len2 = arguments.length,
      quasis = new Array(_len2 > 1 ? _len2 - 1 : 0),
      _key2 = 1;
    _key2 < _len2;
    _key2++
  ) {
    quasis[_key2 - 1] = arguments[_key2]
  }

  var ast = parse0.apply(void 0, [this, strings].concat(quasis))
  var result = (0, _ensureArray['default'])(ast).map(function (n) {
    return new _this.t.NodePath(n)
  })
  var allComments = []
  ;(0, _forEachNode['default'])(this.t, result, ['Node'], function (path) {
    if (allComments.length >= 2) return
    var node = path.node

    var _iterator = _createForOfIteratorHelper(_this.comments(node)),
      _step

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done; ) {
        var comment = _step.value
        allComments.push(comment)
      }
    } catch (err) {
      _iterator.e(err)
    } finally {
      _iterator.f()
    }
  })
  var done = false

  if (allComments.length >= 2) {
    var from = Infinity,
      to = -Infinity

    var _iterator2 = _createForOfIteratorHelper(allComments),
      _step2

    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
        var comment = _step2.value

        var _this$location2 = this.location(comment),
          start = _this$location2.start,
          end = _this$location2.end

        if (start != null && start > to) to = start
        if (end != null && end < from) from = end
      }
    } catch (err) {
      _iterator2.e(err)
    } finally {
      _iterator2.f()
    }

    if (from != null && to != null && from < to) {
      var pathInRange = function pathInRange(path) {
        var _this$location = _this.location(path.node),
          start = _this$location.start,
          end = _this$location.end

        return start != null && end != null && start >= from && end <= to
      }

      ;(0, _forEachNode['default'])(this.t, result, ['Node'], function (path) {
        if (done) return

        if (pathInRange(path)) {
          while (path.parentPath != null && pathInRange(path.parentPath)) {
            path = path.parentPath
          }

          result = path
          done = true
        }
      })
      if (done) return result
    }
  }

  var extractNext = false
  ;(0, _forEachNode['default'])(this.t, result, ['Node'], function (path) {
    if (done) return

    if (extractNext) {
      result = path
      done = true
      return
    }

    var node = path.node
    var _ref = node,
      comments = _ref.comments,
      leadingComments = _ref.leadingComments,
      innerComments = _ref.innerComments

    if (comments) {
      for (var i = 0; i < comments.length; i++) {
        var c = comments[i]

        if (!c.value && c.leading) {
          comments.splice(i, 1)
          result = path
          done = true
          return
        } else if (!c.value && c.inner) {
          extractNext = true
          return
        }
      }
    }

    if (leadingComments) {
      for (var _i = 0; _i < leadingComments.length; _i++) {
        var _c = leadingComments[_i]

        if (!_c.value) {
          leadingComments.splice(_i, 1)
          result = path
          done = true
          return
        }
      }
    }

    if (innerComments) {
      for (var _i2 = 0; _i2 < innerComments.length; _i2++) {
        var _c2 = innerComments[_i2]

        if (!_c2.value) {
          innerComments.splice(_i2, 1)
          extractNext = true
          return
        }
      }
    }
  })
  return result
}

function parsePatternToNodes(strings) {
  for (
    var _len3 = arguments.length,
      quasis = new Array(_len3 > 1 ? _len3 - 1 : 0),
      _key3 = 1;
    _key3 < _len3;
    _key3++
  ) {
    quasis[_key3 - 1] = arguments[_key3]
  }

  var paths = this.parsePattern.apply(this, [strings].concat(quasis))
  return Array.isArray(paths)
    ? paths.map(function (p) {
        return p.node
      })
    : paths.node
}