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

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

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

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

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

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

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

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

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

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

var defaultParser = _interopRequireWildcard(require('@babel/parser'))

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

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

var _babelAstTypes = _interopRequireDefault(require('./babelAstTypes'))

var _reprint = _interopRequireDefault(require('./reprint'))

var _detectChangedNodes = _interopRequireDefault(
  require('../util/detectChangedNodes')
)
var _cloneAstWithOriginals = require('../util/cloneAstWithOriginals')

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 _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct()

  return function _createSuperInternal() {
    var Super = (0, _getPrototypeOf2['default'])(Derived),
      result

    if (hasNativeReflectConstruct) {
      var NewTarget = (0, _getPrototypeOf2['default'])(this).constructor
      result = Reflect.construct(Super, arguments, NewTarget)
    } else {
      result = Super.apply(this, arguments)
    }

    return (0, _possibleConstructorReturn2['default'])(this, result)
  }
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === 'undefined' || !Reflect.construct) return false
  if (Reflect.construct.sham) return false
  if (typeof Proxy === 'function') return true

  try {
    Boolean.prototype.valueOf.call(
      Reflect.construct(Boolean, [], function () {})
    )
    return true
  } catch (e) {
    return false
  }
}

var BabelBackend = /*#__PURE__*/ (function (_Backend) {
  ;(0, _inherits2['default'])(BabelBackend, _Backend)

  var _super = _createSuper(BabelBackend)

  function BabelBackend() {
    var _this

    var _ref =
        arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      _ref$parser = _ref.parser,
      parser = _ref$parser === void 0 ? defaultParser : _ref$parser,
      parserOptions = _ref.parserOptions,
      _ref$generator = _ref.generator,
      generator = _ref$generator === void 0 ? defaultGenerator : _ref$generator,
      _ref$types = _ref.types,
      types = _ref$types === void 0 ? defaultTypes : _ref$types,
      preserveFormat = _ref.preserveFormat

    ;(0, _classCallCheck2['default'])(this, BabelBackend)
    _this = _super.call(this)
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      't',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'parse',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'parseExpression',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'parseStatements',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'generator',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'generate',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'location',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'comments',
      void 0
    )
    var t = (0, _babelAstTypes['default'])(types)
    _this.t = t

    _this.parse = function (code) {
      return (0, _cloneAstWithOriginals.cloneAstWithOriginals)(
        parser.parse(code, parserOptions),
        code
      )
    }

    _this.parseExpression = function (code) {
      return parser.parseExpression(code, parserOptions)
    }

    _this.parseStatements = function (code) {
      var ast = _this.parse(code)

      if (ast.type !== 'File') {
        throw new Error('failed to get File node')
      }

      return ast.program.body
    }

    _this.generator = generator
    _this.generate =
      preserveFormat === 'generatorHack'
        ? function (node) {
            ;(0, _detectChangedNodes['default'])(_this.t, new t.NodePath(node))
            return (0, _reprint['default'])(_this.generator, node)
          }
        : generator['default']

    _this.location = function (node) {
      var _node$loc,
        _node$loc$start,
        _node$loc2,
        _node$loc2$start,
        _node$loc3,
        _node$loc3$end,
        _node$loc4,
        _node$loc4$end

      return {
        start: node.start,
        end: node.end,
        startLine:
          (_node$loc = node.loc) === null || _node$loc === void 0
            ? void 0
            : (_node$loc$start = _node$loc.start) === null ||
              _node$loc$start === void 0
            ? void 0
            : _node$loc$start.line,
        startColumn:
          (_node$loc2 = node.loc) === null || _node$loc2 === void 0
            ? void 0
            : (_node$loc2$start = _node$loc2.start) === null ||
              _node$loc2$start === void 0
            ? void 0
            : _node$loc2$start.column,
        endLine:
          (_node$loc3 = node.loc) === null || _node$loc3 === void 0
            ? void 0
            : (_node$loc3$end = _node$loc3.end) === null ||
              _node$loc3$end === void 0
            ? void 0
            : _node$loc3$end.line,
        endColumn:
          (_node$loc4 = node.loc) === null || _node$loc4 === void 0
            ? void 0
            : (_node$loc4$end = _node$loc4.end) === null ||
              _node$loc4$end === void 0
            ? void 0
            : _node$loc4$end.column,
      }
    }

    _this.comments = /*#__PURE__*/ _regenerator['default'].mark(
      function comments(node, kind) {
        var leadingComments, innerComments, trailingComments
        return _regenerator['default'].wrap(function comments$(_context) {
          while (1) {
            switch ((_context.prev = _context.next)) {
              case 0:
                if (!(!kind || kind === 'leading')) {
                  _context.next = 4
                  break
                }

                leadingComments = node.leadingComments

                if (!leadingComments) {
                  _context.next = 4
                  break
                }

                return _context.delegateYield(leadingComments, 't0', 4)

              case 4:
                if (!(!kind || kind === 'inner')) {
                  _context.next = 8
                  break
                }

                innerComments = node.innerComments

                if (!innerComments) {
                  _context.next = 8
                  break
                }

                return _context.delegateYield(innerComments, 't1', 8)

              case 8:
                if (!(!kind || kind === 'trailing')) {
                  _context.next = 12
                  break
                }

                trailingComments = node.trailingComments

                if (!trailingComments) {
                  _context.next = 12
                  break
                }

                return _context.delegateYield(trailingComments, 't2', 12)

              case 12:
              case 'end':
                return _context.stop()
            }
          }
        }, comments)
      }
    )
    return _this
  }

  return (0, _createClass2['default'])(BabelBackend)
})(_Backend2.Backend)

exports['default'] = BabelBackend