@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/daikin/daikin.mapper.ts

@@ -1,8 +1,8 @@
 import * as plugins from '../../plugins.js';
-import type { IIntegrationEntity, IServiceCallRequest, TEntityPlatform } from '../../core/types.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IServiceCallRequest, TEntityPlatform } from '../../core/types.js';
 import type {
-  IDaikinCommandRequest,
   IDaikinConfig,
+  IDaikinNativeConfig,
   IDaikinDeviceSnapshotInfo,
   IDaikinEnergySnapshot,
   IDaikinRawData,
@@ -10,11 +10,11 @@ import type {
   IDaikinValueMap,
   IDaikinZoneSnapshot,
   TDaikinApiVariant,
-  TDaikinHvacAction,
   TDaikinHvacMode,
   TDaikinPresetMode,
   TDaikinSnapshotSource,
 } from './daikin.types.js';
+import { daikinKeys, daikinObject } from './daikin.validation.js';
 import { daikinDefaultHttpPort, daikinDisplayName, daikinDomain, daikinSkyFiPort } from './daikin.types.js';
 
 interface IDaikinSnapshotOptions {
@@ -201,6 +201,61 @@ const sensorDefinitions: Array<{ key: string; name: string; unit?: string; devic
 ];
 
 export class DaikinMapper {
+  /** Maps only fields supplied by a fresh public-protocol observation. */
+  public static fromState(configArg: Readonly<IDaikinNativeConfig>, stateArg: plugins.ecobridgeDeviceManager.IDaikinState): IDaikinSnapshot {
+    return {
+      device: { id: stateArg.mac, homeId: configArg.homeId, name: configArg.name ?? `Daikin ${stateArg.mac}`,
+        manufacturer: 'Daikin', model: stateArg.model, firmware: stateArg.firmwareVersion,
+        host: configArg.host, port: configArg.port ?? 80, ssl: false, macAddress: this.normalizeMac(stateArg.mac), apiVariant: 'brp069' },
+      climate: { power: stateArg.power, hvacMode: stateArg.power ? stateArg.mode === 'fan' ? 'fan_only' : stateArg.mode : 'off',
+        hvacAction: stateArg.power ? 'unknown' : 'off', rawDaikinMode: stateArg.modeCode, rawPower: stateArg.power ? '1' : '0',
+        targetTemperature: stateArg.targetTemperatureCelsius,
+        targetHumidity: /^\d+$/.test(stateArg.targetHumidity) ? Number(stateArg.targetHumidity) : undefined,
+        fanMode: stateArg.fanRate, swingMode: stateArg.fanDirection, presetMode: 'none',
+        fanModes: [], swingModes: [], presetModes: [], temperatureUnit: 'C', targetTemperatureStep: 1 },
+      energy: {}, zones: [], capabilities: { localControl: stateArg.capabilities.power,
+        fanRate: stateArg.fanRate !== undefined, swingMode: stateArg.fanDirection !== undefined,
+        awayMode: false, advancedModes: false, streamer: false, outsideTemperature: false, humidity: false,
+        compressorFrequency: false, energyConsumption: false, zones: false, zoneTemperatureControl: false },
+      online: true, updatedAt: stateArg.observedAt, source: 'http', nativeState: stateArg,
+    };
+  }
+
+  public static controlForService(snapshotArg: IDaikinSnapshot, requestArg: IServiceCallRequest): plugins.ecobridgeDeviceManager.IDaikinControl | 'snapshot' {
+    const request = daikinObject(requestArg, 'Daikin service request');
+    daikinKeys(request, ['domain', 'service', 'target', 'data']);
+    const target = daikinObject(request.target, 'Daikin service target');
+    daikinKeys(target, ['entityId', 'deviceId']);
+    const data = request.data === undefined ? {} : daikinObject(request.data, 'Daikin service data');
+    const entities = this.toEntities(snapshotArg);
+    const selected = target.entityId === undefined ? undefined : entities.find((entityArg) => entityArg.id === target.entityId);
+    if ((!selected && target.entityId !== undefined) || (target.deviceId !== undefined && target.deviceId !== this.deviceId(snapshotArg))
+      || (target.entityId === undefined && target.deviceId === undefined)) throw new TypeError('Daikin service requires an exact owned entity or device target.');
+    if (request.domain === 'daikin' && request.service === 'refresh') { daikinKeys(data, []); return 'snapshot'; }
+    if (request.domain !== 'climate' && request.domain !== 'switch') throw new TypeError('Unsupported Daikin service domain.');
+    if (selected && (selected.platform !== request.domain || !['climate', 'power'].includes(String(selected.attributes?.key)))) throw new TypeError('Daikin service does not match the selected entity.');
+    if (request.service === 'turn_on' || request.service === 'turn_off') { daikinKeys(data, []); return { power: request.service === 'turn_on' }; }
+    if (request.domain === 'climate' && request.service === 'set_temperature') {
+      daikinKeys(data, ['temperature']);
+      if (typeof data.temperature !== 'number' || !Number.isSafeInteger(data.temperature)) throw new TypeError('Daikin target must be an explicit integer Celsius number.');
+      return { targetTemperatureCelsius: data.temperature };
+    }
+    throw new TypeError('Unsupported Daikin service.');
+  }
+
+  public static controlForFeature(snapshotArg: IDaikinSnapshot, requestArg: IDeviceFeatureWriteRequest): plugins.ecobridgeDeviceManager.IDaikinControl {
+    const request = daikinObject(requestArg, 'Daikin feature request');
+    daikinKeys(request, ['device', 'feature', 'value']);
+    const device = daikinObject(request.device, 'Daikin device target');
+    const feature = daikinObject(request.feature, 'Daikin feature target');
+    daikinKeys(feature, ['id', 'capability', 'name', 'readable', 'writable', 'unit']);
+    if (device.id !== this.deviceId(snapshotArg) || device.integrationDomain !== daikinDomain) throw new TypeError('Daikin feature requires an exact owned device.');
+    if (feature.id === 'power' && feature.capability === 'switch' && typeof request.value === 'boolean') return { power: request.value };
+    if (feature.id === 'target_temperature' && feature.capability === 'climate' && feature.unit === 'C'
+      && typeof request.value === 'number' && Number.isSafeInteger(request.value)) return { targetTemperatureCelsius: request.value };
+    throw new TypeError('Unsupported Daikin feature or nonexplicit value.');
+  }
+
   public static toSnapshot(optionsArg: IDaikinSnapshotOptions): IDaikinSnapshot {
     if (optionsArg.config.snapshot && !optionsArg.rawData) {
       return this.normalizeSnapshot(this.clone(optionsArg.config.snapshot), optionsArg.config, optionsArg.source || 'snapshot');
@@ -214,7 +269,7 @@ export class DaikinMapper {
     const climate = this.climate(values, variant);
     const energy = this.energy(values);
     const capabilities = {
-      localControl: Boolean(optionsArg.config.host || optionsArg.config.url || optionsArg.config.commandExecutor || optionsArg.config.client?.execute),
+      localControl: false,
       fanRate: values.f_rate !== undefined,
       swingMode: values.f_dir !== undefined || values.f_dir_ud !== undefined || values.f_dir_lr !== undefined,
       awayMode: values.en_hol !== undefined,
@@ -245,11 +300,13 @@ export class DaikinMapper {
   public static toDevices(snapshotArg: IDaikinSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
     const updatedAt = snapshotArg.updatedAt || new Date().toISOString();
     const features: plugins.shxInterfaces.data.IDeviceFeature[] = [
-      { id: 'power', capability: 'switch', name: 'Power', readable: true, writable: snapshotArg.capabilities.localControl },
-      { id: 'hvac_mode', capability: 'climate', name: 'HVAC mode', readable: true, writable: snapshotArg.capabilities.localControl },
-      { id: 'target_temperature', capability: 'climate', name: 'Target temperature', readable: true, writable: snapshotArg.capabilities.localControl, unit: 'C' },
-      { id: 'inside_temperature', capability: 'sensor', name: 'Inside temperature', readable: true, writable: false, unit: 'C' },
+      { id: 'power', capability: 'switch', name: 'Power', readable: true, writable: snapshotArg.nativeState?.capabilities.power === true },
+      { id: 'hvac_mode', capability: 'climate', name: 'HVAC mode', readable: true, writable: false },
+      { id: 'target_temperature', capability: 'climate', name: 'Target temperature', readable: true, writable: snapshotArg.nativeState?.capabilities.targetTemperature === true, unit: 'C' },
     ];
+    if (snapshotArg.climate.insideTemperature !== undefined) {
+      features.push({ id: 'inside_temperature', capability: 'sensor', name: 'Inside temperature', readable: true, writable: false, unit: 'C' });
+    }
     if (snapshotArg.capabilities.outsideTemperature) {
       features.push({ id: 'outside_temperature', capability: 'sensor', name: 'Outside temperature', readable: true, writable: false, unit: 'C' });
     }
@@ -257,24 +314,24 @@ export class DaikinMapper {
       features.push({ id: 'humidity', capability: 'sensor', name: 'Humidity', readable: true, writable: false, unit: '%' });
     }
     if (snapshotArg.capabilities.fanRate) {
-      features.push({ id: 'fan_mode', capability: 'fan', name: 'Fan mode', readable: true, writable: snapshotArg.capabilities.localControl });
+      features.push({ id: 'fan_mode', capability: 'fan', name: 'Fan mode', readable: true, writable: false });
     }
     if (snapshotArg.capabilities.swingMode) {
-      features.push({ id: 'swing_mode', capability: 'fan', name: 'Swing mode', readable: true, writable: snapshotArg.capabilities.localControl });
+      features.push({ id: 'swing_mode', capability: 'fan', name: 'Swing mode', readable: true, writable: false });
     }
     if (snapshotArg.capabilities.energyConsumption) {
       features.push({ id: 'energy_today', capability: 'sensor', name: 'Energy today', readable: true, writable: false, unit: 'kWh' });
     }
     for (const zone of snapshotArg.zones) {
-      features.push({ id: `zone_${zone.id}`, capability: 'switch', name: `${zone.name} zone`, readable: true, writable: snapshotArg.capabilities.localControl });
+      features.push({ id: `zone_${zone.id}`, capability: 'switch', name: `${zone.name} zone`, readable: true, writable: false });
     }
 
     const state: plugins.shxInterfaces.data.IDeviceState[] = [
       { featureId: 'power', value: snapshotArg.climate.power, updatedAt },
       { featureId: 'hvac_mode', value: snapshotArg.climate.hvacMode, updatedAt },
       { featureId: 'target_temperature', value: snapshotArg.climate.targetTemperature ?? null, updatedAt },
-      { featureId: 'inside_temperature', value: snapshotArg.climate.insideTemperature ?? null, updatedAt },
     ];
+    if (snapshotArg.climate.insideTemperature !== undefined) state.push({ featureId: 'inside_temperature', value: snapshotArg.climate.insideTemperature, updatedAt });
     if (snapshotArg.capabilities.outsideTemperature) {
       state.push({ featureId: 'outside_temperature', value: snapshotArg.climate.outsideTemperature ?? null, updatedAt });
     }
@@ -313,6 +370,7 @@ export class DaikinMapper {
         apiVariant: snapshotArg.device.apiVariant,
         source: snapshotArg.source,
         error: snapshotArg.error,
+        homeId: snapshotArg.device.homeId,
       }),
     }];
   }
@@ -332,7 +390,7 @@ export class DaikinMapper {
         currentTemperature: snapshotArg.climate.insideTemperature,
         targetTemperature: snapshotArg.climate.targetTemperature,
         hvacAction: snapshotArg.climate.hvacAction,
-        hvacModes: ['off', 'fan_only', 'dry', 'cool', 'heat', 'heat_cool'],
+        hvacModes: [],
         fanMode: snapshotArg.climate.fanMode,
         fanModes: snapshotArg.climate.fanModes,
         swingMode: snapshotArg.climate.swingMode,
@@ -410,83 +468,6 @@ export class DaikinMapper {
     return entities;
   }
 
-  public static commandForService(snapshotArg: IDaikinSnapshot, requestArg: IServiceCallRequest): IDaikinCommandRequest | undefined {
-    if (requestArg.domain === daikinDomain && requestArg.service === 'refresh') {
-      return { action: 'refresh', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-    }
-
-    if (requestArg.domain === 'climate') {
-      if (requestArg.service === 'turn_on') {
-        return this.controlCommand(snapshotArg, {}, requestArg);
-      }
-      if (requestArg.service === 'turn_off') {
-        return this.controlCommand(snapshotArg, { mode: 'off' }, requestArg);
-      }
-      if (requestArg.service === 'set_temperature') {
-        const temperature = this.numberValue(requestArg.data?.temperature);
-        if (temperature === undefined) {
-          return undefined;
-        }
-        const hvacMode = this.stringValue(requestArg.data?.hvac_mode ?? requestArg.data?.hvacMode);
-        return this.controlCommand(snapshotArg, {
-          stemp: this.formatTargetTemperature(temperature),
-          mode: hvacMode ? this.hvacToDaikinMode(hvacMode) : undefined,
-        }, requestArg);
-      }
-      if (requestArg.service === 'set_hvac_mode') {
-        const hvacMode = this.stringValue(requestArg.data?.hvac_mode ?? requestArg.data?.hvacMode);
-        return hvacMode ? this.controlCommand(snapshotArg, { mode: this.hvacToDaikinMode(hvacMode) }, requestArg) : undefined;
-      }
-      if (requestArg.service === 'set_fan_mode') {
-        const fanMode = this.stringValue(requestArg.data?.fan_mode ?? requestArg.data?.fanMode);
-        return fanMode ? this.controlCommand(snapshotArg, { f_rate: fanMode.toLowerCase() }, requestArg) : undefined;
-      }
-      if (requestArg.service === 'set_swing_mode') {
-        const swingMode = this.stringValue(requestArg.data?.swing_mode ?? requestArg.data?.swingMode);
-        return swingMode ? this.controlCommand(snapshotArg, { f_dir: swingMode.toLowerCase() }, requestArg) : undefined;
-      }
-      if (requestArg.service === 'set_preset_mode') {
-        return this.presetCommand(snapshotArg, this.stringValue(requestArg.data?.preset_mode ?? requestArg.data?.presetMode), requestArg);
-      }
-    }
-
-    if (requestArg.domain === 'switch') {
-      const enabled = requestArg.service === 'turn_on' ? true : requestArg.service === 'turn_off' ? false : undefined;
-      if (enabled === undefined) {
-        return undefined;
-      }
-      const target = `${requestArg.target.entityId || ''} ${requestArg.target.deviceId || ''}`.toLowerCase();
-      const zoneMatch = target.match(/(?:zone[_\-. ]?)(\d+)/);
-      if (zoneMatch) {
-        return { action: 'set_zone', protocol: snapshotArg.device.apiVariant, zoneId: Number(zoneMatch[1]), zoneKey: 'zone_onoff', zoneValue: enabled ? '1' : '0', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-      }
-      if (target.includes('streamer')) {
-        return { action: 'set_streamer', protocol: snapshotArg.device.apiVariant, enabled, mode: enabled ? 'on' : 'off', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-      }
-      return this.controlCommand(snapshotArg, { mode: enabled ? undefined : 'off' }, requestArg);
-    }
-
-    if (requestArg.domain === daikinDomain && requestArg.service === 'set_zone') {
-      const zoneId = this.numberValue(requestArg.data?.zone_id ?? requestArg.data?.zoneId);
-      const value = requestArg.data?.value ?? requestArg.data?.enabled ?? requestArg.data?.on;
-      if (zoneId === undefined) {
-        return undefined;
-      }
-      return {
-        action: 'set_zone',
-        protocol: snapshotArg.device.apiVariant,
-        zoneId,
-        zoneKey: this.stringValue(requestArg.data?.key) || 'zone_onoff',
-        zoneValue: typeof value === 'boolean' ? value ? '1' : '0' : String(value ?? '1'),
-        service: requestArg.service,
-        target: requestArg.target,
-        data: requestArg.data,
-      };
-    }
-
-    return undefined;
-  }
-
   public static deviceId(snapshotArg: IDaikinSnapshot): string {
     return `${daikinDomain}.ac.${this.uniqueBase(snapshotArg)}`;
   }
@@ -496,6 +477,7 @@ export class DaikinMapper {
   }
 
   public static uniqueBase(snapshotArg: IDaikinSnapshot): string {
+    if (snapshotArg.device.homeId !== undefined) return `${Buffer.from(snapshotArg.device.homeId, 'utf8').toString('base64url')}.${this.compactMac(snapshotArg.device.macAddress)}`;
     return this.slug(snapshotArg.device.macAddress || snapshotArg.device.id || snapshotArg.device.host || snapshotArg.device.name || daikinDomain);
   }
 
@@ -508,7 +490,7 @@ export class DaikinMapper {
       return undefined;
     }
     const compact = valueArg.replace(/[^a-fA-F0-9]/g, '').toLowerCase();
-    return compact.length === 12 ? compact.match(/.{1,2}/g)?.join(':') : valueArg.toLowerCase();
+    return compact.length === 12 && /^[a-fA-F0-9:.-]+$/.test(valueArg) ? compact.match(/.{1,2}/g)?.join(':') : undefined;
   }
 
   public static compactMac(valueArg?: string): string | undefined {
@@ -625,7 +607,8 @@ export class DaikinMapper {
       device: { ...derived.device, ...snapshotArg.device },
       climate: { ...derived.climate, ...snapshotArg.climate },
       energy: { ...derived.energy, ...snapshotArg.energy },
-      capabilities: { ...derived.capabilities, ...snapshotArg.capabilities },
+      capabilities: { ...derived.capabilities, ...snapshotArg.capabilities, localControl: false },
+      nativeState: undefined,
       zones: snapshotArg.zones?.length ? snapshotArg.zones : derived.zones,
       rawData: Object.keys(rawData).length ? rawData : snapshotArg.rawData,
       source: snapshotArg.source || sourceArg,
@@ -675,7 +658,7 @@ export class DaikinMapper {
     return {
       power: hvacMode !== 'off' && rawPower !== '0',
       hvacMode,
-      hvacAction: this.hvacAction(hvacMode, compressorFrequency),
+      hvacAction: hvacMode === 'off' ? 'off' : 'unknown',
       rawDaikinMode: daikinMode,
       rawPower,
       targetTemperature: this.numberValue(valuesArg.stemp),
@@ -763,7 +746,7 @@ export class DaikinMapper {
   private static entity(snapshotArg: IDaikinSnapshot, definitionArg: IDaikinEntityDefinition, deviceIdArg: string, uniqueBaseArg: string): IIntegrationEntity {
     const platform = definitionArg.platform || 'sensor';
     return {
-      id: `${platform}.${this.slug(definitionArg.name)}`,
+      id: snapshotArg.device.homeId === undefined ? `${platform}.${this.slug(definitionArg.name)}` : `${platform}.daikin.${uniqueBaseArg}.${definitionArg.key}`,
       uniqueId: `${daikinDomain}_${uniqueBaseArg}_${this.slug(definitionArg.key)}`,
       integrationDomain: daikinDomain,
       deviceId: deviceIdArg,
@@ -778,56 +761,19 @@ export class DaikinMapper {
         entityCategory: definitionArg.entityCategory,
         source: snapshotArg.source,
         error: snapshotArg.error,
+        homeId: snapshotArg.device.homeId,
         ...definitionArg.attributes,
       }),
       available: definitionArg.available ?? snapshotArg.online,
     };
   }
 
-  private static controlCommand(snapshotArg: IDaikinSnapshot, settingsArg: IDaikinCommandRequest['settings'], requestArg: IServiceCallRequest): IDaikinCommandRequest {
-    return { action: 'set_control', protocol: snapshotArg.device.apiVariant, settings: this.cleanAttributes(settingsArg || {}) as IDaikinCommandRequest['settings'], service: requestArg.service, target: requestArg.target, data: requestArg.data };
-  }
-
-  private static presetCommand(snapshotArg: IDaikinSnapshot, presetArg: string | undefined, requestArg: IServiceCallRequest): IDaikinCommandRequest | undefined {
-    if (!presetArg) {
-      return undefined;
-    }
-    const preset = presetArg.toLowerCase();
-    if (preset === 'away') {
-      return { action: 'set_holiday', protocol: snapshotArg.device.apiVariant, enabled: true, mode: 'on', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-    }
-    if (preset === 'boost') {
-      return { action: 'set_advanced_mode', protocol: snapshotArg.device.apiVariant, enabled: true, mode: 'powerful', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-    }
-    if (preset === 'eco') {
-      return { action: 'set_advanced_mode', protocol: snapshotArg.device.apiVariant, enabled: true, mode: 'econo', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-    }
-    if (preset === 'none') {
-      if (snapshotArg.climate.presetMode === 'away') {
-        return { action: 'set_holiday', protocol: snapshotArg.device.apiVariant, enabled: false, mode: 'off', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-      }
-      if (snapshotArg.climate.presetMode === 'boost') {
-        return { action: 'set_advanced_mode', protocol: snapshotArg.device.apiVariant, enabled: false, mode: 'powerful', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-      }
-      if (snapshotArg.climate.presetMode === 'eco') {
-        return { action: 'set_advanced_mode', protocol: snapshotArg.device.apiVariant, enabled: false, mode: 'econo', service: requestArg.service, target: requestArg.target, data: requestArg.data };
-      }
-    }
-    return undefined;
-  }
-
   private static supportedClimateFeatures(snapshotArg: IDaikinSnapshot): string[] {
-    const features = ['turn_on', 'turn_off', 'target_temperature'];
-    if (snapshotArg.capabilities.fanRate) {
-      features.push('fan_mode');
-    }
-    if (snapshotArg.capabilities.swingMode) {
-      features.push('swing_mode');
-    }
-    if (snapshotArg.capabilities.awayMode || snapshotArg.capabilities.advancedModes) {
-      features.push('preset_mode');
-    }
-    return features;
+    if (!snapshotArg.nativeState) return [];
+    return [
+      ...(snapshotArg.nativeState.capabilities.power ? ['turn_on', 'turn_off'] : []),
+      ...(snapshotArg.nativeState.capabilities.targetTemperature ? ['target_temperature'] : []),
+    ];
   }
 
   private static detectVariant(configArg: IDaikinConfig, rawDataArg: Partial<IDaikinRawData>, valuesArg: IDaikinValueMap): TDaikinApiVariant {
@@ -846,9 +792,6 @@ export class DaikinMapper {
     if (Object.keys(rawDataArg.resources || {}).some((keyArg) => keyArg.startsWith('skyfi/')) || valuesArg.lztemp_c !== undefined || valuesArg.zone_name !== undefined) {
       return 'airbase';
     }
-    if (configArg.apiKey) {
-      return 'brp072c';
-    }
     return 'brp069';
   }
 
@@ -869,28 +812,6 @@ export class DaikinMapper {
     return value || 'unknown';
   }
 
-  private static hvacAction(hvacModeArg: TDaikinHvacMode, compressorFrequencyArg?: number): TDaikinHvacAction {
-    if (hvacModeArg === 'off') {
-      return 'off';
-    }
-    if (compressorFrequencyArg === 0 && (hvacModeArg === 'cool' || hvacModeArg === 'heat')) {
-      return 'idle';
-    }
-    if (hvacModeArg === 'cool') {
-      return 'cooling';
-    }
-    if (hvacModeArg === 'heat') {
-      return 'heating';
-    }
-    if (hvacModeArg === 'dry') {
-      return 'drying';
-    }
-    if (hvacModeArg === 'fan_only') {
-      return 'fan';
-    }
-    return 'idle';
-  }
-
   private static presetMode(valuesArg: IDaikinValueMap, variantArg: TDaikinApiVariant): TDaikinPresetMode {
     if (this.daikinToHuman('en_hol', valuesArg.en_hol, variantArg) === 'on') {
       return 'away';
@@ -1025,10 +946,6 @@ export class DaikinMapper {
     return undefined;
   }
 
-  private static stringValue(valueArg: unknown): string | undefined {
-    return typeof valueArg === 'string' && valueArg.trim() ? valueArg.trim() : undefined;
-  }
-
   private static title(valueArg: string | undefined): string | undefined {
     if (!valueArg) {
       return undefined;

package/ts/integrations/daikin/daikin.types.ts

@@ -1,3 +1,5 @@
+import type * as plugins from '../../plugins.js';
+
 export const daikinDomain = 'daikin';
 export const daikinDisplayName = 'Daikin AC';
 export const daikinDefaultHttpPort = 80;
@@ -10,11 +12,10 @@ export const daikinUdpDiscoveryMessage = 'DAIKIN_UDP/common/basic_info';
 export const daikinZeroconfType = '_dkapi._tcp.local.';
 
 export type TDaikinApiVariant = 'auto' | 'brp069' | 'brp072c' | 'airbase' | 'skyfi' | 'brp084';
-export type TDaikinSnapshotSource = 'http' | 'client' | 'manual' | 'snapshot' | 'runtime' | 'executor';
+export type TDaikinSnapshotSource = 'http' | 'manual' | 'snapshot' | 'runtime';
 export type TDaikinHvacMode = 'off' | 'fan_only' | 'dry' | 'cool' | 'heat' | 'heat_cool' | 'auto' | 'unknown' | string;
 export type TDaikinHvacAction = 'off' | 'idle' | 'cooling' | 'heating' | 'drying' | 'fan' | 'unknown';
 export type TDaikinPresetMode = 'none' | 'away' | 'boost' | 'eco' | string;
-export type TDaikinCommandAction = 'refresh' | 'set_control' | 'set_holiday' | 'set_advanced_mode' | 'set_streamer' | 'set_zone';
 
 export interface IDaikinValueMap {
   [key: string]: string | undefined;
@@ -52,6 +53,7 @@ export interface IDaikinDeviceSnapshotInfo {
   ssl?: boolean;
   macAddress?: string;
   apiVariant: TDaikinApiVariant;
+  homeId?: string;
 }
 
 export interface IDaikinClimateSnapshot {
@@ -121,58 +123,18 @@ export interface IDaikinSnapshot {
   updatedAt: string;
   source: TDaikinSnapshotSource;
   error?: string;
+  /** Present only for a current observation from the public selected BRP069 protocol. */
+  nativeState?: plugins.ecobridgeDeviceManager.IDaikinState;
 }
 
-export interface IDaikinControlSettings {
-  mode?: string;
-  pow?: string;
-  stemp?: string | number;
-  shum?: string | number;
-  f_rate?: string;
-  f_dir?: string;
-}
-
-export interface IDaikinCommandRequest {
-  action: TDaikinCommandAction;
-  method?: 'GET' | 'POST';
-  path?: string;
-  query?: Record<string, string | number | boolean | undefined>;
-  protocol?: TDaikinApiVariant | 'legacy';
-  settings?: Partial<IDaikinControlSettings>;
-  mode?: string;
-  enabled?: boolean;
-  zoneId?: number;
-  zoneKey?: string;
-  zoneValue?: string;
-  service?: string;
-  target?: Record<string, unknown>;
-  data?: Record<string, unknown>;
-}
-
-export interface IDaikinCommandExecutor {
-  execute(requestArg: IDaikinCommandRequest): Promise<unknown>;
-}
-
-export interface IDaikinClientLike {
-  getSnapshot?: () => Promise<IDaikinSnapshot | Partial<IDaikinRawData>>;
-  getRawData?: () => Promise<Partial<IDaikinRawData>>;
-  getResource?: (pathArg: string, queryArg?: Record<string, string | number | boolean | undefined>) => Promise<IDaikinValueMap>;
-  execute?: (requestArg: IDaikinCommandRequest) => Promise<unknown>;
-  destroy?: () => Promise<void>;
-}
-
+/** Offline mapper input; this shape cannot authorize native setup or effects. */
 export interface IDaikinConfig {
   host?: string;
   url?: string;
   port?: number;
   ssl?: boolean;
   tls?: boolean;
-  verifySsl?: boolean;
-  apiKey?: string;
-  uuid?: string;
-  password?: string;
   apiVariant?: TDaikinApiVariant;
-  timeoutMs?: number;
   name?: string;
   manufacturer?: string;
   model?: string;
@@ -181,12 +143,10 @@ export interface IDaikinConfig {
   snapshot?: IDaikinSnapshot;
   rawData?: Partial<IDaikinRawData>;
   values?: IDaikinValueMap;
-  client?: IDaikinClientLike;
-  commandExecutor?: IDaikinCommandExecutor;
   online?: boolean;
 }
 
-export interface IHomeAssistantDaikinConfig extends IDaikinConfig {}
+export interface IHomeAssistantDaikinConfig extends IDaikinNativeConfig {}
 
 export interface IDaikinManualEntry extends IDaikinConfig {
   id?: string;
@@ -239,3 +199,22 @@ export interface IDaikinRefreshResult {
   error?: string;
   data?: unknown;
 }
+
+/** Live setup is an explicit selected, unauthenticated BRP069 LAN connection. */
+export interface IDaikinIntegrationOptions {
+  readonly homeId?: string;
+  readonly capacity?: number;
+}
+
+export interface IDaikinNativeConfig {
+  homeId: string;
+  apiVariant: 'brp069';
+  host: string;
+  expectedMac: string;
+  allowPlaintext: true;
+  name?: string;
+  port?: number;
+  timeoutMs?: number;
+  maxResponseBytes?: number;
+  maxPendingOperations?: number;
+}

package/ts/integrations/daikin/daikin.validation.ts

@@ -0,0 +1,51 @@
+import type { IDaikinNativeConfig } from './daikin.types.js';
+
+export const daikinObject = (valueArg: unknown, nameArg: string): Record<string, unknown> => {
+  if (!valueArg || typeof valueArg !== 'object' || Object.getPrototypeOf(valueArg) !== Object.prototype) {
+    throw new TypeError(`${nameArg} must be a plain object.`);
+  }
+  const result: Record<string, unknown> = {};
+  for (const key of Reflect.ownKeys(valueArg)) {
+    const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+    if (typeof key !== 'string' || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+      throw new TypeError(`${nameArg} accepts only enumerable own data fields.`);
+    }
+    Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+  }
+  return result;
+};
+
+export const daikinKeys = (valueArg: Record<string, unknown>, allowedArg: readonly string[]): void => {
+  if (Object.keys(valueArg).some((keyArg) => !allowedArg.includes(keyArg))) throw new TypeError('Daikin arguments contain unsupported fields.');
+};
+
+const text = (valueArg: unknown, nameArg: string, maximumArg: number): string => {
+  if (typeof valueArg !== 'string' || valueArg.length === 0 || valueArg.length > maximumArg || /[\p{Cc}\p{Cs}]/u.test(valueArg)) {
+    throw new TypeError(`${nameArg} must be a nonempty bounded string without control characters.`);
+  }
+  return valueArg;
+};
+
+const optionalNumber = (valueArg: unknown, nameArg: string): number | undefined => {
+  if (valueArg === undefined) return undefined;
+  if (typeof valueArg !== 'number') throw new TypeError(`${nameArg} must be a number.`);
+  return valueArg;
+};
+
+/** Device address, MAC and protocol limits are validated by the public DaikinProtocol. */
+export const normalizeDaikinConfig = (valueArg: IDaikinNativeConfig): Readonly<IDaikinNativeConfig> => {
+  const value = daikinObject(valueArg, 'Daikin configuration');
+  daikinKeys(value, ['homeId', 'apiVariant', 'host', 'expectedMac', 'allowPlaintext', 'name', 'port', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']);
+  if (value.apiVariant !== 'brp069') throw new TypeError('Daikin live control requires the explicitly selected brp069 family.');
+  if (value.allowPlaintext !== true) throw new TypeError('Daikin BRP069 requires explicit allowPlaintext: true for unauthenticated LAN HTTP.');
+  const result: IDaikinNativeConfig = {
+    allowPlaintext: true, homeId: text(value.homeId, 'Daikin home ID', 256), apiVariant: 'brp069',
+    host: text(value.host, 'Daikin selected IPv4', 64), expectedMac: text(value.expectedMac, 'Daikin expected adapter MAC', 12).toUpperCase(),
+  };
+  if (value.name !== undefined) result.name = text(value.name, 'Daikin name', 256);
+  for (const key of ['port', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations'] as const) {
+    const number = optionalNumber(value[key], `Daikin ${key}`);
+    if (number !== undefined) result[key] = number;
+  }
+  return Object.freeze(result);
+};