@apocaliss92/nodedreame 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -351,6 +351,16 @@ var PropertyResultSchema = import_zod.z.object({
   value: import_zod.z.unknown().optional(),
   code: import_zod.z.number().optional()
 }).passthrough();
+var CachedPropEntrySchema = import_zod.z.object({
+  key: import_zod.z.string(),
+  value: import_zod.z.unknown().optional(),
+  updateDate: import_zod.z.number().optional()
+}).passthrough();
+var CachedPropsResponseSchema = import_zod.z.object({
+  code: import_zod.z.number().optional(),
+  msg: import_zod.z.string().optional(),
+  data: import_zod.z.array(CachedPropEntrySchema).optional()
+}).passthrough();
 var SendCommandResponseSchema = import_zod.z.object({
   code: import_zod.z.number().optional(),
   msg: import_zod.z.string().optional(),
@@ -540,6 +550,57 @@ async function getProperties(base, props, opts = {}) {
   const res = await sendCommand({ ...base, ...opts, method: "get_properties", params });
   return extractResultArray(res, "get_properties");
 }
+async function getCachedProperties(base, props, opts = {}) {
+  const ctx = base.ctx ?? RequestContext.from({ ...base, host: base.apiHost });
+  const keys = props.map((p) => `${p.siid}.${p.piid}`).join(",");
+  const signal = opts.signal ?? base.signal;
+  const timeoutMs = opts.timeoutMs ?? base.timeoutMs;
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: "/dreame-user-iot/iotstatus/props",
+    accessToken: base.session.accessToken,
+    body: { did: base.did, keys },
+    context: "cached properties",
+    ...signal !== void 0 ? { signal } : {},
+    ...timeoutMs !== void 0 ? { timeoutMs } : {}
+  });
+  const parsed = CachedPropsResponseSchema.parse(raw);
+  if (parsed.code !== void 0 && parsed.code !== 0) {
+    throw new DreameApiError(
+      `cached properties rejected: code=${parsed.code} msg=${parsed.msg ?? "?"}`,
+      200,
+      parsed
+    );
+  }
+  return (parsed.data ?? []).flatMap((entry) => {
+    const [siidStr, piidStr] = entry.key.split(".");
+    const siid = Number(siidStr);
+    const piid = Number(piidStr);
+    if (!Number.isFinite(siid) || !Number.isFinite(piid)) {
+      return [];
+    }
+    const result = { siid, piid, value: coerceShadowValue(entry.value) };
+    if (entry.updateDate !== void 0) {
+      result.updateDate = entry.updateDate;
+    }
+    return [result];
+  });
+}
+function coerceShadowValue(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (value.trim() !== "" && Number.isFinite(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
 async function setProperties(base, writes, opts = {}) {
   const params = writes.map((p) => ({
     did: base.did,
@@ -917,6 +978,7 @@ function defaultBaseDeviceDeps() {
   return {
     createPush: (device, session, region) => new DreamePush({ device, session, region }),
     getProperties: (base, props) => getProperties(base, props),
+    getCachedProperties: (base, props) => getCachedProperties(base, props),
     setProperties: (base, writes) => setProperties(base, writes),
     callAction: (base, action) => callAction(base, action)
   };
@@ -1005,6 +1067,23 @@ var BaseDevice = class extends TypedEmitter {
   async refreshProperties(props) {
     this.#assertOpen();
     const results = await this.#deps.getProperties(this.#base(), props);
+    this.#seedFromResults(results);
+    return results;
+  }
+  /**
+   * Read the CLOUD-CACHED (shadow) values of `props` WITHOUT waking the device,
+   * update the cache, and emit `propertyChanged`/`stateChanged` just like
+   * {@link refreshProperties} — but sourced from the cloud shadow endpoint, so
+   * it works for standby/offline robots (and never surfaces a false 80001).
+   */
+  async refreshCachedProperties(props) {
+    this.#assertOpen();
+    const results = await this.#deps.getCachedProperties(this.#base(), props);
+    this.#seedFromResults(results);
+    return results;
+  }
+  /** Mirror a PropertyResult[] into the cache + emit the change events. */
+  #seedFromResults(results) {
     const changes = [];
     for (const r of results) {
       if (typeof r.siid === "number" && typeof r.piid === "number") {
@@ -1014,7 +1093,6 @@ var BaseDevice = class extends TypedEmitter {
     if (changes.length > 0) {
       this.#onProperties(changes);
     }
-    return results;
   }
   /** Write a property to the device. */
   async setProperty(write) {
@@ -2408,7 +2486,7 @@ var TASK = enumLookup([
   12 /* TransientPauseEdge */,
   14 /* NeedsIntervention */
 ]);
-var VacuumDevice = class extends BaseDevice {
+var VacuumDevice = class _VacuumDevice extends BaseDevice {
   #caps;
   #lastMap = null;
   constructor(input) {
@@ -2623,6 +2701,16 @@ var VacuumDevice = class extends BaseDevice {
     const points = [[Math.round(point.x), Math.round(point.y), repeats, fan, water]];
     return this.#startCustom(CUSTOM_CLEAN_MODE.SPOT, { points });
   }
+  /**
+   * Seed the cache from the CLOUD SHADOW (last-known values) WITHOUT waking the
+   * robot — reads {@link VacuumDevice.DEFAULT_PROPS} from the cloud-cached
+   * endpoint. After it resolves, every typed getter (status/battery/suction/
+   * water/cleaningMode/error/charging…) reflects the cached values, so a
+   * standby/docked vacuum reports its state exactly as the Dreamehome app does.
+   */
+  async refreshFromCache() {
+    await this.refreshCachedProperties([..._VacuumDevice.DEFAULT_PROPS]);
+  }
   // -- maps ---------------------------------------------------------------
   /** The most-recently-decoded map, or `null` until {@link getMap} succeeds. */
   get lastMap() {
@@ -3455,7 +3543,7 @@ var STATUS = enumLookup(
 var CHARGING2 = enumLookup(
   Object.values(MowerChargingStatus).filter((v) => typeof v === "number")
 );
-var MowerDevice = class extends BaseDevice {
+var MowerDevice = class _MowerDevice extends BaseDevice {
   #caps;
   #fetchBatch;
   #lastMap = null;
@@ -3595,6 +3683,16 @@ var MowerDevice = class extends BaseDevice {
     }
     return this.#sendTask(buildSpotPayload(spotAreaIds.map((s) => Math.trunc(s))));
   }
+  /**
+   * Seed the cache from the CLOUD SHADOW (last-known values) WITHOUT waking the
+   * mower — reads {@link MowerDevice.DEFAULT_PROPS} from the cloud-cached
+   * endpoint. After it resolves, every typed getter (status/battery/charging/
+   * coverage/task/controlAction…) reflects the cached values, so a docked/
+   * standby mower reports its state exactly as the Dreamehome app does.
+   */
+  async refreshFromCache() {
+    await this.refreshCachedProperties([..._MowerDevice.DEFAULT_PROPS]);
+  }
   // -- maps ---------------------------------------------------------------
   /** The most-recently-parsed map, or `null` until {@link getMap} succeeds. */
   get lastMap() {