retail-print-kit 0.0.0-stage → 0.2.0

package/dist/core/printer.js

@@ -0,0 +1,96 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Printer = void 0;
+const encode_1 = require("./encode");
+const builder_1 = require("./builder");
+const status_1 = require("./status");
+__exportStar(require("./builder"), exports);
+/** An `OpBuilder` bound to a transport: `open()`, record ops, `close()` sends them. */
+class Printer extends builder_1.OpBuilder {
+    constructor(transport, profile, options = {}) {
+        super(profile);
+        this.transport = transport;
+        this.options = options;
+        this.opened = false;
+    }
+    async open() {
+        await this.transport.open();
+        this.opened = true;
+        if (this.options.initOnOpen !== false)
+            this.ops.unshift({ kind: 'init' });
+        return this;
+    }
+    /** Encodes and sends everything recorded so far, keeping the connection open. */
+    async flush() {
+        if (!this.opened)
+            throw new Error('retail-print-kit: call open() before flush()');
+        const ops = this.ops;
+        this.ops = [];
+        if (ops.length)
+            await this.transport.write((0, encode_1.encode)(ops, this.profile, this.options));
+        return this;
+    }
+    /** Flushes, then closes the transport. */
+    async close() {
+        try {
+            await this.flush();
+        }
+        finally {
+            this.opened = false;
+            await this.transport.close();
+        }
+    }
+    /** Renders a template with data and appends the result. */
+    render(template, data) {
+        const { render } = require('../template/render');
+        return this.append(render(template, data, this.profile));
+    }
+    /** HTML preview of the recorded ops. */
+    toHtml(options) {
+        const { opsToHtml } = require('../preview/html');
+        return opsToHtml(this.ops, this.profile, options);
+    }
+    /** The bytes that would be sent for the recorded ops; useful for tests and previews. */
+    toBuffer() {
+        return (0, encode_1.encode)(this.ops, this.profile, this.options);
+    }
+    /**
+     * Asks the printer for its state (ESC/POS DLE EOT 1..4). Flushes pending ops first so the
+     * reply is not mixed with receipt data. Needs a transport with `read`.
+     */
+    async status() {
+        if (this.profile.set !== 'escpos' && this.profile.set !== 'star-line')
+            return status_1.UNSUPPORTED_STATUS;
+        if (!this.transport.read)
+            throw new Error(`retail-print-kit: ${this.transport.name} transport cannot read from the printer`);
+        await this.flush();
+        const timeout = this.options.statusTimeout ?? 1500;
+        if (this.profile.set === 'star-line') {
+            await this.transport.write(Buffer.from([0x1b, 0x06, 0x01]));
+            const reply = await this.transport.read(timeout);
+            return (0, status_1.parseStarStatus)(Array.from(reply));
+        }
+        const bytes = [];
+        for (const n of [1, 2, 3, 4]) {
+            await this.transport.write(Buffer.from([0x10, 0x04, n]));
+            const reply = await this.transport.read(timeout);
+            bytes.push(reply[0]);
+        }
+        return (0, status_1.parseEscPosStatus)(bytes);
+    }
+}
+exports.Printer = Printer;

package/dist/core/rasterizer.d.ts

@@ -0,0 +1,29 @@
+import { Op } from './ops';
+import { Profile } from '../profiles/types';
+import { Bitmap } from './bitmap';
+/** Turns text ops into a page image for printers that only accept bitmaps (Star TSP100). */
+export interface Rasterizer {
+    render(ops: Op[], profile: Profile): Bitmap;
+}
+interface Canvas2D {
+    width: number;
+    height: number;
+    getContext(kind: '2d'): any;
+}
+export interface CanvasFactory {
+    (width: number, height: number): Canvas2D;
+}
+/**
+ * Lays text out the way a line printer would (hard wrap at the column count, character cells of
+ * dots/columns width, 24-dot lines, size multipliers), then paints it with a monospace font on a
+ * canvas and thresholds to 1 bit. The canvas comes from `@napi-rs/canvas` or `canvas` unless a
+ * factory is given; Electron hosts can pass a factory that wraps `document.createElement('canvas')`.
+ */
+export declare class CanvasRasterizer implements Rasterizer {
+    private readonly factory;
+    private readonly fontFamily;
+    constructor(factory?: CanvasFactory, fontFamily?: string);
+    render(ops: Op[], profile: Profile): Bitmap;
+}
+export declare function loadCanvasFactory(): CanvasFactory;
+export {};

package/dist/core/rasterizer.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasRasterizer = void 0;
+exports.loadCanvasFactory = loadCanvasFactory;
+const bitmap_1 = require("./bitmap");
+const barcode1d_1 = require("./barcode1d");
+const LINE_DOTS = 24;
+/**
+ * Lays text out the way a line printer would (hard wrap at the column count, character cells of
+ * dots/columns width, 24-dot lines, size multipliers), then paints it with a monospace font on a
+ * canvas and thresholds to 1 bit. The canvas comes from `@napi-rs/canvas` or `canvas` unless a
+ * factory is given; Electron hosts can pass a factory that wraps `document.createElement('canvas')`.
+ */
+class CanvasRasterizer {
+    constructor(factory = loadCanvasFactory(), fontFamily = 'monospace') {
+        this.factory = factory;
+        this.fontFamily = fontFamily;
+    }
+    render(ops, profile) {
+        const width = profile.dots;
+        const items = layout(ops, profile);
+        const height = items.reduce((h, it) => Math.max(h, it.y + it.height), 0);
+        if (height === 0)
+            return (0, bitmap_1.emptyBitmap)(width, 0);
+        const canvas = this.factory(width, height);
+        const ctx = canvas.getContext('2d');
+        ctx.fillStyle = '#fff';
+        ctx.fillRect(0, 0, width, height);
+        ctx.fillStyle = '#000';
+        ctx.textBaseline = 'top';
+        const page = (0, bitmap_1.emptyBitmap)(width, height);
+        for (const it of items) {
+            if (it.type === 'gap')
+                continue;
+            if (it.type === 'bitmap') {
+                const x = it.align === 'left' ? 0 : it.align === 'right' ? width - it.bitmap.width : Math.floor((width - it.bitmap.width) / 2);
+                (0, bitmap_1.blit)(page, it.bitmap, x, it.y);
+                continue;
+            }
+            const s = it.state;
+            const cell = Math.floor(width / profile.columns[s.font]);
+            const cw = cell * s.w;
+            const ch = LINE_DOTS * s.h;
+            const textWidth = it.text.length * cw;
+            const x0 = s.align === 'left' ? 0 : s.align === 'right' ? width - textWidth : Math.floor((width - textWidth) / 2);
+            if (s.invert) {
+                ctx.fillStyle = '#000';
+                ctx.fillRect(x0, it.y, textWidth, ch);
+                ctx.fillStyle = '#fff';
+            }
+            else {
+                ctx.fillStyle = '#000';
+            }
+            const weight = s.bold ? 'bold ' : '';
+            ctx.font = `${weight}100px ${this.fontFamily}`;
+            const advance = (ctx.measureText('M').width || 60) / 100;
+            const fontSize = Math.floor(Math.min(cw / advance, ch * 0.92));
+            ctx.font = `${weight}${fontSize}px ${this.fontFamily}`;
+            const glyphWidth = ctx.measureText('M').width;
+            const scaleY = Math.max(1, (ch * 0.92) / fontSize);
+            const baseline = it.y + Math.floor((ch - fontSize * scaleY) / 2);
+            for (let i = 0; i < it.text.length; i++) {
+                const chr = it.text[i];
+                if (chr === ' ')
+                    continue;
+                ctx.save();
+                ctx.translate(x0 + i * cw + Math.floor((cw - glyphWidth) / 2), baseline);
+                ctx.scale(1, scaleY);
+                ctx.fillText(chr, 0, 0);
+                ctx.restore();
+            }
+            if (s.underline) {
+                const t = s.underline === 2 ? 2 : 1;
+                ctx.fillRect(x0, it.y + ch - t - 1, textWidth, t);
+            }
+        }
+        const img = ctx.getImageData(0, 0, width, height);
+        const text = (0, bitmap_1.fromRgba)(img.data, width, height, 170);
+        for (let i = 0; i < page.bits.length; i++)
+            page.bits[i] |= text.bits[i];
+        return page;
+    }
+}
+exports.CanvasRasterizer = CanvasRasterizer;
+function layout(ops, profile) {
+    const items = [];
+    let y = 0;
+    const state = { align: 'left', font: 'a', w: 1, h: 1, bold: false, underline: 0, invert: false };
+    let pending = '';
+    const flushLine = (force) => {
+        if (!pending && !force)
+            return;
+        const cols = Math.max(1, Math.floor(profile.columns[state.font] / state.w));
+        const text = pending;
+        pending = '';
+        const parts = [];
+        for (let i = 0; i < text.length; i += cols)
+            parts.push(text.slice(i, i + cols));
+        if (!parts.length)
+            parts.push('');
+        for (const p of parts) {
+            const height = LINE_DOTS * state.h;
+            items.push({ type: 'line', text: p, state: { ...state }, y, height });
+            y += height;
+        }
+    };
+    for (const op of ops) {
+        switch (op.kind) {
+            case 'text': {
+                const lines = op.text.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    pending += lines[i];
+                    if (i < lines.length - 1)
+                        flushLine(true);
+                }
+                break;
+            }
+            case 'newline':
+                for (let i = 0; i < op.count; i++)
+                    flushLine(true);
+                break;
+            case 'feed':
+                flushLine(false);
+                items.push({ type: 'gap', y, height: LINE_DOTS * op.lines });
+                y += LINE_DOTS * op.lines;
+                break;
+            case 'align':
+                flushLine(false);
+                state.align = op.align;
+                break;
+            case 'font':
+                flushLine(false);
+                state.font = op.font;
+                break;
+            case 'size':
+                flushLine(false);
+                state.w = Math.max(1, Math.min(8, Math.floor(op.width)));
+                state.h = Math.max(1, Math.min(8, Math.floor(op.height)));
+                break;
+            case 'style':
+                flushLine(false);
+                state.bold = !!op.style.bold;
+                state.underline = op.style.underline ?? 0;
+                state.invert = !!op.style.invert;
+                break;
+            case 'qr': {
+                flushLine(false);
+                const bm = (0, bitmap_1.qrBitmap)(op.data, op.options);
+                items.push({ type: 'bitmap', bitmap: bm, align: state.align, y, height: bm.height });
+                y += bm.height;
+                break;
+            }
+            case 'raster': {
+                flushLine(false);
+                const bm = (0, bitmap_1.fitWidth)({ width: op.width, height: op.height, bits: op.bits }, Math.min(op.width, profile.dots), 'left');
+                items.push({ type: 'bitmap', bitmap: bm, align: state.align, y, height: bm.height });
+                y += bm.height;
+                break;
+            }
+            case 'barcode': {
+                flushLine(false);
+                const bm = (0, barcode1d_1.barcodeBitmap)(op.type, op.data, op.options.width ?? 2, op.options.height ?? 80);
+                items.push({ type: 'bitmap', bitmap: bm, align: state.align, y, height: bm.height });
+                y += bm.height;
+                const pos = op.options.position ?? 'below';
+                if (pos === 'below' || pos === 'both') {
+                    pending = op.data;
+                    flushLine(true);
+                }
+                break;
+            }
+            case 'cut':
+                flushLine(false);
+                if (op.feed > 0) {
+                    items.push({ type: 'gap', y, height: LINE_DOTS * op.feed });
+                    y += LINE_DOTS * op.feed;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    flushLine(false);
+    return items;
+}
+function loadCanvasFactory() {
+    for (const name of ['@napi-rs/canvas', 'canvas']) {
+        try {
+            const mod = require(name);
+            return (w, h) => mod.createCanvas(w, h);
+        }
+        catch {
+            /* try the next */
+        }
+    }
+    return () => {
+        throw new Error('retail-print-kit: bitmap printers need a canvas; install @napi-rs/canvas or pass a CanvasFactory');
+    };
+}

package/dist/core/star-graphic-encoder.d.ts

@@ -0,0 +1,12 @@
+import { Op } from './ops';
+import { Profile } from '../profiles/types';
+import { Rasterizer } from './rasterizer';
+/**
+ * Star raster mode (TSP100 / TSP143 family, "graphic only" printers). The whole receipt is one
+ * bitmap sent line by line with `b nL nH data`; cut happens at end of document per the EOT mode.
+ * Drawer kick uses the peripheral commands outside raster mode.
+ *
+ * Byte values for ESC * r E (EOT cut mode) follow the Star raster spec as read; verify on a real
+ * TSP143 before release: 1 = full cut, 2 = partial cut, 0 = no cut.
+ */
+export declare function encodeStarGraphic(ops: Op[], profile: Profile, rasterizer: Rasterizer): Buffer;

package/dist/core/star-graphic-encoder.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeStarGraphic = encodeStarGraphic;
+const ESC = 0x1b;
+const NUL = 0x00;
+const FF = 0x0c;
+const BEL = 0x07;
+const SUB = 0x1a;
+/**
+ * Star raster mode (TSP100 / TSP143 family, "graphic only" printers). The whole receipt is one
+ * bitmap sent line by line with `b nL nH data`; cut happens at end of document per the EOT mode.
+ * Drawer kick uses the peripheral commands outside raster mode.
+ *
+ * Byte values for ESC * r E (EOT cut mode) follow the Star raster spec as read; verify on a real
+ * TSP143 before release: 1 = full cut, 2 = partial cut, 0 = no cut.
+ */
+function encodeStarGraphic(ops, profile, rasterizer) {
+    const chunks = [];
+    const push = (...parts) => {
+        for (const p of parts)
+            chunks.push(typeof p === 'number' ? Buffer.from([p]) : Buffer.from(p));
+    };
+    const cut = ops.find((o) => o.kind === 'cut');
+    const drawers = ops.filter((o) => o.kind === 'drawer');
+    const raws = ops.filter((o) => o.kind === 'raw');
+    const printable = ops.filter((o) => o.kind !== 'drawer' && o.kind !== 'raw' && o.kind !== 'init');
+    const page = printable.length ? rasterizer.render(printable, profile) : null;
+    if (page && page.height > 0) {
+        push([ESC, 0x2a, 0x72, 0x52]);
+        push([ESC, 0x2a, 0x72, 0x41]);
+        push([ESC, 0x2a, 0x72, 0x50, 0x30, NUL]);
+        push([ESC, 0x2a, 0x72, 0x45, cut ? (cut.partial ? 0x32 : 0x31) : 0x30, NUL]);
+        const rowBytes = Math.ceil(page.width / 8);
+        for (let y = 0; y < page.height; y++) {
+            push([0x62, rowBytes & 0xff, rowBytes >> 8], page.bits.subarray(y * rowBytes, (y + 1) * rowBytes));
+        }
+        push([ESC, FF, NUL]);
+        push([ESC, 0x2a, 0x72, 0x42]);
+    }
+    for (const d of drawers) {
+        const on = Math.max(1, Math.min(127, Math.floor(profile.drawer.on / 5)));
+        const off = Math.max(1, Math.min(127, Math.floor(profile.drawer.off / 5)));
+        push([ESC, BEL, on, off], d.pin === 2 ? BEL : SUB);
+    }
+    for (const r of raws)
+        push(r.bytes);
+    return Buffer.concat(chunks);
+}

package/dist/core/star-line-encoder.d.ts

@@ -0,0 +1,8 @@
+import { Op } from './ops';
+import { Profile } from '../profiles/types';
+/**
+ * Star Line Mode (TSP650II, TSP700II, mC-Print, SP700). Text is printed by the printer, like
+ * ESC/POS, but every command byte differs. Drawer kick is BEL (drawer 1) or SUB (drawer 2) after
+ * ESC BEL sets the pulse.
+ */
+export declare function encodeStarLine(ops: Op[], profile: Profile): Buffer;

package/dist/core/star-line-encoder.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeStarLine = encodeStarLine;
+const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const ESC = 0x1b;
+const GS = 0x1d;
+const RS = 0x1e;
+const LF = 0x0a;
+const BEL = 0x07;
+const SUB = 0x1a;
+/** Star barcode type numbers for ESC b. */
+const BARCODE_CODE = {
+    UPC_E: 0, UPC_A: 1, EAN8: 2, EAN13: 3, CODE39: 4, ITF: 5, CODE128: 6, CODABAR: 8,
+};
+const QR_CORRECTION = { L: 0, M: 1, Q: 2, H: 3 };
+function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, Math.floor(n)));
+}
+/**
+ * Star Line Mode (TSP650II, TSP700II, mC-Print, SP700). Text is printed by the printer, like
+ * ESC/POS, but every command byte differs. Drawer kick is BEL (drawer 1) or SUB (drawer 2) after
+ * ESC BEL sets the pulse.
+ */
+function encodeStarLine(ops, profile) {
+    const chunks = [];
+    const push = (...parts) => {
+        for (const p of parts)
+            chunks.push(typeof p === 'number' ? Buffer.from([p]) : Buffer.from(p));
+    };
+    for (const op of ops) {
+        switch (op.kind) {
+            case 'init':
+                push([ESC, 0x40]);
+                if (profile.codepage !== null)
+                    push([ESC, GS, 0x74, profile.codepage]);
+                break;
+            case 'text':
+                push(iconv_lite_1.default.encode(op.text, profile.encoding));
+                break;
+            case 'newline':
+                for (let i = 0; i < op.count; i++)
+                    push(LF);
+                break;
+            case 'feed':
+                push([ESC, 0x61, clamp(op.lines, 0, 255)]);
+                break;
+            case 'align':
+                push([ESC, GS, 0x61, op.align === 'left' ? 0 : op.align === 'center' ? 1 : 2]);
+                break;
+            case 'font':
+                push([ESC, RS, 0x46, op.font === 'a' ? 0 : 1]);
+                break;
+            case 'size':
+                push([ESC, 0x69, clamp(op.height, 1, 6) - 1, clamp(op.width, 1, 6) - 1]);
+                break;
+            case 'style':
+                push([ESC, op.style.bold ? 0x45 : 0x46]);
+                push([ESC, 0x2d, op.style.underline ? 1 : 0]);
+                if (profile.features.invert)
+                    push([ESC, op.style.invert ? 0x34 : 0x35]);
+                break;
+            case 'lineSpacing':
+                push(op.dots === null ? [ESC, 0x7a, 1] : [ESC, 0x30]);
+                break;
+            case 'cut': {
+                const feed = clamp(op.feed, 0, 255);
+                if (feed > 0)
+                    push([ESC, 0x61, feed]);
+                push([ESC, 0x64, op.partial ? 3 : 2]);
+                break;
+            }
+            case 'drawer': {
+                const on = clamp(profile.drawer.on / 5, 1, 127);
+                const off = clamp(profile.drawer.off / 5, 1, 127);
+                push([ESC, BEL, on, off], op.pin === 2 ? BEL : SUB);
+                break;
+            }
+            case 'beep':
+                break;
+            case 'barcode': {
+                const o = op.options;
+                const pos = o.position ?? 'below';
+                const hri = pos === 'none' || pos === 'above' ? 3 : 4;
+                const code = BARCODE_CODE[op.type];
+                if (code === undefined)
+                    throw new Error(`retail-print-kit: Star Line has no barcode type ${op.type}`);
+                push([ESC, 0x62, code, hri, clamp(o.width ?? 2, 1, 9), clamp(o.height ?? 80, 1, 255)], Buffer.from(op.data, 'ascii'), RS);
+                break;
+            }
+            case 'qr':
+                if (!profile.features.nativeQr)
+                    throw new Error(`retail-print-kit: profile ${profile.id} has no native QR`);
+                pushQr(push, op.data, op.options);
+                break;
+            case 'raster': {
+                if (!profile.features.raster)
+                    throw new Error(`retail-print-kit: profile ${profile.id} cannot print raster images`);
+                const xBytes = Math.ceil(op.width / 8);
+                push([ESC, GS, 0x53, 1, xBytes & 0xff, xBytes >> 8, op.height & 0xff, op.height >> 8, 0], op.bits);
+                break;
+            }
+            case 'raw':
+                push(op.bytes);
+                break;
+        }
+    }
+    return Buffer.concat(chunks);
+}
+function pushQr(push, data, options) {
+    const payload = Buffer.from(data, 'utf8');
+    push([ESC, GS, 0x79, 0x53, 0x30, options.model === 1 ? 1 : 2]);
+    push([ESC, GS, 0x79, 0x53, 0x31, QR_CORRECTION[options.correction ?? 'M']]);
+    push([ESC, GS, 0x79, 0x53, 0x32, clamp(options.size ?? 6, 1, 8)]);
+    push([ESC, GS, 0x79, 0x44, 0x31, 0, payload.length & 0xff, payload.length >> 8], payload);
+    push([ESC, GS, 0x79, 0x50]);
+}

package/dist/core/status.d.ts

@@ -0,0 +1,22 @@
+export interface PrinterStatus {
+    /** False when the profile's command set has no status query implemented. */
+    supported: boolean;
+    online: boolean;
+    coverOpen: boolean;
+    paperOut: boolean;
+    paperNearEnd: boolean;
+    cutterError: boolean;
+    recoverableError: boolean;
+    unrecoverableError: boolean;
+    /** Level of drawer kick-out connector pin 3; which level means "open" depends on the drawer. */
+    drawerPinHigh: boolean;
+    raw: number[];
+}
+/** Parses the four ESC/POS real-time status bytes (DLE EOT 1..4). */
+export declare function parseEscPosStatus(b: number[]): PrinterStatus;
+export declare const UNSUPPORTED_STATUS: PrinterStatus;
+/**
+ * Parses a Star Line Mode status block (reply to ESC ACK SOH). Bit positions follow the Star Line
+ * Mode command specification as read; verify against a TSP650II / mC-Print before relying on it.
+ */
+export declare function parseStarStatus(b: number[]): PrinterStatus;

package/dist/core/status.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSUPPORTED_STATUS = void 0;
+exports.parseEscPosStatus = parseEscPosStatus;
+exports.parseStarStatus = parseStarStatus;
+/** Parses the four ESC/POS real-time status bytes (DLE EOT 1..4). */
+function parseEscPosStatus(b) {
+    const [printer = 0, offline = 0, error = 0, paper = 0] = b;
+    return {
+        supported: true,
+        online: (printer & 0x08) === 0,
+        drawerPinHigh: (printer & 0x04) !== 0,
+        coverOpen: (offline & 0x04) !== 0,
+        paperOut: (offline & 0x20) !== 0 || (paper & 0x60) !== 0,
+        paperNearEnd: (paper & 0x0c) !== 0,
+        cutterError: (error & 0x08) !== 0,
+        recoverableError: (error & 0x40) !== 0,
+        unrecoverableError: (error & 0x20) !== 0,
+        raw: b,
+    };
+}
+exports.UNSUPPORTED_STATUS = {
+    supported: false,
+    online: true,
+    coverOpen: false,
+    paperOut: false,
+    paperNearEnd: false,
+    cutterError: false,
+    recoverableError: false,
+    unrecoverableError: false,
+    drawerPinHigh: false,
+    raw: [],
+};
+/**
+ * Parses a Star Line Mode status block (reply to ESC ACK SOH). Bit positions follow the Star Line
+ * Mode command specification as read; verify against a TSP650II / mC-Print before relying on it.
+ */
+function parseStarStatus(b) {
+    const [, printer = 0, error = 0, , paper = 0] = b;
+    return {
+        supported: true,
+        online: (printer & 0x08) === 0,
+        coverOpen: (printer & 0x20) !== 0,
+        drawerPinHigh: (printer & 0x04) !== 0,
+        cutterError: (error & 0x08) !== 0,
+        unrecoverableError: (error & 0x20) !== 0,
+        recoverableError: (error & 0x40) !== 0,
+        paperNearEnd: (paper & 0x04) !== 0,
+        paperOut: (paper & 0x08) !== 0,
+        raw: b,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export * from './core/ops';
+export * from './core/printer';
+export { encode } from './core/encode';
+export { encodeEscPos } from './core/escpos-encoder';
+export * from './profiles';
+export type { Transport } from './transports/types';
+export { NetTransport } from './transports/net';
+export type { NetOptions } from './transports/net';
+export * from './core/bitmap';
+export * from './core/status';
+export { CanvasRasterizer, loadCanvasFactory } from './core/rasterizer';
+export type { Rasterizer, CanvasFactory } from './core/rasterizer';
+export type { EncodeContext } from './core/encode';
+export { encodeStarLine } from './core/star-line-encoder';
+export { encodeStarGraphic } from './core/star-graphic-encoder';
+export * from './core/barcode1d';
+export * from './template';
+export * from './preview';
+export * from './core/identify';
+export * from './label';
+export { toBase64 } from './util/base64';
+export { loadImage } from './core/image';
+export type { LoadImageOptions } from './core/image';
+export { discoverNetworkPrinters, localSubnets } from './transports/discover';
+export type { DiscoverOptions, DiscoveredPrinter } from './transports/discover';
+export { fromBase64 } from './util/base64';

package/dist/index.js

@@ -0,0 +1,49 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = exports.localSubnets = exports.discoverNetworkPrinters = exports.loadImage = exports.toBase64 = exports.encodeStarGraphic = exports.encodeStarLine = exports.loadCanvasFactory = exports.CanvasRasterizer = exports.NetTransport = exports.encodeEscPos = exports.encode = void 0;
+__exportStar(require("./core/ops"), exports);
+__exportStar(require("./core/printer"), exports);
+var encode_1 = require("./core/encode");
+Object.defineProperty(exports, "encode", { enumerable: true, get: function () { return encode_1.encode; } });
+var escpos_encoder_1 = require("./core/escpos-encoder");
+Object.defineProperty(exports, "encodeEscPos", { enumerable: true, get: function () { return escpos_encoder_1.encodeEscPos; } });
+__exportStar(require("./profiles"), exports);
+var net_1 = require("./transports/net");
+Object.defineProperty(exports, "NetTransport", { enumerable: true, get: function () { return net_1.NetTransport; } });
+__exportStar(require("./core/bitmap"), exports);
+__exportStar(require("./core/status"), exports);
+var rasterizer_1 = require("./core/rasterizer");
+Object.defineProperty(exports, "CanvasRasterizer", { enumerable: true, get: function () { return rasterizer_1.CanvasRasterizer; } });
+Object.defineProperty(exports, "loadCanvasFactory", { enumerable: true, get: function () { return rasterizer_1.loadCanvasFactory; } });
+var star_line_encoder_1 = require("./core/star-line-encoder");
+Object.defineProperty(exports, "encodeStarLine", { enumerable: true, get: function () { return star_line_encoder_1.encodeStarLine; } });
+var star_graphic_encoder_1 = require("./core/star-graphic-encoder");
+Object.defineProperty(exports, "encodeStarGraphic", { enumerable: true, get: function () { return star_graphic_encoder_1.encodeStarGraphic; } });
+__exportStar(require("./core/barcode1d"), exports);
+__exportStar(require("./template"), exports);
+__exportStar(require("./preview"), exports);
+__exportStar(require("./core/identify"), exports);
+__exportStar(require("./label"), exports);
+var base64_1 = require("./util/base64");
+Object.defineProperty(exports, "toBase64", { enumerable: true, get: function () { return base64_1.toBase64; } });
+var image_1 = require("./core/image");
+Object.defineProperty(exports, "loadImage", { enumerable: true, get: function () { return image_1.loadImage; } });
+var discover_1 = require("./transports/discover");
+Object.defineProperty(exports, "discoverNetworkPrinters", { enumerable: true, get: function () { return discover_1.discoverNetworkPrinters; } });
+Object.defineProperty(exports, "localSubnets", { enumerable: true, get: function () { return discover_1.localSubnets; } });
+var base64_2 = require("./util/base64");
+Object.defineProperty(exports, "fromBase64", { enumerable: true, get: function () { return base64_2.fromBase64; } });