@apocaliss92/nodedreame 1.8.0 → 1.9.0

package/dist/index.cjs

@@ -81,7 +81,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/support/version.ts
 var LIBRARY_NAME = "nodedreame";
-var LIBRARY_VERSION = "1.8.0";
+var LIBRARY_VERSION = "1.9.0";
 
 // src/transport/errors.ts
 var DreameError = class extends Error {
@@ -1963,11 +1963,43 @@ function unwrapEnvelope(value, opts = {}) {
     }
     bytes = aesCbcDecrypt(bytes, key2, opts.iv);
   }
+  let inflated;
   try {
-    return zlib.inflateSync(bytes);
+    inflated = zlib.inflateSync(bytes);
   } catch (err) {
     throw new MapDecodeError("envelope: zlib inflate failed", { cause: err });
   }
+  let guard = 0;
+  while (guard < MAX_EXTRA_WRAP_LAYERS && looksLikeBase64Zlib(inflated)) {
+    const text = inflated.toString("latin1").replace(/-/g, "+").replace(/_/g, "/");
+    try {
+      inflated = zlib.inflateSync(Buffer.from(text, "base64"));
+    } catch (err) {
+      throw new MapDecodeError("envelope: nested zlib inflate failed", { cause: err });
+    }
+    guard += 1;
+  }
+  return inflated;
+}
+var MAX_EXTRA_WRAP_LAYERS = 4;
+function looksLikeBase64Zlib(buf) {
+  if (buf.length < 8) return false;
+  for (const b of buf) {
+    const isB64 = b >= 65 && b <= 90 || // A-Z
+    b >= 97 && b <= 122 || // a-z
+    b >= 48 && b <= 57 || // 0-9
+    b === 43 || b === 47 || // + /
+    b === 45 || b === 95 || // - _ (url-safe)
+    b === 61;
+    if (!isB64) return false;
+  }
+  try {
+    const prefix = buf.subarray(0, 16).toString("latin1").replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = Buffer.from(prefix, "base64");
+    return decoded.length >= 2 && decoded[0] === 120;
+  } catch {
+    return false;
+  }
 }
 function aesCbcDecrypt(cipher, rawKey, iv) {
   const keyBytes = Buffer.from(
@@ -2603,7 +2635,7 @@ function decodeCleanedAreaPixels(pixels, width, height) {
 
 // src/models/vacuum/map/decode.ts
 function decodeVacuumMap(input, opts = {}) {
-  const inflated = typeof input === "string" ? unwrapEnvelope(input, opts) : input;
+  const inflated = typeof input === "string" ? unwrapEnvelope(input, opts) : looksLikeBase64Zlib(input) ? unwrapEnvelope(input.toString("latin1"), opts) : input;
   const { header, tail } = parseFrame(inflated);
   const dimensions = mergeDimensions(header, tail);
   const robot = pose(header.robotX, header.robotY, header.robotA, tail.nr === true);
@@ -2665,10 +2697,79 @@ function pose(x, y, angle, absent) {
 
 // src/models/vacuum/map/render.ts
 var import_pngjs = require("pngjs");
-var RGBA = {
-  wall: [60, 60, 60, 255],
-  floor: [210, 222, 235, 255],
-  carpet: [180, 150, 120, 200]
+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]
+  }
 };
 function hsvToRgba(h, s, v) {
   const c = v * s;
@@ -2699,49 +2800,230 @@ function hsvToRgba(h, s, v) {
   const m = v - c;
   return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255), 255];
 }
-function segmentColor(id) {
+function segmentColor(id, pal) {
   const hue = id * 137.508 % 360;
-  return hsvToRgba(hue, 0.45, 0.95);
+  return hsvToRgba(hue, pal.segSat, pal.segVal);
 }
 function renderVacuumPng(map, opts = {}) {
   const scale = Math.max(1, Math.trunc(opts.scale ?? 1));
-  const w = map.dimensions.width * scale;
-  const h = map.dimensions.height * scale;
-  const png = new import_pngjs.PNG({ width: Math.max(1, w), height: Math.max(1, h) });
+  const pal = SCHEMES[opts.colorScheme ?? "dreame-light"];
+  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 });
   png.data.fill(0);
   for (const layer of map.layers) {
-    paintLayer(png, layer, scale);
+    paintLayer(png, layer, scale, pal);
+  }
+  const dim = map.dimensions;
+  if (opts.showNoGo !== false) {
+    for (const area of map.restrictedAreas) {
+      const fill = area.kind === "noMop" ? pal.noMopFill : pal.noGoFill;
+      const border = area.kind === "noMop" ? pal.noMopBorder : pal.noGoBorder;
+      const a = worldToPx(area.bbox.xMin, area.bbox.yMin, dim, scale);
+      const b = worldToPx(area.bbox.xMax, area.bbox.yMax, dim, scale);
+      fillRect(png, a.x, a.y, b.x, b.y, fill);
+      strokeRect(png, a.x, a.y, b.x, b.y, border);
+    }
+  }
+  if (opts.showVirtualWalls !== false) {
+    for (const vw of map.virtualWalls) {
+      const a = worldToPx(vw.from.x, vw.from.y, dim, scale);
+      const b = worldToPx(vw.to.x, vw.to.y, dim, scale);
+      drawLine(png, a.x, a.y, b.x, b.y, pal.virtualWall, Math.max(1, scale));
+    }
+  }
+  if (opts.showPath !== false) {
+    for (const path of map.paths) {
+      drawPolyline(png, path.points, dim, scale, pal.path, Math.max(1, scale));
+    }
+  }
+  if (opts.showObstacles !== false) {
+    for (const ob of map.obstacles) {
+      const p = worldToPx(ob.x, ob.y, dim, scale);
+      drawDisk(png, p.x, p.y, Math.max(2, scale * 2), pal.obstacle);
+    }
+  }
+  if (opts.showCharger !== false && map.dock !== null) {
+    drawCharger(png, map.dock, dim, scale, pal);
+  }
+  if (opts.showRobot !== false && map.robot !== null) {
+    drawRobot(png, map.robot, dim, scale, pal);
+  }
+  if (opts.showSegmentLabels === true) {
+    for (const seg of map.segments) {
+      const p = worldToPx(seg.centroid.x, seg.centroid.y, dim, scale);
+      drawLabel(png, p.x, p.y, String(seg.id), pal.label, Math.max(1, scale));
+    }
   }
   return import_pngjs.PNG.sync.write(png);
 }
-function paintLayer(png, layer, scale) {
-  const color = layer.type === "segment" ? segmentColor(layer.segmentId ?? 0) : RGBA[layer.type];
+function worldToPx(worldX, worldY, dim, scale) {
+  return {
+    x: Math.round((worldX - dim.left) / dim.gridSize * scale),
+    y: Math.round((worldY - dim.top) / dim.gridSize * scale)
+  };
+}
+function paintLayer(png, layer, scale, pal) {
+  const color = layer.type === "segment" ? segmentColor(layer.segmentId ?? 0, pal) : layer.type === "wall" ? pal.wall : layer.type === "carpet" ? pal.carpet : pal.floor;
   for (const run of layer.runs) {
-    paintRun(png, run, color, scale, png.width, png.height);
+    paintRun(png, run, color, scale);
   }
 }
-function paintRun(png, run, color, scale, width, height) {
+function paintRun(png, run, color, scale) {
   const [xPx, yPx, len] = run;
   for (let i = 0; i < len; i += 1) {
     const baseX = (xPx + i) * scale;
     const baseY = yPx * scale;
     for (let dy = 0; dy < scale; dy += 1) {
-      const py = baseY + dy;
-      if (py < 0 || py >= height) {
-        continue;
-      }
       for (let dx = 0; dx < scale; dx += 1) {
-        const px = baseX + dx;
-        if (px < 0 || px >= width) {
-          continue;
+        setPixel(png, baseX + dx, baseY + dy, color);
+      }
+    }
+  }
+}
+function setPixel(png, x, y, color) {
+  if (x < 0 || y < 0 || x >= png.width || y >= png.height) return;
+  const off = (y * png.width + x) * 4;
+  const a = color[3];
+  if (a >= 255) {
+    png.data[off] = color[0];
+    png.data[off + 1] = color[1];
+    png.data[off + 2] = color[2];
+    png.data[off + 3] = 255;
+    return;
+  }
+  const sa = a / 255;
+  const da = (png.data[off + 3] ?? 0) / 255;
+  const outA = sa + da * (1 - sa);
+  if (outA <= 0) return;
+  for (let k = 0; k < 3; k += 1) {
+    const src = color[k] ?? 0;
+    const dst = png.data[off + k] ?? 0;
+    png.data[off + k] = Math.round((src * sa + dst * da * (1 - sa)) / outA);
+  }
+  png.data[off + 3] = Math.round(outA * 255);
+}
+function fillRect(png, x0, y0, x1, y1, color) {
+  const xa = Math.min(x0, x1);
+  const xb = Math.max(x0, x1);
+  const ya = Math.min(y0, y1);
+  const yb = Math.max(y0, y1);
+  for (let y = ya; y <= yb; y += 1) {
+    for (let x = xa; x <= xb; x += 1) {
+      setPixel(png, x, y, color);
+    }
+  }
+}
+function strokeRect(png, x0, y0, x1, y1, color) {
+  const xa = Math.min(x0, x1);
+  const xb = Math.max(x0, x1);
+  const ya = Math.min(y0, y1);
+  const yb = Math.max(y0, y1);
+  for (let x = xa; x <= xb; x += 1) {
+    setPixel(png, x, ya, color);
+    setPixel(png, x, yb, color);
+  }
+  for (let y = ya; y <= yb; y += 1) {
+    setPixel(png, xa, y, color);
+    setPixel(png, xb, y, color);
+  }
+}
+function drawLine(png, x0, y0, x1, y1, color, thickness) {
+  let x = x0;
+  let y = y0;
+  const dx = Math.abs(x1 - x0);
+  const dy = -Math.abs(y1 - y0);
+  const sx = x0 < x1 ? 1 : -1;
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx + dy;
+  const r = Math.max(0, Math.trunc((thickness - 1) / 2));
+  for (; ; ) {
+    for (let oy = -r; oy <= r; oy += 1) {
+      for (let ox = -r; ox <= r; ox += 1) {
+        setPixel(png, x + ox, y + oy, color);
+      }
+    }
+    if (x === x1 && y === y1) break;
+    const e2 = 2 * err;
+    if (e2 >= dy) {
+      err += dy;
+      x += sx;
+    }
+    if (e2 <= dx) {
+      err += dx;
+      y += sy;
+    }
+  }
+}
+function drawPolyline(png, points, dim, scale, color, thickness) {
+  for (let i = 1; i < points.length; i += 1) {
+    const p0 = points[i - 1];
+    const p1 = points[i];
+    if (p0 === void 0 || p1 === void 0) continue;
+    const a = worldToPx(p0.x, p0.y, dim, scale);
+    const b = worldToPx(p1.x, p1.y, dim, scale);
+    drawLine(png, a.x, a.y, b.x, b.y, color, thickness);
+  }
+}
+function drawDisk(png, cx, cy, r, color) {
+  const rr = r * r;
+  for (let dy = -r; dy <= r; dy += 1) {
+    for (let dx = -r; dx <= r; dx += 1) {
+      if (dx * dx + dy * dy <= rr) setPixel(png, cx + dx, cy + dy, color);
+    }
+  }
+}
+function drawRobot(png, robot, dim, scale, pal) {
+  const p = worldToPx(robot.x, robot.y, dim, scale);
+  const r = Math.max(3, scale * 3);
+  drawDisk(png, p.x, p.y, r, pal.robotBody);
+  const rad = robot.angle * Math.PI / 180;
+  const hx = Math.round(p.x + Math.cos(rad) * r);
+  const hy = Math.round(p.y + Math.sin(rad) * r);
+  drawLine(png, p.x, p.y, hx, hy, pal.robotHeading, Math.max(1, Math.trunc(scale / 2) + 1));
+}
+function drawCharger(png, dock, dim, scale, pal) {
+  const p = worldToPx(dock.x, dock.y, dim, scale);
+  const r = Math.max(2, scale * 2);
+  fillRect(png, p.x - r, p.y - r, p.x + r, p.y + r, pal.charger);
+}
+var GLYPHS = {
+  "0": [7, 5, 5, 5, 7],
+  "1": [2, 6, 2, 2, 7],
+  "2": [7, 1, 7, 4, 7],
+  "3": [7, 1, 7, 1, 7],
+  "4": [5, 5, 7, 1, 1],
+  "5": [7, 4, 7, 1, 7],
+  "6": [7, 4, 7, 5, 7],
+  "7": [7, 1, 2, 2, 2],
+  "8": [7, 5, 7, 5, 7],
+  "9": [7, 5, 7, 1, 7],
+  "-": [0, 0, 7, 0, 0]
+};
+function drawLabel(png, cx, cy, text, color, px) {
+  const glyphW = 3 * px;
+  const glyphH = 5 * px;
+  const gap = px;
+  const totalW = text.length * glyphW + Math.max(0, text.length - 1) * gap;
+  let originX = Math.round(cx - totalW / 2);
+  const originY = Math.round(cy - glyphH / 2);
+  for (const ch of text) {
+    const glyph = GLYPHS[ch];
+    if (glyph !== void 0) {
+      for (let row = 0; row < 5; row += 1) {
+        const bits = glyph[row];
+        if (bits === void 0) continue;
+        for (let col = 0; col < 3; col += 1) {
+          if ((bits & 1 << 2 - col) === 0) continue;
+          for (let sy = 0; sy < px; sy += 1) {
+            for (let sx = 0; sx < px; sx += 1) {
+              setPixel(png, originX + col * px + sx, originY + row * px + sy, color);
+            }
+          }
         }
-        const off = (py * width + px) * 4;
-        png.data[off] = color[0];
-        png.data[off + 1] = color[1];
-        png.data[off + 2] = color[2];
-        png.data[off + 3] = color[3];
       }
     }
+    originX += glyphW + gap;
   }
 }