astx/cjs/compileReplacement/Placeholder.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.compileArrayPlaceholderReplacement = compileArrayPlaceholderReplacement
exports['default'] = compilePlaceholderReplacement
Object.defineProperty(exports, 'unescapeIdentifier', {
  enumerable: true,
  get: function get() {
    return _Placeholder.unescapeIdentifier
  },
})

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

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

var _convertReplacement = _interopRequireWildcard(
  require('../convertReplacement')
)

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

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 compileArrayPlaceholderReplacement(
  pattern,
  identifier, // eslint-disable-next-line @typescript-eslint/no-unused-vars
  compileReplacementOptions
) {
  var arrayPlaceholder =
    (0, _Placeholder.getArrayPlaceholder)(identifier) ||
    (0, _Placeholder.getRestPlaceholder)(identifier)

  if (
    arrayPlaceholder &&
    (0, _Placeholder.isCapturePlaceholder)(arrayPlaceholder)
  ) {
    var convertReplacement = (0, _convertReplacement['default'])(pattern)
    return {
      generate: function generate(match) {
        var _match$arrayCaptures

        var captures =
          (_match$arrayCaptures = match.arrayCaptures) === null ||
          _match$arrayCaptures === void 0
            ? void 0
            : _match$arrayCaptures[arrayPlaceholder]

        if (captures) {
          return (0, _toConsumableArray2['default'])(
            (0, _convertReplacement.bulkConvert)(
              captures.map(function (c) {
                return (0, _cloneNode['default'])(c)
              }),
              convertReplacement
            )
          )
        }

        return (0, _toConsumableArray2['default'])(
          (0, _convertReplacement.bulkConvert)(
            (0, _cloneNode['default'])(pattern.value),
            convertReplacement
          )
        )
      },
    }
  }
}

function compilePlaceholderReplacement(
  pattern,
  identifier,
  compileReplacementOptions
) {
  var placeholder = (0, _Placeholder.getPlaceholder)(identifier)

  if (placeholder && (0, _Placeholder.isCapturePlaceholder)(placeholder)) {
    var convertReplacement = (0, _convertReplacement['default'])(pattern)
    return {
      generate: function generate(match) {
        var _match$captures

        var capture =
          (_match$captures = match.captures) === null ||
          _match$captures === void 0
            ? void 0
            : _match$captures[placeholder]

        if (capture) {
          var _astx

          var clone = (0, _cloneNode['default'])(capture)
          if (
            (_astx = capture.astx) !== null &&
            _astx !== void 0 &&
            _astx.excludeTypeAnnotationFromCapture
          )
            delete clone.typeAnnotation
          return convertReplacement(clone)
        }

        return convertReplacement((0, _cloneNode['default'])(pattern.value))
      },
    }
  }

  return compileArrayPlaceholderReplacement(
    pattern,
    identifier,
    compileReplacementOptions
  )
}