@robotical/webapp-types 0.6.58

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

@@ -0,0 +1,63 @@
+import RAFT from "./RAFT";
+/**
+ * Connection Verifying Subscription Helper
+ */
+export declare const raftConnectingSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * RAFT Connected Subscription Helper
+ */
+export declare const raftConnectedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * RAFT Disconnected Subscription Helper
+ */
+export declare const raftDisconnectedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * RAFT Verified Subscription Helper
+ */
+export declare const raftVerifiedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftFound event
+ * ApplicationManager
+ */
+export declare const raftFoundSubscriptionHelper: () => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftDiscoveryFinished event
+ */
+export declare const raftDiscoveryFinishedSubscriptionHelper: () => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftDiscoveryStarted event
+ */
+export declare const raftDiscoveryStartedSubscriptionHelper: () => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftRejected event
+ * This event is triggered when the RAFT is rejected during the verification process
+ */
+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

@@ -0,0 +1,355 @@
+import { RaftConnEvent } from "@robotical/raftjs";
+/**
+ * Connection Verifying Subscription Helper
+ */
+export var raftConnectingSubscriptionHelper = function (raft) {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftConnectingSubscriptionObserver_(callback);
+            raft.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                raft.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftConnectingSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                // case "conn":
+                //     switch (eventEnum) {
+                //         case RaftConnEvent.BLE_VERIFYING_CORRECT:
+                //             callback(eventData.bondingColors);
+                //             break;
+                //         default:
+                //             break;
+                //     }
+                //     break;
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.CONN_VERIFYING_CORRECT:
+                            callback(eventData);
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * RAFT Connected Subscription Helper
+ */
+export var raftConnectedSubscriptionHelper = function (raft) {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftConnectedSubscriptionObserver_(callback);
+            raft.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                raft.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftConnectedSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                // case "conn":
+                //     switch (eventEnum) {
+                //         case RaftConnEvent.BLE_CONNECTED:
+                //             console.log("Marty Connected!!!!!!!!!");
+                //             callback();
+                //             break;
+                //         default:
+                //             break;
+                //     }
+                //     break;
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.CONN_CONNECTED:
+                            console.log("Marty Connected!!!!!!!!!");
+                            callback();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * RAFT Disconnected Subscription Helper
+ */
+export var raftDisconnectedSubscriptionHelper = function (raft) {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftDisconnectedSubscriptionObserver_(callback);
+            raft.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                raft.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftDisconnectedSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                // case "conn":
+                //     switch (eventEnum) {
+                //         case RaftConnEvent.BLE_DISCONNECTED:
+                //             console.log("Marty Disconnected!!!!!!!!!");
+                //             callback();
+                //             break;
+                //         default:
+                //             break;
+                //     }
+                //     break;
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.CONN_DISCONNECTED:
+                            console.log("Marty Disconnected!!!!!!!!!");
+                            callback();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * RAFT Verified Subscription Helper
+ */
+export var raftVerifiedSubscriptionHelper = function (raft) {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftVerifiedSubscriptionObserver_(callback);
+            raft.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                raft.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftVerifiedSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                // case "conn":
+                //     switch (eventEnum) {
+                //         case RaftConnEvent.BLE_VERIFIED_CORRECT:
+                //             callback();
+                //             break;
+                //         default:
+                //             break;
+                //     }
+                //     break;
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.CONN_VERIFIED_CORRECT:
+                            callback();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * Subscription Helper for raftFound event
+ * ApplicationManager
+ */
+export var raftFoundSubscriptionHelper = function () {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftFoundSubscriptionObserver_(callback);
+            window.applicationManager.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                window.applicationManager.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftFoundSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.BLE_DEVICE_FOUND:
+                            callback(eventData);
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * Subscription Helper for raftDiscoveryFinished event
+ */
+export var raftDiscoveryFinishedSubscriptionHelper = function () {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftDiscoveryFinishedSubscriptionObserver_(callback);
+            window.applicationManager.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                window.applicationManager.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftDiscoveryFinishedSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.BLE_SCANNING_FINISHED:
+                            callback(eventData);
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * Subscription Helper for raftDiscoveryStarted event
+ */
+export var raftDiscoveryStartedSubscriptionHelper = function () {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftDiscoveryStartedSubscriptionObserver_(callback);
+            window.applicationManager.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                window.applicationManager.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftDiscoveryStartedSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.BLE_SCANNING_STARTED:
+                            callback(eventData);
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+/**
+ * Subscription Helper for raftRejected event
+ * This event is triggered when the RAFT is rejected during the verification process
+ */
+export var raftRejectedSubscriptionHelper = function (raft) {
+    var observer = null;
+    return {
+        subscribe: function (callback) {
+            observer = raftRejectedSubscriptionObserver_(callback);
+            raft.subscribe(observer, ["conn"]);
+        },
+        unsubscribe: function () {
+            if (observer) {
+                raft.unsubscribe(observer);
+            }
+        }
+    };
+};
+var raftRejectedSubscriptionObserver_ = function (callback) {
+    return {
+        notify: function (eventType, eventEnum, eventName, eventData) {
+            switch (eventType) {
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.CONN_REJECTED:
+                            callback();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                case "conn":
+                    switch (eventEnum) {
+                        case RaftConnEvent.CONN_REJECTED:
+                            callback();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        },
+    };
+};
+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/dist-types/src/application/communicators/SelfdestructiveMessagePromise.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+export default class SelfdestructiveMessagePromise {
+    resolve: (value?: any) => void;
+    reject: (reason?: any) => void;
+    timeout: NodeJS.Timeout;
+    TIMEOUT_PERIOD: number;
+    constructor(resolve: (value?: any) => void, reject: (reason?: any) => void, id: string, messagePromises: {
+        [key: string]: SelfdestructiveMessagePromise | undefined;
+    });
+}

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

@@ -0,0 +1,31 @@
+import Logger from "../../services/logger/Logger";
+var SHOW_LOGS = true;
+var TAG = "SelfdestructiveMessagePromise";
+var SelfdestructiveMessagePromise = /** @class */ (function () {
+    function SelfdestructiveMessagePromise(resolve, reject, id, messagePromises) {
+        var _this = this;
+        this.resolve = function () { };
+        this.reject = function () { };
+        this.TIMEOUT_PERIOD = 30000;
+        this.resolve = function (value) {
+            resolve(value);
+            clearTimeout(_this.timeout);
+            delete messagePromises[id];
+        };
+        this.reject = function (reason) {
+            resolve(reason); // on purpose resolving instead of rejecting
+            clearTimeout(_this.timeout);
+            delete messagePromises[id];
+        };
+        this.timeout = setTimeout(function () {
+            if (_this.reject) {
+                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);
+    }
+    return SelfdestructiveMessagePromise;
+}());
+export default SelfdestructiveMessagePromise;

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

@@ -0,0 +1,24 @@
+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
+     */
+    receiveMessage(receivedMessage: IWrapperSentMessage): void;
+    /**
+     * It sends a message to the phone app
+     * The client can await the response to that message
+     */
+    sendMessageAndWait<R>(message: AppSentMessage, data?: any): Promise<R>;
+    /**
+   * It sends a message to the wrapper app
+   * The wrapper cannot await the response to that message
+   */
+    sendMessageNoWait(message: AppSentMessage, data?: any): void;
+    /**
+     * Called by the react-native code to respond to sendMessage
+     */
+    onMessageResponse(response: WRAPPER_RESPONSE_BASE): void;
+}
+export default WrapperCommunicator;

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

@@ -0,0 +1,137 @@
+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 };
+    }
+};
+import Logger from "../../services/logger/Logger";
+import { 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";
+var SHOW_LOGS = true;
+var TAG = "WrapperAppCommunicator";
+var WrapperCommunicator = /** @class */ (function () {
+    function WrapperCommunicator() {
+        this.messagePromises = {};
+    }
+    /**
+     * Receives a message from the wrapper app
+     */
+    WrapperCommunicator.prototype.receiveMessage = function (receivedMessage) {
+        receivedMessageHandler(receivedMessage.message, receivedMessage.data, receivedMessage.messagePromiseId);
+    };
+    /**
+     * It sends a message to the phone app
+     * The client can await the response to that message
+     */
+    WrapperCommunicator.prototype.sendMessageAndWait = function (message, data) {
+        var _this = this;
+        var messagePromiseId = randomHashGenerator();
+        var promise = new Promise(function (resolve, reject) {
+            _this.messagePromises[messagePromiseId] = new SelfdestructiveMessagePromise(resolve, reject, messagePromiseId, _this.messagePromises);
+        });
+        var messageObject = {
+            message: message,
+            data: data,
+            messagePromiseId: messagePromiseId
+        };
+        var stringifiedMessage = JSON.stringify(messageObject);
+        if (isPhoneApp()) {
+            window.ReactNativeWebView.postMessage(stringifiedMessage);
+        }
+        else {
+            window.WebAppCommunicator.receiveMessage(stringifiedMessage);
+        }
+        return promise;
+    };
+    /**
+   * It sends a message to the wrapper app
+   * The wrapper cannot await the response to that message
+   */
+    WrapperCommunicator.prototype.sendMessageNoWait = function (message, data) {
+        // Logger.info(SHOW_LOGS, TAG, "Sending message without waiting: " + message);
+        var messagePromiseId = randomHashGenerator();
+        var messageObject = {
+            message: message,
+            data: data,
+            messagePromiseId: messagePromiseId
+        };
+        var stringifiedMessage = JSON.stringify(messageObject);
+        if (isPhoneApp()) {
+            window.ReactNativeWebView.postMessage(stringifiedMessage);
+        }
+        else {
+            window.WebAppCommunicator.receiveMessage(stringifiedMessage);
+        }
+    };
+    /**
+     * Called by the react-native code to respond to sendMessage
+     */
+    WrapperCommunicator.prototype.onMessageResponse = function (response) {
+        var _a, _b;
+        Logger.info(SHOW_LOGS, TAG, "Received message reply: " + JSON.stringify(response));
+        if (this.messagePromises[response.messagePromiseId]) {
+            if (response.success) {
+                (_a = this.messagePromises[response.messagePromiseId]) === null || _a === void 0 ? void 0 : _a.resolve(response.results);
+            }
+            else {
+                (_b = this.messagePromises[response.messagePromiseId]) === null || _b === void 0 ? void 0 : _b.reject(response.error);
+            }
+        }
+        else {
+            Logger.warn(SHOW_LOGS, TAG, "Unhandled message reply with id: ".concat(response.messagePromiseId));
+        }
+    };
+    return WrapperCommunicator;
+}());
+export { WrapperCommunicator };
+export default WrapperCommunicator;
+var receivedMessageHandler = function (receivedMessage, data, messagePromiseId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (data.eventName !== "StateInfo" && data.eventType !== "pub") {
+            Logger.info(SHOW_LOGS, TAG, "RAFT published event: ".concat(JSON.stringify(data)));
+        }
+        switch (receivedMessage) {
+            case WrapperSentMessage.RAFT_CONNECTED_RESULTS:
+                console.log("RAFT connected results");
+                break;
+            case WrapperSentMessage.RAFT_PUBLISHED_EVENT:
+                window.applicationManager.receivedRICEvent(data.raftId, data.eventType, data.eventEnum, data.eventName, data.eventData);
+                break;
+            default:
+                console.log("Unhandled message");
+        }
+        return [2 /*return*/];
+    });
+}); };

package/dist-types/src/components/disposables/LoadingSpinner/index.d.ts

@@ -0,0 +1,7 @@
+import "./styles.css";
+type LoadingSpinnerProps = {
+    colourA?: string;
+    colourB?: string;
+};
+export default function LoadingSpinner({ colourA, colourB, }: LoadingSpinnerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-types/src/components/disposables/LoadingSpinner/index.js

@@ -0,0 +1,29 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import "./styles.css";
+export default function LoadingSpinner(_a) {
+    var colourA = _a.colourA, colourB = _a.colourB;
+    var spinnerRef = useRef(null);
+    useEffect(function () {
+        if (spinnerRef.current) {
+            if (colourA) {
+                spinnerRef.current.style.setProperty("--border-colour", colourA);
+            }
+            if (colourB) {
+                spinnerRef.current.style.setProperty("--border-colour", colourB);
+            }
+        }
+    }, [spinnerRef.current]);
+    return (_jsx("div", __assign({ className: "loading-spinner-container" }, { children: _jsx("div", { className: "loading-spinner", ref: spinnerRef }) })));
+}

package/dist-types/src/components/disposables/buttons/SVGImageButton/index.d.ts

@@ -0,0 +1,14 @@
+import { FunctionComponent, SVGProps } from "react";
+import "./styles.css";
+type SVGImageButtonProps = {
+    onClick: () => void;
+    title: string;
+    subtitle?: string;
+    SVGImage: FunctionComponent<SVGProps<SVGSVGElement>>;
+    backgroundColour?: string;
+    titleColour?: string;
+    SVGColour?: string;
+    disabled?: boolean;
+};
+export default function SVGImageButton({ onClick, title, subtitle, SVGImage, backgroundColour, titleColour, SVGColour, disabled, }: SVGImageButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};