@takazudo/mdx-formatter 0.2.0 → 0.4.0

package/dist/hybrid-formatter.d.ts

@@ -29,6 +29,10 @@ export declare class HybridFormatter {
     collectJsxFormatOperations(operations: FormatterOperation[]): void;
     needsJsxFormatting(node: MdxJsxElement, originalText: string): boolean;
     formatJsxElement(node: MdxJsxElement, originalText: string): string;
+    /**
+     * Check if template literal indentation should be preserved based on settings.
+     */
+    shouldPreserveTemplateLiteral(): boolean;
     getAttributeString(attr: MdxJsxAttribute, originalText: string): string;
     extractAttributeExpression(attrName: string, originalText: string): string | null;
     extractExpressionValue(expr: MdxJsxAttributeValueExpression): string;
@@ -53,6 +57,12 @@ export declare class HybridFormatter {
     extractHtmlFromNode(node: MdxJsxElement): string | null;
     collectJsxIndentOperations(operations: FormatterOperation[]): void;
     collectBlockJsxEmptyLineOperations(operations: FormatterOperation[]): void;
+    /**
+     * Pre-process YAML text to fix values that would cause parsing failures
+     * or silent data corruption. Detects unquoted values containing special
+     * YAML characters and wraps them in double quotes.
+     */
+    preprocessYamlForParsing(yamlText: string): string;
     collectYamlFormatOperations(operations: FormatterOperation[]): void;
     getLineAtPosition(charPos: number): number;
     applyOperation(lines: string[], op: FormatterOperation): void;

package/dist/hybrid-formatter.js

@@ -499,15 +499,21 @@ export class HybridFormatter {
             // Add each attribute on its own line with proper indent
             for (const attr of attributes) {
                 const attrStr = this.getAttributeString(attr, originalText);
-                // Handle multi-line expression values (like arrays)
+                // Handle multi-line expression values (like arrays, template literals)
                 if (attrStr.includes('\n')) {
                     const attrLines = attrStr.split('\n');
                     lines.push(`${indent}${attrLines[0]}`);
+                    // Check if this is a template literal expression (backtick string)
+                    // Template literal content has meaningful indentation that must be preserved
+                    const isTemplateLiteral = this.shouldPreserveTemplateLiteral() && attrLines[0].includes('={`');
                     // Add subsequent lines with additional indentation for expression content
                     for (let i = 1; i < attrLines.length; i++) {
-                        // Check if this line is part of the expression or the closing
                         const line = attrLines[i];
-                        if (line.trim().endsWith(']}') || line.trim() === ']}') {
+                        if (isTemplateLiteral) {
+                            // Preserve original indentation inside template literals
+                            lines.push(line);
+                        }
+                        else if (line.trim().endsWith(']}') || line.trim() === ']}') {
                             // Closing of array expression
                             lines.push(`${indent}${line.trim()}`);
                         }
@@ -561,6 +567,12 @@ export class HybridFormatter {
         }
         return lines.join('\n');
     }
+    /**
+     * Check if template literal indentation should be preserved based on settings.
+     */
+    shouldPreserveTemplateLiteral() {
+        return this.settings.formatMultiLineJsx.preserveTemplateLiteralIndent !== false;
+    }
     getAttributeString(attr, originalText) {
         if (!attr || !attr.name)
             return '';
@@ -573,7 +585,20 @@ export class HybridFormatter {
             else if (attr.value && attr.value.type === 'mdxJsxAttributeValueExpression') {
                 // Expression value
                 const exprValue = this.extractExpressionValue(attr.value);
-                if (exprValue) {
+                // For template literals, prefer extracting from original text to preserve
+                // internal indentation (AST normalizes/strips leading whitespace)
+                if (this.shouldPreserveTemplateLiteral() &&
+                    exprValue &&
+                    exprValue.trimStart().startsWith('`')) {
+                    const extracted = this.extractAttributeExpression(attr.name, originalText);
+                    if (extracted) {
+                        result = extracted;
+                    }
+                    else {
+                        result += `={${exprValue}}`;
+                    }
+                }
+                else if (exprValue) {
                     result += `={${exprValue}}`;
                 }
                 else {
@@ -893,16 +918,69 @@ export class HybridFormatter {
             }
         });
     }
+    /**
+     * Pre-process YAML text to fix values that would cause parsing failures
+     * or silent data corruption. Detects unquoted values containing special
+     * YAML characters and wraps them in double quotes.
+     */
+    preprocessYamlForParsing(yamlText) {
+        const lines = yamlText.split('\n');
+        const result = [];
+        for (const line of lines) {
+            // Match a YAML mapping entry: optional indent, key, colon, space, value
+            // Keys must start with a word char, may contain word chars, dots, hyphens
+            const match = line.match(/^(\s*)([\w][\w.-]*):\s+(.+)$/);
+            if (match) {
+                const [, indent, key, value] = match;
+                const trimmedValue = value.trim();
+                // Skip if already quoted
+                if ((trimmedValue.startsWith('"') && trimmedValue.endsWith('"')) ||
+                    (trimmedValue.startsWith("'") && trimmedValue.endsWith("'"))) {
+                    result.push(line);
+                    continue;
+                }
+                // Skip if the value is a flow sequence [...] or flow mapping {...}
+                if ((trimmedValue.startsWith('[') && trimmedValue.endsWith(']')) ||
+                    (trimmedValue.startsWith('{') && trimmedValue.endsWith('}'))) {
+                    result.push(line);
+                    continue;
+                }
+                // Skip block scalar indicators (>, |, >-, |-, >+, |+)
+                if (/^[|>][-+]?$/.test(trimmedValue)) {
+                    result.push(line);
+                    continue;
+                }
+                const needsQuoting = trimmedValue.includes(': ') ||
+                    trimmedValue.includes(' #') ||
+                    /^[!&*%@`]/.test(trimmedValue);
+                if (needsQuoting) {
+                    const escaped = trimmedValue.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+                    result.push(`${indent}${key}: "${escaped}"`);
+                    continue;
+                }
+            }
+            result.push(line);
+        }
+        return result.join('\n');
+    }
     collectYamlFormatOperations(operations) {
         const yamlSettings = this.settings.formatYamlFrontmatter;
         visit(this.ast, (node) => {
             if (node.type === 'yaml' && node.position) {
                 const yamlNode = node;
                 try {
-                    // Parse the YAML content
-                    const parsed = yaml.load(yamlNode.value);
-                    // Format it back with proper formatting
+                    let yamlToParse = yamlNode.value;
+                    // Pre-process YAML to fix unsafe values (e.g., unquoted colons)
+                    if (yamlSettings.fixUnsafeValues !== false) {
+                        yamlToParse = this.preprocessYamlForParsing(yamlToParse);
+                    }
+                    // Parse the YAML content using JSON_SCHEMA to prevent silent
+                    // data corruption (e.g., dates parsed as Date objects, octals)
+                    const parsed = yaml.load(yamlToParse, { schema: yaml.JSON_SCHEMA });
+                    // Format it back with proper formatting using JSON_SCHEMA
+                    // to preserve string representations (dates, etc.)
                     const formatted = yaml.dump(parsed, {
+                        schema: yaml.JSON_SCHEMA,
                         indent: yamlSettings.indent || 2,
                         lineWidth: yamlSettings.lineWidth || 100,
                         quotingType: (yamlSettings.quotingType || '"'),

package/dist/settings.js

@@ -15,6 +15,8 @@ export const formatterSettings = {
         indentSize: 2,
         // Components to ignore (preserve their formatting completely)
         ignoreComponents: [],
+        // Preserve indentation inside template literal JSX attributes (html={`...`}, css={`...`})
+        preserveTemplateLiteralIndent: true,
     },
     // Rule 3: Format all HTML blocks within MDX using Prettier
     formatHtmlBlocksInMdx: {
@@ -60,6 +62,7 @@ export const formatterSettings = {
         quotingType: '"', // Quote type for strings that need quoting: '"' or "'"
         forceQuotes: false, // Force quotes on all string values
         noCompatMode: true, // Use YAML 1.2 spec (not 1.1)
+        fixUnsafeValues: true, // Pre-process YAML to quote values containing special characters like colons
     },
     // Rule 8: Preserve Docusaurus admonitions
     preserveAdmonitions: {

package/dist/types.d.ts

@@ -76,6 +76,7 @@ export interface FormatMultiLineJsxSetting {
     indentSize: number;
     indentType?: string;
     ignoreComponents: string[];
+    preserveTemplateLiteralIndent: boolean;
 }
 export interface FormatHtmlBlocksInMdxSetting {
     enabled: boolean;
@@ -111,6 +112,7 @@ export interface FormatYamlFrontmatterSetting {
     quotingType: string;
     forceQuotes: boolean;
     noCompatMode: boolean;
+    fixUnsafeValues: boolean;
 }
 export interface PreserveAdmonitionsSetting {
     enabled: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takazudo/mdx-formatter",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "AST-based markdown and MDX formatter with Japanese text support",
   "type": "module",
   "main": "dist/index.js",
@@ -33,6 +33,7 @@
     "lint:fix": "eslint --fix .",
     "check": "prettier --check . && eslint .",
     "check:fix": "prettier --write . && eslint --fix .",
+    "b4push": "./scripts/run-b4push.sh",
     "doc:start": "pnpm --dir doc start",
     "prepare": "husky",
     "prepublishOnly": "tsc && vitest run"