@gurezo/web-serial-rxjs 0.1.21 → 2.0.0

package/dist/client/index.d.ts

@@ -1,250 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,98 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/filters/build-request-options.d.ts

@@ -1,42 +0,0 @@
-import { SerialClientOptions } from '../types/options';
-/**
- * Build SerialPortRequestOptions from SerialClientOptions.
- *
- * This utility function converts filter options from {@link SerialClientOptions} into
- * the format expected by the Web Serial API's `navigator.serial.requestPort()` method.
- * It validates the filter options to ensure they are valid before returning them.
- *
- * If no filters are provided in the options, this function returns `undefined`, which
- * allows the port selection dialog to show all available ports.
- *
- * @param options - Optional SerialClientOptions containing filter configuration
- * @returns SerialPortRequestOptions object with validated filters, or `undefined` if no filters are provided
- * @throws {@link SerialError} with code {@link SerialErrorCode.INVALID_FILTER_OPTIONS} if filter validation fails
- *
- * @example
- * ```typescript
- * // With filters
- * const options = {
- *   baudRate: 9600,
- *   filters: [
- *     { usbVendorId: 0x1234 },
- *     { usbVendorId: 0x5678, usbProductId: 0x9abc },
- *   ],
- * };
- * const requestOptions = buildRequestOptions(options);
- * // Returns: { filters: [...] }
- *
- * // Without filters
- * const requestOptions = buildRequestOptions({ baudRate: 9600 });
- * // Returns: undefined
- *
- * // Invalid filter (will throw)
- * try {
- *   buildRequestOptions({ filters: [{ usbVendorId: -1 }] });
- * } catch (error) {
- *   // SerialError with code INVALID_FILTER_OPTIONS
- * }
- * ```
- */
-export declare function buildRequestOptions(options?: SerialClientOptions): SerialPortRequestOptions | undefined;
-//# sourceMappingURL=build-request-options.d.ts.map

package/dist/filters/build-request-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-request-options.d.ts","sourceRoot":"","sources":["../../src/filters/build-request-options.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,wBAAwB,GAAG,SAAS,CA4CtC"}

package/dist/io/observable-to-writable.d.ts

@@ -1,65 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * Convert an RxJS Observable to a WritableStream.
- *
- * This utility function converts an RxJS Observable into a Web Streams API WritableStream.
- * Values emitted by the Observable will be written to the returned WritableStream. The stream
- * will close when the Observable completes or abort if the Observable errors.
- *
- * Note: This function creates a new WritableStream. For directly subscribing to an Observable
- * and writing to an existing WritableStream, use {@link subscribeToWritable} instead.
- *
- * @param observable - The Observable to convert to a WritableStream
- * @returns A WritableStream that writes Uint8Array chunks emitted by the Observable
- *
- * @example
- * ```typescript
- * const data$ = from([
- *   new TextEncoder().encode('Hello'),
- *   new TextEncoder().encode('World'),
- * ]);
- *
- * const writableStream = observableToWritable(data$);
- * // Use the writable stream with other Web Streams APIs
- * ```
- */
-export declare function observableToWritable(observable: Observable<Uint8Array>): WritableStream<Uint8Array>;
-/**
- * Subscribe to an Observable and write its values to a WritableStream.
- *
- * This utility function subscribes to an RxJS Observable and writes all emitted values
- * to the provided WritableStream. This is commonly used to write Observable data to a
- * serial port's writable stream.
- *
- * The function returns a subscription object that can be used to unsubscribe and clean up.
- * When unsubscribed, the writer lock will be released properly.
- *
- * @param observable - The Observable to subscribe to and read data from
- * @param stream - The WritableStream to write data to
- * @returns A subscription object with an `unsubscribe` method for cleanup
- * @throws {@link SerialError} with code {@link SerialErrorCode.WRITE_FAILED} if writing to the stream fails
- *
- * @example
- * ```typescript
- * const data$ = from([
- *   new TextEncoder().encode('Hello'),
- *   new TextEncoder().encode('World'),
- * ]);
- *
- * const subscription = subscribeToWritable(data$, port.writable);
- *
- * // Later, to cancel and clean up:
- * subscription.unsubscribe();
- *
- * // Use with RxJS operators
- * const processedData$ = of('Hello, Serial!').pipe(
- *   map((text) => new TextEncoder().encode(text))
- * );
- *
- * subscribeToWritable(processedData$, port.writable);
- * ```
- */
-export declare function subscribeToWritable(observable: Observable<Uint8Array>, stream: WritableStream<Uint8Array>): {
-    unsubscribe: () => void;
-};
-//# sourceMappingURL=observable-to-writable.d.ts.map

package/dist/io/observable-to-writable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observable-to-writable.d.ts","sourceRoot":"","sources":["../../src/io/observable-to-writable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAGlC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,GACjC,cAAc,CAAC,UAAU,CAAC,CAqE5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,EAClC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC;IAAE,WAAW,EAAE,MAAM,IAAI,CAAA;CAAE,CAiD7B"}

package/dist/io/readable-to-observable.d.ts

@@ -1,44 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * Convert a ReadableStream to an RxJS Observable.
- *
- * This utility function converts a Web Streams API ReadableStream into an RxJS Observable,
- * allowing you to use RxJS operators with stream data. The Observable will emit Uint8Array
- * chunks as they are read from the stream, complete when the stream ends, or error if
- * the stream encounters an error.
- *
- * The returned Observable handles stream cleanup automatically - if you unsubscribe before
- * the stream completes, the reader lock will be released properly.
- *
- * @param stream - The ReadableStream to convert to an Observable
- * @returns An Observable that emits Uint8Array chunks from the stream
- * @throws {@link SerialError} with code {@link SerialErrorCode.READ_FAILED} if reading from the stream fails
- *
- * @example
- * ```typescript
- * // Convert a serial port's readable stream to an Observable
- * const readable$ = readableToObservable(port.readable);
- *
- * readable$.subscribe({
- *   next: (chunk) => {
- *     console.log('Received chunk:', chunk);
- *   },
- *   complete: () => {
- *     console.log('Stream completed');
- *   },
- *   error: (error) => {
- *     console.error('Stream error:', error);
- *   },
- * });
- *
- * // Use with RxJS operators
- * readableToObservable(port.readable)
- *   .pipe(
- *     map((chunk) => new TextDecoder().decode(chunk)),
- *     filter((text) => text.includes('OK'))
- *   )
- *   .subscribe((text) => console.log('Filtered text:', text));
- * ```
- */
-export declare function readableToObservable(stream: ReadableStream<Uint8Array>): Observable<Uint8Array>;
-//# sourceMappingURL=readable-to-observable.d.ts.map

package/dist/io/readable-to-observable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"readable-to-observable.d.ts","sourceRoot":"","sources":["../../src/io/readable-to-observable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAGlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,UAAU,CAAC,UAAU,CAAC,CAoDxB"}

package/dist/lib/web-serial-rxjs.d.ts

@@ -1,7 +0,0 @@
-/**
- * Utility function that returns the library name.
- *
- * @returns The library name as a string: 'web-serial-rxjs'
- */
-export declare function webSerialRxjs(): string;
-//# sourceMappingURL=web-serial-rxjs.d.ts.map

package/dist/lib/web-serial-rxjs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-serial-rxjs.d.ts","sourceRoot":"","sources":["../../src/lib/web-serial-rxjs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC"}

package/dist/types/options.d.ts

@@ -1,107 +0,0 @@
-/**
- * Options for creating a SerialClient instance.
- *
- * These options configure the serial port connection parameters. All properties are optional
- * and will use default values if not specified. See {@link DEFAULT_SERIAL_CLIENT_OPTIONS} for
- * the default values used.
- *
- * @example
- * ```typescript
- * const client = createSerialClient({
- *   baudRate: 115200,
- *   dataBits: 8,
- *   stopBits: 1,
- *   parity: 'none',
- *   flowControl: 'none',
- *   filters: [{ usbVendorId: 0x1234, usbProductId: 0x5678 }],
- * });
- * ```
- */
-export interface SerialClientOptions {
-    /**
-     * Baud rate for the serial port connection (bits per second).
-     *
-     * Common values include 9600, 19200, 38400, 57600, 115200, etc.
-     * Must match the baud rate configured on the connected device.
-     *
-     * @default 9600
-     */
-    baudRate?: number;
-    /**
-     * Number of data bits per character (7 or 8).
-     *
-     * - `7`: Seven data bits (used with parity)
-     * - `8`: Eight data bits (most common, used without parity)
-     *
-     * @default 8
-     */
-    dataBits?: 7 | 8;
-    /**
-     * Number of stop bits (1 or 2).
-     *
-     * - `1`: One stop bit (most common)
-     * - `2`: Two stop bits (less common, used for slower devices)
-     *
-     * @default 1
-     */
-    stopBits?: 1 | 2;
-    /**
-     * Parity checking mode.
-     *
-     * - `'none'`: No parity checking (most common)
-     * - `'even'`: Even parity
-     * - `'odd'`: Odd parity
-     *
-     * @default 'none'
-     */
-    parity?: 'none' | 'even' | 'odd';
-    /**
-     * Buffer size for reading data from the serial port, in bytes.
-     *
-     * This determines how much data can be buffered before it needs to be read.
-     * Larger buffers can improve performance but use more memory.
-     *
-     * @default 255
-     */
-    bufferSize?: number;
-    /**
-     * Flow control mode.
-     *
-     * - `'none'`: No flow control (most common)
-     * - `'hardware'`: Hardware flow control (RTS/CTS)
-     *
-     * @default 'none'
-     */
-    flowControl?: 'none' | 'hardware';
-    /**
-     * Filters for port selection when requesting a port.
-     *
-     * When specified, the port selection dialog will only show devices matching
-     * these filters. Each filter can specify `usbVendorId` and/or `usbProductId`
-     * to filter by USB device identifiers.
-     *
-     * @example
-     * ```typescript
-     * filters: [
-     *   { usbVendorId: 0x1234 },
-     *   { usbVendorId: 0x1234, usbProductId: 0x5678 },
-     * ]
-     * ```
-     *
-     * @see {@link SerialPortFilter} for the filter structure
-     */
-    filters?: SerialPortFilter[];
-}
-/**
- * Default options for SerialClient instances.
- *
- * These are the default values used when creating a SerialClient if no options
- * are provided or if specific options are omitted. The values are chosen to work
- * with most common serial devices.
- *
- * @see {@link SerialClientOptions} for details on each option
- */
-export declare const DEFAULT_SERIAL_CLIENT_OPTIONS: Required<Omit<SerialClientOptions, 'filters'>> & {
-    filters?: SerialPortFilter[];
-};
-//# sourceMappingURL=options.d.ts.map

package/dist/types/options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/types/options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEjB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEjB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IAEjC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAElC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAClD,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,CACrC,GAAG;IAAE,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAQjC,CAAC"}