astx/cjs/convertReplacement/index.js

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

'use strict'

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

var _regeneratorRuntime2 = require('@babel/runtime/regenerator')

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

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

var _regenerator = _interopRequireDefault(require('@babel/runtime/regenerator'))

var _convertJSXChildReplacement = _interopRequireDefault(
  require('./convertJSXChildReplacement')
)

var _convertJSXAttributeValueReplacement = _interopRequireDefault(
  require('./convertJSXAttributeValueReplacement')
)

var _convertTypeParameterReplacement = _interopRequireDefault(
  require('./convertTypeParameterReplacement')
)

var _convertTSTypeParameterReplacement = _interopRequireDefault(
  require('./convertTSTypeParameterReplacement')
)

var _convertFlowTypeReplacement = _interopRequireDefault(
  require('./convertFlowTypeReplacement')
)

var _convertTSTypeReplacement = _interopRequireDefault(
  require('./convertTSTypeReplacement')
)

var _convertPropertyReplacement = _interopRequireDefault(
  require('./convertPropertyReplacement')
)

var _convertExpressionReplacement = _interopRequireDefault(
  require('./convertExpressionReplacement')
)

var _convertStatementReplacement = _interopRequireDefault(
  require('./convertStatementReplacement')
)

var _convertImportSpecifierReplacement = _interopRequireDefault(
  require('./convertImportSpecifierReplacement')
)

var t = _interopRequireWildcard(require('@babel/types'))

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

var _convertArrayElementReplacement = _interopRequireDefault(
  require('./convertArrayElementReplacement')
)

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
}

var _marked = /*#__PURE__*/ _regeneratorRuntime2.mark(bulkConvert)

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 identity(x) {
  return x
}

var nodeConverters = {
  TypeParameter: _convertTypeParameterReplacement['default'],
  TSTypeParameter: _convertTSTypeParameterReplacement['default'],
  ImportSpecifier: _convertImportSpecifierReplacement['default'],
  ImportDefaultSpecifier: _convertImportSpecifierReplacement['default'],
}

function createReplacementConverter(path) {
  var _path$parentPath

  var parentNode =
    (_path$parentPath = path.parentPath) === null || _path$parentPath === void 0
      ? void 0
      : _path$parentPath.node
  var nodeConverter = nodeConverters[path.node.type]
  if (nodeConverter) return nodeConverter(path)

  switch (
    parentNode === null || parentNode === void 0 ? void 0 : parentNode.type
  ) {
    case 'JSXAttribute':
      if (path.node === parentNode.value)
        return _convertJSXAttributeValueReplacement['default']
      break
    case 'JSXElement':
      return _convertJSXChildReplacement['default']

    case 'ObjectExpression':
    case 'ObjectPattern':
      return _convertPropertyReplacement['default']

    case 'ArrayExpression':
    case 'ArrayPattern':
      return _convertArrayElementReplacement['default']
  }

  if (t.isStatement(path.node)) {
    return _convertStatementReplacement['default']
  }

  if (t.isExpression(path.node)) {
    return _convertExpressionReplacement['default']
  }

  if (t.isFlow(path.node)) {
    return _convertFlowTypeReplacement['default']
  }

  if (t.isTSType(path.node)) {
    return _convertTSTypeReplacement['default']
  }

  return identity
}

function bulkConvert(nodes, convert) {
  var _iterator, _step, node, converted

  return _regenerator['default'].wrap(
    function bulkConvert$(_context) {
      while (1) {
        switch ((_context.prev = _context.next)) {
          case 0:
            _iterator = _createForOfIteratorHelper(
              (0, _ensureArray['default'])(nodes)
            )
            _context.prev = 1

            _iterator.s()

          case 3:
            if ((_step = _iterator.n()).done) {
              _context.next = 14
              break
            }

            node = _step.value
            converted = convert(node)

            if (!Array.isArray(converted)) {
              _context.next = 10
              break
            }

            return _context.delegateYield(converted, 't0', 8)

          case 8:
            _context.next = 12
            break

          case 10:
            _context.next = 12
            return converted

          case 12:
            _context.next = 3
            break

          case 14:
            _context.next = 19
            break

          case 16:
            _context.prev = 16
            _context.t1 = _context['catch'](1)

            _iterator.e(_context.t1)

          case 19:
            _context.prev = 19

            _iterator.f()

            return _context.finish(19)

          case 22:
          case 'end':
            return _context.stop()
        }
      }
    },
    _marked,
    null,
    [[1, 16, 19, 22]]
  )
}