@jakobgoerke/ac-infinity-client 0.2.1 → 0.3.0

package/build/src/types/Device.js

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.DeviceMode = exports.DeviceType = void 0;
+exports.DeviceSettingsChangesSchema = exports.DeviceModeSettingsChangesSchema = exports.DeviceModeSettingsSchema = exports.DeviceSettingsSchema = exports.TemperatureUnit = exports.DeviceMode = exports.DeviceType = void 0;
 exports.encodeDeviceModeSettings = encodeDeviceModeSettings;
+exports.encodeDeviceSettings = encodeDeviceSettings;
 const zod_1 = require("zod");
 var DeviceType;
 (function (DeviceType) {
+    DeviceType[DeviceType["NONE"] = 0] = "NONE";
     DeviceType[DeviceType["GROW_LIGHT"] = 1] = "GROW_LIGHT";
     DeviceType[DeviceType["HUMIDIFIER"] = 2] = "HUMIDIFIER";
     DeviceType[DeviceType["DEHUMIDIFIER"] = 3] = "DEHUMIDIFIER";
     DeviceType[DeviceType["HEATER"] = 4] = "HEATER";
     DeviceType[DeviceType["AIR_CONDITION"] = 5] = "AIR_CONDITION";
     DeviceType[DeviceType["FAN"] = 6] = "FAN";
+    DeviceType[DeviceType["PUMP"] = 8] = "PUMP";
+    DeviceType[DeviceType["WATER_PUMP"] = 9] = "WATER_PUMP";
+    DeviceType[DeviceType["CO2_GENERATOR"] = 10] = "CO2_GENERATOR";
+    DeviceType[DeviceType["WATER_COOLER"] = 13] = "WATER_COOLER";
+    DeviceType[DeviceType["WATER_HEATER"] = 14] = "WATER_HEATER";
 })(DeviceType || (exports.DeviceType = DeviceType = {}));
 var DeviceMode;
 (function (DeviceMode) {
@@ -23,6 +30,28 @@ var DeviceMode;
     DeviceMode[DeviceMode["SCHEDULE"] = 7] = "SCHEDULE";
     DeviceMode[DeviceMode["VPD"] = 8] = "VPD";
 })(DeviceMode || (exports.DeviceMode = DeviceMode = {}));
+var TemperatureUnit;
+(function (TemperatureUnit) {
+    TemperatureUnit[TemperatureUnit["FAHRENHEIT"] = 0] = "FAHRENHEIT";
+    TemperatureUnit[TemperatureUnit["CELSIUS"] = 1] = "CELSIUS";
+})(TemperatureUnit || (exports.TemperatureUnit = TemperatureUnit = {}));
+// the vendor uses this value for a schedule boundary that is not set
+const SCHEDULE_DISABLED = 65535;
+const celsiusToFahrenheit = (celsius) => Math.round((celsius * 9) / 5 + 32);
+const fahrenheitToCelsius = (fahrenheit) => Math.round(((fahrenheit - 32) * 5) / 9);
+const decodeScheduleTime = (minutes) => (minutes === SCHEDULE_DISABLED ? null : minutes);
+const encodeScheduleTime = (minutes) => (minutes === null ? SCHEDULE_DISABLED : minutes);
+const encodeFlag = (value) => (value === undefined ? undefined : Number(value));
+const encodeTemperature = (value) => {
+    if (value?.celsius !== undefined) {
+        return { celsius: value.celsius, fahrenheit: celsiusToFahrenheit(value.celsius) };
+    }
+    if (value?.fahrenheit !== undefined) {
+        return { celsius: fahrenheitToCelsius(value.fahrenheit), fahrenheit: value.fahrenheit };
+    }
+    return { celsius: undefined, fahrenheit: undefined };
+};
+const compact = (value) => Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
 const DeviceBaseInputSchema = zod_1.z.object({
     devId: zod_1.z.string(),
     devMacAddr: zod_1.z.string().nullable(),
@@ -59,7 +88,7 @@ exports.DeviceSettingsSchema = DeviceBaseInputSchema.extend({
     devCh: zod_1.z.number(),
     devTt: zod_1.z.number(),
     devTh: zod_1.z.number(),
-    devCompany: zod_1.z.number(),
+    devCompany: zod_1.z.enum(TemperatureUnit),
     devTth: zod_1.z.number(),
     vpdCth: zod_1.z.number(),
     vpdCt: zod_1.z.number(),
@@ -122,6 +151,30 @@ exports.DeviceSettingsSchema = DeviceBaseInputSchema.extend({
     matterSta: zod_1.z.unknown().nullable(),
 }).transform((v) => ({
     ...transformDeviceBase(v),
+    name: v.devName,
+    temperatureUnit: v.devCompany,
+    brightness: v.devLight,
+    backlight: v.backlightSwitch !== 0,
+    calibration: {
+        temperatureC: v.devCt,
+        temperatureF: v.devCth,
+        humidity: v.devCh,
+        leafTemperatureC: v.vpdCt,
+        leafTemperatureF: v.vpdCth,
+    },
+    transition: {
+        temperatureC: v.devTt,
+        temperatureF: v.devTth,
+        humidity: v.devTh,
+        vpd: v.vpdTransition,
+    },
+    buffer: {
+        enabled: v.isFlag !== 0,
+        temperatureC: v.devBt,
+        temperatureF: v.devBth,
+        humidity: v.devBh,
+        vpd: v.devBvpd,
+    },
 }));
 exports.DeviceModeSettingsSchema = DeviceBaseInputSchema.extend({
     acitveTimerOff: zod_1.z.number(),
@@ -178,9 +231,167 @@ exports.DeviceModeSettingsSchema = DeviceBaseInputSchema.extend({
     waterTempLowValueF: zod_1.z.number(),
 }).transform((v) => ({
     ...transformDeviceBase(v),
+    /** seconds left until the current timer, cycle or schedule step switches */
+    remainingTime: v.surplus,
+    /** durations in seconds */
+    timer: {
+        toOn: v.acitveTimerOn,
+        toOff: v.acitveTimerOff,
+    },
+    /** durations in seconds */
+    cycle: {
+        on: v.activeCycleOn,
+        off: v.activeCycleOff,
+    },
+    /** minutes after midnight, null when not set */
+    schedule: {
+        start: decodeScheduleTime(v.schedStartTime),
+        end: decodeScheduleTime(v.schedEndtTime),
+    },
+    auto: {
+        targetMode: v.settingMode !== 0,
+        highTemperature: { enabled: v.activeHt !== 0, celsius: v.devHt, fahrenheit: v.devHtf },
+        lowTemperature: { enabled: v.activeLt !== 0, celsius: v.devLt, fahrenheit: v.devLtf },
+        highHumidity: { enabled: v.activeHh !== 0, value: v.devHh },
+        lowHumidity: { enabled: v.activeLh !== 0, value: v.devLh },
+        targetTemperature: { enabled: v.targetTSwitch !== 0, celsius: v.targetTemp, fahrenheit: v.targetTempF },
+        targetHumidity: { enabled: v.targetHumiSwitch !== 0, value: v.targetHumi },
+    },
+    /** values in kPa */
+    vpd: {
+        targetMode: v.vpdSettingMode !== 0,
+        high: { enabled: v.activeHtVpd !== 0, value: v.activeHtVpdNums / 10 },
+        low: { enabled: v.activeLtVpd !== 0, value: v.activeLtVpdNums / 10 },
+        target: { enabled: v.targetVpdSwitch !== 0, value: v.targetVpd / 10 },
+    },
 }));
+const LevelSchema = zod_1.z.number().int().min(0).max(10);
+const DurationSchema = zod_1.z.number().int().nonnegative();
+const ScheduleTimeSchema = zod_1.z.number().int().min(0).max(1439).nullable();
+const TemperatureTriggerChangesSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    celsius: zod_1.z.number().int().min(0).max(90),
+    fahrenheit: zod_1.z.number().int().min(32).max(194),
+})
+    .partial()
+    .refine((v) => v.celsius === undefined || v.fahrenheit === undefined, { message: 'Provide either celsius or fahrenheit, not both' });
+const HumidityTriggerChangesSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    value: zod_1.z.number().int().min(0).max(100),
+})
+    .partial();
+const VpdTriggerChangesSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean(),
+    value: zod_1.z.number().min(0).max(9.9),
+})
+    .partial();
+exports.DeviceModeSettingsChangesSchema = zod_1.z
+    .object({
+    mode: zod_1.z.enum(DeviceMode),
+    levelWhileOn: LevelSchema,
+    levelWhileOff: LevelSchema,
+    timer: zod_1.z.object({ toOn: DurationSchema, toOff: DurationSchema }).partial(),
+    cycle: zod_1.z.object({ on: DurationSchema, off: DurationSchema }).partial(),
+    schedule: zod_1.z.object({ start: ScheduleTimeSchema, end: ScheduleTimeSchema }).partial(),
+    auto: zod_1.z
+        .object({
+        targetMode: zod_1.z.boolean(),
+        highTemperature: TemperatureTriggerChangesSchema,
+        lowTemperature: TemperatureTriggerChangesSchema,
+        highHumidity: HumidityTriggerChangesSchema,
+        lowHumidity: HumidityTriggerChangesSchema,
+        targetTemperature: TemperatureTriggerChangesSchema,
+        targetHumidity: HumidityTriggerChangesSchema,
+    })
+        .partial(),
+    vpd: zod_1.z
+        .object({
+        targetMode: zod_1.z.boolean(),
+        high: VpdTriggerChangesSchema,
+        low: VpdTriggerChangesSchema,
+        target: VpdTriggerChangesSchema,
+    })
+        .partial(),
+})
+    .partial()
+    .transform(({ mode, levelWhileOn, levelWhileOff, timer, cycle, schedule, auto, vpd }) => {
+    const highTemperature = encodeTemperature(auto?.highTemperature);
+    const lowTemperature = encodeTemperature(auto?.lowTemperature);
+    const targetTemperature = encodeTemperature(auto?.targetTemperature);
+    const encodeVpd = (value) => (value === undefined ? undefined : Math.round(value * 10));
+    return compact({
+        atType: mode,
+        onSpead: levelWhileOn,
+        offSpead: levelWhileOff,
+        acitveTimerOn: timer?.toOn,
+        acitveTimerOff: timer?.toOff,
+        activeCycleOn: cycle?.on,
+        activeCycleOff: cycle?.off,
+        schedStartTime: encodeScheduleTime(schedule?.start),
+        schedEndtTime: encodeScheduleTime(schedule?.end),
+        settingMode: encodeFlag(auto?.targetMode),
+        activeHt: encodeFlag(auto?.highTemperature?.enabled),
+        devHt: highTemperature.celsius,
+        devHtf: highTemperature.fahrenheit,
+        activeLt: encodeFlag(auto?.lowTemperature?.enabled),
+        devLt: lowTemperature.celsius,
+        devLtf: lowTemperature.fahrenheit,
+        activeHh: encodeFlag(auto?.highHumidity?.enabled),
+        devHh: auto?.highHumidity?.value,
+        activeLh: encodeFlag(auto?.lowHumidity?.enabled),
+        devLh: auto?.lowHumidity?.value,
+        targetTSwitch: encodeFlag(auto?.targetTemperature?.enabled),
+        targetTemp: targetTemperature.celsius,
+        targetTempF: targetTemperature.fahrenheit,
+        targetHumiSwitch: encodeFlag(auto?.targetHumidity?.enabled),
+        targetHumi: auto?.targetHumidity?.value,
+        vpdSettingMode: encodeFlag(vpd?.targetMode),
+        activeHtVpd: encodeFlag(vpd?.high?.enabled),
+        activeHtVpdNums: encodeVpd(vpd?.high?.value),
+        activeLtVpd: encodeFlag(vpd?.low?.enabled),
+        activeLtVpdNums: encodeVpd(vpd?.low?.value),
+        targetVpdSwitch: encodeFlag(vpd?.target?.enabled),
+        targetVpd: encodeVpd(vpd?.target?.value),
+    });
+});
+exports.DeviceSettingsChangesSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().min(1),
+    temperatureUnit: zod_1.z.enum(TemperatureUnit),
+    brightness: zod_1.z.number().int().nonnegative(),
+    backlight: zod_1.z.boolean(),
+    calibration: zod_1.z
+        .object({
+        temperatureC: zod_1.z.number().int(),
+        temperatureF: zod_1.z.number().int(),
+        humidity: zod_1.z.number().int(),
+    })
+        .partial()
+        .refine((v) => v.temperatureC === undefined || v.temperatureF === undefined, {
+        message: 'Provide either temperatureC or temperatureF, not both',
+    }),
+})
+    .partial()
+    .transform(({ name, temperatureUnit, brightness, backlight, calibration }) => {
+    // the fahrenheit calibration is kept at twice the celsius one
+    const calibrationC = calibration?.temperatureF !== undefined ? Math.trunc(calibration.temperatureF / 2) : calibration?.temperatureC;
+    const calibrationF = calibration?.temperatureC !== undefined ? calibration.temperatureC * 2 : calibration?.temperatureF;
+    return compact({
+        devName: name,
+        devCompany: temperatureUnit,
+        devLight: brightness,
+        backlightSwitch: encodeFlag(backlight),
+        devCt: calibrationC,
+        devCth: calibrationF,
+        devCh: calibration?.humidity,
+    });
+});
 function encodeDeviceModeSettings(settings) {
-    return {
-        onSpead: settings.levelWhileOn,
-    };
+    return exports.DeviceModeSettingsChangesSchema.parse(settings);
+}
+function encodeDeviceSettings(settings) {
+    return exports.DeviceSettingsChangesSchema.parse(settings);
 }

package/build/src/types/index.d.ts

@@ -1,7 +1,7 @@
-export type { Controller, ControllerDeviceInfo, ControllerPort } from './Controller';
-export { ControllerDeviceType, ControllerSchema } from './Controller';
-export type { DeviceModeSettings, DeviceModeSettingsInput, DeviceSettings } from './Device';
-export { DeviceMode, DeviceModeSettingsSchema, DeviceSettingsSchema, DeviceType, encodeDeviceModeSettings } from './Device';
+export type { Controller, ControllerDeviceInfo, ControllerPort, ControllerSensor } from './Controller';
+export { ControllerDeviceType, ControllerSchema, SensorType } from './Controller';
+export type { DeviceModeSettings, DeviceModeSettingsChanges, DeviceModeSettingsInput, DeviceSettings, DeviceSettingsChanges, DeviceSettingsInput, } from './Device';
+export { DeviceMode, DeviceModeSettingsChangesSchema, DeviceModeSettingsSchema, DeviceSettingsChangesSchema, DeviceSettingsSchema, DeviceType, encodeDeviceModeSettings, encodeDeviceSettings, TemperatureUnit, } from './Device';
 export type { User } from './User';
 export { UserSchema } from './User';
 //# sourceMappingURL=index.d.ts.map

package/build/src/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAC5H,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,oBAAoB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACvG,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClF,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,UAAU,EACV,+BAA+B,EAC/B,wBAAwB,EACxB,2BAA2B,EAC3B,oBAAoB,EACpB,UAAU,EACV,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,GAChB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/build/src/types/index.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserSchema = exports.encodeDeviceModeSettings = exports.DeviceType = exports.DeviceSettingsSchema = exports.DeviceModeSettingsSchema = exports.DeviceMode = exports.ControllerSchema = exports.ControllerDeviceType = void 0;
+exports.UserSchema = exports.TemperatureUnit = exports.encodeDeviceSettings = exports.encodeDeviceModeSettings = exports.DeviceType = exports.DeviceSettingsSchema = exports.DeviceSettingsChangesSchema = exports.DeviceModeSettingsSchema = exports.DeviceModeSettingsChangesSchema = exports.DeviceMode = exports.SensorType = exports.ControllerSchema = exports.ControllerDeviceType = void 0;
 var Controller_1 = require("./Controller");
 Object.defineProperty(exports, "ControllerDeviceType", { enumerable: true, get: function () { return Controller_1.ControllerDeviceType; } });
 Object.defineProperty(exports, "ControllerSchema", { enumerable: true, get: function () { return Controller_1.ControllerSchema; } });
+Object.defineProperty(exports, "SensorType", { enumerable: true, get: function () { return Controller_1.SensorType; } });
 var Device_1 = require("./Device");
 Object.defineProperty(exports, "DeviceMode", { enumerable: true, get: function () { return Device_1.DeviceMode; } });
+Object.defineProperty(exports, "DeviceModeSettingsChangesSchema", { enumerable: true, get: function () { return Device_1.DeviceModeSettingsChangesSchema; } });
 Object.defineProperty(exports, "DeviceModeSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceModeSettingsSchema; } });
+Object.defineProperty(exports, "DeviceSettingsChangesSchema", { enumerable: true, get: function () { return Device_1.DeviceSettingsChangesSchema; } });
 Object.defineProperty(exports, "DeviceSettingsSchema", { enumerable: true, get: function () { return Device_1.DeviceSettingsSchema; } });
 Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return Device_1.DeviceType; } });
 Object.defineProperty(exports, "encodeDeviceModeSettings", { enumerable: true, get: function () { return Device_1.encodeDeviceModeSettings; } });
+Object.defineProperty(exports, "encodeDeviceSettings", { enumerable: true, get: function () { return Device_1.encodeDeviceSettings; } });
+Object.defineProperty(exports, "TemperatureUnit", { enumerable: true, get: function () { return Device_1.TemperatureUnit; } });
 var User_1 = require("./User");
 Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return User_1.UserSchema; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jakobgoerke/ac-infinity-client",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "main": "./build/src",
   "types": "./build/src/index.d.ts",
   "repository": "git@github.com:jakobgoerke/ac-infinity-client.git",
@@ -11,20 +11,20 @@
     "build/src/**"
   ],
   "dependencies": {
-    "axios": "1.13.5",
-    "zod": "4.3.6"
+    "axios": "1.20.0",
+    "zod": "4.6.7"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.4",
-    "@jest/globals": "30.2.0",
-    "@tsconfig/node24": "24.0.4",
+    "@biomejs/biome": "2.6.2",
+    "@jest/globals": "30.5.2",
+    "@tsconfig/node24": "24.0.5",
     "@types/jest": "30.0.0",
-    "@types/node": "25.3.0",
-    "jest": "30.2.0",
+    "@types/node": "24.19.2",
+    "jest": "30.5.2",
     "rimraf": "6.1.3",
-    "ts-jest": "29.4.6",
+    "ts-jest": "29.4.15",
     "ts-node": "10.9.2",
-    "typescript": "5.9.3"
+    "typescript": "6.0.3"
   },
   "scripts": {
     "build": "rimraf build && tsc -p .",
@@ -33,5 +33,9 @@
     "coverage": "jest --coverage",
     "lint": "biome check"
   },
-  "packageManager": "yarn@4.12.0"
+  "packageManager": "yarn@4.12.0",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
 }