md-template-vars 0.1.0

package/dist/application/use-cases/process-templates.d.ts

@@ -0,0 +1,2 @@
+import type { CliOptions, ProcessResult } from "../../shared/types.js";
+export declare function processTemplates(options: CliOptions): Promise<ProcessResult>;

package/dist/application/use-cases/process-templates.js

@@ -0,0 +1,32 @@
+import { resolve, relative, join } from "node:path";
+import { SameInputOutputError } from "../../shared/errors.js";
+import { loadVariables } from "../../infrastructure/repositories/variables-repository.js";
+import { readTemplate, writeTemplate } from "../../infrastructure/repositories/template-repository.js";
+import { scanTemplates } from "../../infrastructure/services/file-scanner.js";
+import { renderTemplate } from "../../domain/services/template-renderer.js";
+export async function processTemplates(options) {
+    const inputDir = resolve(options.input);
+    const outputDir = resolve(options.output);
+    if (inputDir === outputDir) {
+        throw new SameInputOutputError();
+    }
+    const variables = loadVariables(options.vars);
+    const files = await scanTemplates(inputDir, {
+        include: options.include,
+        exclude: options.exclude,
+    });
+    const processedFiles = [];
+    const warnings = [];
+    for (const filePath of files) {
+        const template = readTemplate(filePath);
+        const result = renderTemplate(template.content, variables);
+        const relativePath = relative(inputDir, filePath);
+        const outputPath = join(outputDir, relativePath);
+        writeTemplate(outputPath, result.content);
+        processedFiles.push(relativePath);
+        for (const varName of result.undefinedVariables) {
+            warnings.push(`Warning: undefined variable "{{${varName}}}" in ${relativePath}`);
+        }
+    }
+    return { processedFiles, warnings };
+}

package/dist/domain/entities/template.d.ts

@@ -0,0 +1,5 @@
+export declare class Template {
+    readonly path: string;
+    readonly content: string;
+    constructor(path: string, content: string);
+}

package/dist/domain/entities/template.js

@@ -0,0 +1,8 @@
+export class Template {
+    path;
+    content;
+    constructor(path, content) {
+        this.path = path;
+        this.content = content;
+    }
+}

package/dist/domain/services/template-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { Variables } from "../value-objects/variables.js";
+import type { RenderResult } from "../../shared/types.js";
+export declare function renderTemplate(content: string, variables: Variables): RenderResult;

package/dist/domain/services/template-renderer.js

@@ -0,0 +1,15 @@
+const VARIABLE_PATTERN = /\{\{(\w+)\}\}/g;
+export function renderTemplate(content, variables) {
+    const undefinedVariables = [];
+    const renderedContent = content.replace(VARIABLE_PATTERN, (match, varName) => {
+        if (varName in variables) {
+            return variables[varName];
+        }
+        undefinedVariables.push(varName);
+        return match;
+    });
+    return {
+        content: renderedContent,
+        undefinedVariables,
+    };
+}

package/dist/domain/value-objects/variables.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const VariablesSchema: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, string, string | number | boolean>>;
+export type Variables = Record<string, string>;

package/dist/domain/value-objects/variables.js

@@ -0,0 +1,3 @@
+import { z } from "zod";
+const VariableValueSchema = z.union([z.string(), z.number(), z.boolean()]).transform(String);
+export const VariablesSchema = z.record(z.string(), VariableValueSchema);

package/dist/infrastructure/repositories/template-repository.d.ts

@@ -0,0 +1,3 @@
+import { Template } from "../../domain/entities/template.js";
+export declare function readTemplate(filePath: string): Template;
+export declare function writeTemplate(filePath: string, content: string): void;

package/dist/infrastructure/repositories/template-repository.js

@@ -0,0 +1,11 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { Template } from "../../domain/entities/template.js";
+export function readTemplate(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    return new Template(filePath, content);
+}
+export function writeTemplate(filePath, content) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content, "utf-8");
+}

package/dist/infrastructure/repositories/variables-repository.d.ts

@@ -0,0 +1,2 @@
+import { type Variables } from "../../domain/value-objects/variables.js";
+export declare function loadVariables(filePath: string): Variables;

package/dist/infrastructure/repositories/variables-repository.js

@@ -0,0 +1,16 @@
+import { readFileSync, existsSync } from "node:fs";
+import { parse } from "yaml";
+import { VariablesSchema } from "../../domain/value-objects/variables.js";
+import { VariablesFileNotFoundError, InvalidVariablesError } from "../../shared/errors.js";
+export function loadVariables(filePath) {
+    if (!existsSync(filePath)) {
+        throw new VariablesFileNotFoundError(filePath);
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parse(content);
+    const result = VariablesSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new InvalidVariablesError(result.error.message);
+    }
+    return result.data;
+}

package/dist/infrastructure/services/file-scanner.d.ts

@@ -0,0 +1,5 @@
+export interface ScanOptions {
+    include?: string;
+    exclude?: string;
+}
+export declare function scanTemplates(inputDir: string, options?: ScanOptions): Promise<string[]>;

package/dist/infrastructure/services/file-scanner.js

@@ -0,0 +1,8 @@
+import fg from "fast-glob";
+export async function scanTemplates(inputDir, options = {}) {
+    const pattern = options.include
+        ? `${inputDir}/${options.include}`
+        : `${inputDir}/**/*.md`;
+    const ignore = options.exclude ? [`${inputDir}/${options.exclude}`] : [];
+    return fg(pattern, { ignore });
+}

package/dist/presentation/cli/commands/main.d.ts

@@ -0,0 +1,25 @@
+export declare const mainCommand: import("citty").CommandDef<{
+    input: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    vars: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        description: string;
+    };
+}>;

package/dist/presentation/cli/commands/main.js

@@ -0,0 +1,61 @@
+import { defineCommand } from "citty";
+import { processTemplates } from "../../../application/use-cases/process-templates.js";
+import { VariablesFileNotFoundError, SameInputOutputError, InvalidVariablesError, } from "../../../shared/errors.js";
+export const mainCommand = defineCommand({
+    meta: {
+        name: "md-template-vars",
+        description: "Replace {{variables}} in markdown templates with YAML values",
+    },
+    args: {
+        input: {
+            type: "positional",
+            description: "Input directory containing templates",
+            required: true,
+        },
+        output: {
+            type: "positional",
+            description: "Output directory for processed files",
+            required: true,
+        },
+        vars: {
+            type: "string",
+            description: "Path to variables YAML file",
+            default: "variables.yaml",
+        },
+        include: {
+            type: "string",
+            description: "Glob pattern to include files",
+        },
+        exclude: {
+            type: "string",
+            description: "Glob pattern to exclude files",
+        },
+    },
+    async run({ args }) {
+        try {
+            const result = await processTemplates({
+                input: args.input,
+                output: args.output,
+                vars: args.vars,
+                include: args.include,
+                exclude: args.exclude,
+            });
+            for (const warning of result.warnings) {
+                console.warn(warning);
+            }
+            console.log(`Processed ${result.processedFiles.length} file(s)`);
+            for (const file of result.processedFiles) {
+                console.log(`  - ${file}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof VariablesFileNotFoundError ||
+                error instanceof SameInputOutputError ||
+                error instanceof InvalidVariablesError) {
+                console.error(`Error: ${error.message}`);
+                process.exit(1);
+            }
+            throw error;
+        }
+    },
+});

package/dist/presentation/cli/index.d.ts

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

package/dist/presentation/cli/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runMain } from "citty";
+import { mainCommand } from "./commands/main.js";
+runMain(mainCommand);

package/dist/shared/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class VariablesFileNotFoundError extends Error {
+    constructor(filePath: string);
+}
+export declare class SameInputOutputError extends Error {
+    constructor();
+}
+export declare class InvalidVariablesError extends Error {
+    constructor(message: string);
+}

package/dist/shared/errors.js

@@ -0,0 +1,18 @@
+export class VariablesFileNotFoundError extends Error {
+    constructor(filePath) {
+        super(`Variables file not found: ${filePath}`);
+        this.name = "VariablesFileNotFoundError";
+    }
+}
+export class SameInputOutputError extends Error {
+    constructor() {
+        super("Input and output directories cannot be the same");
+        this.name = "SameInputOutputError";
+    }
+}
+export class InvalidVariablesError extends Error {
+    constructor(message) {
+        super(`Invalid variables file: ${message}`);
+        this.name = "InvalidVariablesError";
+    }
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,15 @@
+export interface CliOptions {
+    input: string;
+    output: string;
+    vars: string;
+    include?: string;
+    exclude?: string;
+}
+export interface ProcessResult {
+    processedFiles: string[];
+    warnings: string[];
+}
+export interface RenderResult {
+    content: string;
+    undefinedVariables: string[];
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "md-template-vars",
+  "author": "Shunta Toda",
+  "version": "0.1.0",
+  "description": "Replace {{variables}} in markdown templates with YAML values",
+  "type": "module",
+  "main": "./dist/application/use-cases/process-templates.js",
+  "types": "./dist/application/use-cases/process-templates.d.ts",
+  "bin": {
+    "md-template-vars": "./dist/presentation/cli/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node ./dist/presentation/cli/index.js",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "prepublishOnly": "pnpm test run && pnpm build"
+  },
+  "keywords": [
+    "markdown",
+    "template",
+    "variables",
+    "yaml",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "fast-glob": "^3.3.2",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}