npm - manifest-label-print - Versions diffs - 0.1.1 - Mend

manifest-label-print 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +76 -0
package/dist/adapters/browser.d.ts +6 -0
package/dist/adapters/browser.js +117 -0
package/dist/adapters/clodop.d.ts +6 -0
package/dist/adapters/clodop.js +227 -0
package/dist/capture.d.ts +1 -0
package/dist/capture.js +22 -0
package/dist/config.d.ts +7 -0
package/dist/config.js +72 -0
package/dist/index.d.ts +6 -0
package/dist/index.js +5 -0
package/dist/mapper.d.ts +9 -0
package/dist/mapper.js +58 -0
package/dist/service.d.ts +4 -0
package/dist/service.js +31 -0
package/dist/types.d.ts +50 -0
package/dist/types.js +1 -0
package/package.json +26 -0

package/README.md ADDED Viewed

@@ -0,0 +1,76 @@
+# manifest-label-print
+Reusable label print module for `manifest-design`.
+## Install
+```bash
+npm i manifest-label-print
+```
+## Features
+- Template normalization (`components/canvasConfig`, legacy `data`, array input)
+- Print engine abstraction (`browser` and `clodop`)
+- Engine preference storage with legacy key migration
+- Browser engine prints canvas snapshot (`target` is required)
+- Print mode applies to CLodop engine (`native` falls back to `image` when unsupported)
+## Quick Start
+```ts
+import {
+  toPrintTemplate,
+  executePrint,
+  getPreferredPrintEngine,
+  setPreferredPrintEngine,
+  setPreferredPrintMode
+} from 'manifest-label-print'
+const input = {
+  components: [],
+  canvasConfig: { width: 60, height: 40, unit: 'mm' }
+}
+const template = toPrintTemplate(input)
+const printTarget = document.querySelector('.preview-canvas') as HTMLElement | null
+setPreferredPrintEngine('browser')
+setPreferredPrintMode('image')
+await executePrint(template, {
+  engine: getPreferredPrintEngine(),
+  target: printTarget
+})
+```
+## API
+- `toPrintTemplate(input)`:
+  Normalize `components/canvasConfig`, legacy `{ data }`, or component-array inputs.
+- `executePrint(template, options)`:
+  Execute print by selected engine and fallback to browser print when needed.
+- `getPreferredPrintEngine()` / `setPreferredPrintEngine(engine)`:
+  Read/write print engine preference with legacy key migration support.
+- `getPreferredPrintMode()` / `setPreferredPrintMode(mode)`:
+  Read/write print mode preference with legacy key migration support.
+- `BrowserPrintAdapter` / `ClodopPrintAdapter`:
+  Built-in engine adapters.
+## Behavior Notes
+- Browser engine always uses snapshot printing and requires `options.target`.
+- Print mode (`image` / `native`) is used by CLodop engine.
+- If CLodop native mode cannot render a template, it automatically falls back to image mode.
+## Build
+```bash
+npm run build
+```
+## Release
+```bash
+npm version patch
+npm publish --access public
+```

package/dist/adapters/browser.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import type { PrintAdapter, PrintJobOptions, PrintJobResult, PrintTemplate } from '../types';
+export declare class BrowserPrintAdapter implements PrintAdapter {
+    readonly engine: "browser";
+    isAvailable(): boolean;
+    print(_template: PrintTemplate, options: PrintJobOptions): Promise<PrintJobResult>;
+}

package/dist/adapters/browser.js ADDED Viewed

@@ -0,0 +1,117 @@
+import { capturePrintTarget } from '../capture';
+const createPrintFrame = () => {
+    const iframe = document.createElement('iframe');
+    iframe.setAttribute('aria-hidden', 'true');
+    iframe.style.position = 'fixed';
+    iframe.style.right = '0';
+    iframe.style.bottom = '0';
+    iframe.style.width = '0';
+    iframe.style.height = '0';
+    iframe.style.border = '0';
+    document.body.appendChild(iframe);
+    return iframe;
+};
+const cleanupPrintFrame = (iframe) => {
+    window.setTimeout(() => {
+        iframe.remove();
+    }, 1000);
+};
+const printImage = async (dataUrl, width, height, copies) => {
+    const iframe = createPrintFrame();
+    const doc = iframe.contentDocument;
+    if (!doc) {
+        iframe.remove();
+        throw new Error('Print frame is unavailable');
+    }
+    doc.open();
+    doc.write(`
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>Print</title>
+        <style>
+          @page { margin: 0; }
+          html, body {
+            margin: 0;
+            padding: 0;
+            background: #ffffff;
+          }
+          body {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+          }
+          img {
+            display: block;
+            width: ${width};
+            height: ${height};
+            object-fit: contain;
+          }
+        </style>
+      </head>
+      <body>
+        <img src="${dataUrl}" alt="print-target" />
+      </body>
+    </html>
+  `);
+    doc.close();
+    await new Promise((resolve) => {
+        const image = doc.querySelector('img');
+        if (!image) {
+            resolve();
+            return;
+        }
+        image.addEventListener('load', () => resolve(), { once: true });
+        image.addEventListener('error', () => resolve(), { once: true });
+    });
+    const frameWindow = iframe.contentWindow;
+    if (!frameWindow) {
+        iframe.remove();
+        throw new Error('Print frame window is unavailable');
+    }
+    for (let i = 0; i < copies; i++) {
+        frameWindow.focus();
+        frameWindow.print();
+    }
+    cleanupPrintFrame(iframe);
+};
+export class BrowserPrintAdapter {
+    constructor() {
+        this.engine = 'browser';
+    }
+    isAvailable() {
+        return typeof window !== 'undefined' && typeof window.print === 'function';
+    }
+    async print(_template, options) {
+        if (!this.isAvailable()) {
+            return {
+                success: false,
+                message: 'Browser print is unavailable'
+            };
+        }
+        if (!options.target) {
+            return {
+                success: false,
+                message: 'Print target is missing'
+            };
+        }
+        try {
+            const dataUrl = await capturePrintTarget(options.target);
+            const copies = Math.max(1, options.copies || 1);
+            const unit = _template.canvasConfig.unit || 'mm';
+            const width = `${_template.canvasConfig.width}${unit}`;
+            const height = `${_template.canvasConfig.height}${unit}`;
+            await printImage(dataUrl, width, height, copies);
+            return {
+                success: true
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Browser print failed',
+                error
+            };
+        }
+    }
+}

package/dist/adapters/clodop.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import type { PrintAdapter, PrintJobOptions, PrintJobResult, PrintTemplate } from '../types';
+export declare class ClodopPrintAdapter implements PrintAdapter {
+    readonly engine: "clodop";
+    isAvailable(): boolean;
+    print(template: PrintTemplate, options: PrintJobOptions): Promise<PrintJobResult>;
+}

package/dist/adapters/clodop.js ADDED Viewed

@@ -0,0 +1,227 @@
+import { capturePrintTarget } from '../capture';
+const getLodopInstance = () => {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    const lodopWindow = window;
+    if (lodopWindow.CLODOP) {
+        return lodopWindow.CLODOP;
+    }
+    if (typeof lodopWindow.getCLodop === 'function') {
+        try {
+            return lodopWindow.getCLodop() || null;
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    return null;
+};
+const mmToClodop01mm = (value) => {
+    return Math.round(value * 10);
+};
+const mmToPoints = (value) => {
+    return Math.max(1, Math.round(value * 2.83465));
+};
+const toNumber = (value, fallback = 0) => {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+};
+const toStringValue = (value, fallback = '') => {
+    return typeof value === 'string' ? value : fallback;
+};
+const isVisible = (component) => {
+    return component.visible !== false;
+};
+const supportsNativeMode = (template) => {
+    return template.components.every((component) => {
+        const type = component.type || '';
+        const rotation = toNumber(component.rotation, 0);
+        const opacity = toNumber(component.opacity, 1);
+        if (!isVisible(component) || rotation !== 0 || opacity !== 1) {
+            return false;
+        }
+        switch (type) {
+            case 'text':
+            case 'barcode':
+            case 'qrcode':
+            case 'horizontal-line':
+            case 'vertical-line':
+            case 'rectangle':
+                return true;
+            case 'image':
+                return typeof component.src === 'string' && component.src.length > 0;
+            default:
+                return false;
+        }
+    });
+};
+const setupPageSize = (lodop, template) => {
+    const pageWidth = mmToClodop01mm(template.canvasConfig.width);
+    const pageHeight = mmToClodop01mm(template.canvasConfig.height);
+    if (lodop.SET_PRINT_PAGESIZE) {
+        lodop.SET_PRINT_PAGESIZE(1, pageWidth, pageHeight, '');
+    }
+    if (lodop.SET_PRINT_STYLEA) {
+        lodop.SET_PRINT_STYLEA(0, 'PageWidth', pageWidth);
+        lodop.SET_PRINT_STYLEA(0, 'PageHeight', pageHeight);
+    }
+    return { pageWidth, pageHeight };
+};
+const executePrintTask = (lodop, options) => {
+    if (options.preview && lodop.PREVIEW) {
+        lodop.PREVIEW();
+    }
+    else if (lodop.PRINT) {
+        lodop.PRINT();
+    }
+};
+const applyTextStyles = (lodop, itemIndex, component) => {
+    if (!lodop.SET_PRINT_STYLEA) {
+        return;
+    }
+    lodop.SET_PRINT_STYLEA(itemIndex, 'FontSize', mmToPoints(toNumber(component.fontSize, 3)));
+    const fontFamily = toStringValue(component.fontFamily);
+    if (fontFamily) {
+        lodop.SET_PRINT_STYLEA(itemIndex, 'FontName', fontFamily);
+    }
+    const color = toStringValue(component.color);
+    if (color) {
+        lodop.SET_PRINT_STYLEA(itemIndex, 'FontColor', color);
+    }
+    const fontWeight = toStringValue(component.fontWeight);
+    if (fontWeight.toLowerCase() === 'bold') {
+        lodop.SET_PRINT_STYLEA(itemIndex, 'Bold', 1);
+    }
+    const textAlign = toStringValue(component.textAlign, 'left');
+    const alignMap = {
+        left: 1,
+        center: 2,
+        right: 3
+    };
+    lodop.SET_PRINT_STYLEA(itemIndex, 'Alignment', alignMap[textAlign] || 1);
+};
+const renderNativeComponent = (lodop, component, itemIndex) => {
+    const type = component.type || '';
+    const top = mmToClodop01mm(toNumber(component.y));
+    const left = mmToClodop01mm(toNumber(component.x));
+    const width = mmToClodop01mm(toNumber(component.width));
+    const height = mmToClodop01mm(toNumber(component.height));
+    switch (type) {
+        case 'text': {
+            lodop.ADD_PRINT_TEXT?.(top, left, width, height, toStringValue(component.content));
+            applyTextStyles(lodop, itemIndex, component);
+            return;
+        }
+        case 'barcode': {
+            lodop.ADD_PRINT_BARCODE?.(top, left, width, height, toStringValue(component.format, 'Code128'), toStringValue(component.content));
+            if (lodop.SET_PRINT_STYLEA && component.displayValue === false) {
+                lodop.SET_PRINT_STYLEA(itemIndex, 'ShowBarText', 0);
+            }
+            return;
+        }
+        case 'qrcode': {
+            lodop.ADD_PRINT_BARCODE?.(top, left, width, height, 'QRCode', toStringValue(component.content));
+            if (lodop.SET_PRINT_STYLEA) {
+                const errorLevel = toStringValue(component.errorCorrectionLevel, 'M');
+                lodop.SET_PRINT_STYLEA(itemIndex, 'QRCodeErrorLevel', errorLevel);
+            }
+            return;
+        }
+        case 'horizontal-line': {
+            const strokeWidth = Math.max(1, mmToClodop01mm(toNumber(component.strokeWidth, 0.2)));
+            lodop.ADD_PRINT_LINE?.(top, left, top, left + width, strokeWidth, 0);
+            return;
+        }
+        case 'vertical-line': {
+            const strokeWidth = Math.max(1, mmToClodop01mm(toNumber(component.strokeWidth, 0.2)));
+            lodop.ADD_PRINT_LINE?.(top, left, top + height, left, strokeWidth, 0);
+            return;
+        }
+        case 'rectangle': {
+            const strokeWidth = Math.max(1, mmToClodop01mm(toNumber(component.strokeWidth, 0.2)));
+            lodop.ADD_PRINT_RECT?.(top, left, width, height, strokeWidth, 0);
+            return;
+        }
+        case 'image': {
+            lodop.ADD_PRINT_IMAGE?.(top, left, width, height, toStringValue(component.src));
+            if (lodop.SET_PRINT_STYLEA) {
+                lodop.SET_PRINT_STYLEA(itemIndex, 'Stretch', 2);
+            }
+            return;
+        }
+    }
+};
+export class ClodopPrintAdapter {
+    constructor() {
+        this.engine = 'clodop';
+    }
+    isAvailable() {
+        return getLodopInstance() !== null;
+    }
+    async print(template, options) {
+        const lodop = getLodopInstance();
+        if (!lodop) {
+            return {
+                success: false,
+                message: 'CLodop is unavailable'
+            };
+        }
+        try {
+            const mode = options.mode || 'image';
+            const canUseNativeMode = mode === 'native' && supportsNativeMode(template);
+            lodop.PRINT_INIT(`manifest-label-print-${Date.now()}`);
+            setupPageSize(lodop, template);
+            if (options.printerName && lodop.SET_PRINTER_INDEXA) {
+                lodop.SET_PRINTER_INDEXA(options.printerName);
+            }
+            if (canUseNativeMode) {
+                let itemIndex = 1;
+                for (const component of template.components) {
+                    if (!isVisible(component)) {
+                        continue;
+                    }
+                    renderNativeComponent(lodop, component, itemIndex);
+                    itemIndex += 1;
+                }
+                executePrintTask(lodop, options);
+                return {
+                    success: true,
+                    message: 'Printed with CLodop native mode'
+                };
+            }
+            if (!options.target) {
+                return {
+                    success: false,
+                    message: 'Print target is missing'
+                };
+            }
+            if (!lodop.ADD_PRINT_IMAGE) {
+                return {
+                    success: false,
+                    message: 'CLodop image printing is unavailable'
+                };
+            }
+            const dataUrl = await capturePrintTarget(options.target);
+            const pageWidth = mmToClodop01mm(template.canvasConfig.width);
+            const pageHeight = mmToClodop01mm(template.canvasConfig.height);
+            lodop.ADD_PRINT_IMAGE(0, 0, pageWidth, pageHeight, dataUrl);
+            if (lodop.SET_PRINT_STYLEA) {
+                lodop.SET_PRINT_STYLEA(1, 'Stretch', 2);
+            }
+            executePrintTask(lodop, options);
+            return {
+                success: true,
+                message: mode === 'native'
+                    ? 'Native mode fallback to image mode'
+                    : 'Printed with CLodop image mode'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'CLodop print failed',
+                error
+            };
+        }
+    }
+}

package/dist/capture.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export declare const capturePrintTarget: (target: HTMLElement) => Promise<string>;

package/dist/capture.js ADDED Viewed

@@ -0,0 +1,22 @@
+import html2canvas from 'html2canvas';
+const DEFAULT_IGNORED_SELECTORS = [
+    '.grid-background',
+    '.selection-handles',
+    '.selection-box',
+    '.snap-guide',
+    '.multi-selection-area',
+    '.context-menu-overlay'
+];
+const shouldIgnoreElement = (element) => {
+    return DEFAULT_IGNORED_SELECTORS.some((selector) => element.matches(selector));
+};
+export const capturePrintTarget = async (target) => {
+    const canvas = await html2canvas(target, {
+        backgroundColor: '#ffffff',
+        scale: 2,
+        useCORS: true,
+        logging: false,
+        ignoreElements: (element) => shouldIgnoreElement(element)
+    });
+    return canvas.toDataURL('image/png');
+};

package/dist/config.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { PrintEngine, PrintMode } from './types';
+export declare const getStoredPrintEngine: () => PrintEngine | null;
+export declare const getPreferredPrintEngine: () => PrintEngine;
+export declare const setPreferredPrintEngine: (engine: PrintEngine) => void;
+export declare const getStoredPrintMode: () => PrintMode | null;
+export declare const getPreferredPrintMode: () => PrintMode;
+export declare const setPreferredPrintMode: (mode: PrintMode) => void;

package/dist/config.js ADDED Viewed

@@ -0,0 +1,72 @@
+const PRINT_ENGINE_STORAGE_KEY = 'manifest-print-engine';
+const PRINT_MODE_STORAGE_KEY = 'manifest-print-mode';
+const LEGACY_ENGINE_STORAGE_KEYS = ['print_engine', 'label_print_engine'];
+const LEGACY_MODE_STORAGE_KEYS = ['print_mode', 'label_print_mode'];
+const isPrintEngine = (value) => {
+    return value === 'browser' || value === 'clodop';
+};
+const isPrintMode = (value) => {
+    return value === 'image' || value === 'native';
+};
+const readStorageValue = (key) => {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    try {
+        return window.localStorage.getItem(key);
+    }
+    catch (_error) {
+        return null;
+    }
+};
+const writeStorageValue = (key, value) => {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    try {
+        window.localStorage.setItem(key, value);
+    }
+    catch (_error) {
+        // Ignore localStorage unavailable scenarios.
+    }
+};
+export const getStoredPrintEngine = () => {
+    const primary = readStorageValue(PRINT_ENGINE_STORAGE_KEY);
+    if (isPrintEngine(primary)) {
+        return primary;
+    }
+    for (const key of LEGACY_ENGINE_STORAGE_KEYS) {
+        const legacyValue = readStorageValue(key);
+        if (isPrintEngine(legacyValue)) {
+            writeStorageValue(PRINT_ENGINE_STORAGE_KEY, legacyValue);
+            return legacyValue;
+        }
+    }
+    return null;
+};
+export const getPreferredPrintEngine = () => {
+    return getStoredPrintEngine() || 'browser';
+};
+export const setPreferredPrintEngine = (engine) => {
+    writeStorageValue(PRINT_ENGINE_STORAGE_KEY, engine);
+};
+export const getStoredPrintMode = () => {
+    const primary = readStorageValue(PRINT_MODE_STORAGE_KEY);
+    if (isPrintMode(primary)) {
+        return primary;
+    }
+    for (const key of LEGACY_MODE_STORAGE_KEYS) {
+        const legacyValue = readStorageValue(key);
+        if (isPrintMode(legacyValue)) {
+            writeStorageValue(PRINT_MODE_STORAGE_KEY, legacyValue);
+            return legacyValue;
+        }
+    }
+    return null;
+};
+export const getPreferredPrintMode = () => {
+    return getStoredPrintMode() || 'image';
+};
+export const setPreferredPrintMode = (mode) => {
+    writeStorageValue(PRINT_MODE_STORAGE_KEY, mode);
+};

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export type { DesignTemplateSnapshot, PrintAdapter, PrintCanvasConfig, PrintComponent, PrintEngine, PrintMode, PrintJobOptions, PrintJobResult, PrintTemplate } from './types';
+export { normalizeTemplateInput, toPrintTemplate } from './mapper';
+export { BrowserPrintAdapter } from './adapters/browser';
+export { ClodopPrintAdapter } from './adapters/clodop';
+export { executePrint, getDefaultPrintAdapters, resolvePrintAdapter } from './service';
+export { getPreferredPrintEngine, getPreferredPrintMode, getStoredPrintEngine, getStoredPrintMode, setPreferredPrintEngine, setPreferredPrintMode } from './config';

package/dist/index.js ADDED Viewed

@@ -0,0 +1,5 @@
+export { normalizeTemplateInput, toPrintTemplate } from './mapper';
+export { BrowserPrintAdapter } from './adapters/browser';
+export { ClodopPrintAdapter } from './adapters/clodop';
+export { executePrint, getDefaultPrintAdapters, resolvePrintAdapter } from './service';
+export { getPreferredPrintEngine, getPreferredPrintMode, getStoredPrintEngine, getStoredPrintMode, setPreferredPrintEngine, setPreferredPrintMode } from './config';

package/dist/mapper.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import type { DesignTemplateSnapshot, PrintCanvasConfig, PrintComponent, PrintTemplate } from './types';
+type LegacyTemplateInput = DesignTemplateSnapshot | {
+    data?: unknown;
+    components?: unknown;
+    canvasConfig?: Partial<PrintCanvasConfig>;
+} | PrintComponent[];
+export declare const normalizeTemplateInput: (input: LegacyTemplateInput) => DesignTemplateSnapshot;
+export declare const toPrintTemplate: (input: LegacyTemplateInput) => PrintTemplate;
+export {};

package/dist/mapper.js ADDED Viewed

@@ -0,0 +1,58 @@
+const defaultCanvasConfig = {
+    width: 60,
+    height: 40,
+    unit: 'mm',
+    zoom: 1,
+    showGrid: true,
+    showRuler: true,
+    showGuides: true
+};
+const deepClone = (value) => JSON.parse(JSON.stringify(value));
+const asComponents = (value) => {
+    return Array.isArray(value) ? value : [];
+};
+export const normalizeTemplateInput = (input) => {
+    if (Array.isArray(input)) {
+        return {
+            components: deepClone(input),
+            canvasConfig: deepClone(defaultCanvasConfig)
+        };
+    }
+    if ('components' in input && 'canvasConfig' in input && Array.isArray(input.components)) {
+        return {
+            components: deepClone(asComponents(input.components)),
+            canvasConfig: {
+                ...defaultCanvasConfig,
+                ...(input.canvasConfig || {}),
+                unit: input.canvasConfig?.unit || 'mm'
+            }
+        };
+    }
+    if ('data' in input && Array.isArray(input.data)) {
+        return {
+            components: deepClone(asComponents(input.data)),
+            canvasConfig: {
+                ...defaultCanvasConfig,
+                ...(input.canvasConfig || {}),
+                unit: input.canvasConfig?.unit || 'mm'
+            }
+        };
+    }
+    return {
+        components: [],
+        canvasConfig: deepClone(defaultCanvasConfig)
+    };
+};
+export const toPrintTemplate = (input) => {
+    const normalized = normalizeTemplateInput(input);
+    return {
+        schemaVersion: '1.0',
+        source: 'manifest-design',
+        components: deepClone(normalized.components),
+        canvasConfig: {
+            ...deepClone(defaultCanvasConfig),
+            ...deepClone(normalized.canvasConfig),
+            unit: normalized.canvasConfig.unit || 'mm'
+        }
+    };
+};

package/dist/service.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import type { PrintAdapter, PrintEngine, PrintJobOptions, PrintJobResult, PrintTemplate } from './types';
+export declare const resolvePrintAdapter: (engine: PrintEngine, adapters?: PrintAdapter[], fallbackToBrowser?: boolean) => Promise<PrintAdapter | null>;
+export declare const executePrint: (template: PrintTemplate, options: PrintJobOptions, adapters?: PrintAdapter[]) => Promise<PrintJobResult>;
+export declare const getDefaultPrintAdapters: () => PrintAdapter[];

package/dist/service.js ADDED Viewed

@@ -0,0 +1,31 @@
+import { BrowserPrintAdapter } from './adapters/browser';
+import { ClodopPrintAdapter } from './adapters/clodop';
+const defaultAdapters = [new BrowserPrintAdapter(), new ClodopPrintAdapter()];
+const getAdapterByEngine = (adapters, engine) => {
+    return adapters.find((adapter) => adapter.engine === engine);
+};
+export const resolvePrintAdapter = async (engine, adapters = defaultAdapters, fallbackToBrowser = true) => {
+    const target = getAdapterByEngine(adapters, engine);
+    if (target && (await target.isAvailable())) {
+        return target;
+    }
+    if (!fallbackToBrowser || engine === 'clodop') {
+        return null;
+    }
+    const browser = getAdapterByEngine(adapters, 'browser');
+    if (browser && (await browser.isAvailable())) {
+        return browser;
+    }
+    return null;
+};
+export const executePrint = async (template, options, adapters = defaultAdapters) => {
+    const adapter = await resolvePrintAdapter(options.engine, adapters, options.fallbackToBrowser ?? options.engine === 'browser');
+    if (!adapter) {
+        return {
+            success: false,
+            message: `${options.engine} print engine is unavailable`
+        };
+    }
+    return adapter.print(template, options);
+};
+export const getDefaultPrintAdapters = () => defaultAdapters;

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,50 @@
+export type PrintEngine = 'browser' | 'clodop';
+export type PrintMode = 'image' | 'native';
+export interface PrintComponent {
+    id?: string;
+    type?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    [key: string]: unknown;
+}
+export interface PrintCanvasConfig {
+    width: number;
+    height: number;
+    unit: string;
+    zoom?: number;
+    showGrid?: boolean;
+    showRuler?: boolean;
+    showGuides?: boolean;
+    [key: string]: unknown;
+}
+export interface DesignTemplateSnapshot {
+    components: PrintComponent[];
+    canvasConfig: PrintCanvasConfig;
+}
+export interface PrintTemplate {
+    schemaVersion: '1.0';
+    source: string;
+    components: PrintComponent[];
+    canvasConfig: PrintCanvasConfig;
+}
+export interface PrintJobOptions {
+    engine: PrintEngine;
+    mode?: PrintMode;
+    copies?: number;
+    preview?: boolean;
+    printerName?: string;
+    target?: HTMLElement | null;
+    fallbackToBrowser?: boolean;
+}
+export interface PrintJobResult {
+    success: boolean;
+    message?: string;
+    error?: unknown;
+}
+export interface PrintAdapter {
+    readonly engine: PrintEngine;
+    isAvailable: () => boolean | Promise<boolean>;
+    print: (template: PrintTemplate, options: PrintJobOptions) => Promise<PrintJobResult>;
+}

package/dist/types.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/package.json ADDED Viewed

@@ -0,0 +1,26 @@
+{
+  "name": "manifest-label-print",
+  "version": "0.1.1",
+  "description": "Label print engine adapters and template mapper for manifest-design",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "html2canvas": "^1.4.1"
+  }
+}