@mmote/niimblue-node 0.0.7

package/README.md

@@ -0,0 +1,101 @@
+## niimblue-node [![NPM](https://img.shields.io/npm/v/@mmote/niimblue-node)](https://npmjs.com/package/@mmote/niimblue-node)
+
+[niimbluelib](https://github.com/MultiMote/niimbluelib) BLE and serial client implementations for non-browser use cases.
+
+Command line interface, simple REST server are also included.
+
+Tested with:
+
+* Windows 10
+* Bluetooth adapter (TP-LINK UB500)
+* USB serial connection
+* Printers: B1, D110
+
+Usage example:
+
+* [src/service.ts](src/service.ts)
+
+### Install
+
+Global (for cli usage):
+
+```bash
+npm i -g @mmote/niimblue-node
+```
+
+[node-gyp](https://www.npmjs.com/package/node-gyp) is required to install [noble](https://www.npmjs.com/package/@abandonware/noble) dependency.
+It requires working compiler installed on your system.
+
+Windows requirements:
+
+* [MS Build tools 2019+](https://visualstudio.microsoft.com/downloads/?q=build+tools)
+  - C++ build tools with `Windows SDK >=22000` must be installed
+* Python 3
+
+See [node-gyp](https://github.com/nodejs/node-gyp) and [noble](https://github.com/abandonware/noble) installation.
+
+### Command-line usage
+
+While development:
+
+```bash
+npm run cli --- <options>
+```
+
+If installed as package globally:
+
+```bash
+niimblue-cli <options>
+```
+
+Available options:
+
+```bash
+niimblue-cli help print
+niimblue-cli help info
+niimblue-cli help scan
+niimblue-cli help server
+niimblue-cli help flash
+```
+
+#### Examples
+
+B1 BLE:
+
+```bash
+niimblue-cli print -d -t ble -a 27:03:07:17:6e:82 -p B1 -o top label_15x30.png
+```
+
+D110 BLE:
+
+```bash
+niimblue-cli print -d -t ble -a 26:03:03:c3:f9:11 -p D110 -o left label_15x30.png
+```
+
+B1 serial, long parameter names (will resize image to fit 50x30 label keeping aspect ration):
+
+```bash
+niimblue-cli print --debug --transport serial --address COM8 --print-task B1 --print-direction top --label-width 384 --label-height 240 label_15x30.png
+```
+
+B1 firmware upgrade via serial:
+
+```bash
+niimblue-cli flash -t serial -a COM8 -n 5.14 -f path/to/B1_5.14.bin
+```
+
+### Server mode
+
+You can start a simple server with:
+
+```bash
+niimblue-cli server
+```
+
+Enable debug logging, set host and port, enable CORS:
+
+```bash
+niimblue-cli server -d -h 0.0.0.0 -p 5000 --cors
+```
+
+[Server API docs](https://multimote.github.io/niimblue-node/server/)

package/cli.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "./dist/cli/index.js"

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extra_typings_1 = require("@commander-js/extra-typings");
+const niimbluelib_1 = require("@mmote/niimbluelib");
+const server_1 = require("../server");
+const worker_1 = require("./worker");
+const intOption = (value) => {
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed) || parsed < 0) {
+        throw new extra_typings_1.InvalidArgumentError("Integer required");
+    }
+    return parsed;
+};
+extra_typings_1.program.name("niimblue-cli");
+extra_typings_1.program
+    .command("info")
+    .description("Printer information")
+    .requiredOption("-d, --debug", "Debug information", false)
+    .addOption(new extra_typings_1.Option("-t, --transport <type>", "Transport").makeOptionMandatory().choices(["ble", "serial"]))
+    .requiredOption("-a, --address <string>", "Device bluetooth address or serial port name/path")
+    .action(worker_1.cliPrinterInfo);
+extra_typings_1.program
+    .command("scan")
+    .description("Get available device list")
+    .requiredOption("-n, --timeout <number>", "Timeout", intOption, 5000)
+    .addOption(new extra_typings_1.Option("-t, --transport <type>", "Transport").makeOptionMandatory().choices(["ble", "serial"]))
+    .action(worker_1.cliScan);
+extra_typings_1.program
+    .command("print")
+    .description("Prints image")
+    .argument("<path>", "PNG image path")
+    .requiredOption("-d, --debug", "Debug information", false)
+    .addOption(new extra_typings_1.Option("-t, --transport <type>", "Transport").makeOptionMandatory().choices(["ble", "serial"]))
+    .requiredOption("-a, --address <string>", "Device bluetooth address or serial port name/path")
+    .addOption(new extra_typings_1.Option("-o, --print-direction <dir>", "Print direction").choices(["left", "top"]))
+    .addOption(new extra_typings_1.Option("-p, --print-task <type>", "Print task").choices(niimbluelib_1.printTaskNames))
+    .requiredOption("-l, --label-type <type number>", "Label type", intOption, 1)
+    .requiredOption("-q, --density <number>", "Density", intOption, 3)
+    .requiredOption("-n, --quantity <number>", "Quantity", intOption, 1)
+    .requiredOption("-x, --threshold <number>", "Threshold", intOption, 128)
+    .option("-w, --label-width <number>", "Label width", intOption)
+    .option("-h, --label-height <number>", "Label height", intOption)
+    .addOption(new extra_typings_1.Option("-f, --image-fit <dir>", "Image fit while resizing (label-width and label-height must be set)").choices([
+    "contain",
+    "cover",
+    "fill",
+    "inside",
+    "outside",
+]).default("contain"))
+    .addOption(new extra_typings_1.Option("-m, --image-position <dir>", "Image position while resizing (label-width and label-height must be set)").choices([
+    "left",
+    "top",
+    "centre",
+    "right top",
+    "right",
+    "right bottom",
+    "bottom",
+    "left bottom",
+    "left top",
+]).default("centre"))
+    .action(worker_1.cliConnectAndPrintImageFile);
+extra_typings_1.program
+    .command("server")
+    .description("Start in server mode")
+    .requiredOption("-d, --debug", "Debug information", false)
+    .requiredOption("-c, --cors", "Enable CORS", false)
+    .requiredOption("-p, --port <number>", "Listen port", intOption, 5000)
+    .requiredOption("-h, --host <host>", "Listen hostname", "localhost")
+    .action(server_1.cliStartServer);
+extra_typings_1.program
+    .command("flash")
+    .description("Flash firmware")
+    .requiredOption("-d, --debug", "Debug information", false)
+    .addOption(new extra_typings_1.Option("-t, --transport <type>", "Transport").makeOptionMandatory().choices(["ble", "serial"]))
+    .requiredOption("-a, --address <string>", "Device bluetooth address or serial port name/path")
+    .requiredOption("-f, --file <path>", "Firmware path")
+    .requiredOption("-n, --new-version <version>", "New firmware version")
+    .action(worker_1.cliFlashFirmware);
+extra_typings_1.program.parse();

package/dist/cli/worker.d.ts

@@ -0,0 +1,41 @@
+import { LabelType, PrintDirection, PrintTaskName } from "@mmote/niimbluelib";
+import { TransportType } from "../utils";
+export type SharpImageFit = "contain" | "cover" | "fill" | "inside" | "outside";
+export type SharpImagePosition = "left" | "top" | "centre" | "right top" | "right" | "right bottom" | "bottom" | "left bottom" | "left top";
+export interface TransportOptions {
+    transport: TransportType;
+    address: string;
+}
+export interface ScanOptions {
+    transport: TransportType;
+    timeout: number;
+}
+export interface InfoOptions {
+    transport: TransportType;
+    address: string;
+    debug: boolean;
+}
+export interface FirmwareOptions {
+    transport: TransportType;
+    address: string;
+    file: string;
+    newVersion: string;
+    debug: boolean;
+}
+export interface PrintOptions {
+    printTask?: PrintTaskName;
+    printDirection?: PrintDirection;
+    quantity: number;
+    labelType: LabelType;
+    density: number;
+    threshold: number;
+    labelWidth?: number;
+    labelHeight?: number;
+    imageFit: SharpImageFit;
+    imagePosition: SharpImagePosition;
+    debug: boolean;
+}
+export declare const cliConnectAndPrintImageFile: (path: string, options: PrintOptions & TransportOptions) => Promise<never>;
+export declare const cliScan: (options: ScanOptions) => Promise<never>;
+export declare const cliPrinterInfo: (options: InfoOptions) => Promise<never>;
+export declare const cliFlashFirmware: (options: FirmwareOptions) => Promise<never>;

package/dist/cli/worker.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliFlashFirmware = exports.cliPrinterInfo = exports.cliScan = exports.cliConnectAndPrintImageFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const sharp_1 = __importDefault(require("sharp"));
+const __1 = require("..");
+const utils_1 = require("../utils");
+const extra_typings_1 = require("@commander-js/extra-typings");
+const cliConnectAndPrintImageFile = async (path, options) => {
+    const client = (0, utils_1.initClient)(options.transport, options.address, options.debug);
+    if (options.debug) {
+        console.log("Connecting to", options.transport, options.address);
+    }
+    await client.connect();
+    let image = await (0, utils_1.loadImageFromFile)(path);
+    image = image.flatten({ background: "#fff" }).threshold(options.threshold);
+    if (options.labelWidth !== undefined && options.labelHeight !== undefined) {
+        image = image.resize(options.labelWidth, options.labelHeight, {
+            kernel: sharp_1.default.kernel.nearest,
+            fit: options.imageFit,
+            position: options.imagePosition,
+            background: "#fff",
+        });
+    }
+    else if (options.imageFit !== undefined || options.imagePosition !== undefined) {
+        throw new extra_typings_1.InvalidArgumentError("label-width and label-height must be set");
+    }
+    const printDirection = options.printDirection ?? client.getModelMetadata()?.printDirection;
+    const printTask = options.printTask ?? client.getPrintTaskType();
+    const encoded = await __1.ImageEncoder.encodeImage(image, printDirection);
+    if (printTask === undefined) {
+        throw new Error("Unable to detect print task, please set it manually");
+    }
+    if (options.debug) {
+        console.log("Print task:", printTask);
+    }
+    try {
+        await (0, utils_1.printImage)(client, printTask, encoded, {
+            quantity: options.quantity,
+            labelType: options.labelType,
+            density: options.density,
+        });
+    }
+    finally {
+        await client.disconnect();
+    }
+    process.exit(0);
+};
+exports.cliConnectAndPrintImageFile = cliConnectAndPrintImageFile;
+const cliScan = async (options) => {
+    if (options.transport === "ble") {
+        const devices = await __1.NiimbotHeadlessBleClient.scan(options.timeout);
+        devices.forEach((dev) => console.log(`${dev.address}: ${dev.name}`));
+    }
+    else if (options.transport === "serial") {
+        const devices = await __1.NiimbotHeadlessSerialClient.scan();
+        devices.forEach((dev) => console.log(`${dev.address}: ${dev.name}`));
+    }
+    process.exit(0);
+};
+exports.cliScan = cliScan;
+const cliPrinterInfo = async (options) => {
+    const client = (0, utils_1.initClient)(options.transport, options.address, options.debug);
+    await client.connect();
+    console.log("Printer info:", client.getPrinterInfo());
+    console.log("Model metadata:", client.getModelMetadata());
+    console.log("Detected print task:", client.getPrintTaskType());
+    await client.disconnect();
+    process.exit(0);
+};
+exports.cliPrinterInfo = cliPrinterInfo;
+const cliFlashFirmware = async (options) => {
+    const data = fs_1.default.readFileSync(options.file);
+    const client = (0, utils_1.initClient)(options.transport, options.address, options.debug);
+    await client.connect();
+    client.stopHeartbeat();
+    const listener = (e) => {
+        console.log(`Sending ${e.currentChunk}/${e.totalChunks}`);
+    };
+    client.on("firmwareprogress", listener);
+    try {
+        console.log("Uploading firmware...");
+        await client.abstraction.firmwareUpgrade(data, options.newVersion);
+        console.log("Done, printer will shut down");
+    }
+    finally {
+        client.off("firmwareprogress", listener);
+        await client.disconnect();
+    }
+    process.exit(0);
+};
+exports.cliFlashFirmware = cliFlashFirmware;

package/dist/client/headless_ble_impl.d.ts

@@ -0,0 +1,21 @@
+import { ConnectionInfo, NiimbotAbstractClient } from "@mmote/niimbluelib";
+export interface ScanItem {
+    address: string;
+    name: string;
+}
+export declare class NiimbotHeadlessBleClient extends NiimbotAbstractClient {
+    private addr;
+    private device;
+    private channel;
+    constructor();
+    /** Set device mac address for connect */
+    setAddress(address: string): void;
+    static waitAdapterReady(): Promise<void>;
+    static scan(timeoutMs?: number): Promise<ScanItem[]>;
+    private getDevice;
+    private connectToDevice;
+    connect(): Promise<ConnectionInfo>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+    sendRaw(data: Uint8Array, force?: boolean): Promise<void>;
+}

package/dist/client/headless_ble_impl.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NiimbotHeadlessBleClient = void 0;
+const noble_1 = __importDefault(require("@abandonware/noble"));
+const niimbluelib_1 = require("@mmote/niimbluelib");
+class NiimbotHeadlessBleClient extends niimbluelib_1.NiimbotAbstractClient {
+    constructor() {
+        super();
+        this.addr = "";
+    }
+    /** Set device mac address for connect */
+    setAddress(address) {
+        this.addr = address.toLowerCase();
+    }
+    static async waitAdapterReady() {
+        if (noble_1.default._state === "poweredOn") {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            let timer;
+            noble_1.default.on("stateChange", async (state) => {
+                clearTimeout(timer);
+                if (state === "poweredOn") {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`BLE state is ${state}`));
+                }
+            });
+            timer = setTimeout(() => {
+                reject(new Error("Can't init BLE"));
+            }, 5000);
+        });
+    }
+    static async scan(timeoutMs = 5000) {
+        await NiimbotHeadlessBleClient.waitAdapterReady();
+        return new Promise((resolve, reject) => {
+            const peripherals = [];
+            let timer;
+            noble_1.default.on("discover", async (peripheral) => {
+                peripherals.push({
+                    address: peripheral.address,
+                    name: peripheral.advertisement.localName || "unknown",
+                });
+            });
+            noble_1.default.startScanning([], false, (error) => {
+                if (error) {
+                    clearTimeout(timer);
+                    reject(error);
+                }
+            });
+            timer = setTimeout(() => {
+                noble_1.default.stopScanning();
+                resolve(peripherals);
+            }, timeoutMs ?? 5000);
+        });
+    }
+    async getDevice(address, timeoutMs = 5000) {
+        await NiimbotHeadlessBleClient.waitAdapterReady();
+        return new Promise((resolve, reject) => {
+            let timer;
+            noble_1.default.on("discover", async (peripheral) => {
+                if (peripheral.address === address) {
+                    clearTimeout(timer);
+                    resolve(peripheral);
+                }
+            });
+            noble_1.default.startScanning([], false, (error) => {
+                if (error)
+                    reject(error);
+            });
+            timer = setTimeout(() => {
+                noble_1.default.stopScanning();
+                reject(new Error("Device not found"));
+            }, timeoutMs ?? 5000);
+        });
+    }
+    async connectToDevice(address, timeoutMs = 5000) {
+        const periph = await this.getDevice(address, timeoutMs);
+        await periph.connectAsync();
+        const services = await periph.discoverServicesAsync();
+        let channelCharacteristic;
+        for (const service of services) {
+            if (service.uuid.length < 5) {
+                continue;
+            }
+            const characteristics = await service.discoverCharacteristicsAsync();
+            const suitableCharacteristic = characteristics.find((ch) => ch.properties.includes("notify") && ch.properties.includes("writeWithoutResponse"));
+            if (suitableCharacteristic) {
+                channelCharacteristic = suitableCharacteristic;
+                break;
+            }
+        }
+        if (channelCharacteristic === undefined) {
+            await periph.disconnectAsync();
+            throw new Error("Unable to find suitable channel characteristic");
+        }
+        periph.on("disconnect", () => {
+            this.stopHeartbeat();
+            this.emit("disconnect", new niimbluelib_1.DisconnectEvent());
+            this.device = undefined;
+            this.channel = undefined;
+        });
+        channelCharacteristic.on("read", (data, isNotification) => {
+            if (isNotification)
+                this.processRawPacket(new Uint8Array(data));
+        });
+        channelCharacteristic.subscribeAsync();
+        this.channel = channelCharacteristic;
+        this.device = periph;
+    }
+    async connect() {
+        await this.disconnect();
+        if (!this.addr) {
+            throw new Error("Device address not set");
+        }
+        await this.connectToDevice(this.addr);
+        try {
+            await this.initialNegotiate();
+            await this.fetchPrinterInfo();
+        }
+        catch (e) {
+            console.error("Unable to fetch printer info.");
+            console.error(e);
+        }
+        const result = {
+            deviceName: this.device.advertisement.localName ?? this.addr,
+            result: this.info.connectResult ?? niimbluelib_1.ConnectResult.FirmwareErrors,
+        };
+        this.emit("connect", new niimbluelib_1.ConnectEvent(result));
+        return result;
+    }
+    isConnected() {
+        return this.device !== undefined && this.channel !== undefined;
+    }
+    async disconnect() {
+        this.stopHeartbeat();
+        if (this.device !== undefined) {
+            await this.device.disconnectAsync();
+            this.emit("disconnect", new niimbluelib_1.DisconnectEvent());
+        }
+        this.device = undefined;
+        this.channel = undefined;
+    }
+    async sendRaw(data, force) {
+        const send = async () => {
+            if (!this.isConnected()) {
+                this.disconnect();
+                throw new Error("Disconnected");
+            }
+            await niimbluelib_1.Utils.sleep(this.packetIntervalMs);
+            await this.channel.writeAsync(Buffer.from(data), true);
+            this.emit("rawpacketsent", new niimbluelib_1.RawPacketSentEvent(data));
+        };
+        if (force) {
+            await send();
+        }
+        else {
+            await this.mutex.runExclusive(send);
+        }
+    }
+}
+exports.NiimbotHeadlessBleClient = NiimbotHeadlessBleClient;

package/dist/client/headless_serial_impl.d.ts

@@ -0,0 +1,20 @@
+import { ConnectionInfo, NiimbotAbstractClient } from "@mmote/niimbluelib";
+export interface ScanItem {
+    address: string;
+    name: string;
+}
+/** WIP. Uses serial communication (serialport lib) */
+export declare class NiimbotHeadlessSerialClient extends NiimbotAbstractClient {
+    private device?;
+    private portName?;
+    private isOpen;
+    constructor();
+    /** Set port for connect */
+    setPort(portName: string): void;
+    connect(): Promise<ConnectionInfo>;
+    private dataReady;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    sendRaw(data: Uint8Array, force?: boolean): Promise<void>;
+    static scan(): Promise<ScanItem[]>;
+}

package/dist/client/headless_serial_impl.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NiimbotHeadlessSerialClient = void 0;
+const serialport_1 = require("serialport");
+const niimbluelib_1 = require("@mmote/niimbluelib");
+// Open SerialPort asynchronously instead of callback
+const serialOpenAsync = (path) => {
+    return new Promise((resolve, reject) => {
+        const p = new serialport_1.SerialPort({ path, baudRate: 115200, endOnClose: true, autoOpen: false });
+        p.open((err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(p);
+            }
+        });
+    });
+};
+/** WIP. Uses serial communication (serialport lib) */
+class NiimbotHeadlessSerialClient extends niimbluelib_1.NiimbotAbstractClient {
+    constructor() {
+        super();
+        this.isOpen = false;
+    }
+    /** Set port for connect */
+    setPort(portName) {
+        this.portName = portName;
+    }
+    async connect() {
+        await this.disconnect();
+        if (!this.portName) {
+            throw new Error("Port not set");
+        }
+        const _port = await serialOpenAsync(this.portName);
+        this.isOpen = true;
+        _port.on("close", () => {
+            this.isOpen = false;
+            this.emit("disconnect", new niimbluelib_1.DisconnectEvent());
+        });
+        _port.on("readable", () => {
+            this.dataReady();
+        });
+        this.device = _port;
+        try {
+            await this.initialNegotiate();
+            await this.fetchPrinterInfo();
+        }
+        catch (e) {
+            console.error("Unable to fetch printer info (is it turned on?).");
+            console.error(e);
+        }
+        const result = {
+            deviceName: `Serial (${this.portName})`,
+            result: this.info.connectResult ?? niimbluelib_1.ConnectResult.FirmwareErrors,
+        };
+        this.emit("connect", new niimbluelib_1.ConnectEvent(result));
+        return result;
+    }
+    dataReady() {
+        while (true) {
+            try {
+                const result = this.device.read();
+                if (result !== null) {
+                    if (this.debug) {
+                        console.info(`<< serial chunk ${niimbluelib_1.Utils.bufToHex(result)}`);
+                    }
+                    this.processRawPacket(result);
+                }
+                else {
+                    break;
+                }
+            }
+            catch (_e) {
+                break;
+            }
+        }
+    }
+    async disconnect() {
+        this.stopHeartbeat();
+        this.device?.close();
+    }
+    isConnected() {
+        return this.isOpen;
+    }
+    async sendRaw(data, force) {
+        const send = async () => {
+            if (!this.isConnected()) {
+                throw new Error("Not connected");
+            }
+            await niimbluelib_1.Utils.sleep(this.packetIntervalMs);
+            this.device.write(Buffer.from(data));
+            this.emit("rawpacketsent", new niimbluelib_1.RawPacketSentEvent(data));
+        };
+        if (force) {
+            await send();
+        }
+        else {
+            await this.mutex.runExclusive(send);
+        }
+    }
+    static async scan() {
+        const ports = await serialport_1.SerialPort.list();
+        return ports.map((p) => {
+            let name = "unknown";
+            let pRaw = p;
+            if (pRaw["friendlyName"] !== undefined) {
+                name = pRaw["friendlyName"];
+            }
+            else if (p.pnpId !== undefined) {
+                name = p.pnpId;
+            }
+            return {
+                name,
+                address: p.path,
+            };
+        });
+    }
+}
+exports.NiimbotHeadlessSerialClient = NiimbotHeadlessSerialClient;

package/dist/image_encoder.d.ts

@@ -0,0 +1,6 @@
+import { EncodedImage, PrintDirection } from "@mmote/niimbluelib";
+import sharp from "sharp";
+export declare class ImageEncoder {
+    static encodeImage(src: sharp.Sharp, printDirection?: PrintDirection): Promise<EncodedImage>;
+    static isPixelNonWhite(buf: Buffer<ArrayBufferLike>, imgWidth: number, imgHeight: number, x: number, y: number, printDirection?: PrintDirection): boolean;
+}

package/dist/image_encoder.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageEncoder = void 0;
+const niimbluelib_1 = require("@mmote/niimbluelib");
+class ImageEncoder {
+    static async encodeImage(src, printDirection = "left") {
+        const rowsData = [];
+        const { data, info } = await src
+            .flatten({ background: "#fff" })
+            .toColorspace("b-w")
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        let cols = info.width;
+        let rows = info.height;
+        if (printDirection === "left") {
+            cols = info.height;
+            rows = info.width;
+        }
+        if (cols % 8 !== 0) {
+            throw new Error("Column count must be multiple of 8");
+        }
+        for (let row = 0; row < rows; row++) {
+            let isVoid = true;
+            let blackPixelsCount = 0;
+            const rowData = new Uint8Array(cols / 8);
+            for (let colOct = 0; colOct < cols / 8; colOct++) {
+                let pixelsOctet = 0;
+                for (let colBit = 0; colBit < 8; colBit++) {
+                    if (ImageEncoder.isPixelNonWhite(data, info.width, info.height, colOct * 8 + colBit, row, printDirection)) {
+                        pixelsOctet |= 1 << (7 - colBit);
+                        isVoid = false;
+                        blackPixelsCount++;
+                    }
+                }
+                rowData[colOct] = pixelsOctet;
+            }
+            const newPart = {
+                dataType: isVoid ? "void" : "pixels",
+                rowNumber: row,
+                repeat: 1,
+                rowData: isVoid ? undefined : rowData,
+                blackPixelsCount,
+            };
+            // Check previous row and increment repeats instead of adding new row if data is same
+            if (rowsData.length === 0) {
+                rowsData.push(newPart);
+            }
+            else {
+                const lastPacket = rowsData[rowsData.length - 1];
+                let same = newPart.dataType === lastPacket.dataType;
+                if (same && newPart.dataType === "pixels") {
+                    same = niimbluelib_1.Utils.u8ArraysEqual(newPart.rowData, lastPacket.rowData);
+                }
+                if (same) {
+                    lastPacket.repeat++;
+                }
+                else {
+                    rowsData.push(newPart);
+                }
+            }
+        }
+        return { cols, rows, rowsData };
+    }
+    static isPixelNonWhite(buf, imgWidth, imgHeight, x, y, printDirection = "left") {
+        let idx = y * imgWidth + x;
+        if (printDirection === "left") {
+            idx = (imgHeight - 1 - x) * imgWidth + y;
+        }
+        return buf.at(idx) !== 0xff;
+    }
+}
+exports.ImageEncoder = ImageEncoder;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { NiimbotHeadlessSerialClient } from "./client/headless_serial_impl";
+export { NiimbotHeadlessBleClient } from "./client/headless_ble_impl";
+export { ImageEncoder } from "./image_encoder";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,24 @@
+"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.ImageEncoder = exports.NiimbotHeadlessBleClient = exports.NiimbotHeadlessSerialClient = void 0;
+var headless_serial_impl_1 = require("./client/headless_serial_impl");
+Object.defineProperty(exports, "NiimbotHeadlessSerialClient", { enumerable: true, get: function () { return headless_serial_impl_1.NiimbotHeadlessSerialClient; } });
+var headless_ble_impl_1 = require("./client/headless_ble_impl");
+Object.defineProperty(exports, "NiimbotHeadlessBleClient", { enumerable: true, get: function () { return headless_ble_impl_1.NiimbotHeadlessBleClient; } });
+var image_encoder_1 = require("./image_encoder");
+Object.defineProperty(exports, "ImageEncoder", { enumerable: true, get: function () { return image_encoder_1.ImageEncoder; } });
+__exportStar(require("./utils"), exports);

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+export type ServerOptions = {
+    debug: boolean;
+    port: number;
+    host: string;
+    cors: boolean;
+};
+export declare const cliStartServer: (options: ServerOptions) => void;

package/dist/server/index.js

@@ -0,0 +1,59 @@
+"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.cliStartServer = void 0;
+const simple_server_1 = require("./simple_server");
+const w = __importStar(require("./worker"));
+const cliStartServer = (options) => {
+    w.setDebug(options.debug);
+    const s = new simple_server_1.SimpleServer();
+    if (options.cors) {
+        s.enableCors();
+    }
+    s.anything("/", w.index);
+    s.post("/connect", w.connect);
+    s.post("/disconnect", w.disconnect);
+    s.get("/connected", w.connected);
+    s.get("/info", w.info);
+    s.post("/print", w.print);
+    s.post("/scan", w.scan);
+    s.start(options.host, options.port, () => {
+        console.log(`Server is listening ${options.host}:${options.port}`);
+        if (options.cors) {
+            console.log("CORS enabled");
+        }
+    });
+};
+exports.cliStartServer = cliStartServer;

package/dist/server/simple_server.d.ts

@@ -0,0 +1,20 @@
+import http from "http";
+import { z } from "zod";
+type RouteHandler = (request: http.IncomingMessage) => unknown;
+export declare class RestError extends Error {
+    readonly status: number;
+    constructor(message: string, status?: number);
+}
+export declare const writeObj: (response: http.ServerResponse, o: unknown, status?: number) => void;
+export declare const readBodyJson: <T>(request: http.IncomingMessage, schema: z.ZodType<T>) => Promise<T>;
+export declare class SimpleServer {
+    private readonly routes;
+    private corsEnabled;
+    enableCors(): void;
+    get(path: string, handler: RouteHandler): void;
+    post(path: string, handler: RouteHandler): void;
+    anything(path: string, handler: RouteHandler): void;
+    private onRequest;
+    start(host: string, port: number, listeningListener?: () => void): void;
+}
+export {};

package/dist/server/simple_server.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleServer = exports.readBodyJson = exports.writeObj = exports.RestError = void 0;
+const http_1 = __importDefault(require("http"));
+const zod_1 = require("zod");
+class RestError extends Error {
+    constructor(message, status = 500) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.RestError = RestError;
+const writeObj = (response, o, status = 200) => {
+    response.setHeader("Content-Type", "application/json");
+    response.writeHead(status);
+    response.end(JSON.stringify(o));
+};
+exports.writeObj = writeObj;
+const readBodyJson = async (request, schema) => {
+    return new Promise((resolve, reject) => {
+        const bodyParts = [];
+        request
+            .on("data", (chunk) => {
+            bodyParts.push(chunk);
+        })
+            .on("end", () => {
+            let body = Buffer.concat(bodyParts).toString();
+            let data = null;
+            try {
+                data = JSON.parse(body);
+            }
+            catch (e) {
+                reject(e);
+            }
+            if (data === null) {
+                reject(new Error("No data"));
+            }
+            const result = schema.safeParse(data);
+            if (result.success) {
+                resolve(result.data);
+            }
+            else {
+                reject(result.error);
+            }
+        });
+    });
+};
+exports.readBodyJson = readBodyJson;
+class SimpleServer {
+    constructor() {
+        this.routes = [];
+        this.corsEnabled = false;
+    }
+    enableCors() {
+        this.corsEnabled = true;
+    }
+    get(path, handler) {
+        this.routes.push({ path, handler, method: "GET" });
+    }
+    post(path, handler) {
+        this.routes.push({ path, handler, method: "POST" });
+    }
+    anything(path, handler) {
+        this.routes.push({ path, handler });
+    }
+    async onRequest(request, response) {
+        if (request.url === undefined || request.method === undefined) {
+            return;
+        }
+        console.log(`${request.socket.remoteAddress} ${request.method} ${request.url}`);
+        if (this.corsEnabled) {
+            response.setHeader("Access-Control-Allow-Origin", "*");
+            response.setHeader("Access-Control-Allow-Headers", "*");
+            response.setHeader("Access-Control-Allow-Methods", "OPTIONS, POST, GET");
+            response.setHeader("Access-Control-Max-Age", 2592000); // 30 days
+            if (request.method === "OPTIONS") {
+                response.writeHead(204);
+                response.end();
+                return;
+            }
+        }
+        try {
+            const route = this.routes.find((r) => r.path === request.url && (r.method === undefined || r.method === request.method));
+            if (route === undefined) {
+                (0, exports.writeObj)(response, { error: "Not found" }, 404);
+                return;
+            }
+            if (request.method === "POST" && request.headers["content-type"] !== "application/json") {
+                (0, exports.writeObj)(response, { error: "Only JSON accepted" }, 400);
+                return;
+            }
+            const result = await route.handler(request);
+            (0, exports.writeObj)(response, result, 200);
+        }
+        catch (e) {
+            if (e instanceof zod_1.z.ZodError) {
+                const error = e.issues.map((i) => `${i.path.join("→")}: ${i.message}`).join("\n");
+                (0, exports.writeObj)(response, { error }, 400);
+            }
+            else if (e instanceof RestError) {
+                (0, exports.writeObj)(response, { error: e.message }, e.status);
+            }
+            else {
+                (0, exports.writeObj)(response, { error: `${e}` }, 500);
+            }
+        }
+    }
+    start(host, port, listeningListener) {
+        const server = http_1.default.createServer();
+        server.on("request", (req, res) => this.onRequest(req, res));
+        server.listen({ port, host }, listeningListener);
+    }
+}
+exports.SimpleServer = SimpleServer;

package/dist/server/worker.d.ts

@@ -0,0 +1,25 @@
+import { IncomingMessage } from "http";
+export declare const setDebug: (v: boolean) => void;
+export declare const index: () => {
+    message: string;
+};
+export declare const connect: (r: IncomingMessage) => Promise<{
+    message: string;
+}>;
+export declare const disconnect: () => Promise<{
+    message: string;
+}>;
+export declare const connected: () => Promise<{
+    connected: boolean;
+}>;
+export declare const info: () => Promise<{
+    printerInfo: import("@mmote/niimbluelib").PrinterInfo;
+    modelMetadata: import("@mmote/niimbluelib").PrinterModelMeta | undefined;
+    detectedPrintTask: "D11_V1" | "D110" | "B1" | "B21_V1" | "V5" | undefined;
+}>;
+export declare const print: (r: IncomingMessage) => Promise<{
+    message: string;
+}>;
+export declare const scan: (r: IncomingMessage) => Promise<{
+    devices: import("../client/headless_ble_impl").ScanItem[];
+}>;

package/dist/server/worker.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scan = exports.print = exports.info = exports.connected = exports.disconnect = exports.connect = exports.index = exports.setDebug = void 0;
+const niimbluelib_1 = require("@mmote/niimbluelib");
+const sharp_1 = __importDefault(require("sharp"));
+const zod_1 = require("zod");
+const headless_ble_impl_1 = require("../client/headless_ble_impl");
+const image_encoder_1 = require("../image_encoder");
+const utils_1 = require("../utils");
+const simple_server_1 = require("./simple_server");
+const headless_serial_impl_1 = require("../client/headless_serial_impl");
+let client = null;
+let debug = false;
+const ConnectSchema = zod_1.z.object({
+    transport: zod_1.z.enum(["serial", "ble"]),
+    address: zod_1.z.string(),
+});
+const ScanSchema = zod_1.z.object({
+    transport: zod_1.z.enum(["serial", "ble"]),
+    timeout: zod_1.z.number().default(5000),
+});
+const [firstTask, ...otherTasks] = niimbluelib_1.printTaskNames;
+const PrintSchema = zod_1.z
+    .object({
+    printDirection: zod_1.z.enum(["left", "top"]).optional(),
+    printTask: zod_1.z.enum([firstTask, ...otherTasks]).optional(),
+    quantity: zod_1.z.number().min(1).default(1),
+    labelType: zod_1.z.number().min(1).default(niimbluelib_1.LabelType.WithGaps),
+    density: zod_1.z.number().min(1).default(3),
+    imageBase64: zod_1.z.string().optional(),
+    imageUrl: zod_1.z.string().optional(),
+    labelWidth: zod_1.z.number().positive().optional(),
+    labelHeight: zod_1.z.number().positive().optional(),
+    threshold: zod_1.z.number().min(1).max(255).default(128),
+    imagePosition: zod_1.z
+        .enum(["centre", "top", "right top", "right", "right bottom", "bottom", "left bottom", "left", "left top"])
+        .default("centre"),
+    imageFit: zod_1.z.enum(["contain", "cover", "fill", "inside", "outside"]).default("contain"),
+})
+    .refine(({ imageUrl, imageBase64 }) => {
+    return !!imageUrl !== !!imageBase64;
+}, { message: "imageUrl or imageBase64 must be defined", path: ["image"] });
+const setDebug = (v) => {
+    debug = v;
+};
+exports.setDebug = setDebug;
+const assertConnected = () => {
+    if (!client?.isConnected()) {
+        throw new simple_server_1.RestError("Not connected", 400);
+    }
+};
+const index = () => ({ message: "Server is working" });
+exports.index = index;
+const connect = async (r) => {
+    const data = await (0, simple_server_1.readBodyJson)(r, ConnectSchema);
+    if (client?.isConnected()) {
+        throw new simple_server_1.RestError("Already connected", 400);
+    }
+    client = (0, utils_1.initClient)(data.transport, data.address, debug);
+    await client.connect();
+    return { message: "Connected" };
+};
+exports.connect = connect;
+const disconnect = async () => {
+    assertConnected();
+    await client.disconnect();
+    client = null;
+    return { message: "Disconnected" };
+};
+exports.disconnect = disconnect;
+const connected = async () => {
+    return { connected: !!client?.isConnected() };
+};
+exports.connected = connected;
+const info = async () => {
+    assertConnected();
+    return {
+        printerInfo: client.getPrinterInfo(),
+        modelMetadata: client.getModelMetadata(),
+        detectedPrintTask: client.getPrintTaskType(),
+    };
+};
+exports.info = info;
+const print = async (r) => {
+    assertConnected();
+    const options = await (0, simple_server_1.readBodyJson)(r, PrintSchema);
+    let image;
+    if (options.imageBase64 !== undefined) {
+        image = await (0, utils_1.loadImageFromBase64)(options.imageBase64);
+    }
+    else if (options.imageUrl !== undefined) {
+        image = await (0, utils_1.loadImageFromUrl)(options.imageUrl);
+    }
+    else {
+        throw new simple_server_1.RestError("Image is not defined", 400);
+    }
+    image = image.flatten({ background: "#fff" });
+    if (options.labelWidth !== undefined && options.labelHeight !== undefined) {
+        image = image.resize(options.labelWidth, options.labelHeight, {
+            kernel: sharp_1.default.kernel.nearest,
+            fit: options.imageFit,
+            position: options.imagePosition,
+            background: "#fff",
+        });
+    }
+    image = image.threshold(options.threshold);
+    // await image.toFile("tmp.png");
+    const printDirection = options.printDirection ?? client.getModelMetadata()?.printDirection;
+    const printTask = options.printTask ?? client.getPrintTaskType();
+    const encoded = await image_encoder_1.ImageEncoder.encodeImage(image, printDirection);
+    if (printTask === undefined) {
+        throw new simple_server_1.RestError("Unable to detect print task, please set it manually", 400);
+    }
+    if (debug) {
+        console.log("Print task:", printTask);
+    }
+    await (0, utils_1.printImage)(client, printTask, encoded, {
+        quantity: options.quantity,
+        labelType: options.labelType,
+        density: options.density,
+    });
+    return { message: "Printed" };
+};
+exports.print = print;
+const scan = async (r) => {
+    const options = await (0, simple_server_1.readBodyJson)(r, ScanSchema);
+    if (options.transport === "ble") {
+        return { devices: await headless_ble_impl_1.NiimbotHeadlessBleClient.scan(options.timeout) };
+    }
+    else if (options.transport === "serial") {
+        return { devices: await headless_serial_impl_1.NiimbotHeadlessSerialClient.scan() };
+    }
+    throw new simple_server_1.RestError("Invalid transport", 400);
+};
+exports.scan = scan;

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/image_encoder.ts","../src/index.ts","../src/utils.ts","../src/cli/index.ts","../src/cli/worker.ts","../src/client/headless_ble_impl.ts","../src/client/headless_serial_impl.ts","../src/server/index.ts","../src/server/simple_server.ts","../src/server/worker.ts"],"version":"5.7.3"}

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+import { EncodedImage, LabelType, NiimbotAbstractClient, PrintTaskName } from "@mmote/niimbluelib";
+import sharp from "sharp";
+export type TransportType = "serial" | "ble";
+export interface PrintOptions {
+    quantity?: number;
+    labelType?: LabelType;
+    density?: number;
+}
+export declare const initClient: (transport: TransportType, address: string, debug: boolean) => NiimbotAbstractClient;
+export declare const printImage: (client: NiimbotAbstractClient, printTaskName: PrintTaskName, encoded: EncodedImage, options: PrintOptions) => Promise<void>;
+export declare const loadImageFromBase64: (b64: string) => Promise<sharp.Sharp>;
+export declare const loadImageFromUrl: (url: string) => Promise<sharp.Sharp>;
+export declare const loadImageFromFile: (path: string) => Promise<sharp.Sharp>;

package/dist/utils.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImageFromFile = exports.loadImageFromUrl = exports.loadImageFromBase64 = exports.printImage = exports.initClient = void 0;
+const niimbluelib_1 = require("@mmote/niimbluelib");
+const fs_1 = __importDefault(require("fs"));
+const sharp_1 = __importDefault(require("sharp"));
+const stream_1 = require("stream");
+const _1 = require(".");
+const initClient = (transport, address, debug) => {
+    let client = null;
+    if (transport === "serial") {
+        client = new _1.NiimbotHeadlessSerialClient();
+        client.setPort(address);
+    }
+    else if (transport === "ble") {
+        client = new _1.NiimbotHeadlessBleClient();
+        client.setAddress(address);
+    }
+    else {
+        throw new Error("Invalid transport");
+    }
+    client.on("printprogress", (e) => {
+        console.log(`Page ${e.page}/${e.pagesTotal}, Page print ${e.pagePrintProgress}%, Page feed ${e.pageFeedProgress}%`);
+    });
+    client.on("heartbeatfailed", (e) => {
+        const maxFails = 5;
+        console.warn(`Heartbeat failed ${e.failedAttempts}/${maxFails}`);
+        if (e.failedAttempts >= maxFails) {
+            console.warn("Disconnecting");
+            client.disconnect();
+        }
+    });
+    if (debug) {
+        client.on("packetsent", (e) => {
+            console.log(`>> ${niimbluelib_1.Utils.bufToHex(e.packet.toBytes())} (${niimbluelib_1.RequestCommandId[e.packet.command]})`);
+        });
+        client.on("packetreceived", (e) => {
+            console.log(`<< ${niimbluelib_1.Utils.bufToHex(e.packet.toBytes())} (${niimbluelib_1.ResponseCommandId[e.packet.command]})`);
+        });
+        client.on("connect", () => {
+            console.log("Connected");
+        });
+        client.on("disconnect", () => {
+            console.log("Disconnected");
+        });
+    }
+    return client;
+};
+exports.initClient = initClient;
+const printImage = async (client, printTaskName, encoded, options) => {
+    const printTask = client.abstraction.newPrintTask(printTaskName, {
+        density: options.density ?? 3,
+        labelType: options.labelType ?? niimbluelib_1.LabelType.WithGaps,
+        totalPages: options.quantity ?? 1,
+        statusPollIntervalMs: 500,
+        statusTimeoutMs: 8_000,
+    });
+    try {
+        await printTask.printInit();
+        await printTask.printPage(encoded, options.quantity ?? 1);
+        await printTask.waitForFinished();
+    }
+    catch (e) {
+        console.error(e);
+    }
+    await client.abstraction.printEnd();
+};
+exports.printImage = printImage;
+const loadImageFromBase64 = async (b64) => {
+    const buf = Buffer.from(b64, "base64");
+    const stream = stream_1.Readable.from(buf);
+    return stream.pipe((0, sharp_1.default)());
+};
+exports.loadImageFromBase64 = loadImageFromBase64;
+const loadImageFromUrl = async (url) => {
+    const { body, ok, status } = await fetch(url);
+    if (!ok) {
+        throw new Error(`Can't fetch image, error ${status}`);
+    }
+    if (body === null) {
+        throw new Error("Body is null");
+    }
+    return stream_1.Readable.fromWeb(body).pipe((0, sharp_1.default)());
+};
+exports.loadImageFromUrl = loadImageFromUrl;
+const loadImageFromFile = async (path) => {
+    const stream = fs_1.default.createReadStream(path);
+    return stream.pipe((0, sharp_1.default)());
+};
+exports.loadImageFromFile = loadImageFromFile;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@mmote/niimblue-node",
+  "version": "0.0.7",
+  "description": "Headless clients for niimbluelib. Command line interface, simple REST server are also included.",
+  "keywords": [
+    "command-line",
+    "thermal-printer",
+    "label-printer",
+    "niimbot",
+    "niimbot-d110",
+    "niimbot-b1",
+    "bluetooth",
+    "serial"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MultiMote/niimblue-node.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "bin": {
+    "niimblue-cli": "./cli.mjs"
+  },
+  "author": "MultiMote",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "clean-build": "yarn clean && yarn build",
+    "build": "tsc --build",
+    "cli": "tsc --build && node cli.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "@abandonware/noble": "^1.9.2-26",
+    "@commander-js/extra-typings": "^12.1.0",
+    "@mmote/niimbluelib": "0.0.1-alpha.24",
+    "async-mutex": "^0.5.0",
+    "commander": "^12.1.0",
+    "serialport": "^12.0.0",
+    "sharp": "^0.33.5",
+    "zod": "^3.23.8"
+  }
+}