Function transformJavaScript

src/index.ts:613–682

(ast: import('@babel/types').Node, env: TransformerEnv)

// We cross several parsers that share roughly the same shape so things are
// good enough. The actual AST we should be using is probably estree + ts.
function transformJavaScript(ast: import('@babel/types').Node, env: TransformerEnv) {
  let { matcher } = env

  function sortInside(ast: import('@babel/types').Node) {
    visit(ast, (node, path) => {
      let collapseWhitespace = canCollapseWhitespaceIn(path, env)

      if (isStringLiteral(node)) {
        sortStringLiteral(node, { env, collapseWhitespace })
      } else if (node.type === 'TemplateLiteral') {
        sortTemplateLiteral(node, { env, collapseWhitespace })
      } else if (node.type === 'TaggedTemplateExpression') {
        if (isSortableTemplateExpression(node, matcher)) {
          sortTemplateLiteral(node.quasi, { env, collapseWhitespace })
        }
      }
    })
  }

  visit(ast, {
    JSXAttribute(node) {
      node = node as import('@babel/types').JSXAttribute

      if (!node.value) {
        return
      }

      // We don't want to support namespaced attributes (e.g. `somens:class`)
      // React doesn't support them and most tools don't either
      if (typeof node.name.name !== 'string') {
        return
      }

      if (!matcher.hasStaticAttr(node.name.name)) {
        return
      }

      if (isStringLiteral(node.value)) {
        sortStringLiteral(node.value, { env })
      } else if (node.value.type === 'JSXExpressionContainer') {
        sortInside(node.value)
      }
    },

    CallExpression(node) {
      node = node as import('@babel/types').CallExpression

      if (!isSortableCallExpression(node, matcher)) {
        return
      }

      node.arguments.forEach((arg) => sortInside(arg))
    },

    TaggedTemplateExpression(node, path) {
      node = node as import('@babel/types').TaggedTemplateExpression

      if (!isSortableTemplateExpression(node, matcher)) {