@robotical/webapp-types 0.6.58

package/application-manager.ts

@@ -0,0 +1,20 @@
+/**
+ * This file is needed so we can build and publish the ApplicationManager interface to the children projects
+ */
+import ApplicationManager from "../src/application/ApplicationManager/ApplicationManager";
+import WrapperCommunicator from "../src/application/communicators/WrapperCommunicator";
+import Logger from "../src/services/logger/Logger";
+import WebAppCommunicator from "../src/wrapper-app/communicators/WebAppCommunicator";
+
+export { ApplicationManager }
+
+declare global {
+    interface Window {
+        ReactNativeWebView: any;
+        // marty: Marty;
+        WebAppCommunicator: WebAppCommunicator;
+        wrapperCommunicator: WrapperCommunicator;
+        applicationManager: ApplicationManager;
+        Logger: Logger;
+    }
+}

package/dist-types/src/analytics/AnalyticsManager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AnalyticsManager
+ *
+ * This class is responsible for managing the analytics services for the testing phase.
+ * Analytics gathered:
+ * - Connections
+ * - Disconnections
+ * - Visited pages
+ * - emoji feedback
+ * - text feedback
+ *
+ * Each of them will be stored as an event. They will stored in the order they were received so we can track the user's journey.
+ * There will be a timestamp for each event.
+ *
+ * We store client's id in a cookie so we can track the user's journey.
+ */
+type EventType = "connection" | "disconnection" | "page" | "emojifeedback" | "textfeedback" | "connection_issue" | "connection_issue_resolved";
+export declare class AnalyticsManager {
+    private static instance;
+    private clientId;
+    private eventsStorer;
+    private constructor();
+    static getInstance(): AnalyticsManager;
+    private getClientId;
+    private generateClientId;
+    logEvent(eventType: EventType, data: any): void;
+}
+export {};

package/dist-types/src/analytics/AnalyticsManager.js

@@ -0,0 +1,171 @@
+/**
+ * AnalyticsManager
+ *
+ * This class is responsible for managing the analytics services for the testing phase.
+ * Analytics gathered:
+ * - Connections
+ * - Disconnections
+ * - Visited pages
+ * - emoji feedback
+ * - text feedback
+ *
+ * Each of them will be stored as an event. They will stored in the order they were received so we can track the user's journey.
+ * There will be a timestamp for each event.
+ *
+ * We store client's id in a cookie so we can track the user's journey.
+ */
+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);
+};
+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 AnalyticsManager = /** @class */ (function () {
+    function AnalyticsManager() {
+        this.clientId = this.getClientId();
+        this.eventsStorer = new EventsStorer(this.clientId);
+    }
+    AnalyticsManager.getInstance = function () {
+        if (!AnalyticsManager.instance) {
+            AnalyticsManager.instance = new AnalyticsManager();
+        }
+        return AnalyticsManager.instance;
+    };
+    AnalyticsManager.prototype.getClientId = function () {
+        var clientId = localStorage.getItem('@robotical/webapp/analytics/clientId');
+        if (!clientId) {
+            clientId = this.generateClientId();
+            localStorage.setItem('@robotical/webapp/analytics/clientId', clientId);
+        }
+        return clientId;
+    };
+    AnalyticsManager.prototype.generateClientId = function () {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    };
+    AnalyticsManager.prototype.logEvent = function (eventType, data) {
+        var event = new AnalyticsEvent(eventType, data);
+        this.eventsStorer.addEvent(event);
+    };
+    return AnalyticsManager;
+}());
+export { AnalyticsManager };
+var AnalyticsEvent = /** @class */ (function () {
+    function AnalyticsEvent(type, data) {
+        this.type = type;
+        this.data = data;
+        this.isProcessed = false;
+        this.timestamp = new Date().toString();
+        this.urlSafeTimestamp = new Date().toISOString().replaceAll("T", "_").replaceAll(":", "-").replaceAll("/", "-").replaceAll(".", "_");
+    }
+    AnalyticsEvent.prototype.process = function () {
+        this.isProcessed = true;
+    };
+    return AnalyticsEvent;
+}());
+var EventsStorer = /** @class */ (function () {
+    function EventsStorer(clientId) {
+        this.clientId = clientId;
+        this.events = [];
+        this.processing = false;
+    }
+    EventsStorer.prototype.addEvent = function (event) {
+        this.events.push(event);
+        this._processEvents();
+    };
+    EventsStorer.prototype._processEvents = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, event_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.processing)
+                            return [2 /*return*/];
+                        this.processing = true;
+                        _i = 0, _a = this.events;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        event_1 = _a[_i];
+                        if (!!event_1.isProcessed) return [3 /*break*/, 3];
+                        this._processEvent(event_1);
+                        return [4 /*yield*/, this._delay(1000)];
+                    case 2:
+                        _b.sent(); // 1 second debounce time
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        this.processing = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EventsStorer.prototype._delay = function (ms) {
+        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+    };
+    EventsStorer.prototype._processEvent = function (event) {
+        event.process();
+        var data = __assign(__assign(__assign({}, event), event.data), { data: undefined, isProcessed: undefined, urlSafeTimestamp: undefined });
+        var path = "".concat(this.clientId, "/").concat(event.urlSafeTimestamp, "-").concat(event.type);
+        FirebaseInteractor.put(path, data);
+    };
+    return EventsStorer;
+}());
+var FirebaseInteractor = /** @class */ (function () {
+    function FirebaseInteractor() {
+    }
+    FirebaseInteractor.put = function (path, data) {
+        fetch("".concat(this.db_href, "/").concat(path, ".json"), {
+            method: 'PUT',
+            body: JSON.stringify(data),
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    };
+    FirebaseInteractor.db_href = "https://app-v2-analytics-default-rtdb.firebaseio.com";
+    return FirebaseInteractor;
+}());

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

@@ -0,0 +1,117 @@
+import { RaftConnectionMethod, RaftTypeE } from "../../types/raft";
+import WebAppCommunicator from "../../wrapper-app/communicators/WebAppCommunicator";
+import RAFT from "../RAFTs/RAFT";
+import Marty from "../RAFTs/Marty/Marty";
+import Cog from "../RAFTs/Cog/Cog";
+import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
+import { RaftObserver } from "../RAFTs/RaftObserver";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robotical/raftjs";
+import { ConnectedRaftItem } from "../../store/SelectedRaftContext";
+import Toaster from "../../utils/Toaster";
+import { AnalyticsManager } from "../../analytics/AnalyticsManager";
+export default class ApplicationManager {
+    private _observers;
+    static wrapperAppCommunicator: WebAppCommunicator;
+    connectedRafts: {
+        [key: string]: RAFT;
+    };
+    connectedRaftsContext: ConnectedRaftItem[];
+    returnToMainApp: () => void;
+    private _router;
+    setRouter(router: any): void;
+    navigateTo(path: string): void;
+    ricSelectedCb: ((raft: RAFT) => void) | null;
+    toaster: typeof Toaster;
+    analyticsManager: AnalyticsManager;
+    showBackHomeButton: () => void;
+    hideBackHomeButton: () => void;
+    connectedRaftContextMethods: {
+        addConnectedRaft: (connectedRaft: ConnectedRaftItem) => void;
+        removeConnectedRaft: (connectedRaftId: string) => void;
+        setSelectedRaft: (connectedRaftId: string) => void;
+    };
+    isPhoneApp: () => boolean;
+    constructor();
+    createNewCog(id: string): Cog;
+    createNewMarty(id: string): Marty;
+    connectGenericMarty(afterRaftConnectedCb: (raft: RAFT) => void): Promise<void>;
+    connectGenericCog(afterRaftConnectedCb: (raft: RAFT) => void): Promise<void>;
+    /**
+     * Generic Connect method
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     * Known issue: connecting to a raft from within a platform won't add the newly connected raft to the connectedRafts hook
+     */
+    connectGeneric(afterRaftConnectedCb: (raft: RAFT) => void, uuids?: string[]): Promise<void>;
+    /**
+     * Disconnect from RAFT generic
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     */
+    disconnectGeneric(raft: RAFT, afterRaftDisconnectedCb?: () => void): Promise<void>;
+    /**
+     * 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[]): Promise<RAFT | null>;
+    /**
+     * Toggles the Sensors Dashboard modal
+     */
+    toggleSensorsDashboard(): void;
+    /**
+     * Disconnect from RAFT
+     */
+    disconnectFromRaft(raftId: string): Promise<void>;
+    /**
+     * Removes raft after a certain time
+     * Removes from the rics list after x seconds so that we can still get the last event
+     */
+    _removeRaft(raftId: string, timeout: number): void;
+    /**
+     * Start looking for rics to connect to
+     * This is used from the Phone App only
+     */
+    startDiscovery(ricSelectedCb: (raft: RAFT) => void, uuids: string[]): Promise<void>;
+    /**
+     * Stοp discovery
+     * When the user cancels the discovery process without having first connected to a robot
+     */
+    stopDiscovery(): Promise<void>;
+    /**
+     * Stop verifying raft
+     */
+    stopVerifyingRaft(raftId: string, isCorrectRIC: boolean): Promise<void>;
+    /**
+     * Publishing events to observers
+     * It could be either events we get from RAFT, or custom events related to the app
+     */
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    subscribe(observer: RaftObserver, topics: Array<string>): void;
+    unsubscribe(observer: RaftObserver): void;
+    receivedRICEvent(raftId: string, eventType: any, eventEnum: any, eventName: any, eventData: any): void;
+    /**
+     * Save the file on the device
+     */
+    saveFileOnDevice(fileName: string, base64: string): void | Promise<unknown>;
+    /**
+     * Save the file on the device's local storage
+     */
+    saveFileOnDeviceLocalStorage(dirname: string, fileName: string, base64: string): void | Promise<unknown>;
+    /**
+     * Load the file from the device's local storage
+     */
+    loadFileFromDeviceLocalStorage(dirname: string, fileName: string): void | Promise<unknown>;
+    /**
+     * Delete the file from the device's local storage
+     */
+    deleteFileFromDeviceLocalStorage(dirname: string, fileName: string): void | Promise<unknown>;
+    /**
+     * List the files from the device's local storage
+     */
+    listFilesFromDeviceLocalStorage(dirname: string): Promise<unknown>;
+    /**
+     * Injects JS code to the phone app
+     * This is used to call native functions from the web app
+     */
+    injectJS(jsCode: string): Promise<unknown>;
+    getTheCurrentlySelectedDeviceOrFirstOfItsKind(deviceType: RaftTypeE): RAFT | undefined;
+}