astx/cjs/compileMatcher/Identifier.js

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

'use strict'

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

var _typeof = require('@babel/runtime/helpers/typeof')

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

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

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

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

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

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

function _getRequireWildcardCache(nodeInterop) {
  if (typeof WeakMap !== 'function') return null
  var cacheBabelInterop = new WeakMap()
  var cacheNodeInterop = new WeakMap()
  return (_getRequireWildcardCache = function _getRequireWildcardCache(
    nodeInterop
  ) {
    return nodeInterop ? cacheNodeInterop : cacheBabelInterop
  })(nodeInterop)
}

function _interopRequireWildcard(obj, nodeInterop) {
  if (!nodeInterop && obj && obj.__esModule) {
    return obj
  }

  if (
    obj === null ||
    (_typeof(obj) !== 'object' && typeof obj !== 'function')
  ) {
    return {
      default: obj,
    }
  }

  var cache = _getRequireWildcardCache(nodeInterop)

  if (cache && cache.has(obj)) {
    return cache.get(obj)
  }

  var newObj = {}
  var hasPropertyDescriptor =
    Object.defineProperty && Object.getOwnPropertyDescriptor

  for (var key in obj) {
    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
      var desc = hasPropertyDescriptor
        ? Object.getOwnPropertyDescriptor(obj, key)
        : null

      if (desc && (desc.get || desc.set)) {
        Object.defineProperty(newObj, key, desc)
      } else {
        newObj[key] = obj[key]
      }
    }
  }

  newObj['default'] = obj

  if (cache) {
    cache.set(obj, newObj)
  }

  return newObj
}

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 compileIdentifierMatcher(path, compileOptions) {
  var pattern = path.value
  var n = compileOptions.backend.t.namedTypes
  var typeAnnotation = path.get('typeAnnotation')
  var placeholderMatcher = (0, _Placeholder['default'])(
    path,
    pattern.name,
    compileOptions,
    {
      nodeType: 'Identifier',
      getCondition: function getCondition() {
        return []
          .concat(
            (0, _toConsumableArray2['default'])(
              [
                [n.VariableDeclarator, 'id'],
                [n.Function, 'id'],
                [n.CallExpression, 'callee'],
                [n.MemberExpression, 'object'],
                [n.MemberExpression, 'property'],
                [n.ObjectProperty, 'key'],
                [n.ObjectProperty, 'value'],
                [n.SpreadElement, 'argument'],
                [n.Class, 'id'],
                [n.Class, 'superClass'],
                [n.TypeAlias, 'id'],
                [n.TSTypeAliasDeclaration, 'id'],
                [n.ObjectTypeProperty, 'key'],
                [n.ObjectTypeProperty, 'value'],
              ].map(function (_ref) {
                var _ref2 = (0, _slicedToArray2['default'])(_ref, 2),
                  type = _ref2[0],
                  field = _ref2[1]

                return function (path) {
                  var _path$parent

                  return (
                    type.check(
                      (_path$parent = path.parent) === null ||
                        _path$parent === void 0
                        ? void 0
                        : _path$parent.value
                    ) && path.name === field
                  )
                }
              })
            ),
            (0, _toConsumableArray2['default'])(
              [[n.TSFunctionType, 'parameters']].map(function (_ref3) {
                var _ref4 = (0, _slicedToArray2['default'])(_ref3, 2),
                  type = _ref4[0],
                  field = _ref4[1]

                return function (path) {
                  var _path$parent2, _path$parentPath

                  return (
                    type.check(
                      (_path$parent2 = path.parent) === null ||
                        _path$parent2 === void 0
                        ? void 0
                        : _path$parent2.value
                    ) &&
                    ((_path$parentPath = path.parentPath) === null ||
                    _path$parentPath === void 0
                      ? void 0
                      : _path$parentPath.name) === field
                  )
                }
              })
            )
          )
          .find(function (cond) {
            return cond(path)
          })
      },
    }
  )

  if (placeholderMatcher) {
    var placeholder = placeholderMatcher.placeholder

    if (typeAnnotation && typeAnnotation.value) {
      var typeAnnotationMatcher = (0, _['default'])(
        typeAnnotation,
        compileOptions
      )
      return _objectSpread(
        _objectSpread({}, placeholderMatcher),
        {},
        {
          match: function match(path, matchSoFar) {
            var _matchSoFar$captures

            matchSoFar = placeholderMatcher.match(path, matchSoFar)
            if (matchSoFar == null) return null
            var captured = placeholder
              ? (_matchSoFar$captures = matchSoFar.captures) === null ||
                _matchSoFar$captures === void 0
                ? void 0
                : _matchSoFar$captures[placeholder]
              : null

            if (captured) {
              captured.node.astx = {
                excludeTypeAnnotationFromCapture: true,
              }
            }

            return typeAnnotationMatcher.match(
              path.get('typeAnnotation'),
              matchSoFar
            )
          },
        }
      )
    }

    return placeholderMatcher
  }

  pattern.name = (0, _Placeholder.unescapeIdentifier)(pattern.name)
}