@gurezo/web-serial-rxjs 0.2.0 → 2.0.1

package/dist/session/send-queue.d.ts

@@ -0,0 +1,58 @@
+import { Observable } from 'rxjs';
+/**
+ * A single enqueued unit of work. Operations are awaited sequentially so
+ * that `send$` guarantees call order even when the caller fires multiple
+ * observables concurrently.
+ *
+ * @internal
+ */
+export type SendQueueOperation<T> = () => Promise<T>;
+/**
+ * Internal helper returned by {@link createSendQueue}.
+ *
+ * The queue is intentionally not an RxJS operator because Issue #199 calls
+ * out explicitly that `send$` must not be re-implemented with `mergeMap`
+ * (or any other concurrency-altering operator). A chained `Promise<void>`
+ * is the simplest way to guarantee strict FIFO ordering while still
+ * surfacing per-operation completion back to the caller.
+ *
+ * @internal
+ */
+export interface SendQueue {
+    /**
+     * Schedule an operation to run after all previously enqueued operations
+     * have settled (resolved or rejected). The returned Observable completes
+     * with the operation's resolved value, or errors with its rejection.
+     *
+     * Subscribing is what actually schedules the work - the queue is driven
+     * by `defer`, so late/never-subscribed Observables never enqueue.
+     */
+    enqueue<T>(operation: SendQueueOperation<T>): Observable<T>;
+    /**
+     * Reset the internal promise chain. Existing in-flight operations keep
+     * running because we do not cancel native promises, but no newly
+     * enqueued work will wait for them. Use this when the session is torn
+     * down so a fresh `connect$` starts with a clean chain.
+     */
+    clear(): void;
+}
+/**
+ * Create an internal send queue that serialises `send$` writes.
+ *
+ * Ordering model:
+ *
+ * - Each `enqueue` call appends its operation to a single `Promise<void>`
+ *   chain.
+ * - A failure in one operation does not poison the chain - the next
+ *   operation still runs (the chain is advanced with a `.then(() => {},
+ *   () => {})` safety tail).
+ * - Unsubscribing before the operation resolves suppresses `next` /
+ *   `complete` / `error` for that subscriber; the underlying promise is
+ *   still awaited so later operations continue to respect call order.
+ *
+ * @internal
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/199 | Issue #199}
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/203 | Issue #203}
+ */
+export declare function createSendQueue(): SendQueue;
+//# sourceMappingURL=send-queue.d.ts.map

package/dist/session/send-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-queue.d.ts","sourceRoot":"","sources":["../../src/session/send-queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAS,MAAM,MAAM,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;OAOG;IACH,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAC5D;;;;;OAKG;IACH,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,IAAI,SAAS,CAwC3C"}

package/dist/session/serial-session-options.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Options for creating a {@link SerialSession} via {@link createSerialSession}.
+ *
+ * These options configure the serial port connection parameters used when
+ * calling `port.open` and `navigator.serial.requestPort`. All properties
+ * are optional; omitted fields fall back to {@link DEFAULT_SERIAL_SESSION_OPTIONS}.
+ *
+ * @example
+ * ```typescript
+ * const session = createSerialSession({
+ *   baudRate: 115200,
+ *   dataBits: 8,
+ *   stopBits: 1,
+ *   parity: 'none',
+ *   flowControl: 'none',
+ *   filters: [{ usbVendorId: 0x1234, usbProductId: 0x5678 }],
+ * });
+ * ```
+ *
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/199 | Issue #199}
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/200 | Issue #200}
+ */
+export interface SerialSessionOptions {
+    /**
+     * 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).
+     *
+     * @default 8
+     */
+    dataBits?: 7 | 8;
+    /**
+     * Number of stop bits (1 or 2).
+     *
+     * @default 1
+     */
+    stopBits?: 1 | 2;
+    /**
+     * Parity checking mode.
+     *
+     * @default 'none'
+     */
+    parity?: 'none' | 'even' | 'odd';
+    /**
+     * Buffer size for the underlying read stream, in bytes.
+     *
+     * @default 255
+     */
+    bufferSize?: number;
+    /**
+     * Flow control mode.
+     *
+     * @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`.
+     */
+    filters?: SerialPortFilter[];
+}
+/**
+ * Default values applied to omitted {@link SerialSessionOptions} fields.
+ *
+ * @internal
+ */
+export declare const DEFAULT_SERIAL_SESSION_OPTIONS: Required<Omit<SerialSessionOptions, 'filters'>> & {
+    filters?: SerialPortFilter[];
+};
+//# sourceMappingURL=serial-session-options.d.ts.map

package/dist/session/serial-session-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial-session-options.d.ts","sourceRoot":"","sources":["../../src/session/serial-session-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IAEjC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAElC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CACnD,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,CACtC,GAAG;IAAE,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAQjC,CAAC"}

package/dist/session/serial-session-state.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reactive lifecycle state for a {@link SerialSession}.
+ *
+ * This is the v2 API counterpart of the legacy `SerialState` used by
+ * `SerialClient`. The runtime values are the same flat strings v1
+ * consumers used for UI switches; the {@link SerialSessionState} const
+ * object is the canonical source of those literals so call sites can
+ * avoid string typos and get IDE completion.
+ *
+ * Lifecycle transitions:
+ *
+ * ```
+ * idle -> connecting -> connected -> disconnecting -> idle
+ *                                \-> error
+ * (any)  -> unsupported   (when Web Serial API is unavailable)
+ * (any)  -> error         (when an unrecoverable failure occurs)
+ * ```
+ *
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/199 | Issue #199}
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/200 | Issue #200}
+ */
+export declare const SerialSessionState: {
+    readonly Idle: "idle";
+    readonly Connecting: "connecting";
+    readonly Connected: "connected";
+    readonly Disconnecting: "disconnecting";
+    readonly Unsupported: "unsupported";
+    readonly Error: "error";
+};
+/**
+ * String union of allowed {@link SerialSessionState} runtime values
+ * (same set as the values on the {@link SerialSessionState} object).
+ */
+export type SerialSessionState = (typeof SerialSessionState)[keyof typeof SerialSessionState];
+//# sourceMappingURL=serial-session-state.d.ts.map

package/dist/session/serial-session-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial-session-state.d.ts","sourceRoot":"","sources":["../../src/session/serial-session-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;CAOrB,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC"}

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

@@ -0,0 +1,143 @@
+import type { Observable } from 'rxjs';
+import type { SerialError } from '../errors/serial-error';
+import type { SerialSessionState } from './serial-session-state';
+/**
+ * v2 public API for interacting with the Web Serial API through a
+ * minimal, session-oriented surface.
+ *
+ * The session is intentionally slim so that apps (Angular, Vue, React, etc.)
+ * can drive their UI purely from `state$` + `isConnected$` + `receive$` + `lines$` + `errors$` and never
+ * have to rebuild BehaviorSubjects, manage a read loop, or serialize writes
+ * themselves.
+ *
+ * All imperative Web Serial work (open / read loop / write / close) is
+ * encapsulated by the implementation. Only Observables are exposed.
+ *
+ * @example
+ * ```typescript
+ * const session = createSerialSession({ baudRate: 115200 });
+ *
+ * session.state$.subscribe((state) => console.log('state:', state));
+ * session.receive$.subscribe((chunk) => console.log('rx:', chunk));
+ * session.errors$.subscribe((error) => console.error('err:', error));
+ *
+ * session.connect$().subscribe();
+ * session.send$('hello\r\n').subscribe();
+ * ```
+ *
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/199 | Issue #199}
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/200 | Issue #200}
+ * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/203 | Issue #203}
+ */
+export interface SerialSession {
+    /**
+     * Synchronous feature detection for the Web Serial API.
+     *
+     * Never throws; intended for UI branching before calling `connect$`.
+     *
+     * @returns `true` when `navigator.serial` is available.
+     */
+    isBrowserSupported(): boolean;
+    /**
+     * Open a serial port and start the internal read pump.
+     *
+     * Returns an Observable that completes when the port is fully opened and
+     * the read pump is running. Subscribing to `receive$` before calling
+     * `connect$` is safe: emissions simply start after the pump is active.
+     *
+     * @returns An Observable that completes on successful connection.
+     */
+    connect$(): Observable<void>;
+    /**
+     * Close the active serial port and stop the internal read pump.
+     *
+     * Safe to call when already disconnected.
+     *
+     * @returns An Observable that completes when the port is fully closed.
+     */
+    disconnect$(): Observable<void>;
+    /**
+     * Reactive session lifecycle state.
+     *
+     * Replays the current state on subscribe. UIs should drive entirely from
+     * this stream instead of reconstructing their own BehaviorSubject.
+     */
+    readonly state$: Observable<SerialSessionState>;
+    /**
+     * `true` when {@link state$} is `'connected'`, `false` for all other states.
+     *
+     * Derived from `state$` with `distinctUntilChanged` so UIs can bind
+     * connect/disabled flags without reimplementing the comparison.
+     */
+    readonly isConnected$: Observable<boolean>;
+    /**
+     * Primary error channel.
+     *
+     * All {@link SerialError} instances produced by the session (connect /
+     * read / write / close) are multiplexed here. This is the main channel,
+     * not a supplementary one.
+     *
+     * Every emission is the exact same instance that is also surfaced to
+     * the relevant call-site subscriber (for example `connect$().subscribe`
+     * receives the same `SerialError` that `errors$` emits for that
+     * failure), so a single subscription is enough to observe the full
+     * error history without double-normalisation.
+     *
+     * Fatal failures (connect / read / close) additionally drive `state$`
+     * to `'error'` and tear down the live pump + port; non-fatal failures
+     * (currently only `send$` write failures) are multiplexed here without
+     * mutating `state$`, on the assumption that a real connection loss is
+     * detected by the read pump on the next tick.
+     *
+     * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/204 | Issue #204}
+     */
+    readonly errors$: Observable<SerialError>;
+    /**
+     * Incoming data from the serial port as UTF-8 decoded text.
+     *
+     * The stream is driven by the read pump started by `connect$` and is
+     * decoded internally with a streaming `TextDecoder`, so multi-byte
+     * characters split across chunks are joined correctly. It is **not**
+     * subscription-lazy: emissions happen regardless of whether a consumer
+     * is currently subscribed, so late subscribers see only new data.
+     *
+     * Emits **raw decoder chunks** (not line-aligned). For newline-framed
+     * protocols, use {@link lines$} or derive your own framing from
+     * `receive$`.
+     */
+    readonly receive$: Observable<string>;
+    /**
+     * Decoded text split into **complete lines** using `\n`, `\r\n`, and
+     * lone interior `\r` (see implementation). A trailing fragment without
+     * a line terminator is buffered until a later chunk completes a line, or
+     * discarded on disconnect. It is **not** subscription-lazy: the same
+     * framing runs whenever the read pump is active, independent of
+     * subscribers.
+     */
+    readonly lines$: Observable<string>;
+    /**
+     * Enqueue data for ordered transmission.
+     *
+     * Writes are serialized internally through a FIFO send queue so that
+     * concurrent `send$` calls are delivered to the port in **call order**,
+     * regardless of how quickly each subscriber runs. String payloads are
+     * UTF-8 encoded via a shared `TextEncoder`; `Uint8Array` payloads are
+     * passed through unchanged. Write failures are normalized into
+     * {@link SerialError} with {@link SerialErrorCode.WRITE_FAILED} and
+     * multiplexed on {@link SerialSession.errors$} in addition to being
+     * surfaced to the subscriber, so a single subscription is enough to
+     * observe every I/O error. Calling `send$` while the session is not in
+     * `'connected'` state fails fast with
+     * {@link SerialErrorCode.PORT_NOT_OPEN}.
+     *
+     * The returned Observable completes once the enqueued payload has been
+     * flushed to the underlying writer.
+     *
+     * @param data - Text (UTF-8 encoded) or raw bytes to send.
+     * @returns An Observable that completes when the payload is written.
+     *
+     * @see {@link https://github.com/gurezo/web-serial-rxjs/issues/203 | Issue #203}
+     */
+    send$(data: string | Uint8Array): Observable<void>;
+}
+//# sourceMappingURL=serial-session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serial-session.d.ts","sourceRoot":"","sources":["../../src/session/serial-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,kBAAkB,IAAI,OAAO,CAAC;IAE9B;;;;;;;;OAQG;IACH,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IAE7B;;;;;;OAMG;IACH,WAAW,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IAEhC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAEhD;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAE1C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;IAEtC;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;IAEpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;CACpD"}

package/dist/session/session-state-machine.d.ts

@@ -0,0 +1,39 @@
+import { Observable } from 'rxjs';
+import { SerialSessionState } from './serial-session-state';
+/**
+ * Internal state machine that backs {@link SerialSession.state$}.
+ *
+ * The machine is deliberately kept as an internal module (not exported
+ * from the package) because the public surface is only the Observable.
+ * Sub-issues of #199 (read pump / send queue / errors) drive transitions
+ * through the dedicated `to*` methods below instead of mutating a shared
+ * `BehaviorSubject` directly.
+ *
+ * Design notes:
+ *
+ * - Invalid transitions are silently rejected so that the `state$` stream
+ *   never emits a state that violates the lifecycle contract. A
+ *   `console.warn` is emitted in development builds to aid debugging.
+ * - `unsupported` is terminal: once entered (during construction when
+ *   `navigator.serial` is missing), the machine refuses every further
+ *   transition.
+ * - `state$` is derived from a {@link BehaviorSubject} so late subscribers
+ *   still receive the current state on subscription.
+ *
+ * @internal
+ */
+export declare class SessionStateMachine {
+    private readonly subject;
+    constructor(initial?: SerialSessionState);
+    get current(): SerialSessionState;
+    get state$(): Observable<SerialSessionState>;
+    toConnecting(): boolean;
+    toConnected(): boolean;
+    toDisconnecting(): boolean;
+    toIdle(): boolean;
+    toError(): boolean;
+    toUnsupported(): boolean;
+    complete(): void;
+    private transition;
+}
+//# sourceMappingURL=session-state-machine.d.ts.map

package/dist/session/session-state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-state-machine.d.ts","sourceRoot":"","sources":["../../src/session/session-state-machine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,MAAM,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAoC5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAElD,OAAO,GAAE,kBAA4C;IAIjE,IAAI,OAAO,IAAI,kBAAkB,CAEhC;IAED,IAAI,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAE3C;IAED,YAAY,IAAI,OAAO;IAIvB,WAAW,IAAI,OAAO;IAItB,eAAe,IAAI,OAAO;IAI1B,MAAM,IAAI,OAAO;IAIjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAIxB,QAAQ,IAAI,IAAI;IAIhB,OAAO,CAAC,UAAU;CAoBnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gurezo/web-serial-rxjs",
-  "version": "0.2.0",
+  "version": "2.0.1",
   "description": "RxJS-based utilities for the Web Serial API, usable from Angular, React, Svelte, and Vanilla JavaScript/TypeScript.",
   "author": "Akihiko Kigure <akihiko.kigure@gmail.com>",
   "license": "MIT",
@@ -11,10 +11,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
-    "./shell": {
-      "types": "./dist/shell/index.d.ts",
-      "import": "./dist/shell/index.mjs"
-    },
     "./package.json": "./package.json"
   },
   "files": [

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

@@ -1,104 +0,0 @@
-/**
- * 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

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

@@ -1,57 +0,0 @@
-/**
- * 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

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