@gurezo/web-serial-rxjs 2.3.6 → 3.0.0

package/dist/index.js

@@ -1,724 +0,0 @@
-// packages/web-serial-rxjs/src/session/create-serial-session.ts
-import {
-  BehaviorSubject as BehaviorSubject2,
-  distinctUntilChanged,
-  map as map2,
-  Observable as Observable3,
-  ReplaySubject,
-  share,
-  Subject,
-  switchMap
-} from "rxjs";
-
-// packages/web-serial-rxjs/src/errors/serial-error-code.ts
-var SerialErrorCode = /* @__PURE__ */ ((SerialErrorCode2) => {
-  SerialErrorCode2["BROWSER_NOT_SUPPORTED"] = "BROWSER_NOT_SUPPORTED";
-  SerialErrorCode2["PORT_NOT_AVAILABLE"] = "PORT_NOT_AVAILABLE";
-  SerialErrorCode2["PORT_OPEN_FAILED"] = "PORT_OPEN_FAILED";
-  SerialErrorCode2["PORT_ALREADY_OPEN"] = "PORT_ALREADY_OPEN";
-  SerialErrorCode2["PORT_NOT_OPEN"] = "PORT_NOT_OPEN";
-  SerialErrorCode2["READ_FAILED"] = "READ_FAILED";
-  SerialErrorCode2["WRITE_FAILED"] = "WRITE_FAILED";
-  SerialErrorCode2["CONNECTION_LOST"] = "CONNECTION_LOST";
-  SerialErrorCode2["INVALID_FILTER_OPTIONS"] = "INVALID_FILTER_OPTIONS";
-  SerialErrorCode2["OPERATION_CANCELLED"] = "OPERATION_CANCELLED";
-  SerialErrorCode2["OPERATION_TIMEOUT"] = "OPERATION_TIMEOUT";
-  SerialErrorCode2["UNKNOWN"] = "UNKNOWN";
-  return SerialErrorCode2;
-})(SerialErrorCode || {});
-
-// packages/web-serial-rxjs/src/errors/serial-error.ts
-var SerialError = class _SerialError extends Error {
-  /**
-   * Creates a new SerialError instance.
-   *
-   * @param code - The error code identifying the type of error
-   * @param message - A human-readable error message
-   * @param originalError - The original error that caused this SerialError, if any
-   */
-  constructor(code, message, originalError) {
-    super(message);
-    this.name = "SerialError";
-    this.code = code;
-    this.originalError = originalError;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _SerialError);
-    }
-  }
-  /**
-   * Check if the error matches a specific error code.
-   *
-   * This is a convenience method for checking the error code without directly
-   * comparing the code property.
-   *
-   * @param code - The error code to check against
-   * @returns `true` if this error's code matches the provided code, `false` otherwise
-   *
-   * @example
-   * ```typescript
-   * if (error.is(SerialErrorCode.PORT_NOT_OPEN)) {
-   *   // Handle port not open error
-   * }
-   * ```
-   */
-  is(code) {
-    return this.code === code;
-  }
-};
-
-// packages/web-serial-rxjs/src/terminal/create-terminal-buffer.ts
-import { map, scan, shareReplay } from "rxjs";
-function applyTerminalChunk(state, chunk) {
-  let { completed, currentLine } = state;
-  const len = chunk.length;
-  for (let i = 0; i < len; i++) {
-    const c = chunk.charAt(i);
-    if (c === "\r") {
-      const next = i + 1 < len ? chunk.charAt(i + 1) : "";
-      if (next === "\n") {
-        completed += currentLine + "\n";
-        currentLine = "";
-        i++;
-      } else {
-        currentLine = "";
-      }
-    } else if (c === "\n") {
-      completed += currentLine + "\n";
-      currentLine = "";
-    } else {
-      currentLine += c;
-    }
-  }
-  return { completed, currentLine };
-}
-function terminalDisplayText(state) {
-  return state.completed + state.currentLine;
-}
-var initialTerminalState = {
-  completed: "",
-  currentLine: ""
-};
-function createTerminalBuffer(receive$) {
-  const text$ = receive$.pipe(
-    scan(
-      (state, chunk) => applyTerminalChunk(state, chunk),
-      initialTerminalState
-    ),
-    map(terminalDisplayText),
-    shareReplay({ bufferSize: 1, refCount: true })
-  );
-  return { text$ };
-}
-
-// packages/web-serial-rxjs/src/session/internal/build-request-options.ts
-function buildRequestOptions(options) {
-  if (!options || !options.filters || options.filters.length === 0) {
-    return void 0;
-  }
-  for (const filter of options.filters) {
-    if (!filter.usbVendorId && !filter.usbProductId) {
-      throw new SerialError(
-        "INVALID_FILTER_OPTIONS" /* INVALID_FILTER_OPTIONS */,
-        "Filter must have at least usbVendorId or usbProductId"
-      );
-    }
-    if (filter.usbVendorId !== void 0) {
-      if (!Number.isInteger(filter.usbVendorId) || filter.usbVendorId < 0 || filter.usbVendorId > 65535) {
-        throw new SerialError(
-          "INVALID_FILTER_OPTIONS" /* INVALID_FILTER_OPTIONS */,
-          `Invalid usbVendorId: ${filter.usbVendorId}. Must be an integer between 0 and 65535.`
-        );
-      }
-    }
-    if (filter.usbProductId !== void 0) {
-      if (!Number.isInteger(filter.usbProductId) || filter.usbProductId < 0 || filter.usbProductId > 65535) {
-        throw new SerialError(
-          "INVALID_FILTER_OPTIONS" /* INVALID_FILTER_OPTIONS */,
-          `Invalid usbProductId: ${filter.usbProductId}. Must be an integer between 0 and 65535.`
-        );
-      }
-    }
-  }
-  return {
-    filters: options.filters
-  };
-}
-
-// packages/web-serial-rxjs/src/session/internal/has-web-serial-support.ts
-function hasWebSerialSupport() {
-  return typeof navigator !== "undefined" && "serial" in navigator && navigator.serial !== void 0 && navigator.serial !== null;
-}
-
-// packages/web-serial-rxjs/src/session/internal/line-buffer.ts
-function createLineBuffer() {
-  let buffer = "";
-  const clear = () => {
-    buffer = "";
-  };
-  const feed = (chunk) => {
-    buffer += chunk;
-    const out = [];
-    for (; ; ) {
-      const crlf = buffer.indexOf("\r\n");
-      if (crlf >= 0) {
-        out.push(buffer.slice(0, crlf));
-        buffer = buffer.slice(crlf + 2);
-        continue;
-      }
-      const cr = buffer.indexOf("\r");
-      if (cr >= 0 && cr + 1 < buffer.length && buffer[cr + 1] !== "\n") {
-        out.push(buffer.slice(0, cr));
-        buffer = buffer.slice(cr + 1);
-        continue;
-      }
-      const nl = buffer.indexOf("\n");
-      if (nl >= 0) {
-        out.push(buffer.slice(0, nl));
-        buffer = buffer.slice(nl + 1);
-        continue;
-      }
-      if (cr >= 0 && cr + 1 === buffer.length) {
-        break;
-      }
-      break;
-    }
-    return out;
-  };
-  return { feed, clear };
-}
-
-// packages/web-serial-rxjs/src/session/normalize-serial-error.ts
-var DEFAULT_MESSAGE_PREFIX = "Serial operation failed";
-var isDomExceptionWithName = (error, name) => typeof DOMException !== "undefined" && error instanceof DOMException && error.name === name;
-function normalizeSerialError(error, options) {
-  if (error instanceof SerialError) {
-    return error;
-  }
-  const prefix = options.messagePrefix ?? DEFAULT_MESSAGE_PREFIX;
-  if (isDomExceptionWithName(error, "NotFoundError")) {
-    return new SerialError(
-      "OPERATION_CANCELLED" /* OPERATION_CANCELLED */,
-      "Port selection was cancelled by the user",
-      error
-    );
-  }
-  const cause = error instanceof Error ? error : new Error(String(error));
-  return new SerialError(
-    options.fallbackCode,
-    `${prefix}: ${cause.message}`,
-    cause
-  );
-}
-
-// packages/web-serial-rxjs/src/session/read-pump.ts
-function createReadPump(port, { onChunk, onError }) {
-  let reader = null;
-  let running = false;
-  let stopped = false;
-  const decoder = new TextDecoder(void 0, { fatal: false });
-  const releaseReader = () => {
-    if (!reader) {
-      return;
-    }
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-    reader = null;
-  };
-  const pump = async (stream) => {
-    reader = stream.getReader();
-    running = true;
-    try {
-      while (!stopped) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        if (value && value.byteLength > 0) {
-          const text = decoder.decode(value, { stream: true });
-          if (text.length > 0) {
-            onChunk(text);
-          }
-        }
-      }
-      if (!stopped) {
-        const tail = decoder.decode();
-        if (tail.length > 0) {
-          onChunk(tail);
-        }
-      }
-    } catch (error) {
-      if (!stopped) {
-        onError(
-          normalizeSerialError(error, {
-            fallbackCode: "READ_FAILED" /* READ_FAILED */,
-            messagePrefix: "Read pump failed"
-          })
-        );
-      }
-    } finally {
-      running = false;
-      releaseReader();
-    }
-  };
-  return {
-    start() {
-      if (running || stopped) {
-        return;
-      }
-      const stream = port.readable;
-      if (!stream) {
-        stopped = true;
-        onError(
-          new SerialError(
-            "CONNECTION_LOST" /* CONNECTION_LOST */,
-            "Read pump failed: port.readable is not available"
-          )
-        );
-        return;
-      }
-      void pump(stream);
-    },
-    async stop() {
-      if (stopped) {
-        return;
-      }
-      stopped = true;
-      if (!reader) {
-        return;
-      }
-      try {
-        await reader.cancel();
-      } catch {
-      } finally {
-        releaseReader();
-      }
-    },
-    get isRunning() {
-      return running;
-    }
-  };
-}
-
-// packages/web-serial-rxjs/src/session/send-queue.ts
-import { Observable, defer } from "rxjs";
-function createSendQueue() {
-  let chain = Promise.resolve();
-  return {
-    enqueue(operation) {
-      return defer(
-        () => new Observable((subscriber) => {
-          let cancelled = false;
-          const run = async () => {
-            try {
-              const value = await operation();
-              if (!cancelled) {
-                subscriber.next(value);
-                subscriber.complete();
-              }
-            } catch (error) {
-              if (!cancelled) {
-                subscriber.error(error);
-              }
-            }
-          };
-          const scheduled = chain.then(run, run);
-          chain = scheduled.then(
-            () => void 0,
-            () => void 0
-          );
-          return () => {
-            cancelled = true;
-          };
-        })
-      );
-    },
-    clear() {
-      chain = Promise.resolve();
-    }
-  };
-}
-
-// packages/web-serial-rxjs/src/session/serial-session-options.ts
-var DEFAULT_RECEIVE_REPLAY = {
-  enabled: false,
-  bufferSize: 512
-};
-var DEFAULT_SERIAL_SESSION_OPTIONS = {
-  baudRate: 9600,
-  dataBits: 8,
-  stopBits: 1,
-  parity: "none",
-  bufferSize: 255,
-  flowControl: "none",
-  filters: void 0,
-  receiveReplay: { ...DEFAULT_RECEIVE_REPLAY }
-};
-
-// packages/web-serial-rxjs/src/session/serial-session-state.ts
-var SerialSessionState = {
-  Idle: "idle",
-  Connecting: "connecting",
-  Connected: "connected",
-  Disconnecting: "disconnecting",
-  Unsupported: "unsupported",
-  Error: "error"
-};
-
-// packages/web-serial-rxjs/src/session/session-state-machine.ts
-import { BehaviorSubject } from "rxjs";
-var S = SerialSessionState;
-var ALLOWED_TRANSITIONS = {
-  [S.Idle]: [S.Connecting, S.Error],
-  [S.Connecting]: [S.Connected, S.Error, S.Idle],
-  [S.Connected]: [S.Disconnecting, S.Error],
-  [S.Disconnecting]: [S.Idle, S.Error],
-  [S.Error]: [S.Idle, S.Connecting],
-  [S.Unsupported]: []
-};
-var SessionStateMachine = class {
-  constructor(initial = SerialSessionState.Idle) {
-    this.subject = new BehaviorSubject(initial);
-  }
-  get current() {
-    return this.subject.getValue();
-  }
-  get state$() {
-    return this.subject.asObservable();
-  }
-  toConnecting() {
-    return this.transition(S.Connecting);
-  }
-  toConnected() {
-    return this.transition(S.Connected);
-  }
-  toDisconnecting() {
-    return this.transition(S.Disconnecting);
-  }
-  toIdle() {
-    return this.transition(S.Idle);
-  }
-  toError() {
-    return this.transition(S.Error);
-  }
-  toUnsupported() {
-    return this.transition(S.Unsupported);
-  }
-  complete() {
-    this.subject.complete();
-  }
-  transition(next) {
-    const current = this.subject.getValue();
-    if (current === next) {
-      return false;
-    }
-    const allowed = ALLOWED_TRANSITIONS[current];
-    if (!allowed.includes(next)) {
-      if (typeof console !== "undefined" && console.warn) {
-        console.warn(
-          `[web-serial-rxjs] Ignoring invalid SerialSession transition ${current} -> ${next}`
-        );
-      }
-      return false;
-    }
-    this.subject.next(next);
-    return true;
-  }
-};
-
-// packages/web-serial-rxjs/src/session/create-serial-session.ts
-function createSerialSession(options) {
-  const resolvedOptions = {
-    ...DEFAULT_SERIAL_SESSION_OPTIONS,
-    ...options,
-    filters: options?.filters,
-    receiveReplay: {
-      ...DEFAULT_SERIAL_SESSION_OPTIONS.receiveReplay,
-      ...options?.receiveReplay
-    }
-  };
-  const supported = hasWebSerialSupport();
-  const machine = new SessionStateMachine(
-    supported ? SerialSessionState.Idle : SerialSessionState.Unsupported
-  );
-  const errorsSubject = new Subject();
-  const receiveSubject = new Subject();
-  const linesSubject = new Subject();
-  const sendQueue = createSendQueue();
-  const textEncoder = new TextEncoder();
-  const lineBuffer = createLineBuffer();
-  const errors$ = errorsSubject.asObservable();
-  const receive$ = receiveSubject.asObservable();
-  const lines$ = linesSubject.asObservable();
-  const terminalText$ = createTerminalBuffer(receive$).text$;
-  const isConnected$ = machine.state$.pipe(
-    map2((state) => state === SerialSessionState.Connected),
-    distinctUntilChanged()
-  );
-  const portInfoSubject = new BehaviorSubject2(null);
-  const portInfo$ = portInfoSubject.asObservable();
-  const receiveReplayStream$ = resolvedOptions.receiveReplay.enabled ? new BehaviorSubject2(receive$) : null;
-  let activeReceiveReplay = null;
-  const clearLiveReceiveReplay = () => {
-    if (receiveReplayStream$) {
-      if (activeReceiveReplay) {
-        activeReceiveReplay.complete();
-        activeReceiveReplay = null;
-      }
-      receiveReplayStream$.next(receive$);
-    }
-  };
-  const startLiveReceiveReplay = () => {
-    if (!receiveReplayStream$) {
-      return;
-    }
-    if (activeReceiveReplay) {
-      activeReceiveReplay.complete();
-      activeReceiveReplay = null;
-    }
-    const rs = new ReplaySubject(resolvedOptions.receiveReplay.bufferSize);
-    activeReceiveReplay = rs;
-    receiveReplayStream$.next(rs.asObservable());
-  };
-  const receiveReplay$ = receiveReplayStream$ ? receiveReplayStream$.pipe(switchMap((inner) => inner), share()) : receive$;
-  let activePort = null;
-  let activePump = null;
-  const setActivePort = (port) => {
-    activePort = port;
-    portInfoSubject.next(port ? port.getInfo() : null);
-  };
-  const teardownPump = async () => {
-    clearLiveReceiveReplay();
-    const pump = activePump;
-    activePump = null;
-    lineBuffer.clear();
-    if (pump) {
-      await pump.stop();
-    }
-  };
-  const closePortSafely = async (port) => {
-    if (!port) {
-      return;
-    }
-    try {
-      await port.close();
-    } catch {
-    }
-  };
-  const reportError = (error, severity, options2) => {
-    const serialError = normalizeSerialError(error, options2);
-    errorsSubject.next(serialError);
-    if (severity === "fatal") {
-      machine.toError();
-      sendQueue.clear();
-      const portToClose = activePort;
-      setActivePort(null);
-      void teardownPump().then(() => closePortSafely(portToClose));
-    }
-    return serialError;
-  };
-  const writeToPort = async (payload) => {
-    const port = activePort;
-    if (machine.current !== SerialSessionState.Connected || !port || !port.writable) {
-      throw new SerialError(
-        "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
-        "Cannot send data while session is not connected"
-      );
-    }
-    const writer = port.writable.getWriter();
-    try {
-      await writer.write(payload);
-    } finally {
-      try {
-        writer.releaseLock();
-      } catch {
-      }
-    }
-  };
-  return {
-    isBrowserSupported() {
-      return hasWebSerialSupport();
-    },
-    connect$() {
-      return new Observable3((subscriber) => {
-        if (!hasWebSerialSupport()) {
-          const error = reportError(
-            new SerialError(
-              "BROWSER_NOT_SUPPORTED" /* BROWSER_NOT_SUPPORTED */,
-              "Web Serial API is not supported in this environment"
-            ),
-            "non-fatal",
-            { fallbackCode: "BROWSER_NOT_SUPPORTED" /* BROWSER_NOT_SUPPORTED */ }
-          );
-          subscriber.error(error);
-          return;
-        }
-        const current = machine.current;
-        if (current !== SerialSessionState.Idle && current !== SerialSessionState.Error) {
-          const error = reportError(
-            new SerialError(
-              "PORT_ALREADY_OPEN" /* PORT_ALREADY_OPEN */,
-              `Cannot connect while session state is '${current}'`
-            ),
-            "non-fatal",
-            { fallbackCode: "PORT_ALREADY_OPEN" /* PORT_ALREADY_OPEN */ }
-          );
-          subscriber.error(error);
-          return;
-        }
-        let cancelled = false;
-        machine.toConnecting();
-        const run = async () => {
-          let selectedPort = null;
-          try {
-            selectedPort = await navigator.serial.requestPort(
-              buildRequestOptions(resolvedOptions)
-            );
-            await selectedPort.open({
-              baudRate: resolvedOptions.baudRate,
-              dataBits: resolvedOptions.dataBits,
-              stopBits: resolvedOptions.stopBits,
-              parity: resolvedOptions.parity,
-              bufferSize: resolvedOptions.bufferSize,
-              flowControl: resolvedOptions.flowControl
-            });
-          } catch (error) {
-            if (selectedPort) {
-              await closePortSafely(selectedPort);
-            }
-            const serialError = reportError(error, "fatal", {
-              fallbackCode: "PORT_OPEN_FAILED" /* PORT_OPEN_FAILED */,
-              messagePrefix: "Failed to open port"
-            });
-            if (!cancelled) {
-              subscriber.error(serialError);
-            }
-            return;
-          }
-          if (cancelled) {
-            await closePortSafely(selectedPort);
-            return;
-          }
-          setActivePort(selectedPort);
-          lineBuffer.clear();
-          if (resolvedOptions.receiveReplay.enabled) {
-            startLiveReceiveReplay();
-          }
-          activePump = createReadPump(selectedPort, {
-            onChunk: (text) => {
-              receiveSubject.next(text);
-              if (activeReceiveReplay) {
-                activeReceiveReplay.next(text);
-              }
-              for (const line of lineBuffer.feed(text)) {
-                linesSubject.next(line);
-              }
-            },
-            onError: (pumpError) => reportError(pumpError, "fatal", {
-              fallbackCode: "READ_FAILED" /* READ_FAILED */,
-              messagePrefix: "Read pump failed"
-            })
-          });
-          activePump.start();
-          sendQueue.clear();
-          machine.toConnected();
-          subscriber.next();
-          subscriber.complete();
-        };
-        void run();
-        return () => {
-          cancelled = true;
-        };
-      });
-    },
-    disconnect$() {
-      return new Observable3((subscriber) => {
-        const current = machine.current;
-        if (current === SerialSessionState.Idle || current === SerialSessionState.Unsupported) {
-          subscriber.next();
-          subscriber.complete();
-          return;
-        }
-        if (current !== SerialSessionState.Connected && current !== SerialSessionState.Error) {
-          const error = reportError(
-            new SerialError(
-              "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
-              `Cannot disconnect while session state is '${current}'`
-            ),
-            "non-fatal",
-            { fallbackCode: "PORT_NOT_OPEN" /* PORT_NOT_OPEN */ }
-          );
-          subscriber.error(error);
-          return;
-        }
-        machine.toDisconnecting();
-        sendQueue.clear();
-        const portToClose = activePort;
-        const run = async () => {
-          try {
-            await teardownPump();
-            if (portToClose) {
-              try {
-                await portToClose.close();
-              } catch (error) {
-                setActivePort(null);
-                const serialError = reportError(error, "fatal", {
-                  fallbackCode: "CONNECTION_LOST" /* CONNECTION_LOST */,
-                  messagePrefix: "Failed to close port"
-                });
-                subscriber.error(serialError);
-                return;
-              }
-            }
-            setActivePort(null);
-            machine.toIdle();
-            subscriber.next();
-            subscriber.complete();
-          } catch (error) {
-            const serialError = reportError(error, "fatal", {
-              fallbackCode: "UNKNOWN" /* UNKNOWN */,
-              messagePrefix: "Unexpected disconnect failure"
-            });
-            subscriber.error(serialError);
-          }
-        };
-        void run();
-      });
-    },
-    send$(data) {
-      return sendQueue.enqueue(async () => {
-        const payload = typeof data === "string" ? textEncoder.encode(data) : data;
-        try {
-          await writeToPort(payload);
-        } catch (error) {
-          throw reportError(error, "non-fatal", {
-            fallbackCode: "WRITE_FAILED" /* WRITE_FAILED */,
-            messagePrefix: "Failed to write data"
-          });
-        }
-      });
-    },
-    state$: machine.state$,
-    isConnected$,
-    portInfo$,
-    getPortInfo() {
-      return portInfoSubject.getValue();
-    },
-    getCurrentPort() {
-      return activePort;
-    },
-    errors$,
-    receive$,
-    terminalText$,
-    receiveReplay$,
-    lines$
-  };
-}
-export {
-  SerialError,
-  SerialErrorCode,
-  SerialSessionState,
-  createSerialSession,
-  createTerminalBuffer
-};