@thermal-print/escpos 0.1.0

package/dist/styles.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextStyle = extractTextStyle;
+exports.extractViewStyle = extractViewStyle;
+exports.isBold = isBold;
+exports.mapFontSizeToESCPOS = mapFontSizeToESCPOS;
+exports.mapTextAlign = mapTextAlign;
+exports.calculateSpacing = calculateSpacing;
+exports.isDashedBorder = isDashedBorder;
+exports.generateDividerLine = generateDividerLine;
+exports.mergeStyles = mergeStyles;
+exports.parseWidth = parseWidth;
+exports.alignTextInColumn = alignTextInColumn;
+exports.wrapText = wrapText;
+const cp860_1 = require("./encodings/cp860");
+/**
+ * Extracts text style from a style object
+ */
+function extractTextStyle(style) {
+    return {
+        fontSize: style?.fontSize,
+        fontWeight: style?.fontWeight,
+        fontFamily: style?.fontFamily,
+        textAlign: style?.textAlign || "left",
+    };
+}
+/**
+ * Extracts view/layout style from a style object
+ */
+function extractViewStyle(style) {
+    return {
+        display: style?.display,
+        flexDirection: style?.flexDirection || "column",
+        justifyContent: style?.justifyContent,
+        alignItems: style?.alignItems,
+        padding: style?.padding,
+        paddingTop: style?.paddingTop,
+        paddingBottom: style?.paddingBottom,
+        paddingLeft: style?.paddingLeft,
+        paddingRight: style?.paddingRight,
+        margin: style?.margin,
+        marginTop: style?.marginTop,
+        marginBottom: style?.marginBottom,
+        marginLeft: style?.marginLeft,
+        marginRight: style?.marginRight,
+        borderBottom: style?.borderBottom,
+        borderTop: style?.borderTop,
+        width: style?.width,
+    };
+}
+/**
+ * Determines if text should be bold
+ */
+function isBold(style) {
+    return (style.fontWeight === "bold" ||
+        style.fontWeight === 700 ||
+        style.fontWeight === "Helvetica-Bold" ||
+        style.fontFamily === "Helvetica-Bold");
+}
+/**
+ * Maps fontSize to ESC/POS character size (width x height multipliers)
+ *
+ * Font size mapping using ESC ! command (limited to 2x2 maximum):
+ * - 8-12px  → 1x1 (normal)
+ * - 13-18px → 1x2 (normal width, double height)
+ * - 19-24px → 2x1 (double width, normal height)
+ * - 25+px   → 2x2 (double width, double height)
+ *
+ * Note: ESC ! command only supports up to 2x2 character size.
+ * Larger sizes (3x, 4x, etc.) would require GS ! command which may not
+ * be supported on all thermal printers (e.g., Bematech MP-4200 TH).
+ *
+ * PDF uses zoom factor (default 0.46), so actual sizes are smaller:
+ * - 16 * 0.46 = 7.36 (normal text)
+ * - 18 * 0.46 = 8.28 (medium text)
+ * - 20 * 0.46 = 9.2 (title text)
+ *
+ * We use raw fontSize values (ignoring zoom) for better differentiation
+ */
+function mapFontSizeToESCPOS(fontSize) {
+    // Default to 1x1 (normal size)
+    if (!fontSize)
+        return { width: 1, height: 1 };
+    // Parse fontSize if it's a string (e.g., "8.28px")
+    const size = typeof fontSize === "string" ? parseFloat(fontSize) : fontSize;
+    if (isNaN(size))
+        return { width: 1, height: 1 };
+    // Map font size to character multipliers (max 2x2 for ESC ! compatibility)
+    if (size >= 25)
+        return { width: 2, height: 2 }; // 25+px → 2x2 (maximum)
+    if (size >= 19)
+        return { width: 2, height: 1 }; // 19-24px → 2x1
+    if (size >= 13)
+        return { width: 1, height: 2 }; // 13-18px → 1x2
+    return { width: 1, height: 1 }; // 8-12px → 1x1 (normal)
+}
+/**
+ * Maps textAlign to ESC/POS alignment
+ */
+function mapTextAlign(textAlign) {
+    if (textAlign === "center")
+        return "center";
+    if (textAlign === "right")
+        return "right";
+    return "left";
+}
+/**
+ * Calculates spacing (margin/padding) in lines
+ * Approximates pixels to line feeds
+ */
+function calculateSpacing(value) {
+    if (!value)
+        return 0;
+    // Rough approximation: ~20 pixels = 1 line feed
+    return Math.round(value / 20);
+}
+/**
+ * Determines if a border is dashed
+ */
+function isDashedBorder(border) {
+    return border?.includes("dashed") ?? false;
+}
+/**
+ * Generates a divider line based on border style
+ */
+function generateDividerLine(width, dashed = false) {
+    const char = dashed ? "-" : "─";
+    return char.repeat(width);
+}
+/**
+ * Merges multiple style objects (handles spread syntax)
+ */
+function mergeStyles(...styles) {
+    return Object.assign({}, ...styles.filter((s) => s));
+}
+/**
+ * Parses width percentage to column width in characters
+ * Uses Math.round() to minimize rounding errors
+ */
+function parseWidth(width, totalWidth) {
+    if (!width)
+        return totalWidth;
+    if (typeof width === "number")
+        return width;
+    if (typeof width === "string") {
+        if (width.includes("%")) {
+            const percentage = parseInt(width.replace("%", ""));
+            return Math.round((percentage / 100) * totalWidth);
+        }
+    }
+    return totalWidth;
+}
+/**
+ * Aligns text within a column width (using CP860 byte length for accurate padding)
+ */
+function alignTextInColumn(text, width, align) {
+    // Get actual byte length when encoded to CP860
+    let encodedLength = (0, cp860_1.encodeCP860)(text).length;
+    let truncatedText = text;
+    // Truncate if too long (character by character until it fits)
+    while (encodedLength > width && truncatedText.length > 0) {
+        truncatedText = truncatedText.substring(0, truncatedText.length - 1);
+        encodedLength = (0, cp860_1.encodeCP860)(truncatedText).length;
+    }
+    // Calculate padding based on actual encoded byte length
+    const padding = width - encodedLength;
+    // Already fits perfectly
+    if (padding === 0) {
+        return truncatedText;
+    }
+    // Pad based on alignment
+    if (align === "right") {
+        return " ".repeat(padding) + truncatedText;
+    }
+    else if (align === "center") {
+        const leftPad = Math.floor(padding / 2);
+        const rightPad = padding - leftPad;
+        return " ".repeat(leftPad) + truncatedText + " ".repeat(rightPad);
+    }
+    else {
+        // left align
+        return truncatedText + " ".repeat(padding);
+    }
+}
+/**
+ * Splits text into multiple lines if it exceeds width
+ */
+function wrapText(text, width) {
+    if (text.length <= width) {
+        return [text];
+    }
+    const lines = [];
+    let currentLine = "";
+    const words = text.split(" ");
+    for (const word of words) {
+        if ((currentLine + " " + word).trim().length <= width) {
+            currentLine = (currentLine + " " + word).trim();
+        }
+        else {
+            if (currentLine) {
+                lines.push(currentLine);
+            }
+            currentLine = word;
+        }
+    }
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    return lines.length > 0 ? lines : [text.substring(0, width)];
+}

package/dist/traverser.d.ts

@@ -0,0 +1,60 @@
+import { ElementNode } from "@thermal-print/core";
+import { ESCPOSGenerator } from "./generator";
+/**
+ * Tree Traverser
+ * Walks through the element tree and generates ESC/POS commands
+ */
+export declare class TreeTraverser {
+    private generator;
+    constructor(generator: ESCPOSGenerator);
+    /**
+     * Traverse the entire tree starting from root
+     */
+    traverse(node: ElementNode | null): Promise<void>;
+    /**
+     * Handle Document element
+     */
+    private handleDocument;
+    /**
+     * Handle Page element
+     */
+    private handlePage;
+    /**
+     * Handle View element (container with layout)
+     */
+    private handleView;
+    /**
+     * Handle column layout (stacked vertically)
+     * Adds newlines between sibling elements for proper spacing
+     */
+    private handleColumnLayout;
+    /**
+     * Handle row layout (side-by-side columns)
+     */
+    private handleRowLayout;
+    /**
+     * Find the first Text node in a tree
+     */
+    private findFirstTextNode;
+    /**
+     * Collect text content from a node and its children
+     */
+    private collectTextContent;
+    /**
+     * Handle Text element
+     */
+    private handleText;
+    /**
+     * Handle TextNode (raw text)
+     */
+    private handleTextNode;
+    /**
+     * Handle Image element
+     */
+    private handleImage;
+    /**
+     * Traverse children nodes
+     */
+    private traverseChildren;
+}
+//# sourceMappingURL=traverser.d.ts.map

package/dist/traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverser.d.ts","sourceRoot":"","sources":["../src/traverser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAkB;gBAEvB,SAAS,EAAE,eAAe;IAItC;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BvD;;OAEG;YACW,cAAc;IAO5B;;OAEG;YACW,UAAU;IAIxB;;OAEG;YACW,UAAU;IAkBxB;;;OAGG;YACW,kBAAkB;IAchC;;OAEG;YACW,eAAe;IA+F7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,kBAAkB;IAmBhC;;OAEG;YACW,UAAU;IAgCxB;;OAEG;YACW,cAAc;IAM5B;;OAEG;YACW,WAAW;IA+BzB;;OAEG;YACW,gBAAgB;CAK/B"}

package/dist/traverser.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeTraverser = void 0;
+const styles_1 = require("./styles");
+/**
+ * Tree Traverser
+ * Walks through the element tree and generates ESC/POS commands
+ */
+class TreeTraverser {
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * Traverse the entire tree starting from root
+     */
+    async traverse(node) {
+        if (!node)
+            return;
+        // Work with lowercase normalized types
+        const nodeType = node.type.toLowerCase();
+        switch (nodeType) {
+            case "document":
+                await this.handleDocument(node);
+                break;
+            case "page":
+                await this.handlePage(node);
+                break;
+            case "view":
+                await this.handleView(node);
+                break;
+            case "text":
+                await this.handleText(node);
+                break;
+            case "textnode":
+                await this.handleTextNode(node);
+                break;
+            case "image":
+                await this.handleImage(node);
+                break;
+            default:
+                // Unknown element, traverse children
+                await this.traverseChildren(node);
+        }
+    }
+    /**
+     * Handle Document element
+     */
+    async handleDocument(node) {
+        this.generator.initialize();
+        await this.traverseChildren(node);
+        // Add 6 blank lines at end for paper feed spacing
+        this.generator.addNewline(2);
+    }
+    /**
+     * Handle Page element
+     */
+    async handlePage(node) {
+        await this.traverseChildren(node);
+    }
+    /**
+     * Handle View element (container with layout)
+     */
+    async handleView(node) {
+        const viewStyle = (0, styles_1.extractViewStyle)(node.style);
+        // Apply spacing before
+        this.generator.applyViewSpacing(node.style, "before");
+        // Handle different layout modes
+        if (viewStyle.flexDirection === "row") {
+            await this.handleRowLayout(node);
+        }
+        else {
+            // Column layout (default) - add spacing between children
+            await this.handleColumnLayout(node);
+        }
+        // Apply spacing after
+        this.generator.applyViewSpacing(node.style, "after");
+    }
+    /**
+     * Handle column layout (stacked vertically)
+     * Adds newlines between sibling elements for proper spacing
+     */
+    async handleColumnLayout(node) {
+        const children = node.children;
+        for (let i = 0; i < children.length; i++) {
+            await this.traverse(children[i]);
+            // Add newline after each child except the last one
+            // This ensures proper spacing between elements in column layout
+            // if (i < children.length - 1 && children[i].type.toLowerCase() === "view") {
+            //   this.generator.addNewline();
+            // }
+        }
+    }
+    /**
+     * Handle row layout (side-by-side columns)
+     */
+    async handleRowLayout(node) {
+        const children = node.children;
+        if (children.length === 0)
+            return;
+        // If there's only 1 child, just render it normally (not as a row)
+        // This prevents nested column layouts from being flattened
+        if (children.length === 1) {
+            await this.traverse(children[0]);
+            return;
+        }
+        const viewStyle = (0, styles_1.extractViewStyle)(node.style);
+        const paperWidth = this.generator.getPaperWidth();
+        // Check layout justification mode
+        const isSpaceBetween = viewStyle.justifyContent === "space-between";
+        const isCentered = viewStyle.justifyContent === "center";
+        // Calculate column widths
+        const columns = [];
+        for (const child of children) {
+            const childStyle = (0, styles_1.extractViewStyle)(child.style);
+            const width = (0, styles_1.parseWidth)(childStyle.width, paperWidth);
+            // Collect text content from child
+            const content = await this.collectTextContent(child);
+            // Determine alignment - check for Text node textAlign first
+            let align = "left";
+            // Look for Text element with textAlign
+            const textNode = this.findFirstTextNode(child);
+            if (textNode && textNode.style) {
+                const textStyle = (0, styles_1.extractTextStyle)(textNode.style);
+                align = (0, styles_1.mapTextAlign)(textStyle.textAlign);
+            }
+            else {
+                // Fall back to View alignment
+                if (childStyle.alignItems === "center" || childStyle.justifyContent === "center") {
+                    align = "center";
+                }
+                else if (childStyle.alignItems === "flex-end" || childStyle.justifyContent === "flex-end") {
+                    align = "right";
+                }
+            }
+            columns.push({ node: child, width, content, align });
+        }
+        // Build row text
+        let rowText = "";
+        // Check if columns have explicit widths (table layout) or should use space-between
+        const hasExplicitWidths = columns.some((col) => {
+            const childStyle = (0, styles_1.extractViewStyle)(col.node.style);
+            return childStyle.width !== undefined;
+        });
+        if (isSpaceBetween && columns.length === 2 && !hasExplicitWidths) {
+            // Special handling for space-between layout (payment summary style) WITHOUT explicit widths
+            // Calculate space between
+            const usedSpace = columns[0].content.length + columns[1].content.length;
+            const gap = Math.max(1, paperWidth - usedSpace);
+            rowText = columns[0].content + " ".repeat(gap) + columns[1].content;
+        }
+        else if (isCentered && !hasExplicitWidths) {
+            // Center the entire row on the paper by calculating total content width
+            // and adding leading spaces
+            // Add spacing between columns (1 space per gap)
+            const spacingBetweenColumns = Math.max(0, columns.length - 1);
+            const totalContentWidth = columns.reduce((sum, col) => sum + col.content.length, 0) + spacingBetweenColumns;
+            // Calculate leading spaces to center the entire row
+            const leadingSpaces = Math.max(0, Math.floor((paperWidth - totalContentWidth) / 2));
+            // Build row with leading spaces (center entire row)
+            rowText = " ".repeat(leadingSpaces);
+            for (let i = 0; i < columns.length; i++) {
+                if (i > 0) {
+                    rowText += " "; // Add space between columns
+                }
+                rowText += columns[i].content;
+            }
+        }
+        else {
+            // Normal column layout OR space-between with explicit widths (use column padding)
+            for (let i = 0; i < columns.length; i++) {
+                const col = columns[i];
+                const cellText = (0, styles_1.alignTextInColumn)(col.content, col.width, col.align);
+                rowText += cellText;
+            }
+        }
+        this.generator.addText(rowText);
+        this.generator.addNewline();
+    }
+    /**
+     * Find the first Text node in a tree
+     */
+    findFirstTextNode(node) {
+        const normalizedType = node.type.toLowerCase();
+        if (normalizedType === "text") {
+            return node;
+        }
+        for (const child of node.children) {
+            const found = this.findFirstTextNode(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    /**
+     * Collect text content from a node and its children
+     */
+    async collectTextContent(node) {
+        let text = "";
+        const normalizedType = node.type.toLowerCase();
+        if (normalizedType === "text" || normalizedType === "textnode") {
+            // Get text from props.children
+            if (node.props.children !== undefined) {
+                text += String(node.props.children);
+            }
+        }
+        // Recursively collect from children
+        for (const child of node.children) {
+            text += await this.collectTextContent(child);
+        }
+        return text;
+    }
+    /**
+     * Handle Text element
+     */
+    async handleText(node) {
+        // Merge styles from parent if needed
+        const style = (0, styles_1.mergeStyles)(node.style);
+        // Apply text styling (sets alignment, bold, size)
+        this.generator.applyTextStyle(style);
+        // Get text content
+        let textContent = "";
+        // Check props.children first
+        if (node.props.children !== undefined) {
+            if (typeof node.props.children === "string" || typeof node.props.children === "number") {
+                textContent = String(node.props.children);
+            }
+        }
+        // If we have direct text, print it
+        if (textContent) {
+            this.generator.addText(textContent);
+        }
+        // Traverse children (nested Text elements)
+        await this.traverseChildren(node);
+        // Reset formatting after text (especially bold)
+        this.generator.resetFormatting();
+        // Add newline after text element
+        this.generator.addNewline();
+    }
+    /**
+     * Handle TextNode (raw text)
+     */
+    async handleTextNode(node) {
+        if (node.props.children) {
+            this.generator.addText(String(node.props.children));
+        }
+    }
+    /**
+     * Handle Image element
+     */
+    async handleImage(node) {
+        const source = node.props.source || node.props.src;
+        if (source) {
+            // Apply alignment from style (check both node style and parent style)
+            const style = (0, styles_1.mergeStyles)(node.style);
+            const viewStyle = (0, styles_1.extractViewStyle)(style);
+            const textStyle = (0, styles_1.extractTextStyle)(style);
+            // Determine alignment from textAlign or justifyContent
+            let align = "left";
+            if (textStyle.textAlign) {
+                align = (0, styles_1.mapTextAlign)(textStyle.textAlign);
+            }
+            else if (viewStyle.justifyContent === "center" || viewStyle.alignItems === "center") {
+                align = "center";
+            }
+            else if (viewStyle.justifyContent === "flex-end" || viewStyle.alignItems === "flex-end") {
+                align = "right";
+            }
+            // Set alignment before adding image
+            this.generator.setAlign(align);
+            await this.generator.addImage(source);
+            // Reset alignment
+            this.generator.setAlign("left");
+        }
+        this.generator.addNewline();
+    }
+    /**
+     * Traverse children nodes
+     */
+    async traverseChildren(node) {
+        for (const child of node.children) {
+            await this.traverse(child);
+        }
+    }
+}
+exports.TreeTraverser = TreeTraverser;

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ESC/POS-specific type definitions
+ */
+export interface ESCPOSCommand {
+    type: 'raw' | 'text' | 'feed' | 'cut' | 'image' | 'qr';
+    data?: any;
+    buffer?: Buffer;
+}
+export interface ConversionContext {
+    paperWidth: number;
+    currentAlign: 'left' | 'center' | 'right';
+    currentSize: {
+        width: number;
+        height: number;
+    };
+    currentBold: boolean;
+    encoding: string;
+    debug: boolean;
+    buffer: Buffer[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC;IACvD,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC1C,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB"}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * ESC/POS-specific type definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@thermal-print/escpos",
+  "version": "0.1.0",
+  "description": "ESC/POS command generation and thermal printer control",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "thermal-printer",
+    "escpos",
+    "receipt-printer",
+    "pos"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@thermal-print/core": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "build:watch": "tsc --build --watch"
+  }
+}