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

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

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

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

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 _symbols = require('../util/symbols')

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
  }
}

function reprint(generator, node) {
  var CodeGenerator = generator.CodeGenerator,
    generate = generator['default']
  var gen = new CodeGenerator(node)

  if (gen._generator instanceof Object) {
    var Generator = gen._generator.constructor

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

      var _super = _createSuper(Reprinter)

      function Reprinter(ast) {
        var opts =
          arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
        var code = arguments.length > 2 ? arguments[2] : undefined
        ;(0, _classCallCheck2['default'])(this, Reprinter)
        return _super.call(this, ast, opts, code)
      }

      ;(0, _createClass2['default'])(Reprinter, [
        {
          key: 'print',
          value: function print(
            node,
            parent,
            noLineTerminatorAfter,
            trailingCommentsLineOffset,
            forceParens
          ) {
            var _this = this // Nodes with typeAnnotations are screwy in Babel...

            if (node && !node.typeAnnotation) {
              var orig = node[_symbols.original]
              var src = node[_symbols.source]

              if (orig && src) {
                var start = orig.start,
                  end = orig.end

                if (Number.isInteger(start) && Number.isInteger(end)) {
                  var origPrintMethod = this[node.type]

                  try {
                    // massive hack to override the node printing with
                    // the original source formatting,
                    // while letting @babel/generator decide if it needs
                    // to wrap in parens etc
                    this[node.type] = function () {
                      return _this._append(src.substring(start, end), false)
                    }

                    ;(0, _get2['default'])(
                      (0, _getPrototypeOf2['default'])(Reprinter.prototype),
                      'print',
                      this
                    ).call(
                      this,
                      node,
                      parent,
                      noLineTerminatorAfter,
                      trailingCommentsLineOffset,
                      forceParens
                    )
                    return
                  } finally {
                    this[node.type] = origPrintMethod
                  }
                }
              }
            }

            ;(0, _get2['default'])(
              (0, _getPrototypeOf2['default'])(Reprinter.prototype),
              'print',
              this
            ).call(
              this,
              node,
              parent,
              noLineTerminatorAfter,
              trailingCommentsLineOffset,
              forceParens
            )
          },
        },
      ])
      return Reprinter
    })(Generator)

    return new Reprinter(node).generate(node)
  }

  return generate(node)
}