astx/cjs/compileReplacement/TemplateLiteral.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'] = compileTemplateLiteralReplacement

var _slicedToArray2 = _interopRequireDefault(
  require('@babel/runtime/helpers/slicedToArray')
)

var _Placeholder = require('../compileMatcher/Placeholder')

var _Placeholder2 = require('./Placeholder')

var _cloneNode = _interopRequireDefault(require('../util/cloneNode'))

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

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 generateValue(cooked) {
  return {
    raw: cooked.replace(/\\|`|\${/g, '\\$&'),
    cooked: cooked,
  }
}

function compileTemplateLiteralReplacement(path) {
  var pattern = path.value

  if (pattern.quasis.length === 1) {
    var _pattern$quasis = (0, _slicedToArray2['default'])(pattern.quasis, 1),
      quasi = _pattern$quasis[0]

    if (quasi.value.cooked) {
      var placeholder = (0, _Placeholder.getPlaceholder)(quasi.value.cooked)

      if (placeholder) {
        return {
          generate: function generate(match) {
            var _match$stringCaptures

            var captured =
              (_match$stringCaptures = match.stringCaptures) === null ||
              _match$stringCaptures === void 0
                ? void 0
                : _match$stringCaptures[placeholder]
            return captured
              ? t.templateLiteral(
                  [t.templateElement(generateValue(captured), true)],
                  []
                )
              : (0, _cloneNode['default'])(pattern)
          },
        }
      }

      var unescaped = (0, _Placeholder2.unescapeIdentifier)(quasi.value.cooked)
      if (unescaped !== quasi.value.cooked)
        quasi.value = generateValue(unescaped)
    }
  }
}