astx/cjs/backend/template.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.expression = expression
exports.statement = statement
exports.statements = statements

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

var _compileReplacement = _interopRequireDefault(
  require('../compileReplacement')
)

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

var _convertStatementReplacement = _interopRequireDefault(
  require('../convertReplacement/convertStatementReplacement')
)

var _ensureArray = _interopRequireDefault(require('../util/ensureArray'))

var _Astx = _interopRequireDefault(require('../Astx'))

var _CodeFrameError = _interopRequireDefault(require('../util/CodeFrameError'))

var _Placeholder = require('../compileMatcher/Placeholder')
/**
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
function convertQuasis(nodes) {
  var captures = {}
  var arrayCaptures = {}
  var varNames = []

  for (var i = 0; i < nodes.length; i++) {
    var replacement = void 0

    if (typeof nodes[i] === 'string') {
      replacement = nodes[i]
    } else if (Array.isArray(nodes[i])) {
      replacement = nodes[i]
        .map(function (n) {
          return n instanceof _Astx['default'] ? n.nodes : n
        })
        .flat()
    } else if (nodes[i] instanceof _Astx['default']) {
      var astx = nodes[i]

      if (
        astx.size > 1 ||
        (astx.placeholder &&
          (0, _Placeholder.getArrayPlaceholder)(astx.placeholder))
      ) {
        replacement = astx.nodes
      } else {
        replacement = astx.nodes[0]
      }
    } else if (nodes[i]) {
      replacement = nodes[i]
    }

    if (typeof replacement === 'string') {
      varNames.push(replacement)
    } else if (Array.isArray(replacement)) {
      var name = '$$tpl___'.concat(i)
      arrayCaptures[name] = replacement
      varNames.push(name)
    } else {
      var _name = '$tpl___'.concat(i)

      if (replacement) captures[_name] = replacement
      varNames.push(_name)
    }
  }

  return {
    captures: captures,
    arrayCaptures: arrayCaptures,
    varNames: varNames,
  }
}

function statements(code) {
  var _this = this

  for (
    var _len = arguments.length,
      nodes = new Array(_len > 1 ? _len - 1 : 0),
      _key = 1;
    _key < _len;
    _key++
  ) {
    nodes[_key - 1] = arguments[_key]
  }

  var _convertQuasis = convertQuasis(nodes),
    captures = _convertQuasis.captures,
    arrayCaptures = _convertQuasis.arrayCaptures,
    varNames = _convertQuasis.varNames

  var src = (0, _toConsumableArray2['default'])(
    (0, _ensureArray['default'])(code)
  ).reduce(function (result, elem, i) {
    return result + varNames[i - 1] + elem
  })

  try {
    if (
      !nodes.length ||
      nodes.every(function (n) {
        return typeof n === 'string'
      })
    )
      return this.parseStatements(src)
    var result = (0, _compileReplacement['default'])(
      this.parseStatements(src).map(function (n) {
        return new _this.t.NodePath(n)
      }),
      {
        backend: this,
      }
    ).generate({
      captures: captures,
      arrayCaptures: arrayCaptures,
    })
    return (0, _ensureArray['default'])(result).map(
      _convertStatementReplacement['default']
    )
  } catch (error) {
    if (error instanceof Error) {
      _CodeFrameError['default'].rethrow(error, {
        filename: 'statements',
        source: src,
      })
    }

    throw error
  }
}

function statement(template) {
  var _this$template

  for (
    var _len2 = arguments.length,
      nodes = new Array(_len2 > 1 ? _len2 - 1 : 0),
      _key2 = 1;
    _key2 < _len2;
    _key2++
  ) {
    nodes[_key2 - 1] = arguments[_key2]
  }

  var result = (_this$template = this.template).statements.apply(
    _this$template,
    [template].concat(nodes)
  )

  if (result.length !== 1) {
    throw new Error('code is not a statement')
  }

  return result[0]
}

function expression(code) {
  for (
    var _len3 = arguments.length,
      nodes = new Array(_len3 > 1 ? _len3 - 1 : 0),
      _key3 = 1;
    _key3 < _len3;
    _key3++
  ) {
    nodes[_key3 - 1] = arguments[_key3]
  }

  var _convertQuasis2 = convertQuasis(nodes),
    captures = _convertQuasis2.captures,
    arrayCaptures = _convertQuasis2.arrayCaptures,
    varNames = _convertQuasis2.varNames

  var src = (0, _toConsumableArray2['default'])(
    (0, _ensureArray['default'])(code)
  ).reduce(function (result, elem, i) {
    return result + varNames[i - 1] + elem
  })

  try {
    if (
      !nodes.length ||
      nodes.every(function (n) {
        return typeof n === 'string'
      })
    )
      return this.parseExpression(src)
    var result = (0, _compileReplacement['default'])(
      new this.t.NodePath(this.parseExpression(src)),
      {
        backend: this,
      }
    ).generate({
      captures: captures,
      arrayCaptures: arrayCaptures,
    })

    var _expression

    if (Array.isArray(result)) {
      if (result.length !== 1) {
        throw new Error('code is not an expression: '.concat(src))
      }

      _expression = (0, _convertToExpression['default'])(result[0])
    } else {
      _expression = (0, _convertToExpression['default'])(result)
    }

    if (!_expression) {
      throw new Error('code is not an expression: '.concat(src))
    }

    return _expression
  } catch (error) {
    if (error instanceof Error) {
      _CodeFrameError['default'].rethrow(error, {
        filename: 'expression',
        source: src,
      })
    }

    throw error
  }
}