@neurosity/sdk 6.0.0-next.11

package/dist/esm/api/firebase/FirebaseApp.js

@@ -0,0 +1,63 @@
+import firebase from "firebase/app";
+import "firebase/database";
+import "firebase/auth";
+import "firebase/functions";
+import "firebase/firestore";
+import { config } from "./config";
+export const SERVER_TIMESTAMP = firebase.database.ServerValue.TIMESTAMP;
+/**
+ * @hidden
+ */
+export class FirebaseApp {
+    constructor(options) {
+        this.app = this.getApp(options.deviceId);
+        this.standalone = this.app.name === options.deviceId;
+        if (options.emulator) {
+            this.connectEmulators(options);
+        }
+    }
+    getApp(deviceId) {
+        const moduleApps = firebase.apps;
+        const browserApps = typeof window !== "undefined" &&
+            "firebase" in window &&
+            "apps" in window.firebase
+            ? window["firebase"]["apps"]
+            : [];
+        const neurosityApp = [...moduleApps, ...browserApps].find((app) => app.name === "[DEFAULT]" &&
+            app.options.databaseURL === config.databaseURL);
+        if (neurosityApp) {
+            return neurosityApp;
+        }
+        if (deviceId) {
+            const neurosityAppName = deviceId;
+            const neurosityApp = moduleApps.find((app) => app.name === neurosityAppName);
+            return neurosityApp
+                ? neurosityApp
+                : firebase.initializeApp(config, neurosityAppName);
+        }
+        return firebase.initializeApp(config);
+    }
+    connectEmulators(options) {
+        const { emulatorHost, emulatorAuthPort, emulatorDatabasePort, emulatorFunctionsPort, emulatorFirestorePort, emulatorOptions } = options;
+        this.app.auth().useEmulator(`http://${emulatorHost}:${emulatorAuthPort}`);
+        this.app
+            .database()
+            .useEmulator(emulatorHost, emulatorDatabasePort, emulatorOptions);
+        this.app.functions().useEmulator(emulatorHost, emulatorFunctionsPort);
+        this.app
+            .firestore()
+            .useEmulator(emulatorHost, emulatorFirestorePort, emulatorOptions);
+    }
+    goOnline() {
+        this.app.database().goOnline();
+    }
+    goOffline() {
+        this.app.database().goOffline();
+    }
+    disconnect() {
+        if (this.standalone) {
+            return this.app.delete();
+        }
+        return Promise.resolve();
+    }
+}

package/dist/esm/api/firebase/FirebaseDevice.d.ts

@@ -0,0 +1,68 @@
+import firebase from "firebase/app";
+import { FirebaseApp } from "./FirebaseApp";
+import { SDKDependencies } from "../../types/options";
+declare type FirebaseDeviceOptions = {
+    deviceId: string;
+    firebaseApp: FirebaseApp;
+    dependencies: SDKDependencies;
+};
+/**
+ * @hidden
+ */
+export declare class FirebaseDevice {
+    static serverType: string;
+    protected app: firebase.app.App;
+    protected deviceStore: any;
+    deviceId: string;
+    constructor({ deviceId, firebaseApp, dependencies }: FirebaseDeviceOptions);
+    get timestamp(): any;
+    dispatchAction(action: any): Promise<any>;
+    getInfo(): Promise<any>;
+    onNamespace(namespace: string, callback: Function): Function;
+    onceNamespace(namespace: string): Promise<any>;
+    offNamespace(namespace: string, listener: Function): void;
+    getTimesync(): Promise<number>;
+    /**
+     * Pushes metric for each subscriptions in path:
+     * /devices/:deviceId/metrics/:metricName
+     */
+    nextMetric(metricName: string, metricValue: {
+        [label: string]: any;
+    }): void;
+    /**
+     * Listens for metrics in path:
+     * /devices/:deviceId/metrics/:metricName
+     */
+    onMetric(subscription: any, callback: any): Function;
+    /**
+     * Creates a new and unique subscription in path:
+     * /devices/:deviceId/subscriptions/:subscriptionId
+     * E.g. /devices/device1/subscriptions/subscription3
+     *
+     * @param subscription
+     * @returns subscriptionId
+     */
+    subscribeToMetric(subscription: any): any;
+    /**
+     * Removes subscription in path:
+     * /devices/:deviceId/subscriptions/:subscriptionId
+     *
+     * @param subscription
+     */
+    unsubscribeFromMetric(subscription: any): void;
+    /**
+     * Removes metric listener
+     * /devices/:deviceId/metric
+     * or
+     * /devices/:deviceId/metric/label
+     *
+     * @param subscription
+     * @param listener
+     */
+    removeMetricListener(subscription: any, listener: Function): void;
+    changeSettings(settings: any): Promise<void>;
+    getSkill(bundleId: any): Promise<any>;
+    createBluetoothToken(): Promise<string>;
+    disconnect(): void;
+}
+export {};

package/dist/esm/api/firebase/FirebaseDevice.js

@@ -0,0 +1,139 @@
+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());
+    });
+};
+import firebase from "firebase/app";
+import { createDeviceStore } from "./deviceStore";
+const SERVER_TIMESTAMP = firebase.database.ServerValue.TIMESTAMP;
+/**
+ * @hidden
+ */
+export class FirebaseDevice {
+    constructor({ deviceId, firebaseApp, dependencies }) {
+        if (!deviceId) {
+            throw new Error(`No Device ID provided.`);
+        }
+        this.deviceId = deviceId;
+        this.app = firebaseApp.app;
+        this.deviceStore = createDeviceStore(this.app, deviceId, dependencies.subscriptionManager);
+    }
+    get timestamp() {
+        return SERVER_TIMESTAMP;
+    }
+    dispatchAction(action) {
+        return this.deviceStore.dispatchAction(action);
+    }
+    getInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.deviceStore.once("info");
+        });
+    }
+    onNamespace(namespace, callback) {
+        return this.deviceStore.onNamespace(namespace, callback);
+    }
+    onceNamespace(namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.deviceStore.once(namespace);
+        });
+    }
+    offNamespace(namespace, listener) {
+        this.deviceStore.offNamespace(namespace, listener);
+    }
+    getTimesync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.dispatchAction({
+                command: "timesync",
+                action: "get",
+                responseRequired: true,
+                responseTimeout: 250
+            });
+            return response.timestamp;
+        });
+    }
+    /**
+     * Pushes metric for each subscriptions in path:
+     * /devices/:deviceId/metrics/:metricName
+     */
+    nextMetric(metricName, metricValue) {
+        this.deviceStore.nextMetric(metricName, metricValue);
+    }
+    /**
+     * Listens for metrics in path:
+     * /devices/:deviceId/metrics/:metricName
+     */
+    onMetric(subscription, callback) {
+        return this.deviceStore.onMetric(subscription, callback);
+    }
+    /**
+     * Creates a new and unique subscription in path:
+     * /devices/:deviceId/subscriptions/:subscriptionId
+     * E.g. /devices/device1/subscriptions/subscription3
+     *
+     * @param subscription
+     * @returns subscriptionId
+     */
+    subscribeToMetric(subscription) {
+        const subscriptionId = this.deviceStore.subscribeToMetric(Object.assign(Object.assign({}, subscription), { serverType: FirebaseDevice.serverType // @deprecated
+         }));
+        return subscriptionId;
+    }
+    /**
+     * Removes subscription in path:
+     * /devices/:deviceId/subscriptions/:subscriptionId
+     *
+     * @param subscription
+     */
+    unsubscribeFromMetric(subscription) {
+        this.deviceStore.unsubscribeFromMetric(subscription);
+    }
+    /**
+     * Removes metric listener
+     * /devices/:deviceId/metric
+     * or
+     * /devices/:deviceId/metric/label
+     *
+     * @param subscription
+     * @param listener
+     */
+    removeMetricListener(subscription, listener) {
+        this.deviceStore.removeMetricListener(subscription, listener);
+    }
+    changeSettings(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.deviceStore.update("settings", settings);
+        });
+    }
+    getSkill(bundleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.deviceStore.lastOfChildValue("skills", "bundleId", bundleId);
+        });
+    }
+    createBluetoothToken() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const [error, token] = yield this.app
+                .functions()
+                .httpsCallable("createBluetoothToken")({
+                deviceId: this.deviceId
+            })
+                .then(({ data }) => [null, data === null || data === void 0 ? void 0 : data.token])
+                .catch((error) => [error, null]);
+            if (error) {
+                return Promise.reject((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error);
+            }
+            if (!token) {
+                return Promise.reject(`Failed to create Bluetooth token.`);
+            }
+            return token;
+        });
+    }
+    disconnect() {
+        this.deviceStore.disconnect();
+    }
+}
+FirebaseDevice.serverType = "firebase";

package/dist/esm/api/firebase/FirebaseUser.d.ts

@@ -0,0 +1,53 @@
+import { Observable } from "rxjs";
+import firebase from "firebase/app";
+import { User } from "@firebase/auth-types";
+import { FirebaseApp } from "./FirebaseApp";
+import { Credentials, EmailAndPassword, CustomToken } from "../../types/credentials";
+import { UserClaims } from "../../types/user";
+import { DeviceInfo } from "../../types/deviceInfo";
+import { OAuthRemoveResponse } from "../../types/oauth";
+import { Experiment } from "../../types/experiment";
+import { TransferDeviceOptions } from "../../utils/transferDevice";
+/**
+ * @hidden
+ */
+export declare const credentialWithLink: Function;
+/**
+ * @hidden
+ */
+export declare function createUser(...args: any[]): any;
+/**
+ * @hidden
+ */
+export declare class FirebaseUser {
+    app: firebase.app.App;
+    user: User | null;
+    constructor(firebaseApp: FirebaseApp);
+    auth(): firebase.auth.Auth;
+    createAccount(credentials: EmailAndPassword): Promise<any>;
+    deleteAccount(): Promise<void>;
+    onAuthStateChanged(): Observable<User | null>;
+    onLogin(): Observable<User>;
+    login(credentials: Credentials): Promise<firebase.auth.UserCredential>;
+    logout(): Promise<void>;
+    createCustomToken(): Promise<CustomToken>;
+    removeOAuthAccess(): Promise<OAuthRemoveResponse>;
+    getDevices(): Promise<DeviceInfo[]>;
+    addDevice(deviceId: string): Promise<void>;
+    removeDevice(deviceId: string): Promise<void>;
+    transferDevice(options: TransferDeviceOptions): Promise<void>;
+    isDeviceIdValid(deviceId: string): Promise<boolean>;
+    onUserDevicesChange(): Observable<DeviceInfo[]>;
+    onUserClaimsChange(): Observable<UserClaims>;
+    getIdToken(forceRefresh?: boolean): Promise<void>;
+    getClaims(): Promise<UserClaims>;
+    private userDevicesToDeviceInfoList;
+    hasDevicePermission(deviceId: string): Promise<boolean>;
+    private getDeviceClaimedByPath;
+    private getUserClaimedDevicePath;
+    private getUserDevicesPath;
+    private getUserClaimsUpdatedOnPath;
+    private getDeviceInfoPath;
+    onUserExperiments(): Observable<Experiment[]>;
+    deleteUserExperiment(experimentId: string): Promise<void>;
+}