@herb-tools/formatter 0.4.0

package/dist/types/herb-formatter.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { Formatter } from "./formatter.js";
+export { defaultFormatOptions, resolveFormatOptions } from "./options.js";
+export type { FormatOptions } from "./options.js";

package/dist/types/options.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Formatting options for the Herb formatter.
+ *
+ * indentWidth: number of spaces per indentation level.
+ * maxLineLength: maximum line length before wrapping text or attributes.
+ */
+export interface FormatOptions {
+    /** number of spaces per indentation level; defaults to 2 */
+    indentWidth?: number;
+    /** maximum line length before wrapping; defaults to 80 */
+    maxLineLength?: number;
+}
+/**
+ * Default values for formatting options.
+ */
+export declare const defaultFormatOptions: Required<FormatOptions>;
+/**
+ * Merge provided options with defaults for any missing values.
+ * @param options partial formatting options
+ * @returns a complete set of formatting options
+ */
+export declare function resolveFormatOptions(options?: FormatOptions): Required<FormatOptions>;

package/dist/types/printer.d.ts

@@ -0,0 +1,55 @@
+import { Visitor } from "@herb-tools/core";
+import { Node, DocumentNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, HTMLElementNode, HTMLAttributeNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, ERBContentNode, ERBBlockNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode, Token } from "@herb-tools/core";
+import type { FormatOptions } from "./options.js";
+/**
+ * Printer traverses the Herb AST using the Visitor pattern
+ * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
+ */
+export declare class Printer extends Visitor {
+    private indentWidth;
+    private maxLineLength;
+    private source;
+    private lines;
+    private indentLevel;
+    constructor(source: string, options: Required<FormatOptions>);
+    print(object: Node | Token, indentLevel?: number): string;
+    private push;
+    private withIndent;
+    private indent;
+    /**
+     * Print an ERB tag (<% %> or <%= %>) with single spaces around inner content.
+     */
+    private printERBNode;
+    visitDocumentNode(node: DocumentNode): void;
+    visitHTMLElementNode(node: HTMLElementNode): void;
+    visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
+    visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void;
+    visitHTMLCloseTagNode(node: HTMLCloseTagNode): void;
+    visitHTMLTextNode(node: HTMLTextNode): void;
+    visitHTMLAttributeNode(node: HTMLAttributeNode): void;
+    visitHTMLAttributeNameNode(node: HTMLAttributeNameNode): void;
+    visitHTMLAttributeValueNode(node: HTMLAttributeValueNode): void;
+    visitHTMLCommentNode(node: HTMLCommentNode): void;
+    visitERBCommentNode(node: ERBContentNode): void;
+    visitHTMLDoctypeNode(node: HTMLDoctypeNode): void;
+    visitERBContentNode(node: ERBContentNode): void;
+    visitERBEndNode(node: ERBEndNode): void;
+    visitERBYieldNode(node: ERBYieldNode): void;
+    visitERBInNode(node: ERBInNode): void;
+    visitERBCaseMatchNode(node: ERBCaseMatchNode): void;
+    visitERBBlockNode(node: ERBBlockNode): void;
+    visitERBIfNode(node: ERBIfNode): void;
+    visitERBElseNode(node: ERBElseNode): void;
+    visitERBWhenNode(node: ERBWhenNode): void;
+    visitERBCaseNode(node: ERBCaseNode): void;
+    visitERBBeginNode(node: ERBBeginNode): void;
+    visitERBWhileNode(node: ERBWhileNode): void;
+    visitERBUntilNode(node: ERBUntilNode): void;
+    visitERBForNode(node: ERBForNode): void;
+    visitERBRescueNode(node: ERBRescueNode): void;
+    visitERBEnsureNode(node: ERBEnsureNode): void;
+    visitERBUnlessNode(node: ERBUnlessNode): void;
+    private visitERBGeneric;
+    private renderInlineOpen;
+    renderAttribute(attribute: HTMLAttributeNode): string;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@herb-tools/formatter",
+  "version": "0.4.0",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://herb-tools.dev",
+  "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/formatter%60:%20",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marcoroth/herb.git",
+    "directory": "javascript/packages/formatter"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.esm.js",
+  "require": "./dist/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "bin": {
+    "herb-formatter": "bin/herb-formatter"
+  },
+  "scripts": {
+    "build": "yarn clean && rollup -c rollup.config.mjs",
+    "dev": "rollup -c rollup.config.mjs -w",
+    "clean": "rimraf dist",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "prepublishOnly": "yarn clean && yarn build && yarn test"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.esm.js"
+    }
+  },
+  "dependencies": {
+    "@herb-tools/core": "0.4.0"
+  },
+  "files": [
+    "package.json",
+    "README.md",
+    "dist/",
+    "src/",
+    "bin/"
+  ]
+}

package/src/cli.ts

@@ -0,0 +1,70 @@
+import { readFileSync } from "fs"
+import { Herb } from "@herb-tools/node-wasm"
+import { Formatter } from "./formatter.js"
+import { name, version } from "../package.json"
+
+export class CLI {
+  private usage = `
+  Usage: herb-formatter [file] [options]
+
+  Arguments:
+    file             File to format (use '-' or omit for stdin)
+
+  Options:
+    -h, --help       show help
+    -v, --version    show version
+
+  Examples:
+    herb-formatter templates/index.html.erb
+    cat template.html.erb | herb-formatter
+    herb-formatter - < template.html.erb
+`
+
+  async run() {
+    const args = process.argv.slice(2)
+
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log(this.usage)
+      process.exit(0)
+    }
+
+    try {
+      await Herb.load()
+
+      if (args.includes("--version") || args.includes("-v")) {
+        console.log("Versions:")
+        console.log(`  ${name}@${version}, ${Herb.version}`.split(", ").join("\n  "))
+        process.exit(0)
+      }
+
+      let source: string
+
+      // Find the first non-flag argument (the file)
+      const file = args.find(arg => !arg.startsWith("-"))
+
+      // Read from file or stdin
+      if (file && file !== "-") {
+        source = readFileSync(file, "utf-8")
+      } else {
+        source = await this.readStdin()
+      }
+
+      const formatter = new Formatter(Herb)
+      const result = formatter.format(source)
+      process.stdout.write(result)
+    } catch (error) {
+      console.error(error)
+      process.exit(1)
+    }
+  }
+
+  private async readStdin(): Promise<string> {
+    const chunks: Buffer[] = []
+
+    for await (const chunk of process.stdin) {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk)
+    }
+
+    return Buffer.concat(chunks).toString("utf8")
+  }
+}

package/src/formatter.ts

@@ -0,0 +1,36 @@
+import { Printer } from "./printer.js"
+import { resolveFormatOptions } from "./options.js"
+
+import type { FormatOptions } from "./options.js"
+import type { HerbBackend, ParseResult } from "@herb-tools/core"
+
+/**
+ * Formatter uses a Herb Backend to parse the source and then
+ * formats the resulting AST into a well-indented, wrapped string.
+ */
+export class Formatter {
+  private herb: HerbBackend
+  private options: Required<FormatOptions>
+
+  constructor(herb: HerbBackend, options: FormatOptions = {}) {
+    this.herb = herb
+    this.options = resolveFormatOptions(options)
+  }
+
+  /**
+   * Format a source string, optionally overriding format options per call.
+   */
+  format(source: string, options: FormatOptions = {}): string {
+    const result = this.parse(source)
+    if (result.failed) return source
+
+    const resolvedOptions = resolveFormatOptions({ ...this.options, ...options })
+
+    return new Printer(source, resolvedOptions).print(result.value)
+  }
+
+  private parse(source: string): ParseResult {
+    this.herb.ensureBackend()
+    return this.herb.parse(source)
+  }
+}

package/src/herb-formatter.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { CLI } from "./cli.js"
+
+const cli = new CLI()
+cli.run()

package/src/index.ts

@@ -0,0 +1,5 @@
+export { Formatter } from "./formatter.js"
+export { defaultFormatOptions, resolveFormatOptions } from "./options.js"
+// export { CLI } from "./cli.js"
+
+export type { FormatOptions } from "./options.js"

package/src/options.ts

@@ -0,0 +1,34 @@
+/**
+ * Formatting options for the Herb formatter.
+ *
+ * indentWidth: number of spaces per indentation level.
+ * maxLineLength: maximum line length before wrapping text or attributes.
+ */
+export interface FormatOptions {
+  /** number of spaces per indentation level; defaults to 2 */
+  indentWidth?: number
+  /** maximum line length before wrapping; defaults to 80 */
+  maxLineLength?: number
+}
+
+/**
+ * Default values for formatting options.
+ */
+export const defaultFormatOptions: Required<FormatOptions> = {
+  indentWidth: 2,
+  maxLineLength: 80,
+}
+
+/**
+ * Merge provided options with defaults for any missing values.
+ * @param options partial formatting options
+ * @returns a complete set of formatting options
+ */
+export function resolveFormatOptions(
+  options: FormatOptions = {},
+): Required<FormatOptions> {
+  return {
+    indentWidth: options.indentWidth ?? defaultFormatOptions.indentWidth,
+    maxLineLength: options.maxLineLength ?? defaultFormatOptions.maxLineLength,
+  }
+}