@herb-tools/formatter 0.4.1 → 0.4.3

package/dist/types/printer.d.ts

@@ -12,11 +12,46 @@ export declare class Printer extends Visitor {
     private lines;
     private indentLevel;
     private inlineMode;
+    private isInComplexNesting;
+    private static readonly INLINE_ELEMENTS;
     constructor(source: string, options: Required<FormatOptions>);
     print(object: Node | Token, indentLevel?: number): string;
     private push;
     private withIndent;
     private indent;
+    /**
+     * Format ERB content with proper spacing around the inner content.
+     * Returns empty string if content is empty, otherwise wraps content with single spaces.
+     */
+    private formatERBContent;
+    /**
+     * Check if a node is an ERB control flow node (if, unless, block, case, while, for)
+     */
+    private isERBControlFlow;
+    /**
+     * Count total attributes including those inside ERB conditionals
+     */
+    private getTotalAttributeCount;
+    /**
+     * Extract HTML attributes from a list of nodes
+     */
+    private extractAttributes;
+    /**
+     * Extract inline nodes (non-attribute, non-whitespace) from a list of nodes
+     */
+    private extractInlineNodes;
+    /**
+     * Render attributes as a space-separated string
+     */
+    private renderAttributesString;
+    /**
+     * Determine if a tag should be rendered inline based on attribute count and other factors
+     */
+    private shouldRenderInline;
+    /**
+     * Render multiline attributes for a tag
+     */
+    private renderMultilineAttributes;
     /**
      * Print an ERB tag (<% %> or <%= %>) with single spaces around inner content.
      */
@@ -51,6 +86,42 @@ export declare class Printer extends Visitor {
     visitERBEnsureNode(node: ERBEnsureNode): void;
     visitERBUnlessNode(node: ERBUnlessNode): void;
     private visitERBGeneric;
+    private isNonWhitespaceNode;
+    /**
+     * Check if an element should be treated as inline based on its tag name
+     */
+    private isInlineElement;
+    /**
+     * Check if we're in a text flow context (parent contains mixed text and inline elements)
+     */
+    private visitTextFlowChildren;
+    private visitTextFlowChildrenMultiline;
+    private isInTextFlowContext;
     private renderInlineOpen;
     renderAttribute(attribute: HTMLAttributeNode): string;
+    /**
+     * Try to render a complete element inline including opening tag, children, and closing tag
+     */
+    private tryRenderInlineFull;
+    /**
+     * Try to render just the children inline (without tags)
+     */
+    private tryRenderChildrenInline;
+    /**
+     * Try to render children inline if they are simple enough.
+     * Returns the inline string if possible, null otherwise.
+     */
+    private tryRenderInline;
+    /**
+     * Estimate the total content length of children nodes for decision making.
+     */
+    private estimateContentLength;
+    /**
+     * Calculate the maximum nesting depth in a subtree of nodes.
+     */
+    private getMaxNestingDepth;
+    /**
+     * Render an HTML element's content inline (without the wrapping tags).
+     */
+    private renderElementInline;
 }

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@herb-tools/formatter",
-  "version": "0.4.1",
+  "version": "0.4.3",
+  "description": "Auto-formatter for HTML+ERB templates with intelligent indentation, line wrapping, and ERB-aware pretty-printing.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
   "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/formatter%60:%20",
@@ -34,7 +35,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.4.1",
+    "@herb-tools/core": "0.4.3",
     "glob": "^11.0.3"
   },
   "files": [

package/src/cli.ts

@@ -105,13 +105,16 @@ export class CLI {
               try {
                 const source = readFileSync(filePath, "utf-8")
                 const result = formatter.format(source)
-                if (result !== source) {
+                const output = result.endsWith('\n') ? result : result + '\n'
+
+                if (output !== source) {
                   if (isCheckMode) {
                     unformattedFiles.push(filePath)
                   } else {
-                    writeFileSync(filePath, result, "utf-8")
+                    writeFileSync(filePath, output, "utf-8")
                     console.log(`Formatted: ${filePath}`)
                   }
+
                   formattedCount++
                 }
               } catch (error) {
@@ -134,13 +137,14 @@ export class CLI {
           } else {
             const source = readFileSync(file, "utf-8")
             const result = formatter.format(source)
+            const output = result.endsWith('\n') ? result : result + '\n'
 
-            if (result !== source) {
+            if (output !== source) {
               if (isCheckMode) {
                 console.log(`File is not formatted: ${file}`)
                 process.exit(1)
               } else {
-                writeFileSync(file, result, "utf-8")
+                writeFileSync(file, output, "utf-8")
                 console.log(`Formatted: ${file}`)
               }
             } else if (isCheckMode) {
@@ -169,12 +173,13 @@ export class CLI {
           try {
             const source = readFileSync(filePath, "utf-8")
             const result = formatter.format(source)
+            const output = result.endsWith('\n') ? result : result + '\n'
 
-            if (result !== source) {
+            if (output !== source) {
               if (isCheckMode) {
                 unformattedFiles.push(filePath)
               } else {
-                writeFileSync(filePath, result, "utf-8")
+                writeFileSync(filePath, output, "utf-8")
                 console.log(`Formatted: ${filePath}`)
               }
               formattedCount++