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

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.templateRegistry = exports.TemplateRegistry = void 0;
exports.registerTemplate = registerTemplate;
exports.setDefaultTemplate = setDefaultTemplate;
exports.listTemplates = listTemplates;
exports.getTemplateInfo = getTemplateInfo;
exports.hasTemplate = hasTemplate;
exports.resolveTemplate = resolveTemplate;
const errors_js_1 = require("../core/errors.js");
const defaultTemplate_js_1 = require("./defaultTemplate.js");
const modernTemplate_js_1 = require("./modernTemplate.js");
/**
 * Template registry for managing PDF templates
 */
class TemplateRegistry {
    constructor() {
        this.templates = new Map();
        this.defaultTemplateName = 'default';
        // Register built-in templates
        this.templates.set('default', defaultTemplate_js_1.defaultTemplate);
        this.templates.set('simple', defaultTemplate_js_1.simpleTemplate);
        this.templates.set('modern', modernTemplate_js_1.modernTemplate);
    }
    /**
     * Register a new template
     */
    register(name, compiler) {
        if (typeof name !== 'string' || !name.trim()) {
            throw new errors_js_1.TemplateError('Template name must be a non-empty string');
        }
        if (typeof compiler !== 'function') {
            throw new errors_js_1.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 errors_js_1.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' || name === 'modern') {
            throw new errors_js_1.TemplateError('Cannot unregister built-in templates');
        }
        return this.templates.delete(name);
    }
    /**
     * Set the default template
     */
    setDefault(name) {
        if (!this.has(name)) {
            throw new errors_js_1.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 errors_js_1.TemplateError(`Template "${name}" not found`);
        }
        return {
            name,
            isDefault: name === this.defaultTemplateName,
            isBuiltIn: ['default', 'simple', 'modern'].includes(name),
        };
    }
    /**
     * Clear all custom templates (keeps built-in ones)
     */
    clearCustom() {
        const customTemplates = this.list().filter(name => !['default', 'simple', 'modern'].includes(name));
        customTemplates.forEach(name => this.templates.delete(name));
        // Reset default if it was a custom template
        if (!['default', 'simple', 'modern'].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;
    }
}
exports.TemplateRegistry = TemplateRegistry;
// Global template registry instance
exports.templateRegistry = new TemplateRegistry();
/**
 * Register a template globally
 */
function registerTemplate(name, compiler) {
    exports.templateRegistry.register(name, compiler);
}
/**
 * Set the default template globally
 */
function setDefaultTemplate(name) {
    exports.templateRegistry.setDefault(name);
}
/**
 * List all available templates
 */
function listTemplates() {
    return exports.templateRegistry.list();
}
/**
 * Get template info
 */
function getTemplateInfo(name) {
    return exports.templateRegistry.getInfo(name);
}
/**
 * Check if template exists
 */
function hasTemplate(name) {
    return exports.templateRegistry.has(name);
}
/**
 * Resolve template from string name or function
 */
function resolveTemplate(template) {
    if (typeof template === 'function') {
        return template;
    }
    if (typeof template === 'string') {
        return exports.templateRegistry.get(template);
    }
    return exports.templateRegistry.getDefault();
}
//# sourceMappingURL=registry.js.map