@gurezo/web-serial-rxjs 0.2.0 → 2.0.1

package/dist/client/index.d.ts

@@ -1,283 +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>;
-    /**
-     * Get an Observable that emits text read from the serial port.
-     *
-     * This is a convenience API on top of {@link getReadStream} that decodes bytes
-     * with TextDecoder and emits text chunks.
-     *
-     * @returns An Observable that emits decoded text chunks
-     * @throws {@link SerialError} with code {@link SerialErrorCode.PORT_NOT_OPEN} if the port is not open
-     */
-    getReadStreamAsText(): Observable<string>;
-    /**
-     * 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>;
-    /**
-     * Write text data to the serial port.
-     *
-     * This is a convenience API on top of {@link write} that encodes text with TextEncoder.
-     *
-     * @param data - Text 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
-     */
-    writeText(data: string): Observable<void>;
-    /**
-     * Check if the port is currently open and connected.
-     *
-     * @returns `true` if a port is currently open, `false` otherwise
-     */
-    readonly connected: boolean;
-    /**
-     * Reactive connection state stream.
-     *
-     * Emits `true` when connected and `false` when disconnected.
-     */
-    readonly connected$: Observable<boolean>;
-    /**
-     * Reactive connection event stream.
-     *
-     * Emits `'connected'` on successful connection and `'disconnected'` on disconnection.
-     */
-    readonly connectionEvents$: Observable<'connected' | 'disconnected'>;
-    /**
-     * 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;;;;;;;;OAQG;IACH,mBAAmB,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;OASG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAE1C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAEzC;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,EAAE,UAAU,CAAC,WAAW,GAAG,cAAc,CAAC,CAAC;IAErE;;;;;;;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,137 +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 sharedReadStream$;
-    /** @internal */
-    private textEncoder;
-    /** @internal */
-    private textDecoder;
-    /** @internal */
-    private readonly connectedState$;
-    /** @internal */
-    private readonly connectionEventsSubject$;
-    /** @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>;
-    /**
-     * Get an Observable that emits decoded text from the serial port.
-     *
-     * @returns Observable that emits text chunks
-     * @internal
-     */
-    getReadStreamAsText(): Observable<string>;
-    /**
-     * 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>;
-    /**
-     * Write text data to the serial port.
-     *
-     * @param data - Text data to write
-     * @returns Observable that completes when the data is written
-     * @internal
-     */
-    writeText(data: string): Observable<void>;
-    /**
-     * Check if the port is currently open.
-     *
-     * @returns `true` if a port is currently open, `false` otherwise
-     * @internal
-     */
-    get connected(): boolean;
-    /**
-     * Get an Observable that emits connection state changes.
-     *
-     * @returns Observable that emits `true` when connected and `false` when disconnected
-     * @internal
-     */
-    get connected$(): Observable<boolean>;
-    /**
-     * Get an Observable that emits connection lifecycle events.
-     *
-     * @returns Observable that emits 'connected' or 'disconnected'
-     * @internal
-     */
-    get connectionEvents$(): Observable<'connected' | 'disconnected'>;
-    /**
-     * 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,EAEL,UAAU,EAMX,MAAM,MAAM,CAAC;AAMd,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,iBAAiB,CAAuC;IAChE,gBAAgB;IAChB,OAAO,CAAC,WAAW,CAAqB;IACxC,gBAAgB;IAChB,OAAO,CAAC,WAAW,CAAqB;IACxC,gBAAgB;IAChB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuC;IACvE,gBAAgB;IAChB,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAErC;IACJ,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;IA2D5C;;;;;OAKG;IACH,UAAU,IAAI,UAAU,CAAC,IAAI,CAAC;IA2C9B;;;;;OAKG;IACH,aAAa,IAAI,UAAU,CAAC,UAAU,CAAC;IAqBvC;;;;;OAKG;IACH,mBAAmB,IAAI,UAAU,CAAC,MAAM,CAAC;IAMzC;;;;;;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;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC;IAIzC;;;;;OAKG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;;OAKG;IACH,IAAI,UAAU,IAAI,UAAU,CAAC,OAAO,CAAC,CAEpC;IAED;;;;;OAKG;IACH,IAAI,iBAAiB,IAAI,UAAU,CAAC,WAAW,GAAG,cAAc,CAAC,CAEhE;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/shell/create-shell-client.d.ts

@@ -1,17 +0,0 @@
-import { Observable } from 'rxjs';
-import type { SerialClient } from '../client';
-export interface ShellClientOptions {
-    prompt: string | RegExp;
-    timeout?: number;
-    retry?: number;
-    lineEnding?: string;
-}
-export interface ShellExecResult {
-    stdout: string;
-}
-export interface ShellClient {
-    exec$(command: string): Observable<ShellExecResult>;
-    readUntilPrompt$(): Observable<string>;
-}
-export declare function createShellClient(client: SerialClient, options: ShellClientOptions): ShellClient;
-//# sourceMappingURL=create-shell-client.d.ts.map

package/dist/shell/create-shell-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-shell-client.d.ts","sourceRoot":"","sources":["../../src/shell/create-shell-client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAMX,MAAM,MAAM,CAAC;AACd,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC;IACpD,gBAAgB,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;CACxC;AAyLD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,kBAAkB,GAC1B,WAAW,CAEb"}

package/dist/shell/index.d.ts

@@ -1,2 +0,0 @@
-export { createShellClient, type ShellClient, type ShellClientOptions, type ShellExecResult, } from './create-shell-client';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shell/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,eAAe,GACrB,MAAM,uBAAuB,CAAC"}