@htnabe/prettier-plugin-hugo-post 0.0.1-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chad Metcalf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,158 @@
+# @htnabe/prettier-plugin-hugo-post
+
+[![npm version](https://img.shields.io/npm/v/@htnabe/prettier-plugin-hugo-post)](https://www.npmjs.com/package/@htnabe/prettier-plugin-hugo-post)
+[![GitHub](https://img.shields.io/github/stars/htnabe/prettier-plugin-hugo-post?style=social)](https://github.com/htnabe/prettier-plugin-hugo-post)
+[![codecov](https://codecov.io/gh/htnabe/prettier-plugin-hugo-post/graph/badge.svg?token=BR5Y5MAXON)](https://codecov.io/gh/htnabe/prettier-plugin-hugo-post)
+[![license](https://img.shields.io/npm/l/@htnabe/prettier-plugin-hugo-post)](https://github.com/htnabe/prettier-plugin-hugo-post/blob/main/LICENSE)
+
+A Prettier plugin for formatting Hugo content files that mix front matter, Markdown, and Go template syntax.
+
+## Why this plugin?
+
+Hugo content files are not plain Markdown. They often contain:
+
+- YAML, TOML, or JSON front matter
+- Markdown prose and lists
+- Hugo shortcodes
+- Go template expressions and pipelines
+
+This plugin keeps those pieces formatted consistently while leaving the rest of your Prettier setup alone.
+
+## Features
+
+- Front matter formatting for YAML, TOML, and JSON
+- Markdown formatting via Prettier
+- Hugo shortcode spacing and normalization
+- Template expression formatting for `.Title`, pipelines, conditions, and range blocks
+- Works with standard Prettier overrides
+
+## Installation
+
+Using Bun:
+
+```bash
+bun add -d prettier @htnabe/prettier-plugin-hugo-post
+```
+
+Using npm:
+
+```bash
+npm install --save-dev prettier @htnabe/prettier-plugin-hugo-post
+```
+
+If you also format Hugo layout templates, install the companion plugin:
+
+```bash
+bun add -d @htnabe/prettier-plugin-go-template
+```
+
+## Basic configuration
+
+Add the plugin to Prettier and set the parser for Hugo content files:
+
+```json
+{
+  "plugins": ["@htnabe/prettier-plugin-hugo-post"],
+  "overrides": [
+    {
+      "files": ["content/**/*.md", "**/*.md", "**/*.hugo"],
+      "options": {
+        "parser": "hugo-post"
+      }
+    }
+  ]
+}
+```
+
+For a mixed Hugo project, combine it with `@htnabe/prettier-plugin-go-template`:
+
+```json
+{
+  "plugins": ["@htnabe/prettier-plugin-hugo-post", "@htnabe/prettier-plugin-go-template"],
+  "overrides": [
+    {
+      "files": ["content/**/*.md", "**/*.md"],
+      "options": {
+        "parser": "hugo-post"
+      }
+    },
+    {
+      "files": ["layouts/**/*.html", "**/*.html"],
+      "options": {
+        "parser": "go-template"
+      }
+    }
+  ]
+}
+```
+
+## Usage
+
+Format a single file:
+
+```bash
+bunx prettier --write content/posts/my-post.md
+```
+
+Check formatting without writing:
+
+```bash
+bunx prettier --check "content/**/*.md"
+```
+
+## Example
+
+This input:
+
+```markdown
+---
+title:    "My Post"
+tags: [  "hugo",  "blog" ]
+---
+
+{{<figure src="/img.jpg"alt="Test">}}
+{{ .Title|upper }}
+```
+
+is normalized to:
+
+```markdown
+---
+title: "My Post"
+tags: ["hugo", "blog"]
+---
+
+{{< figure src="/img.jpg" alt="Test" >}}
+{{ .Title | upper }}
+```
+
+## Project scripts
+
+The repository uses these package scripts:
+
+```bash
+bun test
+bun run lint
+bun run lint:fix
+bun run format
+bun run format:check
+bun run example
+```
+
+## Contributing
+
+Contributions are welcome. Please read the [contributing guide](docs/development/CONTRIBUTING.md) before opening a PR.
+
+## License
+
+MIT
+
+## Acknowledgments
+
+- [Prettier](https://prettier.io/) for the excellent formatting engine
+- [@htnabe/prettier-plugin-go-template](https://github.com/htnabe/prettier-plugin-go-template) for inspiration on Go template formatting
+- [Hugo](https://gohugo.io/) for the amazing static site generator
+
+---
+
+Made with ❤️ for the Hugo community.

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+//#region src/types/hugo-post-node.d.ts
+interface HugoPostNode {
+  source?: string;
+}
+//#endregion
+//#region src/features/printers/printers.d.ts
+declare const printers: {
+  'hugo-post-ast': {
+    print: typeof printHugoPost;
+  };
+};
+/**
+ * Print Hugo post content
+ */
+declare function printHugoPost(path: any, options: any): Promise<string>;
+//#endregion
+//#region src/index.d.ts
+declare const parsers: {
+  'hugo-post': {
+    parse: typeof parseHugoPost;
+    astFormat: string;
+    locStart: (_node: HugoPostNode) => number;
+    locEnd: (node: HugoPostNode) => number;
+  };
+};
+/**
+ * Parse Hugo post content
+ */
+declare function parseHugoPost(text: string): {
+  type: string;
+  source: string;
+  frontMatter: {
+    content: string;
+    delimiter: string | null;
+  } | null;
+  content: string;
+};
+declare const _default: {
+  languages: import("prettier").SupportLanguage[];
+  parsers: {
+    'hugo-post': {
+      parse: typeof parseHugoPost;
+      astFormat: string;
+      locStart: (_node: HugoPostNode) => number;
+      locEnd: (node: HugoPostNode) => number;
+    };
+  };
+  printers: {
+    'hugo-post-ast': {
+      print: (path: any, options: any) => Promise<string>;
+    };
+  };
+  options: {
+    hugoTemplateBracketSpacing: {
+      type: string;
+      category: string;
+      default: boolean;
+      description: string;
+    };
+  };
+};
+//#endregion
+export { _default as default, parsers, printers };

package/dist/index.mjs

@@ -0,0 +1,374 @@
+//#region src/config/options.ts
+const options = { hugoTemplateBracketSpacing: {
+	type: "boolean",
+	category: "Hugo",
+	default: true,
+	description: "Print spaces between go template brackets"
+} };
+//#endregion
+//#region src/config/languages.ts
+const languages = [{
+	name: "Hugo Post",
+	parsers: ["hugo-post"],
+	extensions: [".md", ".hugo"],
+	filenames: []
+}];
+//#endregion
+//#region src/features/printers/printers.ts
+const printers = { "hugo-post-ast": { print: printHugoPost } };
+/**
+* Print Hugo post content
+*/
+async function printHugoPost(path, options) {
+	const node = path.getValue();
+	const parts = [];
+	if (node.frontMatter) {
+		if (node.frontMatter.delimiter === "yaml") {
+			const formattedYaml = await formatYaml(node.frontMatter.content, options);
+			parts.push(`---\n${formattedYaml}\n---`);
+		} else if (node.frontMatter.delimiter === "toml") {
+			const formattedToml = await formatToml(node.frontMatter.content, options);
+			parts.push(`+++\n${formattedToml}\n+++`);
+		} else if (node.frontMatter.delimiter === "json") {
+			const formattedJson = await formatJson(node.frontMatter.content, options);
+			parts.push(formattedJson);
+		}
+	}
+	if (node.content && node.content.trim()) {
+		const formattedContent = await formatHugoContent(node.content, options);
+		parts.push(formattedContent);
+	}
+	return parts.join("\n\n");
+}
+/**
+* Format TOML front matter using prettier-plugin-toml
+*/
+async function formatToml(tomlContent, options) {
+	try {
+		const { format } = await import("prettier");
+		return (await format(tomlContent, {
+			...options,
+			parser: "toml",
+			plugins: ["prettier-plugin-toml"]
+		})).trim();
+	} catch (error) {
+		if (error instanceof Error) console.warn("TOML formatting failed:", error.message);
+		else console.warn("TOML formatting failed with unknown error:", error);
+		return tomlContent.trim();
+	}
+}
+/**
+* Format JSON front matter using Prettier's built-in JSON parser
+*/
+async function formatJson(jsonContent, options) {
+	try {
+		const { format } = await import("prettier");
+		return (await format(jsonContent, {
+			...options,
+			parser: "json"
+		})).trim();
+	} catch (error) {
+		if (error instanceof Error) console.warn("JSON formatting failed:", error.message);
+		else console.warn("JSON formatting failed with unknown error:", error);
+		return jsonContent.trim();
+	}
+}
+/**
+* Format Hugo content (markdown + templates)
+*/
+async function formatHugoContent(content, options) {
+	content = formatHugoTemplates(content);
+	try {
+		const { format } = await import("prettier");
+		return (await format(content, {
+			...options,
+			parser: "markdown"
+		})).trim();
+	} catch {
+		return content.trim();
+	}
+}
+function formatHugoTemplates(content) {
+	try {
+		content = content.replace(/(\{\{[<%]\s*)(.*?)(\s*[>%]\}\})/g, (match, open, inner, _close) => {
+			try {
+				inner = inner.replace(/\/$/, "");
+				const formatted = formatShortcodeFromTokens(tokenizeShortcode(inner));
+				const isPercent = open.includes("%");
+				const openDelim = isPercent ? "{{% " : "{{< ";
+				const closeDelim = isPercent ? " %}}" : " >}}";
+				return openDelim + formatted + closeDelim;
+			} catch (error) {
+				if (error instanceof Error) console.warn(`Failed to format shortcode: ${match}. Error: ${error.message}`);
+				else console.warn(`Failed to format shortcode: ${match}. Unknown error:`, error);
+				return match;
+			}
+		});
+		content = content.replace(/\{\{(?!<|%|\/\*)\s*([^}]*?)\s*\}\}/g, (match, inner) => {
+			try {
+				return formatTemplateVariable(match, inner);
+			} catch (error) {
+				if (error instanceof Error) console.warn(`Failed to format variable: ${match}. Error: ${error.message}`);
+				else console.warn(`Failed to format variable: ${match}. Unknown error:`, error);
+				return match;
+			}
+		});
+		content = content.replace(/\{\{\/\*\s*([\s\S]*?)\s*\*\/\}\}/g, (match, inner) => {
+			try {
+				return `{{/* ${inner.trim()} */}}`;
+			} catch (error) {
+				if (error instanceof Error) console.warn(`Failed to format comment: ${match}. Error: ${error.message}`);
+				else console.warn(`Failed to format comment: ${match}. Unknown error:`, error);
+				return match;
+			}
+		});
+		content = ensureProperBlockSpacing(content);
+		return content;
+	} catch (error) {
+		if (error instanceof Error) console.error(`Critical error in formatHugoTemplates: ${error.message}`);
+		else console.error(`Critical error in formatHugoTemplates with unknown error:`, error);
+		return content;
+	}
+}
+/**
+* Format Hugo templates manually using regex
+*/
+/**
+* Tokenization-based Hugo shortcode formatter
+* Treats shortcode content as a mini-language to parse properly
+*/
+function tokenizeShortcode(content) {
+	const tokens = [];
+	let i = 0;
+	const maxIterations = Math.max(1e3, content.length * 2);
+	let iterations = 0;
+	while (i < content.length) {
+		iterations++;
+		if (iterations > maxIterations) {
+			console.warn(`Tokenizer stopped at position ${i} to prevent infinite loop. Content: ${content.substring(i, i + 20)}...`);
+			break;
+		}
+		const char = content[i];
+		if (/\s/.test(char)) {
+			i++;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			const quote = char;
+			let value = quote;
+			i++;
+			while (i < content.length && iterations < maxIterations) {
+				iterations++;
+				const current = content[i];
+				if (current === "\\" && i + 1 < content.length) {
+					value += current + content[i + 1];
+					i += 2;
+				} else if (current === quote) {
+					value += current;
+					i++;
+					break;
+				} else {
+					value += current;
+					i++;
+				}
+			}
+			const trimmed = value.slice(1, -1).replace(/^\s+|\s+$/g, "");
+			tokens.push({
+				type: "quoted",
+				value: quote + trimmed + quote
+			});
+			continue;
+		}
+		let token = "";
+		while (i < content.length && !/[\s"']/.test(content[i]) && iterations < maxIterations) {
+			iterations++;
+			token += content[i];
+			i++;
+		}
+		if (token) tokens.push({
+			type: "unquoted",
+			value: token
+		});
+	}
+	return tokens;
+}
+function formatShortcodeFromTokens(tokens) {
+	if (tokens.length === 0) return "";
+	const result = [];
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		const nextToken = tokens[i + 1];
+		result.push(token.value);
+		if (nextToken) {
+			if (token.value.endsWith("=")) continue;
+			if (nextToken.value.startsWith("=")) continue;
+			if (token.type === "unquoted" && nextToken.type === "quoted") {
+				result.push(" ");
+				continue;
+			}
+			result.push(" ");
+		}
+	}
+	return result.join("");
+}
+/**
+* Enhanced template variable formatter inspired by @htnabe/prettier-plugin-go-template
+* Handles Go template syntax with better spacing and structure
+*/
+function formatTemplateVariable(match, inner) {
+	const startControl = match.match(/^\{\{-/) ? "{{- " : "{{ ";
+	const endControl = match.match(/-\}\}$/) ? " -}}" : " }}";
+	inner = inner.replace(/^-\s*/, "").replace(/\s*-$/, "");
+	return `${startControl}${formatTemplateExpression(inner.trim())}${endControl}`;
+}
+/**
+* Ensure block-level control structures have proper spacing to prevent
+* Prettier's markdown formatter from treating them as part of other constructs
+*/
+function ensureProperBlockSpacing(content) {
+	const lines = content.split("\n");
+	const result = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const prevLine = i > 0 ? lines[i - 1] : "";
+		const isEndControl = line.trim().match(/^\{\{\s*end\s*\}\}$/);
+		const prevIsListItem = prevLine.trim().match(/^[-*+]\s/);
+		if (isEndControl && prevIsListItem) {
+			result.push("");
+			result.push(line);
+		} else result.push(line);
+	}
+	return result.join("\n");
+}
+/**
+* Format a template expression with proper spacing and structure
+*/
+function formatTemplateExpression(expr) {
+	if (!expr) return "";
+	if (expr.match(/^\s*(if|range|with|block|define|template)\b/)) return formatControlStructure(expr);
+	if (expr.match(/^\s*end\s*$/)) return "end";
+	if (expr.match(/^\s*else(\s+if\b)?/)) return formatControlStructure(expr);
+	return formatExpression(expr);
+}
+/**
+* Format control structures like if, range, with
+*/
+function formatControlStructure(expr) {
+	return expr.trim().replace(/\s+/g, " ");
+}
+/**
+* Format regular expressions with proper pipe spacing and function calls
+*/
+function formatExpression(expr) {
+	if (expr.includes("|")) return formatPipeExpression(expr);
+	if (expr.includes(" ")) return formatFunctionCall(expr);
+	return expr.trim();
+}
+/**
+* Format pipe expressions with proper spacing
+*/
+function formatPipeExpression(expr) {
+	return expr.split("|").map((part) => formatFunctionCall(part.trim())).filter((part) => part).join(" | ");
+}
+/**
+* Format function calls with proper argument spacing
+*/
+function formatFunctionCall(expr) {
+	const parts = [];
+	let current = "";
+	let inQuotes = false;
+	let quoteChar = "";
+	for (let i = 0; i < expr.length; i++) {
+		const char = expr[i];
+		if ((char === "\"" || char === "'") && !inQuotes) {
+			inQuotes = true;
+			quoteChar = char;
+			current += char;
+		} else if (char === quoteChar && inQuotes) {
+			inQuotes = false;
+			current += char;
+			parts.push(current.trim());
+			current = "";
+		} else if (char === " " && !inQuotes) {
+			if (current.trim()) {
+				parts.push(current.trim());
+				current = "";
+			}
+		} else current += char;
+	}
+	if (current.trim()) parts.push(current.trim());
+	return parts.join(" ");
+}
+/**
+* Format YAML front matter using Prettier
+*/
+async function formatYaml(yamlContent, options) {
+	try {
+		const { format } = await import("prettier");
+		return (await format(yamlContent, {
+			...options,
+			parser: "yaml"
+		})).trim();
+	} catch {
+		return yamlContent.trim();
+	}
+}
+//#endregion
+//#region src/index.ts
+const parsers = { "hugo-post": {
+	parse: parseHugoPost,
+	astFormat: "hugo-post-ast",
+	locStart: (_node) => 0,
+	locEnd: (node) => node.source?.length || 0
+} };
+/**
+* Parse Hugo post content
+*/
+function parseHugoPost(text) {
+	const parts = splitFrontMatter(text);
+	return {
+		type: "hugo-post",
+		source: text,
+		frontMatter: parts.frontMatter !== null ? {
+			content: parts.frontMatter,
+			delimiter: parts.delimiter
+		} : null,
+		content: parts.content || ""
+	};
+}
+/**
+* Split text into front matter and content
+*/
+function splitFrontMatter(text) {
+	const yamlMatch = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+	if (yamlMatch) return {
+		frontMatter: yamlMatch[1],
+		delimiter: "yaml",
+		content: yamlMatch[2]
+	};
+	const tomlMatch = text.match(/^\+\+\+\r?\n([\s\S]*?)\r?\n\+\+\+\r?\n([\s\S]*)$/);
+	if (tomlMatch) return {
+		frontMatter: tomlMatch[1],
+		delimiter: "toml",
+		content: tomlMatch[2]
+	};
+	const jsonMatch = text.match(/^{\r?\n([\s\S]*?)\r?\n}\r?\n([\s\S]*)$/);
+	if (jsonMatch) return {
+		frontMatter: `{\n${jsonMatch[1]}\n}`,
+		delimiter: "json",
+		content: jsonMatch[2]
+	};
+	return {
+		frontMatter: null,
+		delimiter: null,
+		content: text
+	};
+}
+var src_default = {
+	languages,
+	parsers,
+	printers,
+	options
+};
+//#endregion
+export { src_default as default, parsers, printers };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@htnabe/prettier-plugin-hugo-post",
+  "version": "0.0.1-rc.1",
+  "description": "A Prettier plugin for formatting Hugo content files with YAML, TOML, or JSON front matter, Markdown content, and Go template syntax.",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "type": "module",
+  "keywords": [
+    "prettier",
+    "plugin",
+    "hugo",
+    "markdown",
+    "yaml",
+    "toml",
+    "json",
+    "go-template",
+    "front-matter",
+    "static-site-generator"
+  ],
+  "author": "htnabe",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/htnabe/prettier-plugin-hugo-post.git"
+  },
+  "bugs": {
+    "url": "https://github.com/htnabe/prettier-plugin-hugo-post/issues"
+  },
+  "homepage": "https://github.com/htnabe/prettier-plugin-hugo-post#readme",
+  "engines": {
+    "node": ">=22.0.0",
+    "bun": ">=1.1.0"
+  },
+  "packageManager": "bun@1.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "prettier": ">=3.0.0"
+  },
+  "dependencies": {
+    "prettier-plugin-toml": "^2.0.6"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260707.2",
+    "@vitest/coverage-v8": "^4.1.11",
+    "jsdom": "^30.0.1",
+    "lefthook": "^2.1.10",
+    "oxlint": "^1.79.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "prettier": "^3.9.6",
+    "ts-node": "^10.9.2",
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "scripts": {
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "build": "tsdown",
+    "example": "bun run build && bunx prettier --plugin ./dist/index.mjs examples/test.md"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "prettier": {
+    "semi": true,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "printWidth": 100,
+    "bracketSpacing": true,
+    "arrowParens": "avoid"
+  },
+  "allowScripts": {
+    "lefthook@2.1.10": true
+  }
+}