astx/cjs/chooseGetBackend.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'] = chooseGetBackend

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

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

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

var _getBabelAutoBackend = _interopRequireDefault(
  require('./babel/getBabelAutoBackend')
)

var _getBabelBackend = _interopRequireDefault(
  require('./babel/getBabelBackend')
)

var _Backend = require('./backend/Backend')

var _getRecastBackend = _interopRequireDefault(
  require('./recast/getRecastBackend')
)

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 chooseGetBackend(parser) {
  if (parser instanceof _Backend.Backend)
    return /*#__PURE__*/ (0, _asyncToGenerator2['default'])(
      /*#__PURE__*/ _regenerator['default'].mark(function _callee() {
        return _regenerator['default'].wrap(function _callee$(_context) {
          while (1) {
            switch ((_context.prev = _context.next)) {
              case 0:
                return _context.abrupt('return', parser)

              case 1:
              case 'end':
                return _context.stop()
            }
          }
        }, _callee)
      })
    )
  if (!parser) return _getBabelAutoBackend['default']

  if (parser.startsWith('recast/')) {
    var getWrappedBackend = chooseGetBackend(parser.substring('recast/'.length))
    return (0, _getRecastBackend['default'])(function (file, options) {
      return getWrappedBackend(
        file,
        _objectSpread(
          _objectSpread({}, options),
          {},
          {
            tokens: true,
          }
        )
      )
    })
  }

  switch (parser) {
    case 'babel/auto':
      return _getBabelAutoBackend['default']

    case 'babel':
      return _getBabelBackend['default']

    default:
      throw new Error('unknown parser: '.concat(parser))
  }
}