zklib-ts 1.0.0-development → 1.0.2-development

package/dist/index.es.js

@@ -2,103 +2,109 @@ import { Socket } from 'net';
 import { appendFile } from 'fs';
 import * as dgram from 'node:dgram';
 
-const COMMANDS = {
-    CMD_CONNECT: 1000,
-    CMD_EXIT: 1001,
-    CMD_ENABLEDEVICE: 1002,
-    CMD_DISABLEDEVICE: 1003,
-    CMD_RESTART: 1004,
-    CMD_POWEROFF: 1005,
-    CMD_SLEEP: 1006,
-    CMD_RESUME: 1007,
-    CMD_CAPTUREFINGER: 1009,
-    CMD_TEST_TEMP: 1011,
-    CMD_CAPTUREIMAGE: 1012,
-    CMD_REFRESHDATA: 1013,
-    CMD_REFRESHOPTION: 1014,
-    CMD_TESTVOICE: 1017,
-    CMD_GET_VERSION: 1100,
-    CMD_CHANGE_SPEED: 1101,
-    CMD_AUTH: 1102,
-    CMD_PREPARE_DATA: 1500,
-    CMD_DATA: 1501,
-    CMD_FREE_DATA: 1502,
-    CMD_DATA_WRRQ: 1503,
-    CMD_DATA_RDY: 1504,
-    CMD_DB_RRQ: 7,
-    CMD_USER_WRQ: 8,
-    CMD_USERTEMP_RRQ: 9,
-    CMD_USERTEMP_WRQ: 10,
-    CMD_OPTIONS_RRQ: 11,
-    CMD_OPTIONS_WRQ: 12,
-    CMD_ATTLOG_RRQ: 13,
-    CMD_CLEAR_DATA: 14,
-    CMD_CLEAR_ATTLOG: 15,
-    CMD_DELETE_USER: 18,
-    CMD_DELETE_USERTEMP: 19,
-    CMD_CLEAR_ADMIN: 20,
-    CMD_USERGRP_RRQ: 21,
-    CMD_USERGRP_WRQ: 22,
-    CMD_USERTZ_RRQ: 23,
-    CMD_USERTZ_WRQ: 24,
-    CMD_GRPTZ_RRQ: 25,
-    CMD_GRPTZ_WRQ: 26,
-    CMD_TZ_RRQ: 27,
-    CMD_TZ_WRQ: 28,
-    CMD_ULG_RRQ: 29,
-    CMD_ULG_WRQ: 30,
-    CMD_UNLOCK: 31,
-    CMD_CLEAR_ACC: 32,
-    CMD_CLEAR_OPLOG: 33,
-    CMD_OPLOG_RRQ: 34,
-    CMD_GET_FREE_SIZES: 50,
-    CMD_ENABLE_CLOCK: 57,
-    CMD_STARTVERIFY: 60,
-    CMD_STARTENROLL: 61,
-    CMD_CANCELCAPTURE: 62,
-    CMD_STATE_RRQ: 64,
-    CMD_WRITE_LCD: 66,
-    CMD_CLEAR_LCD: 67,
-    CMD_GET_PINWIDTH: 69,
-    CMD_SMS_WRQ: 70,
-    CMD_SMS_RRQ: 71,
-    CMD_DELETE_SMS: 72,
-    CMD_UDATA_WRQ: 73,
-    CMD_DELETE_UDATA: 74,
-    CMD_DOORSTATE_RRQ: 75,
-    CMD_WRITE_MIFARE: 76,
-    CMD_EMPTY_MIFARE: 78,
-    CMD_VERIFY_WRQ: 79,
-    CMD_VERIFY_RRQ: 80,
-    CMD_TMP_WRITE: 87,
-    CMD_GET_USERTEMP: 88,
-    CMD_CHECKSUM_BUFFER: 119,
-    CMD_DEL_FPTMP: 134,
-    CMD_GET_TIME: 201,
-    CMD_SET_TIME: 202,
-    CMD_REG_EVENT: 500,
-    CMD_ACK_OK: 2000,
-    CMD_ACK_ERROR: 2001,
-    CMD_ACK_DATA: 2002,
-    CMD_ACK_RETRY: 2003,
-    CMD_ACK_REPEAT: 2004,
-    CMD_ACK_UNAUTH: 2005,
-    CMD_ACK_UNKNOWN: 65535,
-    CMD_ACK_ERROR_CMD: 65533,
-    CMD_ACK_ERROR_INIT: 65532,
-    CMD_ACK_ERROR_DATA: 65531,
-    EF_ATTLOG: 1,
-    EF_FINGER: 2,
-    EF_ENROLLUSER: 4,
-    EF_ENROLLFINGER: 8,
-    EF_BUTTON: 16,
-    EF_UNLOCK: 32,
-    EF_VERIFY: 128,
-    EF_FPFTR: 256,
-    EF_ALARM: 512
-};
-const USHRT_MAX = 65535;
-const MAX_CHUNK = 65472;
+var COMMANDS;
+(function (COMMANDS) {
+    COMMANDS[COMMANDS["CMD_ACK_DATA"] = 2002] = "CMD_ACK_DATA";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR"] = 2001] = "CMD_ACK_ERROR";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR_CMD"] = 65533] = "CMD_ACK_ERROR_CMD";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR_DATA"] = 65531] = "CMD_ACK_ERROR_DATA";
+    COMMANDS[COMMANDS["CMD_ACK_ERROR_INIT"] = 65532] = "CMD_ACK_ERROR_INIT";
+    COMMANDS[COMMANDS["CMD_ACK_OK"] = 2000] = "CMD_ACK_OK";
+    COMMANDS[COMMANDS["CMD_ACK_REPEAT"] = 2004] = "CMD_ACK_REPEAT";
+    COMMANDS[COMMANDS["CMD_ACK_RETRY"] = 2003] = "CMD_ACK_RETRY";
+    COMMANDS[COMMANDS["CMD_ACK_UNAUTH"] = 2005] = "CMD_ACK_UNAUTH";
+    COMMANDS[COMMANDS["CMD_ACK_UNKNOWN"] = 65535] = "CMD_ACK_UNKNOWN";
+    COMMANDS[COMMANDS["CMD_ATTLOG_RRQ"] = 13] = "CMD_ATTLOG_RRQ";
+    COMMANDS[COMMANDS["CMD_AUTH"] = 1102] = "CMD_AUTH";
+    COMMANDS[COMMANDS["CMD_CANCELCAPTURE"] = 62] = "CMD_CANCELCAPTURE";
+    COMMANDS[COMMANDS["CMD_CAPTUREFINGER"] = 1009] = "CMD_CAPTUREFINGER";
+    COMMANDS[COMMANDS["CMD_CAPTUREIMAGE"] = 1012] = "CMD_CAPTUREIMAGE";
+    COMMANDS[COMMANDS["CMD_CHANGE_SPEED"] = 1101] = "CMD_CHANGE_SPEED";
+    COMMANDS[COMMANDS["CMD_CHECKSUM_BUFFER"] = 119] = "CMD_CHECKSUM_BUFFER";
+    COMMANDS[COMMANDS["CMD_CLEAR_ACC"] = 32] = "CMD_CLEAR_ACC";
+    COMMANDS[COMMANDS["CMD_CLEAR_ADMIN"] = 20] = "CMD_CLEAR_ADMIN";
+    COMMANDS[COMMANDS["CMD_CLEAR_ATTLOG"] = 15] = "CMD_CLEAR_ATTLOG";
+    COMMANDS[COMMANDS["CMD_CLEAR_DATA"] = 14] = "CMD_CLEAR_DATA";
+    COMMANDS[COMMANDS["CMD_CLEAR_LCD"] = 67] = "CMD_CLEAR_LCD";
+    COMMANDS[COMMANDS["CMD_CLEAR_OPLOG"] = 33] = "CMD_CLEAR_OPLOG";
+    COMMANDS[COMMANDS["CMD_CONNECT"] = 1000] = "CMD_CONNECT";
+    COMMANDS[COMMANDS["CMD_DATA"] = 1501] = "CMD_DATA";
+    COMMANDS[COMMANDS["CMD_DATA_RDY"] = 1504] = "CMD_DATA_RDY";
+    COMMANDS[COMMANDS["CMD_DATA_WRRQ"] = 1503] = "CMD_DATA_WRRQ";
+    COMMANDS[COMMANDS["CMD_DB_RRQ"] = 7] = "CMD_DB_RRQ";
+    COMMANDS[COMMANDS["CMD_DEL_FPTMP"] = 134] = "CMD_DEL_FPTMP";
+    COMMANDS[COMMANDS["CMD_DELETE_SMS"] = 72] = "CMD_DELETE_SMS";
+    COMMANDS[COMMANDS["CMD_DELETE_UDATA"] = 74] = "CMD_DELETE_UDATA";
+    COMMANDS[COMMANDS["CMD_DELETE_USER"] = 18] = "CMD_DELETE_USER";
+    COMMANDS[COMMANDS["CMD_DELETE_USERTEMP"] = 19] = "CMD_DELETE_USERTEMP";
+    COMMANDS[COMMANDS["CMD_DISABLEDEVICE"] = 1003] = "CMD_DISABLEDEVICE";
+    COMMANDS[COMMANDS["CMD_DOORSTATE_RRQ"] = 75] = "CMD_DOORSTATE_RRQ";
+    COMMANDS[COMMANDS["CMD_EMPTY_MIFARE"] = 78] = "CMD_EMPTY_MIFARE";
+    COMMANDS[COMMANDS["CMD_ENABLE_CLOCK"] = 57] = "CMD_ENABLE_CLOCK";
+    COMMANDS[COMMANDS["CMD_ENABLEDEVICE"] = 1002] = "CMD_ENABLEDEVICE";
+    COMMANDS[COMMANDS["CMD_EXIT"] = 1001] = "CMD_EXIT";
+    COMMANDS[COMMANDS["CMD_FREE_DATA"] = 1502] = "CMD_FREE_DATA";
+    COMMANDS[COMMANDS["CMD_GET_FREE_SIZES"] = 50] = "CMD_GET_FREE_SIZES";
+    COMMANDS[COMMANDS["CMD_GET_PINWIDTH"] = 69] = "CMD_GET_PINWIDTH";
+    COMMANDS[COMMANDS["CMD_GET_TIME"] = 201] = "CMD_GET_TIME";
+    COMMANDS[COMMANDS["CMD_GET_USERTEMP"] = 88] = "CMD_GET_USERTEMP";
+    COMMANDS[COMMANDS["CMD_GET_VERSION"] = 1100] = "CMD_GET_VERSION";
+    COMMANDS[COMMANDS["CMD_GRPTZ_RRQ"] = 25] = "CMD_GRPTZ_RRQ";
+    COMMANDS[COMMANDS["CMD_GRPTZ_WRQ"] = 26] = "CMD_GRPTZ_WRQ";
+    COMMANDS[COMMANDS["CMD_OPLOG_RRQ"] = 34] = "CMD_OPLOG_RRQ";
+    COMMANDS[COMMANDS["CMD_OPTIONS_RRQ"] = 11] = "CMD_OPTIONS_RRQ";
+    COMMANDS[COMMANDS["CMD_OPTIONS_WRQ"] = 12] = "CMD_OPTIONS_WRQ";
+    COMMANDS[COMMANDS["CMD_POWEROFF"] = 1005] = "CMD_POWEROFF";
+    COMMANDS[COMMANDS["CMD_PREPARE_DATA"] = 1500] = "CMD_PREPARE_DATA";
+    COMMANDS[COMMANDS["CMD_REFRESHDATA"] = 1013] = "CMD_REFRESHDATA";
+    COMMANDS[COMMANDS["CMD_REFRESHOPTION"] = 1014] = "CMD_REFRESHOPTION";
+    COMMANDS[COMMANDS["CMD_REG_EVENT"] = 500] = "CMD_REG_EVENT";
+    COMMANDS[COMMANDS["CMD_RESTART"] = 1004] = "CMD_RESTART";
+    COMMANDS[COMMANDS["CMD_RESUME"] = 1007] = "CMD_RESUME";
+    COMMANDS[COMMANDS["CMD_SET_TIME"] = 202] = "CMD_SET_TIME";
+    COMMANDS[COMMANDS["CMD_SLEEP"] = 1006] = "CMD_SLEEP";
+    COMMANDS[COMMANDS["CMD_SMS_RRQ"] = 71] = "CMD_SMS_RRQ";
+    COMMANDS[COMMANDS["CMD_SMS_WRQ"] = 70] = "CMD_SMS_WRQ";
+    COMMANDS[COMMANDS["CMD_STARTENROLL"] = 61] = "CMD_STARTENROLL";
+    COMMANDS[COMMANDS["CMD_STARTVERIFY"] = 60] = "CMD_STARTVERIFY";
+    COMMANDS[COMMANDS["CMD_STATE_RRQ"] = 64] = "CMD_STATE_RRQ";
+    COMMANDS[COMMANDS["CMD_TEST_TEMP"] = 1011] = "CMD_TEST_TEMP";
+    COMMANDS[COMMANDS["CMD_TESTVOICE"] = 1017] = "CMD_TESTVOICE";
+    COMMANDS[COMMANDS["CMD_TMP_WRITE"] = 87] = "CMD_TMP_WRITE";
+    COMMANDS[COMMANDS["CMD_TZ_RRQ"] = 27] = "CMD_TZ_RRQ";
+    COMMANDS[COMMANDS["CMD_TZ_WRQ"] = 28] = "CMD_TZ_WRQ";
+    COMMANDS[COMMANDS["CMD_UDATA_WRQ"] = 73] = "CMD_UDATA_WRQ";
+    COMMANDS[COMMANDS["CMD_ULG_RRQ"] = 29] = "CMD_ULG_RRQ";
+    COMMANDS[COMMANDS["CMD_ULG_WRQ"] = 30] = "CMD_ULG_WRQ";
+    COMMANDS[COMMANDS["CMD_UNLOCK"] = 31] = "CMD_UNLOCK";
+    COMMANDS[COMMANDS["CMD_USER_WRQ"] = 8] = "CMD_USER_WRQ";
+    COMMANDS[COMMANDS["CMD_USERGRP_RRQ"] = 21] = "CMD_USERGRP_RRQ";
+    COMMANDS[COMMANDS["CMD_USERGRP_WRQ"] = 22] = "CMD_USERGRP_WRQ";
+    COMMANDS[COMMANDS["CMD_USERTEMP_RRQ"] = 9] = "CMD_USERTEMP_RRQ";
+    COMMANDS[COMMANDS["CMD_USERTEMP_WRQ"] = 10] = "CMD_USERTEMP_WRQ";
+    COMMANDS[COMMANDS["CMD_USERTZ_RRQ"] = 23] = "CMD_USERTZ_RRQ";
+    COMMANDS[COMMANDS["CMD_USERTZ_WRQ"] = 24] = "CMD_USERTZ_WRQ";
+    COMMANDS[COMMANDS["CMD_VERIFY_RRQ"] = 80] = "CMD_VERIFY_RRQ";
+    COMMANDS[COMMANDS["CMD_VERIFY_WRQ"] = 79] = "CMD_VERIFY_WRQ";
+    COMMANDS[COMMANDS["CMD_WRITE_LCD"] = 66] = "CMD_WRITE_LCD";
+    COMMANDS[COMMANDS["CMD_WRITE_MIFARE"] = 76] = "CMD_WRITE_MIFARE";
+    COMMANDS[COMMANDS["EF_ALARM"] = 512] = "EF_ALARM";
+    COMMANDS[COMMANDS["EF_ATTLOG"] = 1] = "EF_ATTLOG";
+    COMMANDS[COMMANDS["EF_BUTTON"] = 16] = "EF_BUTTON";
+    COMMANDS[COMMANDS["EF_ENROLLFINGER"] = 8] = "EF_ENROLLFINGER";
+    COMMANDS[COMMANDS["EF_ENROLLUSER"] = 4] = "EF_ENROLLUSER";
+    COMMANDS[COMMANDS["EF_FINGER"] = 2] = "EF_FINGER";
+    COMMANDS[COMMANDS["EF_FPFTR"] = 256] = "EF_FPFTR";
+    COMMANDS[COMMANDS["EF_UNLOCK"] = 32] = "EF_UNLOCK";
+    COMMANDS[COMMANDS["EF_VERIFY"] = 128] = "EF_VERIFY";
+})(COMMANDS || (COMMANDS = {}));
+var Constants;
+(function (Constants) {
+    Constants[Constants["USHRT_MAX"] = 65535] = "USHRT_MAX";
+    Constants[Constants["MAX_CHUNK"] = 65472] = "MAX_CHUNK";
+    Constants[Constants["MACHINE_PREPARE_DATA_1"] = 20560] = "MACHINE_PREPARE_DATA_1";
+    Constants[Constants["MACHINE_PREPARE_DATA_2"] = 32130] = "MACHINE_PREPARE_DATA_2";
+})(Constants || (Constants = {}));
 const REQUEST_DATA = {
     DISABLE_DEVICE: Buffer.from([0, 0, 0, 0]),
     GET_REAL_TIME_EVENT: Buffer.from([0x01, 0x00, 0x00, 0x00]),
@@ -252,7 +258,7 @@ class Attendance {
     record_time;
     type;
     state;
-    _ip;
+    ip;
     constructor(sn, user_id, record_time, type, state) {
         this.sn = sn;
         this.user_id = user_id;
@@ -260,9 +266,6 @@ class Attendance {
         this.type = type;
         this.state = state;
     }
-    set ip(value) {
-        this._ip = value;
-    }
 }
 
 const parseHexToTime = (hex) => {
@@ -285,9 +288,9 @@ const createChkSum = (buf) => {
         else {
             chksum += buf.readUInt16LE(i);
         }
-        chksum %= USHRT_MAX;
+        chksum %= Constants.USHRT_MAX;
     }
-    chksum = USHRT_MAX - chksum - 1;
+    chksum = Constants.USHRT_MAX - chksum - 1;
     return chksum;
 };
 const createUDPHeader = (command, sessionId, replyId, data) => {
@@ -300,7 +303,7 @@ const createUDPHeader = (command, sessionId, replyId, data) => {
     dataBuffer.copy(buf, 8);
     const chksum2 = createChkSum(buf);
     buf.writeUInt16LE(chksum2, 2);
-    replyId = (replyId + 1) % USHRT_MAX;
+    replyId = (replyId + 1) % Constants.USHRT_MAX;
     buf.writeUInt16LE(replyId, 6);
     return buf;
 };
@@ -314,7 +317,7 @@ const createTCPHeader = (command, sessionId, replyId, data) => {
     dataBuffer.copy(buf, 8);
     const chksum2 = createChkSum(buf);
     buf.writeUInt16LE(chksum2, 2);
-    replyId = (replyId + 1) % USHRT_MAX;
+    replyId = (replyId + 1) % Constants.USHRT_MAX;
     buf.writeUInt16LE(replyId, 6);
     const prefixBuf = Buffer.from([0x50, 0x50, 0x82, 0x7d, 0x13, 0x00, 0x00, 0x00]);
     prefixBuf.writeUInt16LE(buf.length, 4);
@@ -515,8 +518,8 @@ class Finger {
         this.template = template;
         this.size = template.length;
         // Create mark showing first and last 8 bytes as hex
-        const start = template.slice(0, 8).toString('hex');
-        const end = template.slice(-8).toString('hex');
+        const start = Uint8Array.prototype.slice.call(template, 0, 8).toString('hex');
+        const end = Uint8Array.prototype.slice.call(template, -8).toString('hex');
         this.mark = `${start}...${end}`;
     }
     /**
@@ -647,10 +650,12 @@ class ZTCP {
     face_cap = 0;
     userPacketSize = 72;
     verbose = false;
+    packetNumber = 0;
+    replyData = Buffer.from([]);
     constructor(ip, port, timeout, comm_key, verbose) {
         this.ip = ip;
         this.port = port;
-        this.timeout = timeout;
+        this.timeout = timeout ? timeout : 10000;
         this.replyId = 0;
         this.comm_key = comm_key;
         this.verbose = verbose;
@@ -871,9 +876,6 @@ class ZTCP {
         else {
             this.replyId++;
         }
-        if (this.verbose) {
-            console.log("linea 305: replyId: ", this.replyId, "     command: ", command, Object.keys(COMMANDS).find(u => COMMANDS[u] == command));
-        }
         const buf = createTCPHeader(command, this.sessionId, this.replyId, data);
         try {
             // Write the message to the socket and wait for a response
@@ -919,8 +921,8 @@ class ZTCP {
     }
     /**
      *
-     * @param {*} reqData - indicate the type of data that need to receive ( user or attLog)
-     * @param {*} cb - callback is triggered when receiving packets
+     * @param {Buffer} reqData - indicate the type of data that need to receive ( user or attLog)
+     * @param {Function} cb - callback is triggered when receiving packets
      *
      * readWithBuffer will reject error if it'wrong when starting request data
      * readWithBuffer will return { data: replyData , err: Error } when receiving requested data
@@ -935,7 +937,6 @@ class ZTCP {
             }
             catch (err) {
                 reject(err);
-                console.log(reply);
             }
             const header = decodeTCPHeader(reply.subarray(0, 16));
             switch (header.commandId) {
@@ -951,56 +952,73 @@ class ZTCP {
                     const size = recvData.readUIntLE(1, 4);
                     // We need to split the data to many chunks to receive , because it's to large
                     // After receiving all chunk data , we concat it to TotalBuffer variable , that 's the data we want
-                    let remain = size % MAX_CHUNK;
-                    let numberChunks = Math.round(size - remain) / MAX_CHUNK;
-                    let totalPackets = numberChunks + (remain > 0 ? 1 : 0);
-                    let replyData = Buffer.from([]);
+                    let remain = size % Constants.MAX_CHUNK;
+                    let numberChunks = Math.round(size - remain) / Constants.MAX_CHUNK;
+                    this.packetNumber = numberChunks + (remain > 0 ? 1 : 0);
+                    //let replyData = Buffer.from([])
                     let totalBuffer = Buffer.from([]);
                     let realTotalBuffer = Buffer.from([]);
-                    const timeout = 10000;
                     let timer = setTimeout(() => {
-                        internalCallback(replyData, new Error('TIMEOUT WHEN RECEIVING PACKET'));
-                    }, timeout);
+                        internalCallback(this.replyData, new Error('TIMEOUT WHEN RECEIVING PACKET'));
+                    }, this.timeout);
                     const internalCallback = (replyData, err = null) => {
-                        // this.socket && this.socket.removeListener('data', handleOnData)
+                        this.socket && this.socket.removeAllListeners('data');
                         timer && clearTimeout(timer);
                         resolve({ data: replyData, err });
                     };
-                    const handleOnData = (reply) => {
-                        if (checkNotEventTCP(reply))
-                            return;
-                        clearTimeout(timer);
-                        timer = setTimeout(() => {
-                            internalCallback(replyData, new Error(`TIME OUT !! ${totalPackets} PACKETS REMAIN !`));
-                        }, timeout);
-                        totalBuffer = Buffer.concat([totalBuffer, reply]);
-                        const packetLength = totalBuffer.readUIntLE(4, 2);
-                        if (totalBuffer.length >= 8 + packetLength) {
-                            realTotalBuffer = Buffer.concat([realTotalBuffer, totalBuffer.subarray(16, 8 + packetLength)]);
-                            totalBuffer = totalBuffer.subarray(8 + packetLength);
-                            if ((totalPackets > 1 && realTotalBuffer.length === MAX_CHUNK + 8)
-                                || (totalPackets === 1 && realTotalBuffer.length === remain + 8)) {
-                                replyData = Buffer.concat([replyData, realTotalBuffer.subarray(8)]);
-                                totalBuffer = Buffer.from([]);
-                                realTotalBuffer = Buffer.from([]);
-                                totalPackets -= 1;
-                                cb && cb(replyData.length, size);
-                                if (totalPackets <= 0) {
-                                    internalCallback(replyData);
-                                }
-                            }
-                        }
-                    };
                     this.socket.once('close', () => {
-                        internalCallback(replyData, new Error('Socket is disconnected unexpectedly'));
+                        internalCallback(this.replyData, new Error('Socket is disconnected unexpectedly'));
                     });
-                    this.socket.on('data', handleOnData);
                     for (let i = 0; i <= numberChunks; i++) {
-                        if (i === numberChunks) {
-                            await this.sendChunkRequest(numberChunks * MAX_CHUNK, remain);
-                        }
-                        else {
-                            await this.sendChunkRequest(i * MAX_CHUNK, MAX_CHUNK);
+                        const data = await new Promise((resolve2, reject2) => {
+                            try {
+                                this.sendChunkRequest(i * Constants.MAX_CHUNK, (i === numberChunks)
+                                    ? remain
+                                    : Constants.MAX_CHUNK);
+                                this.socket.on('data', (reply) => {
+                                    clearTimeout(timer);
+                                    timer = setTimeout(() => {
+                                        internalCallback(this.replyData, new Error(`TIME OUT !! ${this.packetNumber} PACKETS REMAIN !`));
+                                    }, this.timeout);
+                                    const headers = decodeTCPHeader(reply);
+                                    if (COMMANDS[headers.commandId]) {
+                                        switch (headers.commandId) {
+                                            case COMMANDS.CMD_ACK_OK:
+                                            case COMMANDS.CMD_DATA:
+                                                this.verbose && console.log("CMD received: ", COMMANDS[headers.commandId]);
+                                                break;
+                                            case COMMANDS.CMD_PREPARE_DATA:
+                                                this.verbose && console.log("CMD received: ", COMMANDS[headers.commandId]);
+                                                this.verbose && console.log(`recieve chunk: prepare data size is ${headers.payloadSize}`);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                    totalBuffer = Buffer.concat([totalBuffer, reply]);
+                                    const packetLength = totalBuffer.readUIntLE(4, 2);
+                                    if (totalBuffer.length >= 8 + packetLength) {
+                                        realTotalBuffer = Buffer.concat([realTotalBuffer, totalBuffer.subarray(16, 8 + packetLength)]);
+                                        totalBuffer = totalBuffer.subarray(8 + packetLength);
+                                        if ((this.packetNumber > 1 && realTotalBuffer.length === (Constants.MAX_CHUNK + 8))
+                                            || (this.packetNumber === 1 && realTotalBuffer.length === remain + 8)) {
+                                            this.packetNumber--;
+                                            cb && cb(realTotalBuffer.length, size);
+                                            resolve2(realTotalBuffer.subarray(8));
+                                            totalBuffer = Buffer.from([]);
+                                            realTotalBuffer = Buffer.from([]);
+                                        }
+                                    }
+                                });
+                            }
+                            catch (e) {
+                                reject2(e);
+                            }
+                        });
+                        this.replyData = Buffer.concat([this.replyData, data]);
+                        this.socket.removeAllListeners('data');
+                        if (this.packetNumber <= 0) {
+                            resolve({ data: this.replyData });
                         }
                     }
                     break;
@@ -1632,32 +1650,58 @@ class ZTCP {
             throw err;
         }
     }
-    async getTemplates() {
+    /**
+     * Get all Finger objects
+     * @returns {Record<string, Finger[]>}
+     */
+    async getTemplates(callbackInProcess = () => { }) {
+        let templates = [];
         try {
+            await this.getSizes();
+            if (this.fp_count == 0)
+                return { data: [] };
             await this.freeData();
             await this.disableDevice();
             const Buffer = await this.readWithBuffer(REQUEST_DATA.GET_TEMPLATES);
-            let templateData = Buffer.data.slice(4);
+            let templateData = Buffer.data.subarray(4);
             let totalSize = Buffer.data.readUIntLE(0, 4);
-            let templates = [];
             while (totalSize) {
-                const buf = templateData.slice(0, 6);
+                const buf = templateData.subarray(0, 6);
                 const size = buf.readUIntLE(0, 2);
-                templates.push(new Finger(buf.readUIntLE(2, 2), buf.readUIntLE(4, 1), buf.readUIntLE(5, 1), templateData.slice(6, size)));
-                templateData = templateData.slice(size);
+                templates.push(new Finger(buf.readUIntLE(2, 2), buf.readUIntLE(4, 1), buf.readUIntLE(5, 1), templateData.subarray(6, size)));
+                templateData = templateData.subarray(size);
                 totalSize -= size;
             }
-            return templates;
+            return { data: templates };
         }
         catch (err) {
-            console.error('Error getting user templates: ', err);
-            throw err;
+            this.verbose && console.log("Error getting templates", err);
+            return { data: templates };
         }
         finally {
             await this.enableDevice();
             await this.freeData();
         }
     }
+    /**
+     * Return size
+     * @param packet
+     */
+    testTcpTop(packet) {
+        // Check if packet is too small
+        if (packet.length <= 8)
+            return 0;
+        // Extract header values using little-endian format
+        const headerValue1 = packet.readUInt16LE(0);
+        const headerValue2 = packet.readUInt16LE(2);
+        const size = packet.readUInt32LE(4);
+        // Check if magic numbers match
+        if (headerValue1 === Constants.MACHINE_PREPARE_DATA_1 &&
+            headerValue2 === Constants.MACHINE_PREPARE_DATA_2) {
+            return size;
+        }
+        return 0;
+    }
     async refreshData() {
         try {
             const reply = await this.executeCmd(COMMANDS.CMD_REFRESHDATA, '');
@@ -1955,7 +1999,7 @@ class ZTCP {
     }
     async ackOk() {
         try {
-            const buf = createTCPHeader(COMMANDS.CMD_ACK_OK, this.sessionId, USHRT_MAX - 1, Buffer.from([]));
+            const buf = createTCPHeader(COMMANDS.CMD_ACK_OK, this.sessionId, Constants.USHRT_MAX - 1, Buffer.from([]));
             this.socket.write(buf);
         }
         catch (e) {
@@ -2266,10 +2310,10 @@ class ZUDP {
                 }
             };
             this.socket.on('message', handleOnData);
-            const chunkCount = Math.ceil(size / MAX_CHUNK);
+            const chunkCount = Math.ceil(size / Constants.MAX_CHUNK);
             for (let i = 0; i < chunkCount; i++) {
-                const start = i * MAX_CHUNK;
-                const chunkSize = (i === chunkCount - 1) ? size % MAX_CHUNK : MAX_CHUNK;
+                const start = i * Constants.MAX_CHUNK;
+                const chunkSize = (i === chunkCount - 1) ? size % Constants.MAX_CHUNK : Constants.MAX_CHUNK;
                 this.sendChunkRequest(start, chunkSize).catch(err => {
                     internalCallback(Buffer.from([]), err);
                 });

package/dist/models/Attendance.d.ts

@@ -4,7 +4,6 @@ export declare class Attendance {
     record_time: Date;
     type?: number;
     state?: number;
-    private _ip?;
+    ip?: string;
     constructor(sn: number, user_id: string, record_time: Date, type?: number, state?: number);
-    set ip(value: string);
 }

package/dist/ztcp.d.ts

@@ -32,6 +32,8 @@ export declare class ZTCP {
     private face_cap;
     private userPacketSize;
     private verbose;
+    private packetNumber;
+    private replyData;
     constructor(ip: string, port: number, timeout: number, comm_key: number, verbose: boolean);
     createSocket(cbError: any, cbClose: any): Promise<unknown>;
     connect(): Promise<boolean>;
@@ -47,16 +49,16 @@ export declare class ZTCP {
      * reject error when command fail and resolve data when success
      */
     executeCmd(command: number, data: Buffer | string | ArrayBuffer): Promise<Buffer>;
-    sendChunkRequest(start: number, size: number): Promise<any>;
+    sendChunkRequest(start: number, size: number): Promise<void>;
     /**
      *
-     * @param {*} reqData - indicate the type of data that need to receive ( user or attLog)
-     * @param {*} cb - callback is triggered when receiving packets
+     * @param {Buffer} reqData - indicate the type of data that need to receive ( user or attLog)
+     * @param {Function} cb - callback is triggered when receiving packets
      *
      * readWithBuffer will reject error if it'wrong when starting request data
      * readWithBuffer will return { data: replyData , err: Error } when receiving requested data
      */
-    readWithBuffer(reqData: Buffer | string, cb?: any): Promise<Record<string, Buffer | number>>;
+    readWithBuffer(reqData: Buffer | string, cb?: Function): Promise<Record<string, Buffer | number>>;
     /**
      *  reject error when starting request data
      *  @return {Record<string, User[] | Error>} when receiving requested data
@@ -121,7 +123,16 @@ export declare class ZTCP {
     clearAttendanceLog(): Promise<Buffer<ArrayBufferLike>>;
     clearData(): Promise<Buffer<ArrayBufferLike>>;
     getRealTimeLogs(cb?: (realTimeLog: RealTimeLog) => void): Promise<void>;
-    getTemplates(): Promise<Finger[]>;
+    /**
+     * Get all Finger objects
+     * @returns {Record<string, Finger[]>}
+     */
+    getTemplates(callbackInProcess?: any): Promise<Record<string, Finger[]>>;
+    /**
+     * Return size
+     * @param packet
+     */
+    testTcpTop(packet: any): any;
     refreshData(): Promise<boolean>;
     sendWithBuffer(buffer: Buffer): Promise<unknown>;
     sendChunk(commandString: Buffer): Promise<unknown>;
@@ -141,7 +152,7 @@ export declare class ZTCP {
      * @returns {Promise<void>}
      * @throws {ZKErrorResponse} If registration fails
      */
-    regEvent(flags: any): Promise<void>;
+    regEvent(flags: number): Promise<void>;
     ackOk(): Promise<void>;
     cancelCapture(): Promise<boolean>;
     verifyUser(uid: number): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zklib-ts",
-  "version": "1.0.0-development",
+  "version": "1.0.2-development",
   "description": "Unofficial zkteco library allows Node.js developers to easily interface with ZK BioMetric Fingerprint Attendance Devices",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/dist/helper/models/Attendance.d.ts

@@ -1,12 +0,0 @@
-/**
- * Represents an Attendance Records
- */
-export declare class Attendance {
-    private sn;
-    private user_id;
-    private record_time;
-    private type?;
-    private state?;
-    private ip?;
-    constructor(sn: number, user_id: string, record_time: Date, type?: number, state?: number);
-}

package/dist/helper/models/Finger.d.ts

@@ -1,35 +0,0 @@
-/**
- * Represents a fingerprint template with associated metadata
- */
-export declare class Finger {
-    uid: number;
-    fid: number;
-    valid: number;
-    template: Buffer;
-    size: number;
-    readonly mark: string;
-    /**
-     * Creates a new Finger instance
-     * @param uid User internal reference
-     * @param fid Finger ID (value >= 0 && value <= 9)
-     * @param valid Flag indicating 0 = invalid | 1 = valid | 3 = duress
-     * @param template Fingerprint template data buffer
-     */
-    constructor(uid: number, fid: number, valid: number, template: Buffer);
-    /**
-     * Packs the fingerprint data with metadata into a Buffer
-     * @returns Buffer containing packed fingerprint data
-     */
-    repack(): Buffer;
-    /**
-     * Packs only the fingerprint template data into a Buffer
-     * @returns Buffer containing just the template data
-     */
-    repackOnly(): Buffer;
-    /**
-     * Compares this fingerprint with another for equality
-     * @param other Another Finger instance to compare with
-     * @returns true if all properties and template data match
-     */
-    equals(other: Finger): boolean;
-}