@bota.dev/web-app-sdk 2.0.0-beta.0

package/dist/webBluetoothTransport.d.ts

@@ -0,0 +1,23 @@
+import { type BrowserBluetoothTransport, type BrowserDeviceHandle, type BrowserNotification, type BrowserSubscription } from './transport.ts';
+export declare class WebBluetoothTransport implements BrowserBluetoothTransport {
+    readonly maximumWriteValueLength = 128;
+    private readonly connections;
+    private readonly connectionTeardowns;
+    get isSupported(): boolean;
+    get supportsAuthorizedDevices(): boolean;
+    requestDevice(): Promise<BrowserDeviceHandle>;
+    getAuthorizedDevices(): Promise<BrowserDeviceHandle[]>;
+    connect(device: BrowserDeviceHandle): Promise<void>;
+    discoverServices(device: BrowserDeviceHandle): Promise<void>;
+    read(device: BrowserDeviceHandle, serviceUuid: string, characteristicUuid: string): Promise<Uint8Array>;
+    write(device: BrowserDeviceHandle, serviceUuid: string, characteristicUuid: string, value: Uint8Array, withResponse: boolean): Promise<void>;
+    subscribe(device: BrowserDeviceHandle, serviceUuid: string, characteristicUuid: string, listener: (notification: BrowserNotification) => void): Promise<BrowserSubscription>;
+    disconnect(device: BrowserDeviceHandle): Promise<void>;
+    onDisconnected(device: BrowserDeviceHandle, listener: () => void): () => void;
+    private connection;
+    private assertCurrent;
+    private characteristic;
+    private invalidateConnection;
+    private detachConnection;
+    private clearConnectionTeardown;
+}

package/dist/webBluetoothTransport.js

@@ -0,0 +1,369 @@
+import { canonicalGattUuid, FOREGROUND_GATT_SERVICES, } from "./gatt.js";
+import { BrowserTransportError, } from "./transport.js";
+const MAXIMUM_WRITE_VALUE_LENGTH = 128;
+export class WebBluetoothTransport {
+    maximumWriteValueLength = MAXIMUM_WRITE_VALUE_LENGTH;
+    connections = new Map();
+    connectionTeardowns = new Map();
+    get isSupported() {
+        return typeof browserBluetooth()?.requestDevice === 'function';
+    }
+    get supportsAuthorizedDevices() {
+        return this.isSupported && typeof browserBluetooth()?.getDevices === 'function';
+    }
+    async requestDevice() {
+        const bluetooth = browserBluetooth();
+        if (!bluetooth || typeof bluetooth.requestDevice !== 'function') {
+            throw new BrowserTransportError('unavailable');
+        }
+        try {
+            return deviceHandle(await bluetooth.requestDevice({
+                filters: [{ namePrefix: 'Bota' }],
+                optionalServices: [...FOREGROUND_GATT_SERVICES],
+            }));
+        }
+        catch (error) {
+            throw sanitizeDomError(error, 'picker');
+        }
+    }
+    async getAuthorizedDevices() {
+        const bluetooth = browserBluetooth();
+        if (!bluetooth || typeof bluetooth.getDevices !== 'function') {
+            throw new BrowserTransportError('unavailable');
+        }
+        try {
+            return (await bluetooth.getDevices()).map(deviceHandle);
+        }
+        catch (error) {
+            throw sanitizeDomError(error, 'availability');
+        }
+    }
+    async connect(device) {
+        const native = nativeDevice(device);
+        if (!native.gatt)
+            throw new BrowserTransportError('unavailable');
+        try {
+            const existing = this.connections.get(device.id);
+            if (existing) {
+                await this.detachConnection(device.id, existing);
+            }
+            else {
+                await this.connectionTeardowns.get(device.id);
+            }
+            const server = await native.gatt.connect();
+            if (!server.connected)
+                throw new BrowserTransportError('disconnected');
+            let cache;
+            const disconnectedListener = () => {
+                if (this.connections.get(device.id) === cache) {
+                    this.invalidateConnection(device.id);
+                }
+            };
+            cache = {
+                native,
+                server,
+                services: new Map(),
+                characteristics: new Map(),
+                notificationSessions: new Map(),
+                disconnectedListener,
+            };
+            this.connections.set(device.id, cache);
+            native.addEventListener('gattserverdisconnected', disconnectedListener);
+        }
+        catch (error) {
+            throw sanitizeDomError(error, 'gatt');
+        }
+    }
+    async discoverServices(device) {
+        const cache = this.connection(device);
+        try {
+            const services = await cache.server.getPrimaryServices();
+            this.assertCurrent(device.id, cache);
+            for (const service of services) {
+                cache.services.set(canonicalGattUuid(service.uuid), service);
+            }
+        }
+        catch (error) {
+            throw sanitizeDomError(error, 'gatt');
+        }
+    }
+    async read(device, serviceUuid, characteristicUuid) {
+        try {
+            const characteristic = await this.characteristic(device, serviceUuid, characteristicUuid);
+            return cloneDataView(await characteristic.readValue());
+        }
+        catch (error) {
+            throw sanitizeDomError(error, 'characteristic');
+        }
+    }
+    async write(device, serviceUuid, characteristicUuid, value, withResponse) {
+        let ownedValue = null;
+        try {
+            const characteristic = await this.characteristic(device, serviceUuid, characteristicUuid);
+            ownedValue = new Uint8Array(value.length);
+            ownedValue.set(value);
+            if (withResponse) {
+                await characteristic.writeValueWithResponse(ownedValue);
+            }
+            else {
+                await characteristic.writeValueWithoutResponse(ownedValue);
+            }
+        }
+        catch (error) {
+            throw sanitizeDomError(error, 'characteristic');
+        }
+        finally {
+            ownedValue?.fill(0);
+        }
+    }
+    async subscribe(device, serviceUuid, characteristicUuid, listener) {
+        const cache = this.connection(device);
+        let subscription = null;
+        try {
+            const characteristic = await this.characteristic(device, serviceUuid, characteristicUuid);
+            this.assertCurrent(device.id, cache);
+            let session = cache.notificationSessions.get(characteristic);
+            if (session?.isStopping) {
+                await session.teardown();
+                this.assertCurrent(device.id, cache);
+                session = cache.notificationSessions.get(characteristic);
+            }
+            if (!session) {
+                let created;
+                created = new WebBluetoothNotificationSession(characteristic, () => {
+                    if (cache.notificationSessions.get(characteristic) === created) {
+                        cache.notificationSessions.delete(characteristic);
+                    }
+                });
+                cache.notificationSessions.set(characteristic, created);
+                session = created;
+            }
+            subscription = session.add(listener);
+            await session.start();
+            this.assertCurrent(device.id, cache);
+            return subscription;
+        }
+        catch (error) {
+            await subscription?.remove().catch(() => undefined);
+            throw sanitizeDomError(error, 'characteristic');
+        }
+    }
+    async disconnect(device) {
+        const native = nativeDevice(device);
+        const cache = this.connections.get(device.id);
+        const teardown = cache
+            ? this.detachConnection(device.id, cache)
+            : this.connectionTeardowns.get(device.id);
+        let teardownError = null;
+        try {
+            await teardown;
+        }
+        catch (error) {
+            teardownError = error;
+        }
+        try {
+            native.gatt?.disconnect();
+        }
+        catch (error) {
+            if (!teardownError)
+                teardownError = sanitizeDomError(error, 'gatt');
+        }
+        if (teardownError)
+            throw teardownError;
+    }
+    onDisconnected(device, listener) {
+        const native = nativeDevice(device);
+        native.addEventListener('gattserverdisconnected', listener);
+        return () => native.removeEventListener('gattserverdisconnected', listener);
+    }
+    connection(device) {
+        const cache = this.connections.get(device.id);
+        if (!cache?.server.connected) {
+            this.invalidateConnection(device.id);
+            throw new BrowserTransportError('disconnected');
+        }
+        return cache;
+    }
+    assertCurrent(deviceId, cache) {
+        if (this.connections.get(deviceId) !== cache || !cache.server.connected) {
+            throw new BrowserTransportError('disconnected');
+        }
+    }
+    async characteristic(device, serviceUuid, characteristicUuid) {
+        const cache = this.connection(device);
+        const serviceKey = canonicalGattUuid(serviceUuid);
+        const characteristicKey = `${serviceKey}:${canonicalGattUuid(characteristicUuid)}`;
+        const cached = cache.characteristics.get(characteristicKey);
+        if (cached)
+            return cached;
+        let service = cache.services.get(serviceKey);
+        if (!service) {
+            service = await cache.server.getPrimaryService(serviceUuid);
+            this.assertCurrent(device.id, cache);
+            cache.services.set(serviceKey, service);
+        }
+        const characteristic = await service.getCharacteristic(characteristicUuid);
+        this.assertCurrent(device.id, cache);
+        cache.characteristics.set(characteristicKey, characteristic);
+        return characteristic;
+    }
+    invalidateConnection(deviceId) {
+        const cache = this.connections.get(deviceId);
+        if (!cache)
+            return;
+        void this.detachConnection(deviceId, cache).catch(() => undefined);
+    }
+    detachConnection(deviceId, cache) {
+        if (this.connections.get(deviceId) !== cache) {
+            return this.connectionTeardowns.get(deviceId) ?? Promise.resolve();
+        }
+        this.connections.delete(deviceId);
+        cache.native.removeEventListener('gattserverdisconnected', cache.disconnectedListener);
+        const teardowns = [...cache.notificationSessions.values()].map((session) => session.teardown());
+        const teardown = Promise.allSettled(teardowns).then((outcomes) => {
+            const failure = outcomes.find((outcome) => outcome.status === 'rejected');
+            if (failure?.status === 'rejected')
+                throw failure.reason;
+        });
+        this.connectionTeardowns.set(deviceId, teardown);
+        void teardown.then(() => this.clearConnectionTeardown(deviceId, teardown), () => this.clearConnectionTeardown(deviceId, teardown));
+        cache.notificationSessions.clear();
+        cache.characteristics.clear();
+        cache.services.clear();
+        return teardown;
+    }
+    clearConnectionTeardown(deviceId, teardown) {
+        if (this.connectionTeardowns.get(deviceId) === teardown) {
+            this.connectionTeardowns.delete(deviceId);
+        }
+    }
+}
+class WebBluetoothNotificationSession {
+    characteristic;
+    onStopped;
+    listeners = new Map();
+    eventListener;
+    startPromise = null;
+    stopPromise = null;
+    constructor(characteristic, onStopped) {
+        this.characteristic = characteristic;
+        this.onStopped = onStopped;
+        this.eventListener = () => {
+            if (!this.characteristic.value)
+                return;
+            for (const listener of [...this.listeners.values()]) {
+                try {
+                    listener({
+                        characteristicUuid: this.characteristic.uuid,
+                        value: cloneDataView(this.characteristic.value),
+                    });
+                }
+                catch {
+                    // A consumer callback cannot block or escape the shared DOM listener.
+                }
+            }
+        };
+        characteristic.addEventListener('characteristicvaluechanged', this.eventListener);
+    }
+    get isStopping() {
+        return this.stopPromise !== null;
+    }
+    add(listener) {
+        if (this.stopPromise)
+            throw new BrowserTransportError('unavailable');
+        const subscription = new WebBluetoothSubscription(this);
+        this.listeners.set(subscription, listener);
+        return subscription;
+    }
+    start() {
+        this.startPromise ??= this.characteristic.startNotifications()
+            .then(() => undefined)
+            .catch((error) => {
+            throw sanitizeDomError(error, 'characteristic');
+        });
+        return this.startPromise;
+    }
+    remove(subscription) {
+        this.listeners.delete(subscription);
+        if (this.listeners.size > 0)
+            return Promise.resolve();
+        return this.teardown();
+    }
+    teardown() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        this.characteristic.removeEventListener('characteristicvaluechanged', this.eventListener);
+        const stopping = this.startPromise
+            ? this.startPromise.then(() => this.characteristic.stopNotifications())
+            : Promise.resolve();
+        this.stopPromise = stopping
+            .then(() => undefined)
+            .catch((error) => {
+            throw sanitizeDomError(error, 'gatt');
+        })
+            .finally(this.onStopped);
+        for (const subscription of this.listeners.keys()) {
+            subscription.useTeardown(this.stopPromise);
+        }
+        this.listeners.clear();
+        return this.stopPromise;
+    }
+}
+class WebBluetoothSubscription {
+    session;
+    removePromise = null;
+    constructor(session) {
+        this.session = session;
+    }
+    remove() {
+        this.removePromise ??= this.session.remove(this);
+        return this.removePromise;
+    }
+    useTeardown(teardown) {
+        this.removePromise ??= teardown;
+    }
+}
+function browserBluetooth() {
+    if (typeof navigator === 'undefined')
+        return null;
+    return navigator.bluetooth ?? null;
+}
+function deviceHandle(device) {
+    return { id: device.id, name: device.name ?? null, nativeValue: device };
+}
+function nativeDevice(device) {
+    if (!device.nativeValue)
+        throw new BrowserTransportError('unavailable');
+    return device.nativeValue;
+}
+function cloneDataView(value) {
+    const copy = new Uint8Array(value.byteLength);
+    copy.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    return copy;
+}
+function sanitizeDomError(error, context) {
+    if (error instanceof BrowserTransportError)
+        return error;
+    const name = domErrorName(error);
+    if (context === 'picker' && (name === 'AbortError' || name === 'NotFoundError')) {
+        return new BrowserTransportError('picker_cancelled', { cause: error });
+    }
+    if (name === 'NotAllowedError' || name === 'SecurityError') {
+        return new BrowserTransportError('permission_denied', { cause: error });
+    }
+    if (context === 'characteristic' && name === 'NotFoundError') {
+        return new BrowserTransportError('characteristic_not_found', { cause: error });
+    }
+    if (name === 'InvalidStateError' || name === 'NetworkError') {
+        return new BrowserTransportError('disconnected', { cause: error });
+    }
+    if (name === 'NotReadableError' || name === 'NotSupportedError') {
+        return new BrowserTransportError('unavailable', { cause: error });
+    }
+    return new BrowserTransportError('unavailable', { cause: error });
+}
+function domErrorName(error) {
+    return typeof error === 'object' && error !== null && 'name' in error
+        ? String(error.name)
+        : '';
+}

package/dist/wifiManager.d.ts

@@ -0,0 +1,54 @@
+import type { CoreBridge } from './core.ts';
+import { DeviceManager } from './deviceManager.ts';
+import { type BotaOperation } from './errors.ts';
+import type { WiFiConfigResult, WiFiCredentials, WiFiScanResult, WiFiStatusInfo, WiFiStatusSubscription } from './models.ts';
+import { type BrowserBluetoothTransport, type BrowserDeviceHandle, type BrowserNotification } from './transport.ts';
+import { BrowserWorkflowRuntime } from './workflowRuntime.ts';
+interface WiFiManagerOptions {
+    core: CoreBridge;
+    transport: BrowserBluetoothTransport;
+    runtime: BrowserWorkflowRuntime;
+    devices: DeviceManager;
+    operationTimeoutMs?: number | undefined;
+}
+interface SubscriptionOptions<T> {
+    runtime: BrowserWorkflowRuntime;
+    transport: BrowserBluetoothTransport;
+    device: BrowserDeviceHandle;
+    serviceUuid: string;
+    characteristicUuid: string;
+    operation: BotaOperation;
+    signal: AbortSignal;
+    listener(notification: BrowserNotification): void;
+    beforeSubscribe?: (() => Promise<void>) | undefined;
+    body(): Promise<T>;
+}
+export declare class WiFiManager {
+    private readonly core;
+    private readonly transport;
+    private readonly runtime;
+    private readonly devices;
+    private readonly operationTimeoutMs;
+    private readonly removeDisconnectListener;
+    private activeOperation;
+    private statusOwner;
+    private destroyed;
+    private destroyPromise;
+    constructor(options: WiFiManagerOptions);
+    scanNetworks(): Promise<WiFiScanResult>;
+    configure(credentials: WiFiCredentials, grant: string): Promise<WiFiConfigResult>;
+    disconnect(): Promise<WiFiConfigResult>;
+    readStatus(): Promise<WiFiStatusInfo>;
+    subscribeToStatus(listener: (status: WiFiStatusInfo) => void): Promise<WiFiStatusSubscription>;
+    private subscribeToVerifiedStatus;
+    destroy(): Promise<void>;
+    private configureWithSubscription;
+    private runManaged;
+    private verifyConnectedDevice;
+    private requireConnectedDevice;
+    private normalizeFailure;
+    private closeStatusOwner;
+    private requireUsable;
+}
+export declare function withSubscription<T>(options: SubscriptionOptions<T>): Promise<T>;
+export {};