@neurosity/sdk 6.0.0-next.11

package/dist/cjs/api/bluetooth/react-native/ReactNativeTransport.js

@@ -0,0 +1,386 @@
+"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.ReactNativeTransport = void 0;
+const ipk_1 = require("@neurosity/ipk");
+const ipk_2 = require("@neurosity/ipk");
+const ipk_3 = require("@neurosity/ipk");
+const rxjs_1 = require("rxjs");
+const rxjs_2 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const operators_2 = require("rxjs/operators");
+const operators_3 = require("rxjs/operators");
+const create6DigitPin_1 = require("../utils/create6DigitPin");
+const stitch_1 = require("../utils/stitch");
+const encoding_1 = require("../utils/encoding");
+const types_1 = require("../types");
+const constants_1 = require("../constants");
+const constants_2 = require("../constants");
+const constants_3 = require("../constants");
+const constants_4 = require("../constants");
+const osHasBluetoothSupport_1 = require("../utils/osHasBluetoothSupport");
+class ReactNativeTransport {
+    constructor(options) {
+        this.type = types_1.TRANSPORT_TYPE.REACT_NATIVE;
+        this.characteristicsByName = {};
+        this.connection$ = new rxjs_1.BehaviorSubject(types_1.BLUETOOTH_CONNECTION.DISCONNECTED);
+        this.pendingActions$ = new rxjs_1.BehaviorSubject([]);
+        this.logs$ = new rxjs_1.ReplaySubject(10);
+        this.connectionStream$ = this.connection$
+            .asObservable()
+            .pipe((0, operators_1.filter)((connection) => !!connection), (0, operators_2.distinctUntilChanged)(), (0, operators_2.shareReplay)(1));
+        const { BleManager, bleManagerEmitter, platform } = options;
+        if (!BleManager) {
+            const errorMessage = "React Native option: BleManager not provided.";
+            this.addLog(errorMessage);
+            throw new Error(errorMessage);
+        }
+        if (!bleManagerEmitter) {
+            const errorMessage = "React Native option: bleManagerEmitter not provided.";
+            this.addLog(errorMessage);
+            throw new Error(errorMessage);
+        }
+        if (!platform) {
+            const errorMessage = "React Native option: platform not provided.";
+            this.addLog(errorMessage);
+            throw new Error(errorMessage);
+        }
+        this.BleManager = BleManager;
+        this.bleManagerEmitter = bleManagerEmitter;
+        this.platform = platform;
+        // We create a single listener per event type to
+        // avoid missing events when multiple listeners are attached.
+        this.bleEvents = {
+            stopScan$: this._fromEvent("BleManagerStopScan"),
+            discoverPeripheral$: this._fromEvent("BleManagerDiscoverPeripheral"),
+            connectPeripheral$: this._fromEvent("BleManagerConnectPeripheral"),
+            disconnectPeripheral$: this._fromEvent("BleManagerDisconnectPeripheral"),
+            didUpdateValueForCharacteristic$: this._fromEvent("BleManagerDidUpdateValueForCharacteristic")
+        };
+        this.onDisconnected$ = this.bleEvents.disconnectPeripheral$.pipe((0, operators_3.share)());
+        // Initializes the module. This can only be called once.
+        this.BleManager.start({ showAlert: false })
+            .then(() => {
+            this.addLog(`BleManger started`);
+        })
+            .catch((error) => {
+            var _a;
+            this.addLog(`BleManger failed to start. ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+        });
+        this.connection$.asObservable().subscribe((connection) => {
+            this.addLog(`connection status is ${connection}`);
+        });
+        this.onDisconnected$.subscribe(() => {
+            this.connection$.next(types_1.BLUETOOTH_CONNECTION.DISCONNECTED);
+        });
+    }
+    addLog(log) {
+        this.logs$.next(log);
+    }
+    isConnected() {
+        const connection = this.connection$.getValue();
+        return connection === types_1.BLUETOOTH_CONNECTION.CONNECTED;
+    }
+    _autoConnect(selectedDevice$) {
+        const selectedDeviceAfterDisconnect$ = this.onDisconnected$.pipe((0, operators_1.switchMap)(() => selectedDevice$));
+        return (0, rxjs_1.merge)(selectedDevice$, selectedDeviceAfterDisconnect$).pipe((0, operators_1.switchMap)((selectedDevice) => !(0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice)
+            ? rxjs_2.NEVER
+            : this.scan().pipe((0, operators_1.switchMap)((peripherals) => {
+                const peripheralMatch = peripherals.find((peripheral) => peripheral.name === (selectedDevice === null || selectedDevice === void 0 ? void 0 : selectedDevice.deviceNickname));
+                return peripheralMatch ? (0, rxjs_1.of)(peripheralMatch) : rxjs_2.NEVER;
+            }), (0, operators_3.distinct)((peripheral) => peripheral.id), (0, operators_3.take)(1))), (0, operators_1.switchMap)((peripheral) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.connect(peripheral);
+        })));
+    }
+    connection() {
+        return this.connectionStream$;
+    }
+    _fromEvent(eventName) {
+        return (0, rxjs_2.fromEventPattern)((addHandler) => {
+            this.bleManagerEmitter.addListener(eventName, addHandler);
+        }, () => {
+            this.bleManagerEmitter.removeAllListeners(eventName);
+        }).pipe(
+        // @important: we need to share the subscription
+        // to avoid missing events
+        (0, operators_3.share)());
+    }
+    scan(options) {
+        var _a, _b;
+        const RESCAN_INTERVAL = 10000; // 10 seconds
+        const seconds = (_a = options === null || options === void 0 ? void 0 : options.seconds) !== null && _a !== void 0 ? _a : RESCAN_INTERVAL / 1000;
+        const once = (_b = options === null || options === void 0 ? void 0 : options.once) !== null && _b !== void 0 ? _b : false;
+        const serviceUUIDs = [ipk_1.BLUETOOTH_PRIMARY_SERVICE_UUID_STRING];
+        const allowDuplicates = true;
+        const scanOptions = {};
+        const scanOnce$ = new rxjs_2.Observable((subscriber) => {
+            var _a;
+            try {
+                this.BleManager.scan(serviceUUIDs, seconds, allowDuplicates, scanOptions).then(() => {
+                    this.addLog(`BleManger scanning ${once ? "once" : "indefintely"}`);
+                    subscriber.next();
+                });
+            }
+            catch (error) {
+                this.addLog(`BleManger scanning ${once ? "once" : "indefintely"} failed. ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                subscriber.error(error);
+            }
+            return () => {
+                this.BleManager.stopScan();
+            };
+        });
+        const scan$ = once
+            ? scanOnce$
+            : (0, rxjs_1.timer)(0, RESCAN_INTERVAL).pipe((0, operators_1.switchMap)(() => scanOnce$));
+        const peripherals$ = scan$.pipe((0, operators_1.tap)(() => {
+            this.connection$.next(types_1.BLUETOOTH_CONNECTION.SCANNING);
+        }), (0, operators_1.takeUntil)(this.onDisconnected$), (0, operators_1.switchMap)(() => this.bleEvents.discoverPeripheral$), 
+        // Filter out devices that are not Neurosity devices
+        (0, operators_1.filter)((peripheral) => {
+            var _a, _b, _c;
+            const peripheralName = (_c = (_b = (_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertising) === null || _a === void 0 ? void 0 : _a.localName) !== null && _b !== void 0 ? _b : peripheral.name) !== null && _c !== void 0 ? _c : "";
+            if (!peripheralName) {
+                return false;
+            }
+            const startsWithPrefix = ipk_3.BLUETOOTH_DEVICE_NAME_PREFIXES.findIndex((prefix) => peripheralName.startsWith(prefix)) !== -1;
+            return startsWithPrefix;
+        }), (0, operators_3.scan)((acc, peripheral) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            // normalized peripheral name for backwards compatibility
+            // Neurosity OS v15 doesn't have peripheral.name as deviceNickname
+            // it only has peripheral.advertising.localName as deviceNickname
+            // and OS v16 has both as deviceNickname
+            const peripheralName = (_c = (_b = (_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertising) === null || _a === void 0 ? void 0 : _a.localName) !== null && _b !== void 0 ? _b : peripheral.name) !== null && _c !== void 0 ? _c : "";
+            const manufactureDataString = (_h = (_g = (0, encoding_1.decode)(this.type, (_f = (_e = (_d = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertising) === null || _d === void 0 ? void 0 : _d.manufacturerData) === null || _e === void 0 ? void 0 : _e.bytes) !== null && _f !== void 0 ? _f : [])) === null || _g === void 0 ? void 0 : _g.slice) === null || _h === void 0 ? void 0 : _h.call(_g, 2); // First 2 bytes are reserved for the Neurosity company code
+            return Object.assign(Object.assign({}, acc), { [peripheral.id]: Object.assign(Object.assign({}, peripheral), { name: peripheralName, manufactureDataString }) });
+        }, {}), (0, operators_2.distinctUntilChanged)((a, b) => JSON.stringify(a) === JSON.stringify(b)), (0, operators_1.map)((peripheralMap) => Object.values(peripheralMap)), (0, operators_3.share)());
+        return peripherals$;
+    }
+    connect(peripheral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!peripheral) {
+                        this.addLog("Peripheral not found");
+                        return;
+                    }
+                    this.connection$.next(types_1.BLUETOOTH_CONNECTION.CONNECTING);
+                    yield this.BleManager.connect(peripheral.id);
+                    this.addLog(`Getting service...`);
+                    const peripheralInfo = yield this.BleManager.retrieveServices(peripheral.id, [
+                        ipk_1.BLUETOOTH_PRIMARY_SERVICE_UUID_STRING
+                    ]);
+                    if (!peripheralInfo) {
+                        this.addLog("Could not retreive services");
+                        reject(`Could not retreive services`);
+                        return;
+                    }
+                    this.addLog(`Got service ${ipk_1.BLUETOOTH_PRIMARY_SERVICE_UUID_STRING}, getting characteristics...`);
+                    this.device = peripheral;
+                    this.characteristicsByName = Object.fromEntries(peripheralInfo.characteristics.map((characteristic) => [
+                        constants_2.CHARACTERISTIC_UUIDS_TO_NAMES[characteristic.characteristic.toLowerCase() // react native uses uppercase
+                        ],
+                        {
+                            characteristicUUID: characteristic.characteristic,
+                            serviceUUID: characteristic.service,
+                            peripheralId: peripheral.id
+                        }
+                    ]));
+                    this.addLog(`Got characteristics.`);
+                    if (this.platform === "android") {
+                        this.addLog(`Setting Android MTU to ${constants_3.ANDROID_MAX_MTU}`);
+                        yield this.BleManager.requestMTU(peripheral.id, constants_3.ANDROID_MAX_MTU);
+                    }
+                    this.addLog(`Successfully connected to peripheral ${peripheral.id}`);
+                    this.connection$.next(types_1.BLUETOOTH_CONNECTION.CONNECTED);
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }));
+        });
+    }
+    disconnect() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.isConnected() && ((_a = this === null || this === void 0 ? void 0 : this.device) === null || _a === void 0 ? void 0 : _a.id)) {
+                    yield this.BleManager.disconnect(this.device.id);
+                }
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        });
+    }
+    getCharacteristicByName(characteristicName) {
+        var _a;
+        if (!(characteristicName in this.characteristicsByName)) {
+            throw new Error(`Characteristic by name ${characteristicName} is not found`);
+        }
+        return (_a = this.characteristicsByName) === null || _a === void 0 ? void 0 : _a[characteristicName];
+    }
+    subscribeToCharacteristic({ characteristicName, manageNotifications = true }) {
+        const getData = ({ peripheralId, serviceUUID, characteristicUUID }) => (0, rxjs_1.defer)(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (manageNotifications) {
+                try {
+                    yield this.BleManager.startNotification(peripheralId, serviceUUID, characteristicUUID);
+                    this.addLog(`Started notifications for ${characteristicName} characteristic`);
+                }
+                catch (error) {
+                    this.addLog(`Attemped to stop notifications for ${characteristicName} characteristic: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                }
+            }
+        })).pipe((0, operators_1.switchMap)(() => this.bleEvents.didUpdateValueForCharacteristic$), (0, operators_2.finalize)(() => __awaiter(this, void 0, void 0, function* () {
+            var _b;
+            if (manageNotifications) {
+                try {
+                    yield this.BleManager.stopNotification(peripheralId, serviceUUID, characteristicUUID);
+                    this.addLog(`Stopped notifications for ${characteristicName} characteristic`);
+                }
+                catch (error) {
+                    this.addLog(`Attemped to stop notifications for ${characteristicName} characteristic: ${(_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error}`);
+                }
+            }
+        })), (0, operators_1.filter)(({ characteristic }) => characteristic === characteristicUUID), (0, operators_1.map)(({ value }) => (0, encoding_1.decode)(this.type, value)), (0, stitch_1.stitchChunks)({ delimiter: ipk_2.BLUETOOTH_CHUNK_DELIMITER }), (0, operators_1.map)((payload) => {
+            var _a;
+            try {
+                return JSON.parse(payload);
+            }
+            catch (error) {
+                this.addLog(`Failed to parse JSON for ${characteristicName} characteristic. Falling back to unparsed string. ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                return payload;
+            }
+        }));
+        return this.connection$.pipe((0, operators_1.switchMap)((connection) => connection === types_1.BLUETOOTH_CONNECTION.CONNECTED
+            ? getData(this.getCharacteristicByName(characteristicName))
+            : rxjs_2.NEVER));
+    }
+    readCharacteristic(characteristicName, parse = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.addLog(`Reading characteristic: ${characteristicName}`);
+            const { peripheralId, serviceUUID, characteristicUUID } = this.getCharacteristicByName(characteristicName);
+            if (!characteristicUUID) {
+                return Promise.reject(`Did not find characteristic matching ${characteristicName}`);
+            }
+            try {
+                const value = yield this.BleManager.read(peripheralId, serviceUUID, characteristicUUID);
+                const decodedValue = (0, encoding_1.decode)(this.type, value);
+                const data = parse ? JSON.parse(decodedValue) : decodedValue;
+                this.addLog(`Received read data from ${characteristicName} characteristic: \n${data}`);
+                return data;
+            }
+            catch (error) {
+                return Promise.reject(`readCharacteristic ${characteristicName} error. ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+            }
+        });
+    }
+    writeCharacteristic(characteristicName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.addLog(`Writing characteristic: ${characteristicName}`);
+            const { peripheralId, serviceUUID, characteristicUUID } = this.getCharacteristicByName(characteristicName);
+            if (!characteristicUUID) {
+                return Promise.reject(`Did not find characteristic matching ${characteristicName}`);
+            }
+            const encoded = (0, encoding_1.encode)(this.type, data);
+            yield this.BleManager.write(peripheralId, serviceUUID, characteristicUUID, encoded, constants_4.REACT_NATIVE_MAX_BYTE_SIZE);
+        });
+    }
+    _addPendingAction(actionId) {
+        const actions = this.pendingActions$.getValue();
+        this.pendingActions$.next([...actions, actionId]);
+    }
+    _removePendingAction(actionId) {
+        const actions = this.pendingActions$.getValue();
+        this.pendingActions$.next(actions.filter((id) => id !== actionId));
+    }
+    _autoToggleActionNotifications(selectedDevice$) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let started = false;
+            const sideEffects$ = this.connection$.asObservable().pipe((0, operators_1.switchMap)((connection) => connection === types_1.BLUETOOTH_CONNECTION.CONNECTED
+                ? this.pendingActions$
+                : rxjs_2.NEVER), (0, operators_1.tap)((pendingActions) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const { peripheralId, serviceUUID, characteristicUUID } = this.getCharacteristicByName("actions");
+                const hasPendingActions = !!pendingActions.length;
+                if (hasPendingActions && !started) {
+                    started = true;
+                    try {
+                        yield this.BleManager.startNotification(peripheralId, serviceUUID, characteristicUUID);
+                        this.addLog(`Started notifications for [actions] characteristic`);
+                    }
+                    catch (error) {
+                        this.addLog(`Attemped to start notifications for [actions] characteristic: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                    }
+                }
+                if (!hasPendingActions && started) {
+                    started = false;
+                    try {
+                        yield this.BleManager.stopNotification(peripheralId, serviceUUID, characteristicUUID);
+                        this.addLog(`Stopped notifications for actions characteristic`);
+                    }
+                    catch (error) {
+                        this.addLog(`Attemped to stop notifications for [actions] characteristic: ${(_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error}`);
+                    }
+                }
+            })));
+            selectedDevice$
+                .pipe((0, operators_1.switchMap)((selectedDevice) => !(0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice) ? rxjs_2.EMPTY : sideEffects$))
+                .subscribe();
+        });
+    }
+    dispatchAction({ characteristicName, action }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { responseRequired = false, responseTimeout = constants_1.DEFAULT_ACTION_RESPONSE_TIMEOUT } = action;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const actionId = (0, create6DigitPin_1.create6DigitPin)(); // use to later identify and filter response
+                const payload = JSON.stringify(Object.assign({ actionId }, action)); // add the response id to the action
+                this.addLog(`Dispatched action with id ${actionId}`);
+                if (responseRequired && responseTimeout) {
+                    this._addPendingAction(actionId);
+                    const timeout = (0, rxjs_1.timer)(responseTimeout).subscribe(() => {
+                        this._removePendingAction(actionId);
+                        reject(`Action with id ${actionId} timed out after ${responseTimeout}ms`);
+                    });
+                    // listen for a response before writing
+                    this.subscribeToCharacteristic({
+                        characteristicName,
+                        manageNotifications: false
+                    })
+                        .pipe((0, operators_1.filter)((response) => (response === null || response === void 0 ? void 0 : response.actionId) === actionId), (0, operators_3.take)(1))
+                        .subscribe((response) => {
+                        timeout.unsubscribe();
+                        this._removePendingAction(actionId);
+                        resolve(response);
+                    });
+                    // register action by writing
+                    this.writeCharacteristic(characteristicName, payload).catch((error) => {
+                        this._removePendingAction(actionId);
+                        reject(error.message);
+                    });
+                }
+                else {
+                    this.writeCharacteristic(characteristicName, payload)
+                        .then(() => {
+                        resolve(null);
+                    })
+                        .catch((error) => {
+                        reject(error.message);
+                    });
+                }
+            }));
+        });
+    }
+}
+exports.ReactNativeTransport = ReactNativeTransport;

package/dist/cjs/api/bluetooth/react-native/types/BleManagerTypes.d.ts

@@ -0,0 +1,63 @@
+export declare class BleManager {
+    start(options?: StartOptions): Promise<void>;
+    scan(serviceUUIDs: string[], seconds: number, allowDuplicates?: boolean, options?: ScanOptions): Promise<void>;
+    stopScan(): Promise<void>;
+    connect(peripheralID: string): Promise<void>;
+    disconnect(peripheralID: string, force?: boolean): Promise<void>;
+    checkState(): void;
+    startNotification(peripheralID: string, serviceUUID: string, characteristicUUID: string): Promise<void>;
+    startNotificationUseBuffer(peripheralID: string, serviceUUID: string, characteristicUUID: string, buffer: number): Promise<void>;
+    stopNotification(peripheralID: string, serviceUUID: string, characteristicUUID: string): Promise<void>;
+    read(peripheralID: string, serviceUUID: string, characteristicUUID: string): Promise<any>;
+    write(peripheralID: string, serviceUUID: string, characteristicUUID: string, data: any, maxByteSize?: number): Promise<void>;
+    writeWithoutResponse(peripheralID: string, serviceUUID: string, characteristicUUID: string, data: any, maxByteSize?: number, queueSleepTime?: number): Promise<void>;
+    readRSSI(peripheralID: string): Promise<void>;
+    getConnectedPeripherals(serviceUUIDs: string[]): Promise<Peripheral[]>;
+    getDiscoveredPeripherals(): Promise<Peripheral[]>;
+    isPeripheralConnected(peripheralID: string, serviceUUIDs: string[]): Promise<boolean>;
+    requestConnectionPriority(peripheralID: string, connectionPriority: ConnectionPriority): Promise<void>;
+    enableBluetooth(): Promise<void>;
+    refreshCache(peripheralID: string): Promise<void>;
+    requestMTU(peripheralID: string, mtu: number): Promise<void>;
+    createBond(peripheralID: string, peripheralPin?: string): Promise<void>;
+    removeBond(peripheralID: string): Promise<void>;
+    getBondedPeripherals(): Promise<Peripheral[]>;
+    removePeripheral(peripheralID: string): Promise<void>;
+    retrieveServices(peripheralID: string, serviceUUIDs?: string[]): Promise<PeripheralInfo>;
+}
+export interface Peripheral {
+    id: string;
+    rssi: number;
+    name?: string;
+    advertising: AdvertisingData;
+}
+export interface AdvertisingData {
+    isConnectable?: boolean;
+    localName?: string;
+    manufacturerData?: any;
+    serviceUUIDs?: string[];
+    txPowerLevel?: number;
+}
+export interface StartOptions {
+    showAlert?: boolean;
+    restoreIdentifierKey?: string;
+    queueIdentifierKey?: string;
+    forceLegacy?: boolean;
+}
+export interface ScanOptions {
+    numberOfMatches?: number;
+    matchMode?: number;
+    scanMode?: number;
+    reportDelay?: number;
+}
+export declare enum ConnectionPriority {
+    balanced = 0,
+    high = 1,
+    low = 2
+}
+export interface PeripheralInfo {
+    characteristics: Characteristic[];
+}
+export interface Characteristic {
+    characteristic: string;
+}

package/dist/cjs/api/bluetooth/react-native/types/BleManagerTypes.js

@@ -0,0 +1,11 @@
+"use strict";
+// Taken from react-native-ble-manager project
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionPriority = void 0;
+// [Android only API 21+]
+var ConnectionPriority;
+(function (ConnectionPriority) {
+    ConnectionPriority[ConnectionPriority["balanced"] = 0] = "balanced";
+    ConnectionPriority[ConnectionPriority["high"] = 1] = "high";
+    ConnectionPriority[ConnectionPriority["low"] = 2] = "low";
+})(ConnectionPriority = exports.ConnectionPriority || (exports.ConnectionPriority = {}));

package/dist/cjs/api/bluetooth/react-native/types/ReactNativeTypes.d.ts

@@ -0,0 +1,180 @@
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+interface EmitterSubscription extends EventSubscription {
+    emitter: EventEmitter;
+    listener: () => any;
+    context: any;
+    /**
+     * @param emitter - The event emitter that registered this
+     *   subscription
+     * @param subscriber - The subscriber that controls
+     *   this subscription
+     * @param listener - Function to invoke when the specified event is
+     *   emitted
+     * @param context - Optional context object to use when invoking the
+     *   listener
+     */
+    new (emitter: EventEmitter, subscriber: EventSubscriptionVendor, listener: () => any, context: any): EmitterSubscription;
+    /**
+     * Removes this subscription from the emitter that registered it.
+     * Note: we're overriding the `remove()` method of EventSubscription here
+     * but deliberately not calling `super.remove()` as the responsibility
+     * for removing the subscription lies with the EventEmitter.
+     */
+    remove(): void;
+}
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+interface EventSubscription {
+    eventType: string;
+    key: number;
+    subscriber: EventSubscriptionVendor;
+    /**
+     * @param subscriber the subscriber that controls
+     *   this subscription.
+     */
+    new (subscriber: EventSubscriptionVendor): EventSubscription;
+    /**
+     * Removes this subscription from the subscriber that controls it.
+     */
+    remove(): void;
+}
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+declare class EventSubscriptionVendor {
+    constructor();
+    /**
+     * Adds a subscription keyed by an event type.
+     *
+     */
+    addSubscription(eventType: string, subscription: EventSubscription): EventSubscription;
+    /**
+     * Removes a bulk set of the subscriptions.
+     *
+     * @param eventType - Optional name of the event type whose
+     *   registered supscriptions to remove, if null remove all subscriptions.
+     */
+    removeAllSubscriptions(eventType?: string): void;
+    /**
+     * Removes a specific subscription. Instead of calling this function, call
+     * `subscription.remove()` directly.
+     *
+     */
+    removeSubscription(subscription: any): void;
+    /**
+     * Returns the array of subscriptions that are currently registered for the
+     * given event type.
+     *
+     * Note: This array can be potentially sparse as subscriptions are deleted
+     * from it when they are removed.
+     *
+     */
+    getSubscriptionsForType(eventType: string): EventSubscription[];
+}
+declare class EventEmitter {
+    /**
+     *
+     * @param subscriber - Optional subscriber instance
+     *   to use. If omitted, a new subscriber will be created for the emitter.
+     */
+    constructor(subscriber?: EventSubscriptionVendor | null);
+    /**
+     * Adds a listener to be invoked when events of the specified type are
+     * emitted. An optional calling context may be provided. The data arguments
+     * emitted will be passed to the listener function.
+     *
+     * @param eventType - Name of the event to listen to
+     * @param listener - Function to invoke when the specified event is
+     *   emitted
+     * @param context - Optional context object to use when invoking the
+     *   listener
+     */
+    addListener(eventType: string, listener: (...args: any[]) => any, context?: any): EmitterSubscription;
+    /**
+     * Removes all of the registered listeners, including those registered as
+     * listener maps.
+     *
+     * @param eventType - Optional name of the event whose registered
+     *   listeners to remove
+     */
+    removeAllListeners(eventType?: string): void;
+    /**
+     * Returns the number of listeners that are currently registered for the given
+     * event.
+     *
+     * @param eventType - Name of the event to query
+     */
+    listenerCount(eventType: string): number;
+    /**
+     * Emits an event of the given type with the given data. All handlers of that
+     * particular type will be notified.
+     *
+     * @param eventType - Name of the event to emit
+     * @param Arbitrary arguments to be passed to each registered listener
+     *
+     * @example
+     *   emitter.addListener('someEvent', function(message) {
+     *     console.log(message);
+     *   });
+     *
+     *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+     */
+    emit(eventType: string, ...params: any[]): void;
+}
+/**
+ * The React Native implementation of the IOS RCTEventEmitter which is required when creating
+ * a module that communicates with IOS
+ */
+declare type NativeModule = {
+    /**
+     * Add the provided eventType as an active listener
+     * @param eventType name of the event for which we are registering listener
+     */
+    addListener: (eventType: string) => void;
+    /**
+     * Remove a specified number of events.  There are no eventTypes in this case, as
+     * the native side doesn't remove the name, but only manages a counter of total
+     * listeners
+     * @param count number of listeners to remove (of any type)
+     */
+    removeListeners: (count: number) => void;
+};
+/**
+ * Abstract base class for implementing event-emitting modules. This implements
+ * a subset of the standard EventEmitter node module API.
+ */
+export declare class NativeEventEmitter extends EventEmitter {
+    /**
+     * @param nativeModule the NativeModule implementation.  This is required on IOS and will throw
+     *      an invariant error if undefined.
+     */
+    constructor(nativeModule?: NativeModule);
+    /**
+     * Add the specified listener, this call passes through to the NativeModule
+     * addListener
+     *
+     * @param eventType name of the event for which we are registering listener
+     * @param listener the listener function
+     * @param context context of the listener
+     */
+    addListener(eventType: string, listener: (event: any) => void, context?: Object): EmitterSubscription;
+    /**
+     * @param eventType  name of the event whose registered listeners to remove
+     */
+    removeAllListeners(eventType: string): void;
+    /**
+     * Removes a subscription created by the addListener, the EventSubscription#remove()
+     * function actually calls through to this.
+     */
+    removeSubscription(subscription: EmitterSubscription): void;
+}
+/**
+ * @see https://reactnative.dev/docs/platform-specific-code#content
+ */
+export declare type PlatformOSType = "ios" | "android" | "macos" | "windows" | "web" | "native";
+export {};

package/dist/cjs/api/bluetooth/react-native/types/ReactNativeTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+// This is a subset of React Native's types
+// EmitterSubscription
+// EventSubscription
+// EventSubscriptionVendor
+// EventEmitter
+// NativeModule
+// NativeEventEmitter
+// PlatformOSType
+Object.defineProperty(exports, "__esModule", { value: true });