astx/cjs/convertReplacement/convertToJSXIdentifierNameExpressionPair.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'] = convertToJSXIdentifierNameExpressionPair

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

var _convertToIdentifierName = _interopRequireDefault(
  require('./convertToIdentifierName')
)

var _convertToExpression = _interopRequireDefault(
  require('./convertToExpression')
)

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 convertToJSXIdentifierNameExpressionPair(node) {
  switch (node.type) {
    case 'ObjectProperty':
    case 'ObjectTypeProperty':
    case 'Property': {
      var _key = (0, _convertToIdentifierName['default'])(node.key)

      var value = (0, _convertToExpression['default'])(node.value)
      if (_key && value) return [_key, value]
      break
    }

    case 'TSPropertySignature': {
      var _key2 = (0, _convertToIdentifierName['default'])(node.key)

      var _value = (0, _convertToExpression['default'])(
        node.typeAnnotation || node.key
      )

      if (_key2 && _value) return [_key2, _value]
      break
    }

    case 'JSXAttribute': {
      var _key3 = (0, _convertToIdentifierName['default'])(node.name)

      var _value2 = (0, _convertToExpression['default'])(
        node.value || node.name
      )

      if (_key3 && _value2) return [_key3, _value2]
      break
    }

    case 'ImportSpecifier': {
      var _key4 =
        node.imported.type === 'StringLiteral'
          ? node.imported.value
          : node.imported.name

      var _value3 = node.local || node.imported

      return [_key4, _value3]
    }

    case 'ImportDefaultSpecifier': {
      var _value4 = node.local || t.identifier('default')

      return ['default', _value4]
    }
  }

  var key = (0, _convertToIdentifierName['default'])(node)
  if (key) return [key, t.identifier(key)]
}