@gurezo/web-serial-rxjs 0.1.0 → 0.1.1

package/dist/browser/browser-detection.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Browser type enumeration for identifying the browser environment.
+ *
+ * This enum is used to identify the specific browser type, which is useful for
+ * browser-specific behavior or error messages.
+ *
+ * @example
+ * ```typescript
+ * const browserType = detectBrowserType();
+ * if (browserType === BrowserType.CHROME) {
+ *   console.log('Running in Chrome');
+ * }
+ * ```
+ */
+export declare enum BrowserType {
+    /** Google Chrome browser */
+    CHROME = "chrome",
+    /** Microsoft Edge browser */
+    EDGE = "edge",
+    /** Opera browser */
+    OPERA = "opera",
+    /** Unknown or unsupported browser */
+    UNKNOWN = "unknown"
+}
+/**
+ * Feature detection for Web Serial API.
+ *
+ * Checks if the browser supports the Web Serial API by verifying the presence
+ * of `navigator.serial`. This is a non-throwing check that returns `false` if
+ * the API is not available.
+ *
+ * Note: This function only checks for API availability, not whether the browser
+ * type is supported. For a throwing check that provides better error messages,
+ * use {@link checkBrowserSupport}.
+ *
+ * @returns `true` if the Web Serial API is available, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * if (hasWebSerialSupport()) {
+ *   // Safe to use serial port functionality
+ *   const client = createSerialClient();
+ * } else {
+ *   console.error('Web Serial API is not supported');
+ * }
+ * ```
+ *
+ * @see {@link checkBrowserSupport} for a throwing version with better error messages
+ * @see {@link isBrowserSupported} for an alias to this function
+ */
+export declare function hasWebSerialSupport(): boolean;
+/**
+ * Detect browser type from the user agent string.
+ *
+ * Analyzes the browser's user agent string to identify the browser type.
+ * This function is useful for providing browser-specific functionality or
+ * error messages.
+ *
+ * @returns The detected {@link BrowserType}, or {@link BrowserType.UNKNOWN} if the browser cannot be identified
+ *
+ * @example
+ * ```typescript
+ * const browserType = detectBrowserType();
+ * switch (browserType) {
+ *   case BrowserType.CHROME:
+ *     console.log('Running in Chrome');
+ *     break;
+ *   case BrowserType.EDGE:
+ *     console.log('Running in Edge');
+ *     break;
+ *   case BrowserType.OPERA:
+ *     console.log('Running in Opera');
+ *     break;
+ *   default:
+ *     console.log('Unknown browser');
+ * }
+ * ```
+ *
+ * @see {@link isChromiumBased} for checking if the browser is Chromium-based
+ */
+export declare function detectBrowserType(): BrowserType;
+/**
+ * Check if the browser is Chromium-based.
+ *
+ * Determines if the current browser is based on Chromium, which includes
+ * Chrome, Edge, and Opera. These browsers support the Web Serial API.
+ *
+ * @returns `true` if the browser is Chromium-based (Chrome, Edge, or Opera), `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isChromiumBased()) {
+ *   // Browser supports Web Serial API
+ *   const client = createSerialClient();
+ * } else {
+ *   console.error('Please use a Chromium-based browser (Chrome, Edge, or Opera)');
+ * }
+ * ```
+ *
+ * @see {@link detectBrowserType} for identifying the specific browser type
+ * @see {@link hasWebSerialSupport} for checking Web Serial API availability
+ */
+export declare function isChromiumBased(): boolean;
+//# sourceMappingURL=browser-detection.d.ts.map

package/dist/browser/browser-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-detection.d.ts","sourceRoot":"","sources":["../../src/browser/browser-detection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,oBAAY,WAAW;IACrB,4BAA4B;IAC5B,MAAM,WAAW;IACjB,6BAA6B;IAC7B,IAAI,SAAS;IACb,oBAAoB;IACpB,KAAK,UAAU;IACf,qCAAqC;IACrC,OAAO,YAAY;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAO7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,CAoB/C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAOzC"}

package/dist/browser/browser-support.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Check if the browser supports the Web Serial API, throwing an error if not supported.
+ *
+ * This function performs a feature detection check and throws a {@link SerialError}
+ * with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the Web Serial API
+ * is not available. The error message includes the detected browser type for better
+ * user feedback.
+ *
+ * This is the recommended way to check browser support before using serial port
+ * functionality, as it provides clear error messages.
+ *
+ * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED}
+ *         if the browser doesn't support the Web Serial API
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   checkBrowserSupport();
+ *   // Safe to use serial port functionality
+ *   const client = createSerialClient();
+ * } catch (error) {
+ *   if (error instanceof SerialError && error.code === SerialErrorCode.BROWSER_NOT_SUPPORTED) {
+ *     console.error(error.message);
+ *     // Show user-friendly message: "Please use a Chromium-based browser..."
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link isBrowserSupported} for a non-throwing version that returns a boolean
+ * @see {@link hasWebSerialSupport} for the underlying feature detection function
+ */
+export declare function checkBrowserSupport(): void;
+/**
+ * Check if the browser supports the Web Serial API (non-throwing version).
+ *
+ * This is a convenience function that returns a boolean indicating whether
+ * the Web Serial API is available. Unlike {@link checkBrowserSupport}, this
+ * function does not throw an error if the API is not available.
+ *
+ * @returns `true` if the Web Serial API is supported, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isBrowserSupported()) {
+ *   const client = createSerialClient();
+ *   // Use serial port functionality
+ * } else {
+ *   console.error('Web Serial API is not supported in this browser');
+ *   // Show fallback UI or message
+ * }
+ * ```
+ *
+ * @see {@link checkBrowserSupport} for a throwing version with better error messages
+ * @see {@link hasWebSerialSupport} which this function calls internally
+ */
+export declare function isBrowserSupported(): boolean;
+//# sourceMappingURL=browser-support.d.ts.map

package/dist/browser/browser-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-support.d.ts","sourceRoot":"","sources":["../../src/browser/browser-support.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAa1C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C"}

package/dist/client/index.d.ts

@@ -0,0 +1,250 @@
+import { Observable } from 'rxjs';
+import { SerialClientOptions } from '../types/options';
+/**
+ * SerialClient interface for interacting with serial ports using RxJS Observables.
+ *
+ * This interface provides a reactive API for serial port communication, allowing you to
+ * connect to serial devices, read and write data using RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * const client = createSerialClient({ baudRate: 9600 });
+ *
+ * // Connect to a port
+ * client.connect().subscribe({
+ *   next: () => {
+ *     console.log('Connected!');
+ *
+ *     // Read data
+ *     client.getReadStream().subscribe({
+ *       next: (data) => console.log('Received:', data),
+ *     });
+ *
+ *     // Write data
+ *     const encoder = new TextEncoder();
+ *     client.write(encoder.encode('Hello')).subscribe();
+ *   },
+ *   error: (error) => console.error('Connection error:', error),
+ * });
+ * ```
+ */
+export interface SerialClient {
+    /**
+     * Request a serial port from the user.
+     *
+     * This method opens the browser's port selection dialog and returns an Observable
+     * that emits the selected SerialPort when the user chooses a port.
+     *
+     * @returns An Observable that emits the selected {@link SerialPort} when the user selects a port
+     * @throws {@link SerialError} with code {@link SerialErrorCode.OPERATION_CANCELLED} if the user cancels the selection
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_NOT_AVAILABLE} if the port request fails
+     * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the browser doesn't support Web Serial API
+     *
+     * @example
+     * ```typescript
+     * client.requestPort().subscribe({
+     *   next: (port) => console.log('Selected port:', port),
+     *   error: (error) => console.error('Port selection failed:', error),
+     * });
+     * ```
+     */
+    requestPort(): Observable<SerialPort>;
+    /**
+     * Get available serial ports that have been previously granted access.
+     *
+     * This method returns an Observable that emits an array of SerialPort instances
+     * that the user has previously granted access to in this browser session.
+     *
+     * @returns An Observable that emits an array of available {@link SerialPort} instances
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_NOT_AVAILABLE} if getting ports fails
+     * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the browser doesn't support Web Serial API
+     *
+     * @example
+     * ```typescript
+     * client.getPorts().subscribe({
+     *   next: (ports) => {
+     *     console.log(`Found ${ports.length} available ports`);
+     *     if (ports.length > 0) {
+     *       client.connect(ports[0]).subscribe();
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    getPorts(): Observable<SerialPort[]>;
+    /**
+     * Connect to a serial port.
+     *
+     * Opens the specified port (or requests one if not provided) and configures it
+     * with the options passed to {@link createSerialClient}. The port must be connected
+     * before reading or writing data.
+     *
+     * @param port - Optional {@link SerialPort} to connect to. If not provided, will call {@link requestPort} to prompt the user.
+     * @returns An Observable that completes when the port is successfully opened
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_ALREADY_OPEN} if a port is already open
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_OPEN_FAILED} if opening the port fails
+     * @throws {@link SerialError} with code {@link SerialErrorCode.OPERATION_CANCELLED} if the user cancels port selection
+     * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the browser doesn't support Web Serial API
+     *
+     * @example
+     * ```typescript
+     * // Connect by requesting a port
+     * client.connect().subscribe({
+     *   next: () => console.log('Connected!'),
+     *   error: (error) => console.error('Connection failed:', error),
+     * });
+     *
+     * // Connect to a specific port
+     * client.getPorts().subscribe({
+     *   next: (ports) => {
+     *     if (ports.length > 0) {
+     *       client.connect(ports[0]).subscribe();
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    connect(port?: SerialPort): Observable<void>;
+    /**
+     * Disconnect from the serial port.
+     *
+     * Closes the currently open port and stops all active read/write streams.
+     * This method is safe to call even if no port is currently open.
+     *
+     * @returns An Observable that completes when the port is successfully closed
+     * @throws {@link SerialError} with code {@link SerialErrorCode.CONNECTION_LOST} if closing the port fails
+     *
+     * @example
+     * ```typescript
+     * client.disconnect().subscribe({
+     *   next: () => console.log('Disconnected'),
+     *   error: (error) => console.error('Disconnect failed:', error),
+     * });
+     * ```
+     */
+    disconnect(): Observable<void>;
+    /**
+     * Get an Observable that emits data read from the serial port.
+     *
+     * Returns an Observable stream that emits Uint8Array chunks as data is received
+     * from the serial port. The stream will continue until the port is disconnected
+     * or an error occurs.
+     *
+     * @returns An Observable that emits Uint8Array chunks containing data read from the serial port
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_NOT_OPEN} if the port is not open
+     *
+     * @example
+     * ```typescript
+     * client.getReadStream().subscribe({
+     *   next: (data) => {
+     *     const text = new TextDecoder().decode(data);
+     *     console.log('Received:', text);
+     *   },
+     *   error: (error) => console.error('Read error:', error),
+     * });
+     * ```
+     */
+    getReadStream(): Observable<Uint8Array>;
+    /**
+     * Write data to the serial port from an Observable.
+     *
+     * Writes data from an Observable stream to the serial port. The Observable should
+     * emit Uint8Array chunks that will be written sequentially to the port. If a previous
+     * write stream is active, it will be cancelled before starting the new one.
+     *
+     * @param data$ - Observable that emits Uint8Array chunks to write to the serial port
+     * @returns An Observable that completes when all data has been written and the stream completes
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_NOT_OPEN} if the port is not open
+     * @throws {@link SerialError} with code {@link SerialErrorCode.WRITE_FAILED} if writing fails
+     *
+     * @example
+     * ```typescript
+     * const data$ = from([
+     *   new TextEncoder().encode('Hello'),
+     *   new TextEncoder().encode('World'),
+     * ]);
+     *
+     * client.writeStream(data$).subscribe({
+     *   next: () => console.log('Writing...'),
+     *   complete: () => console.log('All data written'),
+     *   error: (error) => console.error('Write error:', error),
+     * });
+     * ```
+     */
+    writeStream(data$: Observable<Uint8Array>): Observable<void>;
+    /**
+     * Write a single chunk of data to the serial port.
+     *
+     * Writes a single Uint8Array chunk to the serial port. For writing multiple chunks,
+     * consider using {@link writeStream} with an Observable instead.
+     *
+     * @param data - Uint8Array data to write to the serial port
+     * @returns An Observable that completes when the data has been written
+     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_NOT_OPEN} if the port is not open
+     * @throws {@link SerialError} with code {@link SerialErrorCode.WRITE_FAILED} if writing fails
+     *
+     * @example
+     * ```typescript
+     * const encoder = new TextEncoder();
+     * const data = encoder.encode('Hello, Serial!');
+     *
+     * client.write(data).subscribe({
+     *   next: () => console.log('Data written'),
+     *   error: (error) => console.error('Write error:', error),
+     * });
+     * ```
+     */
+    write(data: Uint8Array): Observable<void>;
+    /**
+     * Check if the port is currently open and connected.
+     *
+     * @returns `true` if a port is currently open, `false` otherwise
+     */
+    readonly connected: boolean;
+    /**
+     * Get the current SerialPort instance.
+     *
+     * Returns the currently connected SerialPort instance, or `null` if no port is open.
+     * This allows direct access to the underlying Web Serial API SerialPort object if needed.
+     *
+     * @returns The current {@link SerialPort} instance, or `null` if no port is open
+     */
+    readonly currentPort: SerialPort | null;
+}
+/**
+ * Create a new SerialClient instance for interacting with serial ports.
+ *
+ * This is the main entry point for creating a serial client. The client provides
+ * a reactive RxJS-based API for connecting to serial ports and reading/writing data.
+ *
+ * @param options - Optional configuration options for the serial port connection.
+ *                  If not provided, default values will be used (9600 baud, 8 data bits, etc.)
+ * @returns A new {@link SerialClient} instance
+ * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the browser doesn't support Web Serial API
+ *
+ * @example
+ * ```typescript
+ * // Create a client with default settings (9600 baud)
+ * const client = createSerialClient();
+ *
+ * // Create a client with custom settings
+ * const client = createSerialClient({
+ *   baudRate: 115200,
+ *   dataBits: 8,
+ *   stopBits: 1,
+ *   parity: 'none',
+ *   filters: [{ usbVendorId: 0x1234 }],
+ * });
+ *
+ * // Check browser support before creating a client
+ * import { isBrowserSupported } from '@gurezo/web-serial-rxjs';
+ *
+ * if (!isBrowserSupported()) {
+ *   console.error('Web Serial API is not supported');
+ * } else {
+ *   const client = createSerialClient();
+ * }
+ * ```
+ */
+export declare function createSerialClient(options?: SerialClientOptions): SerialClient;
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAE7D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAE1C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,UAAU,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,YAAY,CAEd"}

package/dist/client/serial-client.d.ts

@@ -0,0 +1,98 @@
+import { Observable } from 'rxjs';
+import { SerialClientOptions } from '../types/options';
+/**
+ * Internal implementation of SerialClient interface.
+ *
+ * This class implements the {@link SerialClient} interface and provides the actual
+ * functionality for serial port communication. Users should not instantiate this class
+ * directly; instead, use {@link createSerialClient} to create a SerialClient instance.
+ *
+ * @internal
+ */
+export declare class SerialClientImpl {
+    /** @internal */
+    private port;
+    /** @internal */
+    private isOpen;
+    /** @internal */
+    private readSubscription;
+    /** @internal */
+    private writeSubscription;
+    /** @internal */
+    private readonly options;
+    /**
+     * Creates a new SerialClientImpl instance.
+     *
+     * @param options - Optional configuration options for the serial port connection
+     * @throws {@link SerialError} with code {@link SerialErrorCode.BROWSER_NOT_SUPPORTED} if the browser doesn't support Web Serial API
+     * @internal
+     */
+    constructor(options?: SerialClientOptions);
+    /**
+     * Request a serial port from the user.
+     *
+     * @returns Observable that emits the selected SerialPort
+     * @internal
+     */
+    requestPort(): Observable<SerialPort>;
+    /**
+     * Get available serial ports.
+     *
+     * @returns Observable that emits an array of available SerialPorts
+     * @internal
+     */
+    getPorts(): Observable<SerialPort[]>;
+    /**
+     * Connect to a serial port.
+     *
+     * @param port - Optional SerialPort to connect to. If not provided, will request one.
+     * @returns Observable that completes when the port is opened
+     * @internal
+     */
+    connect(port?: SerialPort): Observable<void>;
+    /**
+     * Disconnect from the serial port.
+     *
+     * @returns Observable that completes when the port is closed
+     * @internal
+     */
+    disconnect(): Observable<void>;
+    /**
+     * Get an Observable that emits data read from the serial port.
+     *
+     * @returns Observable that emits Uint8Array chunks
+     * @internal
+     */
+    getReadStream(): Observable<Uint8Array>;
+    /**
+     * Write data to the serial port from an Observable.
+     *
+     * @param data$ - Observable that emits Uint8Array chunks to write
+     * @returns Observable that completes when writing is finished
+     * @internal
+     */
+    writeStream(data$: Observable<Uint8Array>): Observable<void>;
+    /**
+     * Write a single chunk of data to the serial port.
+     *
+     * @param data - Data to write
+     * @returns Observable that completes when the data is written
+     * @internal
+     */
+    write(data: Uint8Array): Observable<void>;
+    /**
+     * Check if the port is currently open.
+     *
+     * @returns `true` if a port is currently open, `false` otherwise
+     * @internal
+     */
+    get connected(): boolean;
+    /**
+     * Get the current SerialPort instance.
+     *
+     * @returns The current SerialPort instance, or `null` if no port is open
+     * @internal
+     */
+    get currentPort(): SerialPort | null;
+}
+//# sourceMappingURL=serial-client.d.ts.map

package/dist/client/serial-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial-client.d.ts","sourceRoot":"","sources":["../../src/client/serial-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAoB,MAAM,MAAM,CAAC;AAMpD,OAAO,EAEL,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;IAC3B,gBAAgB;IAChB,OAAO,CAAC,IAAI,CAA2B;IACvC,gBAAgB;IAChB,OAAO,CAAC,MAAM,CAAS;IACvB,gBAAgB;IAChB,OAAO,CAAC,gBAAgB,CAA4C;IACpE,gBAAgB;IAChB,OAAO,CAAC,iBAAiB,CAA4C;IACrE,gBAAgB;IAChB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEtB;IAEF;;;;;;OAMG;gBACS,OAAO,CAAC,EAAE,mBAAmB;IASzC;;;;;OAKG;IACH,WAAW,IAAI,UAAU,CAAC,UAAU,CAAC;IAuBrC;;;;;OAKG;IACH,QAAQ,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;IAcpC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC;IAyD5C;;;;;OAKG;IACH,UAAU,IAAI,UAAU,CAAC,IAAI,CAAC;IAqC9B;;;;;OAKG;IACH,aAAa,IAAI,UAAU,CAAC,UAAU,CAAC;IAWvC;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC;IAuD5D;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC;IA0BzC;;;;;OAKG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;;OAKG;IACH,IAAI,WAAW,IAAI,UAAU,GAAG,IAAI,CAEnC;CACF"}

package/dist/errors/serial-error-code.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Error codes for serial port operations.
+ *
+ * These codes identify specific error conditions that can occur when working with
+ * serial ports. Each error code corresponds to a specific failure scenario, making
+ * it easier to handle errors programmatically.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.connect().toPromise();
+ * } catch (error) {
+ *   if (error instanceof SerialError) {
+ *     switch (error.code) {
+ *       case SerialErrorCode.BROWSER_NOT_SUPPORTED:
+ *         console.error('Please use a Chromium-based browser');
+ *         break;
+ *       case SerialErrorCode.OPERATION_CANCELLED:
+ *         console.log('User cancelled port selection');
+ *         break;
+ *       // ... handle other error codes
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare enum SerialErrorCode {
+    /**
+     * Browser does not support the Web Serial API.
+     *
+     * This error occurs when attempting to use serial port functionality in a browser
+     * that doesn't support the Web Serial API. Only Chromium-based browsers (Chrome,
+     * Edge, Opera) support this API.
+     *
+     * **Suggested action**: Inform the user to use a supported browser.
+     */
+    BROWSER_NOT_SUPPORTED = "BROWSER_NOT_SUPPORTED",
+    /**
+     * Serial port is not available.
+     *
+     * This error occurs when a requested port cannot be accessed, such as when
+     * getting previously granted ports fails or when the port is already in use
+     * by another application.
+     *
+     * **Suggested action**: Check if the port is available or being used by another application.
+     */
+    PORT_NOT_AVAILABLE = "PORT_NOT_AVAILABLE",
+    /**
+     * Failed to open the serial port.
+     *
+     * This error occurs when the port cannot be opened, typically due to incorrect
+     * connection parameters, hardware issues, or permission problems.
+     *
+     * **Suggested action**: Verify connection parameters and check hardware connections.
+     */
+    PORT_OPEN_FAILED = "PORT_OPEN_FAILED",
+    /**
+     * Serial port is already open.
+     *
+     * This error occurs when attempting to open a port that is already connected.
+     * Only one connection can be active at a time per SerialClient instance.
+     *
+     * **Suggested action**: Disconnect the current port before connecting a new one.
+     */
+    PORT_ALREADY_OPEN = "PORT_ALREADY_OPEN",
+    /**
+     * Serial port is not open.
+     *
+     * This error occurs when attempting to read from or write to a port that hasn't
+     * been opened yet. The port must be connected before performing I/O operations.
+     *
+     * **Suggested action**: Call {@link SerialClient.connect} before reading or writing.
+     */
+    PORT_NOT_OPEN = "PORT_NOT_OPEN",
+    /**
+     * Failed to read from the serial port.
+     *
+     * This error occurs when reading data from the port fails, typically due to
+     * connection loss, hardware issues, or stream errors.
+     *
+     * **Suggested action**: Check the connection and hardware, then retry the read operation.
+     */
+    READ_FAILED = "READ_FAILED",
+    /**
+     * Failed to write to the serial port.
+     *
+     * This error occurs when writing data to the port fails, typically due to
+     * connection loss, hardware issues, or stream errors.
+     *
+     * **Suggested action**: Check the connection and hardware, then retry the write operation.
+     */
+    WRITE_FAILED = "WRITE_FAILED",
+    /**
+     * Serial port connection was lost.
+     *
+     * This error occurs when the connection to the serial port is unexpectedly
+     * terminated, such as when the device is disconnected or the port is closed
+     * by another process.
+     *
+     * **Suggested action**: Check the physical connection and reconnect if needed.
+     */
+    CONNECTION_LOST = "CONNECTION_LOST",
+    /**
+     * Invalid filter options provided.
+     *
+     * This error occurs when port filter options are invalid, such as when
+     * filter values are out of range or missing required fields.
+     *
+     * **Suggested action**: Verify filter options match the expected format and value ranges.
+     */
+    INVALID_FILTER_OPTIONS = "INVALID_FILTER_OPTIONS",
+    /**
+     * Operation was cancelled by the user.
+     *
+     * This error occurs when the user cancels a port selection dialog or aborts
+     * an operation before it completes.
+     *
+     * **Suggested action**: This is a normal condition - no action required, but you may want
+     * to inform the user that the operation was cancelled.
+     */
+    OPERATION_CANCELLED = "OPERATION_CANCELLED",
+    /**
+     * Unknown error occurred.
+     *
+     * This error code is used for errors that don't fit into any other category.
+     * The original error details may be available in the error's message or originalError property.
+     *
+     * **Suggested action**: Check the error message and originalError for more details.
+     */
+    UNKNOWN = "UNKNOWN"
+}
+//# sourceMappingURL=serial-error-code.d.ts.map

package/dist/errors/serial-error-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial-error-code.d.ts","sourceRoot":"","sources":["../../src/errors/serial-error-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oBAAY,eAAe;IACzB;;;;;;;;OAQG;IACH,qBAAqB,0BAA0B;IAE/C;;;;;;;;OAQG;IACH,kBAAkB,uBAAuB;IAEzC;;;;;;;OAOG;IACH,gBAAgB,qBAAqB;IAErC;;;;;;;OAOG;IACH,iBAAiB,sBAAsB;IAEvC;;;;;;;OAOG;IACH,aAAa,kBAAkB;IAE/B;;;;;;;OAOG;IACH,WAAW,gBAAgB;IAE3B;;;;;;;OAOG;IACH,YAAY,iBAAiB;IAE7B;;;;;;;;OAQG;IACH,eAAe,oBAAoB;IAEnC;;;;;;;OAOG;IACH,sBAAsB,2BAA2B;IAEjD;;;;;;;;OAQG;IACH,mBAAmB,wBAAwB;IAE3C;;;;;;;OAOG;IACH,OAAO,YAAY;CACpB"}