svelte-pagedjs/dist/pagedjs-manager.svelte.js

A Svelte wrapper for PagedJS, providing easy pagination and print layout capabilities for your Svelte applications.

//@ts-ignore
import { Previewer, registerHandlers } from 'pagedjs';
import { BROWSER } from 'esm-env';
// Base Handler class
class Handler {
    chunker;
    polisher;
    caller;
    constructor(chunker, polisher, caller) {
        this.chunker = chunker;
        this.polisher = polisher;
        this.caller = caller;
    }
}
// Default handlers that can be extended
export class PageHandler extends Handler {
    beforePreview(content, renderTo) { }
    afterPreview(pages) { }
    // Chunker hooks
    beforeParsed(content) { }
    filter(content) { }
    afterParsed(parsed) { }
    beforePageLayout(page) { }
    onPageLayout(pageWrapper, breakToken, layout) { }
    afterPageLayout(pageElement, page, breakToken) { }
    finalizePage(pageElement, page, breakToken) { }
    afterRendered(pages) { }
    // Polisher hooks
    beforeTreeParse(text, sheet) { }
    beforeTreeWalk(ast) { }
    afterTreeWalk(ast, sheet) { }
    onUrl(urlNode) { }
    onAtPage(atPageNode) { }
    onRule(ruleNode) { }
    onDeclaration(declarationNode, ruleNode) { }
    onContent(contentNode, declarationNode, ruleNode) { }
    // Layout hooks
    layoutNode(node) { }
    renderNode(node, sourceNode, layout) { }
    onOverflow(overflow, rendered, bounds) { }
    onBreakToken(breakToken, overflow, rendered) { }
    afterOverflowRemoved(removed, rendered) { }
    beforeRenderResult(breakToken, pageWrapper) { }
}
export class PagedjsManager {
    static instance;
    previewer = null;
    isInitialized = false;
    registeredHandlers = new Set();
    performance = null;
    constructor() { }
    static getInstance() {
        if (!PagedjsManager.instance) {
            PagedjsManager.instance = new PagedjsManager();
        }
        return PagedjsManager.instance;
    }
    registerHandler(handler) {
        if (!this.registeredHandlers.has(handler)) {
            this.registeredHandlers.add(handler);
            if (BROWSER) {
                registerHandlers(handler);
            }
        }
    }
    registerHandlers(handlers) {
        handlers.forEach(handler => this.registerHandler(handler));
    }
    async initialize() {
        if (this.isInitialized || !BROWSER)
            return;
        try {
            this.previewer = new Previewer();
            this.isInitialized = true;
        }
        catch (error) {
            console.error('Failed to initialize PagedjsManager:', error);
            throw error;
        }
    }
    async render(element, options = {}) {
        if (!BROWSER || !this.previewer) {
            throw new Error('PagedjsManager not properly initialized');
        }
        try {
            // Start performance tracking
            const startTime = performance.now();
            const startDate = new Date().toISOString();
            // Register handlers
            if (options.handlers) {
                this.registerHandlers(options.handlers);
            }
            // Render content
            const flow = await this.previewer.preview(element, options.cssFiles || [], document.body);
            // Record performance metrics
            const endTime = performance.now();
            this.performance = {
                totalPages: flow.total,
                renderTime: endTime - startTime,
                initiated: startDate,
                completed: new Date().toISOString()
            };
        }
        catch (error) {
            console.error('Error rendering paged content:', error);
            throw error;
        }
    }
    getPerformanceMetrics() {
        return this.performance;
    }
    cleanup() {
        if (!BROWSER)
            return;
        this.registeredHandlers.clear();
        this.previewer = null;
        this.isInitialized = false;
        this.performance = null;
    }
    isReady() {
        return this.isInitialized && !!this.previewer;
    }
}
export const manager = PagedjsManager.getInstance();