@smarthome.exchange/integrations 1.0.0 → 3.0.0

package/dist_ts/integrations/modbus/modbus.discovery.js

@@ -1,108 +1,53 @@
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
-const modbusDomain = 'modbus';
-const defaultModbusTcpPort = 502;
+import { modbusAddress, modbusIdentityText, modbusInteger, modbusRecord, modbusText, modbusUnit } from './modbus.validation.js';
 export class ModbusManualTcpMatcher {
     id = 'modbus-manual-tcp-match';
     source = 'manual';
-    description = 'Recognize manual Modbus TCP setup entries without probing serial ports.';
+    description = 'Accept explicit Modbus endpoint and family identity selections without network probes.';
     async matches(inputArg, contextArg) {
-        void contextArg;
-        if (inputArg.type === 'serial' || this.looksLikeSerialPort(inputArg.host) || this.looksLikeSerialPort(String(inputArg.port || ''))) {
-            return {
-                matched: false,
-                confidence: 'low',
-                reason: 'Serial RTU setup is not auto-discovered by this integration.',
-            };
+        contextArg.abortSignal?.throwIfAborted();
+        try {
+            const input = modbusRecord(inputArg, ['integrationDomain', 'address', 'port', 'unitId', 'expectedVendorName', 'expectedProductCode', 'expectedRevision', 'name']);
+            if (input.integrationDomain !== 'modbus')
+                throw new TypeError('Manual Modbus selection requires the exact integration domain.');
+            const address = modbusAddress(input.address);
+            const port = modbusInteger(input.port === undefined ? 502 : input.port, 1, 65535);
+            const unitId = modbusUnit(input.unitId);
+            const expectedVendorName = modbusIdentityText(input.expectedVendorName);
+            const expectedProductCode = modbusIdentityText(input.expectedProductCode);
+            const expectedRevision = input.expectedRevision === undefined ? undefined : modbusIdentityText(input.expectedRevision);
+            const id = `modbus:${address}:${port}:${unitId}`;
+            return { matched: true, confidence: 'low', reason: 'Explicit manual selection is structurally valid; no network identity verification has occurred.',
+                normalizedDeviceId: id, candidate: { source: 'manual', integrationDomain: 'modbus', id, host: address, port,
+                    ...(input.name === undefined ? {} : { name: modbusText(input.name, 'name', 128) }),
+                    metadata: { unitId, expectedVendorName, expectedProductCode, ...(expectedRevision === undefined ? {} : { expectedRevision }) } } };
         }
-        const haystack = `${inputArg.name || ''} ${inputArg.protocol || ''} ${inputArg.manufacturer || ''} ${inputArg.model || ''}`.toLowerCase();
-        const hasModbusHint = inputArg.type === 'tcp' || haystack.includes('modbus') || Boolean(inputArg.metadata?.modbus || inputArg.metadata?.modbusTcp);
-        const matched = Boolean(inputArg.host && (hasModbusHint || inputArg.port === defaultModbusTcpPort));
-        if (!matched) {
-            return {
-                matched: false,
-                confidence: 'low',
-                reason: 'Manual entry does not contain a Modbus TCP host or hint.',
-            };
+        catch (errorArg) {
+            return { matched: false, confidence: 'low', reason: errorArg instanceof Error ? errorArg.message : 'Invalid explicit Modbus selection.' };
         }
-        const id = this.normalizedId(inputArg);
-        return {
-            matched: true,
-            confidence: hasModbusHint ? 'high' : 'medium',
-            reason: 'Manual entry can be configured as a Modbus TCP hub.',
-            normalizedDeviceId: id,
-            candidate: {
-                source: 'manual',
-                integrationDomain: modbusDomain,
-                id,
-                host: inputArg.host,
-                port: inputArg.port || defaultModbusTcpPort,
-                name: inputArg.name,
-                manufacturer: inputArg.manufacturer || 'Modbus',
-                model: inputArg.model || 'TCP hub',
-                serialNumber: inputArg.serialNumber,
-                metadata: {
-                    ...inputArg.metadata,
-                    type: 'tcp',
-                    unitId: inputArg.unitId || inputArg.slave || 1,
-                },
-            },
-        };
-    }
-    normalizedId(inputArg) {
-        return slug(inputArg.id || inputArg.serialNumber || `${inputArg.host || 'modbus'}_${inputArg.port || defaultModbusTcpPort}`);
-    }
-    looksLikeSerialPort(valueArg) {
-        return Boolean(valueArg && (/^\/dev\//.test(valueArg) || /^com\d+$/i.test(valueArg)));
     }
 }
 export class ModbusCandidateValidator {
     id = 'modbus-candidate-validator';
-    description = 'Validate that a candidate has enough Modbus TCP information for setup.';
+    description = 'Validate explicit manual selections; live admission belongs to the config flow.';
     async validate(candidateArg, contextArg) {
-        void contextArg;
-        const type = String(candidateArg.metadata?.type || '').toLowerCase();
-        if (type === 'serial' || this.looksLikeSerialPort(candidateArg.host)) {
-            return {
-                matched: false,
-                confidence: 'low',
-                reason: 'Serial RTU candidates require explicit serial configuration and are not probed.',
-            };
+        contextArg.abortSignal?.throwIfAborted();
+        try {
+            const candidate = modbusRecord(candidateArg);
+            if (candidate.source !== 'manual' || candidate.integrationDomain !== 'modbus')
+                throw new TypeError('Modbus accepts explicit manual candidates only.');
+            const metadata = modbusRecord(candidate.metadata, ['unitId', 'expectedVendorName', 'expectedProductCode', 'expectedRevision']);
+            return new ModbusManualTcpMatcher().matches({ integrationDomain: 'modbus', address: modbusAddress(candidate.host),
+                port: candidate.port === undefined ? undefined : modbusInteger(candidate.port, 1, 65535), unitId: modbusUnit(metadata.unitId),
+                expectedVendorName: modbusIdentityText(metadata.expectedVendorName), expectedProductCode: modbusIdentityText(metadata.expectedProductCode),
+                ...(metadata.expectedRevision === undefined ? {} : { expectedRevision: modbusIdentityText(metadata.expectedRevision) }),
+                ...(candidate.name === undefined ? {} : { name: modbusText(candidate.name, 'name', 128) }) }, contextArg);
+        }
+        catch (errorArg) {
+            return { matched: false, confidence: 'low', reason: errorArg instanceof Error ? errorArg.message : 'Invalid explicit Modbus candidate.' };
         }
-        const haystack = `${candidateArg.name || ''} ${candidateArg.model || ''} ${candidateArg.manufacturer || ''}`.toLowerCase();
-        const matched = Boolean(candidateArg.host && (candidateArg.integrationDomain === modbusDomain
-            || candidateArg.port === defaultModbusTcpPort
-            || type === 'tcp'
-            || haystack.includes('modbus')
-            || candidateArg.metadata?.modbus
-            || candidateArg.metadata?.modbusTcp));
-        const id = slug(candidateArg.id || candidateArg.serialNumber || `${candidateArg.host || 'modbus'}_${candidateArg.port || defaultModbusTcpPort}`);
-        return {
-            matched,
-            confidence: matched && candidateArg.integrationDomain === modbusDomain ? 'high' : matched ? 'medium' : 'low',
-            reason: matched ? 'Candidate has Modbus TCP setup data.' : 'Candidate is not a Modbus TCP hub.',
-            normalizedDeviceId: matched ? id : undefined,
-            candidate: matched ? {
-                ...candidateArg,
-                integrationDomain: modbusDomain,
-                id,
-                port: candidateArg.port || defaultModbusTcpPort,
-                manufacturer: candidateArg.manufacturer || 'Modbus',
-                model: candidateArg.model || 'TCP hub',
-                metadata: {
-                    ...candidateArg.metadata,
-                    type: 'tcp',
-                },
-            } : undefined,
-        };
-    }
-    looksLikeSerialPort(valueArg) {
-        return Boolean(valueArg && (/^\/dev\//.test(valueArg) || /^com\d+$/i.test(valueArg)));
     }
 }
-export const createModbusDiscoveryDescriptor = () => {
-    return new DiscoveryDescriptor({ integrationDomain: modbusDomain, displayName: 'Modbus' })
-        .addMatcher(new ModbusManualTcpMatcher())
-        .addValidator(new ModbusCandidateValidator());
-};
-const slug = (valueArg) => valueArg.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || modbusDomain;
-//# sourceMappingURL=data:application/json;base64,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
+export const createModbusDiscoveryDescriptor = () => new DiscoveryDescriptor({ integrationDomain: 'modbus', displayName: 'Modbus' })
+    .addMatcher(new ModbusManualTcpMatcher()).addValidator(new ModbusCandidateValidator());
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/modbus/modbus.mapper.d.ts

@@ -1,36 +1,12 @@
-import * as plugins from '../../plugins.js';
-import type { IIntegrationEntity, IIntegrationEvent, IServiceCallRequest } from '../../core/types.js';
-import type { IModbusCommand, IModbusEvent, IModbusHubSnapshot, IModbusRegisterState, IModbusSnapshot, TModbusDataType } from './modbus.types.js';
+import type * as plugins from '../../plugins.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IServiceCallRequest } from '../../core/types.js';
+import type { IModbusNormalizedConfig, IModbusSnapshot, TModbusCommand } from './modbus.types.js';
 export declare class ModbusMapper {
+    static deviceId(configArg: IModbusNormalizedConfig): string;
+    static entityId(configArg: IModbusNormalizedConfig, mappingIdArg: string): string;
     static toDevices(snapshotArg: IModbusSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
     static toEntities(snapshotArg: IModbusSnapshot): IIntegrationEntity[];
-    static commandForService(snapshotArg: IModbusSnapshot, requestArg: IServiceCallRequest): IModbusCommand | undefined;
-    static toIntegrationEvent(eventArg: IModbusEvent): IIntegrationEvent;
-    static hubDeviceId(hubArg: Pick<IModbusHubSnapshot, 'id'>): string;
-    static slaveDeviceId(hubArg: Pick<IModbusHubSnapshot, 'id'>, unitIdArg: number): string;
-    static decodeRegisterValue(registerArg: IModbusRegisterState): number | string | number[] | null;
-    static registerCountForDataType(dataTypeArg: TModbusDataType | undefined): number;
-    private static toEntity;
-    private static entityState;
-    private static coilBoolean;
-    private static uniqueEntityId;
-    private static findEntity;
-    private static commandTarget;
-    private static addressValue;
-    private static registerType;
-    private static coilType;
-    private static dataType;
-    private static numberData;
-    private static attributeNumber;
-    private static toNumber;
-    private static stringData;
-    private static numberOrArrayData;
-    private static boolOrArrayData;
-    private static toBooleanOrNumber;
-    private static normalizedDataType;
-    private static decodeFloat16;
-    private static processNumericValue;
-    private static toNumberValue;
-    private static cleanAttributes;
-    private static slug;
+    static commandForService(configArg: IModbusNormalizedConfig, requestArg: IServiceCallRequest): TModbusCommand;
+    static commandForFeature(configArg: IModbusNormalizedConfig, requestArg: IDeviceFeatureWriteRequest): TModbusCommand;
+    private static writable;
 }