@neurosity/sdk 6.2.1-next.2 → 6.2.2

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

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseApp = exports.SERVER_TIMESTAMP = void 0;
+const app_1 = __importDefault(require("firebase/app"));
+require("firebase/database");
+require("firebase/auth");
+require("firebase/functions");
+require("firebase/firestore");
+const config_1 = require("./config");
+exports.SERVER_TIMESTAMP = app_1.default.database.ServerValue.TIMESTAMP;
+/**
+ * @hidden
+ */
+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 = app_1.default.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_1.config.databaseURL);
+        if (neurosityApp) {
+            return neurosityApp;
+        }
+        if (deviceId) {
+            const neurosityAppName = deviceId;
+            const neurosityApp = moduleApps.find((app) => app.name === neurosityAppName);
+            return neurosityApp
+                ? neurosityApp
+                : app_1.default.initializeApp(config_1.config, neurosityAppName);
+        }
+        return app_1.default.initializeApp(config_1.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();
+    }
+}
+exports.FirebaseApp = FirebaseApp;

package/dist/{api → cjs/api}/firebase/FirebaseDevice.d.ts

@@ -1,7 +1,7 @@
 import firebase from "firebase/app";
 import { FirebaseApp } from "./FirebaseApp";
 import { SDKDependencies } from "../../types/options";
-type FirebaseDeviceOptions = {
+declare type FirebaseDeviceOptions = {
     deviceId: string;
     firebaseApp: FirebaseApp;
     dependencies: SDKDependencies;

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

@@ -0,0 +1,146 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseDevice = void 0;
+const app_1 = __importDefault(require("firebase/app"));
+const deviceStore_1 = require("./deviceStore");
+const SERVER_TIMESTAMP = app_1.default.database.ServerValue.TIMESTAMP;
+/**
+ * @hidden
+ */
+class FirebaseDevice {
+    constructor({ deviceId, firebaseApp, dependencies }) {
+        if (!deviceId) {
+            throw new Error(`No Device ID provided.`);
+        }
+        this.deviceId = deviceId;
+        this.app = firebaseApp.app;
+        this.deviceStore = (0, deviceStore_1.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();
+    }
+}
+exports.FirebaseDevice = FirebaseDevice;
+FirebaseDevice.serverType = "firebase";

package/dist/cjs/api/firebase/FirebaseUser.js

@@ -0,0 +1,434 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseUser = exports.createUser = exports.credentialWithLink = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const app_1 = __importDefault(require("firebase/app"));
+const SERVER_TIMESTAMP = app_1.default.database.ServerValue.TIMESTAMP;
+/**
+ * @hidden
+ */
+exports.credentialWithLink = app_1.default.auth.EmailAuthProvider.credentialWithLink;
+/**
+ * @hidden
+ */
+function createUser(...args) {
+    return new app_1.default.User(...args);
+}
+exports.createUser = createUser;
+/**
+ * @hidden
+ */
+class FirebaseUser {
+    constructor(firebaseApp) {
+        this.app = firebaseApp.app;
+        this.app.auth().onAuthStateChanged((user) => {
+            this.user = user;
+        });
+    }
+    auth() {
+        return this.app.auth();
+    }
+    createAccount(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { email, password } = credentials;
+            const [error, user] = yield this.app
+                .auth()
+                .createUserWithEmailAndPassword(email, password)
+                .then((user) => [null, user])
+                .catch((error) => [error, null]);
+            if (error) {
+                return Promise.reject(error);
+            }
+            return user;
+        });
+    }
+    deleteAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = this.app.auth().currentUser;
+            if (!user) {
+                return Promise.reject(new Error(`You are trying to delete an account that is not authenticated. To delete an account, the account must have signed in recently.`));
+            }
+            const [devicesError, devices] = yield this.getDevices()
+                .then((response) => [null, response])
+                .catch((error) => [error, null]);
+            if (devicesError) {
+                return Promise.reject(devicesError);
+            }
+            if (devices.length) {
+                const removeDeviceError = yield Promise.all(devices.map((device) => this.removeDevice(device.deviceId)))
+                    .then(() => null)
+                    .catch((error) => error);
+                if (removeDeviceError) {
+                    return Promise.reject(removeDeviceError);
+                }
+            }
+            return user.delete();
+        });
+    }
+    onAuthStateChanged() {
+        return new rxjs_1.Observable((subscriber) => {
+            try {
+                this.app.auth().onAuthStateChanged((user) => {
+                    subscriber.next(user);
+                }, (error) => {
+                    subscriber.error(error);
+                });
+            }
+            catch (error) {
+                subscriber.error(error);
+            }
+        });
+    }
+    onLogin() {
+        return new rxjs_1.Observable((subscriber) => {
+            const unsubscribe = this.app
+                .auth()
+                .onAuthStateChanged((user) => {
+                if (!!user) {
+                    subscriber.next(user);
+                    subscriber.complete();
+                }
+            });
+            return () => unsubscribe();
+        });
+    }
+    login(credentials) {
+        if ("customToken" in credentials) {
+            const { customToken } = credentials;
+            return this.app.auth().signInWithCustomToken(customToken);
+        }
+        if ("idToken" in credentials && "providerId" in credentials) {
+            const provider = new app_1.default.auth.OAuthProvider(credentials.providerId);
+            const oAuthCredential = provider.credential(credentials.idToken);
+            return this.app.auth().signInWithCredential(oAuthCredential);
+        }
+        if ("email" in credentials && "password" in credentials) {
+            const { email, password } = credentials;
+            return this.app
+                .auth()
+                .signInWithEmailAndPassword(email, password);
+        }
+        throw new Error(`Either {email,password}, {customToken}, or {idToken,providerId} is required`);
+    }
+    logout() {
+        return this.app.auth().signOut();
+    }
+    createCustomToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [error, customToken] = yield this.app
+                .functions()
+                .httpsCallable("createCustomToken")()
+                .then(({ data }) => [null, data])
+                .catch((error) => [error, null]);
+            if (error) {
+                return Promise.reject(error);
+            }
+            return customToken;
+        });
+    }
+    removeOAuthAccess() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = (_a = this.user) === null || _a === void 0 ? void 0 : _a.uid;
+            if (!userId) {
+                return Promise.reject(`OAuth access can only be removed while logged in via OAuth.`);
+            }
+            const [error, response] = yield this.app
+                .functions()
+                .httpsCallable("removeAccessOAuthApp")()
+                .then(({ data }) => [null, data])
+                .catch((error) => [error, null]);
+            if (error) {
+                return Promise.reject(error);
+            }
+            const logoutError = yield this.logout()
+                .then(() => false)
+                .catch((error) => error);
+            if (logoutError) {
+                return Promise.reject(logoutError);
+            }
+            return response;
+        });
+    }
+    getDevices() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = (_a = this.user) === null || _a === void 0 ? void 0 : _a.uid;
+            if (!userId) {
+                return Promise.reject(`Please login.`);
+            }
+            const snapshot = yield this.app
+                .database()
+                .ref(this.getUserDevicesPath())
+                .once("value");
+            const userDevices = snapshot.val();
+            return this.userDevicesToDeviceInfoList(userDevices);
+        });
+    }
+    addDevice(deviceId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = (_a = this.user) === null || _a === void 0 ? void 0 : _a.uid;
+            if (!userId) {
+                return Promise.reject(`Please login.`);
+            }
+            const devices = yield this.getDevices().catch((error) => {
+                console.log(error);
+            });
+            const deviceAlreadyInAccount = devices &&
+                devices.length &&
+                devices.map(({ deviceId }) => deviceId).includes(deviceId);
+            if (deviceAlreadyInAccount) {
+                return Promise.reject(`The device is already added to this account.`);
+            }
+            const [isValid, invalidErrorMessage] = yield this.isDeviceIdValid(deviceId)
+                .then((isValid) => [isValid])
+                .catch((error) => [false, error]);
+            if (!isValid) {
+                return Promise.reject(invalidErrorMessage);
+            }
+            const claimedByPath = this.getDeviceClaimedByPath(deviceId);
+            const userDevicePath = this.getUserClaimedDevicePath(deviceId);
+            const [hasError, errorMessage] = yield this.app
+                .database()
+                .ref()
+                .update({
+                [claimedByPath]: userId,
+                [userDevicePath]: {
+                    claimedOn: SERVER_TIMESTAMP
+                }
+            })
+                .then(() => [false])
+                .catch((error) => [true, error]);
+            if (hasError) {
+                return Promise.reject(errorMessage);
+            }
+        });
+    }
+    removeDevice(deviceId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = (_a = this.user) === null || _a === void 0 ? void 0 : _a.uid;
+            if (!userId) {
+                return Promise.reject(`Please login.`);
+            }
+            const claimedByPath = this.getDeviceClaimedByPath(deviceId);
+            const userDevicePath = this.getUserClaimedDevicePath(deviceId);
+            const claimedByRef = this.app.database().ref(claimedByPath);
+            const userDeviceRef = this.app.database().ref(userDevicePath);
+            const [hasError, errorMessage] = yield Promise.all([
+                claimedByRef.remove(),
+                userDeviceRef.remove()
+            ])
+                .then(() => [false])
+                .catch((error) => [true, error]);
+            if (hasError) {
+                return Promise.reject(errorMessage);
+            }
+        });
+    }
+    transferDevice(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = (_a = this.user) === null || _a === void 0 ? void 0 : _a.uid;
+            if (!userId) {
+                return Promise.reject(new Error(`transferDevice: auth is required.`));
+            }
+            if (!("recipientsEmail" in options) &&
+                !("recipientsUserId" in options)) {
+                return Promise.reject(new Error(`transferDevice: either 'recipientsEmail' or 'recipientsUserId' key is required.`));
+            }
+            if (!(options === null || options === void 0 ? void 0 : options.deviceId)) {
+                return Promise.reject(new Error(`transferDevice: a deviceId is required.`));
+            }
+            const [error, response] = yield this.app
+                .functions()
+                .httpsCallable("transferDeviceOwnership")(options)
+                .then(({ data }) => [null, data])
+                .catch((error) => [error, null]);
+            if (error) {
+                return Promise.reject(error);
+            }
+        });
+    }
+    isDeviceIdValid(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // hex string of 32 characters
+            const hexRegEx = /[0-9A-Fa-f]{32}/g;
+            if (!deviceId ||
+                deviceId.length !== 32 ||
+                !hexRegEx.test(deviceId)) {
+                return Promise.reject("The device id is incorrectly formatted.");
+            }
+            const claimedByPath = this.getDeviceClaimedByPath(deviceId);
+            const claimedByRef = this.app.database().ref(claimedByPath);
+            const claimedBySnapshot = yield claimedByRef
+                .once("value")
+                .catch(() => null);
+            if (!claimedBySnapshot || claimedBySnapshot.exists()) {
+                return Promise.reject("The device has already been claimed.");
+            }
+            return true;
+        });
+    }
+    onUserDevicesChange() {
+        return this.onAuthStateChanged().pipe((0, operators_1.switchMap)((user) => {
+            if (!user) {
+                return rxjs_1.EMPTY;
+            }
+            const userDevicesPath = this.getUserDevicesPath();
+            const userDevicesRef = this.app.database().ref(userDevicesPath);
+            return (0, rxjs_1.fromEventPattern)((handler) => userDevicesRef.on("value", handler), (handler) => userDevicesRef.off("value", handler)).pipe((0, operators_1.map)(([snapshot]) => snapshot.val()), (0, operators_1.switchMap)((userDevices) => {
+                return (0, rxjs_1.from)(this.userDevicesToDeviceInfoList(userDevices));
+            }));
+        }));
+    }
+    onUserClaimsChange() {
+        return this.onAuthStateChanged().pipe((0, operators_1.switchMap)((user) => {
+            if (!user) {
+                return rxjs_1.EMPTY;
+            }
+            const claimsUpdatedOnPath = this.getUserClaimsUpdatedOnPath();
+            const claimsUpdatedOnRef = this.app
+                .database()
+                .ref(claimsUpdatedOnPath);
+            return (0, rxjs_1.fromEventPattern)((handler) => claimsUpdatedOnRef.on("value", handler), (handler) => claimsUpdatedOnRef.off("value", handler)).pipe((0, operators_1.map)(([snapshot]) => snapshot.val()), (0, operators_1.switchMap)(() => {
+                // Force refresh of auth id token
+                return (0, rxjs_1.from)(this.getIdToken(true)).pipe((0, operators_1.switchMap)(() => (0, rxjs_1.from)(this.getClaims())));
+            }));
+        }));
+    }
+    getIdToken(forceRefresh = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = (_a = this.app.auth()) === null || _a === void 0 ? void 0 : _a.currentUser;
+            if (!user) {
+                return Promise.reject(`getUserIdToken: unable to get currentUser`);
+            }
+            yield user.getIdToken(forceRefresh).catch((error) => {
+                console.error(error);
+            });
+        });
+    }
+    getClaims() {
+        var _a;
+        const user = (_a = this.app.auth()) === null || _a === void 0 ? void 0 : _a.currentUser;
+        if (!user) {
+            return Promise.reject(`getUserClaims: unable to get currentUser`);
+        }
+        return user
+            .getIdTokenResult()
+            .then((token) => token.claims)
+            .catch((error) => {
+            console.error(error);
+            return null;
+        });
+    }
+    userDevicesToDeviceInfoList(userDevices) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devicesInfoSnapshots = Object.keys(userDevices !== null && userDevices !== void 0 ? userDevices : {}).map((deviceId) => this.app
+                .database()
+                .ref(this.getDeviceInfoPath(deviceId))
+                .once("value"));
+            const devicesList = yield Promise.all(devicesInfoSnapshots).then((snapshots) => snapshots.map((snapshot) => snapshot.val()));
+            const validDevices = devicesList.filter((device) => !!device);
+            validDevices.sort((a, b) => {
+                return (userDevices[a.deviceId].claimedOn -
+                    userDevices[b.deviceId].claimedOn);
+            });
+            return validDevices;
+        });
+    }
+    hasDevicePermission(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceInfoPath = this.getDeviceInfoPath(deviceId);
+            const hasPermission = yield this.app
+                .database()
+                .ref(deviceInfoPath)
+                .once("value")
+                .then(() => true)
+                .catch(() => false);
+            return hasPermission;
+        });
+    }
+    getDeviceClaimedByPath(deviceId) {
+        return `devices/${deviceId}/status/claimedBy`;
+    }
+    getUserClaimedDevicePath(deviceId) {
+        const userId = this.user.uid;
+        return `users/${userId}/devices/${deviceId}`;
+    }
+    getUserDevicesPath() {
+        const userId = this.user.uid;
+        return `users/${userId}/devices`;
+    }
+    getUserClaimsUpdatedOnPath() {
+        const userId = this.user.uid;
+        return `users/${userId}/claimsUpdatedOn`;
+    }
+    getDeviceInfoPath(deviceId) {
+        return `devices/${deviceId}/info`;
+    }
+    onUserExperiments() {
+        return this.onAuthStateChanged().pipe((0, operators_1.switchMap)((user) => {
+            if (!user) {
+                return rxjs_1.EMPTY;
+            }
+            const userId = this.user.uid;
+            const userExperimentsRef = this.app
+                .database()
+                .ref("experiments")
+                .orderByChild("userId")
+                .equalTo(userId)
+                .limitToFirst(100);
+            return (0, rxjs_1.fromEventPattern)((handler) => userExperimentsRef.on("value", handler), (handler) => userExperimentsRef.off("value", handler)).pipe((0, operators_1.map)(([snapshot]) => snapshot.val()), 
+            // transform experiments map into sorted list
+            (0, operators_1.map)((experimentsMaps) => {
+                return Object.entries(experimentsMaps !== null && experimentsMaps !== void 0 ? experimentsMaps : {})
+                    .map(([id, value]) => {
+                    var _a;
+                    return (Object.assign({ id: (_a = value === null || value === void 0 ? void 0 : value.id) !== null && _a !== void 0 ? _a : id }, value));
+                })
+                    .sort((a, b) => new Date(b === null || b === void 0 ? void 0 : b.timestamp).getTime() -
+                    new Date(a === null || a === void 0 ? void 0 : a.timestamp).getTime());
+            }));
+        }));
+    }
+    deleteUserExperiment(experimentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!experimentId) {
+                return Promise.reject(`deleteUserExperiment: please provide an experiment id`);
+            }
+            const removeExperiment = (experimentId) => {
+                return this.app
+                    .database()
+                    .ref("experiments")
+                    .child(experimentId)
+                    .remove();
+            };
+            const removeRelations = (experimentId) => {
+                return this.app.functions().httpsCallable("removeRelations")({
+                    experimentId
+                });
+            };
+            yield Promise.all([
+                removeExperiment(experimentId),
+                removeRelations(experimentId)
+            ]).catch(() => { });
+        });
+    }
+}
+exports.FirebaseUser = FirebaseUser;

package/dist/cjs/api/firebase/config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.config = {
+    apiKey: "AIzaSyB0TkZ83Fj0CIzn8AAmE-Osc92s3ER8hy8",
+    authDomain: "neurosity-device.firebaseapp.com",
+    databaseURL: "https://neurosity-device.firebaseio.com",
+    projectId: "neurosity-device",
+    storageBucket: "neurosity-device.appspot.com",
+    messagingSenderId: "212595049674"
+};