safeer-pdf-generator/dist/esm/templates/registry.js

Framework-agnostic PDF generation library with chunking, merging, S3 upload, and email delivery

import { TemplateError } from '../core/errors.js';
import { defaultTemplate, simpleTemplate } from './defaultTemplate.js';
/**
 * Template registry for managing PDF templates
 */
export class TemplateRegistry {
    constructor() {
        this.templates = new Map();
        this.defaultTemplateName = 'default';
        // Register built-in templates
        this.templates.set('default', defaultTemplate);
        this.templates.set('simple', simpleTemplate);
    }
    /**
     * Register a new template
     */
    register(name, compiler) {
        if (typeof name !== 'string' || !name.trim()) {
            throw new TemplateError('Template name must be a non-empty string');
        }
        if (typeof compiler !== 'function') {
            throw new TemplateError('Template compiler must be a function');
        }
        this.templates.set(name, compiler);
    }
    /**
     * Get a template by name
     */
    get(name) {
        const template = this.templates.get(name);
        if (!template) {
            throw new TemplateError(`Template "${name}" not found`);
        }
        return template;
    }
    /**
     * Check if a template exists
     */
    has(name) {
        return this.templates.has(name);
    }
    /**
     * Remove a template
     */
    unregister(name) {
        if (name === 'default' || name === 'simple') {
            throw new TemplateError('Cannot unregister built-in templates');
        }
        return this.templates.delete(name);
    }
    /**
     * Set the default template
     */
    setDefault(name) {
        if (!this.has(name)) {
            throw new TemplateError(`Cannot set default to non-existent template "${name}"`);
        }
        this.defaultTemplateName = name;
    }
    /**
     * Get the default template
     */
    getDefault() {
        return this.get(this.defaultTemplateName);
    }
    /**
     * Get the default template name
     */
    getDefaultName() {
        return this.defaultTemplateName;
    }
    /**
     * List all available templates
     */
    list() {
        return Array.from(this.templates.keys());
    }
    /**
     * Get template info
     */
    getInfo(name) {
        if (!this.has(name)) {
            throw new TemplateError(`Template "${name}" not found`);
        }
        return {
            name,
            isDefault: name === this.defaultTemplateName,
            isBuiltIn: ['default', 'simple'].includes(name),
        };
    }
    /**
     * Clear all custom templates (keeps built-in ones)
     */
    clearCustom() {
        const customTemplates = this.list().filter(name => !['default', 'simple'].includes(name));
        customTemplates.forEach(name => this.templates.delete(name));
        // Reset default if it was a custom template
        if (!['default', 'simple'].includes(this.defaultTemplateName)) {
            this.defaultTemplateName = 'default';
        }
    }
    /**
     * Clone the registry
     */
    clone() {
        const newRegistry = new TemplateRegistry();
        newRegistry.templates.clear(); // Clear built-ins first
        // Copy all templates
        for (const [name, compiler] of this.templates) {
            newRegistry.templates.set(name, compiler);
        }
        newRegistry.defaultTemplateName = this.defaultTemplateName;
        return newRegistry;
    }
}
// Global template registry instance
export const templateRegistry = new TemplateRegistry();
/**
 * Register a template globally
 */
export function registerTemplate(name, compiler) {
    templateRegistry.register(name, compiler);
}
/**
 * Set the default template globally
 */
export function setDefaultTemplate(name) {
    templateRegistry.setDefault(name);
}
/**
 * List all available templates
 */
export function listTemplates() {
    return templateRegistry.list();
}
/**
 * Get template info
 */
export function getTemplateInfo(name) {
    return templateRegistry.getInfo(name);
}
/**
 * Check if template exists
 */
export function hasTemplate(name) {
    return templateRegistry.has(name);
}
/**
 * Resolve template from string name or function
 */
export function resolveTemplate(template) {
    if (typeof template === 'function') {
        return template;
    }
    if (typeof template === 'string') {
        return templateRegistry.get(template);
    }
    return templateRegistry.getDefault();
}
//# sourceMappingURL=registry.js.map