@mdfriday/foundry/dist/internal/domain/template/vo/namespace.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 { TemplateNamespace, TemplateState } from '../type';
/**
 * Base namespace for template storage with common functionality
 * Abstract base class for different template namespace types
 */
declare abstract class BaseNamespace<T extends TemplateState> {
    protected templates: Map<string, T>;
    protected readonly mutex: Set<string>;
    /**
     * Add template to namespace
     */
    addTemplate(name: string, state: T): void;
    /**
     * Find template in namespace
     */
    findTemplate(name: string): T | null;
    /**
     * Get all templates
     */
    getTemplates(): Map<string, T>;
    /**
     * Check if template exists
     */
    hasTemplate(name: string): boolean;
    /**
     * Get template names
     */
    getTemplateNames(): string[];
    /**
     * Remove template
     */
    removeTemplate(name: string): boolean;
    /**
     * Clear all templates
     */
    clear(): void;
    /**
     * Get template count
     */
    size(): number;
    /**
     * Get templates by pattern
     */
    getTemplatesByPattern(pattern: RegExp): T[];
    /**
     * Simple lock mechanism for thread safety simulation
     */
    protected withLock<R>(fn: () => R): R;
    /**
     * Simple read lock mechanism
     */
    protected withReadLock<R>(fn: () => R): R;
    /**
     * Abstract method for type-specific lookup logic
     */
    abstract lookup(name: string): Template | null;
}
/**
 * Regular template namespace - supports baseof dependencies and template keywords
 * Handles complex template dependencies and inheritance
 */
export declare class RegularTemplateNamespace extends BaseNamespace<TemplateState> implements TemplateNamespace {
    /**
     * Lookup template by name with dependency support
     */
    lookup(name: string): Template | null;
    /**
     * Find template with dependency information for baseof processing
     */
    findTemplateWithDependencies(name: string): TemplateState | null;
    /**
     * Get templates that need baseof
     */
    getTemplatesNeedingBase(): TemplateState[];
}
/**
 * Partial template namespace - simple lookup, no template keyword support
 * For templates in the partials/ directory
 */
export declare class PartialTemplateNamespace extends BaseNamespace<TemplateState> {
    /**
     * Simple lookup for partial templates
     */
    lookup(name: string): Template | null;
    /**
     * Add partial template with validation
     */
    addPartialTemplate(name: string, state: TemplateState): void;
}
/**
 * Shortcode template namespace - simplest lookup, no dependencies allowed
 * For shortcode templates with content-focused rendering
 */
export declare class ShortcodeTemplateNamespace extends BaseNamespace<TemplateState> {
    /**
     * Simple lookup for shortcode templates
     */
    lookup(name: string): Template | null;
    /**
     * Add shortcode template with validation
     */
    addShortcodeTemplate(name: string, state: TemplateState): void;
    /**
     * Get shortcode by name (alias for lookup for clarity)
     */
    getShortcode(name: string): Template | null;
    /**
     * Check if shortcode exists
     */
    hasShortcode(name: string): boolean;
    /**
     * Get all shortcode names
     */
    getShortcodeNames(): string[];
}
/**
 * Create a new regular template namespace
 */
export declare function newRegularTemplateNamespace(): RegularTemplateNamespace;
/**
 * Create a new partial template namespace
 */
export declare function newPartialTemplateNamespace(): PartialTemplateNamespace;
/**
 * Create a new shortcode template namespace
 */
export declare function newShortcodeTemplateNamespace(): ShortcodeTemplateNamespace;
export {};
//# sourceMappingURL=namespace.d.ts.map