astx/cjs/compileMatcher/AssignmentPattern.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'] = compileAssignmentPatternMatcher

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

var _types = require('../types')

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

var _indentDebug = _interopRequireDefault(require('./indentDebug'))

var _GenericNodeMatcher = _interopRequireDefault(
  require('./GenericNodeMatcher')
)

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object)

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object)
    enumerableOnly &&
      (symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable
      })),
      keys.push.apply(keys, symbols)
  }

  return keys
}

function _objectSpread(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {}
    i % 2
      ? ownKeys(Object(source), !0).forEach(function (key) {
          ;(0, _defineProperty2['default'])(target, key, source[key])
        })
      : Object.getOwnPropertyDescriptors
      ? Object.defineProperties(
          target,
          Object.getOwnPropertyDescriptors(source)
        )
      : ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(
            target,
            key,
            Object.getOwnPropertyDescriptor(source, key)
          )
        })
  }

  return target
}

function compileAssignmentPatternMatcher(pattern, compileOptions) {
  var debug = compileOptions.debug
  var n = compileOptions.backend.t.namedTypes

  var subCompileOptions = _objectSpread(
    _objectSpread({}, compileOptions),
    {},
    {
      debug: (0, _indentDebug['default'])(debug, 1),
    }
  )

  var left = pattern.get('left')
  var right = pattern.get('right')
  var rightMatcher = (0, _['default'])(right, subCompileOptions)

  if (rightMatcher.optional) {
    var leftMatcher = (0, _['default'])(left, subCompileOptions)
    var wholeMatcher = (0, _GenericNodeMatcher['default'])(
      pattern,
      subCompileOptions
    )
    return {
      pattern: pattern,
      match: function match(path, matchSoFar) {
        debug('AssignmentPattern (with optional right)')
        return (
          (0, _types.pathIs)(path, n.AssignmentPattern)
            ? wholeMatcher
            : leftMatcher
        ).match(path, matchSoFar)
      },
    }
  }
}