@robotical/webapp-types 3.18.13 → 3.19.1

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

@@ -1,19 +1,7 @@
-import { RaftOKFail, RaftWifiConnStatus, RaftWifiScanResults } from "@robdobsn/raftjs";
-import Marty from "./Marty";
-export declare class MartyWifiManager {
-    marty: Marty;
-    private _wifiConnStatus;
-    private _defaultWiFiHostname;
-    private _maxSecsToWaitForWiFiConn;
-    private _wifiScanDuration;
-    constructor(marty: Marty);
-    _getHostnameFromFriendlyName(): string;
-    wifiConnect(ssid: string, password: string): Promise<boolean>;
-    wifiDisconnect(): Promise<boolean>;
-    getWiFiConnStatus(): Promise<boolean | null>;
-    pauseWifiConnection(pause: boolean): Promise<boolean>;
-    _wifiScanResults(): Promise<boolean | RaftOKFail | RaftWifiScanResults>;
-    _wifiScanStart(): Promise<boolean>;
-    getCachedWifiStatus(): RaftWifiConnStatus;
-    getWifiScanResults(): Promise<boolean | RaftOKFail | RaftWifiScanResults>;
+import { RaftWifiManager } from "../RaftWifiManager";
+/**
+ * Compatibility alias for code that still imports the old Marty-specific
+ * manager. Wi-Fi provisioning now uses the common RAFT NetMan contract.
+ */
+export declare class MartyWifiManager extends RaftWifiManager {
 }

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

@@ -1,277 +1,28 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { RaftWifiManager } from "../RaftWifiManager";
+/**
+ * Compatibility alias for code that still imports the old Marty-specific
+ * manager. Wi-Fi provisioning now uses the common RAFT NetMan contract.
+ */
+var MartyWifiManager = /** @class */ (function (_super) {
+    __extends(MartyWifiManager, _super);
+    function MartyWifiManager() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-};
-import { RaftWifiConnState, RaftWifiConnStatus } from "@robdobsn/raftjs";
-import Logger from "../../../services/logger/Logger";
-var SHOW_LOGS = true;
-var TAG = "MartyWifiManager";
-var MartyWifiManager = /** @class */ (function () {
-    function MartyWifiManager(marty) {
-        this.marty = marty;
-        this._wifiConnStatus = new RaftWifiConnStatus();
-        this._defaultWiFiHostname = "Raft";
-        this._maxSecsToWaitForWiFiConn = 20;
-        this._wifiScanDuration = 10000; // ms
-        this.marty = marty;
-    }
-    MartyWifiManager.prototype._getHostnameFromFriendlyName = function () {
-        var friendlyName = this.marty.getFriendlyName();
-        if (!friendlyName) {
-            return this._defaultWiFiHostname;
-        }
-        var hostname = friendlyName;
-        hostname = hostname === null || hostname === void 0 ? void 0 : hostname.replace(/ /g, "-");
-        hostname = hostname.replace(/\W+/g, "");
-        return hostname;
-    };
-    MartyWifiManager.prototype.wifiConnect = function (ssid, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var RaftRESTURL_wifiCredentials, error_1, timeoutCount, connStat;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils Connect to WiFi ".concat(ssid, " password ").concat(password));
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        RaftRESTURL_wifiCredentials = "w/" +
-                            ssid +
-                            "/" +
-                            password +
-                            "/" +
-                            this._getHostnameFromFriendlyName();
-                        Logger.info(SHOW_LOGS, TAG, "wifiConnect attempting to connect to wifi ".concat(RaftRESTURL_wifiCredentials));
-                        return [4 /*yield*/, this.marty.sendRestMessage(RaftRESTURL_wifiCredentials)];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiConnect failed ".concat(error_1));
-                        return [2 /*return*/, false];
-                    case 4:
-                        timeoutCount = 0;
-                        _a.label = 5;
-                    case 5:
-                        if (!(timeoutCount < this._maxSecsToWaitForWiFiConn)) return [3 /*break*/, 9];
-                        // Wait a little before checking
-                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                    case 6:
-                        // Wait a little before checking
-                        _a.sent();
-                        return [4 /*yield*/, this.getWiFiConnStatus()];
-                    case 7:
-                        connStat = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiConnect connStat ".concat(connStat));
-                        if (connStat) {
-                            return [2 /*return*/, true];
-                        }
-                        _a.label = 8;
-                    case 8:
-                        timeoutCount++;
-                        return [3 /*break*/, 5];
-                    case 9: return [2 /*return*/, false];
-                }
-            });
-        });
-    };
-    MartyWifiManager.prototype.wifiDisconnect = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 4, , 5]);
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiDisconnect clearing wifi info");
-                        return [4 /*yield*/, this.marty.sendRestMessage("wc")];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 2000); })];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, this.getWiFiConnStatus()];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/, true];
-                    case 4:
-                        error_2 = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiDisconnect clearing unsuccessful ".concat(error_2));
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/, false];
-                }
-            });
-        });
-    };
-    MartyWifiManager.prototype.getWiFiConnStatus = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var ricSysModInfoWiFi, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.marty.sendRestMessage("sysmodinfo/NetMan")];
-                    case 1:
-                        ricSysModInfoWiFi = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "wifiConnStatus rslt ".concat(ricSysModInfoWiFi.rslt, " isConn ").concat(ricSysModInfoWiFi.isConn, " paused ").concat(ricSysModInfoWiFi.isPaused));
-                        // Check status indicates WiFi connected
-                        if (ricSysModInfoWiFi.rslt === "ok") {
-                            this._wifiConnStatus.connState =
-                                ricSysModInfoWiFi.isConn !== 0
-                                    ? RaftWifiConnState.WIFI_CONN_CONNECTED
-                                    : RaftWifiConnState.WIFI_CONN_NONE;
-                            this._wifiConnStatus.isPaused = ricSysModInfoWiFi.isPaused !== 0;
-                            this._wifiConnStatus.ipAddress = ricSysModInfoWiFi.IP;
-                            this._wifiConnStatus.hostname = ricSysModInfoWiFi.Hostname;
-                            this._wifiConnStatus.ssid = ricSysModInfoWiFi.SSID;
-                            this._wifiConnStatus.bssid = ricSysModInfoWiFi.WiFiMAC;
-                            this._wifiConnStatus.validMs = Date.now();
-                            return [2 /*return*/, (ricSysModInfoWiFi.isConn !== 0 || ricSysModInfoWiFi.isPaused !== 0)];
-                        }
-                        return [3 /*break*/, 3];
-                    case 2:
-                        error_3 = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "[DEBUG]: wifiConnStatus sysmodinfo failed ".concat(error_3));
-                        this._wifiConnStatus.validMs = 0;
-                        return [3 /*break*/, 3];
-                    case 3:
-                        this._wifiConnStatus.connState = RaftWifiConnState.WIFI_CONN_NONE;
-                        this._wifiConnStatus.isPaused = false;
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    MartyWifiManager.prototype.pauseWifiConnection = function (pause) {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_4;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        if (!pause) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.marty.sendRestMessage("wifipause/pause")];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.marty.sendRestMessage("wifipause/resume")];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4: return [2 /*return*/, true];
-                    case 5:
-                        error_4 = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiConnect wifi pause ".concat(error_4));
-                        return [2 /*return*/, false];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    MartyWifiManager.prototype._wifiScanResults = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                try {
-                    Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiScanResults");
-                    return [2 /*return*/, this.marty.sendRestMessage("wifiscan/results")];
-                }
-                catch (error) {
-                    Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils wifiScanResults unsuccessful ".concat(error));
-                }
-                return [2 /*return*/, false];
-            });
-        });
-    };
-    MartyWifiManager.prototype._wifiScanStart = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_5;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils _wifiScanStart");
-                        return [4 /*yield*/, this.marty.sendRestMessage("wifiscan/start")];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, true];
-                    case 2:
-                        error_5 = _a.sent();
-                        Logger.info(SHOW_LOGS, TAG, "RaftSystemUtils _wifiScanStart unsuccessful ".concat(error_5));
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/, false];
-                }
-            });
-        });
-    };
-    MartyWifiManager.prototype.getCachedWifiStatus = function () {
-        return this._wifiConnStatus;
-    };
-    MartyWifiManager.prototype.getWifiScanResults = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var resultsTimeout, results;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._wifiScanStart()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                return (resultsTimeout = setTimeout(function () {
-                                    _this._wifiScanResults()
-                                        .then(function (wifiscanMsgResults) {
-                                        if (typeof wifiscanMsgResults !== "boolean") {
-                                            resolve(wifiscanMsgResults);
-                                        }
-                                        else {
-                                            reject("Something went wrong");
-                                        }
-                                    })
-                                        .catch(function (err) { return reject(err); })
-                                        .finally(function () { return clearTimeout(resultsTimeout); });
-                                }, _this._wifiScanDuration));
-                            })];
-                    case 2:
-                        results = _a.sent();
-                        if (results.hasOwnProperty("wifi")) {
-                            return [2 /*return*/, results];
-                        }
-                        return [2 /*return*/, false];
-                }
-            });
-        });
-    };
     return MartyWifiManager;
-}());
+}(RaftWifiManager));
 export { MartyWifiManager };

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

@@ -1,5 +1,5 @@
 import type { RestMessageOptions } from "../../types/communication-between-apps/wrapper-communication";
-import { ConnectionAttemptResults, RaftConnectionMethod, RaftTypeE } from "../../types/raft";
+import { ConnectableRaftType, ConnectionAttemptResults, RaftConnectionMethod, RaftTypeE } from "../../types/raft";
 import { RaftInfoEvents } from "../../types/events/raft-info";
 import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
 import RICInterface from "./RAFTInterface";
@@ -18,6 +18,12 @@ export default class RAFT implements RICInterface {
     systemInfo: RaftSystemInfo | null;
     raftStateInfo: RICStateInfo | SimplifiedCogStateInfo | null;
     isVerified: boolean;
+    /**
+     * Transport metadata belongs to the host RAFT entity so every embedded
+     * platform sees the same connection, regardless of how it was established.
+     */
+    connectionMethod: RaftConnectionMethod | null;
+    connectionLocator: string;
     private _verificationDecision;
     hasVerifiedConnection(): boolean;
     /**
@@ -34,7 +40,7 @@ export default class RAFT implements RICInterface {
     * Connect to a RAFT
     * We first connect, then we discover the raft type, and then we create the appopriate raft instance
     */
-    static connect(method: RaftConnectionMethod, uuids: string[]): Promise<ConnectionAttemptResults>;
+    static connect(method: RaftConnectionMethod, uuids: string[], locator?: string, expectedRaftType?: ConnectableRaftType): Promise<ConnectionAttemptResults>;
     /**
      * Disconnect from a RAFT
      */

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

@@ -35,7 +35,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { AppSentMessage } from "../../types/communication-between-apps/wrapper-communication";
-import { RaftTypeE } from "../../types/raft";
+import { RaftTypeE, } from "../../types/raft";
 import { RaftInfoEvents } from "../../types/events/raft-info";
 import { RaftConnEvent, RaftPublishEvent, } from "@robdobsn/raftjs";
 import Logger from "../../services/logger/Logger";
@@ -58,6 +58,12 @@ var RAFT = /** @class */ (function () {
         // RAFT State Info
         this.raftStateInfo = null;
         this.isVerified = false;
+        /**
+         * Transport metadata belongs to the host RAFT entity so every embedded
+         * platform sees the same connection, regardless of how it was established.
+         */
+        this.connectionMethod = null;
+        this.connectionLocator = "";
         this._verificationDecision = null;
     }
     RAFT.prototype.hasVerifiedConnection = function () {
@@ -95,14 +101,27 @@ var RAFT = /** @class */ (function () {
     * Connect to a RAFT
     * We first connect, then we discover the raft type, and then we create the appopriate raft instance
     */
-    RAFT.connect = function (method, uuids) {
+    RAFT.connect = function (method, uuids, locator, expectedRaftType) {
+        if (locator === void 0) { locator = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var connectResults;
+            var request, connectResults;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_CONNECT, { method: method, uuids: uuids })];
+                    case 0:
+                        request = {
+                            method: method,
+                            locator: locator,
+                            uuids: uuids,
+                            expectedRaftType: expectedRaftType,
+                        };
+                        return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_CONNECT, request)];
                     case 1:
                         connectResults = _a.sent();
+                        if (!connectResults ||
+                            typeof connectResults !== "object" ||
+                            typeof connectResults.success !== "boolean") {
+                            throw new Error("The connection bridge did not return a valid result.");
+                        }
                         return [2 /*return*/, connectResults];
                 }
             });

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

@@ -0,0 +1,24 @@
+import { RaftOKFail, RaftWifiConnStatus, RaftWifiScanResults } from "@robdobsn/raftjs";
+import RAFT from "./RAFT";
+/**
+ * Wi-Fi provisioning is implemented by the common RAFT NetMan endpoints, so
+ * it is shared by Marty and Cog. The manager deliberately owns no transport:
+ * commands continue over the RAFT's current BLE or WebSocket connection.
+ */
+export declare class RaftWifiManager {
+    raft: RAFT;
+    private readonly _defaultWiFiHostname;
+    private _wifiConnStatus;
+    private readonly _maxSecsToWaitForWiFiConn;
+    private readonly _wifiScanDuration;
+    constructor(raft: RAFT, _defaultWiFiHostname?: string);
+    private _getHostnameFromFriendlyName;
+    wifiConnect(ssid: string, password: string): Promise<boolean>;
+    wifiDisconnect(): Promise<boolean>;
+    getWiFiConnStatus(): Promise<boolean | null>;
+    pauseWifiConnection(pause: boolean): Promise<boolean>;
+    private _wifiScanResults;
+    private _wifiScanStart;
+    getCachedWifiStatus(): RaftWifiConnStatus;
+    getWifiScanResults(): Promise<RaftOKFail | RaftWifiScanResults | false>;
+}