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

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

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

var _Placeholder = _interopRequireDefault(require('./Placeholder'))

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

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
}

var nodeTypes = ['ObjectProperty']

function compileObjectPropertyMatcher(path, compileOptions) {
  var debug = compileOptions.debug,
    backend = compileOptions.backend
  var n = backend.t.namedTypes

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

  var pattern = path.value

  if (n.Identifier.check(pattern.key)) {
    if (
      pattern.shorthand &&
      !pattern.computed &&
      backend.t.astNodesAreEquivalent(pattern.key, pattern.value)
    ) {
      var placeholderMatcher = (0, _Placeholder['default'])(
        path,
        pattern.key.name,
        compileOptions,
        {
          nodeType: 'ObjectMember',
        }
      )
      if (placeholderMatcher) return placeholderMatcher
    }
  }

  if (!pattern.computed) {
    var keyMatcher = (0, _['default'])(path.get('key'), subCompileOptions)
    var valueMatcher = (0, _['default'])(path.get('value'), subCompileOptions)
    return {
      pattern: path,
      nodeType: nodeTypes,
      match: function match(_path, matchSoFar) {
        var node = _path.value

        if (!nodeTypes.includes(node.type)) {
          debug('wrong node type')
          return null
        }

        var path = _path
        debug('key')
        matchSoFar = keyMatcher.match(path.get('key'), matchSoFar)
        if (!matchSoFar) return null
        debug('value')
        return valueMatcher.match(path.get('value'), matchSoFar)
      },
    }
  }
}