@simplysm/capacitor-plugin-usb-storage 13.0.69 → 13.0.71

package/README.md

@@ -1,267 +1,22 @@
 # @simplysm/capacitor-plugin-usb-storage
 
-A Capacitor plugin for accessing USB Mass Storage devices. On Android, it directly accesses the USB storage device's file system through the [libaums](https://github.com/magnusja/libaums) library, while in web environments it provides an IndexedDB-based virtual USB storage to support development and testing.
+Simplysm Package - Capacitor USB Storage Plugin
 
 ## Installation
 
-```bash
 pnpm add @simplysm/capacitor-plugin-usb-storage
-npx cap sync
-```
 
-## Supported Platforms
+**Peer Dependencies:** `@capacitor/core ^7.4.4`
 
-| Platform | Supported | Implementation |
-|--------|-----------|-----------|
-| Android | Yes | USB Mass Storage access through libaums 0.9.1 |
-| Web | Yes (emulation) | IndexedDB-based virtual USB storage |
-| iOS | No | -- |
+## Source Index
 
-### Android Requirements
+### USB Storage
 
-- `compileSdk`: 35
-- `minSdk`: 23 (Android 6.0 or higher)
-- Maximum file read size: 100MB
-
-## Main Modules
-
-### UsbStorage (Static Class)
-
-The main entry point of the plugin. All methods are static and operate asynchronously.
-
-```typescript
-import { UsbStorage } from "@simplysm/capacitor-plugin-usb-storage";
-```
-
-| Method | Return Type | Description |
-|--------|-----------|------|
-| `getDevices()` | `Promise<IUsbDeviceInfo[]>` | Retrieve list of connected USB devices |
-| `requestPermission(filter)` | `Promise<boolean>` | Request USB device access permission |
-| `hasPermission(filter)` | `Promise<boolean>` | Check if USB device access permission is granted |
-| `readdir(filter, dirPath)` | `Promise<IUsbFileInfo[]>` | Read list of files/folders in directory |
-| `read(filter, filePath)` | `Promise<Bytes \| undefined>` | Read file contents as binary |
-
-### IUsbStoragePlugin (Raw Plugin Interface)
-
-The low-level Capacitor plugin interface. Most users should use the `UsbStorage` static class instead.
-This interface is useful for advanced scenarios such as creating custom plugin implementations.
-
-```typescript
-import type { IUsbStoragePlugin } from "@simplysm/capacitor-plugin-usb-storage";
-```
-
-| Method | Return Type | Description |
-|--------|-----------|------|
-| `getDevices()` | `Promise<{ devices: IUsbDeviceInfo[] }>` | Get connected USB devices (raw) |
-| `requestPermission(options)` | `Promise<{ granted: boolean }>` | Request USB permission (raw) |
-| `hasPermission(options)` | `Promise<{ granted: boolean }>` | Check USB permission (raw) |
-| `readdir(options)` | `Promise<{ files: IUsbFileInfo[] }>` | List directory contents (raw) |
-| `read(options)` | `Promise<{ data: string \| null }>` | Read file as Base64 string (raw) |
-
-### Interfaces
-
-```typescript
-import type { IUsbDeviceInfo, IUsbDeviceFilter, IUsbFileInfo } from "@simplysm/capacitor-plugin-usb-storage";
-```
-
-#### IUsbDeviceInfo
-
-Represents USB device information.
-
-| Property | Type | Description |
-|------|------|------|
-| `deviceName` | `string` | Device name (system path) |
-| `manufacturerName` | `string` | Manufacturer name |
-| `productName` | `string` | Product name |
-| `vendorId` | `number` | USB Vendor ID |
-| `productId` | `number` | USB Product ID |
-
-#### IUsbDeviceFilter
-
-A filter for identifying specific USB devices. Specifies the device using the combination of `vendorId` and `productId`.
-
-| Property | Type | Description |
-|------|------|------|
-| `vendorId` | `number` | USB Vendor ID |
-| `productId` | `number` | USB Product ID |
-
-#### IUsbFileInfo
-
-Represents file or directory information.
-
-| Property | Type | Description |
-|------|------|------|
-| `name` | `string` | File/directory name |
-| `isDirectory` | `boolean` | Whether it's a directory |
-
-## Usage Examples
-
-### List Devices and Request Permission
-
-```typescript
-import { UsbStorage } from "@simplysm/capacitor-plugin-usb-storage";
-
-// Retrieve connected USB device list
-const devices = await UsbStorage.getDevices();
-console.log("Connected devices:", devices);
-
-if (devices.length > 0) {
-  const device = devices[0];
-  const filter = { vendorId: device.vendorId, productId: device.productId };
-
-  // Check permission
-  const hasPerm = await UsbStorage.hasPermission(filter);
-  if (!hasPerm) {
-    // Request permission (displays system dialog on Android)
-    const granted = await UsbStorage.requestPermission(filter);
-    if (!granted) {
-      console.log("USB device access permission was denied.");
-      return;
-    }
-  }
-}
-```
-
-### Read Directory Contents
-
-```typescript
-import { UsbStorage } from "@simplysm/capacitor-plugin-usb-storage";
-
-const filter = { vendorId: 1234, productId: 5678 };
-
-// Read root directory
-const rootFiles = await UsbStorage.readdir(filter, "/");
-for (const file of rootFiles) {
-  const type = file.isDirectory ? "[DIR]" : "[FILE]";
-  console.log(`${type} ${file.name}`);
-}
-
-// Read subdirectory
-const subFiles = await UsbStorage.readdir(filter, "/Documents");
-```
-
-### Read File
-
-```typescript
-import { UsbStorage } from "@simplysm/capacitor-plugin-usb-storage";
-
-const filter = { vendorId: 1234, productId: 5678 };
-
-// Read file as binary (Bytes)
-const data = await UsbStorage.read(filter, "/data/config.json");
-if (data != null) {
-  // Convert Bytes to string
-  const text = new TextDecoder().decode(data);
-  console.log("File contents:", text);
-}
-```
-
-### Complete Flow Example
-
-```typescript
-import { UsbStorage } from "@simplysm/capacitor-plugin-usb-storage";
-import type { IUsbDeviceFilter } from "@simplysm/capacitor-plugin-usb-storage";
-
-async function readUsbFile(filePath: string): Promise<string | undefined> {
-  // 1. Search for device
-  const devices = await UsbStorage.getDevices();
-  if (devices.length === 0) {
-    throw new Error("No USB device is connected.");
-  }
-
-  const device = devices[0];
-  const filter: IUsbDeviceFilter = {
-    vendorId: device.vendorId,
-    productId: device.productId,
-  };
-
-  // 2. Secure permission
-  const hasPerm = await UsbStorage.hasPermission(filter);
-  if (!hasPerm) {
-    const granted = await UsbStorage.requestPermission(filter);
-    if (!granted) {
-      throw new Error("USB device access permission is required.");
-    }
-  }
-
-  // 3. Read file
-  const data = await UsbStorage.read(filter, filePath);
-  if (data == null) {
-    return undefined;
-  }
-
-  return new TextDecoder().decode(data);
-}
-```
-
-## Web Emulation (Development/Testing)
-
-In web environments, the `UsbStorageWeb` class is automatically used, providing an IndexedDB-based virtual USB storage. Permission requests are always processed as approved.
-
-`UsbStorageWeb` provides methods for adding virtual devices and files for development and testing purposes.
-
-> **Note**: `UsbStorageWeb` is not re-exported from the main package entry point.
-> Import it via a deep path as shown below.
-
-```typescript
-import { UsbStorageWeb } from "@simplysm/capacitor-plugin-usb-storage/dist/web/UsbStorageWeb";
-```
-
-| Method | Description |
-|--------|------|
-| `addVirtualDevice(device)` | Register a virtual USB device |
-| `addVirtualFile(filter, filePath, data)` | Add a file to virtual device (parent directories created automatically) |
-| `addVirtualDirectory(filter, dirPath)` | Add a directory to virtual device |
-
-### Web Emulation Usage Example
-
-```typescript
-import { UsbStorageWeb } from "@simplysm/capacitor-plugin-usb-storage/dist/web/UsbStorageWeb";
-
-const web = new UsbStorageWeb();
-
-// Add virtual device
-await web.addVirtualDevice({
-  vendorId: 1234,
-  productId: 5678,
-  deviceName: "Virtual USB",
-  manufacturerName: "Test Manufacturer",
-  productName: "Test USB Drive",
-});
-
-const filter = { vendorId: 1234, productId: 5678 };
-
-// Add virtual file
-const content = new TextEncoder().encode("Hello, USB!");
-await web.addVirtualFile(filter, "/test/hello.txt", content);
-
-// Add virtual directory
-await web.addVirtualDirectory(filter, "/test/subdir");
-```
-
-## Android Native Implementation Details
-
-The Android native layer uses the `libaums` library to directly handle the USB Mass Storage protocol. Key operations are as follows.
-
-- **Device Search**: Uses `UsbMassStorageDevice.getMassStorageDevices()` to query connected USB Mass Storage devices.
-- **Permission Management**: Requests and verifies USB device access permission through Android's `UsbManager`. On Android 12 (API 31) and above, it uses `PendingIntent.FLAG_MUTABLE`, and on Android 13 (API 33) and above, it applies the `RECEIVER_NOT_EXPORTED` flag.
-- **File System Access**: Mounts the file system of the first partition to perform directory navigation and file reading.
-- **Data Transfer**: File data is Base64-encoded for transmission to the JavaScript layer.
-
-## Dependencies
-
-### Peer Dependencies
-
-| Package | Version |
-|--------|------|
-| `@capacitor/core` | `^7.4.4` |
-
-### Internal Dependencies
-
-| Package | Description |
-|--------|------|
-| `@simplysm/core-common` | Common utilities such as Base64 conversion, `Bytes` type |
+| Source | Exports | Description | Test |
+|--------|---------|-------------|------|
+| `src/IUsbStoragePlugin.ts` | `IUsbDeviceInfo`, `IUsbDeviceFilter`, `IUsbFileInfo`, `IUsbStoragePlugin` | Interfaces for USB device info, file info, filters, and the native plugin contract | - |
+| `src/UsbStorage.ts` | `UsbStorage` | Static class to enumerate USB devices, manage permissions, and read files | - |
 
 ## License
 
-MIT
+Apache-2.0

package/dist/UsbStorage.d.ts

@@ -1,40 +1,40 @@
 import type { IUsbDeviceFilter, IUsbDeviceInfo, IUsbFileInfo } from "./IUsbStoragePlugin";
 import type { Bytes } from "@simplysm/core-common";
 /**
- * USB 저장장치와 상호작용하기 위한 플러그인
- * - Android: libaums 라이브러리를 통한 USB Mass Storage 접근
- * - Browser: IndexedDB 기반 가상 USB 저장소 에뮬레이션
+ * Plugin for interacting with USB storage devices
+ * - Android: USB Mass Storage access via libaums library
+ * - Browser: IndexedDB-based virtual USB storage emulation
  */
 export declare abstract class UsbStorage {
     /**
-     * 연결된 USB 장치 목록을 가져옴
-     * @returns 연결된 USB 장치 정보 배열
+     * Get list of connected USB devices
+     * @returns Array of connected USB device info
      */
     static getDevices(): Promise<IUsbDeviceInfo[]>;
     /**
-     * USB 장치 접근 권한을 요청
-     * @param filter 권한을 요청할 USB 장치의 vendorId와 productId
-     * @returns 권한 승인 여부
+     * Request USB device access permission
+     * @param filter vendorId and productId of the USB device to request permission for
+     * @returns Whether permission was granted
      */
     static requestPermission(filter: IUsbDeviceFilter): Promise<boolean>;
     /**
-     * USB 장치 접근 권한이 있는지 확인
-     * @param filter 권한을 확인할 USB 장치의 vendorId와 productId
-     * @returns 권한 보유 여부
+     * Check if USB device access permission is granted
+     * @param filter vendorId and productId of the USB device to check permission for
+     * @returns Whether permission is held
      */
     static hasPermission(filter: IUsbDeviceFilter): Promise<boolean>;
     /**
-     * USB 저장장치의 디렉토리 내용을 읽어옴
-     * @param filter 대상 USB 장치의 vendorId와 productId
-     * @param dirPath 읽어올 디렉토리 경로
-     * @returns 디렉토리 내 파일/폴더 정보 배열
+     * Read directory contents from USB storage device
+     * @param filter vendorId and productId of the target USB device
+     * @param dirPath Directory path to read
+     * @returns Array of file/folder info in the directory
      */
     static readdir(filter: IUsbDeviceFilter, dirPath: string): Promise<IUsbFileInfo[]>;
     /**
-     * USB 저장장치의 파일을 읽어옴
-     * @param filter 대상 USB 장치의 vendorId와 productId
-     * @param filePath 읽어올 파일 경로
-     * @returns 파일 데이터를 담은 Bytes 또는 undefined
+     * Read a file from USB storage device
+     * @param filter vendorId and productId of the target USB device
+     * @param filePath File path to read
+     * @returns Bytes containing file data, or undefined
      */
     static read(filter: IUsbDeviceFilter, filePath: string): Promise<Bytes | undefined>;
 }

package/dist/UsbStorage.js

@@ -8,46 +8,46 @@ const UsbStoragePlugin = registerPlugin("UsbStorage", {
 });
 class UsbStorage {
   /**
-   * 연결된 USB 장치 목록을 가져옴
-   * @returns 연결된 USB 장치 정보 배열
+   * Get list of connected USB devices
+   * @returns Array of connected USB device info
    */
   static async getDevices() {
     const result = await UsbStoragePlugin.getDevices();
     return result.devices;
   }
   /**
-   * USB 장치 접근 권한을 요청
-   * @param filter 권한을 요청할 USB 장치의 vendorId와 productId
-   * @returns 권한 승인 여부
+   * Request USB device access permission
+   * @param filter vendorId and productId of the USB device to request permission for
+   * @returns Whether permission was granted
    */
   static async requestPermission(filter) {
     const result = await UsbStoragePlugin.requestPermission(filter);
     return result.granted;
   }
   /**
-   * USB 장치 접근 권한이 있는지 확인
-   * @param filter 권한을 확인할 USB 장치의 vendorId와 productId
-   * @returns 권한 보유 여부
+   * Check if USB device access permission is granted
+   * @param filter vendorId and productId of the USB device to check permission for
+   * @returns Whether permission is held
    */
   static async hasPermission(filter) {
     const result = await UsbStoragePlugin.hasPermission(filter);
     return result.granted;
   }
   /**
-   * USB 저장장치의 디렉토리 내용을 읽어옴
-   * @param filter 대상 USB 장치의 vendorId와 productId
-   * @param dirPath 읽어올 디렉토리 경로
-   * @returns 디렉토리 내 파일/폴더 정보 배열
+   * Read directory contents from USB storage device
+   * @param filter vendorId and productId of the target USB device
+   * @param dirPath Directory path to read
+   * @returns Array of file/folder info in the directory
    */
   static async readdir(filter, dirPath) {
     const result = await UsbStoragePlugin.readdir({ ...filter, path: dirPath });
     return result.files;
   }
   /**
-   * USB 저장장치의 파일을 읽어옴
-   * @param filter 대상 USB 장치의 vendorId와 productId
-   * @param filePath 읽어올 파일 경로
-   * @returns 파일 데이터를 담은 Bytes 또는 undefined
+   * Read a file from USB storage device
+   * @param filter vendorId and productId of the target USB device
+   * @param filePath File path to read
+   * @returns Bytes containing file data, or undefined
    */
   static async read(filter, filePath) {
     const result = await UsbStoragePlugin.read({ ...filter, path: filePath });

package/dist/web/UsbStorageWeb.d.ts

@@ -22,7 +22,7 @@ export declare class UsbStorageWeb extends WebPlugin implements IUsbStoragePlugi
         data: string | null;
     }>;
     /**
-     * 가상 USB 장치를 추가합니다. (테스트/개발용)
+     * Add a virtual USB device. (For testing/development)
      */
     addVirtualDevice(device: {
         vendorId: number;
@@ -32,11 +32,11 @@ export declare class UsbStorageWeb extends WebPlugin implements IUsbStoragePlugi
         productName: string;
     }): Promise<void>;
     /**
-     * 가상 USB 장치에 파일을 추가합니다. (테스트/개발용)
+     * Add a file to a virtual USB device. (For testing/development)
      */
     addVirtualFile(filter: IUsbDeviceFilter, filePath: string, data: Uint8Array): Promise<void>;
     /**
-     * 가상 USB 장치에 디렉토리를 추가합니다. (테스트/개발용)
+     * Add a directory to a virtual USB device. (For testing/development)
      */
     addVirtualDirectory(filter: IUsbDeviceFilter, dirPath: string): Promise<void>;
 }

package/dist/web/UsbStorageWeb.js

@@ -49,13 +49,13 @@ class UsbStorageWeb extends WebPlugin {
     return { data: entry.dataBase64 };
   }
   /**
-   * 가상 USB 장치를 추가합니다. (테스트/개발용)
+   * Add a virtual USB device. (For testing/development)
    */
   async addVirtualDevice(device) {
     await this._storage.addDevice(device);
   }
   /**
-   * 가상 USB 장치에 파일을 추가합니다. (테스트/개발용)
+   * Add a file to a virtual USB device. (For testing/development)
    */
   async addVirtualFile(filter, filePath, data) {
     const deviceKey = `${filter.vendorId}:${filter.productId}`;
@@ -70,7 +70,7 @@ class UsbStorageWeb extends WebPlugin {
     });
   }
   /**
-   * 가상 USB 장치에 디렉토리를 추가합니다. (테스트/개발용)
+   * Add a directory to a virtual USB device. (For testing/development)
    */
   async addVirtualDirectory(filter, dirPath) {
     const deviceKey = `${filter.vendorId}:${filter.productId}`;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@simplysm/capacitor-plugin-usb-storage",
-  "version": "13.0.69",
-  "description": "심플리즘 패키지 - Capacitor USB Storage Plugin",
-  "author": "김석래",
+  "version": "13.0.71",
+  "description": "Simplysm Package - Capacitor USB Storage Plugin",
+  "author": "simplysm",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -14,10 +14,11 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "src",
     "android"
   ],
   "dependencies": {
-    "@simplysm/core-common": "13.0.69"
+    "@simplysm/core-common": "13.0.71"
   },
   "devDependencies": {
     "@capacitor/core": "^7.5.0"

package/src/IUsbStoragePlugin.ts

@@ -0,0 +1,25 @@
+export interface IUsbDeviceInfo {
+  deviceName: string;
+  manufacturerName: string;
+  productName: string;
+  vendorId: number;
+  productId: number;
+}
+
+export interface IUsbDeviceFilter {
+  vendorId: number;
+  productId: number;
+}
+
+export interface IUsbFileInfo {
+  name: string;
+  isDirectory: boolean;
+}
+
+export interface IUsbStoragePlugin {
+  getDevices(): Promise<{ devices: IUsbDeviceInfo[] }>;
+  requestPermission(options: IUsbDeviceFilter): Promise<{ granted: boolean }>;
+  hasPermission(options: IUsbDeviceFilter): Promise<{ granted: boolean }>;
+  readdir(options: IUsbDeviceFilter & { path: string }): Promise<{ files: IUsbFileInfo[] }>;
+  read(options: IUsbDeviceFilter & { path: string }): Promise<{ data: string | null }>;
+}

package/src/UsbStorage.ts

@@ -0,0 +1,77 @@
+import { registerPlugin } from "@capacitor/core";
+import type {
+  IUsbDeviceFilter,
+  IUsbDeviceInfo,
+  IUsbFileInfo,
+  IUsbStoragePlugin,
+} from "./IUsbStoragePlugin";
+import type { Bytes } from "@simplysm/core-common";
+import { bytesFromBase64 } from "@simplysm/core-common";
+
+const UsbStoragePlugin = registerPlugin<IUsbStoragePlugin>("UsbStorage", {
+  web: async () => {
+    const { UsbStorageWeb } = await import("./web/UsbStorageWeb");
+    return new UsbStorageWeb();
+  },
+});
+
+/**
+ * Plugin for interacting with USB storage devices
+ * - Android: USB Mass Storage access via libaums library
+ * - Browser: IndexedDB-based virtual USB storage emulation
+ */
+export abstract class UsbStorage {
+  /**
+   * Get list of connected USB devices
+   * @returns Array of connected USB device info
+   */
+  static async getDevices(): Promise<IUsbDeviceInfo[]> {
+    const result = await UsbStoragePlugin.getDevices();
+    return result.devices;
+  }
+
+  /**
+   * Request USB device access permission
+   * @param filter vendorId and productId of the USB device to request permission for
+   * @returns Whether permission was granted
+   */
+  static async requestPermission(filter: IUsbDeviceFilter): Promise<boolean> {
+    const result = await UsbStoragePlugin.requestPermission(filter);
+    return result.granted;
+  }
+
+  /**
+   * Check if USB device access permission is granted
+   * @param filter vendorId and productId of the USB device to check permission for
+   * @returns Whether permission is held
+   */
+  static async hasPermission(filter: IUsbDeviceFilter): Promise<boolean> {
+    const result = await UsbStoragePlugin.hasPermission(filter);
+    return result.granted;
+  }
+
+  /**
+   * Read directory contents from USB storage device
+   * @param filter vendorId and productId of the target USB device
+   * @param dirPath Directory path to read
+   * @returns Array of file/folder info in the directory
+   */
+  static async readdir(filter: IUsbDeviceFilter, dirPath: string): Promise<IUsbFileInfo[]> {
+    const result = await UsbStoragePlugin.readdir({ ...filter, path: dirPath });
+    return result.files;
+  }
+
+  /**
+   * Read a file from USB storage device
+   * @param filter vendorId and productId of the target USB device
+   * @param filePath File path to read
+   * @returns Bytes containing file data, or undefined
+   */
+  static async read(filter: IUsbDeviceFilter, filePath: string): Promise<Bytes | undefined> {
+    const result = await UsbStoragePlugin.read({ ...filter, path: filePath });
+    if (result.data == null) {
+      return undefined;
+    }
+    return bytesFromBase64(result.data);
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+// USB Storage
+export * from "./IUsbStoragePlugin";
+export * from "./UsbStorage";

package/src/web/IndexedDbStore.ts

@@ -0,0 +1,88 @@
+export interface IStoreConfig {
+  name: string;
+  keyPath: string;
+}
+
+export class IndexedDbStore {
+  constructor(
+    private readonly _dbName: string,
+    private readonly _dbVersion: number,
+    private readonly _storeConfigs: IStoreConfig[],
+  ) {}
+
+  async open(): Promise<IDBDatabase> {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, this._dbVersion);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        for (const config of this._storeConfigs) {
+          if (!db.objectStoreNames.contains(config.name)) {
+            db.createObjectStore(config.name, { keyPath: config.keyPath });
+          }
+        }
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+      req.onblocked = () => reject(new Error("Database blocked by another connection"));
+    });
+  }
+
+  async withStore<T>(
+    storeName: string,
+    mode: IDBTransactionMode,
+    fn: (store: IDBObjectStore) => Promise<T>,
+  ): Promise<T> {
+    const db = await this.open();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName, mode);
+      const store = tx.objectStore(storeName);
+      let result: T;
+      Promise.resolve(fn(store))
+        .then((r) => {
+          result = r;
+        })
+        .catch((err) => {
+          db.close();
+          reject(err);
+        });
+      tx.oncomplete = () => {
+        db.close();
+        resolve(result);
+      };
+      tx.onerror = () => {
+        db.close();
+        reject(tx.error);
+      };
+    });
+  }
+
+  async get<T>(storeName: string, key: IDBValidKey): Promise<T | undefined> {
+    return this.withStore(storeName, "readonly", async (store) => {
+      return new Promise((resolve, reject) => {
+        const req = store.get(key);
+        req.onsuccess = () => resolve(req.result as T | undefined);
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async put(storeName: string, value: unknown): Promise<void> {
+    return this.withStore(storeName, "readwrite", async (store) => {
+      return new Promise((resolve, reject) => {
+        const req = store.put(value);
+        req.onsuccess = () => resolve();
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async getAll<T>(storeName: string): Promise<T[]> {
+    return this.withStore(storeName, "readonly", async (store) => {
+      return new Promise((resolve, reject) => {
+        const req = store.getAll();
+        req.onsuccess = () => resolve(req.result as T[]);
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+}

package/src/web/UsbStorageWeb.ts

@@ -0,0 +1,104 @@
+import { WebPlugin } from "@capacitor/core";
+import type {
+  IUsbDeviceFilter,
+  IUsbDeviceInfo,
+  IUsbFileInfo,
+  IUsbStoragePlugin,
+} from "../IUsbStoragePlugin";
+import { VirtualUsbStorage } from "./VirtualUsbStorage";
+import { bytesToBase64 } from "@simplysm/core-common";
+
+export class UsbStorageWeb extends WebPlugin implements IUsbStoragePlugin {
+  private readonly _storage = new VirtualUsbStorage();
+
+  async getDevices(): Promise<{ devices: IUsbDeviceInfo[] }> {
+    const devices = await this._storage.getDevices();
+    return {
+      devices: devices.map((d) => ({
+        deviceName: d.deviceName,
+        manufacturerName: d.manufacturerName,
+        productName: d.productName,
+        vendorId: d.vendorId,
+        productId: d.productId,
+      })),
+    };
+  }
+
+  async requestPermission(_options: IUsbDeviceFilter): Promise<{ granted: boolean }> {
+    return Promise.resolve({ granted: true });
+  }
+
+  async hasPermission(_options: IUsbDeviceFilter): Promise<{ granted: boolean }> {
+    return Promise.resolve({ granted: true });
+  }
+
+  async readdir(options: IUsbDeviceFilter & { path: string }): Promise<{ files: IUsbFileInfo[] }> {
+    const deviceKey = `${options.vendorId}:${options.productId}`;
+    const devices = await this._storage.getDevices();
+    const deviceExists = devices.some((d) => d.key === deviceKey);
+    if (!deviceExists) {
+      return { files: [] };
+    }
+    const entry = await this._storage.getEntry(deviceKey, options.path);
+    if (!entry || entry.kind !== "dir") {
+      return { files: [] };
+    }
+    const children = await this._storage.listChildren(deviceKey, options.path);
+    return { files: children };
+  }
+
+  async read(options: IUsbDeviceFilter & { path: string }): Promise<{ data: string | null }> {
+    const deviceKey = `${options.vendorId}:${options.productId}`;
+    const devices = await this._storage.getDevices();
+    const deviceExists = devices.some((d) => d.key === deviceKey);
+    if (!deviceExists) {
+      return { data: null };
+    }
+    const entry = await this._storage.getEntry(deviceKey, options.path);
+    if (!entry || entry.kind !== "file" || entry.dataBase64 == null) {
+      return { data: null };
+    }
+    return { data: entry.dataBase64 };
+  }
+
+  /**
+   * Add a virtual USB device. (For testing/development)
+   */
+  async addVirtualDevice(device: {
+    vendorId: number;
+    productId: number;
+    deviceName: string;
+    manufacturerName: string;
+    productName: string;
+  }): Promise<void> {
+    await this._storage.addDevice(device);
+  }
+
+  /**
+   * Add a file to a virtual USB device. (For testing/development)
+   */
+  async addVirtualFile(
+    filter: IUsbDeviceFilter,
+    filePath: string,
+    data: Uint8Array,
+  ): Promise<void> {
+    const deviceKey = `${filter.vendorId}:${filter.productId}`;
+    const idx = filePath.lastIndexOf("/");
+    const dir = idx === -1 ? "/" : filePath.substring(0, idx) || "/";
+    await this._storage.ensureDir(deviceKey, dir);
+    await this._storage.putEntry({
+      deviceKey,
+      path: filePath,
+      kind: "file",
+      dataBase64: bytesToBase64(data),
+    });
+  }
+
+  /**
+   * Add a directory to a virtual USB device. (For testing/development)
+   */
+  async addVirtualDirectory(filter: IUsbDeviceFilter, dirPath: string): Promise<void> {
+    const deviceKey = `${filter.vendorId}:${filter.productId}`;
+    await this._storage.ensureDir(deviceKey, dirPath);
+  }
+}

package/src/web/VirtualUsbStorage.ts

@@ -0,0 +1,107 @@
+import { IndexedDbStore } from "./IndexedDbStore";
+
+interface VirtualDevice {
+  key: string;
+  vendorId: number;
+  productId: number;
+  deviceName: string;
+  manufacturerName: string;
+  productName: string;
+}
+
+interface VirtualEntry {
+  fullKey: string;
+  deviceKey: string;
+  path: string;
+  kind: "file" | "dir";
+  dataBase64?: string;
+}
+
+export class VirtualUsbStorage {
+  private readonly _DEVICES_STORE = "devices";
+  private readonly _FILES_STORE = "files";
+  private readonly _db: IndexedDbStore;
+
+  constructor() {
+    this._db = new IndexedDbStore("capacitor_usb_virtual_storage", 1, [
+      { name: this._DEVICES_STORE, keyPath: "key" },
+      { name: this._FILES_STORE, keyPath: "fullKey" },
+    ]);
+  }
+
+  async addDevice(device: Omit<VirtualDevice, "key">): Promise<void> {
+    const key = `${device.vendorId}:${device.productId}`;
+    const entry: VirtualDevice = { ...device, key };
+    return this._db.put(this._DEVICES_STORE, entry);
+  }
+
+  async getDevices(): Promise<VirtualDevice[]> {
+    return this._db.getAll<VirtualDevice>(this._DEVICES_STORE);
+  }
+
+  async getEntry(deviceKey: string, path: string): Promise<VirtualEntry | undefined> {
+    const fullKey = `${deviceKey}:${path}`;
+    return this._db.get<VirtualEntry>(this._FILES_STORE, fullKey);
+  }
+
+  async putEntry(entry: Omit<VirtualEntry, "fullKey">): Promise<void> {
+    const fullKey = `${entry.deviceKey}:${entry.path}`;
+    const fullEntry: VirtualEntry = { ...entry, fullKey };
+    return this._db.put(this._FILES_STORE, fullEntry);
+  }
+
+  async listChildren(
+    deviceKey: string,
+    dirPath: string,
+  ): Promise<{ name: string; isDirectory: boolean }[]> {
+    const prefix = `${deviceKey}:${dirPath === "/" ? "/" : dirPath + "/"}`;
+    return this._db.withStore(this._FILES_STORE, "readonly", async (store) => {
+      return new Promise((resolve, reject) => {
+        const req = store.openCursor();
+        const map = new Map<string, boolean>();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) {
+            resolve(
+              Array.from(map.entries()).map(([name, isDirectory]) => ({ name, isDirectory })),
+            );
+            return;
+          }
+          const key = String(cursor.key);
+          if (key.startsWith(prefix)) {
+            const rest = key.slice(prefix.length);
+            if (rest) {
+              const segments = rest.split("/").filter(Boolean);
+              if (segments.length > 0) {
+                const firstName = segments[0];
+                if (!map.has(firstName)) {
+                  const isDir =
+                    segments.length > 1 || (cursor.value as VirtualEntry).kind === "dir";
+                  map.set(firstName, isDir);
+                }
+              }
+            }
+          }
+          cursor.continue();
+        };
+        req.onerror = () => reject(req.error);
+      });
+    });
+  }
+
+  async ensureDir(deviceKey: string, dirPath: string): Promise<void> {
+    if (dirPath === "/") {
+      await this.putEntry({ deviceKey, path: "/", kind: "dir" });
+      return;
+    }
+    const segments = dirPath.split("/").filter(Boolean);
+    let acc = "";
+    for (const seg of segments) {
+      acc += "/" + seg;
+      const existing = await this.getEntry(deviceKey, acc);
+      if (!existing) {
+        await this.putEntry({ deviceKey, path: acc, kind: "dir" });
+      }
+    }
+  }
+}