@robotical/webapp-types 3.18.1 → 3.18.3

package/dist-types/src/application/ApplicationManager/ApplicationManager.d.ts

@@ -14,6 +14,7 @@ import AnalyticsFacade from "@robotical/appv2-analytics-gatherer";
 import { CarouselNavigatorManager } from "../../utils/CarouselNavigatorManager";
 import { CustomBluetoothItem, UserDeviceInfo } from "../../types/userDeviceInfo";
 import { UserRoleContextTypes } from "../../store/user-role-context";
+type ConnectResultDisposition = "commit" | "release" | "ignore";
 export default class ApplicationManager {
     selectedLocale: string;
     AnalyticsFacade: typeof AnalyticsFacade;
@@ -97,6 +98,7 @@ export default class ApplicationManager {
     private _clearConnectPromise;
     private _dismissConnectAttempt;
     private _isConnectAttemptActive;
+    private _getConnectResultDisposition;
     private _createConnectingModal;
     private _connectGeneric;
     /**
@@ -108,7 +110,7 @@ export default class ApplicationManager {
      * Selects a RAFT in Phone's verification modal
      */
     selectRaft(ricToConnectTo: FOUND_RAFT_ON_DISCOVERY_RESPONSE['foundRIC'], method: RaftConnectionMethod): Promise<RAFT | null>;
-    connectToRIC(method: RaftConnectionMethod, uuids: string[], withoutVerification?: boolean): Promise<RAFT | null>;
+    connectToRIC(method: RaftConnectionMethod, uuids: string[], withoutVerification?: boolean, getResultDisposition?: () => ConnectResultDisposition): Promise<RAFT | null>;
     /**
      * Warranty Service bluetooth scan for device
      * It scans for a device and gets the device object
@@ -187,3 +189,4 @@ export default class ApplicationManager {
     injectJS(jsCode: string): Promise<unknown>;
     getTheCurrentlySelectedDeviceOrFirstOfItsKind(deviceType: RaftTypeE): RAFT | undefined;
 }
+export {};

package/dist-types/src/application/ApplicationManager/ApplicationManager.js

@@ -546,6 +546,16 @@ var ApplicationManager = /** @class */ (function () {
     ApplicationManager.prototype._isConnectAttemptActive = function (connectAttemptId) {
         return this._activeConnectAttemptId === connectAttemptId;
     };
+    ApplicationManager.prototype._getConnectResultDisposition = function (connectAttemptId) {
+        if (this._isConnectAttemptActive(connectAttemptId)) {
+            return "commit";
+        }
+        // A newer app attempt shares WrapperAppManager's in-flight Bluetooth
+        // result. Let that current consumer commit it instead of tearing down the
+        // transport underneath it. With no replacement consumer, Dismiss means
+        // the late success must be fully released.
+        return this._activeConnectAttemptId === null ? "release" : "ignore";
+    };
     ApplicationManager.prototype._createConnectingModal = function (connectAttemptId) {
         var _this = this;
         return createElement(ConnectingLoadingSpinnerModal, {
@@ -633,7 +643,7 @@ var ApplicationManager = /** @class */ (function () {
                         _a.label = 11;
                     case 11:
                         _a.trys.push([11, 16, , 17]);
-                        return [4 /*yield*/, window.applicationManager.connectToRIC(RaftConnectionMethod.WEB_BLE, uuids, isQRVerification)];
+                        return [4 /*yield*/, window.applicationManager.connectToRIC(RaftConnectionMethod.WEB_BLE, uuids, isQRVerification, function () { return _this._getConnectResultDisposition(connectAttemptId); })];
                     case 12:
                         newRaft = _a.sent();
                         if (!this._isConnectAttemptActive(connectAttemptId)) {
@@ -767,21 +777,31 @@ var ApplicationManager = /** @class */ (function () {
             });
         });
     };
-    ApplicationManager.prototype.connectToRIC = function (method, uuids, withoutVerification) {
+    ApplicationManager.prototype.connectToRIC = function (method, uuids, withoutVerification, getResultDisposition) {
         var _a, _b, _c, _d;
+        if (getResultDisposition === void 0) { getResultDisposition = function () { return "commit"; }; }
         return __awaiter(this, void 0, void 0, function () {
-            var wasConnectedObj, raftId, raftType, raft;
+            var wasConnectedObj, raftId, raftType, resultDisposition, raft;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0: return [4 /*yield*/, RAFT.connect(method, uuids)];
                     case 1:
                         wasConnectedObj = _e.sent();
-                        if (!wasConnectedObj.success) return [3 /*break*/, 4];
+                        if (!wasConnectedObj.success) return [3 /*break*/, 7];
                         raftId = (_a = wasConnectedObj.data) === null || _a === void 0 ? void 0 : _a.raftId;
                         raftType = (_b = wasConnectedObj.data) === null || _b === void 0 ? void 0 : _b.raftType;
                         if (!raftId || !raftType) {
                             throw new Error("RAFT ID or RAFT Type is missing: ".concat(raftId, " ").concat(raftType));
                         }
+                        resultDisposition = getResultDisposition();
+                        if (!(resultDisposition !== "commit")) return [3 /*break*/, 4];
+                        if (!(resultDisposition === "release")) return [3 /*break*/, 3];
+                        return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_DISCONNECT, { raftId: raftId })];
+                    case 2:
+                        _e.sent();
+                        _e.label = 3;
+                    case 3: return [2 /*return*/, null];
+                    case 4:
                         raft = void 0;
                         switch (raftType) {
                             case RaftTypeE.MARTY:
@@ -799,23 +819,23 @@ var ApplicationManager = /** @class */ (function () {
                         }
                         // get missed Connect event
                         publishMissedConnectionEvent(raftId);
-                        if (!!((_d = wasConnectedObj.data) === null || _d === void 0 ? void 0 : _d.systemInfo)) return [3 /*break*/, 3];
+                        if (!!((_d = wasConnectedObj.data) === null || _d === void 0 ? void 0 : _d.systemInfo)) return [3 /*break*/, 6];
                         return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 200); })];
-                    case 2:
+                    case 5:
                         _e.sent();
-                        _e.label = 3;
-                    case 3:
+                        _e.label = 6;
+                    case 6:
                         // start LED verification process
                         if (!withoutVerification) {
                             modalState.setModal(createElement(VerificationModal, { connectedRAFT_: raft }), i18n.t("connection.looking_for_raft", { raftType: raft.type }), false);
                         }
                         return [2 /*return*/, raft];
-                    case 4:
+                    case 7:
                         if (wasConnectedObj.reason === 'unplugged') {
                             modalState.setModal(createElement(InUnpluggedModalContent), i18n.t("calibration_screen.colour_calibration.unplugged_modal_title"));
                         }
-                        _e.label = 5;
-                    case 5: return [2 /*return*/, null];
+                        _e.label = 8;
+                    case 8: return [2 /*return*/, null];
                 }
             });
         });
@@ -1113,12 +1133,21 @@ var ApplicationManager = /** @class */ (function () {
         }
     };
     ApplicationManager.prototype.receivedRICEvent = function (raftId, eventType, eventEnum, eventName, eventData) {
-        var _a;
         if (raftId === "scanner") {
             this.publish(eventType, eventEnum, eventName, eventData);
         }
         else {
-            (_a = this.connectedRafts[raftId]) === null || _a === void 0 ? void 0 : _a.receivedRICEvent(eventType, eventEnum, eventName, eventData);
+            var raft = this.connectedRafts[raftId];
+            if (!raft) {
+                return;
+            }
+            var isTerminalDisconnectEvent = eventType === "conn" && (eventEnum === RaftConnEvent.CONN_REJECTED ||
+                eventEnum === RaftConnEvent.CONN_DISCONNECTED);
+            if (this._disconnectPromises.has(raft) && !isTerminalDisconnectEvent) {
+                Logger.info(SHOW_LOGS, TAG, "Ignoring ".concat(eventName, " after disconnect started for ").concat(raftId));
+                return;
+            }
+            raft.receivedRICEvent(eventType, eventEnum, eventName, eventData);
         }
     };
     //======================//

package/dist-types/src/application/communicators/SelfdestructiveMessagePromise.d.ts

@@ -2,9 +2,8 @@
 export default class SelfdestructiveMessagePromise {
     resolve: (value?: any) => void;
     reject: (reason?: any) => void;
-    timeout: NodeJS.Timeout;
-    TIMEOUT_PERIOD: number;
+    timeout?: NodeJS.Timeout;
     constructor(resolve: (value?: any) => void, reject: (reason?: any) => void, id: string, messagePromises: {
         [key: string]: SelfdestructiveMessagePromise | undefined;
-    });
+    }, timeoutPeriod?: number | null);
 }

package/dist-types/src/application/communicators/SelfdestructiveMessagePromise.js

@@ -2,29 +2,29 @@ import Logger from "../../services/logger/Logger";
 var SHOW_LOGS = true;
 var TAG = "SelfdestructiveMessagePromise";
 var SelfdestructiveMessagePromise = /** @class */ (function () {
-    function SelfdestructiveMessagePromise(resolve, reject, id, messagePromises) {
+    function SelfdestructiveMessagePromise(resolve, reject, id, messagePromises, timeoutPeriod) {
+        if (timeoutPeriod === void 0) { timeoutPeriod = 30000; }
         var _this = this;
         this.resolve = function () { };
         this.reject = function () { };
-        this.TIMEOUT_PERIOD = 30000;
         this.resolve = function (value) {
             resolve(value);
-            clearTimeout(_this.timeout);
+            if (_this.timeout)
+                clearTimeout(_this.timeout);
             delete messagePromises[id];
         };
         this.reject = function (reason) {
             resolve(reason); // on purpose resolving instead of rejecting
-            clearTimeout(_this.timeout);
+            if (_this.timeout)
+                clearTimeout(_this.timeout);
             delete messagePromises[id];
         };
-        this.timeout = setTimeout(function () {
-            if (_this.reject) {
+        if (timeoutPeriod !== null) {
+            this.timeout = setTimeout(function () {
                 Logger.warn(SHOW_LOGS, TAG, "Timeout for message promise with id: ".concat(id));
                 _this.reject({ error: "Timeout" });
-                delete messagePromises[id];
-            }
-            clearTimeout(_this.timeout);
-        }, this.TIMEOUT_PERIOD);
+            }, timeoutPeriod);
+        }
     }
     return SelfdestructiveMessagePromise;
 }());

package/dist-types/src/application/communicators/WrapperCommunicator.d.ts

@@ -1,7 +1,6 @@
 import { AppSentMessage, IWrapperSentMessage, WRAPPER_RESPONSE_BASE } from "../../types/communication-between-apps/wrapper-communication";
 export declare class WrapperCommunicator {
     private messagePromises;
-    constructor();
     /**
      * Receives a message from the wrapper app
      */

package/dist-types/src/application/communicators/WrapperCommunicator.js

@@ -35,7 +35,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import Logger from "../../services/logger/Logger";
-import { WrapperSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+import { AppSentMessage, WrapperSentMessage } from "../../types/communication-between-apps/wrapper-communication";
 import randomHashGenerator from "../../utils/helpers/randomHashGenerator";
 import isPhoneApp from "../../utils/phone-app-communication/is-phone-app";
 import SelfdestructiveMessagePromise from "./SelfdestructiveMessagePromise";
@@ -59,7 +59,11 @@ var WrapperCommunicator = /** @class */ (function () {
         var _this = this;
         var messagePromiseId = randomHashGenerator();
         var promise = new Promise(function (resolve, reject) {
-            _this.messagePromises[messagePromiseId] = new SelfdestructiveMessagePromise(resolve, reject, messagePromiseId, _this.messagePromises);
+            _this.messagePromises[messagePromiseId] = new SelfdestructiveMessagePromise(resolve, reject, messagePromiseId, _this.messagePromises, 
+            // Choosing a physical Bluetooth device is user-mediated and has no
+            // application-safe deadline. The connecting modal owns cancellation;
+            // timing this bridge request out would orphan a later chooser result.
+            message === AppSentMessage.RAFT_CONNECT ? null : undefined);
         });
         var messageObject = {
             message: message,

package/dist-types/src/store/SelectedRaftContext.d.ts

@@ -8,6 +8,7 @@ export type ConnectedRaftItem = {
     type: RaftTypeE;
     isSelected: boolean;
 };
+export declare const removeConnectedRaftFromList: (connectedRafts: ConnectedRaftItem[], connectedRaftId: string) => ConnectedRaftItem[];
 export declare const ConnectedRaftContentProvider: ({ children }: {
     children: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist-types/src/store/SelectedRaftContext.js

@@ -25,6 +25,18 @@ export var NewRobotIdE;
 (function (NewRobotIdE) {
     NewRobotIdE["NEW"] = "=+__new__+=";
 })(NewRobotIdE || (NewRobotIdE = {}));
+export var removeConnectedRaftFromList = function (connectedRafts, connectedRaftId) {
+    var removedRaftWasSelected = connectedRafts.some(function (connectedRaft) {
+        return connectedRaft.id === connectedRaftId && connectedRaft.isSelected;
+    });
+    var remainingRafts = connectedRafts.filter(function (connectedRaft) { return connectedRaft.id !== connectedRaftId; });
+    if (!removedRaftWasSelected) {
+        return remainingRafts;
+    }
+    var fallbackRaft = remainingRafts.find(function (connectedRaft) { return connectedRaft.id !== NewRobotIdE.NEW; }) ||
+        remainingRafts[0];
+    return remainingRafts.map(function (connectedRaft) { return (__assign(__assign({}, connectedRaft), { isSelected: connectedRaft.id === (fallbackRaft === null || fallbackRaft === void 0 ? void 0 : fallbackRaft.id) })); });
+};
 var ConnectedRaftContext = createContext({
     nameUpdatedState: 0,
     connectedRafts: [],
@@ -59,17 +71,9 @@ export var ConnectedRaftContentProvider = function (_a) {
         setConnectedRafts(function (prev) { return __spreadArray(__spreadArray([], prev, true), [connectedRaft], false); });
     };
     var removeConnectedRaft = function (connectedRaftId) {
-        // if the removed raft is selected, filter it out and then select the first raft in the list
-        var selectedRaft = connectedRafts.find(function (connectedRaft) { return connectedRaft.isSelected; });
-        if ((selectedRaft === null || selectedRaft === void 0 ? void 0 : selectedRaft.id) === connectedRaftId) {
-            setConnectedRafts(function (prev) { return prev
-                .filter(function (connectedRaft) { return connectedRaft.id !== connectedRaftId; })
-                .map(function (connectedRaft, index) { return (__assign(__assign({}, connectedRaft), { isSelected: index === 1 })); }); });
-        }
-        else {
-            // otherwise just filter out the raft
-            setConnectedRafts(function (prev) { return prev.filter(function (connectedRaft) { return connectedRaft.id !== connectedRaftId; }); });
-        }
+        setConnectedRafts(function (prev) {
+            return removeConnectedRaftFromList(prev, connectedRaftId);
+        });
     };
     var setSelectedRaft = function (connectedRaftId) {
         // deselect the previously selected raft
@@ -95,7 +99,7 @@ export var ConnectedRaftContentProvider = function (_a) {
         }
         tryAttach();
         return function () { handle && clearTimeout(handle); };
-    }, [addConnectedRaft, removeConnectedRaft, setSelectedRaft, nameUpdated]);
+    }, [addConnectedRaft, removeConnectedRaft, getSelectedRaft, setSelectedRaft, nameUpdated]);
     return (_jsx(ConnectedRaftContext.Provider, __assign({ value: { connectedRafts: connectedRafts, addConnectedRaft: addConnectedRaft, removeConnectedRaft: removeConnectedRaft, setSelectedRaft: setSelectedRaft, getSelectedRaft: getSelectedRaft, nameUpdated: nameUpdated, nameUpdatedState: nameUpdatedState } }, { children: children })));
 };
 export var useConnectedRafts = function () { return useContext(ConnectedRaftContext); };

package/dist-types/src/wrapper-app/WrapperAppManager.js

@@ -273,9 +273,10 @@ var WrapperAppManager = /** @class */ (function () {
      * Re-triggers the connect event which was missed due to the connection logic
      */
     WrapperAppManager.prototype.getMissedConnEvent = function (raftId) {
-        if (this.connectors[raftId]) {
-            this.connectors[raftId].eventHandler("conn", RaftConnEvent.CONN_CONNECTED, "connect", {});
-            this.connectors[raftId].publish("conn", RaftConnEvent.CONN_CONNECTED, "connect", {});
+        var connector = this.connectors[raftId];
+        if (connector === null || connector === void 0 ? void 0 : connector.shouldHandleEvent("conn", RaftConnEvent.CONN_CONNECTED)) {
+            connector.eventHandler("conn", RaftConnEvent.CONN_CONNECTED, "connect", {});
+            connector.publish("conn", RaftConnEvent.CONN_CONNECTED, "connect", {});
         }
     };
     /**
@@ -283,6 +284,7 @@ var WrapperAppManager = /** @class */ (function () {
      */
     WrapperAppManager.prototype.confirmVerifiedRaft = function (raftId) {
         return __awaiter(this, void 0, void 0, function () {
+            var connector;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -290,10 +292,14 @@ var WrapperAppManager = /** @class */ (function () {
                             Logger.warn(SHOW_LOGS, TAG, "confirmVerifiedRaft: No connector found for raftId: ".concat(raftId));
                             return [2 /*return*/, false];
                         }
-                        return [4 /*yield*/, this.connectors[raftId].eventHandler("conn", RaftConnEvent.CONN_VERIFIED_CORRECT, "VERIFIED_CORRECT", {})];
+                        connector = this.connectors[raftId];
+                        if (!connector.shouldHandleEvent("conn", RaftConnEvent.CONN_VERIFIED_CORRECT)) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, connector.eventHandler("conn", RaftConnEvent.CONN_VERIFIED_CORRECT, "VERIFIED_CORRECT", {})];
                     case 1:
                         _a.sent();
-                        this.connectors[raftId].publish("conn", RaftConnEvent.CONN_VERIFIED_CORRECT, "VERIFIED_CORRECT", {});
+                        connector.publish("conn", RaftConnEvent.CONN_VERIFIED_CORRECT, "VERIFIED_CORRECT", {});
                         return [2 /*return*/, true];
                 }
             });
@@ -378,6 +384,7 @@ var WrapperAppManager = /** @class */ (function () {
         if ((inFlightDisconnect === null || inFlightDisconnect === void 0 ? void 0 : inFlightDisconnect.connector) === connector) {
             return inFlightDisconnect.promise;
         }
+        connector.beginDisconnect();
         var operation = Promise.resolve().then(function () { return connector.disconnect(); });
         var disconnectPromise;
         disconnectPromise = operation.finally(function () {

package/dist-types/src/wrapper-app/connectors/Connector.d.ts

@@ -12,6 +12,7 @@ declare class Connector implements ConnectorInterface {
         [key: string]: Array<RaftObserver>;
     };
     private _onDisconnected?;
+    private _disconnectStarted;
     connManager: ConnManager;
     constructor(id: string, connManager: ConnManager);
     /**
@@ -38,6 +39,17 @@ declare class Connector implements ConnectorInterface {
      * Disconnect from a RAFT
      */
     disconnect(): Promise<boolean>;
+    /**
+     * Marks this connector as teardown-owned before asynchronous disconnect work
+     * can yield. Late nonterminal callbacks must not revive application state or
+     * install listeners while the connector is going away.
+     */
+    beginDisconnect(): void;
+    /**
+     * Rejection and disconnection are terminal lifecycle notifications and must
+     * still propagate while teardown is pending. All other late events are stale.
+     */
+    shouldHandleEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent): boolean;
     /**
      * Register the manager-owned cleanup callback for a terminal disconnect event.
      */

package/dist-types/src/wrapper-app/connectors/Connector.js

@@ -60,11 +60,16 @@ var Connector = /** @class */ (function () {
         // RAFT
         // Observers
         this._observers = {};
+        this._disconnectStarted = false;
         this.connManager = connManager;
         // Set the listener function
         // Subscribe to connManager events
         this.connManager.setConnectionEventListener(function (eventType, eventEnum, eventName, eventData) {
             var _a;
+            if (!_this.shouldHandleEvent(eventType, eventEnum)) {
+                Logger.info(SHOW_LOGS, TAG, "Ignoring ".concat(eventName, " after disconnect started for ").concat(_this.id));
+                return;
+            }
             if (eventType === "pub") {
                 // if it's a pub event, we are publishing it from _pubEventHandler method (in child classes)
             }
@@ -151,9 +156,10 @@ var Connector = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: 
-                    // this.sendRestMessage('blerestart');
-                    return [4 /*yield*/, this.connManager.disconnect()];
+                    case 0:
+                        this.beginDisconnect();
+                        // this.sendRestMessage('blerestart');
+                        return [4 /*yield*/, this.connManager.disconnect()];
                     case 1:
                         // this.sendRestMessage('blerestart');
                         _a.sent();
@@ -162,6 +168,25 @@ var Connector = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Marks this connector as teardown-owned before asynchronous disconnect work
+     * can yield. Late nonterminal callbacks must not revive application state or
+     * install listeners while the connector is going away.
+     */
+    Connector.prototype.beginDisconnect = function () {
+        this._disconnectStarted = true;
+    };
+    /**
+     * Rejection and disconnection are terminal lifecycle notifications and must
+     * still propagate while teardown is pending. All other late events are stale.
+     */
+    Connector.prototype.shouldHandleEvent = function (eventType, eventEnum) {
+        if (!this._disconnectStarted) {
+            return true;
+        }
+        return eventType === "conn" && (eventEnum === RaftConnEvent.CONN_REJECTED ||
+            eventEnum === RaftConnEvent.CONN_DISCONNECTED);
+    };
     /**
      * Register the manager-owned cleanup callback for a terminal disconnect event.
      */
@@ -175,6 +200,7 @@ var Connector = /** @class */ (function () {
      * RoboticalJS package while the new ConnManager API is being released.
      */
     Connector.prototype.disconnectForPageUnload = function () {
+        this.beginDisconnect();
         var connManagerWithPageUnload = this.connManager;
         if (typeof connManagerWithPageUnload.disconnectForPageUnload === "function") {
             connManagerWithPageUnload.disconnectForPageUnload();

package/package.json

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