astx/cjs/babel/babelAstTypes.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 _slicedToArray2 = _interopRequireDefault(
  require('@babel/runtime/helpers/slicedToArray')
)

var _toConsumableArray2 = _interopRequireDefault(
  require('@babel/runtime/helpers/toConsumableArray')
)

var _types = _interopRequireDefault(require('ast-types/lib/types'))

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

var _lodash = require('lodash')

var _fork = _interopRequireDefault(require('ast-types/fork'))

var _nodePath = _interopRequireDefault(require('ast-types/lib/node-path'))

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 _createForOfIteratorHelper(o, allowArrayLike) {
  var it =
    (typeof Symbol !== 'undefined' && o[Symbol.iterator]) || o['@@iterator']

  if (!it) {
    if (
      Array.isArray(o) ||
      (it = _unsupportedIterableToArray(o)) ||
      (allowArrayLike && o && typeof o.length === 'number')
    ) {
      if (it) o = it
      var i = 0

      var F = function F() {}

      return {
        s: F,
        n: function n() {
          if (i >= o.length)
            return {
              done: true,
            }
          return {
            done: false,
            value: o[i++],
          }
        },
        e: function e(_e) {
          throw _e
        },
        f: F,
      }
    }

    throw new TypeError(
      'Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
    )
  }

  var normalCompletion = true,
    didErr = false,
    err
  return {
    s: function s() {
      it = it.call(o)
    },
    n: function n() {
      var step = it.next()
      normalCompletion = step.done
      return step
    },
    e: function e(_e2) {
      didErr = true
      err = _e2
    },
    f: function f() {
      try {
        if (!normalCompletion && it['return'] != null) it['return']()
      } finally {
        if (didErr) throw err
      }
    },
  }
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return
  if (typeof o === 'string') return _arrayLikeToArray(o, minLen)
  var n = Object.prototype.toString.call(o).slice(8, -1)
  if (n === 'Object' && o.constructor) n = o.constructor.name
  if (n === 'Map' || n === 'Set') return Array.from(o)
  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
    return _arrayLikeToArray(o, minLen)
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length

  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i]
  }

  return arr2
}

var typesPlugin = _types['default']['default'] || _types['default']
var babelAstTypes = (0, _lodash.memoize)(function () {
  var t =
    arguments.length > 0 && arguments[0] !== undefined
      ? arguments[0]
      : defaultTypes

  function babel(fork) {
    var types = fork.use(typesPlugin)
    var builtInTypes = types.builtInTypes,
      Type = types.Type
    var def = Type.def,
      or = Type.or
    fork.use(_nodePath['default'])
    def('Node').field('type', builtInTypes.string)

    function tryConvertValidate(validate, node) {
      if (!validate) return {}

      if (validate.type) {
        switch (validate.type) {
          case 'any':
            return {}

          case 'string':
            return builtInTypes.string

          case 'boolean':
            return builtInTypes['boolean']

          case 'number':
            return builtInTypes.number

          case 'null':
            return builtInTypes['null']

          case 'undefined':
            return builtInTypes.undefined
        }
      }

      if (validate.chainOf) {
        var _iterator = _createForOfIteratorHelper(validate.chainOf),
          _step

        try {
          for (_iterator.s(); !(_step = _iterator.n()).done; ) {
            var elem = _step.value
            var converted = tryConvertValidate(elem)
            if (converted) return converted
          }
        } catch (err) {
          _iterator.e(err)
        } finally {
          _iterator.f()
        }
      }

      if (validate.each) {
        return [convertValidate(validate.each)]
      }

      if (validate.oneOfNodeTypes) {
        return or.apply(
          void 0,
          (0, _toConsumableArray2['default'])(
            validate.oneOfNodeTypes.map(function (type) {
              return def(type)
            })
          )
        )
      }

      if (validate.oneOf) {
        return node !== null && node !== void 0 && node.optional
          ? or.apply(
              void 0,
              (0, _toConsumableArray2['default'])(validate.oneOf).concat([null])
            )
          : or.apply(
              void 0,
              (0, _toConsumableArray2['default'])(validate.oneOf)
            )
      }

      if (validate.shapeOf) {
        return (0, _lodash.mapValues)(validate.shapeOf, function (value) {
          return convertValidate(value.validate, value)
        })
      }

      if (validate.oneOfNodeOrValueTypes) {
        return or.apply(
          void 0,
          (0, _toConsumableArray2['default'])(
            validate.oneOfNodeOrValueTypes.map(function (type) {
              return /^[A-Z]/.test(type)
                ? def(type)
                : convertValidate({
                    type: type,
                  })
            })
          )
        )
      }
    }

    function convertValidate(validate, node) {
      var converted = tryConvertValidate(validate, node)

      if (!converted) {
        throw new Error(
          "couldn't determine field def for validate: ".concat(
            JSON.stringify(validate)
          )
        )
      }

      return converted
    }

    for (
      var _i = 0, _Object$entries = Object.entries(t.NODE_FIELDS);
      _i < _Object$entries.length;
      _i++
    ) {
      var _Object$entries$_i = (0, _slicedToArray2['default'])(
          _Object$entries[_i],
          2
        ),
        type = _Object$entries$_i[0],
        fields = _Object$entries$_i[1]

      var d = def(type)
      d.field('type', type)
      var aliases = t.ALIAS_KEYS[type]

      if (aliases) {
        var _iterator2 = _createForOfIteratorHelper(aliases),
          _step2

        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
            var alias = _step2.value
            def(alias)
          }
        } catch (err) {
          _iterator2.e(err)
        } finally {
          _iterator2.f()
        }

        d.bases.apply(
          d,
          ['Node'].concat((0, _toConsumableArray2['default'])(aliases))
        )
      } else {
        d.bases('Node')
      }

      var _loop = function _loop() {
        var _Object$entries2$_i = (0, _slicedToArray2['default'])(
            _Object$entries2[_i2],
            2
          ),
          field = _Object$entries2$_i[0],
          _Object$entries2$_i$ = _Object$entries2$_i[1],
          validate = _Object$entries2$_i$.validate,
          _default = _Object$entries2$_i$['default']

        var fieldType = convertValidate(validate)
        d.field(
          field,
          fieldType,
          Array.isArray(_default)
            ? function () {
                return (0, _toConsumableArray2['default'])(_default)
              }
            : fieldType === builtInTypes['boolean'] && _default == null
            ? function () {
                return false
              }
            : _default !== undefined
            ? function () {
                return _default
              }
            : undefined
        )
      }
      for (
        var _i2 = 0,
          _Object$entries2 = Object.entries(
            type === 'File' ? (0, _lodash.omit)(fields, 'tokens') : fields
          );
        _i2 < _Object$entries2.length;
        _i2++
      ) {
        _loop()
      }
    }
  }

  return (0, _fork['default'])([babel])
})
var _default2 = babelAstTypes
exports['default'] = _default2