retail-print-kit 0.0.0-stage → 0.2.0

package/dist/template/render.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = render;
+exports.renderBlocks = renderBlocks;
+const builder_1 = require("../core/builder");
+const expr_1 = require("./expr");
+const bitmap_1 = require("../core/bitmap");
+const ALIGN = { left: 'lt', center: 'ct', right: 'rt' };
+/** Renders a template with data into ops for the given profile. */
+function render(template, data, profile) {
+    if (template.version !== 1)
+        throw new Error(`retail-print-kit: unsupported template version ${String(template.version)}`);
+    const b = new builder_1.OpBuilder(profile);
+    renderBlocks(template.blocks, { root: data, current: data }, b);
+    return b.operations;
+}
+function renderBlocks(blocks, scope, b) {
+    for (const block of blocks)
+        renderBlock(block, scope, b);
+}
+function renderBlock(block, scope, b) {
+    switch (block.type) {
+        case 'text': {
+            if (block.align)
+                b.align(ALIGN[block.align]);
+            if (block.font)
+                b.setFont(block.font);
+            if (block.size)
+                b.size(block.size[0], block.size[1]);
+            if (block.style)
+                b.style(block.style);
+            b.text((0, expr_1.interpolate)(block.value, scope));
+            if (block.style)
+                b.style('normal');
+            if (block.size)
+                b.size(1, 1);
+            if (block.font)
+                b.setFont('a');
+            if (block.align && block.align !== 'left')
+                b.align('lt');
+            break;
+        }
+        case 'line':
+            b.drawLine(block.char ?? '-');
+            break;
+        case 'row':
+            b.tableCustom(block.cells.map((c) => ({ text: (0, expr_1.interpolate)(c.value, scope), width: c.width, align: c.align ?? 'LEFT' })));
+            break;
+        case 'table': {
+            const rows = (0, expr_1.evaluate)(block.rows, scope);
+            if (block.header !== false && block.columns.some((c) => c.header)) {
+                b.tableCustom(block.columns.map((c) => ({ text: c.header ?? '', width: c.width, align: c.align ?? 'LEFT' })));
+            }
+            if (!Array.isArray(rows))
+                break;
+            rows.forEach((row, index) => {
+                const rowScope = { root: scope.root, current: row, index };
+                const cells = block.columns.map((c) => ({ text: (0, expr_1.interpolate)(c.value, rowScope), width: c.width, align: c.align ?? 'LEFT' }));
+                b.tableCustom(cells);
+            });
+            break;
+        }
+        case 'feed':
+            b.feed(block.lines ?? 1);
+            break;
+        case 'newline':
+            b.newLine(block.count ?? 1);
+            break;
+        case 'cut':
+            b.cut(block.partial ?? false, block.feed ?? 3);
+            break;
+        case 'drawer':
+            b.cashdraw(block.pin ?? 2);
+            break;
+        case 'qr': {
+            if (block.align)
+                b.align(ALIGN[block.align]);
+            b.qr((0, expr_1.interpolate)(block.value, scope), { size: block.size });
+            if (block.align && block.align !== 'left')
+                b.align('lt');
+            break;
+        }
+        case 'barcode': {
+            if (block.align)
+                b.align(ALIGN[block.align]);
+            b.barcode((0, expr_1.interpolate)(block.value, scope), block.format ?? 'CODE128', {
+                height: block.height,
+                width: block.width,
+                position: block.text === false ? 'none' : 'below',
+            });
+            if (block.align && block.align !== 'left')
+                b.align('lt');
+            break;
+        }
+        case 'image': {
+            if (block.align)
+                b.align(ALIGN[block.align]);
+            b.image((0, bitmap_1.deserializeBitmap)(block));
+            if (block.align && block.align !== 'left')
+                b.align('lt');
+            break;
+        }
+        case 'each': {
+            const items = (0, expr_1.evaluate)(block.items, scope);
+            if (!Array.isArray(items))
+                break;
+            items.forEach((item, index) => renderBlocks(block.blocks, { root: scope.root, current: item, index }, b));
+            break;
+        }
+        case 'if':
+            if ((0, expr_1.truthy)(block.when, scope))
+                renderBlocks(block.blocks, scope, b);
+            else if (block.else)
+                renderBlocks(block.else, scope, b);
+            break;
+        default:
+            throw new Error(`retail-print-kit: unknown template block "${block.type}"`);
+    }
+}

package/dist/template/types.d.ts

@@ -0,0 +1,81 @@
+import { BarcodeType } from '../core/ops';
+import { EscposStyle } from '../core/builder';
+export type TAlign = 'left' | 'center' | 'right';
+export type TCellAlign = 'LEFT' | 'CENTER' | 'RIGHT';
+/** A column of a `table` block. `value` is a template string evaluated per row. */
+export interface TableColumn {
+    value: string;
+    header?: string;
+    width?: number;
+    align?: TCellAlign;
+}
+export type Block = {
+    type: 'text';
+    value: string;
+    align?: TAlign;
+    size?: [number, number];
+    style?: EscposStyle;
+    font?: 'a' | 'b';
+} | {
+    type: 'line';
+    char?: string;
+} | {
+    type: 'row';
+    cells: Array<{
+        value: string;
+        width?: number;
+        align?: TCellAlign;
+    }>;
+} | {
+    type: 'table';
+    rows: string;
+    columns: TableColumn[];
+    header?: boolean;
+} | {
+    type: 'feed';
+    lines?: number;
+} | {
+    type: 'newline';
+    count?: number;
+} | {
+    type: 'cut';
+    partial?: boolean;
+    feed?: number;
+} | {
+    type: 'drawer';
+    pin?: 2 | 5;
+} | {
+    type: 'qr';
+    value: string;
+    size?: number;
+    align?: TAlign;
+} | {
+    type: 'barcode';
+    value: string;
+    format?: BarcodeType;
+    height?: number;
+    width?: number;
+    align?: TAlign;
+    text?: boolean;
+} | {
+    type: 'image';
+    width: number;
+    height: number;
+    data: string;
+    align?: TAlign;
+} | {
+    type: 'each';
+    items: string;
+    blocks: Block[];
+} | {
+    type: 'if';
+    when: string;
+    blocks: Block[];
+    else?: Block[];
+};
+export interface Template {
+    name: string;
+    version: 1;
+    kind?: 'receipt';
+    blocks: Block[];
+}

package/dist/template/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/transports/discover.d.ts

@@ -0,0 +1,21 @@
+import { Identity } from '../core/identify';
+export interface DiscoverOptions {
+    /** TCP port to probe. Default 9100 (raw printing). */
+    port?: number;
+    /** Per-host connect timeout in milliseconds. Default 400. */
+    timeout?: number;
+    /** Simultaneous probes. Default 64. */
+    concurrency?: number;
+    /** Subnets as "192.168.1" prefixes; defaults to every private IPv4 /24 this machine is on. */
+    subnets?: string[];
+    /** Ask each printer found for its maker and model. Default false. */
+    identify?: boolean;
+}
+export interface DiscoveredPrinter {
+    host: string;
+    port: number;
+    identity?: Identity;
+}
+export declare function localSubnets(): string[];
+/** Sweeps the local /24 networks for hosts that accept raw printing connections. */
+export declare function discoverNetworkPrinters(options?: DiscoverOptions): Promise<DiscoveredPrinter[]>;

package/dist/transports/discover.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localSubnets = localSubnets;
+exports.discoverNetworkPrinters = discoverNetworkPrinters;
+const net_1 = __importDefault(require("net"));
+const os_1 = __importDefault(require("os"));
+const net_2 = require("./net");
+const identify_1 = require("../core/identify");
+function isPrivate(ip) {
+    return /^10\./.test(ip) || /^192\.168\./.test(ip) || /^172\.(1[6-9]|2\d|3[01])\./.test(ip);
+}
+function localSubnets() {
+    const out = new Set();
+    for (const list of Object.values(os_1.default.networkInterfaces())) {
+        for (const a of list ?? []) {
+            if (a.family === 'IPv4' && !a.internal && isPrivate(a.address))
+                out.add(a.address.split('.').slice(0, 3).join('.'));
+        }
+    }
+    return [...out];
+}
+function probe(host, port, timeout) {
+    return new Promise((resolve) => {
+        const s = new net_1.default.Socket();
+        const done = (ok) => {
+            s.destroy();
+            resolve(ok);
+        };
+        s.setTimeout(timeout, () => done(false));
+        s.once('error', () => done(false));
+        s.connect(port, host, () => done(true));
+    });
+}
+/** Sweeps the local /24 networks for hosts that accept raw printing connections. */
+async function discoverNetworkPrinters(options = {}) {
+    const port = options.port ?? 9100;
+    const timeout = options.timeout ?? 400;
+    const subnets = options.subnets ?? localSubnets();
+    const hosts = [];
+    for (const s of subnets)
+        for (let i = 1; i < 255; i++)
+            hosts.push(`${s}.${i}`);
+    const found = [];
+    let next = 0;
+    const worker = async () => {
+        while (next < hosts.length) {
+            const host = hosts[next++];
+            if (await probe(host, port, timeout))
+                found.push({ host, port });
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(options.concurrency ?? 64, hosts.length) }, worker));
+    found.sort((a, b) => a.host.localeCompare(b.host, undefined, { numeric: true }));
+    if (options.identify) {
+        for (const p of found) {
+            const t = new net_2.NetTransport(p.host, { port: p.port, timeout: 2000 });
+            try {
+                await t.open();
+                p.identity = await (0, identify_1.identify)(t, 800);
+            }
+            catch {
+                /* leave unidentified */
+            }
+            finally {
+                await t.close().catch(() => undefined);
+            }
+        }
+    }
+    return found;
+}

package/dist/transports/net.d.ts

@@ -0,0 +1,20 @@
+import { Transport } from './types';
+export interface NetOptions {
+    port?: number;
+    /** Connect and write timeout in milliseconds. Default 5000. */
+    timeout?: number;
+}
+/** Raw TCP ("JetDirect", port 9100). Pure Node, works with every network receipt printer. */
+export declare class NetTransport implements Transport {
+    readonly host: string;
+    readonly name = "net";
+    private socket;
+    private readonly inbox;
+    private readonly port;
+    private readonly timeout;
+    constructor(host: string, options?: NetOptions);
+    open(): Promise<void>;
+    write(bytes: Buffer): Promise<void>;
+    read(timeoutMs: number): Promise<Buffer>;
+    close(): Promise<void>;
+}

package/dist/transports/net.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetTransport = void 0;
+const net_1 = __importDefault(require("net"));
+const types_1 = require("./types");
+/** Raw TCP ("JetDirect", port 9100). Pure Node, works with every network receipt printer. */
+class NetTransport {
+    constructor(host, options = {}) {
+        this.host = host;
+        this.name = 'net';
+        this.socket = null;
+        this.inbox = new types_1.ReadQueue();
+        this.port = options.port ?? 9100;
+        this.timeout = options.timeout ?? 5000;
+    }
+    open() {
+        return new Promise((resolve, reject) => {
+            const socket = new net_1.default.Socket();
+            const fail = (err) => {
+                socket.destroy();
+                this.socket = null;
+                reject(err);
+            };
+            socket.setTimeout(this.timeout, () => fail(new Error(`retail-print-kit: timeout connecting to ${this.host}:${this.port}`)));
+            socket.once('error', fail);
+            socket.connect(this.port, this.host, () => {
+                socket.removeListener('error', fail);
+                socket.setTimeout(0);
+                socket.on('data', (d) => this.inbox.push(Buffer.from(d)));
+                socket.on('error', () => this.inbox.clear());
+                this.socket = socket;
+                resolve();
+            });
+        });
+    }
+    write(bytes) {
+        const socket = this.socket;
+        if (!socket)
+            return Promise.reject(new Error('retail-print-kit: net transport is not open'));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`retail-print-kit: timeout writing to ${this.host}:${this.port}`)), this.timeout);
+            socket.write(bytes, (err) => {
+                clearTimeout(timer);
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    read(timeoutMs) {
+        if (!this.socket)
+            return Promise.reject(new Error('retail-print-kit: net transport is not open'));
+        return this.inbox.next(timeoutMs, `${this.host}:${this.port}`);
+    }
+    close() {
+        const socket = this.socket;
+        this.socket = null;
+        this.inbox.clear();
+        if (!socket)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            socket.once('close', () => resolve());
+            socket.end();
+            setTimeout(() => socket.destroy(), this.timeout).unref();
+        });
+    }
+}
+exports.NetTransport = NetTransport;

package/dist/transports/serial.d.ts

@@ -0,0 +1,20 @@
+import { Transport } from './types';
+export interface SerialOptions {
+    baudRate?: number;
+    /** Write timeout in milliseconds. Default 5000. */
+    timeout?: number;
+}
+/** RS-232 / USB-serial printer. Needs the optional `serialport` peer dependency. */
+export declare class SerialTransport implements Transport {
+    readonly path: string;
+    private readonly options;
+    readonly name = "serial";
+    private port;
+    private readonly inbox;
+    constructor(path: string, options?: SerialOptions);
+    static list(): Promise<string[]>;
+    open(): Promise<void>;
+    write(bytes: Buffer): Promise<void>;
+    read(timeoutMs: number): Promise<Buffer>;
+    close(): Promise<void>;
+}

package/dist/transports/serial.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialTransport = void 0;
+const types_1 = require("./types");
+function loadSerial() {
+    try {
+        return require('serialport').SerialPort;
+    }
+    catch (err) {
+        throw new Error('retail-print-kit: the "serialport" package is not installed; run `npm install serialport` to print over serial');
+    }
+}
+/** RS-232 / USB-serial printer. Needs the optional `serialport` peer dependency. */
+class SerialTransport {
+    constructor(path, options = {}) {
+        this.path = path;
+        this.options = options;
+        this.name = 'serial';
+        this.port = null;
+        this.inbox = new types_1.ReadQueue();
+    }
+    static async list() {
+        const SerialPort = loadSerial();
+        const ports = await SerialPort.list();
+        return ports.map((p) => p.path);
+    }
+    open() {
+        const SerialPort = loadSerial();
+        return new Promise((resolve, reject) => {
+            const port = new SerialPort({ path: this.path, baudRate: this.options.baudRate ?? 9600 }, (err) => {
+                if (err)
+                    return reject(err);
+                port.on('data', (d) => this.inbox.push(Buffer.from(d)));
+                this.port = port;
+                resolve();
+            });
+        });
+    }
+    write(bytes) {
+        const port = this.port;
+        if (!port)
+            return Promise.reject(new Error('retail-print-kit: serial transport is not open'));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`retail-print-kit: timeout writing to ${this.path}`)), this.options.timeout ?? 5000);
+            port.write(bytes, (err) => {
+                if (err) {
+                    clearTimeout(timer);
+                    return reject(err);
+                }
+                port.drain((e) => {
+                    clearTimeout(timer);
+                    e ? reject(e) : resolve();
+                });
+            });
+        });
+    }
+    read(timeoutMs) {
+        if (!this.port)
+            return Promise.reject(new Error('retail-print-kit: serial transport is not open'));
+        return this.inbox.next(timeoutMs, this.path);
+    }
+    close() {
+        const port = this.port;
+        this.port = null;
+        this.inbox.clear();
+        if (!port || !port.isOpen)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => port.close((err) => (err ? reject(err) : resolve())));
+    }
+}
+exports.SerialTransport = SerialTransport;

package/dist/transports/types.d.ts

@@ -0,0 +1,16 @@
+export interface Transport {
+    readonly name: string;
+    open(): Promise<void>;
+    write(bytes: Buffer): Promise<void>;
+    /** Resolves with the next bytes the printer sends, or rejects after `timeoutMs`. Optional. */
+    read?(timeoutMs: number): Promise<Buffer>;
+    close(): Promise<void>;
+}
+/** Shared read queue for transports that receive data as events. */
+export declare class ReadQueue {
+    private chunks;
+    private waiters;
+    push(chunk: Buffer): void;
+    next(timeoutMs: number, what: string): Promise<Buffer>;
+    clear(): void;
+}

package/dist/transports/types.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadQueue = void 0;
+/** Shared read queue for transports that receive data as events. */
+class ReadQueue {
+    constructor() {
+        this.chunks = [];
+        this.waiters = [];
+    }
+    push(chunk) {
+        const w = this.waiters.shift();
+        if (w) {
+            clearTimeout(w.timer);
+            w.resolve(chunk);
+        }
+        else {
+            this.chunks.push(chunk);
+        }
+    }
+    next(timeoutMs, what) {
+        const ready = this.chunks.shift();
+        if (ready)
+            return Promise.resolve(ready);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.waiters = this.waiters.filter((x) => x.timer !== timer);
+                reject(new Error(`retail-print-kit: timeout waiting for ${what}`));
+            }, timeoutMs);
+            this.waiters.push({ resolve, reject, timer });
+        });
+    }
+    clear() {
+        this.chunks = [];
+        for (const w of this.waiters) {
+            clearTimeout(w.timer);
+            w.reject(new Error('retail-print-kit: transport closed'));
+        }
+        this.waiters = [];
+    }
+}
+exports.ReadQueue = ReadQueue;

package/dist/transports/usb.d.ts

@@ -0,0 +1,30 @@
+import { Transport } from './types';
+export interface UsbOptions {
+    vendorId?: number;
+    productId?: number;
+    /** Write timeout in milliseconds. Default 5000. */
+    timeout?: number;
+}
+/**
+ * USB printer-class device. Needs the optional `usb` peer dependency. The detach listener is
+ * attached on open and removed on close, so nothing leaks across printer instances.
+ */
+export declare class UsbTransport implements Transport {
+    private readonly options;
+    readonly name = "usb";
+    private usb;
+    private device;
+    private endpoint;
+    private inEndpoint;
+    private iface;
+    private onDetach;
+    constructor(options?: UsbOptions);
+    static list(): Array<{
+        vendorId: number;
+        productId: number;
+    }>;
+    open(): Promise<void>;
+    write(bytes: Buffer): Promise<void>;
+    read(timeoutMs: number): Promise<Buffer>;
+    close(): Promise<void>;
+}