knx.ts 1.0.0

package/dist/utils/KNXHelper.js

@@ -0,0 +1,338 @@
+"use strict";
+//           +-----------------------------------------------+
+// 16 bits   |              INDIVIDUAL ADDRESS               |
+//           +-----------------------+-----------------------+
+//           | OCTET 0 (high byte)   |  OCTET 1 (low byte)   |
+//           +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//    bits   | 7| 6| 5| 4| 3| 2| 1| 0| 7| 6| 5| 4| 3| 2| 1| 0|
+//           +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//           |  Subnetwork Address   |                       |
+//           +-----------+-----------+     Device Address    |
+//           |(Area Adrs)|(Line Adrs)|                       |
+//           +-----------------------+-----------------------+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNXHelper = void 0;
+const InvalidKnxAddresExeption_1 = require("../errors/InvalidKnxAddresExeption");
+//           +-----------------------------------------------+
+// 16 bits   |             GROUP ADDRESS (3 level)           |
+//           +-----------------------+-----------------------+
+//           | OCTET 0 (high byte)   |  OCTET 1 (low byte)   |
+//           +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//    bits   | 7| 6| 5| 4| 3| 2| 1| 0| 7| 6| 5| 4| 3| 2| 1| 0|
+//           +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//           |  | Main Grp  | Midd G |       Sub Group       |
+//           +--+--------------------+-----------------------+
+//           +-----------------------------------------------+
+// 16 bits   |             GROUP ADDRESS (2 level)           |
+//           +-----------------------+-----------------------+
+//           | OCTET 0 (high byte)   |  OCTET 1 (low byte)   |
+//           +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//    bits   | 7| 6| 5| 4| 3| 2| 1| 0| 7| 6| 5| 4| 3| 2| 1| 0|
+//           +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+//           |  | Main Grp  |            Sub Group           |
+//           +--+--------------------+-----------------------+
+/**
+ * This class is completely based on the knx.js repo, which has been very helpful.
+ * @see https://github.com/estbeetoo/knx.js
+ */
+class KNXHelper {
+    constructor() {
+        throw new Error("This class is static");
+    }
+    static GetAddress(addr, separator = "/", threeLevelAddressing = true) {
+        // 1. Caso String: Delegar a GetAddress_
+        if (typeof addr === "string") {
+            return this.GetAddress_(addr);
+        }
+        // 2. Caso Number: llamar recursivamente
+        if (typeof addr === "number") {
+            const buffer = Buffer.alloc(2);
+            buffer.writeUint16BE(addr & 0xFFFF);
+            return this.GetAddress(buffer, separator, threeLevelAddressing);
+        }
+        // 3. Caso Buffer
+        if (Buffer.isBuffer(addr)) {
+            if (addr.length < 2) {
+                throw new Error("KNX Address buffer must be at least 2 bytes");
+            }
+            const highByte = addr[0];
+            const lowByte = addr[1];
+            const isGroup = separator === "/";
+            // Caso A: Dirección de Grupo 2 Niveles (Main/Sub11)
+            if (isGroup && !threeLevelAddressing) {
+                const main = highByte >> 3; // 5 bits
+                const sub = ((highByte & 0x07) << 8) | lowByte; // 3 bits altos + 8 bits bajos (Usar OR bitwise | es más seguro que +)
+                return `${main}/${sub}`;
+            }
+            // Caso B: Dirección de Grupo 3 Niveles (Main/Mid/Sub)
+            if (isGroup) {
+                const main = (highByte >> 3) & 0x1f; // 5 bits (0-31)
+                const middle = highByte & 0x07; // 3 bits (0-7)
+                const sub = lowByte; // 8 bits (0-255)
+                return `${main}/${middle}/${sub}`;
+            }
+            // Caso C: Dirección Individual (Area.Line.Device)
+            // Estándar: Area (4 bits), Line (4 bits), Device (8 bits)
+            const area = highByte >> 4; // 4 bits
+            const line = highByte & 0x0f; // 4 bits
+            const device = lowByte; // 8 bits
+            return `${area}.${line}.${device}`;
+        }
+        throw new TypeError("Address must be a string or a Buffer");
+    }
+    /**
+     * Converts a KNX address (string) into a 2-byte buffer, this method is an alternative to the {@link GetAddress_} method, both methods do the same thing
+     * @param address Group or individual address (e.g., "1.1.100" or "1/2/3")
+     * @param separator Address separator ("." for individual, "/" for group)
+     * @param group `true` for group address, `false` for individual address
+     * @param threeLevelAddressing `true` for 3-level, `false` for 2-level
+     * @returns 2-byte buffer with the encoded address
+     */
+    static addressToBuffer(address, separator = ".", group = false, threeLevelAddressing = true) {
+        const parts = address.split(separator).map(Number);
+        let addr = Buffer.alloc(2);
+        if (parts.length < (threeLevelAddressing ? 3 : 2)) {
+            throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException("Invalid address. Incorrect format.");
+        }
+        if (group) {
+            if (threeLevelAddressing) {
+                if (parts[0] > 31 || parts[1] > 7 || parts[2] > 255) {
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException("Invalid group address (3 levels)");
+                }
+                addr[0] = ((parts[0] & 0x1f) << 3) | (parts[1] & 0x07);
+                addr[1] = parts[2] & 0xff;
+            }
+            else {
+                if (parts[0] > 31 || parts[1] > 2047) {
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException("Invalid group address (2 levels)");
+                }
+                addr[0] = (parts[0] << 3) | ((parts[1] >> 8) & 0x07);
+                addr[1] = parts[1] & 0xff;
+            }
+        }
+        else {
+            if (parts[0] > 15 || parts[1] > 15 || parts[2] > 255) {
+                throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException("Invalid individual address.");
+            }
+            addr[0] = ((parts[0] & 0x0f) << 4) | (parts[1] & 0x0f);
+            addr[1] = parts[2] & 0xff;
+        }
+        return addr;
+    }
+    /**
+     * Converts a group address from a string into a buffer, first validating if it is a source address if its separator is **"."** otherwise validating if it is a group address if the separator is **"/"**, the alternative to this method is {@link addressToBuffer}
+     * @param address Group address
+     * @returns
+     */
+    static GetAddress_(address) {
+        try {
+            let addr = Buffer.alloc(2);
+            let threeLevelAddressing = true;
+            let parts;
+            let group = address.indexOf("/") !== -1;
+            if (!group) {
+                // individual address
+                parts = address.split(".");
+                if (parts.length != 3 || parts[0].length > 2 || parts[1].length > 2 || parts[2].length > 3)
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+            }
+            else {
+                // group address
+                parts = address.split("/");
+                if (parts.length != 3 || parts[0].length > 2 || parts[1].length > 1 || parts[2].length > 3) {
+                    if (parts.length != 2 || parts[0].length > 2 || parts[1].length > 4)
+                        throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                    threeLevelAddressing = false;
+                }
+            }
+            if (!threeLevelAddressing) {
+                let part = parseInt(parts[0]);
+                if (part > 15)
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                addr[0] = (part << 3) & 255;
+                part = parseInt(parts[1]);
+                if (part > 2047)
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                let part2 = Buffer.alloc(2);
+                part2.writeUInt16BE(part, 0);
+                if (part2.length > 2)
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                addr[0] = (addr[0] | part2[0]) & 255;
+                addr[1] = part2[1];
+            }
+            else {
+                let part = parseInt(parts[0]);
+                if (part > 31)
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                addr[0] = group ? (part << 3) & 255 : (part << 4) & 255;
+                part = parseInt(parts[1]);
+                if ((group && part > 7) || (!group && part > 15))
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                addr[0] = (addr[0] | part) & 255;
+                part = parseInt(parts[2]);
+                if (part > 255)
+                    throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+                addr[1] = part & 255;
+            }
+            return addr;
+        }
+        catch (e) {
+            throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(address);
+        }
+    }
+    static GetDataLength(data, isShort = false) {
+        if (data.length <= 0)
+            return 0;
+        if (isShort)
+            return 1;
+        if (data.length == 1 && data[0] <= 0x3f)
+            return 1;
+        if (data.length == 4)
+            return 3;
+        // if (data[0] <= 0x3f) return data.length;
+        return data.length + 1;
+    }
+    /**
+     * Método auxiliar para codificar un número en formato DPT9 (2 bytes).
+     * Implementación corregida usando aritmética de bits y complemento a dos real.
+     */
+    // private static encodeFloatToDPT9(value: number): Buffer {
+    //   // 1. Manejo de errores y casos especiales
+    //   if (isNaN(value) || !isFinite(value)) {
+    //     // Retornar valor de error estándar KNX o manejar excepción
+    //     console.warn("DPT9: Valor inválido, enviando buffer vacío/error");
+    //     return Buffer.from([0x7f, 0xff]);
+    //   }
+    //   // 2. Cálculo matemático
+    //   // FloatValue = (0.01 * M) * 2^E
+    //   let m = value / 0.01;
+    //   let e = 0;
+    //   // 3. Normalización: Buscar encajar M en 11 bits [-2048, 2047]
+    //   while ((m > 2047 || m < -2048) && e < 15) {
+    //     m /= 2;
+    //     e++;
+    //   }
+    //   // Redondeo final
+    //   let mInt = Math.round(m);
+    //   // 4. Clamping (Asegurar límites para no romper el protocolo)
+    //   if (mInt > 2047) mInt = 2047;
+    //   if (mInt < -2048) mInt = -2048;
+    //   // Caso especial: Evitar la colisión con "Invalid Data" (0x7FFF) si se diera el caso extremo
+    //   if (e === 15 && mInt > 2046) mInt = 2046;
+    //   // 5. Empaquetado
+    //   // El signo se maneja automáticamente en la mantisa de 11 bits (complemento a 2)
+    //   // pero KNX requiere que el bit de signo esté explícitamente en el bit 15 (MSB del buffer)
+    //   const signBit = mInt < 0 ? 1 : 0;
+    //   // Máscara 0x7FF (2047) obtiene los 11 bits bajos de la mantisa (sea positiva o negativa)
+    //   const mantissaBits = mInt & 0x7ff;
+    //   // Estructura: S (1 bit) | E (4 bits) | M (11 bits)
+    //   const encoded = (signBit << 15) | ((e & 0x0f) << 11) | mantissaBits;
+    //   const buffer = Buffer.alloc(2);
+    //   buffer.writeUInt16BE(encoded, 0);
+    //   return buffer;
+    // }
+    /**
+     * Escribe los datos en el datagrama.
+     * @param datagram PDU
+     * @param data
+     * @param dataStart Debe ser siempre en el indice donde están los bits menos significativos del APCI
+     * @param isShort Si es true, el dato se incrusta en los 6 bits del APCI (DPT 1, 2, 3)
+     */
+    static WriteData(datagram, data, dataStart, isShort = false) {
+        if (!data || data.length === 0)
+            return;
+        // ESTRATEGIA: DPT9 (Float 16-bit)
+        // Asumimos que si vienen 4 bytes, es un Float32 crudo que debe convertirse a DPT9
+        // !! No es necesario si ya hay una clase que lo codifica, decidir procesarlo aqui desafia lo que se espera de esta escritura
+        // if (data.length === 4) {
+        //   const floatValue = data.readFloatLE(0);
+        //   const dpt9Buffer = this.encodeFloatToDPT9(floatValue);
+        //   // DPT9 siempre ocupa 2 bytes y va después del byte de control APCI
+        //   datagram[dataStart + 1] = dpt9Buffer[0];
+        //   datagram[dataStart + 2] = dpt9Buffer[1];
+        //   return;
+        // }
+        // ESTRATEGIA: Optimización "Short Data" (6 bits)
+        // Si es 1 byte y el valor es pequeño (<= 0x3F), asumimos que es DPT1/2/3 y lo incrustamos.
+        if (data.length === 1 && data[0] <= 0x3f || isShort) {
+            // Usamos OR para mezclar los 6 bits bajos con el comando existente en dataStart
+            datagram[dataStart] = (datagram[dataStart] & 0xc0) | (data[0] & 0x3f);
+            return;
+        }
+        // ESTRATEGIA: Datos estándar (> 6 bits o arrays largos)
+        // Se escriben a partir del siguiente byte (dataStart + 1)
+        datagram[dataStart] = datagram[dataStart] & 0xc0; // Limpiamos la parte de datos del byte de control
+        for (var i = 0; i < data.length; i++) {
+            datagram[dataStart + 1 + i] = data[i];
+        }
+    }
+    /**
+     * Verifica si una dirección de grupo KNX es válida.
+     * Los formatos admitidos son:
+     *   - 3 niveles: "main/middle/sub" donde:
+     *       main: 0-31, middle: 0-7, sub: 0-255.
+     *   - 2 niveles: "main/sub" donde:
+     *       main: 0-31, sub: 0-2047.
+     *   - 1 nivel: un número entre 0 y 65535.
+     *
+     * @param address Dirección de grupo en formato string.
+     * @returns true si la dirección es válida; false en caso contrario.
+     */
+    static isValidGroupAddress(address) {
+        const threeLevelRegex = /^(\d{1,2})\/(\d{1,2})\/(\d{1,3})$/;
+        const twoLevelRegex = /^(\d{1,2})\/(\d{1,4})$/;
+        const oneLevelRegex = /^\d+$/;
+        let match;
+        if ((match = address.match(threeLevelRegex))) {
+            const main = parseInt(match[1], 10);
+            const middle = parseInt(match[2], 10);
+            const sub = parseInt(match[3], 10);
+            return main >= 0 && main <= 31 && middle >= 0 && middle <= 7 && sub >= 0 && sub <= 255;
+        }
+        else if ((match = address.match(twoLevelRegex))) {
+            const main = parseInt(match[1], 10);
+            const sub = parseInt(match[2], 10);
+            return main >= 0 && main <= 31 && sub >= 0 && sub <= 2047;
+        }
+        else if (oneLevelRegex.test(address)) {
+            const value = parseInt(address, 10);
+            return value >= 0 && value <= 65535;
+        }
+        return false;
+    }
+    /**
+     * Verifica si una dirección individual KNX es válida.
+     * Formato válido: "area.line.device" donde:
+     *   - area: 0–15
+     *   - line: 0–15
+     *   - device: 0–255
+     *
+     * @param address Dirección individual en formato string.
+     * @returns true si la dirección es válida; false en caso contrario.
+     */
+    static isValidIndividualAddress(address) {
+        const regex = /^(\d{1,2})\.(\d{1,2})\.(\d{1,3})$/;
+        const match = address.match(regex);
+        if (!match)
+            return false;
+        const area = parseInt(match[1], 10);
+        const line = parseInt(match[2], 10);
+        const device = parseInt(match[3], 10);
+        return area >= 0 && area <= 15 && line >= 0 && line <= 15 && device >= 0 && device <= 255;
+    }
+    /**
+     * Verifica si un Buffer de 2 octetos representa una dirección de grupo KNX válida.
+     *
+     * Se asume que la dirección se codifica en 2 bytes (0–65535).
+     *
+     * @param buffer Buffer con la dirección de grupo.
+     * @returns true si el buffer es válido; false en caso contrario.
+     */
+    static isValidGroupAddressBuffer(buffer) {
+        if (buffer.length !== 2)
+            return false;
+        const value = buffer.readUInt16BE(0);
+        return value >= 0 && value <= 65535;
+    }
+}
+exports.KNXHelper = KNXHelper;

package/dist/utils/Logger.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from "pino";
+import { KNXLoggerOptions } from "../@types/interfaces/connection";
+/**
+ * Creates a configured pino logger instance.
+ * Completely configurable via options, no environment variable dependencies.
+ * Production mode (JSON) is only active if NOT in a test environment.
+ */
+export declare const createKNXLogger: (options?: KNXLoggerOptions) => Logger;
+/**
+ * Global default logger instance.
+ */
+export declare let knxLogger: Logger;
+/**
+ * Configures the global knxLogger instance.
+ * Call this at the beginning of your application to apply custom settings.
+ */
+export declare const setupLogger: (options: KNXLoggerOptions) => Logger;

package/dist/utils/Logger.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupLogger = exports.knxLogger = exports.createKNXLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const colorette_1 = require("colorette");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Creates a configured pino logger instance.
+ * Completely configurable via options, no environment variable dependencies.
+ * Production mode (JSON) is only active if NOT in a test environment.
+ */
+const createKNXLogger = (options) => {
+    const isProduction = process.env.NODE_ENV === "production";
+    const targets = [];
+    // 1. Console Transport
+    if (!isProduction) {
+        targets.push({
+            target: "pino-pretty",
+            options: {
+                colorize: colorette_1.isColorSupported,
+                messageFormat: "[{module}] {msg}",
+                translateTime: "SYS:HH:MM:ss.l",
+                ignore: "pid,hostname,module",
+                customColors: "info:blue,warn:yellow,error:red,debug:magenta",
+            },
+        });
+    }
+    else if (options?.logToFile) {
+        // In production with file logging, we must explicitly add stdout if we want it
+        targets.push({
+            target: "pino/file",
+            options: { destination: 1 }, // 1 = stdout
+        });
+    }
+    // 2. File Transport (pino-roll)
+    if (options?.logToFile) {
+        const logDir = options.logDir || "./logs";
+        let logFile = options.logFilename;
+        if (!logFile || logFile.trim() === "") {
+            const now = new Date();
+            const dateStr = now.toISOString().split("T")[0]; // YYYY-MM-DD
+            logFile = `${dateStr}.log`;
+        }
+        if (!fs_1.default.existsSync(logDir)) {
+            fs_1.default.mkdirSync(logDir, { recursive: true });
+        }
+        targets.push({
+            target: "pino-roll",
+            options: {
+                file: path_1.default.join(logDir, logFile),
+                size: options.logSize || "10M",
+                interval: options.logInterval || "1d",
+                limit: {
+                    count: options.logKeepCount || 7,
+                },
+                mkdir: true,
+            },
+        });
+    }
+    const transportConfig = targets.length > 0
+        ? { targets }
+        : undefined;
+    const defaultOptions = {
+        level: options?.level || "info",
+        timestamp: () => `,"time":"${new Date(Date.now()).toISOString()}"`,
+        enabled: options?.enabled ?? true,
+        transport: options?.transport || transportConfig,
+        ...options,
+    };
+    // Pino does not allow custom level formatters when using transports with targets
+    if (!defaultOptions.transport) {
+        defaultOptions.formatters = {
+            level: (label) => ({ level: label }),
+            ...options?.formatters,
+        };
+    }
+    return (0, pino_1.default)(defaultOptions);
+};
+exports.createKNXLogger = createKNXLogger;
+/**
+ * Global default logger instance.
+ */
+exports.knxLogger = (0, exports.createKNXLogger)();
+/**
+ * Configures the global knxLogger instance.
+ * Call this at the beginning of your application to apply custom settings.
+ */
+const setupLogger = (options) => {
+    exports.knxLogger = (0, exports.createKNXLogger)(options);
+    return exports.knxLogger;
+};
+exports.setupLogger = setupLogger;

package/dist/utils/MessageCodeTranslator.d.ts

@@ -0,0 +1,19 @@
+type StandardType = "EMI1" | "EMI2/IMI2" | "IMI1" | "CEMI";
+export declare class MessageCodeTranslator {
+    private static emi1Map;
+    private static emi2Map;
+    private static cemiMap;
+    /**
+     * Traduce un código de mensaje de un estándar origen a un estándar destino.
+     * @param sourceCode El byte recibido (ej. 0x49)
+     * @param from El estándar origen (ej. "EMI1")
+     * @param to El estándar destino (ej. "CEMI")
+     * @returns El código traducido (ej. 0x29) o null si no existe equivalencia.
+     */
+    static translate(sourceCode: number, from: StandardType, to: StandardType): number | null;
+    /**
+     * Obtiene el nombre legible del servicio dado un código (útil para logs/debug)
+     */
+    static getServiceName(code: number, standard: StandardType): string | null;
+}
+export {};

package/dist/utils/MessageCodeTranslator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCodeTranslator = void 0;
+const MessageCodeField_1 = require("../core/MessageCodeField");
+class MessageCodeTranslator {
+    // Mapas para búsqueda rápida: Code -> ServiceName
+    static emi1Map = new Map();
+    static emi2Map = new Map();
+    static cemiMap = new Map();
+    // Inicialización estática (se ejecuta una sola vez)
+    static {
+        for (const [serviceName, standards] of Object.entries(MessageCodeField_1.MESSAGE_CODE_FIELD)) {
+            if (!standards)
+                continue;
+            // Mapear EMI1
+            if ("EMI1" in standards && standards.EMI1) {
+                this.emi1Map.set(standards.EMI1.value, serviceName);
+            }
+            // Mapear EMI2
+            if ("EMI2/IMI2" in standards && standards["EMI2/IMI2"]) {
+                this.emi2Map.set(standards["EMI2/IMI2"].value, serviceName);
+            }
+            // Mapear CEMI
+            if ("CEMI" in standards && standards.CEMI) {
+                this.cemiMap.set(standards.CEMI.value, serviceName);
+            }
+        }
+    }
+    /**
+     * Traduce un código de mensaje de un estándar origen a un estándar destino.
+     * @param sourceCode El byte recibido (ej. 0x49)
+     * @param from El estándar origen (ej. "EMI1")
+     * @param to El estándar destino (ej. "CEMI")
+     * @returns El código traducido (ej. 0x29) o null si no existe equivalencia.
+     */
+    static translate(sourceCode, from, to) {
+        // 1. Identificar el nombre del servicio (ej. "L_Data.ind")
+        let serviceName;
+        switch (from) {
+            case "EMI1":
+                serviceName = this.emi1Map.get(sourceCode);
+                break;
+            case "EMI2/IMI2":
+                serviceName = this.emi2Map.get(sourceCode);
+                break;
+            case "CEMI":
+                serviceName = this.cemiMap.get(sourceCode);
+                break;
+        }
+        if (!serviceName)
+            return null; // Código no reconocido en el origen
+        // 2. Obtener el valor en el estándar destino
+        const targetStandard = MessageCodeField_1.MESSAGE_CODE_FIELD[serviceName];
+        // Verificación de tipo segura
+        if (targetStandard && to in targetStandard) {
+            // @ts-ignore: TypeScript puede quejarse del acceso dinámico, pero la lógica es sólida
+            return targetStandard[to]?.value ?? null;
+        }
+        return null;
+    }
+    /**
+     * Obtiene el nombre legible del servicio dado un código (útil para logs/debug)
+     */
+    static getServiceName(code, standard) {
+        switch (standard) {
+            case "EMI1":
+                return this.emi1Map.get(code) || null;
+            case "EMI2/IMI2":
+                return this.emi2Map.get(code) || null;
+            case "CEMI":
+                return this.cemiMap.get(code) || null;
+            default:
+                return null;
+        }
+    }
+}
+exports.MessageCodeTranslator = MessageCodeTranslator;

package/dist/utils/checksumFrame.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Calcula el FCS (Frame Check Sequence) de un buffer KNX (sin incluir el FCS final)
+ * @param buffer Buffer con el contenido del telegrama SIN el FCS
+ * @returns Byte FCS calculado
+ */
+export declare function checksum(buffer: Buffer): number;
+/**
+ * Verifica el FCS (Frame Check Sequence) de un buffer KNX.
+ * @param buffer Buffer completo del frame (incluyendo FCS al final)
+ * @returns true si el FCS es válido, false en caso contrario
+ */
+export declare function verifyFCS(buffer: Buffer): boolean;
+/**
+ * Verifica y remueve el FCS de un buffer.
+ * @param buffer Buffer completo del frame
+ * @returns Buffer sin el FCS si es válido, lanza error si no lo es
+ */
+export declare function verifyAndRemoveFCS(buffer: Buffer): Buffer;

package/dist/utils/checksumFrame.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checksum = checksum;
+exports.verifyFCS = verifyFCS;
+exports.verifyAndRemoveFCS = verifyAndRemoveFCS;
+/**
+ * Calcula el FCS (Frame Check Sequence) de un buffer KNX (sin incluir el FCS final)
+ * @param buffer Buffer con el contenido del telegrama SIN el FCS
+ * @returns Byte FCS calculado
+ */
+function checksum(buffer) {
+    let fcs = 0x00;
+    for (let i = 0; i < buffer.length; i++) {
+        fcs ^= buffer[i];
+    }
+    return fcs;
+}
+/**
+ * Verifica el FCS (Frame Check Sequence) de un buffer KNX.
+ * @param buffer Buffer completo del frame (incluyendo FCS al final)
+ * @returns true si el FCS es válido, false en caso contrario
+ */
+function verifyFCS(buffer) {
+    if (buffer.length === 0) {
+        return false;
+    }
+    const receivedFCS = buffer[buffer.length - 1];
+    const calculatedFCS = checksum(buffer.subarray(0, buffer.length - 1));
+    return receivedFCS === calculatedFCS;
+}
+/**
+ * Verifica y remueve el FCS de un buffer.
+ * @param buffer Buffer completo del frame
+ * @returns Buffer sin el FCS si es válido, lanza error si no lo es
+ */
+function verifyAndRemoveFCS(buffer) {
+    if (!verifyFCS(buffer)) {
+        throw new Error("Invalid FCS in frame");
+    }
+    return buffer.subarray(0, buffer.length - 1);
+}

package/dist/utils/localIp.d.ts

@@ -0,0 +1,7 @@
+export declare function getLocalIP(): string;
+export declare function getLocalMac(): string;
+export declare function getNetworkInfo(): {
+    address: string;
+    netmask: string;
+    mac: string;
+};

package/dist/utils/localIp.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalIP = getLocalIP;
+exports.getLocalMac = getLocalMac;
+exports.getNetworkInfo = getNetworkInfo;
+const os_1 = __importDefault(require("os"));
+function getLocalIP() {
+    const networkInterfaces = os_1.default.networkInterfaces();
+    for (const interfaceName in networkInterfaces) {
+        const interfaces = networkInterfaces[interfaceName];
+        for (const net of interfaces) {
+            if (net.family === 'IPv4' && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+function getLocalMac() {
+    const info = getNetworkInfo();
+    return info.mac;
+}
+function getNetworkInfo() {
+    const networkInterfaces = os_1.default.networkInterfaces();
+    for (const interfaceName in networkInterfaces) {
+        const interfaces = networkInterfaces[interfaceName];
+        for (const net of interfaces) {
+            if (net.family === 'IPv4' && !net.internal) {
+                return {
+                    address: net.address,
+                    netmask: net.netmask,
+                    mac: net.mac
+                };
+            }
+        }
+    }
+    return {
+        address: '0.0.0.0',
+        netmask: '0.0.0.0',
+        mac: '00:00:00:00:00:00'
+    };
+}