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

var _taggedTemplateLiteral2 = _interopRequireDefault(
  require('@babel/runtime/helpers/taggedTemplateLiteral')
)

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

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

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 _wrapNativeSuper2 = _interopRequireDefault(
  require('@babel/runtime/helpers/wrapNativeSuper')
)

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

var _CompilePathError = _interopRequireDefault(require('./CompilePathError'))

var _generator = _interopRequireDefault(require('@babel/generator'))

var _codeFrame = require('@babel/code-frame')

var _chalk = _interopRequireDefault(require('chalk'))

var _dedentJs = _interopRequireDefault(require('dedent-js'))

var _templateObject

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

function formatSource(path) {
  var _path3, _generate

  while ((_path = path) !== null && _path !== void 0 && _path.parentPath) {
    var _path, _path2

    path =
      (_path2 = path) === null || _path2 === void 0 ? void 0 : _path2.parentPath
  }

  var node =
    (_path3 = path) === null || _path3 === void 0 ? void 0 : _path3.node
  if (!node) return undefined
  return (_generate = (0, _generator['default'])(node, {
    retainLines: true,
  })) === null || _generate === void 0
    ? void 0
    : _generate.code
}

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

  var _super = _createSuper(CodeFrameError)

  function CodeFrameError(message, _ref) {
    var _path$node

    var _this

    var filename = _ref.filename,
      source = _ref.source,
      path = _ref.path,
      loc = _ref.loc
    ;(0, _classCallCheck2['default'])(this, CodeFrameError)
    _this = _super.call(this, message)
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'filename',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'source',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'path',
      void 0
    )
    ;(0, _defineProperty2['default'])(
      (0, _assertThisInitialized2['default'])(_this),
      'loc',
      void 0
    )
    _this.filename = filename
    _this.path = path
    _this.source =
      source !== null && source !== void 0 ? source : formatSource(path)

    if (
      loc == null &&
      path !== null &&
      path !== void 0 &&
      (_path$node = path.node) !== null &&
      _path$node !== void 0 &&
      _path$node.loc
    ) {
      var _loc = (path === null || path === void 0 ? void 0 : path.node).loc,
        start = _loc.start,
        end = _loc.end
      loc = {
        start: {
          line: start.line,
          column: start.column,
        },
        end: {
          line: end.line,
          column: end.column,
        },
      }
    }

    _this.loc = loc
    return _this
  }

  ;(0, _createClass2['default'])(
    CodeFrameError,
    [
      {
        key: 'format',
        value: function format(options) {
          var red =
            options.highlightCode || options.forceColor
              ? _chalk['default'].red
              : function (s) {
                  return s
                }
          var loc = this.loc,
            source = this.source,
            stack = this.stack,
            message = this.message,
            filename = this.filename
          if (!loc || !source)
            return red(options.stack && stack ? stack : message)
          var start = {
            line: loc.start.line,
            column: loc.start.column + 1,
          }
          var end = loc.end
            ? {
                line: loc.end.line,
                column: loc.end.column + 1,
              }
            : undefined
          return (0, _dedentJs['default'])(
            _templateObject ||
              (_templateObject = (0, _taggedTemplateLiteral2['default'])([
                '\n      ',
                '\n      ',
                '',
                '\n    ',
              ])),
            red(
              'Error in '
                .concat(filename, ' (')
                .concat(start.line, ':')
                .concat(start.column, ')')
            ),
            (0, _codeFrame.codeFrameColumns)(
              source,
              {
                start: start,
                end: end,
              },
              _objectSpread(
                {
                  message: message,
                },
                options
              )
            ),
            options.stack && stack
              ? '\n' +
                  red(
                    stack === null || stack === void 0
                      ? void 0
                      : stack.replace(/^.*?(\r\n?|\n)/, '')
                  )
              : ''
          )
        },
      },
    ],
    [
      {
        key: 'rethrow',
        value: function rethrow(error, _ref2) {
          var filename = _ref2.filename,
            source = _ref2.source

          if (error instanceof CodeFrameError) {
            if (filename) error.filename = filename
            if (source) error.source = source
            throw error
          }

          if (error instanceof _CompilePathError['default']) {
            throw new CodeFrameError(error.message, {
              filename: filename,
              source: source,
              path: error.path,
            })
          }

          if (error instanceof SyntaxError) {
            var _ref3 = error,
              lineNumber = _ref3.lineNumber,
              columnNumber = _ref3.columnNumber,
              loc = _ref3.loc
            throw new CodeFrameError(
              error.message.replace(/\s*\(\d+:\d+\)$/, ''),
              {
                filename: filename,
                source: source,
                loc:
                  typeof (loc === null || loc === void 0
                    ? void 0
                    : loc.line) === 'number' &&
                  typeof (loc === null || loc === void 0
                    ? void 0
                    : loc.column) === 'number'
                    ? {
                        start: loc,
                      }
                    : typeof lineNumber === 'number' &&
                      typeof columnNumber === 'number'
                    ? {
                        start: {
                          line: lineNumber,
                          column: columnNumber,
                        },
                      }
                    : undefined,
              }
            )
          }

          throw error
        },
      },
    ]
  )
  return CodeFrameError
})(/*#__PURE__*/ (0, _wrapNativeSuper2['default'])(Error))

exports['default'] = CodeFrameError