@apocaliss92/nodedreame 1.11.4 → 1.11.6

package/dist/index.cjs

@@ -75,8 +75,10 @@ __export(index_exports, {
   getVacuumCapabilities: () => getVacuumCapabilities,
   isDreameConsumableKey: () => isDreameConsumableKey,
   mowerConsumableIndex: () => mowerConsumableIndex,
+  mowerFaultSeverity: () => mowerFaultSeverity,
   parseMowerConsumables: () => parseMowerConsumables,
   parseMowerHeartbeat: () => parseMowerHeartbeat,
+  parseMowingProgress: () => parseMowingProgress,
   renderMowerSvg: () => renderMowerSvg,
   renderVacuumPng: () => renderVacuumPng,
   resolveCapabilities: () => resolveCapabilities,
@@ -86,7 +88,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/support/version.ts
 var LIBRARY_NAME = "nodedreame";
-var LIBRARY_VERSION = "1.11.4";
+var LIBRARY_VERSION = "1.11.6";
 
 // src/transport/errors.ts
 var DreameError = class extends Error {
@@ -2857,18 +2859,27 @@ function decodeVacuumMap(input, opts = {}) {
   const pixelGrid = inflated.subarray(pixelStart, pixelEnd);
   const canDecodePixels = header.frameType === "I" && pixelGrid.length === header.width * header.height;
   const layers = canDecodePixels ? decodePixelGridFsm1(pixelGrid, header.width, header.height) : [];
-  const segments = canDecodePixels ? collectSegments(layers, dimensions, tail) : [];
   const paths = parsePathTr(tail.tr ?? "");
   const obstacles = parseObstacles(tail.ai_obstacle ?? []);
   let geometry = parseTailGeometry(tail);
-  if (!isGeometryComplete(geometry) && typeof tail.rism === "string" && tail.rism.length > 0) {
+  let segTail = tail;
+  const outerHasNames = Object.values(tail.seg_inf ?? {}).some(
+    (m) => typeof m?.name === "string" && m.name.length > 0
+  );
+  if ((!isGeometryComplete(geometry) || !outerHasNames) && typeof tail.rism === "string" && tail.rism.length > 0) {
     try {
       const innerInflated = unwrapEnvelope(tail.rism);
       const { tail: innerTail } = parseFrame(innerInflated);
-      geometry = coalesceGeometry(geometry, parseTailGeometry(innerTail));
+      if (!isGeometryComplete(geometry)) {
+        geometry = coalesceGeometry(geometry, parseTailGeometry(innerTail));
+      }
+      if (!outerHasNames && innerTail.seg_inf) {
+        segTail = mergeSegInfNames(tail, innerTail.seg_inf);
+      }
     } catch {
     }
   }
+  const segments = canDecodePixels ? collectSegments(layers, dimensions, segTail) : [];
   const cleanedArea = typeof tail.decmap === "string" ? parseCleanedAreaOverlay(tail.decmap) : null;
   return {
     mapId: header.mapId,
@@ -2892,6 +2903,18 @@ function applyVacuumPFrame(prev, pframe, opts = {}) {
   const merged = typeof prev === "string" || typeof pframe === "string" ? mergePFrameEnvelope(prev, pframe, opts.prev, opts.pframe) : mergePFrame(prev, pframe);
   return { buffer: merged, data: decodeVacuumMap(merged) };
 }
+function mergeSegInfNames(tail, innerSegInf) {
+  const outer = tail.seg_inf ?? {};
+  const ids = /* @__PURE__ */ new Set([...Object.keys(outer), ...Object.keys(innerSegInf)]);
+  const merged = {};
+  for (const id of ids) {
+    const o = outer[id] ?? {};
+    const inner = innerSegInf[id] ?? {};
+    const name = typeof o.name === "string" && o.name.length > 0 ? o.name : inner.name;
+    merged[id] = { ...inner, ...o, ...name !== void 0 ? { name } : {} };
+  }
+  return { ...tail, seg_inf: merged };
+}
 function mergeDimensions(header, tail) {
   const left = tail.origin?.[0] ?? header.left;
   const top = tail.origin?.[1] ?? header.top;
@@ -2913,78 +2936,6 @@ function pose(x, y, angle, absent) {
 // src/models/vacuum/map/render.ts
 var import_pngjs = require("pngjs");
 var SCHEMES = {
-  "dreame-light": {
-    floor: [210, 222, 235, 255],
-    wall: [60, 60, 60, 255],
-    carpet: [180, 150, 120, 200],
-    segSat: 0.45,
-    segVal: 0.95,
-    path: [60, 110, 180, 235],
-    robotBody: [40, 70, 110, 255],
-    robotHeading: [255, 255, 255, 255],
-    charger: [40, 160, 80, 255],
-    noGoFill: [220, 60, 60, 70],
-    noGoBorder: [200, 40, 40, 220],
-    noMopFill: [60, 120, 220, 60],
-    noMopBorder: [40, 90, 200, 200],
-    virtualWall: [200, 40, 40, 230],
-    obstacle: [230, 150, 30, 255],
-    label: [40, 40, 40, 255]
-  },
-  "dreame-dark": {
-    floor: [40, 46, 56, 255],
-    wall: [15, 15, 18, 255],
-    carpet: [80, 66, 52, 200],
-    segSat: 0.5,
-    segVal: 0.62,
-    path: [120, 170, 230, 235],
-    robotBody: [120, 170, 230, 255],
-    robotHeading: [20, 24, 30, 255],
-    charger: [60, 200, 110, 255],
-    noGoFill: [220, 70, 70, 80],
-    noGoBorder: [230, 70, 70, 220],
-    noMopFill: [70, 130, 230, 70],
-    noMopBorder: [80, 140, 235, 210],
-    virtualWall: [230, 70, 70, 235],
-    obstacle: [240, 180, 60, 255],
-    label: [225, 230, 240, 255]
-  },
-  "mijia-light": {
-    floor: [225, 232, 240, 255],
-    wall: [70, 78, 92, 255],
-    carpet: [188, 162, 132, 200],
-    segSat: 0.35,
-    segVal: 0.98,
-    path: [80, 130, 200, 230],
-    robotBody: [30, 100, 200, 255],
-    robotHeading: [255, 255, 255, 255],
-    charger: [40, 170, 90, 255],
-    noGoFill: [225, 70, 70, 70],
-    noGoBorder: [205, 45, 45, 220],
-    noMopFill: [70, 130, 225, 60],
-    noMopBorder: [50, 100, 205, 200],
-    virtualWall: [205, 45, 45, 230],
-    obstacle: [235, 160, 35, 255],
-    label: [45, 52, 64, 255]
-  },
-  tasshack: {
-    floor: [200, 210, 225, 255],
-    wall: [80, 80, 95, 255],
-    carpet: [176, 148, 118, 205],
-    segSat: 0.5,
-    segVal: 0.9,
-    path: [50, 100, 170, 235],
-    robotBody: [35, 60, 100, 255],
-    robotHeading: [255, 255, 255, 255],
-    charger: [35, 150, 75, 255],
-    noGoFill: [215, 55, 55, 75],
-    noGoBorder: [195, 35, 35, 220],
-    noMopFill: [55, 115, 215, 65],
-    noMopBorder: [35, 85, 195, 205],
-    virtualWall: [195, 35, 35, 230],
-    obstacle: [225, 145, 25, 255],
-    label: [35, 42, 54, 255]
-  },
   // Flat-design: soft neutral floor, bright low-saturation segment fills, thin
   // mid-grey walls, a single vivid accent for the path.
   flat: {
@@ -3081,7 +3032,7 @@ function segmentColor(id, pal) {
 }
 function renderVacuumPng(map, opts = {}) {
   const scale = Math.max(1, Math.trunc(opts.scale ?? 1));
-  const pal = SCHEMES[opts.colorScheme ?? "dreame-light"];
+  const pal = SCHEMES[opts.colorScheme ?? "flat"] ?? SCHEMES.flat;
   const w = Math.max(1, map.dimensions.width * scale);
   const h = Math.max(1, map.dimensions.height * scale);
   const png = new import_pngjs.PNG({ width: w, height: h });
@@ -3124,8 +3075,12 @@ function renderVacuumPng(map, opts = {}) {
     const byType = opts.colorObstaclesByType !== false;
     for (const ob of map.obstacles) {
       const p = worldToPx(ob.x, ob.y, dim, scale);
-      const color = byType ? obstacleColor(ob.type) : pal.obstacle;
-      drawDiamond(png, p.x, p.y, Math.max(2, scale * 2), color);
+      const r = Math.max(2, scale * 2);
+      if (byType) {
+        drawObstacleShape(png, p.x, p.y, r, ob.type, obstacleColor(ob.type));
+      } else {
+        drawDiamond(png, p.x, p.y, r, pal.obstacle);
+      }
     }
   }
   if (opts.showCharger !== false && map.dock !== null) {
@@ -3286,6 +3241,32 @@ function obstacleColor(type) {
   const hue = Math.abs(Math.trunc(type)) * 47 % 360;
   return hsvToRgba(hue, 0.85, 0.95);
 }
+function drawSquare(png, cx, cy, r, color) {
+  fillRect(png, cx - r, cy - r, cx + r, cy + r, color);
+}
+function drawTriangle(png, cx, cy, r, color) {
+  for (let dy = -r; dy <= r; dy += 1) {
+    const w = Math.round((dy + r) / (2 * r) * r);
+    for (let dx = -w; dx <= w; dx += 1) {
+      setPixel(png, cx + dx, cy + dy, color);
+    }
+  }
+}
+function drawObstacleShape(png, cx, cy, r, type, color) {
+  switch (Math.abs(Math.trunc(type)) % 4) {
+    case 0:
+      drawDiamond(png, cx, cy, r, color);
+      return;
+    case 1:
+      drawSquare(png, cx, cy, r, color);
+      return;
+    case 2:
+      drawTriangle(png, cx, cy, r, color);
+      return;
+    default:
+      drawDisk(png, cx, cy, r, color);
+  }
+}
 var FURNITURE_LINE = [150, 110, 200, 235];
 function paintFurnitureZone(png, points, dim, scale) {
   if (points.length < 2) return;
@@ -4270,6 +4251,12 @@ var MowerFault = /* @__PURE__ */ ((MowerFault2) => {
   MowerFault2[MowerFault2["TopCoverOpen"] = 73] = "TopCoverOpen";
   return MowerFault2;
 })(MowerFault || {});
+function mowerFaultSeverity(code) {
+  if (code === null) return "info";
+  if (code >= 1 && code <= 30 || code === 37 || code === 73) return "error";
+  if (code >= 31 && code <= 36 || code >= 38 && code <= 45) return "warning";
+  return "info";
+}
 
 // src/models/mower/decode.ts
 function isRecord2(v) {
@@ -4480,6 +4467,37 @@ function parseMowerHeartbeat(value) {
   const taskSubState = mainState === HEARTBEAT_MAIN_STATE_MOWING ? MOWER_TASK_SUBSTATES[subStateRaw - HEARTBEAT_SUBSTATE_BASE] ?? null : null;
   return { rawBattery, mainState, subStateRaw, taskSubState };
 }
+var POSE_SENTINEL = 206;
+function poseBytes(value) {
+  if (!Array.isArray(value)) return null;
+  const bytes = [];
+  for (const b of value) {
+    if (typeof b !== "number") return null;
+    bytes.push(b);
+  }
+  return bytes;
+}
+function parseMowingProgress(value) {
+  const bytes = poseBytes(value);
+  if (bytes === null || bytes.length < 11) return null;
+  const last = bytes[bytes.length - 1];
+  const head = bytes[0];
+  let offset = null;
+  if (head !== POSE_SENTINEL && last === POSE_SENTINEL) {
+    offset = 0;
+  } else if (head === POSE_SENTINEL && last === POSE_SENTINEL && bytes.length >= 33) {
+    offset = 22;
+  }
+  if (offset === null || offset + 10 > bytes.length) return null;
+  const rawPercent = (bytes[offset + 2] ?? 0) | (bytes[offset + 3] ?? 0) << 8;
+  const total = (bytes[offset + 4] ?? 0) | (bytes[offset + 5] ?? 0) << 8 | (bytes[offset + 6] ?? 0) << 16;
+  const finish = (bytes[offset + 7] ?? 0) | (bytes[offset + 8] ?? 0) << 8 | (bytes[offset + 9] ?? 0) << 16;
+  return {
+    progressPercent: rawPercent ? Math.min(100, rawPercent / 100) : 0,
+    currentAreaSqm: finish / 100,
+    totalAreaSqm: total / 100
+  };
+}
 
 // src/models/mower/capabilities.ts
 var FALLBACK2 = {
@@ -5179,6 +5197,25 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
   get coverageTargetPct() {
     return this.task?.coverageTarget ?? null;
   }
+  /**
+   * Live mowing PROGRESS decoded from the POSE_COVERAGE (1:4) task block —
+   * `{progressPercent, currentAreaSqm, totalAreaSqm}` — or null when 1:4 carries
+   * no task block (idle / pose-only frame). This is the byte-accurate progress
+   * the Dreamehome app shows (vs {@link coverageTargetPct}, the task TARGET).
+   */
+  get mowingProgress() {
+    return parseMowingProgress(
+      this.getProperty(MOWER_PROP.POSE_COVERAGE.siid, MOWER_PROP.POSE_COVERAGE.piid)?.value
+    );
+  }
+  /** Mowing completion percent (0..100) from {@link mowingProgress}, or null. */
+  get mowingProgressPct() {
+    return this.mowingProgress?.progressPercent ?? null;
+  }
+  /** Severity of the current DEVICE_CODE (2:2) — info / warning / error. */
+  get faultSeverity() {
+    return mowerFaultSeverity(this.faultRaw);
+  }
   /** Parsed per-zone control status (2:56), or null. */
   get controlStatus() {
     return parseControlStatus(
@@ -5358,6 +5395,7 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
   /** Props worth seeding on start() / polling — exported for the facade. */
   static DEFAULT_PROPS = [
     MOWER_PROP.HEARTBEAT,
+    MOWER_PROP.POSE_COVERAGE,
     MOWER_PROP.STATUS,
     MOWER_PROP.DEVICE_CODE,
     MOWER_PROP.BATTERY,
@@ -6017,8 +6055,10 @@ function createClientDumper(client, options) {
   getVacuumCapabilities,
   isDreameConsumableKey,
   mowerConsumableIndex,
+  mowerFaultSeverity,
   parseMowerConsumables,
   parseMowerHeartbeat,
+  parseMowingProgress,
   renderMowerSvg,
   renderVacuumPng,
   resolveCapabilities,