node-red-contrib-tcp-escpos 0.1.2 → 0.1.3

package/nodes/node.html

@@ -9,12 +9,29 @@
 		defaults: {
 			name: { value: '' },
 			host: { value: '' },
+			dotsPerLine: { value: 576 },
 			payloadType: { value: 'text' },
 			payload: { value: "I'm Mr. Printer.\nLook at me!" },
+			cutAfter: { value: true },
 		},
 		label: function () {
 			return this.name || this.host || 'tcp escpos'
 		},
+		oneditprepare: function () {
+			const $type = $('#node-input-payloadType')
+			const $cut = $('#node-input-cutAfter').closest('.form-row')
+
+			function refresh() {
+				if ($type.val() === 'buffer') {
+					$cut.hide()
+				} else {
+					$cut.show()
+				}
+			}
+
+			$type.on('change', refresh)
+			refresh()
+		},
 	})
 </script>
 <script type="text/html" data-template-name="tcp escpos">
@@ -26,6 +43,12 @@
 		<label for="node-input-host"><i class="fa fa-dot-circle-o"></i> Host</label>
 		<input type="text" id="node-input-host" placeholder="192.168.1.101:9100" />
 	</div>
+	<div class="form-row">
+		<label for="node-input-dotsPerLine"
+			><i class="fa fa-ruler-horizontal"></i> Dots per line</label
+		>
+		<input type="number" id="node-input-dotsPerLine" placeholder="576" />
+	</div>
 	<div class="form-row">
 		<label for="node-input-payloadType"
 			><i class="fa fa-play-circle"></i> Type</label
@@ -42,6 +65,12 @@
 		>
 		<textarea id="node-input-payload"></textarea>
 	</div>
+	<div class="form-row">
+		<label for="node-input-cutAfter"
+			><i class="fa fa-dot-scissors"></i> Cut After</label
+		>
+		<input type="checkbox" id="node-input-cutAfter" />
+	</div>
 </script>
 <script type="text/html" data-help-name="tcp escpos">
 	<p>Typescript example Node-RED node</p>

package/nodes/node.js

@@ -12,8 +12,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const promises_1 = __importDefault(require("node:fs/promises"));
 const node_net_1 = __importDefault(require("node:net"));
 const node_url_1 = require("node:url");
+const skia_canvas_1 = require("skia-canvas");
+const dither_1 = require("./utilities/dither");
 const connectTcp = (options) => new Promise((resolve, reject) => {
     const socket = node_net_1.default.createConnection(options);
     socket.once('connect', () => resolve(socket));
@@ -33,8 +36,11 @@ module.exports = function (RED) {
         });
         this.on('input', (message, _send, done) => __awaiter(this, void 0, void 0, function* () {
             const error = yield (() => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
                 try {
-                    const payload = (() => {
+                    const cutAfter = (_a = message.cutAfter) !== null && _a !== void 0 ? _a : configuration.cutAfter;
+                    const dotsPerLine = (_b = message.dotsPerLine) !== null && _b !== void 0 ? _b : configuration.dotsPerLine;
+                    const payload = yield (() => __awaiter(this, void 0, void 0, function* () {
                         const payloadType = allowedPayloadTypes.find((type) => type === message.type) ||
                             configuration.payloadType;
                         const payload = message.payload || configuration.payload;
@@ -44,21 +50,104 @@ module.exports = function (RED) {
                             commands.push(Buffer.from([0x1b, 0x74, 18])); // Language options: 18 is CP852 code table
                             commands.push(Buffer.from([0x1b, 0x61, 1])); // Center alignment
                             commands.push(encodeText(String(payload)));
-                            commands.push(Buffer.from([0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a])); // New lines
-                            commands.push(Buffer.from([0x1b, 0x69])); // Cut
+                            commands.push(Buffer.from([0x0a])); // New line
                             return Buffer.concat(commands);
                         }
                         if (payloadType === 'image') {
-                            throw new Error('Image type not implemented yet');
+                            const imageBuffer = yield (() => __awaiter(this, void 0, void 0, function* () {
+                                if (Buffer.isBuffer(payload)) {
+                                    return payload;
+                                }
+                                if (typeof payload === 'string') {
+                                    if (payload.startsWith('data:image/')) {
+                                        const base64 = payload.split(',', 2)[1];
+                                        return Buffer.from(base64, 'base64');
+                                    }
+                                    try {
+                                        const url = new node_url_1.URL(payload);
+                                        if (url.protocol === 'http:' ||
+                                            url.protocol === 'https:' ||
+                                            url.protocol === 'file:') {
+                                            const response = yield fetch(url.toString());
+                                            return Buffer.from(yield response.arrayBuffer());
+                                        }
+                                    }
+                                    catch (_c) { }
+                                    const base64Pattern = /^[A-Za-z0-9+/]+={0,2}$/;
+                                    if (payload.length % 4 === 0 && base64Pattern.test(payload)) {
+                                        return Buffer.from(payload, 'base64');
+                                    }
+                                    const isFilePath = yield (() => __awaiter(this, void 0, void 0, function* () {
+                                        try {
+                                            yield promises_1.default.access(payload);
+                                            return true;
+                                        }
+                                        catch (_d) { }
+                                        return false;
+                                    }))();
+                                    if (isFilePath) {
+                                        return promises_1.default.readFile(payload);
+                                    }
+                                }
+                                throw new Error('Invalid image payload.');
+                            }))();
+                            const image = yield (0, skia_canvas_1.loadImage)(imageBuffer);
+                            let imageWidth = image.width;
+                            let imageHeight = image.height;
+                            if (imageWidth > dotsPerLine) {
+                                const aspectRatio = image.height / image.width;
+                                imageWidth = dotsPerLine;
+                                imageHeight = imageWidth * aspectRatio;
+                            }
+                            const canvas = new skia_canvas_1.Canvas(imageWidth, imageHeight);
+                            const context = canvas.getContext('2d');
+                            context.drawImage(image, 0, 0, imageWidth, imageHeight);
+                            (0, dither_1.dither)(canvas);
+                            const payloadParts = [];
+                            payloadParts.push(Buffer.from([0x1b, 0x40])); // Initialize printer
+                            payloadParts.push(Buffer.from([0x1b, 0x61, 1])); // Center alignment
+                            const splitImageByHeightInPixels = 1024; // Splitting image to more smaller ones because Epson printer can't handle one super heigh image
+                            for (let yOffset = 0; yOffset < canvas.height; yOffset += splitImageByHeightInPixels) {
+                                const chunkHeight = Math.min(splitImageByHeightInPixels, canvas.height - yOffset);
+                                const { width, height, data: imageData, } = context.getImageData(0, yOffset, canvas.width, chunkHeight);
+                                const bytes = (width + 7) >> 3;
+                                // For xL, xH, yL, yH, see the documentation https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/gs_lv_0.html
+                                const xL = bytes & 0xff;
+                                const xH = bytes >> 8;
+                                const yL = height & 0xff;
+                                const yH = height >> 8;
+                                const pixelsGroupedToBytes = Buffer.alloc(bytes * height);
+                                for (let y = 0; y < height; y++) {
+                                    for (let x = 0; x < width; x++) {
+                                        const index = (y * width + x) * 4;
+                                        const red = imageData[index];
+                                        const green = imageData[index + 1];
+                                        const blue = imageData[index + 2];
+                                        const alpha = imageData[index + 3];
+                                        const greyscale = red * 0.299 + green * 0.587 + blue * 0.114;
+                                        if (alpha > 127 && greyscale < 128) {
+                                            const byteIndex = y * bytes + (x >> 3);
+                                            const bit = 1 << (7 - (x & 7));
+                                            pixelsGroupedToBytes[byteIndex] |= bit;
+                                        }
+                                    }
+                                }
+                                payloadParts.push(Buffer.from([0x1d, 0x76, 0x30, 0, xL, xH, yL, yH]));
+                                payloadParts.push(pixelsGroupedToBytes);
+                            }
+                            return Buffer.concat(payloadParts);
                         }
                         if (payloadType === 'buffer') {
+                            if (Buffer.isBuffer(payload)) {
+                                return payload;
+                            }
                             if (Array.isArray(payload)) {
                                 return Buffer.from(payload);
                             }
                             return Buffer.from(payload, 'base64');
                         }
                         return payloadType;
-                    })();
+                    }))();
                     this.status({ fill: 'yellow', shape: 'dot', text: 'connecting…' });
                     const hostname = message.host || configuration.host;
                     if (!hostname) {
@@ -70,7 +159,16 @@ module.exports = function (RED) {
                     const socket = yield connectTcp({ host, port });
                     this.status({ fill: 'yellow', shape: 'dot', text: 'sending…' });
                     yield new Promise((resolve, reject) => {
-                        socket.write(payload, (error) => {
+                        const commands = Buffer.concat([
+                            payload,
+                            ...(cutAfter
+                                ? [
+                                    Buffer.from([0x0a, 0x0a, 0x0a, 0x0a, 0x0a]),
+                                    Buffer.from([0x1b, 0x69]), // Cut
+                                ]
+                                : []),
+                        ]);
+                        socket.write(commands, (error) => {
                             if (error) {
                                 reject(error);
                             }

package/nodes/utilities/dither.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dither = void 0;
+const dither = (canvas) => {
+    const context = canvas.getContext('2d');
+    if (!context) {
+        throw new Error('Context not available.');
+    }
+    const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+    const { data } = imageData;
+    const dataLength = data.length;
+    const w = canvas.width;
+    const lumR = [];
+    const lumG = [];
+    const lumB = [];
+    let newPixel;
+    let err;
+    for (let i = 0; i < 256; i++) {
+        lumR[i] = i * 0.299;
+        lumG[i] = i * 0.587;
+        lumB[i] = i * 0.11;
+    }
+    // Greyscale luminance (sets r pixels to luminance of rgb)
+    for (let i = 0; i <= dataLength; i += 4) {
+        data[i] = Math.floor(lumR[data[i]] + lumG[data[i + 1]] + lumB[data[i + 2]]);
+    }
+    for (let currentPixel = 0; currentPixel <= dataLength; currentPixel += 4) {
+        // threshold for determining current pixel's conversion to a black or white pixel
+        newPixel = data[currentPixel] < 150 ? 0 : 255;
+        err = Math.floor((data[currentPixel] - newPixel) / 23);
+        data[currentPixel + 0 * 1 - 0] = newPixel;
+        data[currentPixel + 4 * 1 - 0] += err * 7;
+        data[currentPixel + 4 * w - 4] += err * 3;
+        data[currentPixel + 4 * w - 0] += err * 5;
+        data[currentPixel + 4 * w + 4] += err * 1;
+        // Set g and b values equal to r (effectively greyscales the image fully)
+        data[currentPixel + 1] = data[currentPixel + 2] = data[currentPixel];
+    }
+    context.putImageData(imageData, 0, 0);
+};
+exports.dither = dither;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-red-contrib-tcp-escpos",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "Escpos over TCP/IP node for Node-RED",
 	"devDependencies": {
 		"@types/node": "^18.14.0",
@@ -39,6 +39,7 @@
 		}
 	},
 	"dependencies": {
-		"iconv-lite": "^0.7.0"
+		"iconv-lite": "^0.7.0",
+		"skia-canvas": "^3.0.8"
 	}
 }