astx/cjs/compileMatcher/index.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.convertPredicateMatcher = convertPredicateMatcher
exports['default'] = compileMatcher
exports.mergeCaptures = mergeCaptures

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

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

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

var _debug2 = _interopRequireDefault(require('debug'))

var _AssignmentPattern = _interopRequireDefault(require('./AssignmentPattern'))

var _BooleanLiteral = _interopRequireDefault(require('./BooleanLiteral'))

var _CallExpression = _interopRequireDefault(require('./CallExpression'))

var _ClassImplements = _interopRequireDefault(require('./ClassImplements'))

var _ClassProperty = _interopRequireDefault(require('./ClassProperty'))

var _GenericArrayMatcher = _interopRequireDefault(
  require('./GenericArrayMatcher')
)

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

var _ExportSpecifier = _interopRequireDefault(require('./ExportSpecifier'))

var _ExpressionStatement = _interopRequireDefault(
  require('./ExpressionStatement')
)

var _FunctionTypeParam = _interopRequireDefault(require('./FunctionTypeParam'))

var _GenericTypeAnnotation = _interopRequireDefault(
  require('./GenericTypeAnnotation')
)

var _Identifier = _interopRequireDefault(require('./Identifier'))

var _ImportSpecifier = _interopRequireDefault(require('./ImportSpecifier'))

var _JSXAttribute = _interopRequireDefault(require('./JSXAttribute'))

var _JSXElement = _interopRequireDefault(require('./JSXElement'))

var _JSXExpressionContainer = _interopRequireDefault(
  require('./JSXExpressionContainer')
)

var _JSXIdentifier = _interopRequireDefault(require('./JSXIdentifier'))

var _JSXText = _interopRequireDefault(require('./JSXText'))

var _NumericLiteral = _interopRequireDefault(require('./NumericLiteral'))

var _ObjectProperty = _interopRequireDefault(require('./ObjectProperty'))

var _ObjectTypeProperty = _interopRequireDefault(
  require('./ObjectTypeProperty')
)

var _RegExpLiteral = _interopRequireDefault(require('./RegExpLiteral'))

var _SpreadElement = _interopRequireDefault(require('./SpreadElement'))

var _StringLiteral = _interopRequireDefault(require('./StringLiteral'))

var _TemplateLiteral = _interopRequireDefault(require('./TemplateLiteral'))

var _TSExpressionWithTypeArguments = _interopRequireDefault(
  require('./TSExpressionWithTypeArguments')
)

var _TSPropertySignature = _interopRequireDefault(
  require('./TSPropertySignature')
)

var _TSTypeAnnotation = _interopRequireDefault(require('./TSTypeAnnotation'))

var _TSTypeParameter = _interopRequireDefault(require('./TSTypeParameter'))

var _TSTypeReference = _interopRequireDefault(require('./TSTypeReference'))

var _TypeAnnotation = _interopRequireDefault(require('./TypeAnnotation'))

var _TypeParameter = _interopRequireDefault(require('./TypeParameter'))

var _VariableDeclarator = _interopRequireDefault(
  require('./VariableDeclarator')
)

var _Placeholder = require('./Placeholder')

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 _debug = (0, _debug2['default'])('astx:match')

function hasCapturePlaceholder(captures) {
  for (var key in captures) {
    if ((0, _Placeholder.isCapturePlaceholder)(key)) return true
  }

  return false
}

function mergeCaptures() {
  var current = null

  for (
    var _len = arguments.length, results = new Array(_len), _key = 0;
    _key < _len;
    _key++
  ) {
    results[_key] = arguments[_key]
  }

  for (var _i = 0, _results = results; _i < _results.length; _i++) {
    var result = _results[_i]
    if (!result) continue

    if (result.captures && hasCapturePlaceholder(result.captures)) {
      if (!current) current = {}
      if (!current.captures) current.captures = {}

      for (
        var _i2 = 0, _Object$entries = Object.entries(result.captures);
        _i2 < _Object$entries.length;
        _i2++
      ) {
        var _Object$entries$_i = (0, _slicedToArray2['default'])(
            _Object$entries[_i2],
            2
          ),
          key = _Object$entries$_i[0],
          value = _Object$entries$_i[1]

        if ((0, _Placeholder.isCapturePlaceholder)(key))
          current.captures[key] = value
      }
    }

    if (result.arrayCaptures && hasCapturePlaceholder(result.arrayCaptures)) {
      if (!current) current = {}
      if (!current.arrayCaptures) current.arrayCaptures = {}

      for (
        var _i3 = 0, _Object$entries2 = Object.entries(result.arrayCaptures);
        _i3 < _Object$entries2.length;
        _i3++
      ) {
        var _Object$entries2$_i = (0, _slicedToArray2['default'])(
            _Object$entries2[_i3],
            2
          ),
          _key2 = _Object$entries2$_i[0],
          _value = _Object$entries2$_i[1]

        if ((0, _Placeholder.isCapturePlaceholder)(_key2))
          current.arrayCaptures[_key2] = _value
      }
    }

    if (result.stringCaptures) {
      if (!current) current = {}
      if (!current.stringCaptures) current.stringCaptures = {}
      Object.assign(current.stringCaptures, result.stringCaptures)
    }
  }

  return current
}

var nodeMatchers = {
  AssignmentPattern: _AssignmentPattern['default'],
  BooleanLiteral: _BooleanLiteral['default'],
  CallExpression: _CallExpression['default'],
  ClassImplements: _ClassImplements['default'],
  ClassProperty: _ClassProperty['default'],
  ExportSpecifier: _ExportSpecifier['default'],
  ExpressionStatement: _ExpressionStatement['default'],
  FunctionTypeParam: _FunctionTypeParam['default'],
  GenericTypeAnnotation: _GenericTypeAnnotation['default'],
  Identifier: _Identifier['default'],
  ImportSpecifier: _ImportSpecifier['default'],
  JSXAttribute: _JSXAttribute['default'],
  JSXElement: _JSXElement['default'],
  JSXExpressionContainer: _JSXExpressionContainer['default'],
  JSXIdentifier: _JSXIdentifier['default'],
  JSXText: _JSXText['default'],
  NumericLiteral: _NumericLiteral['default'],
  // ObjectExpression,
  ObjectProperty: _ObjectProperty['default'],
  ObjectTypeProperty: _ObjectTypeProperty['default'],
  RegExpLiteral: _RegExpLiteral['default'],
  SpreadElement: _SpreadElement['default'],
  StringLiteral: _StringLiteral['default'],
  TemplateLiteral: _TemplateLiteral['default'],
  TSExpressionWithTypeArguments: _TSExpressionWithTypeArguments['default'],
  TSPropertySignature: _TSPropertySignature['default'],
  TSTypeAnnotation: _TSTypeAnnotation['default'],
  TSTypeParameter: _TSTypeParameter['default'],
  TSTypeReference: _TSTypeReference['default'],
  TypeAnnotation: _TypeAnnotation['default'],
  TypeParameter: _TypeParameter['default'],
  VariableDeclarator: _VariableDeclarator['default'],
}

function convertPredicateMatcher(pattern, matcher, _ref) {
  var debug = _ref.debug
  return {
    pattern: pattern,
    nodeType: matcher.nodeType,
    match: function match(path, matchSoFar) {
      debug('%s (specific)', pattern.value.type)
      var result = matcher.match(path, matchSoFar)

      if (result) {
        if (result === true) debug('  matched')
        return (0, _typeof2['default'])(result) === 'object'
          ? result
          : matchSoFar || {}
      } else {
        if (result === false) debug("  didn't match")
        return null
      }
    },
  }
}

function compileMatcher(path, rootCompileOptions) {
  var _rootCompileOptions$d = rootCompileOptions.debug,
    debug = _rootCompileOptions$d === void 0 ? _debug : _rootCompileOptions$d

  var compileOptions = _objectSpread(
    _objectSpread({}, rootCompileOptions),
    {},
    {
      debug: debug,
    }
  )

  if (Array.isArray(path.value)) {
    return (0, _GenericArrayMatcher['default'])(path, compileOptions)
  } else if (nodeMatchers[path.value.type]) {
    var matcher = nodeMatchers[path.value.type](path, compileOptions)
    if (matcher) return matcher
  }

  return (0, _GenericNodeMatcher['default'])(path, compileOptions)
}