@7365admin1/core 3.83.0 → 3.84.0

package/dist/index.js

@@ -77,6 +77,7 @@ __export(src_exports, {
   ConsoleAuditAction: () => ConsoleAuditAction,
   ConsoleAuditTarget: () => ConsoleAuditTarget,
   DEFAULT_RING_SECONDS: () => DEFAULT_RING_SECONDS,
+  DEFAULT_SCALE_M_PER_PX: () => DEFAULT_SCALE_M_PER_PX,
   DEFAULT_SITE_TIMEZONE: () => DEFAULT_SITE_TIMEZONE,
   DEVICE_STATUS: () => DEVICE_STATUS,
   DOBStatus: () => DOBStatus,
@@ -296,6 +297,8 @@ __export(src_exports, {
   VerificationType: () => VerificationType,
   VisitorSort: () => VisitorSort,
   VisitorStatus: () => VisitorStatus,
+  WALL_HEIGHT_M: () => WALL_HEIGHT_M,
+  WALL_THICKNESS_M: () => WALL_THICKNESS_M,
   addressSchema: () => addressSchema,
   allowedFieldsSite: () => allowedFieldsSite,
   allowedNatures: () => allowedNatures,
@@ -307,6 +310,8 @@ __export(src_exports, {
   attendanceSchema: () => attendanceSchema,
   attendanceSettingsSchema: () => attendanceSettingsSchema,
   buildSelfServiceEmailContext: () => buildSelfServiceEmailContext,
+  buildingMapFromRobotMaps: () => buildingMapFromRobotMaps,
+  buildingSolids: () => buildingSolids,
   building_level_namespace_collection: () => building_level_namespace_collection,
   building_units_namespace_collection: () => building_units_namespace_collection,
   buildings_namespace_collection: () => buildings_namespace_collection,
@@ -413,6 +418,9 @@ __export(src_exports, {
   isTermsCurrent: () => isTermsCurrent,
   isTrackingStale: () => isTrackingStale,
   isValidTimezone: () => isValidTimezone,
+  levelPixelToMetres: () => levelPixelToMetres,
+  levelScale: () => levelScale,
+  levelSolids: () => levelSolids,
   listStaffUserIds: () => listStaffUserIds,
   liveStatusFor: () => liveStatusFor,
   manpowerDesignationsSchema: () => manpowerDesignationsSchema,
@@ -511,6 +519,7 @@ __export(src_exports, {
   robotTier: () => robotTier,
   robotTypesVisibleTo: () => robotTypesVisibleTo,
   rtspUrl: () => rtspUrl,
+  scaleFromMeasurement: () => scaleFromMeasurement,
   schema: () => schema,
   schemaAppSlugNotification: () => schemaAppSlugNotification,
   schemaApprovedBy: () => schemaApprovedBy,
@@ -928,8 +937,10 @@ __export(src_exports, {
   vehicleSchema: () => vehicleSchema,
   vehicleViewOf: () => vehicleViewOf,
   vehicles_namespace_collection: () => vehicles_namespace_collection,
+  vertexDistancePx: () => vertexDistancePx,
   visitors_namespace_collection: () => visitors_namespace_collection,
   wallConfig: () => wallConfig,
+  wallsFromOccupancyGrid: () => wallsFromOccupancyGrid,
   withLiveLink: () => withLiveLink,
   workOrderSchema: () => workOrderSchema,
   work_orders2_namespace_collection: () => work_orders2_namespace_collection,
@@ -60127,6 +60138,179 @@ function createLiftSimulator(options) {
   };
 }
 
+// src/utils/building-map.util.ts
+var WALL_HEIGHT_M = 2.5;
+var WALL_THICKNESS_M = 0.1;
+var DEFAULT_SCALE_M_PER_PX = 0.05;
+function scaleFromMeasurement(pixelDistance, realDistanceM) {
+  if (!Number.isFinite(pixelDistance) || pixelDistance <= 0) {
+    throw new Error("A measurement needs a positive pixel distance.");
+  }
+  if (!Number.isFinite(realDistanceM) || realDistanceM <= 0) {
+    throw new Error("A measurement needs a positive real distance in metres.");
+  }
+  return realDistanceM / pixelDistance;
+}
+function vertexDistancePx(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function levelScale(level) {
+  const measurement = level.measurements?.find((m) => {
+    const a = level.vertices[m.start];
+    const b = level.vertices[m.end];
+    return a && b && m.distanceM > 0 && vertexDistancePx(a, b) > 0;
+  });
+  if (measurement) {
+    return scaleFromMeasurement(
+      vertexDistancePx(level.vertices[measurement.start], level.vertices[measurement.end]),
+      measurement.distanceM
+    );
+  }
+  return level.scaleMPerPx > 0 ? level.scaleMPerPx : DEFAULT_SCALE_M_PER_PX;
+}
+function levelPixelToMetres(level, px, py, imageHeightPx) {
+  const scale = levelScale(level);
+  return {
+    x: level.originXM + px * scale,
+    y: level.originYM + (imageHeightPx - py) * scale
+  };
+}
+function levelSolids(level, imageHeightPx) {
+  const toM = (v) => levelPixelToMetres(level, v.x, v.y, imageHeightPx);
+  const walls = [];
+  for (const wall of level.walls ?? []) {
+    const a = level.vertices[wall.start];
+    const b = level.vertices[wall.end];
+    if (!a || !b)
+      continue;
+    const pa = toM(a);
+    const pb = toM(b);
+    const lengthM = Math.hypot(pb.x - pa.x, pb.y - pa.y);
+    if (lengthM <= 0)
+      continue;
+    const heightM = wall.heightM ?? WALL_HEIGHT_M;
+    walls.push({
+      centre: {
+        x: (pa.x + pb.x) / 2,
+        y: (pa.y + pb.y) / 2,
+        // Boxes are centred, so a wall standing ON the floor sits at half its
+        // own height above the level's elevation.
+        z: level.elevationM + heightM / 2
+      },
+      lengthM,
+      thicknessM: wall.thicknessM ?? WALL_THICKNESS_M,
+      heightM,
+      yaw: Math.atan2(pb.y - pa.y, pb.x - pa.x)
+    });
+  }
+  const floors = [];
+  for (const floor of level.floors ?? []) {
+    const points = (floor.vertices ?? []).map((i) => level.vertices[i]).filter(Boolean).map(toM);
+    if (points.length < 3)
+      continue;
+    floors.push({ points, elevationM: level.elevationM, hole: floor.hole === true });
+  }
+  return { level: level.name, elevationM: level.elevationM, walls, floors };
+}
+function buildingSolids(map, imageHeightFor) {
+  return (map.levels ?? []).map((level) => levelSolids(level, imageHeightFor(level)));
+}
+function wallsFromOccupancyGrid(grid, options) {
+  const threshold = options?.threshold ?? 100;
+  const minRun = Math.max(2, options?.minRunPx ?? 6);
+  const { data, width, height } = grid;
+  if (!width || !height || !data || data.length < width * height) {
+    return { vertices: [], walls: [] };
+  }
+  const occupied = (x, y) => Number(data[y * width + x]) <= threshold;
+  const consumed = new Uint8Array(width * height);
+  const vertices = [];
+  const walls = [];
+  const index = /* @__PURE__ */ new Map();
+  const vertexAt = (x, y) => {
+    const key = `${x}:${y}`;
+    const found = index.get(key);
+    if (found !== void 0)
+      return found;
+    vertices.push({ x, y, z: 0 });
+    index.set(key, vertices.length - 1);
+    return vertices.length - 1;
+  };
+  const addRun = (x1, y1, x2, y2) => {
+    walls.push({ start: vertexAt(x1, y1), end: vertexAt(x2, y2) });
+  };
+  for (let y = 0; y < height; y++) {
+    let run = 0;
+    for (let x = 0; x <= width; x++) {
+      const on = x < width && occupied(x, y);
+      if (on) {
+        run++;
+        continue;
+      }
+      if (run >= minRun) {
+        const startX = x - run;
+        addRun(startX, y, x - 1, y);
+        for (let i = startX; i < x; i++)
+          consumed[y * width + i] = 1;
+      }
+      run = 0;
+    }
+  }
+  for (let x = 0; x < width; x++) {
+    let run = 0;
+    for (let y = 0; y <= height; y++) {
+      const on = y < height && occupied(x, y) && !consumed[y * width + x];
+      if (on) {
+        run++;
+        continue;
+      }
+      if (run >= minRun) {
+        addRun(x, y - run, x, y - 1);
+      }
+      run = 0;
+    }
+  }
+  return { vertices, walls };
+}
+function buildingMapFromRobotMaps(name, maps, floorHeightM = 3) {
+  const levels = [...maps ?? []].sort((a, b) => a.floorNo - b.floorNo).map((map) => {
+    const vertices = [];
+    if (map.baseX || map.baseY) {
+      vertices.push({
+        x: map.baseX ?? 0,
+        y: map.baseY ?? 0,
+        z: 0,
+        name: `L${map.floorNo}_charger`,
+        isCharger: true,
+        theta: map.baseTheta ?? 0
+      });
+    }
+    for (const area of map.areaList ?? []) {
+      vertices.push({
+        x: area.x,
+        y: area.y,
+        z: 0,
+        name: area.areaName,
+        isCleaningZone: true
+      });
+    }
+    return {
+      name: map.mapName?.trim() || `L${map.floorNo}`,
+      elevationM: (map.floorNo - 1) * floorHeightM,
+      drawing: { fileKey: map.backgroundFileKey },
+      scaleMPerPx: map.resolution && map.resolution > 0 ? map.resolution : DEFAULT_SCALE_M_PER_PX,
+      originXM: map.originX ?? 0,
+      originYM: map.originY ?? 0,
+      vertices,
+      walls: [],
+      floors: [],
+      doors: [],
+      measurements: []
+    };
+  });
+  return { name, levels, lifts: [] };
+}
+
 // src/services/robot-fleet.service.ts
 var import_node_server_utils157 = require("@7365admin1/node-server-utils");
 
@@ -93944,6 +94128,7 @@ function usePersonalEmergencyChainController() {
   ConsoleAuditAction,
   ConsoleAuditTarget,
   DEFAULT_RING_SECONDS,
+  DEFAULT_SCALE_M_PER_PX,
   DEFAULT_SITE_TIMEZONE,
   DEVICE_STATUS,
   DOBStatus,
@@ -94163,6 +94348,8 @@ function usePersonalEmergencyChainController() {
   VerificationType,
   VisitorSort,
   VisitorStatus,
+  WALL_HEIGHT_M,
+  WALL_THICKNESS_M,
   addressSchema,
   allowedFieldsSite,
   allowedNatures,
@@ -94174,6 +94361,8 @@ function usePersonalEmergencyChainController() {
   attendanceSchema,
   attendanceSettingsSchema,
   buildSelfServiceEmailContext,
+  buildingMapFromRobotMaps,
+  buildingSolids,
   building_level_namespace_collection,
   building_units_namespace_collection,
   buildings_namespace_collection,
@@ -94280,6 +94469,9 @@ function usePersonalEmergencyChainController() {
   isTermsCurrent,
   isTrackingStale,
   isValidTimezone,
+  levelPixelToMetres,
+  levelScale,
+  levelSolids,
   listStaffUserIds,
   liveStatusFor,
   manpowerDesignationsSchema,
@@ -94378,6 +94570,7 @@ function usePersonalEmergencyChainController() {
   robotTier,
   robotTypesVisibleTo,
   rtspUrl,
+  scaleFromMeasurement,
   schema,
   schemaAppSlugNotification,
   schemaApprovedBy,
@@ -94795,8 +94988,10 @@ function usePersonalEmergencyChainController() {
   vehicleSchema,
   vehicleViewOf,
   vehicles_namespace_collection,
+  vertexDistancePx,
   visitors_namespace_collection,
   wallConfig,
+  wallsFromOccupancyGrid,
   withLiveLink,
   workOrderSchema,
   work_orders2_namespace_collection,