@neurosity/sdk 6.0.0-next.11

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FirebaseApp"), exports);
+__exportStar(require("./FirebaseUser"), exports);
+__exportStar(require("./FirebaseDevice"), exports);

package/dist/cjs/api/https/config.d.ts

@@ -0,0 +1 @@
+export declare const prodFunctionsBaseUrl = "https://us-central1-neurosity-device.cloudfunctions.net";

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prodFunctionsBaseUrl = void 0;
+exports.prodFunctionsBaseUrl = "https://us-central1-neurosity-device.cloudfunctions.net";

package/dist/cjs/api/https/createOAuthURL.d.ts

@@ -0,0 +1,3 @@
+import { SDKOptions } from "../../types/options";
+import { OAuthConfig } from "../../types/oauth";
+export declare function createOAuthURL(config: OAuthConfig, sdkOptions: SDKOptions): Promise<string>;

package/dist/cjs/api/https/createOAuthURL.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOAuthURL = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+function createOAuthURL(config, sdkOptions) {
+    const { clientId, clientSecret, responseType, redirectUri, scope, state } = config;
+    const baseUrl = (0, utils_1.getFunctionsBaseURL)(sdkOptions);
+    return axios_1.default
+        .get(`${baseUrl}/authorize/entry`, {
+        params: Object.assign(Object.assign({ client_id: clientId }, (clientSecret ? { client_secret: clientSecret } : {})), { response_type: responseType, redirect_uri: redirectUri, scope: scope.join(","), state: state, redirect: "false" })
+    })
+        .then((response) => `${baseUrl}${response.data.url}`);
+}
+exports.createOAuthURL = createOAuthURL;

package/dist/cjs/api/https/getOAuthToken.d.ts

@@ -0,0 +1,3 @@
+import { SDKOptions } from "../../types/options";
+import { OAuthQuery, OAuthQueryResult } from "../../types/oauth";
+export declare function getOAuthToken(query: OAuthQuery, sdkOptions: SDKOptions): Promise<OAuthQueryResult>;

package/dist/cjs/api/https/getOAuthToken.js

@@ -0,0 +1,34 @@
+"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.getOAuthToken = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+function getOAuthToken(query, sdkOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const baseUrl = (0, utils_1.getFunctionsBaseURL)(sdkOptions);
+        // Get refresh token
+        const refreshResponse = yield axios_1.default.post(`${baseUrl}/getOAuthRefreshToken`, query);
+        const refreshToken = refreshResponse.data;
+        return axios_1.default
+            .post(`${baseUrl}/token`, {
+            grant_type: "refresh_token",
+            refresh_token: refreshToken.data,
+            client_id: query.clientId,
+            client_secret: query.clientSecret
+        })
+            .then((response) => JSON.parse(response.data)["access_token"]);
+    });
+}
+exports.getOAuthToken = getOAuthToken;

package/dist/cjs/api/https/utils.d.ts

@@ -0,0 +1,2 @@
+import { SDKOptions } from "../../types/options";
+export declare function getFunctionsBaseURL(sdkOptions: SDKOptions): string;

package/dist/cjs/api/https/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionsBaseURL = void 0;
+const config_1 = require("./config");
+function getFunctionsBaseURL(sdkOptions) {
+    if (!sdkOptions.emulator) {
+        return config_1.prodFunctionsBaseUrl;
+    }
+    const { emulatorHost, emulatorFunctionsPort } = sdkOptions;
+    const emulatorFunctionsBaseUrl = `http://${emulatorHost}:${emulatorFunctionsPort}/neurosity-device/us-central1`;
+    return emulatorFunctionsBaseUrl;
+}
+exports.getFunctionsBaseURL = getFunctionsBaseURL;

package/dist/cjs/api/index.d.ts

@@ -0,0 +1,108 @@
+import { Observable } from "rxjs";
+import { FirebaseApp, FirebaseUser, FirebaseDevice } from "./firebase";
+import { Timesync } from "../timesync";
+import { SubscriptionManager } from "../subscriptions/SubscriptionManager";
+import { Client } from "../types/client";
+import { Action, Actions } from "../types/actions";
+import { Metrics } from "../types/metrics";
+import { SDKOptions } from "../types/options";
+import { SkillsClient } from "../types/skill";
+import { Credentials, CustomToken } from "../types/credentials";
+import { EmailAndPassword } from "../types/credentials";
+import { ChangeSettings } from "../types/settings";
+import { DeviceStatus } from "../types/status";
+import { DeviceInfo, DeviceSelector } from "../types/deviceInfo";
+import { UserClaims } from "../types/user";
+import { OAuthRemoveResponse } from "../types/oauth";
+import { Experiment } from "../types/experiment";
+import { TransferDeviceOptions } from "../utils/transferDevice";
+export { credentialWithLink, createUser, SERVER_TIMESTAMP } from "./firebase";
+/**
+ * @hidden
+ */
+export declare class CloudClient implements Client {
+    user: any;
+    userClaims: any;
+    protected options: SDKOptions;
+    protected firebaseApp: FirebaseApp;
+    protected firebaseUser: FirebaseUser;
+    protected firebaseDevice: FirebaseDevice;
+    protected timesync: Timesync;
+    protected subscriptionManager: SubscriptionManager;
+    constructor(options: SDKOptions);
+    onDeviceChange(): Observable<DeviceInfo>;
+    private setAutoSelectedDevice;
+    get actions(): Actions;
+    dispatchAction(action: Action): Promise<any>;
+    disconnect(): Promise<any>;
+    getInfo(): Promise<any>;
+    login(credentials: Credentials): Promise<any>;
+    logout(): Promise<any>;
+    onAuthStateChanged(): Observable<{
+        selectedDevice: DeviceInfo;
+        delete(): Promise<void>;
+        emailVerified: boolean;
+        getIdTokenResult(forceRefresh?: boolean): Promise<import("@firebase/auth-types").IdTokenResult>;
+        getIdToken(forceRefresh?: boolean): Promise<string>;
+        isAnonymous: boolean;
+        linkAndRetrieveDataWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        linkWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        linkWithPhoneNumber(phoneNumber: string, applicationVerifier: import("@firebase/auth-types").ApplicationVerifier): Promise<import("@firebase/auth-types").ConfirmationResult>;
+        linkWithPopup(provider: import("@firebase/auth-types").AuthProvider): Promise<import("@firebase/auth-types").UserCredential>;
+        linkWithRedirect(provider: import("@firebase/auth-types").AuthProvider): Promise<void>;
+        metadata: import("@firebase/auth-types").UserMetadata;
+        multiFactor: import("@firebase/auth-types").MultiFactorUser;
+        phoneNumber: string;
+        providerData: import("@firebase/auth-types").UserInfo[];
+        reauthenticateAndRetrieveDataWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        reauthenticateWithCredential(credential: import("@firebase/auth-types").AuthCredential): Promise<import("@firebase/auth-types").UserCredential>;
+        reauthenticateWithPhoneNumber(phoneNumber: string, applicationVerifier: import("@firebase/auth-types").ApplicationVerifier): Promise<import("@firebase/auth-types").ConfirmationResult>;
+        reauthenticateWithPopup(provider: import("@firebase/auth-types").AuthProvider): Promise<import("@firebase/auth-types").UserCredential>;
+        reauthenticateWithRedirect(provider: import("@firebase/auth-types").AuthProvider): Promise<void>;
+        refreshToken: string;
+        reload(): Promise<void>;
+        sendEmailVerification(actionCodeSettings?: import("@firebase/auth-types").ActionCodeSettings): Promise<void>;
+        tenantId: string;
+        toJSON(): Object;
+        unlink(providerId: string): Promise<import("@firebase/auth-types").User>;
+        updateEmail(newEmail: string): Promise<void>;
+        updatePassword(newPassword: string): Promise<void>;
+        updatePhoneNumber(phoneCredential: import("@firebase/auth-types").AuthCredential): Promise<void>;
+        updateProfile(profile: {
+            displayName?: string;
+            photoURL?: string;
+        }): Promise<void>;
+        verifyBeforeUpdateEmail(newEmail: string, actionCodeSettings?: import("@firebase/auth-types").ActionCodeSettings): Promise<void>;
+        displayName: string;
+        email: string;
+        photoURL: string;
+        providerId: string;
+        uid: string;
+    }>;
+    getDevices(): Promise<DeviceInfo[]>;
+    addDevice(deviceId: string): Promise<void>;
+    removeDevice(deviceId: string): Promise<void>;
+    transferDevice(options: TransferDeviceOptions): Promise<void>;
+    onUserDevicesChange(): Observable<DeviceInfo[]>;
+    onUserClaimsChange(): Observable<UserClaims>;
+    didSelectDevice(): Promise<boolean>;
+    selectDevice(deviceSelector: DeviceSelector): Promise<DeviceInfo>;
+    getSelectedDevice(): Promise<DeviceInfo | null>;
+    status(): Observable<DeviceStatus>;
+    observeNamespace(namespace: string): Observable<any>;
+    onceNamespace(namespace: string): Promise<any>;
+    get metrics(): Metrics;
+    createAccount(credentials: EmailAndPassword): Promise<any>;
+    deleteAccount(): Promise<void>;
+    createBluetoothToken(): Promise<string>;
+    createCustomToken(): Promise<CustomToken>;
+    removeOAuthAccess(): Promise<OAuthRemoveResponse>;
+    onUserExperiments(): Observable<Experiment[]>;
+    deleteUserExperiment(experimentId: string): Promise<void>;
+    get skills(): SkillsClient;
+    get timestamp(): number;
+    getTimesyncOffset(): number;
+    changeSettings(settings: ChangeSettings): Promise<void>;
+    goOffline(): void;
+    goOnline(): void;
+}

package/dist/cjs/api/index.js

@@ -0,0 +1,306 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudClient = exports.SERVER_TIMESTAMP = exports.createUser = exports.credentialWithLink = void 0;
+const rxjs_1 = require("rxjs");
+const rxjs_2 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const firebase_1 = require("./firebase");
+const timesync_1 = require("../timesync");
+const SubscriptionManager_1 = require("../subscriptions/SubscriptionManager");
+const heartbeat_1 = require("../utils/heartbeat");
+const filterInternalKeys_1 = require("../utils/filterInternalKeys");
+var firebase_2 = require("./firebase");
+Object.defineProperty(exports, "credentialWithLink", { enumerable: true, get: function () { return firebase_2.credentialWithLink; } });
+Object.defineProperty(exports, "createUser", { enumerable: true, get: function () { return firebase_2.createUser; } });
+Object.defineProperty(exports, "SERVER_TIMESTAMP", { enumerable: true, get: function () { return firebase_2.SERVER_TIMESTAMP; } });
+/**
+ * @hidden
+ */
+class CloudClient {
+    constructor(options) {
+        /**
+         * @internal
+         */
+        this._selectedDevice = new rxjs_1.ReplaySubject(1);
+        this.options = options;
+        this.subscriptionManager = new SubscriptionManager_1.SubscriptionManager();
+        this.firebaseApp = new firebase_1.FirebaseApp(options);
+        this.firebaseUser = new firebase_1.FirebaseUser(this.firebaseApp);
+        this._selectedDevice.next(undefined);
+        this.firebaseUser.onAuthStateChanged().subscribe((user) => {
+            this.user = user;
+        });
+        this.firebaseUser.onUserClaimsChange().subscribe((userClaims) => {
+            this.userClaims = userClaims;
+        });
+        this.onDeviceChange().subscribe((device) => {
+            if (this.firebaseDevice) {
+                this.firebaseDevice.disconnect();
+            }
+            if (!device) {
+                return;
+            }
+            this.firebaseDevice = new firebase_1.FirebaseDevice({
+                deviceId: device.deviceId,
+                firebaseApp: this.firebaseApp,
+                dependencies: {
+                    subscriptionManager: this.subscriptionManager
+                }
+            });
+            if (this.options.timesync) {
+                this.timesync = new timesync_1.Timesync({
+                    status$: this.status(),
+                    getTimesync: this.firebaseDevice.getTimesync.bind(this.firebaseDevice)
+                });
+            }
+        });
+    }
+    onDeviceChange() {
+        return this._selectedDevice
+            .asObservable()
+            .pipe((0, operators_1.filter)((value) => value !== undefined));
+    }
+    // Automatically select device when user logs in
+    setAutoSelectedDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Select based on `deviceId` passed
+            if (this.options.deviceId) {
+                return yield this.selectDevice((devices) => {
+                    return devices.find((device) => device.deviceId === this.options.deviceId);
+                });
+            }
+            // Auto select first-claimed device
+            if (!this.options.deviceId && this.options.autoSelectDevice) {
+                return yield this.selectDevice((devices) => {
+                    // Auto select first device
+                    return devices[0];
+                });
+            }
+            return null;
+        });
+    }
+    get actions() {
+        return {
+            dispatch: (action) => {
+                return this.firebaseDevice.dispatchAction(action);
+            }
+        };
+    }
+    dispatchAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.firebaseDevice.dispatchAction(action);
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.firebaseApp.disconnect();
+        });
+    }
+    getInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.firebaseDevice.getInfo();
+        });
+    }
+    login(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.user) {
+                return Promise.reject(`Already logged in.`);
+            }
+            const auth = yield this.firebaseUser.login(credentials);
+            const selectedDevice = yield this.setAutoSelectedDevice();
+            return Object.assign(Object.assign({}, auth), { selectedDevice });
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.firebaseDevice) {
+                this.firebaseDevice.disconnect();
+            }
+            return yield this.firebaseUser.logout();
+        });
+    }
+    onAuthStateChanged() {
+        return this.firebaseUser.onAuthStateChanged().pipe((0, operators_1.switchMap)((user) => __awaiter(this, void 0, void 0, function* () {
+            if (!user) {
+                return null;
+            }
+            const selectedDevice = this.didSelectDevice()
+                ? yield this.getSelectedDevice()
+                : yield this.setAutoSelectedDevice();
+            return Object.assign(Object.assign({}, user), { selectedDevice });
+        })));
+    }
+    getDevices() {
+        return this.firebaseUser.getDevices();
+    }
+    addDevice(deviceId) {
+        return this.firebaseUser.addDevice(deviceId);
+    }
+    removeDevice(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [hasError, errorMessage] = yield this.firebaseUser
+                .removeDevice(deviceId)
+                .then(() => [false])
+                .catch((error) => [true, error]);
+            if (hasError) {
+                return Promise.reject(errorMessage);
+            }
+            const selectedDevice = yield this.getSelectedDevice();
+            if ((selectedDevice === null || selectedDevice === void 0 ? void 0 : selectedDevice.deviceId) === deviceId) {
+                this._selectedDevice.next(null);
+            }
+        });
+    }
+    transferDevice(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [hasError, error] = yield this.firebaseUser
+                .transferDevice(options)
+                .then(() => [false])
+                .catch((error) => [true, error]);
+            if (hasError) {
+                return Promise.reject(error);
+            }
+            const selectedDevice = yield this.getSelectedDevice();
+            if ((selectedDevice === null || selectedDevice === void 0 ? void 0 : selectedDevice.deviceId) === options.deviceId) {
+                this._selectedDevice.next(null);
+            }
+        });
+    }
+    onUserDevicesChange() {
+        return this.firebaseUser.onUserDevicesChange();
+    }
+    onUserClaimsChange() {
+        return this.firebaseUser.onUserClaimsChange();
+    }
+    didSelectDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selectedDevice = yield this.getSelectedDevice();
+            return !!selectedDevice;
+        });
+    }
+    selectDevice(deviceSelector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDevices();
+            if (!devices) {
+                return Promise.reject(`Did not find any devices for this user. Make sure your device is claimed by your Neurosity account.`);
+            }
+            const deviceTupleSelector = (devices) => devices.find((device) => {
+                if (!Array.isArray(deviceSelector)) {
+                    return false;
+                }
+                const [deviceKey, deviceValue] = deviceSelector;
+                return (JSON.stringify(device === null || device === void 0 ? void 0 : device[deviceKey]) === JSON.stringify(deviceValue));
+            });
+            const device = typeof deviceSelector === "function"
+                ? deviceSelector(devices)
+                : deviceTupleSelector(devices);
+            if (!device) {
+                return Promise.reject(`A device was not provided. Try returning a device from the devicesList provided in the callback.`);
+            }
+            const hasPermission = yield this.firebaseUser.hasDevicePermission(device.deviceId);
+            if (!hasPermission) {
+                return Promise.reject(`Rejected device access due to permissions.`);
+            }
+            this._selectedDevice.next(device);
+            return device;
+        });
+    }
+    getSelectedDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, rxjs_2.firstValueFrom)(this._selectedDevice);
+        });
+    }
+    status() {
+        return this.observeNamespace("status").pipe((0, heartbeat_1.offlineIfLostHeartbeat)(), (0, filterInternalKeys_1.filterInternalKeys)());
+    }
+    observeNamespace(namespace) {
+        const namespaceValues$ = (0, rxjs_2.fromEventPattern)((handler) => this.firebaseDevice.onNamespace(namespace, handler), (handler) => this.firebaseDevice.offNamespace(namespace, handler));
+        return this.onDeviceChange().pipe((0, operators_1.switchMap)((selectedDevice) => {
+            return selectedDevice ? namespaceValues$ : rxjs_1.EMPTY;
+        }));
+    }
+    onceNamespace(namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.firebaseDevice.onceNamespace(namespace);
+        });
+    }
+    get metrics() {
+        return {
+            next: (metricName, metricValue) => {
+                this.firebaseDevice.nextMetric(metricName, metricValue);
+            },
+            on: (subscription, callback) => {
+                return this.firebaseDevice.onMetric(subscription, callback);
+            },
+            subscribe: (subscription) => {
+                const subscriptionCreated = this.firebaseDevice.subscribeToMetric(subscription);
+                this.subscriptionManager.add(subscriptionCreated);
+                return subscriptionCreated;
+            },
+            unsubscribe: (subscription, listener) => {
+                this.subscriptionManager.remove(subscription);
+                this.firebaseDevice.unsubscribeFromMetric(subscription);
+                this.firebaseDevice.removeMetricListener(subscription, listener);
+            }
+        };
+    }
+    createAccount(credentials) {
+        return this.firebaseUser.createAccount(credentials);
+    }
+    deleteAccount() {
+        return this.firebaseUser.deleteAccount();
+    }
+    createBluetoothToken() {
+        return this.firebaseDevice.createBluetoothToken();
+    }
+    createCustomToken() {
+        return this.firebaseUser.createCustomToken();
+    }
+    removeOAuthAccess() {
+        return this.firebaseUser.removeOAuthAccess();
+    }
+    onUserExperiments() {
+        return this.firebaseUser.onUserExperiments();
+    }
+    deleteUserExperiment(experimentId) {
+        return this.firebaseUser.deleteUserExperiment(experimentId);
+    }
+    get skills() {
+        return {
+            get: (bundleId) => __awaiter(this, void 0, void 0, function* () {
+                return this.firebaseDevice.getSkill(bundleId);
+            })
+        };
+    }
+    get timestamp() {
+        return this.options.timesync ? this.timesync.timestamp : Date.now();
+    }
+    getTimesyncOffset() {
+        return this.timesync.offset;
+    }
+    changeSettings(settings) {
+        return this.firebaseDevice.changeSettings(settings);
+    }
+    goOffline() {
+        this.firebaseApp.goOffline();
+    }
+    goOnline() {
+        this.firebaseApp.goOnline();
+    }
+    /**
+     * @internal
+     */
+    __getApp() {
+        return this.firebaseApp.app;
+    }
+}
+exports.CloudClient = CloudClient;

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Notion";
+export * from "./api/bluetooth";
+export * from "./skills";

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Notion"), exports);
+__exportStar(require("./api/bluetooth"), exports);
+__exportStar(require("./skills"), exports);

package/dist/cjs/skills/NotionOnDevice.d.ts

@@ -0,0 +1,7 @@
+import { Neurosity } from "../Notion";
+import { SDKOptions } from "../types/options";
+import { Skill } from "../types/skill";
+export declare type NotionOnDevice = Omit<Neurosity, "skill">;
+export interface OnDeviceOptions extends SDKOptions {
+    skill: Skill;
+}

package/dist/cjs/skills/NotionOnDevice.js

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotionOnDevice = void 0;
+const Notion_1 = require("../Notion");
+/**
+ * @internal
+ */
+function createNotionOnDevice(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const neurosity = new Notion_1.Neurosity(options);
+        const skill = Object.assign(Object.assign({}, (yield neurosity.skill(options.skill.bundleId))), { props: "props" in options.skill ? options.skill.props : {} });
+        delete neurosity.skill;
+        return [neurosity, skill];
+    });
+}
+exports.createNotionOnDevice = createNotionOnDevice;

package/dist/cjs/skills/createSkill.d.ts

@@ -0,0 +1,7 @@
+import { OnDeviceOptions, NotionOnDevice } from "./NotionOnDevice";
+import { SkillInstance, SkillSubscription } from "../types/skill";
+declare type SkillApp = (neurosity: NotionOnDevice, skill: SkillInstance) => () => Promise<void>;
+export declare function createSkill(app: SkillApp): {
+    subscribe: (options: OnDeviceOptions) => Promise<SkillSubscription>;
+};
+export {};

package/dist/cjs/skills/createSkill.js

@@ -0,0 +1,40 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkill = void 0;
+const NotionOnDevice_1 = require("./NotionOnDevice");
+function createSkill(app) {
+    return {
+        subscribe: (options) => __awaiter(this, void 0, void 0, function* () {
+            const [neurosity, skill] = yield (0, NotionOnDevice_1.createNotionOnDevice)(Object.assign({}, options));
+            const teardown = app(neurosity, skill);
+            return {
+                unsubscribe: () => __awaiter(this, void 0, void 0, function* () {
+                    yield neurosity.disconnect();
+                    if (teardown && "then" in teardown) {
+                        const cleanUp = yield teardown;
+                        if (typeof cleanUp === "function") {
+                            cleanUp();
+                        }
+                    }
+                    if (typeof teardown === "function" && "then" in teardown()) {
+                        return yield teardown();
+                    }
+                    if (typeof teardown === "function") {
+                        return teardown();
+                    }
+                    return teardown;
+                })
+            };
+        })
+    };
+}
+exports.createSkill = createSkill;

package/dist/cjs/skills/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./createSkill";
+export * from "./NotionOnDevice";

package/dist/cjs/skills/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createSkill"), exports);
+__exportStar(require("./NotionOnDevice"), exports);