@takazudo/mdx-formatter 0.1.2 → 0.3.0

package/dist/cli.js

@@ -4,6 +4,7 @@ import { program } from 'commander';
 import { glob } from 'glob';
 import chalk from 'chalk';
 import { formatFile, checkFile } from './index.js';
+import { loadFullConfig } from './load-config.js';
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 program
     .name('mdx-formatter')
@@ -29,12 +30,11 @@ program.parse();
  * Main CLI function
  */
 async function main(patterns, options) {
-    const ignorePatterns = options.ignore.split(',').map((p) => p.trim());
-    // Build format options from CLI flags
-    const formatOptions = {};
-    if (options.config) {
-        formatOptions.config = options.config;
-    }
+    const cliIgnorePatterns = options.ignore.split(',').map((p) => p.trim());
+    // Load config once: get both formatter settings and exclude patterns
+    const { settings, excludePatterns } = loadFullConfig(options.config ? { config: options.config } : {});
+    const ignorePatterns = [...new Set([...cliIgnorePatterns, ...excludePatterns])];
+    const formatOptions = { settings };
     // Find all matching files
     const files = [];
     for (const pattern of patterns) {

package/dist/hybrid-formatter.d.ts

@@ -53,6 +53,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

@@ -893,16 +893,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/load-config.d.ts

@@ -7,6 +7,19 @@
  * 3. Programmatic options (passed to format())
  */
 import type { FormatterSettings, FormatOptions } from './types.js';
+/**
+ * Load config file once and return both formatter settings and exclude patterns.
+ * This avoids reading the config file multiple times in the CLI path.
+ */
+export declare function loadFullConfig(options?: FormatOptions): {
+    settings: FormatterSettings;
+    excludePatterns: string[];
+};
+/**
+ * Load exclude patterns from config file.
+ * These are glob patterns for files the CLI should skip.
+ */
+export declare function loadExcludePatterns(configPath?: string): string[];
 /**
  * Load and merge all configuration layers
  */

package/dist/load-config.js

@@ -53,19 +53,40 @@ function findConfigFile(configPath) {
     return null;
 }
 /**
- * Load and merge all configuration layers
+ * Load config file once and return both formatter settings and exclude patterns.
+ * This avoids reading the config file multiple times in the CLI path.
  */
-export function loadConfig(options = {}) {
+export function loadFullConfig(options = {}) {
     // Layer 1: Built-in defaults
     let settings = deepCloneSettings(formatterSettings);
     // Layer 2: Config file
     const fileConfig = findConfigFile(options.config);
+    // Extract exclude patterns (CLI concern, not formatter settings)
+    let excludePatterns = [];
     if (fileConfig) {
-        settings = mergeSettings(settings, fileConfig);
+        if (Array.isArray(fileConfig.exclude)) {
+            excludePatterns = fileConfig.exclude.filter((item) => typeof item === 'string');
+        }
+        const formatterConfig = { ...fileConfig };
+        delete formatterConfig.exclude;
+        settings = mergeSettings(settings, formatterConfig);
     }
     // Layer 3: Programmatic options
     if (options.settings) {
         settings = mergeSettings(settings, options.settings);
     }
-    return settings;
+    return { settings, excludePatterns };
+}
+/**
+ * Load exclude patterns from config file.
+ * These are glob patterns for files the CLI should skip.
+ */
+export function loadExcludePatterns(configPath) {
+    return loadFullConfig({ config: configPath }).excludePatterns;
+}
+/**
+ * Load and merge all configuration layers
+ */
+export function loadConfig(options = {}) {
+    return loadFullConfig(options).settings;
 }

package/dist/settings.js

@@ -60,6 +60,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

@@ -111,6 +111,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.1.2",
+  "version": "0.3.0",
   "description": "AST-based markdown and MDX formatter with Japanese text support",
   "type": "module",
   "main": "dist/index.js",
@@ -33,6 +33,8 @@
     "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"
   },