@mdfriday/foundry/dist/internal/domain/template/entity/template.d.ts

The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.

import { Template } from '@mdfriday/text-template';
import { TemplateEngine as ITemplateEngine, TemplateFs, TemplateError } from '../type';
import { Executor } from './executor';
import { Parser } from './parser';
import { Lookup } from './lookup';
import { RegularTemplateNamespace, PartialTemplateNamespace, ShortcodeTemplateNamespace } from '../vo/namespace';
/**
 * Template entity - main template engine with separated template management
 * TypeScript version of Go's Template struct
 */
export declare class TemplateEngine implements ITemplateEngine {
    private executor;
    private lookup;
    private parser;
    private templateNamespace;
    private partialNamespace;
    private shortcodeNamespace;
    private fs;
    constructor(executor: Executor, lookup: Lookup, parser: Parser, templateNamespace: RegularTemplateNamespace, partialNamespace: PartialTemplateNamespace, shortcodeNamespace: ShortcodeTemplateNamespace, fs: TemplateFs);
    /**
     * Mark template engine as ready
     */
    markReady(): Promise<void>;
    /**
     * Get regular template by name with baseof dependency support
     */
    getTemplate(name: string): Promise<[Template | null, boolean, Error | null]>;
    /**
     * Get partial template by name (simple lookup)
     */
    getPartial(name: string): Promise<[Template | null, boolean, Error | null]>;
    /**
     * Get shortcode template by name
     */
    getShortcode(name: string): Promise<[Template | null, boolean, Error | null]>;
    /**
     * Get template by name (unified method that routes to appropriate namespace)
     */
    get(name: string): Promise<[Template | null, boolean, Error | null]>;
    /**
     * Find first available template from a list of template names by priority
     * Returns the first template found, its name, whether it was found, and any error
     */
    findFirst(names: string[]): Promise<[Template | null, string | null, boolean, Error | null]>;
    /**
     * Check if a shortcode exists
     * @param name - The shortcode name
     * @returns true if the shortcode exists, false otherwise
     */
    hasShortcode(name: string): boolean;
    /**
     * Get all available shortcode names
     * @returns Array of shortcode names
     */
    getShortcodeNames(): string[];
    /**
     * Get shortcode count
     * @returns Number of loaded shortcodes
     */
    getShortcodeCount(): number;
    /**
     * Load templates from file system (unified for all template types)
     */
    loadTemplates(): Promise<void>;
    /**
     * Add template from file info (routes to appropriate namespace)
     */
    private addTemplateFileInfo;
    /**
     * Add template to appropriate namespace based on type
     */
    private addTemplate;
    /**
     * Execute template with data
     */
    execute(templateName: string, data: any): Promise<string>;
    executeRaw(templateName: string, rawContent: string, data: any): Promise<string>;
    /**
     * Execute shortcode template with data
     */
    executeShortcode(shortcodeName: string, data: any): Promise<string>;
    /**
     * Execute template safely
     */
    executeSafely(templateName: string, data: any): Promise<{
        result: string | null;
        error: TemplateError | null;
    }>;
    /**
     * Execute shortcode safely
     */
    executeShortcodeSafely(shortcodeName: string, data: any): Promise<{
        result: string | null;
        error: TemplateError | null;
    }>;
    /**
     * Check if template exists
     */
    hasTemplate(name: string): Promise<boolean>;
    /**
     * Get all template names
     */
    getTemplateNames(): string[];
    /**
     * Get all partial template names
     */
    getPartialTemplateNames(): string[];
    /**
     * Get all template names from all namespaces
     */
    getAllTemplateNames(): string[];
    /**
     * Get partial namespace (for internal use by partial function)
     */
    getPartialNamespace(): PartialTemplateNamespace;
    /**
     * Get shortcode namespace (for internal use)
     */
    getShortcodeNamespace(): ShortcodeTemplateNamespace;
    /**
     * Get template namespace (for internal use)
     */
    getTemplateNamespace(): RegularTemplateNamespace;
    /**
     * Clear all templates including shortcodes
     */
    clear(): void;
    /**
     * Get template by pattern
     */
    getTemplatesByPattern(pattern: RegExp): string[];
}
/**
 * Create a new TemplateEngine instance
 */
export declare function newTemplateEngine(executor: Executor, lookup: Lookup, parser: Parser, templateNamespace: RegularTemplateNamespace, partialNamespace: PartialTemplateNamespace, shortcodeNamespace: ShortcodeTemplateNamespace, fs: TemplateFs): TemplateEngine;
//# sourceMappingURL=template.d.ts.map