zigbee-herdsman 6.0.1 → 6.0.3

package/src/zspec/zcl/utils.ts

@@ -1,321 +0,0 @@
-import {Clusters} from "./definition/cluster";
-import {DataType, DataTypeClass} from "./definition/enums";
-import {Foundation, type FoundationCommandName, type FoundationDefinition} from "./definition/foundation";
-import type {Attribute, Cluster, ClusterDefinition, ClusterName, Command, CustomClusters} from "./definition/tstype";
-
-const DATA_TYPE_CLASS_DISCRETE = [
-    DataType.DATA8,
-    DataType.DATA16,
-    DataType.DATA24,
-    DataType.DATA32,
-    DataType.DATA40,
-    DataType.DATA48,
-    DataType.DATA56,
-    DataType.DATA64,
-    DataType.BOOLEAN,
-    DataType.BITMAP8,
-    DataType.BITMAP16,
-    DataType.BITMAP24,
-    DataType.BITMAP32,
-    DataType.BITMAP40,
-    DataType.BITMAP48,
-    DataType.BITMAP56,
-    DataType.BITMAP64,
-    DataType.ENUM8,
-    DataType.ENUM16,
-    DataType.OCTET_STR,
-    DataType.CHAR_STR,
-    DataType.LONG_OCTET_STR,
-    DataType.LONG_CHAR_STR,
-    DataType.ARRAY,
-    DataType.STRUCT,
-    DataType.SET,
-    DataType.BAG,
-    DataType.CLUSTER_ID,
-    DataType.ATTR_ID,
-    DataType.BAC_OID,
-    DataType.IEEE_ADDR,
-    DataType.SEC_KEY,
-];
-const DATA_TYPE_CLASS_ANALOG = [
-    DataType.UINT8,
-    DataType.UINT16,
-    DataType.UINT24,
-    DataType.UINT32,
-    DataType.UINT40,
-    DataType.UINT48,
-    DataType.UINT56,
-    DataType.INT8,
-    DataType.INT16,
-    DataType.INT24,
-    DataType.INT32,
-    DataType.INT40,
-    DataType.INT48,
-    DataType.INT56,
-    DataType.SEMI_PREC,
-    DataType.SINGLE_PREC,
-    DataType.DOUBLE_PREC,
-    DataType.TOD,
-    DataType.DATE,
-    DataType.UTC,
-];
-
-const FOUNDATION_DISCOVER_RSP_IDS = [
-    Foundation.discoverRsp.ID,
-    Foundation.discoverCommandsRsp.ID,
-    Foundation.discoverCommandsGenRsp.ID,
-    Foundation.discoverExtRsp.ID,
-];
-
-export function getDataTypeClass(dataType: DataType): DataTypeClass {
-    if (DATA_TYPE_CLASS_DISCRETE.includes(dataType)) {
-        return DataTypeClass.DISCRETE;
-    }
-
-    if (DATA_TYPE_CLASS_ANALOG.includes(dataType)) {
-        return DataTypeClass.ANALOG;
-    }
-
-    throw new Error(`Don't know value type for '${DataType[dataType]}'`);
-}
-
-function hasCustomClusters(customClusters: CustomClusters): boolean {
-    // XXX: was there a good reason to not set the parameter `customClusters` optional? it would allow simple undefined check
-    // below is twice faster than checking `Object.keys(customClusters).length`
-    for (const _k in customClusters) return true;
-    return false;
-}
-
-function findClusterNameByID(
-    id: number,
-    manufacturerCode: number | undefined,
-    clusters: CustomClusters,
-): [name: string | undefined, partialMatch: boolean] {
-    let name: string | undefined;
-    // if manufacturer code is given, consider partial match if didn't match against manufacturer code
-    let partialMatch = Boolean(manufacturerCode);
-
-    for (const clusterName in clusters) {
-        const cluster = clusters[clusterName as ClusterName];
-
-        if (cluster.ID === id) {
-            // priority on first match when matching only ID
-            if (name === undefined) {
-                name = clusterName;
-            }
-
-            if (manufacturerCode && cluster.manufacturerCode === manufacturerCode) {
-                name = clusterName;
-                partialMatch = false;
-                break;
-            }
-
-            if (!cluster.manufacturerCode) {
-                name = clusterName;
-                break;
-            }
-        }
-    }
-
-    return [name, partialMatch];
-}
-
-function getClusterDefinition(
-    key: string | number,
-    manufacturerCode: number | undefined,
-    customClusters: CustomClusters,
-): {name: string; cluster: ClusterDefinition} {
-    let name: string | undefined;
-
-    if (typeof key === "number") {
-        let partialMatch: boolean;
-
-        // custom clusters have priority over Zcl clusters, except in case of better match (see below)
-        [name, partialMatch] = findClusterNameByID(key, manufacturerCode, customClusters);
-
-        if (!name) {
-            [name, partialMatch] = findClusterNameByID(key, manufacturerCode, Clusters);
-        } else if (partialMatch) {
-            let zclName: string | undefined;
-            [zclName, partialMatch] = findClusterNameByID(key, manufacturerCode, Clusters);
-
-            // Zcl clusters contain a better match, use that one
-            if (zclName !== undefined && !partialMatch) {
-                name = zclName;
-            }
-        }
-    } else {
-        name = key;
-    }
-
-    let cluster =
-        name !== undefined && hasCustomClusters(customClusters)
-            ? {
-                  ...Clusters[name as ClusterName],
-                  ...customClusters[name], // should override Zcl clusters
-              }
-            : Clusters[name as ClusterName];
-
-    if (!cluster || cluster.ID === undefined) {
-        if (typeof key === "number") {
-            name = key.toString();
-            cluster = {attributes: {}, commands: {}, commandsResponse: {}, manufacturerCode: undefined, ID: key};
-        } else {
-            name = undefined;
-        }
-    }
-
-    if (!name) {
-        throw new Error(`Cluster with name '${key}' does not exist`);
-    }
-
-    return {name, cluster};
-}
-
-function cloneClusterEntriesWithName<T extends Record<string, unknown>>(entries: Record<string, T>): Record<string, {name: string} & T> {
-    const clone: Record<string, {name: string} & T> = {};
-
-    for (const key in entries) {
-        clone[key] = {...entries[key], name: key};
-    }
-
-    return clone;
-}
-
-function createCluster(name: string, cluster: ClusterDefinition, manufacturerCode?: number): Cluster {
-    const attributes: Record<string, Attribute> = cloneClusterEntriesWithName(cluster.attributes);
-    const commands: Record<string, Command> = cloneClusterEntriesWithName(cluster.commands);
-    const commandsResponse: Record<string, Command> = cloneClusterEntriesWithName(cluster.commandsResponse);
-
-    const getAttribute = (key: number | string): Attribute | undefined => {
-        if (typeof key === "number") {
-            let partialMatchAttr: Attribute | undefined;
-
-            for (const attrKey in attributes) {
-                const attr = attributes[attrKey];
-
-                if (attr.ID === key) {
-                    if (manufacturerCode && attr.manufacturerCode === manufacturerCode) {
-                        return attr;
-                    }
-
-                    if (attr.manufacturerCode === undefined) {
-                        partialMatchAttr = attr;
-                    }
-                }
-            }
-
-            return partialMatchAttr;
-        }
-
-        return attributes[key];
-    };
-
-    const getCommand = (key: number | string): Command => {
-        if (typeof key === "number") {
-            for (const cmdKey in commands) {
-                const cmd = commands[cmdKey];
-
-                if (cmd.ID === key) {
-                    return cmd;
-                }
-            }
-        } else {
-            const cmd = commands[key];
-
-            if (cmd) {
-                return cmd;
-            }
-        }
-
-        throw new Error(`Cluster '${name}' has no command '${key}'`);
-    };
-
-    const getCommandResponse = (key: number | string): Command => {
-        if (typeof key === "number") {
-            for (const cmdKey in commandsResponse) {
-                const cmd = commandsResponse[cmdKey];
-
-                if (cmd.ID === key) {
-                    return cmd;
-                }
-            }
-        } else {
-            const cmd = commandsResponse[key];
-
-            if (cmd) {
-                return cmd;
-            }
-        }
-
-        throw new Error(`Cluster '${name}' has no command response '${key}'`);
-    };
-
-    return {
-        ID: cluster.ID,
-        attributes,
-        manufacturerCode: cluster.manufacturerCode,
-        name,
-        commands,
-        commandsResponse,
-        getAttribute,
-        getCommand,
-        getCommandResponse,
-    };
-}
-
-export function getCluster(key: string | number, manufacturerCode: number | undefined = undefined, customClusters: CustomClusters = {}): Cluster {
-    const {name, cluster} = getClusterDefinition(key, manufacturerCode, customClusters);
-    return createCluster(name, cluster, manufacturerCode);
-}
-
-function getGlobalCommandNameById(id: number): FoundationCommandName {
-    for (const commandName in Foundation) {
-        if (Foundation[commandName as FoundationCommandName].ID === id) {
-            return commandName as FoundationCommandName;
-        }
-    }
-
-    throw new Error(`Global command with id '${id}' does not exist.`);
-}
-
-export function getGlobalCommand(key: number | string): Command {
-    const name = typeof key === "number" ? getGlobalCommandNameById(key) : (key as FoundationCommandName);
-    const command = Foundation[name];
-
-    if (!command) {
-        throw new Error(`Global command with key '${key}' does not exist`);
-    }
-
-    const result: Command = {
-        ID: command.ID,
-        name,
-        parameters: command.parameters,
-    };
-
-    if (command.response !== undefined) {
-        result.response = command.response;
-    }
-
-    return result;
-}
-
-export function isClusterName(name: string): name is ClusterName {
-    return name in Clusters;
-}
-
-export function getFoundationCommand(id: number): FoundationDefinition {
-    for (const commandName in Foundation) {
-        const command = Foundation[commandName as FoundationCommandName];
-
-        if (command.ID === id) {
-            return command;
-        }
-    }
-
-    throw new Error(`Foundation command '${id}' does not exist.`);
-}
-
-export function isFoundationDiscoverRsp(id: number): boolean {
-    return FOUNDATION_DISCOVER_RSP_IDS.includes(id);
-}

package/src/zspec/zcl/zclFrame.ts

@@ -1,356 +0,0 @@
-import "../../utils/patchBigIntSerialization";
-
-import {BuffaloZcl} from "./buffaloZcl";
-import {BuffaloZclDataType, DataType, Direction, FrameType, ParameterCondition} from "./definition/enums";
-import type {FoundationCommandName} from "./definition/foundation";
-import type {BuffaloZclOptions, Cluster, ClusterName, Command, CustomClusters, ParameterDefinition} from "./definition/tstype";
-import * as Utils from "./utils";
-import {ZclHeader} from "./zclHeader";
-
-// biome-ignore lint/suspicious/noExplicitAny: API
-type ZclPayload = any;
-
-const ListTypes: number[] = [
-    BuffaloZclDataType.LIST_UINT8,
-    BuffaloZclDataType.LIST_UINT16,
-    BuffaloZclDataType.LIST_UINT24,
-    BuffaloZclDataType.LIST_UINT32,
-    BuffaloZclDataType.LIST_ZONEINFO,
-];
-
-export class ZclFrame {
-    public readonly header: ZclHeader;
-    public readonly payload: ZclPayload;
-    public readonly cluster: Cluster;
-    public readonly command: Command;
-
-    private constructor(header: ZclHeader, payload: ZclPayload, cluster: Cluster, command: Command) {
-        this.header = header;
-        this.payload = payload;
-        this.cluster = cluster;
-        this.command = command;
-    }
-
-    public toString(): string {
-        return JSON.stringify({header: this.header, payload: this.payload, command: this.command});
-    }
-
-    /**
-     * Creating
-     */
-    public static create(
-        frameType: FrameType,
-        direction: Direction,
-        disableDefaultResponse: boolean,
-        manufacturerCode: number | undefined,
-        transactionSequenceNumber: number,
-        commandKey: number | string | Command,
-        clusterKey: number | string | Cluster,
-        payload: ZclPayload,
-        customClusters: CustomClusters,
-        reservedBits = 0,
-    ): ZclFrame {
-        const cluster = typeof clusterKey === "object" ? clusterKey : Utils.getCluster(clusterKey, manufacturerCode, customClusters);
-        const command: Command =
-            typeof commandKey === "object"
-                ? commandKey
-                : frameType === FrameType.GLOBAL
-                  ? Utils.getGlobalCommand(commandKey)
-                  : direction === Direction.CLIENT_TO_SERVER
-                    ? cluster.getCommand(commandKey)
-                    : cluster.getCommandResponse(commandKey);
-
-        const header = new ZclHeader(
-            {reservedBits, frameType, direction, disableDefaultResponse, manufacturerSpecific: manufacturerCode != null},
-            manufacturerCode,
-            transactionSequenceNumber,
-            command.ID,
-        );
-
-        return new ZclFrame(header, payload, cluster, command);
-    }
-
-    public toBuffer(): Buffer {
-        const buffalo = new BuffaloZcl(Buffer.alloc(250));
-        this.header.write(buffalo);
-
-        if (this.header.isGlobal) {
-            this.writePayloadGlobal(buffalo);
-        } else if (this.header.isSpecific) {
-            this.writePayloadCluster(buffalo);
-        } else {
-            throw new Error(`Frametype '${this.header.frameControl.frameType}' not valid`);
-        }
-
-        return buffalo.getWritten();
-    }
-
-    private writePayloadGlobal(buffalo: BuffaloZcl): void {
-        const command = Utils.getFoundationCommand(this.command.ID);
-
-        if (command.parseStrategy === "repetitive") {
-            for (const entry of this.payload) {
-                for (const parameter of command.parameters) {
-                    const options: BuffaloZclOptions = {};
-
-                    if (!ZclFrame.conditionsValid(parameter, entry, undefined)) {
-                        continue;
-                    }
-
-                    if (parameter.type === BuffaloZclDataType.USE_DATA_TYPE && typeof entry.dataType === "number") {
-                        // We need to grab the dataType to parse useDataType
-                        options.dataType = entry.dataType;
-                    }
-
-                    buffalo.write(parameter.type, entry[parameter.name], options);
-                }
-            }
-        } else if (command.parseStrategy === "flat") {
-            for (const parameter of command.parameters) {
-                buffalo.write(parameter.type, this.payload[parameter.name], {});
-            }
-        } else {
-            if (command.parseStrategy === "oneof") {
-                if (Utils.isFoundationDiscoverRsp(command.ID)) {
-                    buffalo.writeUInt8(this.payload.discComplete);
-
-                    for (const entry of this.payload.attrInfos) {
-                        for (const parameter of command.parameters) {
-                            buffalo.write(parameter.type, entry[parameter.name], {});
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private writePayloadCluster(buffalo: BuffaloZcl): void {
-        for (const parameter of this.command.parameters) {
-            if (!ZclFrame.conditionsValid(parameter, this.payload, undefined)) {
-                continue;
-            }
-
-            // TODO: biome migration - safer
-            if (this.payload[parameter.name] == null) {
-                throw new Error(`Parameter '${parameter.name}' is missing`);
-            }
-
-            buffalo.write(parameter.type, this.payload[parameter.name], {});
-        }
-    }
-
-    /**
-     * Parsing
-     */
-    public static fromBuffer(clusterID: number, header: ZclHeader | undefined, buffer: Buffer, customClusters: CustomClusters): ZclFrame {
-        if (!header) {
-            throw new Error("Invalid ZclHeader.");
-        }
-
-        const buffalo = new BuffaloZcl(buffer, header.length);
-        const cluster = Utils.getCluster(clusterID, header.manufacturerCode, customClusters);
-        const command: Command = header.isGlobal
-            ? Utils.getGlobalCommand(header.commandIdentifier)
-            : header.frameControl.direction === Direction.CLIENT_TO_SERVER
-              ? cluster.getCommand(header.commandIdentifier)
-              : cluster.getCommandResponse(header.commandIdentifier);
-        const payload = ZclFrame.parsePayload(header, cluster, buffalo);
-
-        return new ZclFrame(header, payload, cluster, command);
-    }
-
-    private static parsePayload(header: ZclHeader, cluster: Cluster, buffalo: BuffaloZcl): ZclPayload {
-        if (header.isGlobal) {
-            return ZclFrame.parsePayloadGlobal(header, buffalo);
-        }
-
-        if (header.isSpecific) {
-            return ZclFrame.parsePayloadCluster(header, cluster, buffalo);
-        }
-
-        throw new Error(`Unsupported frameType '${header.frameControl.frameType}'`);
-    }
-
-    private static parsePayloadCluster(header: ZclHeader, cluster: Cluster, buffalo: BuffaloZcl): ZclPayload {
-        const command =
-            header.frameControl.direction === Direction.CLIENT_TO_SERVER
-                ? cluster.getCommand(header.commandIdentifier)
-                : cluster.getCommandResponse(header.commandIdentifier);
-        const payload: ZclPayload = {};
-
-        for (const parameter of command.parameters) {
-            const options: BuffaloZclOptions = {payload};
-
-            if (!ZclFrame.conditionsValid(parameter, payload, buffalo.getBuffer().length - buffalo.getPosition())) {
-                continue;
-            }
-
-            if (ListTypes.includes(parameter.type)) {
-                const lengthParameter = command.parameters[command.parameters.indexOf(parameter) - 1];
-                const length = payload[lengthParameter.name];
-
-                if (typeof length === "number") {
-                    options.length = length;
-                }
-            }
-
-            try {
-                payload[parameter.name] = buffalo.read(parameter.type, options);
-            } catch (error) {
-                throw new Error(`Cannot parse '${command.name}:${parameter.name}' (${(error as Error).message})`);
-            }
-        }
-
-        return payload;
-    }
-
-    private static parsePayloadGlobal(header: ZclHeader, buffalo: BuffaloZcl): ZclPayload {
-        const command = Utils.getFoundationCommand(header.commandIdentifier);
-
-        if (command.parseStrategy === "repetitive") {
-            const payload = [];
-
-            while (buffalo.isMore()) {
-                // biome-ignore lint/suspicious/noExplicitAny: API
-                const entry: {[s: string]: any} = {};
-
-                for (const parameter of command.parameters) {
-                    const options: BuffaloZclOptions = {};
-
-                    if (!ZclFrame.conditionsValid(parameter, entry, buffalo.getBuffer().length - buffalo.getPosition())) {
-                        continue;
-                    }
-
-                    if (parameter.type === BuffaloZclDataType.USE_DATA_TYPE && typeof entry.dataType === "number") {
-                        // We need to grab the dataType to parse useDataType
-                        options.dataType = entry.dataType;
-
-                        if (entry.dataType === DataType.CHAR_STR && entry.attrId === 65281) {
-                            // [workaround] parse char str as Xiaomi struct
-                            options.dataType = BuffaloZclDataType.MI_STRUCT;
-                        }
-                    }
-
-                    entry[parameter.name] = buffalo.read(parameter.type, options);
-
-                    // TODO: not needed, but temp workaroudn to make payload equal to that of zcl-packet
-                    // XXX: is this still needed?
-                    if (parameter.type === BuffaloZclDataType.USE_DATA_TYPE && entry.dataType === DataType.STRUCT) {
-                        entry.structElms = entry.attrData;
-                        entry.numElms = entry.attrData.length;
-                    }
-                }
-
-                payload.push(entry);
-            }
-
-            return payload;
-        }
-
-        if (command.parseStrategy === "flat") {
-            // biome-ignore lint/suspicious/noExplicitAny: API
-            const payload: {[s: string]: any} = {};
-
-            for (const parameter of command.parameters) {
-                payload[parameter.name] = buffalo.read(parameter.type, {});
-            }
-
-            return payload;
-        }
-
-        if (command.parseStrategy === "oneof") {
-            if (Utils.isFoundationDiscoverRsp(command.ID)) {
-                // biome-ignore lint/suspicious/noExplicitAny: API
-                const payload: {discComplete: number; attrInfos: {[k: string]: any}[]} = {
-                    discComplete: buffalo.readUInt8(),
-                    attrInfos: [],
-                };
-
-                while (buffalo.isMore()) {
-                    const entry: (typeof payload.attrInfos)[number] = {};
-
-                    for (const parameter of command.parameters) {
-                        entry[parameter.name] = buffalo.read(parameter.type, {});
-                    }
-
-                    payload.attrInfos.push(entry);
-                }
-
-                return payload;
-            }
-        }
-    }
-
-    /**
-     * Utils
-     */
-
-    public static conditionsValid(parameter: ParameterDefinition, entry: ZclPayload, remainingBufferBytes: number | undefined): boolean {
-        if (parameter.conditions) {
-            for (const condition of parameter.conditions) {
-                switch (condition.type) {
-                    case ParameterCondition.FIELD_EQUAL: {
-                        if (condition.reversed) {
-                            if (entry[condition.field] === condition.value) {
-                                return false;
-                            }
-                        } else if (entry[condition.field] !== condition.value) {
-                            return false;
-                        }
-                        break;
-                    }
-                    case ParameterCondition.BITMASK_SET: {
-                        if (condition.reversed) {
-                            if ((entry[condition.param] & condition.mask) === condition.mask) {
-                                return false;
-                            }
-                        } else if ((entry[condition.param] & condition.mask) !== condition.mask) {
-                            return false;
-                        }
-                        break;
-                    }
-                    case ParameterCondition.BITFIELD_ENUM: {
-                        if (((entry[condition.param] >> condition.offset) & ((1 << condition.size) - 1)) !== condition.value) {
-                            return false;
-                        }
-                        break;
-                    }
-                    case ParameterCondition.MINIMUM_REMAINING_BUFFER_BYTES: {
-                        if (remainingBufferBytes !== undefined && remainingBufferBytes < condition.value) {
-                            return false;
-                        }
-                        break;
-                    }
-                    case ParameterCondition.DATA_TYPE_CLASS_EQUAL: {
-                        if (Utils.getDataTypeClass(entry.dataType) !== condition.value) {
-                            return false;
-                        }
-                        break;
-                    }
-                    case ParameterCondition.FIELD_GT: {
-                        /*if (condition.reversed) {
-                            if (entry[condition.field] >= condition.value) {
-                                return false;
-                            }
-                        } else */
-                        if (entry[condition.field] <= condition.value) {
-                            return false;
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-
-        return true;
-    }
-
-    public isCluster(clusterName: FoundationCommandName | ClusterName): boolean {
-        return this.cluster.name === clusterName;
-    }
-
-    // List of commands is not completed, feel free to add more.
-    public isCommand(commandName: FoundationCommandName | "remove" | "add" | "write" | "enrollReq" | "checkin" | "getAlarm" | "arm"): boolean {
-        return this.command.name === commandName;
-    }
-}