@neurosity/sdk 6.0.0-next.11

package/dist/cjs/utils/metrics.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCloudMetric = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const whileOnline_1 = require("./whileOnline");
+const subscription_1 = require("./subscription");
+/**
+ * @internal
+ */
+function getCloudMetric(dependencies, subscription) {
+    const { options, cloudClient, onDeviceChange, status } = dependencies;
+    const { metric, labels, atomic } = subscription;
+    const metricError = (0, subscription_1.validate)(metric, labels, options);
+    if (metricError) {
+        return (0, rxjs_1.throwError)(() => metricError);
+    }
+    const metric$ = new rxjs_1.Observable((observer) => {
+        const subscriptions = atomic
+            ? [
+                cloudClient.metrics.subscribe({
+                    metric: metric,
+                    labels: labels,
+                    atomic: atomic
+                })
+            ]
+            : labels.map((label) => {
+                return cloudClient.metrics.subscribe({
+                    metric: metric,
+                    labels: [label],
+                    atomic: atomic
+                });
+            });
+        const subscriptionWithListeners = subscriptions.map((subscription) => ({
+            subscription,
+            listener: cloudClient.metrics.on(subscription, (...data) => {
+                observer.next(...data);
+            })
+        }));
+        return () => {
+            subscriptionWithListeners.forEach(({ subscription, listener }) => {
+                cloudClient.metrics.unsubscribe(subscription, listener);
+            });
+        };
+    });
+    return onDeviceChange().pipe((0, operators_1.switchMap)((device) => {
+        if (!device) {
+            return rxjs_1.EMPTY;
+        }
+        return metric$.pipe((0, whileOnline_1.whileOnline)({
+            status$: status(),
+            allowWhileOnSleepMode: false
+        }));
+    }));
+}
+exports.getCloudMetric = getCloudMetric;

package/dist/cjs/utils/oauth.d.ts

@@ -0,0 +1,9 @@
+import { Action } from "../types/actions";
+declare type OAuthClaims = {
+    oauth?: true;
+    authId?: string;
+    scopes?: string;
+};
+export declare function validateOAuthScopeForAction(userClaims: OAuthClaims, action: Action): [boolean, Error | null];
+export declare function validateOAuthScopeForFunctionName(userClaims: OAuthClaims, functionName: string): [boolean, Error | null];
+export {};

package/dist/cjs/utils/oauth.js

@@ -0,0 +1,92 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOAuthScopeForFunctionName = exports.validateOAuthScopeForAction = void 0;
+const errors = __importStar(require("../utils/errors"));
+const scopeRequiredByAction = {
+    "marker/add": "write:brainwave-markers",
+    "brainwaves/record": "write:brainwaves",
+    "haptics/queue": "write:haptics",
+    "training/record": "write:kinesis",
+    "training/stop": "write:kinesis",
+    "training/stopAll": "write:kinesis",
+    "wifi/reset": "write:wifi-settings"
+};
+const scopeRequiredByFunctionName = {
+    //metrics
+    accelerometer: "read:accelerometer",
+    brainwaves: "read:brainwaves",
+    calm: "read:calm",
+    focus: "read:focus",
+    kinesis: "read:kinesis",
+    predictions: "read:kinesis",
+    signalQuality: "read:signal-quality",
+    // end of metrics
+    // device info
+    getInfo: "read:devices-info",
+    getSelectedDevice: "read:devices-info",
+    selectDevice: "read:devices-info",
+    onDeviceChange: "read:devices-info",
+    onUserDevicesChange: "read:devices-info",
+    // end device info
+    settings: "read:devices-settings",
+    changeSettings: "write:devices-settings",
+    status: "read:devices-status",
+    addDevice: "write:devices-add",
+    removeDevice: "write:devices-remove",
+    transferDevice: "write:devices-remove"
+};
+function validateOAuthScopeForAction(userClaims, action) {
+    const { oauth, scopes: scopesString } = userClaims !== null && userClaims !== void 0 ? userClaims : {};
+    if (!oauth) {
+        return [false, null];
+    }
+    const scopes = scopesString.split(",");
+    const { command, action: actionName } = action;
+    const requiredScope = scopeRequiredByAction[`${command}/${actionName}`];
+    const hasRequireScopes = scopes.includes(requiredScope);
+    if (hasRequireScopes) {
+        return [false, null];
+    }
+    return [true, getScopeError(requiredScope)];
+}
+exports.validateOAuthScopeForAction = validateOAuthScopeForAction;
+function validateOAuthScopeForFunctionName(userClaims, functionName) {
+    const { oauth, scopes: scopesString } = userClaims !== null && userClaims !== void 0 ? userClaims : {};
+    if (!oauth) {
+        return [false, null];
+    }
+    const scopes = scopesString.split(",");
+    const requiredScope = scopeRequiredByFunctionName[functionName];
+    const hasRequireScopes = scopes.includes(requiredScope);
+    if (hasRequireScopes) {
+        return [false, null];
+    }
+    return [true, getScopeError(requiredScope)];
+}
+exports.validateOAuthScopeForFunctionName = validateOAuthScopeForFunctionName;
+function getScopeError(...requiredScopes) {
+    return new Error(`${errors.prefix}You are trying to access data with an OAuth token without access to the following scopes: ${requiredScopes.join(", ")}.`);
+}

package/dist/cjs/utils/pick.d.ts

@@ -0,0 +1 @@
+export declare const pick: (object: any, props: any) => any;

package/dist/cjs/utils/pick.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pick = void 0;
+const pick = (object, props) => props.reduce((acc, prop) => (Object.assign(Object.assign({}, acc), (object.hasOwnProperty(prop) ? { [prop]: object[prop] } : {}))), {});
+exports.pick = pick;

package/dist/cjs/utils/pipes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Annotates stream with user-defined metadata
+ * @method addInfo
+ * @example eeg$.pipe(addinfo({ samplingRate: 256, channelNames: ["Af7", "Fp1", "Fp2", "Af8"] })
+ * @param {Object} info Info to be added to the EEG stream. Relevant info may include: `samplingRate` and `channelNames`
+ * @returns {Observable<Sample|Epoch|PSD>}
+ */
+export declare const addInfo: (infoValue: any) => import("rxjs").UnaryFunction<import("rxjs").Observable<any>, import("rxjs").Observable<any>>;
+/**
+ * Takes an array or RxJS buffer of EEG Samples and returns an Epoch.
+ * @method bufferToEpoch
+ * @example eeg$.pipe(bufferTime(1000), bufferToEpoch({ samplingRate: 256 }))
+ *
+ * @param {Object} options - Data structure options
+ * @param {number} [options.samplingRate] Sampling rate
+ * @param {string} [options.dataProp='data'] Name of the key associated with eeg data
+ *
+ * @returns {Observable<Epoch>}
+ */
+export declare const bufferToEpoch: ({ samplingRate, dataProp }?: {
+    samplingRate?: number;
+    dataProp?: string;
+}) => import("rxjs").UnaryFunction<import("rxjs").Observable<unknown>, import("rxjs").Observable<{
+    [x: string]: any;
+    info: any;
+}>>;
+/**
+ * Converts a stream of individual Samples of EEG data into a stream of Epochs of a given duration emitted at specified interval. This operator functions similarly to a circular buffer internally and allows overlapping Epochs of data to be emitted (e.g. emitting the last one second of data every 100ms).
+ * @method epoch
+ * @example eeg$.pipe(epoch({ duration: 1024, interval: 100, samplingRate: 256 }))
+ * @param {Object} options - Epoching options
+ * @param {number} [options.duration=256] Number of samples to include in each epoch
+ * @param {number} [options.interval=100] Time (ms) between emitted Epochs
+ * @param {number} [options.samplingRate=256] Sampling rate
+ * @param {string} [options.dataProp='data'] Name of the key associated with eeg data
+ * @returns {Observable} Epoch
+ */
+export declare const epoch: ({ duration, interval, samplingRate, dataProp }: {
+    duration: any;
+    interval: any;
+    samplingRate: any;
+    dataProp?: string;
+}) => import("rxjs").UnaryFunction<import("rxjs").Observable<unknown>, import("rxjs").Observable<{
+    [x: string]: any;
+    info: any;
+}>>;

package/dist/cjs/utils/pipes.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.epoch = exports.bufferToEpoch = exports.addInfo = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const defaultDataProp = "data";
+const defaultSamplingRate = 256;
+const isObject = (object) => object instanceof Object && object === Object(object);
+const isFunction = (object) => typeof object === "function";
+const patch = (sample) => (info) => {
+    var _a;
+    return (Object.assign(Object.assign({}, sample), { info: Object.assign(Object.assign({}, ((_a = sample === null || sample === void 0 ? void 0 : sample.info) !== null && _a !== void 0 ? _a : {})), (info || {})) }));
+};
+/**
+ * Annotates stream with user-defined metadata
+ * @method addInfo
+ * @example eeg$.pipe(addinfo({ samplingRate: 256, channelNames: ["Af7", "Fp1", "Fp2", "Af8"] })
+ * @param {Object} info Info to be added to the EEG stream. Relevant info may include: `samplingRate` and `channelNames`
+ * @returns {Observable<Sample|Epoch|PSD>}
+ */
+const addInfo = (infoValue) => (0, rxjs_1.pipe)((0, operators_1.map)((sample) => {
+    if (!isObject(sample) ||
+        (!isObject(infoValue) && !isFunction(infoValue))) {
+        return sample;
+    }
+    const info = isFunction(infoValue) ? infoValue(sample) : infoValue;
+    return patch(sample)(info);
+}));
+exports.addInfo = addInfo;
+/**
+ * Get a 2D data array organized by channel from an array of Samples. Credit to Ken from Seattle's elegant transposition
+ * http://www.codesuck.com/2012/02/transpose-javascript-array-in-one-line.html
+ * @method groupByChannel
+ * @param {Array<Sample>} samplesBuffer Array of Samples to be grouped
+ * @param {string} [dataProp] Name of the key associated with EEG data
+ * @returns {Array<Array<number>>}
+ */
+const groupByChannel = (samplesBuffer, dataProp = defaultDataProp) => samplesBuffer[0][dataProp].map((_, channelIndex) => samplesBuffer.map((sample) => sample[dataProp][channelIndex]));
+/**
+ * Takes an array or RxJS buffer of EEG Samples and returns an Epoch.
+ * @method bufferToEpoch
+ * @example eeg$.pipe(bufferTime(1000), bufferToEpoch({ samplingRate: 256 }))
+ *
+ * @param {Object} options - Data structure options
+ * @param {number} [options.samplingRate] Sampling rate
+ * @param {string} [options.dataProp='data'] Name of the key associated with eeg data
+ *
+ * @returns {Observable<Epoch>}
+ */
+const bufferToEpoch = ({ samplingRate = defaultSamplingRate, dataProp = defaultDataProp } = {}) => (0, rxjs_1.pipe)((0, operators_1.map)((samplesArray) => ({
+    [dataProp]: groupByChannel(samplesArray, dataProp),
+    info: Object.assign(Object.assign({}, (samplesArray[0] && samplesArray[0].info
+        ? samplesArray[0].info
+        : {})), { startTime: samplesArray[0].timestamp, samplingRate: samplesArray[0].info && samplesArray[0].info.samplingRate
+            ? samplesArray[0].info.samplingRate
+            : samplingRate })
+})));
+exports.bufferToEpoch = bufferToEpoch;
+/**
+ * Converts a stream of individual Samples of EEG data into a stream of Epochs of a given duration emitted at specified interval. This operator functions similarly to a circular buffer internally and allows overlapping Epochs of data to be emitted (e.g. emitting the last one second of data every 100ms).
+ * @method epoch
+ * @example eeg$.pipe(epoch({ duration: 1024, interval: 100, samplingRate: 256 }))
+ * @param {Object} options - Epoching options
+ * @param {number} [options.duration=256] Number of samples to include in each epoch
+ * @param {number} [options.interval=100] Time (ms) between emitted Epochs
+ * @param {number} [options.samplingRate=256] Sampling rate
+ * @param {string} [options.dataProp='data'] Name of the key associated with eeg data
+ * @returns {Observable} Epoch
+ */
+const epoch = ({ duration, interval, samplingRate, dataProp = defaultDataProp }) => (0, rxjs_1.pipe)((0, operators_1.bufferCount)(interval), (0, operators_1.scan)((acc, val) => acc.concat(val).slice(acc.length < duration ? 0 : -duration)), (0, operators_1.filter)((samplesArray) => samplesArray.length === duration), (0, exports.bufferToEpoch)({ samplingRate, dataProp }));
+exports.epoch = epoch;

package/dist/cjs/utils/platform.d.ts

@@ -0,0 +1,30 @@
+export declare const MODEL_VERSION_1 = "1";
+export declare const MODEL_VERSION_2 = "2";
+export declare const MODEL_VERSION_3 = "3";
+export declare const FEATURE_HAPTICS = "haptics";
+export declare const FEATURE_ACCEL = "accel";
+export declare const HAPTIC_P7 = "P7";
+export declare const HAPTIC_P8 = "P8";
+export declare const platformFeaturesByModelVersion: {
+    1: any[];
+    2: string[];
+    3: string[];
+};
+export declare const platformConfigByModelVersion: {
+    1: {};
+    2: {
+        motorByMotorName: {
+            P7: any[];
+            P8: any[];
+        };
+    };
+    3: {
+        motorByMotorName: {
+            P7: any[];
+            P8: any[];
+        };
+    };
+};
+export declare const supportsHaptics: (modelVersion: string) => boolean;
+export declare const supportsAccel: (modelVersion: string) => boolean;
+export declare const getPlatformHapticMotors: (modelVersion: string) => any;

package/dist/cjs/utils/platform.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformHapticMotors = exports.supportsAccel = exports.supportsHaptics = exports.platformConfigByModelVersion = exports.platformFeaturesByModelVersion = exports.HAPTIC_P8 = exports.HAPTIC_P7 = exports.FEATURE_ACCEL = exports.FEATURE_HAPTICS = exports.MODEL_VERSION_3 = exports.MODEL_VERSION_2 = exports.MODEL_VERSION_1 = void 0;
+exports.MODEL_VERSION_1 = "1";
+exports.MODEL_VERSION_2 = "2";
+exports.MODEL_VERSION_3 = "3";
+exports.FEATURE_HAPTICS = "haptics";
+exports.FEATURE_ACCEL = "accel";
+exports.HAPTIC_P7 = "P7";
+exports.HAPTIC_P8 = "P8";
+exports.platformFeaturesByModelVersion = {
+    [exports.MODEL_VERSION_1]: [],
+    [exports.MODEL_VERSION_2]: [exports.FEATURE_HAPTICS, exports.FEATURE_ACCEL],
+    [exports.MODEL_VERSION_3]: [exports.FEATURE_HAPTICS, exports.FEATURE_ACCEL]
+};
+exports.platformConfigByModelVersion = {
+    [exports.MODEL_VERSION_1]: {},
+    [exports.MODEL_VERSION_2]: {
+        motorByMotorName: {
+            [exports.HAPTIC_P7]: [],
+            [exports.HAPTIC_P8]: []
+        }
+    },
+    [exports.MODEL_VERSION_3]: {
+        motorByMotorName: {
+            [exports.HAPTIC_P7]: [],
+            [exports.HAPTIC_P8]: []
+        }
+    }
+};
+const supportsHaptics = (modelVersion) => {
+    const platformFeaturesForModel = exports.platformFeaturesByModelVersion[modelVersion];
+    return platformFeaturesForModel.includes(exports.FEATURE_HAPTICS);
+};
+exports.supportsHaptics = supportsHaptics;
+const supportsAccel = (modelVersion) => {
+    const platformFeaturesForModel = exports.platformFeaturesByModelVersion[modelVersion];
+    return platformFeaturesForModel.includes(exports.FEATURE_ACCEL);
+};
+exports.supportsAccel = supportsAccel;
+const getPlatformHapticMotors = (modelVersion) => {
+    var _a;
+    const platformConfigForModel = exports.platformConfigByModelVersion[modelVersion];
+    const platformMotorByMotorName = (_a = platformConfigForModel === null || platformConfigForModel === void 0 ? void 0 : platformConfigForModel.motorByMotorName) !== null && _a !== void 0 ? _a : {};
+    return Object.assign({}, platformMotorByMotorName);
+};
+exports.getPlatformHapticMotors = getPlatformHapticMotors;

package/dist/cjs/utils/subscription.d.ts

@@ -0,0 +1,6 @@
+import { SDKOptions } from "../types/options";
+export declare const isMetric: (metric: string) => boolean;
+export declare const getLabels: (metric: string) => string[];
+export declare const hasInvalidLabels: (metric: string, labels: string[]) => boolean;
+export declare const isMetricDisallowed: (metricName: string, options: SDKOptions) => boolean;
+export declare const validate: (metric: string, labels: string[], options: SDKOptions) => Error | false;

package/dist/cjs/utils/subscription.js

@@ -0,0 +1,55 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.isMetricDisallowed = exports.hasInvalidLabels = exports.getLabels = exports.isMetric = void 0;
+const ipk_1 = require("@neurosity/ipk");
+const errors = __importStar(require("../utils/errors"));
+const isMetric = (metric) => Object.keys(ipk_1.metrics).includes(metric);
+exports.isMetric = isMetric;
+const getLabels = (metric) => Object.keys(ipk_1.metrics[metric]);
+exports.getLabels = getLabels;
+const hasInvalidLabels = (metric, labels) => {
+    const validLabels = (0, exports.getLabels)(metric);
+    return !labels.every((label) => validLabels.includes(label));
+};
+exports.hasInvalidLabels = hasInvalidLabels;
+const isMetricDisallowed = (metricName, options) => "skill" in options &&
+    "metrics" in options.skill &&
+    !options.skill.metrics.includes(metricName);
+exports.isMetricDisallowed = isMetricDisallowed;
+const validate = (metric, labels, options) => {
+    const validLabels = (0, exports.getLabels)(metric).join(", ");
+    if (!labels.length) {
+        return new Error(`${errors.prefix}At least one label is required for ${metric} metric. Please add one of the following labels: ${validLabels}`);
+    }
+    if ((0, exports.isMetricDisallowed)(metric, options)) {
+        return new Error(`${errors.prefix}No permission to access the ${metric} metric. To access this metric, edit the skill's permissions`);
+    }
+    if ((0, exports.hasInvalidLabels)(metric, labels)) {
+        return new Error(`${errors.prefix}One ore more labels provided to ${metric} are invalid. The valid labels for ${metric} are ${validLabels}`);
+    }
+    return false;
+};
+exports.validate = validate;

package/dist/cjs/utils/transferDevice.d.ts

@@ -0,0 +1,9 @@
+export declare type TransferDeviceByEmail = {
+    recipientsEmail: string;
+    deviceId: string;
+};
+export declare type TransferDeviceByUserId = {
+    recipientsUserId: string;
+    deviceId: string;
+};
+export declare type TransferDeviceOptions = TransferDeviceByEmail | TransferDeviceByUserId;

package/dist/cjs/utils/transferDevice.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/whileOnline.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { DeviceStatus } from "../types/status";
+declare type Options = {
+    status$: Observable<DeviceStatus>;
+    allowWhileOnSleepMode: boolean;
+};
+export declare function whileOnline({ status$, allowWhileOnSleepMode }: Options): import("rxjs").UnaryFunction<Observable<unknown>, Observable<any>>;
+export {};

package/dist/cjs/utils/whileOnline.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whileOnline = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+function whileOnline({ status$, allowWhileOnSleepMode }) {
+    return (0, rxjs_1.pipe)((0, operators_1.withLatestFrom)(status$), (0, operators_1.mergeMap)(([value, status]) => shouldAllowMetrics(status, allowWhileOnSleepMode)
+        ? (0, rxjs_1.of)(value)
+        : rxjs_1.EMPTY));
+}
+exports.whileOnline = whileOnline;
+function shouldAllowMetrics(status, allowWhileOnSleepMode) {
+    return (status.state === "online" &&
+        (allowWhileOnSleepMode ? true : !status.sleepMode));
+}