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

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

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

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

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

var _path = _interopRequireDefault(require('path'))

var _resolve2 = _interopRequireDefault(require('resolve'))

var _BabelBackend = _interopRequireDefault(require('./BabelBackend'))

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

var defaultBabelGenerator = _interopRequireWildcard(require('@babel/generator'))

var _babelParseWildCode = require('babel-parse-wild-code')

var _util = require('util')

var _excluded = ['preserveFormat']

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 resolve = (0, _util.promisify)(_resolve2['default'])

function importLocal(_x, _x2) {
  return _importLocal.apply(this, arguments)
}

function _importLocal() {
  _importLocal = (0, _asyncToGenerator2['default'])(
    /*#__PURE__*/ _regenerator['default'].mark(function _callee(pkg, basedir) {
      var resolved
      return _regenerator['default'].wrap(function _callee$(_context) {
        while (1) {
          switch ((_context.prev = _context.next)) {
            case 0:
              _context.next = 2
              return resolve(pkg, {
                basedir: basedir,
              })

            case 2:
              resolved = _context.sent
              _context.next = 5
              return Promise.resolve(
                ''.concat(
                  /* webpackIgnore: true */
                  resolved
                )
              ).then(function (s) {
                return _interopRequireWildcard(require(s))
              })

            case 5:
              return _context.abrupt('return', _context.sent)
            case 6:
            case 'end':
              return _context.stop()
          }
        }
      }, _callee)
    })
  )
  return _importLocal.apply(this, arguments)
}

function getBabelAutoBackend(_x3) {
  return _getBabelAutoBackend.apply(this, arguments)
}

function _getBabelAutoBackend() {
  _getBabelAutoBackend = (0, _asyncToGenerator2['default'])(
    /*#__PURE__*/ _regenerator['default'].mark(function _callee2(file) {
      var _ref,
        preserveFormat,
        options,
        basedir,
        _yield$Promise$all,
        _yield$Promise$all2,
        _parser,
        types,
        generator,
        parser,
        _args2 = arguments

      return _regenerator['default'].wrap(function _callee2$(_context2) {
        while (1) {
          switch ((_context2.prev = _context2.next)) {
            case 0:
              ;(_ref =
                _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {}),
                (preserveFormat = _ref.preserveFormat),
                (options = (0, _objectWithoutProperties2['default'])(
                  _ref,
                  _excluded
                ))
              basedir = _path['default'].dirname(file)
              _context2.next = 4
              return Promise.all([
                (0, _babelParseWildCode.getParserAsync)(file, options),
                importLocal('@babel/types', basedir)['catch'](function () {
                  return defaultBabelTypes
                }),
                importLocal('@babel/generator', basedir)['catch'](function () {
                  return defaultBabelGenerator
                }),
              ])

            case 4:
              _yield$Promise$all = _context2.sent
              _yield$Promise$all2 = (0, _slicedToArray2['default'])(
                _yield$Promise$all,
                3
              )
              _parser = _yield$Promise$all2[0]
              types = _yield$Promise$all2[1]
              generator = _yield$Promise$all2[2]
              parser = (
                _parser.parserOpts.sourceType
                  ? _parser
                  : _parser.bindParserOpts({
                      sourceType: 'unambiguous',
                    })
              ).forExtension(file)
              return _context2.abrupt(
                'return',
                new _BabelBackend['default']({
                  parser: parser,
                  parserOptions: options,
                  preserveFormat: preserveFormat,
                  generator: generator,
                  types: types,
                })
              )

            case 11:
            case 'end':
              return _context2.stop()
          }
        }
      }, _callee2)
    })
  )
  return _getBabelAutoBackend.apply(this, arguments)
}