@ukeyfe/hardware-transport-web-device 1.1.13

package/dist/index.js

@@ -0,0 +1,552 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var transport = require('@ukeyfe/hardware-transport');
+var hardwareShared = require('@ukeyfe/hardware-shared');
+var ByteBuffer = require('bytebuffer');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var transport__default = /*#__PURE__*/_interopDefaultLegacy(transport);
+var ByteBuffer__default = /*#__PURE__*/_interopDefaultLegacy(ByteBuffer);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(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());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const { parseConfigure: parseConfigure$1, buildEncodeBuffers, decodeProtocol, receiveOne: receiveOne$1, check: check$1 } = transport__default["default"];
+const CONFIGURATION_ID = 1;
+const INTERFACE_ID = 0;
+const ENDPOINT_ID = 1;
+const PACKET_SIZE = 64;
+const HEADER_LENGTH = 6;
+class WebUsbTransport {
+    constructor() {
+        this.name = 'WebUsbTransport';
+        this.stopped = false;
+        this.configured = false;
+        this.deviceList = [];
+        this.configurationId = CONFIGURATION_ID;
+        this.endpointId = ENDPOINT_ID;
+        this.interfaceId = INTERFACE_ID;
+    }
+    init(logger) {
+        this.Log = logger;
+        const { usb } = navigator;
+        if (!usb) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'WebUSB is not supported by current browsers');
+        }
+        this.usb = usb;
+    }
+    configure(signedData) {
+        const messages = parseConfigure$1(signedData);
+        this.configured = true;
+        this.messages = messages;
+    }
+    promptDeviceAccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.usb)
+                return null;
+            try {
+                const device = yield this.usb.requestDevice({ filters: hardwareShared.UKEY_WEBUSB_FILTER });
+                return device;
+            }
+            catch (e) {
+                this.Log.debug('requestDevice error: ', e);
+                return null;
+            }
+        });
+    }
+    enumerate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getConnectedDevices();
+            return this.deviceList;
+        });
+    }
+    getConnectedDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.usb)
+                return [];
+            const devices = yield this.usb.getDevices();
+            const ukeyDevices = devices.filter(dev => {
+                const isUKey = hardwareShared.UKEY_WEBUSB_FILTER.some(desc => dev.vendorId === desc.vendorId && dev.productId === desc.productId);
+                const hasSerialNumber = typeof dev.serialNumber === 'string' && dev.serialNumber.length > 0;
+                return isUKey && hasSerialNumber;
+            });
+            this.deviceList = ukeyDevices.map(device => ({
+                path: device.serialNumber,
+                device,
+            }));
+            return this.deviceList;
+        });
+    }
+    acquire(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!input.path)
+                return;
+            try {
+                yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
+                return yield Promise.resolve(input.path);
+            }
+            catch (e) {
+                this.Log.debug('acquire error: ', e);
+                throw e;
+            }
+        });
+    }
+    findDevice(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deviceList.length === 0) {
+                yield this.getConnectedDevices();
+            }
+            let device = this.deviceList.find(d => d.path === path);
+            if (device == null) {
+                yield this.getConnectedDevices();
+                device = this.deviceList.find(d => d.path === path);
+                if (device == null) {
+                    throw new Error('Action was interrupted.');
+                }
+            }
+            return device.device;
+        });
+    }
+    connect(path, first) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxRetries = 5;
+            for (let i = 0; i < maxRetries; i++) {
+                try {
+                    return yield this.connectToDevice(path, first);
+                }
+                catch (e) {
+                    if (i === maxRetries - 1) {
+                        throw e;
+                    }
+                    yield hardwareShared.wait(i * 200);
+                }
+            }
+        });
+    }
+    connectToDevice(path, first) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            yield device.open();
+            if (first) {
+                yield device.selectConfiguration(this.configurationId);
+                try {
+                    yield device.reset();
+                }
+                catch (error) {
+                }
+            }
+            yield device.claimInterface(this.interfaceId);
+        });
+    }
+    post(session, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call(session, name, data);
+        });
+    }
+    call(path, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.messages == null) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const device = yield this.findDevice(path);
+            if (!device) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.DeviceNotFound);
+            }
+            const { messages } = this;
+            if (transport.LogBlockCommand.has(name)) {
+                this.Log.debug('call-', ' name: ', name);
+            }
+            else {
+                this.Log.debug('call-', ' name: ', name, ' data: ', data);
+            }
+            const encodeBuffers = buildEncodeBuffers(messages, name, data);
+            for (const buffer of encodeBuffers) {
+                const newArray = new Uint8Array(PACKET_SIZE);
+                newArray[0] = 63;
+                newArray.set(new Uint8Array(buffer), 1);
+                if (!device.opened) {
+                    yield this.connect(path, false);
+                }
+                yield device.transferOut(this.endpointId, newArray);
+            }
+            const resData = yield this.receiveData(path);
+            if (typeof resData !== 'string') {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
+            }
+            const jsonData = receiveOne$1(messages, resData);
+            return check$1.call(jsonData);
+        });
+    }
+    receiveData(path) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            if (!device.opened) {
+                yield this.connect(path, false);
+            }
+            const firstPacket = yield device.transferIn(this.endpointId, PACKET_SIZE);
+            const firstData = (_a = firstPacket.data) === null || _a === void 0 ? void 0 : _a.buffer.slice(1);
+            console.log('receive first packet: ', firstPacket);
+            const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(firstData);
+            console.log('chunk length: ', length);
+            const lengthWithHeader = Number(length + HEADER_LENGTH);
+            const decoded = new ByteBuffer__default["default"](lengthWithHeader);
+            decoded.writeUint16(typeId);
+            decoded.writeUint32(length);
+            if (length) {
+                decoded.append(restBuffer);
+            }
+            console.log('first decoded: ', decoded);
+            while (decoded.offset < lengthWithHeader) {
+                const res = yield device.transferIn(this.endpointId, PACKET_SIZE);
+                if (!res.data) {
+                    throw new Error('no data');
+                }
+                if (res.data.byteLength === 0) {
+                    console.warn('empty data');
+                }
+                const buffer = res.data.buffer.slice(1);
+                if (lengthWithHeader - decoded.offset >= PACKET_SIZE) {
+                    decoded.append(buffer);
+                }
+                else {
+                    decoded.append(buffer.slice(0, lengthWithHeader - decoded.offset));
+                }
+            }
+            decoded.reset();
+            const result = decoded.toBuffer();
+            return Buffer.from(result).toString('hex');
+        });
+    }
+    release(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            yield device.releaseInterface(this.interfaceId);
+            yield device.close();
+        });
+    }
+}
+
+const { parseConfigure, buildBuffers, receiveOne, check } = transport__default["default"];
+class ElectronBleTransport {
+    constructor() {
+        this.name = 'ElectronBleTransport';
+        this.configured = false;
+        this.runPromise = null;
+        this.connectedDevices = new Set();
+        this.dataBuffers = new Map();
+        this.notificationCleanups = new Map();
+        this.disconnectCleanups = new Map();
+    }
+    handleBluetoothError(error) {
+        if (error && typeof error === 'object') {
+            if ('code' in error) {
+                if (error.code === hardwareShared.HardwareErrorCode.BlePoweredOff) {
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BlePoweredOff);
+                }
+                if (error.code === hardwareShared.HardwareErrorCode.BleUnsupported) {
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleUnsupported);
+                }
+                if (error.code === hardwareShared.HardwareErrorCode.BlePermissionError) {
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BlePermissionError);
+                }
+            }
+            const errorMessage = error.message || String(error);
+            const poweredOffMessage = hardwareShared.HardwareErrorCodeMessage[hardwareShared.HardwareErrorCode.BlePoweredOff];
+            const unsupportedMessage = hardwareShared.HardwareErrorCodeMessage[hardwareShared.HardwareErrorCode.BleUnsupported];
+            const permissionMessage = hardwareShared.HardwareErrorCodeMessage[hardwareShared.HardwareErrorCode.BlePermissionError];
+            if (errorMessage.includes(poweredOffMessage) || errorMessage.includes('poweredOff')) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BlePoweredOff);
+            }
+            if (errorMessage.includes(unsupportedMessage) || errorMessage.includes('unsupported')) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleUnsupported);
+            }
+            if (errorMessage.includes(permissionMessage) || errorMessage.includes('unauthorized')) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BlePermissionError);
+            }
+        }
+        throw error;
+    }
+    cleanupDeviceState(deviceId) {
+        this.connectedDevices.delete(deviceId);
+        this.dataBuffers.delete(deviceId);
+        const notifyCleanup = this.notificationCleanups.get(deviceId);
+        if (notifyCleanup) {
+            notifyCleanup();
+            this.notificationCleanups.delete(deviceId);
+        }
+        const disconnectCleanup = this.disconnectCleanups.get(deviceId);
+        if (disconnectCleanup) {
+            disconnectCleanup();
+            this.disconnectCleanups.delete(deviceId);
+        }
+    }
+    init(logger, emitter) {
+        var _a, _b;
+        this.Log = logger;
+        this.emitter = emitter;
+        if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Noble BLE API is not available. Please ensure you are running in Electron with Noble support.');
+        }
+        (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Noble BLE Transport initialized');
+    }
+    configure(signedData) {
+        const messages = parseConfigure(signedData);
+        this.configured = true;
+        this._messages = messages;
+    }
+    listen() { }
+    enumerate() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
+                    throw new Error('Noble BLE API not available');
+                }
+                const devices = yield window.desktopApi.nobleBle.enumerate();
+                return devices;
+            }
+            catch (error) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Transport] Noble BLE enumerate failed:', error);
+                this.handleBluetoothError(error);
+            }
+        });
+    }
+    acquire(input) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { uuid, forceCleanRunPromise } = input;
+            if (!uuid) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleRequiredUUID);
+            }
+            if (forceCleanRunPromise && this.runPromise) {
+                this.runPromise.reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleForceCleanRunPromise));
+            }
+            try {
+                if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
+                    throw new Error('Noble BLE API not available');
+                }
+                const device = yield window.desktopApi.nobleBle.getDevice(uuid);
+                if (!device) {
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.DeviceNotFound, `Device ${uuid} not found`);
+                }
+                try {
+                    yield window.desktopApi.nobleBle.connect(uuid);
+                    this.connectedDevices.add(uuid);
+                }
+                catch (error) {
+                    this.handleBluetoothError(error);
+                }
+                this.dataBuffers.set(uuid, { buffer: [], bufferLength: 0 });
+                yield window.desktopApi.nobleBle.subscribe(uuid);
+                const cleanup = window.desktopApi.nobleBle.onNotification((deviceId, data) => {
+                    if (deviceId === uuid) {
+                        this.handleNotificationData(uuid, data);
+                    }
+                });
+                this.notificationCleanups.set(uuid, cleanup);
+                const disconnectCleanup = window.desktopApi.nobleBle.onDeviceDisconnected((disconnectedDevice) => {
+                    var _a;
+                    if (disconnectedDevice.id === uuid) {
+                        this.cleanupDeviceState(uuid);
+                        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-disconnect', {
+                            name: disconnectedDevice.name,
+                            id: disconnectedDevice.id,
+                            connectId: disconnectedDevice.id,
+                        });
+                    }
+                });
+                this.disconnectCleanups.set(uuid, disconnectCleanup);
+                (_b = this.emitter) === null || _b === void 0 ? void 0 : _b.emit('device-connect', {
+                    name: device.name,
+                    id: device.id,
+                    connectId: device.id,
+                });
+                return { uuid, path: uuid };
+            }
+            catch (error) {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Transport] Noble BLE acquire failed:', error);
+                throw error;
+            }
+        });
+    }
+    release(id) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.connectedDevices.has(id)) {
+                    if ((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) {
+                        yield window.desktopApi.nobleBle.unsubscribe(id);
+                    }
+                    if ((_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.nobleBle) {
+                        yield window.desktopApi.nobleBle.disconnect(id);
+                    }
+                    this.cleanupDeviceState(id);
+                }
+            }
+            catch (error) {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Transport] Noble BLE release failed:', error);
+                this.cleanupDeviceState(id);
+            }
+        });
+    }
+    handleNotificationData(deviceId, hexData) {
+        var _a, _b;
+        if (hexData === 'PAIRING_REJECTED') {
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Pairing rejection detected for device:', deviceId);
+            if (this.runPromise) {
+                this.runPromise.reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleDeviceBondedCanceled));
+            }
+            return;
+        }
+        const result = this.processNotificationPacket(deviceId, hexData);
+        if (result.error) {
+            (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Transport] Packet processing error:', result.error);
+            if (this.runPromise) {
+                this.runPromise.reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleWriteCharacteristicError));
+            }
+            return;
+        }
+        if (result.isComplete && result.completePacket) {
+            if (this.runPromise) {
+                this.runPromise.resolve(result.completePacket);
+            }
+        }
+    }
+    call(uuid, name, data) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._messages == null) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const forceRun = name === 'Initialize' || name === 'Cancel';
+            if (this.runPromise && !forceRun) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportCallInProgress);
+            }
+            if (!this.connectedDevices.has(uuid)) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotFound, `Device ${uuid} not connected`);
+            }
+            this.runPromise = hardwareShared.createDeferred();
+            const messages = this._messages;
+            if (name === 'ResourceUpdate' || name === 'ResourceAck') {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Noble BLE call', 'name:', name, 'data:', {
+                    file_name: data === null || data === void 0 ? void 0 : data.file_name,
+                    hash: data === null || data === void 0 ? void 0 : data.hash,
+                });
+            }
+            else if (transport.LogBlockCommand.has(name)) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Noble BLE call', 'name:', name);
+            }
+            else {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Noble BLE call', 'name:', name, 'data:', data);
+            }
+            const buffers = buildBuffers(messages, name, data);
+            try {
+                if (!((_d = window.desktopApi) === null || _d === void 0 ? void 0 : _d.nobleBle)) {
+                    throw new Error('Noble BLE write API not available');
+                }
+                for (let i = 0; i < buffers.length; i++) {
+                    const buffer = buffers[i];
+                    if (!buffer || typeof buffer.toString !== 'function') {
+                        (_e = this.Log) === null || _e === void 0 ? void 0 : _e.error(`[Transport] Noble BLE buffer ${i + 1} is invalid:`, buffer);
+                        throw new Error(`Buffer ${i + 1} is invalid`);
+                    }
+                    const hexString = buffer.toString('hex');
+                    if (hexString.length === 0) {
+                        (_f = this.Log) === null || _f === void 0 ? void 0 : _f.error(`[Transport] Noble BLE buffer ${i + 1} generated empty hex string`);
+                        throw new Error(`Buffer ${i + 1} is empty`);
+                    }
+                    yield window.desktopApi.nobleBle.write(uuid, hexString);
+                }
+                const response = yield this.runPromise.promise;
+                if (typeof response !== 'string') {
+                    throw new Error('Returning data is not string.');
+                }
+                const jsonData = receiveOne(messages, response);
+                return check.call(jsonData);
+            }
+            catch (e) {
+                (_g = this.Log) === null || _g === void 0 ? void 0 : _g.error('[Transport] Noble BLE call error:', e);
+                throw e;
+            }
+            finally {
+                this.runPromise = null;
+            }
+        });
+    }
+    processNotificationPacket(deviceId, hexData) {
+        try {
+            if (typeof hexData !== 'string') {
+                return { isComplete: false, error: 'Invalid hexData type' };
+            }
+            const cleanHexData = hexData.replace(/\s+/g, '');
+            if (!/^[0-9A-Fa-f]*$/.test(cleanHexData)) {
+                return { isComplete: false, error: 'Invalid hex data format' };
+            }
+            const hexMatch = cleanHexData.match(/.{1,2}/g);
+            if (!hexMatch) {
+                return { isComplete: false, error: 'Failed to parse hex data' };
+            }
+            const data = new Uint8Array(hexMatch.map(byte => parseInt(byte, 16)));
+            const bufferState = this.dataBuffers.get(deviceId);
+            if (!bufferState) {
+                return { isComplete: false, error: 'No buffer state for device' };
+            }
+            if (hardwareShared.isHeaderChunk(data)) {
+                const dataView = new DataView(data.buffer);
+                bufferState.bufferLength = dataView.getInt32(5, false);
+                bufferState.buffer = [...data.subarray(3)];
+            }
+            else {
+                bufferState.buffer = bufferState.buffer.concat([...data]);
+            }
+            if (bufferState.buffer.length - transport.COMMON_HEADER_SIZE >= bufferState.bufferLength) {
+                const completeBuffer = new Uint8Array(bufferState.buffer);
+                bufferState.bufferLength = 0;
+                bufferState.buffer = [];
+                const hexString = Array.from(completeBuffer)
+                    .map(b => b.toString(16).padStart(2, '0'))
+                    .join('');
+                return { isComplete: true, completePacket: hexString };
+            }
+            return { isComplete: false };
+        }
+        catch (error) {
+            return { isComplete: false, error: `Packet processing error: ${error}` };
+        }
+    }
+}
+
+exports.ElectronBleTransport = ElectronBleTransport;
+exports.WebUsbTransport = WebUsbTransport;

package/dist/webusb.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="w3c-web-usb" />
+import transport, { AcquireInput } from '@ukeyfe/hardware-transport';
+interface DeviceInfo {
+    path: string;
+    device: USBDevice;
+}
+export default class WebUsbTransport {
+    messages: ReturnType<typeof transport.parseConfigure> | undefined;
+    name: string;
+    stopped: boolean;
+    configured: boolean;
+    Log?: any;
+    usb?: USB;
+    deviceList: Array<DeviceInfo>;
+    configurationId: number;
+    endpointId: number;
+    interfaceId: number;
+    init(logger: any): void;
+    configure(signedData: any): void;
+    promptDeviceAccess(): Promise<USBDevice | null>;
+    enumerate(): Promise<DeviceInfo[]>;
+    getConnectedDevices(): Promise<DeviceInfo[]>;
+    acquire(input: AcquireInput): Promise<string | undefined>;
+    findDevice(path: string): Promise<USBDevice>;
+    connect(path: string, first: boolean): Promise<void>;
+    connectToDevice(path: string, first: boolean): Promise<void>;
+    post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
+    call(path: string, name: string, data: Record<string, unknown>): Promise<import("@ukeyfe/hardware-transport").MessageFromUKey>;
+    receiveData(path: string): Promise<string>;
+    release(path: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=webusb.d.ts.map

package/dist/webusb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":";AACA,OAAO,SAAS,EAAE,EAAE,YAAY,EAAmB,MAAM,4BAA4B,CAAC;AAetF,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,CAAC;CACnB;AAED,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAElE,IAAI,SAAqB;IAEzB,OAAO,UAAS;IAEhB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,GAAG,CAAC,EAAE,GAAG,CAAC;IAMV,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAM;IAEnC,eAAe,SAAoB;IAEnC,UAAU,SAAe;IAEzB,WAAW,SAAgB;IAK3B,IAAI,CAAC,MAAM,EAAE,GAAG;IAgBhB,SAAS,CAAC,UAAU,EAAE,GAAG;IAWnB,kBAAkB;IAgBlB,SAAS;IAQT,mBAAmB;IAuBnB,OAAO,CAAC,KAAK,EAAE,YAAY;IAc3B,UAAU,CAAC,IAAI,EAAE,MAAM;IAwBvB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAiBpC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAgB5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAOjE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAyC9D,WAAW,CAAC,IAAI,EAAE,MAAM;IAkDxB,OAAO,CAAC,IAAI,EAAE,MAAM;CAK3B"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@ukeyfe/hardware-transport-web-device",
+  "version": "1.1.13",
+  "author": "UKey",
+  "homepage": "https://github.com/UKeyHQ/hardware-js-sdk#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bestyourwallet/hardware-js-sdk"
+  },
+  "scripts": {
+    "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
+    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "dependencies": {
+    "@ukeyfe/hardware-shared": "1.1.13",
+    "@ukeyfe/hardware-transport": "1.1.13"
+  },
+  "devDependencies": {
+    "@ukeyfe/hardware-transport-electron": "1.1.13",
+    "@types/w3c-web-usb": "^1.0.6",
+    "@types/web-bluetooth": "^0.0.17"
+  }
+}