astx/cjs/recast/RecastBackend.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 defaultRecast = _interopRequireWildcard(require('recast'))

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 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 _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 RecastBackend = /*#__PURE__*/ (function (_Backend) {
  ;(0, _inherits2['default'])(RecastBackend, _Backend)

  var _super = _createSuper(RecastBackend)

  function RecastBackend(_ref) {
    var _this

    var wrapped = _ref.wrapped,
      _ref$recast = _ref.recast,
      recast = _ref$recast === void 0 ? defaultRecast : _ref$recast,
      parseOptions = _ref.parseOptions
    ;(0, _classCallCheck2['default'])(this, RecastBackend)
    _this = _super.call(this)
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'wrapped',
      void 0
    )
    ;(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),
      'generate',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'location',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'comments',
      void 0
    )
    _this.wrapped = wrapped
    _this.t = wrapped.t
    parseOptions = _objectSpread(
      _objectSpread({}, parseOptions),
      {},
      {
        parser: wrapped,
      }
    )

    _this.parse = function (code) {
      return recast.parse(code, parseOptions)
    }

    _this.parseStatements = function (code) {
      var ast = recast.parse(code, parseOptions)
      var errors = ast.type === 'File' ? ast.program.errors : ast.errors

      if (errors !== null && errors !== void 0 && errors.length) {
        // Flow parser returns a bogus AST instead of throwing when the grammar is invalid,
        // but it at least includes parse errors in this array
        throw new Error(errors[0].message)
      }

      return ast.program.body
    }

    _this.parseExpression = function (code) {
      var _statements$ // wrap code in `(...)` to force evaluation as expression

      var statements = _this.parseStatements('('.concat(code, ')'))

      var expression

      if (
        ((_statements$ = statements[0]) === null || _statements$ === void 0
          ? void 0
          : _statements$.type) === 'ExpressionStatement'
      ) {
        expression = statements[0].expression
      } else {
        throw new Error('invalid expression: '.concat(code))
      } // Remove added parens


      if (expression.extra) {
        expression.extra.parenthesized = false
      }

      return expression
    }

    _this.generate = function (node) {
      return recast.print(node)
    }

    _this.location = wrapped.location
    _this.comments = /*#__PURE__*/ _regenerator['default'].mark(
      function comments(node, kind) {
        var _node$comments

        return _regenerator['default'].wrap(function comments$(_context) {
          while (1) {
            switch ((_context.prev = _context.next)) {
              case 0:
                if (node.comments) {
                  _context.next = 2
                  break
                }

                return _context.abrupt('return')

              case 2:
                return _context.delegateYield(
                  (_node$comments = node.comments) === null ||
                    _node$comments === void 0
                    ? void 0
                    : _node$comments.filter(function (comment) {
                        return (
                          !kind ||
                          (kind === 'inner'
                            ? !comment.leading && !comment.trailing
                            : comment[kind] === true)
                        )
                      }),
                  't0',
                  3
                )

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

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

exports['default'] = RecastBackend