@herb-tools/rewriter 0.8.9 → 0.9.0

package/src/built-ins/tailwind-class-sorter.ts

@@ -1,4 +1,4 @@
-import { getStaticAttributeName, isLiteralNode } from "@herb-tools/core"
+import { getStaticAttributeName, isLiteralNode, isPureWhitespaceNode, splitLiteralsAtWhitespace, groupNodesByClass } from "@herb-tools/core"
 import { LiteralNode, Location, Visitor } from "@herb-tools/core"
 
 import { TailwindClassSorter } from "@herb-tools/tailwind-class-sorter"
@@ -45,7 +45,23 @@ class TailwindClassSorterVisitor extends Visitor {
     const attributeName = getStaticAttributeName(node.name)
     if (attributeName !== "class") return
 
-    this.visit(node.value)
+    const classAttributeSorter = new ClassAttributeSorter(this.sorter)
+
+    classAttributeSorter.visit(node.value)
+  }
+}
+
+/**
+ * Visitor that sorts classes within a single class attribute value.
+ * Only operates on the content of a class attribute, not the full document.
+ */
+class ClassAttributeSorter extends Visitor {
+  private sorter: TailwindClassSorter
+
+  constructor(sorter: TailwindClassSorter) {
+    super()
+
+    this.sorter = sorter
   }
 
   visitHTMLAttributeValueNode(node: HTMLAttributeValueNode): void {
@@ -127,104 +143,181 @@ class TailwindClassSorterVisitor extends Visitor {
     })
   }
 
-  private startsWithClassLiteral(nodes: Node[]): boolean {
-    return nodes.length > 0 && isLiteralNode(nodes[0]) && !!nodes[0].content.trim()
+  private isInterpolatedGroup(group: Node[]): boolean {
+    return group.some(node => !isLiteralNode(node))
   }
 
-  private isWhitespaceLiteral(node: Node): boolean {
-    return isLiteralNode(node) && !node.content.trim()
+  private isWhitespaceGroup(group: Node[]): boolean {
+    return group.every(node => isPureWhitespaceNode(node))
   }
 
-  private formatNodes(nodes: Node[], isNested: boolean): Node[] {
-    const { classLiterals, others } = this.partitionNodes(nodes)
-    const preserveLeadingSpace = isNested || this.startsWithClassLiteral(nodes)
-
-    return this.formatSortedClasses(classLiterals, others, preserveLeadingSpace, isNested)
+  private getStaticClassContent(group: Node[]): string {
+    return group
+      .filter(node => isLiteralNode(node))
+      .map(node => (node as LiteralNode).content)
+      .join("")
   }
 
-  private partitionNodes(nodes: Node[]): { classLiterals: LiteralNode[], others: Node[] } {
-    const classLiterals: LiteralNode[] = []
-    const others: Node[] = []
+  private categorizeGroups(groups: Node[][]): { staticClasses: string[], interpolationGroups: Node[][], standaloneERBNodes: Node[] } {
+    const staticClasses: string[] = []
+    const interpolationGroups: Node[][] = []
+    const standaloneERBNodes: Node[] = []
+
+    for (const group of groups) {
+      if (this.isWhitespaceGroup(group)) {
+        continue
+      }
+
+      if (this.isInterpolatedGroup(group)) {
+        const hasAttachedLiteral = group.some(node => isLiteralNode(node) && node.content.trim())
+
+        if (hasAttachedLiteral) {
+          for (const node of group) {
+            if (!isLiteralNode(node)) {
+              this.visit(node)
+            }
+          }
 
-    for (const node of nodes) {
-      if (isLiteralNode(node)) {
-        if (node.content.trim()) {
-          classLiterals.push(node)
+          interpolationGroups.push(group)
         } else {
-          others.push(node)
+          for (const node of group) {
+            if (!isLiteralNode(node)) {
+              this.visit(node)
+              standaloneERBNodes.push(node)
+            }
+          }
         }
       } else {
-        this.visit(node)
-        others.push(node)
+        const content = this.getStaticClassContent(group).trim()
+
+        if (content) {
+          staticClasses.push(content)
+        }
       }
     }
 
-    return { classLiterals, others }
+    return { staticClasses, interpolationGroups, standaloneERBNodes }
   }
 
-  private formatSortedClasses(literals: LiteralNode[], others: Node[], preserveLeadingSpace: boolean, isNested: boolean): Node[] {
-    if (literals.length === 0 && others.length === 0) return []
-    if (literals.length === 0) return others
+  private formatNodes(nodes: Node[], isNested: boolean): Node[] {
+    if (nodes.length === 0) return nodes
+    if (nodes.every(child => isPureWhitespaceNode(child))) return nodes
+
+    const splitNodes = splitLiteralsAtWhitespace(nodes)
+    const groups = groupNodesByClass(splitNodes)
+    const groupPrecedingWhitespace = new Map<Node[], Node[]>()
+    const nodePrecedingWhitespace = new Map<Node, Node[]>()
+
+    for (let i = 1; i < groups.length; i++) {
+      if (!this.isWhitespaceGroup(groups[i]) && this.isWhitespaceGroup(groups[i - 1])) {
+        groupPrecedingWhitespace.set(groups[i], groups[i - 1])
+
+        for (const node of groups[i]) {
+          if (!isLiteralNode(node)) {
+            nodePrecedingWhitespace.set(node, groups[i - 1])
+          }
+        }
+      }
+    }
+
+    let leadingWhitespace: Node[] | null = null
+    let trailingWhitespace: Node[] | null = null
 
-    const fullContent = literals.map(n => n.content).join("")
-    const trimmedClasses = fullContent.trim()
+    if (isNested && groups.length > 0) {
+      if (this.isWhitespaceGroup(groups[0])) {
+        leadingWhitespace = groups[0]
+      }
+      if (groups.length > 1 && this.isWhitespaceGroup(groups[groups.length - 1])) {
+        trailingWhitespace = groups[groups.length - 1]
+      }
+    }
 
-    if (!trimmedClasses) return others.length > 0 ? others : []
+    const { staticClasses, interpolationGroups, standaloneERBNodes } = this.categorizeGroups(groups)
 
-    try {
-      const sortedClasses = this.sorter.sortClasses(trimmedClasses)
+    const allStaticContent = staticClasses.join(" ")
+    let sortedContent = allStaticContent
 
-      if (others.length === 0) {
-        return this.formatSortedLiteral(literals[0], fullContent, sortedClasses, trimmedClasses)
+    if (allStaticContent) {
+      try {
+        sortedContent = this.sorter.sortClasses(allStaticContent)
+      } catch {
+        // Keep original on error
       }
+    }
 
-      return this.formatSortedLiteralWithERB(literals[0], fullContent, sortedClasses, others, preserveLeadingSpace, isNested)
-    } catch (error) {
-      return [...literals, ...others]
+    const parts: Node[] = []
+
+    if (sortedContent) {
+      parts.push(new LiteralNode({
+        type: "AST_LITERAL_NODE",
+        content: sortedContent,
+        errors: [],
+        location: Location.zero
+      }))
     }
-  }
 
-  private formatSortedLiteral(literal: LiteralNode, fullContent: string, sortedClasses: string, trimmedClasses: string): Node[] {
-    const leadingSpace = fullContent.match(/^\s*/)?.[0] || ""
-    const trailingSpace = fullContent.match(/\s*$/)?.[0] || ""
-    const alreadySorted = sortedClasses === trimmedClasses
+    for (const group of interpolationGroups) {
+      if (parts.length > 0) {
+        const whitespace = groupPrecedingWhitespace.get(group)
+        parts.push(...(whitespace ?? [this.spaceLiteral]))
+      }
+
+      parts.push(...this.trimGroupWhitespace(group))
+    }
 
-    const sortedContent = alreadySorted ? fullContent : (leadingSpace + sortedClasses + trailingSpace)
+    for (const node of standaloneERBNodes) {
+      if (parts.length > 0) {
+        const whitespace = nodePrecedingWhitespace.get(node)
+        parts.push(...(whitespace ?? [this.spaceLiteral]))
+      }
+      parts.push(node)
+    }
 
-    asMutable(literal).content = sortedContent
+    if (isNested && parts.length > 0) {
+      const leading = leadingWhitespace ?? [this.spaceLiteral]
+      const trailing = trailingWhitespace ?? [this.spaceLiteral]
+      return [...leading, ...parts, ...trailing]
+    }
 
-    return [literal]
+    return parts
   }
 
-  private formatSortedLiteralWithERB(literal: LiteralNode, fullContent: string, sortedClasses: string, others: Node[], preserveLeadingSpace: boolean, isNested: boolean): Node[] {
-    const leadingSpace = fullContent.match(/^\s*/)?.[0] || ""
-    const trailingSpace = fullContent.match(/\s*$/)?.[0] || ""
+  private trimGroupWhitespace(group: Node[]): Node[] {
+    if (group.length === 0) return group
 
-    const leading = preserveLeadingSpace ? leadingSpace : ""
-    const firstIsWhitespace = this.isWhitespaceLiteral(others[0])
-    const spaceBetween = firstIsWhitespace ? "" : " "
+    const result = [...group]
 
-    asMutable(literal).content = leading + sortedClasses + spaceBetween
+    if (isLiteralNode(result[0])) {
+      const first = result[0] as LiteralNode
+      const trimmed = first.content.trimStart()
 
-    const othersWithWhitespace = this.addSpacingBetweenERBNodes(others, isNested, trailingSpace)
+      if (trimmed !== first.content) {
+        result[0] = new LiteralNode({
+          type: "AST_LITERAL_NODE",
+          content: trimmed,
+          errors: [],
+          location: first.location
+        })
+      }
+    }
 
-    return [literal, ...othersWithWhitespace]
-  }
+    const lastIndex = result.length - 1
 
-  private addSpacingBetweenERBNodes(nodes: Node[], isNested: boolean, trailingSpace: string): Node[] {
-    return nodes.flatMap((node, index) => {
-      const isLast = index >= nodes.length - 1
+    if (isLiteralNode(result[lastIndex])) {
+      const last = result[lastIndex] as LiteralNode
+      const trimmed = last.content.trimEnd()
 
-      if (isLast) {
-        return isNested && trailingSpace ? [node, this.spaceLiteral] : [node]
+      if (trimmed !== last.content) {
+        result[lastIndex] = new LiteralNode({
+          type: "AST_LITERAL_NODE",
+          content: trimmed,
+          errors: [],
+          location: last.location
+        })
       }
+    }
 
-      const currentIsWhitespace = this.isWhitespaceLiteral(node)
-      const nextIsWhitespace = this.isWhitespaceLiteral(nodes[index + 1])
-      const needsSpace = !currentIsWhitespace && !nextIsWhitespace
-
-      return needsSpace ? [node, this.spaceLiteral] : [node]
-    })
+    return result
   }
 }
 

package/src/index.ts

@@ -1,4 +1,6 @@
 export { ASTRewriter } from "./ast-rewriter.js"
+export { ActionViewTagHelperToHTMLRewriter } from "./built-ins/action-view-tag-helper-to-html.js"
+export { HTMLToActionViewTagHelperRewriter } from "./built-ins/html-to-action-view-tag-helper.js"
 export { StringRewriter } from "./string-rewriter.js"
 
 export { asMutable } from "./mutable.js"

package/src/rewriter-factories.ts

@@ -1,4 +1,6 @@
 import { TailwindClassSorterRewriter } from "./built-ins/tailwind-class-sorter.js"
+import { ActionViewTagHelperToHTMLRewriter } from "./built-ins/action-view-tag-helper-to-html.js"
+import { HTMLToActionViewTagHelperRewriter } from "./built-ins/html-to-action-view-tag-helper.js"
 
 export interface TailwindClassSorterOptions {
   /**
@@ -35,3 +37,11 @@ export async function tailwindClassSorter(options: TailwindClassSorterOptions =
 
   return rewriter
 }
+
+export function actionViewTagHelperToHTML(): ActionViewTagHelperToHTMLRewriter {
+  return new ActionViewTagHelperToHTMLRewriter()
+}
+
+export function htmlToActionViewTagHelper(): HTMLToActionViewTagHelperRewriter {
+  return new HTMLToActionViewTagHelperRewriter()
+}