@robotical/webapp-types 1.0.5 → 1.0.6

package/dist-types/src/application/RAFTs/Cog/Cog.d.ts

@@ -4,11 +4,13 @@ import { RaftTypeE } from "../../../types/raft";
 import { CogStateInfo, RICLedLcdColours } from "@robotical/roboticaljs";
 import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
 import { RaftInfoEvents } from "../../../types/events/raft-info";
+import PublishedDataAnalyser from "./PublishedDataAnalyser";
 export declare class Cog extends RAFT implements RICInterface {
     id: string;
     type: RaftTypeE;
     _ledLcdColours: RICLedLcdColours;
     raftStateInfo: CogStateInfo | null;
+    publishedDataAnalyser: PublishedDataAnalyser;
     constructor(id: string);
     get ledLcdColours(): RICLedLcdColours;
     /**
@@ -23,6 +25,10 @@ export declare class Cog extends RAFT implements RICInterface {
    * This methods handles RAFT events coming from the RICConnector of the wrapper
    */
     handleRaftEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Conn Event Handler
+     */
+    connEventHandler(eventEnum: RaftConnEvent, eventName: string, data: any): Promise<void>;
     /**
      * Pub Event Handler
      */

package/dist-types/src/application/RAFTs/Cog/Cog.js

@@ -51,8 +51,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import RAFT from "../RAFT";
 import { RaftTypeE } from "../../../types/raft";
-import { RaftPublishEvent } from "@robdobsn/raftjs";
+import { RaftConnEvent, RaftPublishEvent } from "@robdobsn/raftjs";
 import { RaftInfoEvents } from "../../../types/events/raft-info";
+import PublishedDataAnalyser from "./PublishedDataAnalyser";
 var Cog = /** @class */ (function (_super) {
     __extends(Cog, _super);
     function Cog(id) {
@@ -68,6 +69,7 @@ var Cog = /** @class */ (function (_super) {
         ];
         // RAFT State Info
         _this.raftStateInfo = null;
+        _this.publishedDataAnalyser = new PublishedDataAnalyser(_this);
         return _this;
     }
     Object.defineProperty(Cog.prototype, "ledLcdColours", {
@@ -98,6 +100,9 @@ var Cog = /** @class */ (function (_super) {
     Cog.prototype.handleRaftEvent = function (eventType, eventEnum, eventName, eventData) {
         _super.prototype.handleRaftEvent.call(this, eventType, eventEnum, eventName, eventData);
         switch (eventType) {
+            case "conn":
+                this.connEventHandler(eventEnum, eventName, eventData);
+                break;
             case "pub":
                 this.pubEventHandler(eventEnum, eventName, eventData);
                 break;
@@ -108,6 +113,23 @@ var Cog = /** @class */ (function (_super) {
                 break;
         }
     };
+    /**
+     * Conn Event Handler
+     */
+    Cog.prototype.connEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftConnEvent.CONN_DISCONNECTED:
+                        this.publishedDataAnalyser.unsubscribeFromPublishedData();
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Pub Event Handler
      */

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

@@ -0,0 +1,28 @@
+import { CogStateInfo } from "@robotical/roboticaljs";
+import RAFT from "../RAFT";
+interface CogState {
+    tilt: boolean | "forward" | "backward" | "left" | "right";
+    movementType: boolean | "shake" | "move";
+    rotation: boolean | "clockwise" | "counter-clockwise";
+    buttonClick: boolean;
+    objectSense: boolean | "left" | "right";
+    lightSense: boolean | "left" | "right";
+    irMessage: boolean | "left" | "right";
+}
+declare class PublishedDataAnalyser {
+    private cog;
+    cogState: CogState;
+    private pubSub;
+    constructor(cog: RAFT);
+    subscribeToPublishedData(): void;
+    unsubscribeFromPublishedData(): void;
+    analyse(data: CogStateInfo): void;
+    detectTilt(data: CogStateInfo, isMoving: boolean): void;
+    detectMovement(data: CogStateInfo): boolean;
+    detectRotation(data: CogStateInfo, isMoving: boolean): void;
+    detectButtonClick(data: CogStateInfo): void;
+    detectObjectSense(data: CogStateInfo): void;
+    detectLightSense(data: CogStateInfo): void;
+    detectIRMessage(data: CogStateInfo): void;
+}
+export default PublishedDataAnalyser;

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

@@ -0,0 +1,423 @@
+import { raftPubSubscriptionHelper } from "../raft-subscription-helpers";
+import { isVersionGreater_errorCatching } from "../../../utils/helpers/compare-version";
+var PublishedDataAnalyser = /** @class */ (function () {
+    function PublishedDataAnalyser(cog) {
+        this.cog = cog;
+        this.cog = cog;
+        this.cogState = {
+            tilt: false,
+            movementType: false,
+            rotation: false,
+            buttonClick: false,
+            objectSense: false,
+            lightSense: false,
+            irMessage: false
+        };
+        this.pubSub = null;
+        this.subscribeToPublishedData();
+    }
+    PublishedDataAnalyser.prototype.subscribeToPublishedData = function () {
+        var _this = this;
+        this.pubSub = raftPubSubscriptionHelper(this.cog);
+        this.pubSub.subscribe(function (data) {
+            _this.analyse(data.stateInfo);
+        });
+    };
+    PublishedDataAnalyser.prototype.unsubscribeFromPublishedData = function () {
+        var _a;
+        (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    };
+    PublishedDataAnalyser.prototype.analyse = function (data) {
+        var isMoving = this.detectMovement(data);
+        this.detectTilt(data, isMoving);
+        this.detectRotation(data, isMoving);
+        this.detectButtonClick(data);
+        this.detectObjectSense(data);
+        this.detectLightSense(data);
+        this.detectIRMessage(data);
+    };
+    PublishedDataAnalyser.prototype.detectTilt = function (data, isMoving) {
+        tiltDetection.detectTilt(data, isMoving, this.cogState, this.cog.getRaftVersion());
+    };
+    PublishedDataAnalyser.prototype.detectMovement = function (data) {
+        return shakeDetector.detectShake(data.LSM6DS.ax, data.LSM6DS.ay, data.LSM6DS.az, Date.now(), this.cogState);
+    };
+    PublishedDataAnalyser.prototype.detectRotation = function (data, isMoving) {
+        rotationDetection.detectRotation(data, isMoving, this.cogState);
+    };
+    PublishedDataAnalyser.prototype.detectButtonClick = function (data) {
+        buttonClickDetection.detectButtonClick(data.Light.irVals[2], this.cogState, this.cog.getRaftVersion());
+    };
+    PublishedDataAnalyser.prototype.detectObjectSense = function (data) {
+        var objectSenseValueArray = data.Light.irVals;
+        objectSenseDetection.detectObjectSense(objectSenseValueArray, this.cogState);
+    };
+    PublishedDataAnalyser.prototype.detectLightSense = function (data) {
+        var lightSenseValue = data.Light.ambientVals[0];
+        lightSenseDetection.detectLightSense(lightSenseValue, this.cogState);
+    };
+    PublishedDataAnalyser.prototype.detectIRMessage = function (data) {
+        var irMessageData = data;
+        // irMessageDetection.detectIRMessage(data, this.cogState);
+    };
+    return PublishedDataAnalyser;
+}());
+var TiltDetection = /** @class */ (function () {
+    function TiltDetection() {
+    }
+    TiltDetection.prototype.distance = function (a, b) { return Math.sqrt((Math.pow(a, 2) + Math.pow(b, 2))); };
+    TiltDetection.rotateAccelData = function (x, y, z, degrees) {
+        // Convert degrees to radians
+        var radians = degrees * (Math.PI / 180);
+        // First rotate by 180 degrees about y axis
+        var rotatedX = 0 - x;
+        var rotatedY = y;
+        var rotatedZ = 0 - z;
+        var initialRotatedX = rotatedX;
+        // Calculate cosine and sine of the rotation angle
+        var cosTheta = Math.cos(radians);
+        var sinTheta = Math.sin(radians);
+        // Rotate around the z-axis
+        rotatedX = initialRotatedX * cosTheta - rotatedY * sinTheta;
+        rotatedY = initialRotatedX * sinTheta + rotatedY * cosTheta;
+        rotatedZ = rotatedZ; // z remains unchanged as the rotation is around the z-axis
+        return { x: rotatedX, y: rotatedY, z: rotatedZ };
+    };
+    TiltDetection.prototype.detectTilt = function (data, isMoving, cogState, cogVersion) {
+        if (isMoving === void 0) { isMoving = false; }
+        if (isMoving)
+            return;
+        var tiltCorrectionForOlderCog = 30;
+        var tiltCorrectionForNewerCog = -90;
+        var correctionCutOffVersion = "1.2.0";
+        var tiltCorrection = tiltCorrectionForOlderCog;
+        if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
+            tiltCorrection = tiltCorrectionForNewerCog;
+        }
+        var _a = TiltDetection.rotateAccelData(data.LSM6DS.ax, data.LSM6DS.ay, data.LSM6DS.az, tiltCorrection), x = _a.x, y = _a.y, z = _a.z;
+        var pitch = Math.atan2(x, this.distance(y, z));
+        var roll = Math.atan2(y, this.distance(x, z));
+        var yaw = Math.atan2(z, this.distance(x, y));
+        // no tilt example values: pitch: 0.00, roll: 0.00, yaw: 1.50
+        // tilt left example values: pitch: 0.00, roll: -1.00, yaw: 0.50
+        // tilt right example values: pitch: 0.00, roll: 1.00, yaw: 0.50
+        // tilt forward example values: pitch: -1.00, roll: 0.00, yaw: 0.50
+        // tilt backward example values: pitch: 1.00, roll: 0.00, yaw: 0.50
+        var forwardBackwardThreshold = 20 * (Math.PI / 180); // threshold for forward and backward tilt
+        var leftRightThreshold = 20 * (Math.PI / 180); // threshold for left and right tilt
+        var upDownThreshold = 0.5; // threshold for up and down tilt
+        var tiltDirection = false;
+        if (pitch < -forwardBackwardThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "forward";
+        }
+        if (pitch > forwardBackwardThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "backward";
+        }
+        if (roll < -leftRightThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "left";
+        }
+        if (roll > leftRightThreshold) { // && Math.abs(yaw) < upDownThreshold) {
+            tiltDirection = "right";
+        }
+        cogState.tilt = tiltDirection;
+    };
+    return TiltDetection;
+}());
+var RotationDetection = /** @class */ (function () {
+    function RotationDetection() {
+        this.dataBuffer = [];
+        this.bufferSize = 20; // buffer size for rotation detection
+        this.DELAY_FOR_ROTATION = 500; // delay between rotation detection
+        this.ROTATION_THRESHOLD = 8; // threshold for rotation detection
+        this.rotationDetected = false;
+        this.lastRotationDetectionTime = 0;
+        this.rotationTimer = null;
+    }
+    RotationDetection.prototype.addToBuffer = function (data) {
+        this.dataBuffer.push(data);
+        if (this.dataBuffer.length > this.bufferSize) {
+            this.dataBuffer.shift();
+        }
+    };
+    RotationDetection.prototype.detectRotation = function (data, isMoving, cogState) {
+        if (isMoving === void 0) { isMoving = false; }
+        this.bufferSize = this.bufferSize;
+        this.DELAY_FOR_ROTATION = this.DELAY_FOR_ROTATION;
+        this.ROTATION_THRESHOLD = this.ROTATION_THRESHOLD;
+        var currentTime = Date.now();
+        this.addToBuffer(data.LSM6DS.gz);
+        if (this.dataBuffer.length < this.bufferSize) {
+            return; // Wait until buffer is full
+        }
+        if (currentTime - this.lastRotationDetectionTime < this.DELAY_FOR_ROTATION || isMoving) {
+            // Ensure there is a minimum time between detections
+            return;
+        }
+        var metric = this.calculateMetric();
+        // Check if the magnitude of the rate of change is above the threshold
+        if (metric > this.ROTATION_THRESHOLD || metric < -this.ROTATION_THRESHOLD) {
+            this.lastRotationDetectionTime = currentTime;
+            this.dataBuffer = [];
+            if (metric > this.ROTATION_THRESHOLD) {
+                // console.log("Clockwise rotation detected:", metric);
+                cogState.rotation = "clockwise";
+            }
+            else if (metric < -this.ROTATION_THRESHOLD) {
+                // console.log("Counter-clockwise rotation detected:", metric);
+                cogState.rotation = "counter-clockwise";
+            }
+        }
+        else {
+            cogState.rotation = false;
+        }
+    };
+    RotationDetection.prototype.calculateMetric = function () {
+        //let gzArray = [];
+        var sum = 0;
+        for (var i = 0; i < this.dataBuffer.length; i++) {
+            //sum += this.dataBuffer[i].LSM6DS.gz;
+            sum += this.dataBuffer[i];
+            //gzArray.push(this.dataBuffer[i]);
+        }
+        //console.log("gz buffer (" + gzArray.length + " elements avg. " + (sum / this.dataBuffer.length) + "): " + gzArray);
+        //console.log(this.dataBuffer);
+        return sum / this.dataBuffer.length;
+    };
+    return RotationDetection;
+}());
+var ShakeDetector = /** @class */ (function () {
+    function ShakeDetector() {
+        this.thresholdAccelerationMove = 0.3;
+        this.thresholdAcceleration = 1; // how much acceleration is needed to consider shaking
+        this.thresholdShakeNumber = 1; // how many shakes are needed
+        this.interval = 400; // how much time between shakes
+        this.maxShakeDuration = 1500; // Maximum duration between first and last shakes in a sequence
+        this.coolOffPeriod = 1500; // how much time to wait before detecting another shake
+        this.lastTime = 0;
+        this.lastTimeShakeDetected = 0;
+        this.sensorBundles = [];
+        this.gravityVector = [0, 0, 0];
+        this.lastVector = [0, 0, 0];
+        this.shakeInProgress = false;
+        this.moveInProgress = false;
+    }
+    ShakeDetector.prototype.detectShake = function (xAcc, yAcc, zAcc, timestamp, cogState) {
+        this.thresholdAcceleration = this.thresholdAcceleration;
+        this.thresholdAccelerationMove = this.thresholdAccelerationMove;
+        this.thresholdShakeNumber = this.thresholdShakeNumber;
+        this.interval = this.interval;
+        this.maxShakeDuration = this.maxShakeDuration;
+        this.coolOffPeriod = this.coolOffPeriod;
+        var magAcc = Math.sqrt(xAcc * xAcc + yAcc * yAcc + zAcc * zAcc);
+        if (magAcc > 0.9 && magAcc < 1.1) {
+            // device is stationary-ish, log direction of acc values to get a rough reading on where down is
+            this.gravityVector = [xAcc, yAcc, zAcc];
+            if (this.moveInProgress) {
+                // console.log("move detected");
+                cogState.movementType = "move";
+            }
+            else {
+                // console.log("no move detected");
+                cogState.movementType = false;
+            }
+            this.moveInProgress = false;
+            this.shakeInProgress = false;
+            this.sensorBundles = [];
+            return this.moveInProgress;
+        }
+        else {
+            //console.log("move in progrss. prev state: ", this.moveInProgress);
+            // potentially threshold this with thresholeAccelerationMove if we want it to be less trigger happy
+            this.moveInProgress = true;
+            // this assumes that the orientation of the device doesn't change during the movement, so it's not ideal
+            var x = xAcc - this.gravityVector[0];
+            var y = yAcc - this.gravityVector[1];
+            var z = zAcc - this.gravityVector[2];
+            var mag = Math.sqrt(x * x + y * y + z * z);
+            if (mag > this.thresholdAcceleration || this.shakeInProgress) {
+                this.shakeInProgress = true;
+                var diffThresh = this.thresholdAcceleration;
+                if (mag > this.thresholdAcceleration) {
+                    // console.log('large magnitude movement ', x, y, z, this.gravityVector);
+                    // check if the acc vector is significantly changed from the previous large value
+                    if (!this.sensorBundles.length || Math.sqrt(Math.pow(this.lastVector[0] - x, 2) + Math.pow(this.lastVector[1] - y, 2) + Math.pow(this.lastVector[2] - z, 2)) > this.thresholdAcceleration) {
+                        this.sensorBundles.push({ x: x, y: y, z: z, timestamp: timestamp });
+                        //console.log(this.sensorBundles);
+                        this.lastVector = [x, y, z];
+                        // todo - call performCheck() to do a more detailed analysis of the readings? Might need some tweaks
+                        if (this.sensorBundles.length > this.thresholdShakeNumber) {
+                            // console.log("Shake detected!");
+                            this.sensorBundles = [];
+                            this.shakeInProgress = false;
+                            cogState.movementType = "shake";
+                        }
+                    }
+                    // this.noMoveCallback();
+                }
+                else {
+                    if (!this.sensorBundles.length || (timestamp - this.sensorBundles[this.sensorBundles.length - 1].timestamp) > this.interval) {
+                        this.shakeInProgress = false;
+                        this.sensorBundles = [];
+                        // console.log("resetting shake detector. Move detected");
+                        // fire move detector
+                        cogState.movementType = "move";
+                    }
+                }
+            }
+            return this.moveInProgress;
+            /*
+            if (this.sensorBundles.length === 0 || timestamp - this.lastTime > this.interval) {
+                // Check if we should reset based on time since last recorded shake
+                if (this.sensorBundles.length > 0 && (timestamp - this.sensorBundles[0].timestamp) > this.maxShakeDuration) {
+                    this.sensorBundles = []; // Reset the sensor data if the shakes are too far apart
+                }
+                this.sensorBundles.push({ xAcc, yAcc, zAcc, timestamp });
+                this.lastTime = timestamp;
+                this.performCheck();
+            }
+            */
+        }
+    };
+    ShakeDetector.prototype.performCheck = function (cogState) {
+        var _this = this;
+        var matrix = [
+            [0, 0],
+            [0, 0],
+            [0, 0] // Z axis positive and negative
+        ];
+        for (var _i = 0, _a = this.sensorBundles; _i < _a.length; _i++) {
+            var bundle = _a[_i];
+            this.updateAxis(0, bundle.x, matrix);
+            this.updateAxis(1, bundle.y, matrix);
+            this.updateAxis(2, bundle.z, matrix, -1);
+        }
+        // check if any of the negatives and the positives are greater than the threshold
+        var negativesTotal = matrix.reduce(function (acc, axis) { return acc + axis[1]; }, 0);
+        var positivesTotal = matrix.reduce(function (acc, axis) { return acc + axis[0]; }, 0);
+        if (matrix.some(function (axis) { return axis[0] >= _this.thresholdShakeNumber && axis[1] >= _this.thresholdShakeNumber; })) {
+            // if (positivesTotal >= this.thresholdShakeNumber && negativesTotal >= this.thresholdShakeNumber) {
+            if (Date.now() - this.lastTimeShakeDetected < this.coolOffPeriod) {
+                return;
+            }
+            this.lastTimeShakeDetected = Date.now();
+            // console.log("Shake detected!", JSON.stringify(matrix));
+            cogState.movementType = "shake";
+            this.sensorBundles = [];
+        }
+    };
+    ShakeDetector.prototype.updateAxis = function (index, acceleration, matrix, adjustment) {
+        if (adjustment === void 0) { adjustment = 0; }
+        var accelerationAdjusted = acceleration + adjustment;
+        if (accelerationAdjusted > this.thresholdAcceleration) {
+            matrix[index][0]++;
+            // console.log(JSON.stringify(matrix));
+        }
+        else if (accelerationAdjusted < -this.thresholdAcceleration) {
+            matrix[index][1]++;
+            // console.log(JSON.stringify(matrix));
+        }
+    };
+    return ShakeDetector;
+}());
+var ButtonClickDetection = /** @class */ (function () {
+    function ButtonClickDetection() {
+        /*
+        When the threshold is exceeded, the button is clicked, but we want to send the event when the button is released
+        so that the event is triggered only once.
+        */
+        this.clickThreshold = 1600;
+        this.releaseThreshold = 1590;
+        this.lastTime = 0;
+        this.buttonClicked = false;
+    }
+    ButtonClickDetection.prototype.detectButtonClick = function (buttonValue, cogState, cogVersion) {
+        var correctionCutOffVersion = "1.2.0";
+        var clickThreshold = 1600;
+        if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
+            clickThreshold = 1500;
+        }
+        var releaseThreshold = 1590;
+        if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
+            releaseThreshold = 1490;
+        }
+        this.clickThreshold = clickThreshold;
+        this.releaseThreshold = releaseThreshold;
+        var currentTime = Date.now();
+        if (buttonValue > this.clickThreshold && !this.buttonClicked) {
+            // console.log("Button clicked", buttonValue);
+            this.buttonClicked = true;
+            this.lastTime = currentTime;
+            cogState.buttonClick = true;
+        }
+        else if (buttonValue < this.releaseThreshold && this.buttonClicked) {
+            // console.log("Button released", buttonValue);
+            this.buttonClicked = false;
+            cogState.buttonClick = false;
+        }
+        // } else {
+        //     this.buttonClicked = false;
+        //     this.buttonReleaseCallback();
+        // }
+    };
+    return ButtonClickDetection;
+}());
+var ObjectSenseDetection = /** @class */ (function () {
+    function ObjectSenseDetection() {
+        this.objectSensed0Threshold = 2500; // left of the arrow
+        this.objectSensed1Threshold = 2500; // right of the arrow
+        this.objectSensed2Threshold = 1500; // button
+    }
+    ObjectSenseDetection.prototype.detectObjectSense = function (objectSenseValue, cogState) {
+        if (objectSenseValue[0] > this.objectSensed0Threshold) {
+            cogState.objectSense = "left";
+        }
+        else if (objectSenseValue[1] > this.objectSensed1Threshold) {
+            cogState.objectSense = "right";
+        }
+        else {
+            cogState.objectSense = false;
+        }
+    };
+    return ObjectSenseDetection;
+}());
+var LightSenseDetection = /** @class */ (function () {
+    function LightSenseDetection() {
+        this.lightSenseThreshold = 450;
+    }
+    LightSenseDetection.prototype.detectLightSense = function (lightSenseValue, cogState) {
+        if (lightSenseValue > this.lightSenseThreshold) {
+            cogState.lightSense = true;
+        }
+        else {
+            cogState.lightSense = false;
+        }
+    };
+    return LightSenseDetection;
+}());
+var IRMessageDetection = /** @class */ (function () {
+    function IRMessageDetection() {
+        this.irMessage0Threshold = 0;
+        this.irMessage1Threshold = 0;
+    }
+    IRMessageDetection.prototype.detectIRMessage = function (irMessageValue, cogState) {
+        // placeholder for now
+        if (irMessageValue[0] > this.irMessage0Threshold) {
+            cogState.irMessage = "left";
+        }
+        else if (irMessageValue[1] > this.irMessage1Threshold) {
+            cogState.irMessage = "right";
+        }
+        else {
+            cogState.irMessage = false;
+        }
+    };
+    return IRMessageDetection;
+}());
+var rotationDetection = new RotationDetection();
+var shakeDetector = new ShakeDetector();
+var buttonClickDetection = new ButtonClickDetection();
+var tiltDetection = new TiltDetection();
+var objectSenseDetection = new ObjectSenseDetection();
+var lightSenseDetection = new LightSenseDetection();
+var irMessageDetection = new IRMessageDetection();
+export default PublishedDataAnalyser;

package/dist-types/src/application/RAFTs/RAFT.js

@@ -38,7 +38,6 @@ import { AppSentMessage } from "../../types/communication-between-apps/wrapper-c
 import { RaftTypeE } from "../../types/raft";
 import { RaftInfoEvents } from "../../types/events/raft-info";
 import { RaftPublishEvent, } from "@robdobsn/raftjs";
-;
 var RAFT = /** @class */ (function () {
     function RAFT(id) {
         this.id = id;

package/dist-types/src/application/RAFTs/raft-subscription-helpers.d.ts

@@ -57,3 +57,7 @@ export declare const raftRejectedSubscriptionHelper: (raft: RAFT) => {
     subscribe: (callback: any) => void;
     unsubscribe: () => void;
 };
+export declare const raftPubSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: (eventData: any) => void) => void;
+    unsubscribe: () => void;
+};

package/dist-types/src/application/RAFTs/raft-subscription-helpers.js

@@ -322,3 +322,34 @@ var raftRejectedSubscriptionObserver_ = function (callback) {
         },
     };
 };
+export var raftPubSubscriptionHelper = function (raft) {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftPubSubscriptionObserver_(callback);
+            raft.subscribe(observer, ["raftinfo"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                raft.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftPubSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                case "raftinfo":
+                    switch (eventEnum) {
+                        case "STATE_INFO":
+                            callback(eventData);
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};

package/package.json

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