usb 2.5.2-alpha.1 → 2.6.0

package/tsc/webusb/index.ts

@@ -1,374 +0,0 @@
-import * as usb from '../usb';
-import { EventEmitter } from 'events';
-import { WebUSBDevice } from './webusb-device';
-
-/**
- * USB Options
- */
-export interface USBOptions {
-    /**
-     * Optional `device found` callback function to allow the user to select a device
-     */
-    devicesFound?: (devices: USBDevice[]) => Promise<USBDevice | void>;
-
-    /**
-     * Optional array of preconfigured allowed devices
-     */
-    allowedDevices?: USBDeviceFilter[];
-
-    /**
-     * Optional flag to automatically allow all devices
-     */
-    allowAllDevices?: boolean;
-
-    /**
-     * Optional timeout (in milliseconds) to use for the device control transfers
-     */
-    deviceTimeout?: number;
-}
-
-/**
- * Convenience method to get the WebUSB interface available
- */
-export const getWebUsb = (): USB => {
-    if (navigator && navigator.usb) {
-        return navigator.usb;
-    }
-
-    return new WebUSB();
-};
-
-export class WebUSB implements USB {
-
-    protected emitter = new EventEmitter();
-    protected knownDevices: Map<string, USBDevice> = new Map();
-    protected allowedDevices: USBDeviceFilter[];
-
-    constructor(private options: USBOptions = {}) {
-        this.allowedDevices = options.allowedDevices || [];
-
-        const deviceConnectCallback = async (device: usb.Device) => {
-            const webDevice = await WebUSBDevice.createInstance(device);
-
-            // When connected, emit an event if it is an allowed device
-            if (webDevice && this.isAllowedDevice(webDevice)) {
-                const deviceId = this.getDeviceId(device);
-                if (deviceId) {
-                    this.knownDevices.set(deviceId, webDevice);
-                }
-
-                const event = {
-                    type: 'connect',
-                    device: webDevice
-                };
-
-                this.emitter.emit('connect', event);
-            }
-        };
-
-        const deviceDisconnectCallback = async (device: usb.Device) => {
-            const deviceId = this.getDeviceId(device);
-
-            // When disconnected, emit an event if the device was a known allowed device
-            if (deviceId !== undefined && this.knownDevices.has(deviceId)) {
-                const webDevice = this.knownDevices.get(deviceId);
-
-                if (webDevice && this.isAllowedDevice(webDevice)) {
-                    const event = {
-                        type: 'disconnect',
-                        device: webDevice
-                    };
-
-                    this.emitter.emit('disconnect', event);
-                }
-            }
-        };
-
-        this.emitter.on('newListener', event => {
-            const listenerCount = this.emitter.listenerCount(event);
-
-            if (listenerCount !== 0) {
-                return;
-            }
-
-            if (event === 'connect') {
-                usb.addListener('attach', deviceConnectCallback);
-            } else if (event === 'disconnect') {
-                usb.addListener('detach', deviceDisconnectCallback);
-            }
-        });
-
-        this.emitter.on('removeListener', event => {
-            const listenerCount = this.emitter.listenerCount(event);
-
-            if (listenerCount !== 0) {
-                return;
-            }
-
-            if (event === 'connect') {
-                usb.removeListener('attach', deviceConnectCallback);
-            } else if (event === 'disconnect') {
-                usb.removeListener('detach', deviceDisconnectCallback);
-            }
-        });
-    }
-
-    private _onconnect: ((ev: USBConnectionEvent) => void) | undefined;
-    public set onconnect(fn: (ev: USBConnectionEvent) => void) {
-        if (this._onconnect) {
-            this.removeEventListener('connect', this._onconnect);
-            this._onconnect = undefined;
-        }
-
-        if (fn) {
-            this._onconnect = fn;
-            this.addEventListener('connect', this._onconnect);
-        }
-    }
-
-    private _ondisconnect: ((ev: USBConnectionEvent) => void) | undefined;
-    public set ondisconnect(fn: (ev: USBConnectionEvent) => void) {
-        if (this._ondisconnect) {
-            this.removeEventListener('disconnect', this._ondisconnect);
-            this._ondisconnect = undefined;
-        }
-
-        if (fn) {
-            this._ondisconnect = fn;
-            this.addEventListener('disconnect', this._ondisconnect);
-        }
-    }
-
-    public addEventListener(type: 'connect' | 'disconnect', listener: (this: this, ev: USBConnectionEvent) => void): void;
-    public addEventListener(type: 'connect' | 'disconnect', listener: EventListener): void;
-    public addEventListener(type: string, listener: (ev: USBConnectionEvent) => void): void {
-        this.emitter.addListener(type, listener);
-    }
-
-    public removeEventListener(type: 'connect' | 'disconnect', callback: (this: this, ev: USBConnectionEvent) => void): void;
-    public removeEventListener(type: 'connect' | 'disconnect', callback: EventListener): void;
-    public removeEventListener(type: string, callback: (this: this, ev: USBConnectionEvent) => void): void {
-        this.emitter.removeListener(type, callback);
-    }
-
-    public dispatchEvent(_event: Event): boolean {
-        // Don't dispatch from here
-        return false;
-    }
-
-    /**
-     * Requests a single Web USB device
-     * @param options The options to use when scanning
-     * @returns Promise containing the selected device
-     */
-    public async requestDevice(options?: USBDeviceRequestOptions): Promise<USBDevice> {
-        // Must have options
-        if (!options) {
-            throw new TypeError('requestDevice error: 1 argument required, but only 0 present');
-        }
-
-        // Options must be an object
-        if (options.constructor !== {}.constructor) {
-            throw new TypeError('requestDevice error: parameter 1 (options) is not an object');
-        }
-
-        // Must have a filter
-        if (!options.filters) {
-            throw new TypeError('requestDevice error: required member filters is undefined');
-        }
-
-        // Filter must be an array
-        if (options.filters.constructor !== [].constructor) {
-            throw new TypeError('requestDevice error: the provided value cannot be converted to a sequence');
-        }
-
-        // Check filters
-        options.filters.forEach(filter => {
-            // Protocol & Subclass
-            if (filter.protocolCode && !filter.subclassCode) {
-                throw new TypeError('requestDevice error: subclass code is required');
-            }
-
-            // Subclass & Class
-            if (filter.subclassCode && !filter.classCode) {
-                throw new TypeError('requestDevice error: class code is required');
-            }
-        });
-
-        let devices = await this.loadDevices(options.filters);
-        devices = devices.filter(device => this.filterDevice(options, device));
-
-        if (devices.length === 0) {
-            throw new Error('requestDevice error: no devices found');
-        }
-
-        try {
-            // If no devicesFound function, select the first device found
-            const device = this.options.devicesFound ? await this.options.devicesFound(devices) : devices[0];
-
-            if (!device) {
-                throw new Error('selected device not found');
-            }
-
-            if (!this.isAllowedDevice(device)) {
-                this.allowedDevices.push({
-                    vendorId: device.vendorId,
-                    productId: device.productId,
-                    serialNumber: device.serialNumber
-                });
-            }
-
-            return device;
-        } catch (error) {
-            throw new Error(`requestDevice error: ${error}`);
-        }
-    }
-
-    /**
-     * Gets all allowed Web USB devices which are connected
-     * @returns Promise containing an array of devices
-     */
-    public async getDevices(): Promise<USBDevice[]> {
-        let preFilters: USBDeviceFilter[] | undefined;
-
-        if (!this.options.allowAllDevices) {
-            // Create pre-filters
-            preFilters = this.allowedDevices.map(device => ({
-                vendorId: device.vendorId || undefined,
-                productId: device.productId || undefined,
-                serialNumber: device.serialNumber || undefined
-            }));
-        }
-
-        // Refresh devices and filter for allowed ones
-        const devices = await this.loadDevices(preFilters);
-        return devices.filter(device => this.isAllowedDevice(device));
-    }
-
-    private async loadDevices(preFilters?: USBDeviceFilter[]): Promise<USBDevice[]> {
-        let devices = usb.getDeviceList();
-
-        // Pre-filter devices
-        devices = this.preFilterDevices(devices, preFilters);
-
-        const webDevices: USBDevice[] = [];
-
-        for (const device of devices) {
-            if (this.options.deviceTimeout) {
-                device.timeout = this.options.deviceTimeout;
-            }
-
-            const webDevice = await WebUSBDevice.createInstance(device);
-            if (webDevice) {
-                webDevices.push(webDevice);
-
-                const deviceId = this.getDeviceId(device);
-                if (deviceId) {
-                    this.knownDevices.set(deviceId, webDevice);
-                }
-            }
-        }
-
-        return webDevices;
-    }
-
-    private preFilterDevices(devices: usb.Device[], preFilters?: USBDeviceFilter[]): usb.Device[] {
-        if (!preFilters || !preFilters.length) {
-            return devices;
-        }
-
-        // Just pre-filter on vid/pid
-        return devices.filter(device => preFilters.some(filter => {
-            // Vendor
-            if (filter.vendorId && filter.vendorId !== device.deviceDescriptor.idVendor) return false;
-
-            // Product
-            if (filter.productId && filter.productId !== device.deviceDescriptor.idProduct) return false;
-
-            // Ignore serial number for node-usb as it requires device connection
-            return true;
-        }));
-    }
-
-    private filterDevice(options: USBDeviceRequestOptions, device: USBDevice): boolean {
-        if (!options.filters || !options.filters.length) {
-            return true;
-        }
-
-        return options.filters.some(filter => {
-            // Vendor
-            if (filter.vendorId && filter.vendorId !== device.vendorId) return false;
-
-            // Product
-            if (filter.productId && filter.productId !== device.productId) return false;
-
-            // Class
-            if (filter.classCode) {
-
-                if (!device.configuration) {
-                    return false;
-                }
-
-                // Interface Descriptors
-                const match = device.configuration.interfaces.some(iface => {
-                    // Class
-                    if (filter.classCode && filter.classCode !== iface.alternate.interfaceClass) return false;
-
-                    // Subclass
-                    if (filter.subclassCode && filter.subclassCode !== iface.alternate.interfaceSubclass) return false;
-
-                    // Protocol
-                    if (filter.protocolCode && filter.protocolCode !== iface.alternate.interfaceProtocol) return false;
-
-                    return true;
-                });
-
-                if (match) {
-                    return true;
-                }
-            }
-
-            // Class
-            if (filter.classCode && filter.classCode !== device.deviceClass) return false;
-
-            // Subclass
-            if (filter.subclassCode && filter.subclassCode !== device.deviceSubclass) return false;
-
-            // Protocol
-            if (filter.protocolCode && filter.protocolCode !== device.deviceProtocol) return false;
-
-            // Serial
-            if (filter.serialNumber && filter.serialNumber !== device.serialNumber) return false;
-
-            return true;
-        });
-    }
-
-    private getDeviceId(device: usb.Device): string | undefined {
-        if (device.busNumber === undefined || device.deviceAddress === undefined) {
-            return undefined;
-        }
-
-        return `${device.busNumber}.${device.deviceAddress}`;
-    }
-
-    private isAllowedDevice(device: USBDeviceFilter): boolean {
-        if (this.options.allowAllDevices) {
-            return true;
-        }
-
-        const isSameDevice = (device1: USBDeviceFilter, device2: USBDeviceFilter): boolean => {
-            return (device1.productId === device2.productId
-                && device1.vendorId === device2.vendorId
-                && device1.serialNumber === device2.serialNumber);
-        };
-
-        for (const i in this.allowedDevices) {
-            if (isSameDevice(device, this.allowedDevices[i])) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-}