@apocaliss92/nodedreame 1.12.4 → 1.12.5

package/dist/index.cjs

@@ -134,7 +134,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/support/version.ts
 var LIBRARY_NAME = "nodedreame";
-var LIBRARY_VERSION = "1.12.4";
+var LIBRARY_VERSION = "1.12.5";
 
 // src/transport/errors.ts
 var DreameError = class extends Error {
@@ -1980,50 +1980,93 @@ var VACUUM_CONSUMABLES = [
     key: "main-brush",
     label: "Main Brush",
     life: { siid: 9, piid: 2 },
+    timeLeft: { siid: 9, piid: 1, unit: "hours" },
     reset: { siid: 9, aiid: 1 }
   },
   {
     key: "side-brush",
     label: "Side Brush",
     life: { siid: 10, piid: 2 },
+    timeLeft: { siid: 10, piid: 1, unit: "hours" },
     reset: { siid: 10, aiid: 1 }
   },
-  { key: "filter", label: "Filter", life: { siid: 11, piid: 1 }, reset: { siid: 11, aiid: 1 } },
-  { key: "sensor", label: "Sensor", life: { siid: 16, piid: 1 }, reset: { siid: 16, aiid: 1 } },
+  {
+    key: "filter",
+    label: "Filter",
+    life: { siid: 11, piid: 1 },
+    timeLeft: { siid: 11, piid: 2, unit: "hours" },
+    reset: { siid: 11, aiid: 1 }
+  },
+  {
+    key: "sensor",
+    label: "Sensor Dirty",
+    life: { siid: 16, piid: 1 },
+    timeLeft: { siid: 16, piid: 2, unit: "hours" },
+    reset: { siid: 16, aiid: 1 }
+  },
   {
     key: "tank-filter",
     label: "Tank Filter",
     life: { siid: 17, piid: 1 },
+    timeLeft: { siid: 17, piid: 2, unit: "hours" },
     reset: { siid: 17, aiid: 1 }
   },
-  { key: "mop-pad", label: "Mop Pad", life: { siid: 18, piid: 1 }, reset: { siid: 18, aiid: 1 } },
+  {
+    key: "mop-pad",
+    label: "Mop Pad",
+    life: { siid: 18, piid: 1 },
+    timeLeft: { siid: 18, piid: 2, unit: "hours" },
+    reset: { siid: 18, aiid: 1 }
+  },
   {
     key: "silver-ion",
     label: "Silver-ion",
     life: { siid: 19, piid: 2 },
+    timeLeft: { siid: 19, piid: 1, unit: "days" },
     reset: { siid: 19, aiid: 1 }
   },
   {
     key: "detergent",
     label: "Detergent",
     life: { siid: 20, piid: 1 },
+    timeLeft: { siid: 20, piid: 2, unit: "days" },
     reset: { siid: 20, aiid: 1 }
   },
-  { key: "squeegee", label: "Squeegee", life: { siid: 24, piid: 1 }, reset: { siid: 24, aiid: 1 } },
+  {
+    key: "squeegee",
+    label: "Squeegee",
+    life: { siid: 24, piid: 1 },
+    timeLeft: { siid: 24, piid: 2, unit: "days" },
+    reset: { siid: 24, aiid: 1 }
+  },
   {
     key: "deodorizer",
     label: "Deodorizer",
     life: { siid: 29, piid: 2 },
+    timeLeft: { siid: 29, piid: 1, unit: "days" },
     reset: { siid: 29, aiid: 1 }
   },
-  { key: "wheel", label: "Wheel", life: { siid: 30, piid: 2 }, reset: { siid: 30, aiid: 1 } },
+  {
+    key: "wheel",
+    label: "Wheel Dirty",
+    life: { siid: 30, piid: 2 },
+    timeLeft: { siid: 30, piid: 1, unit: "days" },
+    reset: { siid: 30, aiid: 1 }
+  },
   {
     key: "scale-inhibitor",
     label: "Scale Inhibitor",
     life: { siid: 31, piid: 2 },
+    timeLeft: { siid: 31, piid: 1, unit: "days" },
     reset: { siid: 31, aiid: 1 }
   },
-  { key: "dust-bag", label: "Dust Bag", life: { siid: 27, piid: 17 }, reset: null }
+  {
+    key: "dust-bag",
+    label: "Dust Bag",
+    life: { siid: 27, piid: 17 },
+    timeLeft: null,
+    reset: null
+  }
 ];
 function consumableSpec(key2) {
   return VACUUM_CONSUMABLES.find((c) => c.key === key2);
@@ -4895,6 +4938,12 @@ var OssFetcher = class {
 };
 
 // src/models/vacuum/vacuum-device.ts
+function consumableProps(spec) {
+  return spec.timeLeft === null ? [spec.life] : [spec.life, { siid: spec.timeLeft.siid, piid: spec.timeLeft.piid }];
+}
+function asError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
 var SUCTION = enumLookup([
   0 /* Quiet */,
   1 /* Standard */,
@@ -5052,25 +5101,72 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
     });
   }
   /**
-   * Seed EVERY consumable life property from the cloud shadow (no robot wake) so
-   * {@link supportedConsumables} reflects the full set on a docked robot. The
-   * consumable life values are static settings the robot rarely re-pushes over
-   * MQTT, so a fresh connect surfaces only the actively-changing ones without this.
+   * Time left before a consumable needs attention, in the unit the robot counts
+   * it in (see {@link ConsumableSpec.timeLeft}), or `null` when the model does
+   * not report it or the key has no time-left twin.
+   */
+  consumableTimeLeft(key2) {
+    const spec = consumableSpec(key2);
+    if (spec === void 0 || spec.timeLeft === null) return null;
+    const value = this.#num(spec.timeLeft.siid, spec.timeLeft.piid);
+    return value === null ? null : { value, unit: spec.timeLeft.unit };
+  }
+  /**
+   * Seed EVERY consumable life property AND its time-left twin from the cloud
+   * shadow (no robot wake), in one call, so {@link supportedConsumables} and
+   * {@link consumableTimeLeft} reflect the full set on a docked robot. The
+   * robot rarely re-pushes these over MQTT, so a consumer that wants them fresh
+   * must call this again — the library does not poll them.
    */
   async refreshConsumables() {
-    await this.refreshCachedProperties(VACUUM_CONSUMABLES.map((c) => c.life));
+    await this.refreshCachedProperties(VACUUM_CONSUMABLES.flatMap(consumableProps));
   }
   /**
    * Reset (mark replaced → life back to 100%) one consumable via its MIoT reset
-   * action. Rejects when the model exposes no reset action for the key (e.g.
-   * `dust-bag`) or the key is unknown.
+   * action, then re-read that consumable's life % and time left ONCE so the
+   * cache — and every getter after this resolves — reflects the reset. The
+   * re-read is live; if the robot does not answer it falls back to the cloud
+   * shadow (which may still hold the pre-reset value until the robot reports),
+   * and `refreshedFrom` says which one answered.
+   *
+   * Rejects when the model exposes no reset action for the key (e.g.
+   * `dust-bag`), the key is unknown, or the action itself fails. A failed
+   * RE-READ does not reject: the reset happened, and the result says the values
+   * are unknown (`refreshedFrom: null`).
    */
   async resetConsumable(key2) {
     const spec = consumableSpec(key2);
     if (spec === void 0 || spec.reset === null) {
       throw new DreameError(`resetConsumable: no reset action for consumable "${key2}"`);
     }
-    return this.callAction(spec.reset.siid, spec.reset.aiid, []);
+    const actionResult = await this.callAction(spec.reset.siid, spec.reset.aiid, []);
+    const refresh2 = await this.#rereadConsumable(spec);
+    const fresh = refresh2.refreshedFrom !== null;
+    return {
+      key: key2,
+      actionResult,
+      refreshedFrom: refresh2.refreshedFrom,
+      leftPct: fresh ? this.consumableLeftPct(key2) : null,
+      timeLeft: fresh ? this.consumableTimeLeft(key2) : null,
+      refreshError: refresh2.error
+    };
+  }
+  /** One targeted re-read of a consumable's properties: live, else the cloud shadow. */
+  async #rereadConsumable(spec) {
+    const props = consumableProps(spec);
+    let liveError;
+    try {
+      await this.refreshProperties(props);
+      return { refreshedFrom: "device", error: null };
+    } catch (err) {
+      liveError = asError(err);
+    }
+    try {
+      await this.refreshCachedProperties(props);
+      return { refreshedFrom: "cloud-shadow", error: liveError };
+    } catch (err) {
+      return { refreshedFrom: null, error: asError(err) };
+    }
   }
   // -- AI obstacle-detection ----------------------------------------------
   /**
@@ -5438,7 +5534,9 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
         break;
       }
       if (Date.now() + pollMs >= deadline) {
-        throw new DreameError("wifi signal map not available (none stored yet, or request timed out)");
+        throw new DreameError(
+          "wifi signal map not available (none stored yet, or request timed out)"
+        );
       }
       await new Promise((r) => setTimeout(r, pollMs));
     }