@robotical/webapp-types 3.25.10 → 3.25.11

package/dist-types/package.json

@@ -1,6 +1,6 @@
 {
     "name": "marty-web-app",
-    "version": "3.25.10",
+    "version": "3.25.11",
     "private": true,
     "engines": {
         "node": ">=20"

package/dist-types/src/application/RAFTs/Marty/PublishedDataAnalyser.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="node" />
 import EventEmitter from "events";
-import { ColourSignalProfile } from "../../../utils/colour-classifier";
+import { classifyColour, ColourSignalProfile } from "../../../utils/colour-classifier";
 import RAFT from "../RAFT";
 import type { RICStateInfo } from "@robotical/roboticaljs";
 import { type ColourSensorValues } from "./published-data-helpers";
 interface MartyState {
     colourSensed: "blue" | "green" | "red" | "yellow" | "purple" | "unclear" | "air";
-    /** Rule strength (0–100), not probability; null when no scored reading is available. */
+    /** Rule strength of the confirmed/held colour (0–100); null without a reading. */
     colourConfidence: number | null;
     lightSense: "none" | "high" | "mid" | "low";
     objectSense: "none" | "near";
@@ -16,6 +16,11 @@ declare class PublishedDataAnalyser extends EventEmitter {
     private marty;
     martyState: MartyState;
     private pubSub;
+    lastColourReading: ReturnType<typeof classifyColour> | null;
+    private colourFilter;
+    private colourContext;
+    private colourExpiry;
+    private connectionObserver;
     lightSenseDetection: LightSenseDetection;
     colourSensedDetection: ColourSensedDetection;
     objectSenseDetection: ObjectSenseDetection;
@@ -37,12 +42,15 @@ declare class PublishedDataAnalyser extends EventEmitter {
     unsubscribeFromPublishedData(): void;
     analyse(data: RICStateInfo): void;
     setColourSensed(colour: MartyState["colourSensed"], confidence?: number | null): void;
+    private resetColourDetection;
+    recordColourReading(reading: ReturnType<typeof classifyColour>, receivedAtMs: number): void;
+    private scheduleColourExpiry;
     setLightSense(lightSense: MartyState["lightSense"]): void;
     setObjectSense(objectSense: MartyState["objectSense"]): void;
     setNoiseSense(noiseSense: MartyState["noiseSense"]): void;
 }
 declare class ColourSensedDetection {
-    detectColourSensed({ r, g, b, clear, air }: ColourSensorValues, analyser: PublishedDataAnalyser, profile?: ColourSignalProfile): void;
+    detectColourSensed({ r, g, b, clear, air }: ColourSensorValues, analyser: PublishedDataAnalyser, profile?: ColourSignalProfile, receivedAtMs?: number): void;
 }
 declare class LightSenseDetection {
     private lowLightThreshold;

package/dist-types/src/application/RAFTs/Marty/PublishedDataAnalyser.js

@@ -14,15 +14,29 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 import EventEmitter from "events";
-import { classifyColour } from "../../../utils/colour-classifier";
+import { RaftConnEvent } from "@robdobsn/raftjs";
+import { classifyColour, colourChannelsFromValues } from "../../../utils/colour-classifier";
+import { ColourEventFilter } from "../../../utils/colour-event-filter";
 import { getAddonColourSensorProfile } from "../../../utils/colour-sensor-profile";
 import { createRaftPubSubscriptionHelper } from "../raft-subscription-helpers";
-import { getColourSensor, getLightSensor, getObjectSensor, getNoiseSensor, getRGBFromColourSensorVals, getLightSenseValues, getObjectIsTouchingFromVals, getNoiseSenseValue, } from "./published-data-helpers";
+import { getColourSensor, getLightSensor, getObjectSensor, getNoiseSensor, getLightSenseValues, getObjectIsTouchingFromVals, getNoiseSenseValue, } from "./published-data-helpers";
 var PublishedDataAnalyser = /** @class */ (function (_super) {
     __extends(PublishedDataAnalyser, _super);
     function PublishedDataAnalyser(marty) {
         var _this = _super.call(this) || this;
         _this.marty = marty;
+        _this.lastColourReading = null;
+        _this.colourFilter = new ColourEventFilter();
+        _this.colourContext = "";
+        _this.colourExpiry = null;
+        _this.connectionObserver = {
+            notify: function (eventType, eventEnum) {
+                if (eventType === "conn" && [RaftConnEvent.CONN_DISCONNECTED, RaftConnEvent.CONN_REJECTED,
+                    RaftConnEvent.CONN_VERIFYING_CORRECT, RaftConnEvent.CONN_VERIFIED_CORRECT].includes(eventEnum)) {
+                    _this.resetColourDetection();
+                }
+            },
+        };
         _this.lightSenseDetection = new LightSenseDetection();
         _this.colourSensedDetection = new ColourSensedDetection();
         _this.objectSenseDetection = new ObjectSenseDetection();
@@ -72,6 +86,9 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
     }
     PublishedDataAnalyser.prototype.subscribeToPublishedData = function () {
         var _this = this;
+        var _a;
+        (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.marty.subscribe(this.connectionObserver, ["conn"]);
         this.pubSub = createRaftPubSubscriptionHelper(this.marty, this.marty.id);
         this.pubSub.subscribe(function (data) {
             _this.analyse(data.stateInfo);
@@ -80,6 +97,9 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
     PublishedDataAnalyser.prototype.unsubscribeFromPublishedData = function () {
         var _a;
         (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.pubSub = null;
+        this.marty.unsubscribe(this.connectionObserver);
+        this.resetColourDetection();
     };
     PublishedDataAnalyser.prototype.analyse = function (data) {
         var _a;
@@ -89,8 +109,23 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         var lightSensor = getLightSensor(data);
         var objectSensor = getObjectSensor(data);
         var noiseSensor = getNoiseSensor(data);
-        colourSensor &&
-            this.colourSensedDetection.detectColourSensed(getRGBFromColourSensorVals(colourSensor), this, (_a = getAddonColourSensorProfile(this.marty, colourSensor)) === null || _a === void 0 ? void 0 : _a.signal);
+        var powerAge = Date.now() - data.powerValidMs;
+        if (!colourSensor || this.marty.isVerified === false || document.hidden ||
+            (colourSensor.status !== undefined && !(colourSensor.status & 0x80)) ||
+            (data.powerValidMs > 0 && powerAge >= 0 && powerAge < 3000 && ((_a = data.power) === null || _a === void 0 ? void 0 : _a.powerStatus.power5VIsOn) === false)) {
+            this.resetColourDetection();
+        }
+        else {
+            var profile = getAddonColourSensorProfile(this.marty, colourSensor);
+            var context = JSON.stringify([colourSensor.id, colourSensor.name, profile === null || profile === void 0 ? void 0 : profile.serialNumber, profile === null || profile === void 0 ? void 0 : profile.offsetsHex, profile === null || profile === void 0 ? void 0 : profile.whiteCalibrationHex, profile === null || profile === void 0 ? void 0 : profile.capturedAtMs]);
+            if (context !== this.colourContext) {
+                this.resetColourDetection();
+                this.colourContext = context;
+            }
+            var values = colourChannelsFromValues(colourSensor.vals);
+            this.colourSensedDetection.detectColourSensed({ r: values.red, g: values.green, b: values.blue,
+                clear: values.clear, air: values.air }, this, profile === null || profile === void 0 ? void 0 : profile.signal, data.addOnInfoValidMs);
+        }
         (objectSensor || colourSensor) &&
             this.objectSenseDetection.detectObjectSense(getObjectIsTouchingFromVals(objectSensor, colourSensor), this);
         lightSensor &&
@@ -104,9 +139,42 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
     };
     PublishedDataAnalyser.prototype.setColourSensed = function (colour, confidence) {
         if (confidence === void 0) { confidence = null; }
+        var changed = colour !== this.martyState.colourSensed;
         this.martyState.colourSensed = colour;
         this.martyState.colourConfidence = confidence;
-        this.emit(this.eventsMap.colourSensed[colour]);
+        if (changed)
+            this.emit(this.eventsMap.colourSensed[colour]);
+    };
+    PublishedDataAnalyser.prototype.resetColourDetection = function () {
+        if (this.colourExpiry !== null)
+            clearTimeout(this.colourExpiry);
+        this.colourExpiry = null;
+        this.colourContext = "";
+        this.colourFilter.reset();
+        this.lastColourReading = null;
+        this.setColourSensed("unclear", null);
+    };
+    PublishedDataAnalyser.prototype.recordColourReading = function (reading, receivedAtMs) {
+        this.lastColourReading = reading;
+        var value = this.colourFilter.update(reading, receivedAtMs, Date.now());
+        this.setColourSensed(value.colour, value.confidence);
+        this.scheduleColourExpiry();
+    };
+    PublishedDataAnalyser.prototype.scheduleColourExpiry = function () {
+        var _this = this;
+        if (this.colourExpiry !== null)
+            clearTimeout(this.colourExpiry);
+        var expiresAt = this.colourFilter.nextExpiryAtMs;
+        this.colourExpiry = expiresAt === null ? null : setTimeout(function () {
+            _this.colourExpiry = null;
+            if (_this.marty.isVerified === false || document.hidden) {
+                _this.resetColourDetection();
+                return;
+            }
+            var value = _this.colourFilter.current(Date.now());
+            _this.setColourSensed(value.colour, value.confidence);
+            _this.scheduleColourExpiry();
+        }, Math.max(0, expiresAt - Date.now()));
     };
     PublishedDataAnalyser.prototype.setLightSense = function (lightSense) {
         this.martyState.lightSense = lightSense;
@@ -125,10 +193,11 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
 var ColourSensedDetection = /** @class */ (function () {
     function ColourSensedDetection() {
     }
-    ColourSensedDetection.prototype.detectColourSensed = function (_a, analyser, profile) {
+    ColourSensedDetection.prototype.detectColourSensed = function (_a, analyser, profile, receivedAtMs) {
         var r = _a.r, g = _a.g, b = _a.b, clear = _a.clear, air = _a.air;
+        if (receivedAtMs === void 0) { receivedAtMs = Date.now(); }
         var reading = classifyColour({ red: r, green: g, blue: b, clear: clear, air: air }, profile);
-        return analyser.setColourSensed(reading.classifiedColour, reading.confidence);
+        return analyser.recordColourReading(reading, receivedAtMs);
     };
     return ColourSensedDetection;
 }());

package/dist-types/src/utils/colour-classifier.d.ts

@@ -33,7 +33,7 @@ export declare const classifyColour: (values: RGB & {
     signalSource: string;
     classificationReason: string;
 };
-export declare const colourChannelsFromValues: (vals: Record<string, number | boolean>) => {
+export declare const colourChannelsFromValues: (vals: Record<string, unknown>) => {
     red: number;
     green: number;
     blue: number;

package/dist-types/src/utils/colour-classifier.js

@@ -86,5 +86,5 @@ export var colourChannelsFromValues = function (vals) {
                 values[channel.toLowerCase()] = vals[key];
         }
     return { red: values.red, green: values.green, blue: values.blue,
-        clear: values.clear, air: [true, false, 0, 1].includes(values.air) ? Boolean(values.air) : undefined };
+        clear: values.clear, air: [true, false, 0, 1].some(function (value) { return value === values.air; }) ? Boolean(values.air) : undefined };
 };

package/dist-types/src/utils/colour-event-filter.d.ts

@@ -0,0 +1,24 @@
+import type { classifyColour, ColourName } from "./colour-classifier";
+export declare const COLOUR_EVENT_TIMING: {
+    readonly minimumReadings: 3;
+    readonly confirmationMs: 200;
+    readonly signalGapMs: 250;
+    readonly staleMs: 500;
+};
+type Reading = Pick<ReturnType<typeof classifyColour>, "classifiedColour" | "confidence" | "classificationReason">;
+type Value = {
+    colour: ColourName;
+    confidence: number | null;
+};
+/** Per-sensor event confirmation. Instantaneous classification remains independent. */
+export declare class ColourEventFilter {
+    private lastPacketAtMs;
+    private latest;
+    private confirmed;
+    private candidate;
+    reset(): void;
+    current(now: number): Value;
+    update(reading: Reading, receivedAtMs: number, now: number): Value;
+    get nextExpiryAtMs(): number | null;
+}
+export {};

package/dist-types/src/utils/colour-event-filter.js

@@ -0,0 +1,88 @@
+export var COLOUR_EVENT_TIMING = {
+    minimumReadings: 3,
+    confirmationMs: 200,
+    signalGapMs: 250,
+    staleMs: 500,
+};
+var isCard = function (colour) { return colour !== "air" && colour !== "unclear"; };
+/** Per-sensor event confirmation. Instantaneous classification remains independent. */
+var ColourEventFilter = /** @class */ (function () {
+    function ColourEventFilter() {
+        this.lastPacketAtMs = null;
+        this.latest = null;
+        this.confirmed = null;
+        this.candidate = null;
+    }
+    ColourEventFilter.prototype.reset = function () {
+        this.lastPacketAtMs = null;
+        this.latest = this.confirmed = this.candidate = null;
+    };
+    ColourEventFilter.prototype.current = function (now) {
+        var _a, _b;
+        if (this.lastPacketAtMs !== null && now - this.lastPacketAtMs >= COLOUR_EVENT_TIMING.staleMs) {
+            // Retain the packet watermark: repeated cached packets are still duplicates.
+            this.latest = this.confirmed = this.candidate = null;
+        }
+        if (this.confirmed && now - this.confirmed.lastAtMs >= COLOUR_EVENT_TIMING.signalGapMs)
+            this.confirmed = null;
+        if (this.candidate && now - this.candidate.lastAtMs >= COLOUR_EVENT_TIMING.signalGapMs)
+            this.candidate = null;
+        return ((_a = this.confirmed) === null || _a === void 0 ? void 0 : _a.value) || (((_b = this.latest) === null || _b === void 0 ? void 0 : _b.colour) === "air" ? this.latest :
+            { colour: "unclear", confidence: this.latest ? 0 : null });
+    };
+    ColourEventFilter.prototype.update = function (reading, receivedAtMs, now) {
+        var _a, _b;
+        this.current(now);
+        if (!Number.isFinite(receivedAtMs) || receivedAtMs <= 0 || receivedAtMs > now ||
+            now - receivedAtMs >= COLOUR_EVENT_TIMING.staleMs) {
+            this.reset();
+            return this.current(now);
+        }
+        // A STATE_INFO event can reuse the same add-on packet when other telemetry changes.
+        if (this.lastPacketAtMs !== null && receivedAtMs <= this.lastPacketAtMs)
+            return this.current(now);
+        this.lastPacketAtMs = receivedAtMs;
+        var value = { colour: reading.classifiedColour, confidence: reading.confidence };
+        this.latest = value;
+        if (reading.classificationReason === "invalid") {
+            this.confirmed = this.candidate = null;
+        }
+        else if (isCard(value.colour)) {
+            if (((_a = this.confirmed) === null || _a === void 0 ? void 0 : _a.value.colour) === value.colour) {
+                this.confirmed.value = value;
+                this.confirmed.lastAtMs = receivedAtMs;
+                this.candidate = null;
+            }
+            else {
+                if (((_b = this.candidate) === null || _b === void 0 ? void 0 : _b.value.colour) === value.colour) {
+                    this.candidate.count++;
+                    this.candidate.lastAtMs = receivedAtMs;
+                    this.candidate.value = value;
+                }
+                else {
+                    this.candidate = { value: value, firstAtMs: receivedAtMs, lastAtMs: receivedAtMs, count: 1 };
+                }
+                if (this.candidate.count >= COLOUR_EVENT_TIMING.minimumReadings &&
+                    receivedAtMs - this.candidate.firstAtMs >= COLOUR_EVENT_TIMING.confirmationMs) {
+                    this.confirmed = this.candidate;
+                    this.candidate = null;
+                }
+            }
+        }
+        return this.current(now);
+    };
+    Object.defineProperty(ColourEventFilter.prototype, "nextExpiryAtMs", {
+        get: function () {
+            var deadlines = [
+                this.confirmed && this.confirmed.lastAtMs + COLOUR_EVENT_TIMING.signalGapMs,
+                this.candidate && this.candidate.lastAtMs + COLOUR_EVENT_TIMING.signalGapMs,
+                this.latest && this.lastPacketAtMs + COLOUR_EVENT_TIMING.staleMs,
+            ].filter(function (value) { return value !== null; });
+            return deadlines.length ? Math.min.apply(Math, deadlines) : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ColourEventFilter;
+}());
+export { ColourEventFilter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/webapp-types",
-  "version": "3.25.10",
+  "version": "3.25.11",
   "description": "Type definitions for the Application Manager",
   "main": "dist/application-manager.d.ts",
   "types": "dist/application-manager.d.ts",