flaks-node-hon 1.0.0

package/src/parameters.js

@@ -0,0 +1,261 @@
+function strToFloat(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const text = String(value).replace(",", ".");
+  const number = Number(text);
+  if (!Number.isFinite(number)) {
+    throw new ValueError(`Invalid number: ${value}`);
+  }
+  return Number.isInteger(number) ? Number.parseInt(text, 10) : number;
+}
+
+function cleanValue(value) {
+  return String(value).trim().replace(/^\[/, "").replace(/\]$/, "").replaceAll("|", "_").toLowerCase();
+}
+
+class ValueError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValueError";
+  }
+}
+
+class HonParameter {
+  /**
+   * @param {string} key
+   * @param {Record<string, any>} [attributes]
+   * @param {string} [group]
+   */
+  constructor(key, attributes = {}, group = "") {
+    this.key = key;
+    this.attributes = attributes;
+    this.group = group;
+    this.triggers = new Map();
+    this._values = [];
+    this.min = 0;
+    this.max = 0;
+    this.step = 1;
+    this.reset();
+  }
+
+  reset() {
+    this.category = this.attributes.category || "";
+    this.typology = this.attributes.typology || "";
+    this.mandatory = this.attributes.mandatory || 0;
+    this._value = "";
+  }
+
+  get value() {
+    return this._value == null ? "0" : this._value;
+  }
+
+  set value(value) {
+    this._value = value;
+    this.checkTrigger(value);
+  }
+
+  get internValue() {
+    return String(this.value);
+  }
+
+  get values() {
+    return [String(this.value)];
+  }
+
+  set values(values) {
+    this._values = values;
+  }
+
+  addTrigger(value, func, data) {
+    const key = String(value).toLowerCase();
+    if (String(this._value).toLowerCase() === key) {
+      func(data);
+    }
+    if (!this.triggers.has(key)) {
+      this.triggers.set(key, []);
+    }
+    const triggers = this.triggers.get(key);
+    if (triggers) {
+      triggers.push([func, data]);
+    }
+  }
+
+  checkTrigger(value) {
+    const rules = this.triggers.get(String(value).toLowerCase()) || [];
+    for (const [func, data] of rules) {
+      func(data);
+    }
+  }
+}
+
+class HonParameterEnum extends HonParameter {
+  reset() {
+    super.reset();
+    this.defaultValue = this.attributes.defaultValue || "";
+    this._value = this.defaultValue || "0";
+    this._values = this.attributes.enumValues || [];
+    if (this.defaultValue && !this.values.includes(cleanValue(String(this.defaultValue).replace(/^\[/, "").replace(/\]$/, "")))) {
+      this._values.push(this.defaultValue);
+    }
+  }
+
+  get values() {
+    return this._values.map(cleanValue);
+  }
+
+  set values(values) {
+    this._values = values;
+  }
+
+  get internValue() {
+    const fallback = this.values[0] ?? "0";
+    return this._value == null ? String(fallback) : String(this._value);
+  }
+
+  get value() {
+    const fallback = this.values[0] ?? "0";
+    return this._value == null ? fallback : cleanValue(this._value);
+  }
+
+  set value(value) {
+    const cleaned = cleanValue(value);
+    if (this.values.includes(cleaned)) {
+      this._value = value;
+      this.checkTrigger(value);
+      return;
+    }
+    throw new ValueError(`Allowed values: ${this.values.join(", ")}. But was: ${value}`);
+  }
+}
+
+class HonParameterRange extends HonParameter {
+  reset() {
+    super.reset();
+    this.min = strToFloat(this.attributes.minimumValue || 0);
+    this.max = strToFloat(this.attributes.maximumValue || 0);
+    this.step = strToFloat(this.attributes.incrementValue || 0) || 1;
+    this.defaultValue = strToFloat(this.attributes.defaultValue ?? this.min);
+    this._value = this.defaultValue;
+  }
+
+  get value() {
+    return this._value == null ? this.min : this._value;
+  }
+
+  set value(value) {
+    const number = strToFloat(value);
+    const scaled = (number - this.min) * 100;
+    const step = this.step * 100;
+    if (this.min <= number && number <= this.max && Math.abs(scaled % step) < 1e-9) {
+      this._value = number;
+      this.checkTrigger(number);
+      return;
+    }
+    throw new ValueError(`Allowed: min ${this.min} max ${this.max} step ${this.step}. But was: ${value}`);
+  }
+
+  get values() {
+    const result = [];
+    for (let value = this.min; value <= this.max; value += this.step) {
+      result.push(String(value));
+    }
+    return result;
+  }
+}
+
+class HonParameterFixed extends HonParameter {
+  reset() {
+    super.reset();
+    this._value = this.attributes.fixedValue || "";
+  }
+
+  get value() {
+    return this._value !== "" ? this._value : "0";
+  }
+
+  set value(value) {
+    this._value = value;
+    this.checkTrigger(value);
+  }
+}
+
+class HonParameterProgram extends HonParameterEnum {
+  /**
+   * @param {string} key
+   * @param {any} command
+   * @param {string} group
+   */
+  constructor(key, command, group) {
+    super(key, {}, group);
+    this.command = command;
+    this._value = command.categoryName.includes("PROGRAM") ? command.categoryName.split(".").pop().toLowerCase() : command.categoryName;
+    this.programs = command.categories;
+    this.typology = "enum";
+  }
+
+  get value() {
+    return this._value;
+  }
+
+  set value(value) {
+    if (!this.values.includes(value)) {
+      throw new ValueError(`Allowed values: ${this.values.join(", ")}. But was: ${value}`);
+    }
+    this.command.category = value;
+  }
+
+  get values() {
+    return Object.keys(this.programs || {})
+      .filter((value) => !value.includes("iot_recipe") && !value.includes("iot_guided"))
+      .sort();
+  }
+
+  set values(_values) {
+    throw new ValueError("Cannot set program values");
+  }
+
+  get ids() {
+    const values = {};
+    for (const [name, command] of Object.entries(this.programs || {})) {
+      const commandData = /** @type {any} */ (command);
+      if (name.includes("iot_") || !commandData.parameters.prCode) {
+        continue;
+      }
+      if (commandData.parameters.favourite && commandData.parameters.favourite.value === "1") {
+        continue;
+      }
+      values[Number(commandData.parameters.prCode.value)] = name;
+    }
+    return values;
+  }
+
+  setValue(value) {
+    this._value = value;
+  }
+}
+
+function createParameter(name, data, group) {
+  switch (data.typology) {
+    case "range":
+      return new HonParameterRange(name, data, group);
+    case "enum":
+      return new HonParameterEnum(name, data, group);
+    case "fixed":
+      return new HonParameterFixed(name, data, group);
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  HonParameter,
+  HonParameterEnum,
+  HonParameterRange,
+  HonParameterFixed,
+  HonParameterProgram,
+  ValueError,
+  cleanValue,
+  strToFloat,
+  createParameter
+};

package/src/preset-generator.js

@@ -0,0 +1,171 @@
+"use strict";
+
+const fs = require("node:fs");
+
+const BASIC_FIELDS = ["tempSel", "windSpeed", "windDirectionVertical", "windDirectionHorizontal"];
+const PRESET_COMMAND_ORDER = ["startProgram", "settings"];
+
+class PresetGeneratorError extends Error {
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "PresetGeneratorError";
+    this.details = details;
+  }
+}
+
+function loadCapabilitiesFile(filePath) {
+  const text = fs.readFileSync(filePath, "utf8");
+  return validateCapabilities(JSON.parse(text));
+}
+
+function validateCapabilities(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new PresetGeneratorError("Capabilities file must contain a JSON object");
+  }
+  for (const [deviceName, commands] of Object.entries(data)) {
+    if (!commands || typeof commands !== "object" || Array.isArray(commands)) {
+      throw new PresetGeneratorError(`Capabilities for ${deviceName} must be an object`);
+    }
+  }
+  return data;
+}
+
+function listAirConditioners(capabilities) {
+  return Object.keys(validateCapabilities(capabilities)).sort();
+}
+
+function selectAirConditioner(capabilities, acId = "") {
+  const names = listAirConditioners(capabilities);
+  if (!names.length) {
+    throw new PresetGeneratorError("No air conditioners found in capabilities file");
+  }
+  if (!acId) {
+    return { name: names[0], capabilities: capabilities[names[0]] };
+  }
+  const matches = names.filter((name) => name === acId || name.endsWith(`_${acId}`) || name.includes(acId));
+  if (matches.length === 1) {
+    return { name: matches[0], capabilities: capabilities[matches[0]] };
+  }
+  if (matches.length > 1) {
+    throw new PresetGeneratorError(`AC_ID matched multiple capability entries: ${acId}`, { matches });
+  }
+  throw new PresetGeneratorError(`AC_ID did not match any capability entry: ${acId}`, { available: names });
+}
+
+function selectPresetCommand(deviceCapabilities) {
+  const orderedNames = [
+    ...PRESET_COMMAND_ORDER,
+    ...Object.keys(deviceCapabilities).filter((name) => !PRESET_COMMAND_ORDER.includes(name))
+  ];
+  for (const name of orderedNames) {
+    const command = deviceCapabilities[name];
+    if (isCommandCapability(command)) {
+      return { name, command };
+    }
+  }
+  throw new PresetGeneratorError("No usable command capabilities found for selected AC");
+}
+
+function getModeOptions(command) {
+  const categories = Array.isArray(command.categories) ? command.categories.filter(Boolean) : [];
+  if (categories.length) {
+    return [...new Set(categories)].sort();
+  }
+  const program = command.parameters?.program;
+  if (Array.isArray(program?.values)) {
+    return [...new Set(program.values.map(String))].sort();
+  }
+  return [];
+}
+
+function getFieldDescriptors(command, mode = "basic") {
+  const parameters = command.parameters || {};
+  const names = mode === "advanced" ? Object.keys(parameters).sort() : BASIC_FIELDS;
+  const fields = [];
+  const skipped = [];
+  for (const name of names) {
+    const parameter = parameters[name];
+    if (!parameter) {
+      skipped.push({ name, reason: "unsupported" });
+      continue;
+    }
+    if (!isSettableParameter(parameter)) {
+      skipped.push({ name, reason: parameter.typology === "fixed" ? "fixed" : "internal" });
+      continue;
+    }
+    fields.push(describeField(name, parameter));
+  }
+  return { fields, skipped };
+}
+
+function buildPreset(command, selectedValues, mode = "") {
+  const preset = {};
+  const modeOptions = getModeOptions(command);
+  if (mode) {
+    if (modeOptions.length && !modeOptions.includes(mode)) {
+      throw new PresetGeneratorError(`Unsupported mode value: ${mode}`, { values: modeOptions });
+    }
+    preset.mode = mode;
+  }
+  for (const [name, value] of Object.entries(selectedValues)) {
+    const parameter = command.parameters?.[name];
+    if (!parameter) {
+      throw new PresetGeneratorError(`Unsupported preset field: ${name}`);
+    }
+    if (!isSettableParameter(parameter)) {
+      throw new PresetGeneratorError(`Preset field is not settable: ${name}`);
+    }
+    if (!isAllowedValue(parameter, value)) {
+      throw new PresetGeneratorError(`Unsupported value for ${name}: ${value}`, { values: parameter.values || [] });
+    }
+    preset[name] = value;
+  }
+  return preset;
+}
+
+function defaultValueForField(field) {
+  return field.value == null ? field.values[0] || "" : String(field.value);
+}
+
+function isCommandCapability(command) {
+  return Boolean(command && typeof command === "object" && !Array.isArray(command) && command.parameters);
+}
+
+function isSettableParameter(parameter) {
+  if (!parameter || parameter.typology === "fixed") {
+    return false;
+  }
+  if (parameter.group && parameter.group !== "parameters") {
+    return false;
+  }
+  return Array.isArray(parameter.values) && parameter.values.length > 0;
+}
+
+function describeField(name, parameter) {
+  return {
+    name,
+    group: parameter.group || "",
+    typology: parameter.typology || "",
+    value: parameter.value,
+    values: Array.isArray(parameter.values) ? parameter.values.map(String) : []
+  };
+}
+
+function isAllowedValue(parameter, value) {
+  const values = Array.isArray(parameter.values) ? parameter.values.map(String) : [];
+  return values.includes(String(value));
+}
+
+module.exports = {
+  BASIC_FIELDS,
+  PresetGeneratorError,
+  buildPreset,
+  defaultValueForField,
+  getFieldDescriptors,
+  getModeOptions,
+  listAirConditioners,
+  loadCapabilitiesFile,
+  selectAirConditioner,
+  selectPresetCommand,
+  validateCapabilities
+};

package/types/global.ts

@@ -0,0 +1,19 @@
+export interface ProjectConfig {
+  email: string;
+  password: string;
+  mobileId?: string;
+  sessionFile: string;
+  applianceCacheFile?: string;
+  forceApplianceCacheRefresh?: boolean;
+  debug?: boolean;
+  requestLogging?: boolean;
+}
+
+export interface HonSessionData {
+  refreshToken: string;
+  sessionToken: string;
+  idToken?: string;
+  accessToken?: string;
+  expiresAt?: string;
+  updatedAt?: string;
+}