@risleylima/escpos 0.2.0 → 1.0.0

package/dist/printer/index.js

@@ -0,0 +1,703 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Printer = void 0;
+const commands_1 = require("./commands");
+const commands_types_1 = require("./commands-types");
+const profiles_1 = require("./profiles");
+const utils = __importStar(require("./utils"));
+const image_1 = require("./image");
+class SpecBuffer {
+    constructor(maxSize = 10 * 1024 * 1024) {
+        this.currentSize = 0;
+        this.chunks = [];
+        this.maxSize = maxSize;
+    }
+    write(data, type = 'ascii') {
+        const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data, type);
+        if (this.currentSize + chunk.length > this.maxSize) {
+            throw new Error(`Printer buffer overflow: max size of ${this.maxSize} bytes reached.`);
+        }
+        this.chunks.push(chunk);
+        this.currentSize += chunk.length;
+    }
+    prepend(data) {
+        if (data.length === 0)
+            return;
+        this.chunks.unshift(data);
+        this.currentSize += data.length;
+    }
+    flush() {
+        if (this.chunks.length === 0)
+            return Buffer.alloc(0);
+        const data = Buffer.concat(this.chunks);
+        this.chunks = [];
+        this.currentSize = 0;
+        return data;
+    }
+    size() {
+        return this.currentSize;
+    }
+}
+/** Normalize "options or encoding as 3rd/4th param" pattern (DRY for lineItem, total, etc.). */
+function normalizeOptionsEncoding(optionsOrEncoding, encoding) {
+    if (typeof optionsOrEncoding === 'string') {
+        return { encoding: optionsOrEncoding };
+    }
+    return { options: optionsOrEncoding, encoding };
+}
+function buildStyleMap(cmd) {
+    const T = cmd.TEXT_FORMAT;
+    return {
+        B: [T.TXT_BOLD_ON, T.TXT_ITALIC_OFF, T.TXT_UNDERL_OFF],
+        I: [T.TXT_BOLD_OFF, T.TXT_ITALIC_ON, T.TXT_UNDERL_OFF],
+        U: [T.TXT_BOLD_OFF, T.TXT_ITALIC_OFF, T.TXT_UNDERL_ON],
+        U2: [T.TXT_BOLD_OFF, T.TXT_ITALIC_OFF, T.TXT_UNDERL2_ON],
+        BI: [T.TXT_BOLD_ON, T.TXT_ITALIC_ON, T.TXT_UNDERL_OFF],
+        BIU: [T.TXT_BOLD_ON, T.TXT_ITALIC_ON, T.TXT_UNDERL_ON],
+        BIU2: [T.TXT_BOLD_ON, T.TXT_ITALIC_ON, T.TXT_UNDERL2_ON],
+        BU: [T.TXT_BOLD_ON, T.TXT_ITALIC_OFF, T.TXT_UNDERL_OFF],
+        BU2: [T.TXT_BOLD_ON, T.TXT_ITALIC_OFF, T.TXT_UNDERL2_ON],
+        IU: [T.TXT_BOLD_OFF, T.TXT_ITALIC_ON, T.TXT_UNDERL_ON],
+        IU2: [T.TXT_BOLD_OFF, T.TXT_ITALIC_ON, T.TXT_UNDERL2_ON],
+        NORMAL: [T.TXT_BOLD_OFF, T.TXT_ITALIC_OFF, T.TXT_UNDERL_OFF],
+    };
+}
+class Printer {
+    resolveTicketPresentationCommand(options) {
+        if (!this.profile)
+            return undefined;
+        const merged = { ...(this.options?.ticketPresentation ?? {}), ...(options ?? {}) };
+        this.profile.validateTicketPresentationOptions?.(merged);
+        return this.profile.getTicketPresentationCommand?.(merged) ?? this.profile.paperEjectAfterCut;
+    }
+    constructor(adapter, options) {
+        this.ioChain = Promise.resolve();
+        this.adapter = adapter;
+        this.options = options;
+        this.buffer = new SpecBuffer(options?.maxBufferSize);
+        this.Image = image_1.Image;
+        const profileResolver = options?.profileRegistry?.getProfile ?? profiles_1.getProfile;
+        const commandsResolver = options?.profileRegistry?.getCommandsForProfile ?? profiles_1.getCommandsForProfile;
+        const profile = options?.profile === undefined
+            ? undefined
+            : typeof options.profile === 'string'
+                ? profileResolver(options.profile)
+                : options.profile;
+        if (typeof options?.profile === 'string' && !profile) {
+            throw new Error(`Unknown profile "${options.profile}". Register it first or pass a valid profile object.`);
+        }
+        this.commands = profile ? commandsResolver(profile) : commands_1.commands;
+        this.profile = profile;
+        this.styleMap = buildStyleMap(this.commands);
+        this.encoding = options?.encoding ?? 'utf8';
+        this.width = options?.width ?? profile?.defaultPaperWidth ?? 80;
+    }
+    enqueueIo(task) {
+        const run = this.ioChain.then(task, task);
+        this.ioChain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /**
+     * Set paper width (characters per line). If the profile defines a hardware command
+     * (e.g. GS W), it is sent to the printer; otherwise only the internal width is updated.
+     */
+    paperWidth(width) {
+        const w = Math.max(1, Math.floor(Number(width) || 80));
+        if (this.profile?.paperWidths && !this.profile.paperWidths.includes(w)) {
+            console.warn(`[escpos] Paper width ${w} may not be supported by profile "${this.profile.id}".`);
+        }
+        this.width = w;
+        const cmd = this.profile?.getPaperWidthCommand?.(w);
+        if (cmd)
+            this.buffer.write(cmd);
+        return this;
+    }
+    setCharacterCodeTable(codeTable) {
+        this.currentCodepage = codeTable;
+        this.buffer.write(Buffer.concat([
+            this.commands.ESC,
+            Buffer.from([0x74]), // 't'
+            Buffer.from([codeTable]),
+        ]));
+        return this;
+    }
+    margin(type, size) {
+        if (typeof type !== 'string' || !type) {
+            throw new TypeError('margin(type, size): type must be a non-empty string (LEFT, RIGHT, BOTTOM)');
+        }
+        const key = type.toUpperCase();
+        const margin = this.commands.MARGINS[key];
+        if (!margin) {
+            throw new TypeError(`margin(type, size): invalid type "${type}". Use LEFT, RIGHT, or BOTTOM.`);
+        }
+        this.buffer.write(Buffer.concat([margin, Buffer.from(this.commands.numToHexString(size), 'hex')]));
+        return this;
+    }
+    marginBottomCancel() {
+        this.buffer.write(this.commands.MARGIN_BOTTOM_CANCEL);
+        return this;
+    }
+    print(content) {
+        this.buffer.write(Buffer.isBuffer(content) ? content : Buffer.from(content, 'ascii'));
+        return this;
+    }
+    println(content) {
+        this.buffer.write(Buffer.concat([
+            Buffer.isBuffer(content) ? content : Buffer.from(content, 'ascii'),
+            this.commands.EOL,
+        ]));
+        return this;
+    }
+    newLine() {
+        this.buffer.write(this.commands.EOL);
+        return this;
+    }
+    /**
+     * Internal helper to set codepage based on encoding if profile supports it.
+     */
+    autoSetCodepage(encoding) {
+        if (!this.profile?.codepages)
+            return;
+        const cp = this.profile.codepages[encoding];
+        if (cp !== undefined && cp !== this.currentCodepage) {
+            this.setCharacterCodeTable(cp);
+        }
+    }
+    /**
+     * Print text with encoding. If the profile has a mapping for the encoding,
+     * it automatically sends the codepage command (ESC t n).
+     */
+    text(content, encoding) {
+        const enc = encoding ?? this.encoding;
+        this.autoSetCodepage(enc);
+        const buf = Buffer.isEncoding(enc)
+            ? Buffer.from(content, enc)
+            : Buffer.from(content, 'utf8');
+        return this.print(buf);
+    }
+    textln(content, encoding) {
+        const enc = encoding ?? this.encoding;
+        this.autoSetCodepage(enc);
+        const buf = Buffer.isEncoding(enc)
+            ? Buffer.from(content, enc)
+            : Buffer.from(content, 'utf8');
+        return this.println(buf);
+    }
+    drawLine(character = '-') {
+        for (let i = 0; i < this.width; i++) {
+            this.buffer.write(Buffer.from(character, 'ascii'));
+        }
+        return this.newLine();
+    }
+    section(title, encoding) {
+        this.drawLine('-');
+        this.centerln(title, encoding);
+        this.drawLine('-');
+        return this;
+    }
+    center(content, encoding) {
+        this.align('ct');
+        this.text(content, encoding);
+        this.align('lt');
+        return this;
+    }
+    centerln(content, encoding) {
+        this.align('ct');
+        this.textln(content, encoding);
+        this.align('lt');
+        return this;
+    }
+    right(content, encoding) {
+        this.align('rt');
+        this.text(content, encoding);
+        this.align('lt');
+        return this;
+    }
+    rightln(content, encoding) {
+        this.align('rt');
+        this.textln(content, encoding);
+        this.align('lt');
+        return this;
+    }
+    row(columns, encoding) {
+        if (!Array.isArray(columns) || columns.length === 0)
+            return this;
+        let line = '';
+        for (const col of columns) {
+            const w = Math.max(0, Number(col.width) || 0);
+            const align = (col.align ?? 'left').toLowerCase();
+            let s = String(col.text ?? '');
+            if (utils.textLength(s) > w)
+                s = utils.textSubstring(s, 0, w);
+            const len = utils.textLength(s);
+            const pad = w - len;
+            if (align === 'right')
+                line += ' '.repeat(pad) + s;
+            else if (align === 'center')
+                line += ' '.repeat(Math.floor(pad / 2)) + s + ' '.repeat(pad - Math.floor(pad / 2));
+            else
+                line += s + ' '.repeat(pad);
+        }
+        this.textln(line, encoding);
+        return this;
+    }
+    /**
+     * Alias for row() but allows using decimal proportions for widths (e.g. 0.5 for 50%).
+     */
+    tableCustom(columns, encoding) {
+        const formattedCols = columns.map(col => ({
+            text: col.text,
+            width: col.width < 1 ? Math.floor(this.width * col.width) : col.width,
+            align: (col.align?.toLowerCase() ?? 'left')
+        }));
+        return this.row(formattedCols, encoding);
+    }
+    lineItem(desc, price, optionsOrEncoding, encoding) {
+        const { options, encoding: enc } = normalizeOptionsEncoding(optionsOrEncoding, encoding);
+        const priceWidth = options?.priceWidth ?? 12;
+        const descWidth = options?.descWidth ?? this.width - priceWidth;
+        return this.row([
+            { text: String(desc ?? ''), width: descWidth },
+            { text: String(price ?? ''), width: priceWidth, align: 'right' },
+        ], enc);
+    }
+    lineItemWithQty(desc, qty, price, optionsOrEncoding, encoding) {
+        const { options, encoding: enc } = normalizeOptionsEncoding(optionsOrEncoding, encoding);
+        const priceWidth = options?.priceWidth ?? 12;
+        const qtyWidth = options?.qtyWidth ?? 6;
+        const descWidth = options?.descWidth ?? this.width - priceWidth - qtyWidth;
+        return this.row([
+            { text: String(desc ?? ''), width: descWidth },
+            { text: String(qty ?? ''), width: qtyWidth, align: 'right' },
+            { text: String(price ?? ''), width: priceWidth, align: 'right' },
+        ], enc);
+    }
+    total(label, value, optionsOrEncoding, encoding) {
+        const { options, encoding: enc } = normalizeOptionsEncoding(optionsOrEncoding, encoding);
+        const bold = !options || options.bold !== false;
+        if (bold)
+            this.style('b');
+        this.row([
+            { text: String(label ?? ''), width: this.width - 12 },
+            { text: String(value ?? ''), width: 12, align: 'right' },
+        ], enc);
+        if (bold)
+            this.style('normal');
+        return this;
+    }
+    encode(encoding) {
+        this.encoding = encoding;
+        return this;
+    }
+    feed(n = 1) {
+        const lines = Math.min(255, Math.max(0, Math.floor(Number(n) || 0)));
+        if (lines > 0) {
+            this.buffer.write(Buffer.concat(new Array(lines).fill(this.commands.EOL)));
+        }
+        return this;
+    }
+    feedLines(n) {
+        const byte = Math.min(255, Math.max(0, Number(n) || 0));
+        this.buffer.write(Buffer.concat([this.commands.FEED_LINES, Buffer.from([byte])]));
+        return this;
+    }
+    control(ctrl) {
+        if (typeof ctrl !== 'string' || !ctrl) {
+            throw new TypeError('control(ctrl): ctrl must be a non-empty string');
+        }
+        const key = (0, commands_types_1.getFeedControlKey)(ctrl);
+        if (!key) {
+            throw new TypeError(`control(ctrl): invalid ctrl "${ctrl}". Use LF, GLF, FF, CR, HT, or VT.`);
+        }
+        this.buffer.write(this.commands.FEED_CONTROL_SEQUENCES[key]);
+        return this;
+    }
+    align(align) {
+        if (typeof align !== 'string' || !align) {
+            throw new TypeError('align(align): align must be a non-empty string (LT, CT, RT)');
+        }
+        const key = (0, commands_types_1.getAlignKey)(align);
+        if (!key) {
+            throw new TypeError(`align(align): invalid align "${align}". Use LT, CT, or RT.`);
+        }
+        const cmd = this.commands.TEXT_FORMAT[key];
+        this.buffer.write(cmd);
+        return this;
+    }
+    font(family) {
+        if (typeof family !== 'string' || !family) {
+            throw new TypeError('font(family): family must be a non-empty string (A, B, C)');
+        }
+        const key = (0, commands_types_1.getFontKey)(family);
+        if (!key) {
+            throw new TypeError(`font(family): invalid family "${family}". Use A, B, or C.`);
+        }
+        this.buffer.write(this.commands.TEXT_FORMAT[key]);
+        this.width = family.toUpperCase() === 'A' ? (this.options?.width ?? 42) : (this.options?.width ?? 56);
+        return this;
+    }
+    style(type) {
+        if (typeof type !== 'string') {
+            throw new TypeError('style(type): type must be a string');
+        }
+        const key = type.toUpperCase();
+        const buffers = this.styleMap[key] ?? this.styleMap.NORMAL;
+        this.buffer.write(Buffer.concat(buffers));
+        return this;
+    }
+    size(width, height) {
+        this.buffer.write(this.commands.TEXT_FORMAT.TXT_CUSTOM_SIZE(width, height));
+        return this;
+    }
+    /** Write default or parameterised command (DRY for spacing/lineSpace). */
+    writeOptionalNumber(defaultBuf, setPrefix, n) {
+        if (n === undefined || n === null) {
+            this.buffer.write(defaultBuf);
+        }
+        else {
+            if (!Number.isInteger(n) || n < 0 || n > 255) {
+                throw new TypeError('numeric command parameter must be an integer between 0 and 255');
+            }
+            this.buffer.write(Buffer.concat([setPrefix, Buffer.from(this.commands.numToHexString(n), 'hex')]));
+        }
+    }
+    spacing(n) {
+        this.writeOptionalNumber(this.commands.CHARACTER_SPACING.CS_DEFAULT, this.commands.CHARACTER_SPACING.CS_SET, n);
+        return this;
+    }
+    lineSpace(n) {
+        this.writeOptionalNumber(this.commands.LINE_SPACING.LS_DEFAULT, this.commands.LINE_SPACING.LS_SET, n);
+        return this;
+    }
+    hardware(hw) {
+        if (typeof hw !== 'string' || !hw) {
+            throw new TypeError('hardware(hw): hw must be a non-empty string (INIT, SELECT, RESET)');
+        }
+        const key = (0, commands_types_1.getHardwareKey)(hw);
+        if (!key) {
+            throw new TypeError(`hardware(hw): invalid hw "${hw}". Use INIT, SELECT, or RESET.`);
+        }
+        this.buffer.write(this.commands.HARDWARE[key]);
+        return this;
+    }
+    barcode(code, type = 'EAN13', options) {
+        const profileBuf = this.profile?.buildBarcode?.(code, type, options, {
+            commands: this.commands,
+            getParityBit: utils.getParityBit,
+            codeLength: utils.codeLength,
+        });
+        if (Buffer.isBuffer(profileBuf)) {
+            this.buffer.write(profileBuf);
+            return this;
+        }
+        options = options ?? {};
+        const width = options.width;
+        const height = options.height;
+        const position = options.position;
+        const font = options.font;
+        const includeParity = options.includeParity !== false;
+        const convertCode = String(code);
+        let parityBit = '';
+        let codeLen = Buffer.alloc(0);
+        if (type === 'EAN13' && convertCode.length !== 12 && convertCode.length !== 13) {
+            throw new Error('EAN13 Barcode type requires code length 12 or 13');
+        }
+        if (type === 'EAN8' && convertCode.length !== 7 && convertCode.length !== 8) {
+            throw new Error('EAN8 Barcode type requires code length 7 or 8');
+        }
+        const bf = this.commands.BARCODE_FORMAT;
+        const widthKey = width != null && width >= 1 && width <= 5 ? width : undefined;
+        if (widthKey !== undefined) {
+            this.buffer.write(bf.BARCODE_WIDTH[widthKey]);
+        }
+        else {
+            this.buffer.write(bf.BARCODE_WIDTH_DEFAULT);
+        }
+        if (height != null && height >= 1 && height <= 255) {
+            this.buffer.write(bf.BARCODE_HEIGHT(height));
+        }
+        else {
+            this.buffer.write(bf.BARCODE_HEIGHT_DEFAULT);
+        }
+        const fontKey = 'BARCODE_FONT_' + (font || 'A').toUpperCase();
+        const posKey = 'BARCODE_TXT_' + (position || 'BLW').toUpperCase();
+        const typeKey = 'BARCODE_' + (type || 'EAN13').replace('-', '_').toUpperCase();
+        const bfRecord = bf;
+        const fontBuf = bfRecord[fontKey];
+        const posBuf = bfRecord[posKey];
+        const typeBuf = bfRecord[typeKey];
+        if (Buffer.isBuffer(fontBuf))
+            this.buffer.write(fontBuf);
+        if (Buffer.isBuffer(posBuf))
+            this.buffer.write(posBuf);
+        if (Buffer.isBuffer(typeBuf))
+            this.buffer.write(typeBuf);
+        if (includeParity && (type === 'EAN13' || type === 'EAN8')) {
+            const expectsParity = (type === 'EAN13' && convertCode.length === 12) ||
+                (type === 'EAN8' && convertCode.length === 7);
+            if (expectsParity)
+                parityBit = utils.getParityBit(code);
+        }
+        if (type === 'CODE128' || type === 'CODE93') {
+            codeLen = utils.codeLength(code);
+        }
+        this.buffer.write(Buffer.concat([
+            codeLen,
+            Buffer.from(code + (includeParity ? parityBit : ''), 'ascii'),
+            Buffer.from('00', 'hex'),
+        ]));
+        return this;
+    }
+    image(image, density = 'd24') {
+        if (!(image instanceof image_1.Image))
+            throw new TypeError('Only Image object supported');
+        const n = ['d8', 's8'].includes(density) ? 1 : 3;
+        const key = (0, commands_types_1.getBitmapDensityKey)(density);
+        if (!key)
+            throw new TypeError(`image(..., density): invalid density "${density}". Use s8, d8, s24, d24.`);
+        const header = this.commands.BITMAP_FORMAT[key];
+        const bitmap = image.toBitmap(n * 8);
+        for (const line of bitmap.data) {
+            const lineLength = Buffer.allocUnsafe(2);
+            lineLength.writeUInt16LE(line.length / n, 0);
+            this.buffer.write(Buffer.concat([
+                header,
+                lineLength,
+                Buffer.from(line),
+                this.commands.ESC,
+                this.commands.FEED_CONTROL_SEQUENCES.CTL_GLF,
+            ]));
+        }
+        return this;
+    }
+    raster(image, mode = 'normal') {
+        if (!(image instanceof image_1.Image))
+            throw new TypeError('Only Image object supported');
+        if (mode === 'dhdw' || mode === 'dwh' || mode === 'dhw')
+            mode = 'dwdh';
+        const raster = image.toRaster();
+        const key = (0, commands_types_1.getGsv0ModeKey)(mode);
+        if (!key)
+            throw new TypeError(`raster(..., mode): invalid mode "${mode}". Use normal, dw, dh, dwdh.`);
+        const header = this.commands.GSV0_FORMAT[key];
+        const width = Buffer.allocUnsafe(2);
+        width.writeUInt16LE(raster.width, 0);
+        const height = Buffer.allocUnsafe(2);
+        height.writeUInt16LE(raster.height, 0);
+        this.buffer.write(Buffer.concat([header, width, height, Buffer.from(raster.data)]));
+        return this;
+    }
+    cashdraw(pin = 2) {
+        this.buffer.write(this.commands.CASH_DRAWER[(0, commands_types_1.getCashDrawerKey)(pin)]);
+        return this;
+    }
+    beep(n = 1, t = 1) {
+        const nB = Buffer.allocUnsafe(1);
+        const tB = Buffer.allocUnsafe(1);
+        nB.writeUInt8(n, 0);
+        tB.writeUInt8(t, 0);
+        this.buffer.write(Buffer.concat([this.commands.BEEP, nB, tB]));
+        return this;
+    }
+    /**
+     * Feed paper then cut.
+     * If the profile has ejectCommandIncludesCut (e.g. CUSTOM VKP80III),
+     * we still send feed if feed > 0 before the eject command.
+     */
+    cut(part = true, feed = 3) {
+        const n = Math.min(255, Math.max(0, feed));
+        const presentationCmd = this.resolveTicketPresentationCommand();
+        const useEjectOnly = this.profile?.ejectCommandIncludesCut && presentationCmd?.length;
+        if (n > 0) {
+            this.buffer.write(Buffer.concat([this.commands.FEED_LINES, Buffer.from([n])]));
+        }
+        if (!useEjectOnly) {
+            this.buffer.write(this.commands.PAPER[part ? 'PAPER_PART_CUT' : 'PAPER_FULL_CUT']);
+        }
+        if (presentationCmd?.length) {
+            this.buffer.write(presentationCmd);
+        }
+        return this;
+    }
+    /**
+     * High-level ticket presentation API.
+     * Uses profile-specific presentation command when available; otherwise falls back to cut().
+     */
+    presentTicket(options) {
+        const n = Math.min(255, Math.max(0, options?.feed ?? 3));
+        const part = options?.part !== false;
+        const presentationCmd = this.resolveTicketPresentationCommand(options);
+        if (!presentationCmd?.length)
+            return this.cut(part, n);
+        if (n > 0) {
+            this.buffer.write(Buffer.concat([this.commands.FEED_LINES, Buffer.from([n])]));
+        }
+        if (!this.profile?.ejectCommandIncludesCut) {
+            this.buffer.write(this.commands.PAPER[part ? 'PAPER_PART_CUT' : 'PAPER_FULL_CUT']);
+        }
+        this.buffer.write(presentationCmd);
+        return this;
+    }
+    async flush() {
+        const buf = this.buffer.flush();
+        if (buf.length === 0)
+            return this;
+        try {
+            await this.adapter.write(buf);
+        }
+        catch (error) {
+            // Preserve payload for retry in caller-controlled recovery flows.
+            this.buffer.prepend(buf);
+            throw error;
+        }
+        return this;
+    }
+    async close(options) {
+        const buf = this.buffer.flush();
+        if (buf.length > 0) {
+            try {
+                await this.adapter.write(buf);
+            }
+            catch (error) {
+                this.buffer.prepend(buf);
+                throw error;
+            }
+        }
+        await this.adapter.close(options);
+        return this;
+    }
+    color(color) {
+        this.buffer.write(this.commands.COLOR[color === 0 || color === 1 ? color : 0]);
+        return this;
+    }
+    setReverseColors(bool) {
+        this.buffer.write(bool ? this.commands.COLOR.REVERSE : this.commands.COLOR.UNREVERSE);
+        return this;
+    }
+    setReverseColorsAlt(bool) {
+        this.buffer.write(bool ? this.commands.COLOR.REVERSE_ALT : this.commands.COLOR.UNREVERSE_ALT);
+        return this;
+    }
+    raw(data) {
+        if (Buffer.isBuffer(data)) {
+            this.buffer.write(data);
+        }
+        else if (typeof data === 'string') {
+            const normalized = data.toLowerCase().replace(/(\s|:)/g, '');
+            if (normalized.length === 0 || normalized.length % 2 !== 0 || !/^[0-9a-f]+$/.test(normalized)) {
+                throw new TypeError('raw(data): hex string must have even length and contain only [0-9a-f]');
+            }
+            this.buffer.write(Buffer.from(normalized, 'hex'));
+        }
+        else {
+            throw new Error('Data is Invalid!');
+        }
+        return this;
+    }
+    /**
+     * Modern QR Code implementation using GS ( k.
+     * QR sequence (cn=49): fn=65 (model), fn=67 (module size), fn=69 (EC level), fn=80 (store), fn=81 (print).
+     */
+    qrcode(code, options = {}) {
+        const profileBuf = this.profile?.buildQrCode?.(code, options, {
+            commands: this.commands,
+        });
+        if (Buffer.isBuffer(profileBuf)) {
+            this.buffer.write(profileBuf);
+            return this;
+        }
+        const model = options.model ?? 2;
+        const size = options.size ?? 6;
+        const level = (options.level ?? 'L').toUpperCase();
+        const levels = { L: 48, M: 49, Q: 50, H: 51 };
+        const cmd = this.commands.CODE2D_FORMAT.GS_H;
+        // 1. Select Model (Function 165 -> 0x41)
+        this.buffer.write(Buffer.concat([cmd, Buffer.from([0x04, 0x00, 0x31, 0x41, model, 0x00])]));
+        // 2. Set Module Size (Function 167 -> 0x43)
+        this.buffer.write(Buffer.concat([cmd, Buffer.from([0x03, 0x00, 0x31, 0x43, size])]));
+        // 3. Set Error Correction Level (Function 169 -> 0x45)
+        this.buffer.write(Buffer.concat([cmd, Buffer.from([0x03, 0x00, 0x31, 0x45, levels[level] ?? 48])]));
+        // 4. Store Data (Function 180)
+        const data = Buffer.from(code, 'utf8');
+        const len = data.length + 3;
+        const pL = len % 256;
+        const pH = Math.floor(len / 256);
+        this.buffer.write(Buffer.concat([cmd, Buffer.from([pL, pH, 0x31, 0x50, 0x30]), data]));
+        // 5. Print QR Code (Function 181)
+        this.buffer.write(Buffer.concat([cmd, Buffer.from([0x03, 0x00, 0x31, 0x51, 0x30])]));
+        return this;
+    }
+    /**
+     * Legacy 2D code command using ESC Z / GS Z command family.
+     * Use `qrcode(...)` for modern GS ( k flow when possible.
+     */
+    code2d(code, type = 'QR', level) {
+        const f = this.commands.CODE2D_FORMAT;
+        const typeMap = {
+            PDF417: f.TYPE_PDF417,
+            DATAMATRIX: f.TYPE_DATAMATRIX,
+            QR: f.TYPE_QR,
+        };
+        const levelMap = {
+            L: f.QR_LEVEL_L,
+            M: f.QR_LEVEL_M,
+            Q: f.QR_LEVEL_Q,
+            H: f.QR_LEVEL_H,
+        };
+        const typeCmd = typeMap[type];
+        const levelCmd = level ? levelMap[level] : undefined;
+        this.buffer.write(Buffer.concat([
+            typeCmd,
+            f.CODE2D,
+            ...(levelCmd ? [levelCmd] : []),
+            Buffer.from(String(code), 'ascii'),
+        ]));
+        return this;
+    }
+    /**
+     * Request printer status in real-time.
+     * Returns a Buffer with the status byte.
+     */
+    async getStatus(type = 'PRINTER') {
+        return this.enqueueIo(async () => {
+            const n = this.commands.STATUS[type];
+            await this.adapter.write(this.commands.STATUS.DLE_EOT(n));
+            return this.adapter.read();
+        });
+    }
+}
+exports.Printer = Printer;
+//# sourceMappingURL=index.js.map