@gurezo/web-serial-rxjs 4.0.5 → 4.1.1

package/dist/index.mjs

@@ -182,7 +182,13 @@ var SerialErrorCode = {
 };
 
 // src/terminal/create-terminal-buffer.ts
-import { map, scan, shareReplay } from "rxjs";
+import {
+  ReplaySubject,
+  finalize,
+  map,
+  scan,
+  share
+} from "rxjs";
 
 // src/errors/serial-error-context.ts
 var CAUSE_CONTEXT_CODES = /* @__PURE__ */ new Set([
@@ -445,19 +451,46 @@ function createAnsiStripper() {
 }
 
 // src/terminal/create-terminal-buffer.ts
-function applyTerminalChunk(state, chunk) {
+var emptyTerminalState = {
+  completed: "",
+  currentLine: ""
+};
+function createTerminalParser(options = {}) {
+  const stripAnsi = options.stripAnsi ?? false;
   const tokenizer = createNewlineTokenizer("terminal");
-  tokenizer.restorePending(state.currentLine);
-  const events = tokenizer.feed(chunk);
-  let { completed } = state;
-  for (const event of events) {
-    if (event.type === "line") {
-      completed += event.content + "\n";
-    }
-  }
-  return {
+  let ansiStripper = stripAnsi ? createAnsiStripper() : null;
+  let completed = "";
+  const resetAnsiStripper = () => {
+    ansiStripper = stripAnsi ? createAnsiStripper() : null;
+  };
+  const getState = () => ({
     completed,
     currentLine: tokenizer.getPendingText()
+  });
+  const restoreState = (state) => {
+    completed = state.completed;
+    tokenizer.restorePending(state.currentLine);
+  };
+  const reset = () => {
+    completed = "";
+    tokenizer.clear();
+    resetAnsiStripper();
+  };
+  const feed = (chunk) => {
+    const normalized = ansiStripper !== null ? ansiStripper.feed(chunk) : chunk;
+    const events = tokenizer.feed(normalized);
+    for (const event of events) {
+      if (event.type === "line") {
+        completed += event.content + "\n";
+      }
+    }
+    return getState();
+  };
+  return {
+    feed,
+    reset,
+    getState,
+    restoreState
   };
 }
 function terminalDisplayText(state) {
@@ -479,15 +512,21 @@ function trimCompletedByMaxLines(completed, maxLines) {
   if (maxLines <= 0) {
     return completed;
   }
-  let trimmed = completed;
-  while (countCompletedLines(trimmed) > maxLines) {
-    const firstNewline = trimmed.indexOf("\n");
-    if (firstNewline < 0) {
-      break;
+  const lineCount = countCompletedLines(completed);
+  if (lineCount <= maxLines) {
+    return completed;
+  }
+  const linesToDrop = lineCount - maxLines;
+  let dropped = 0;
+  for (let i = 0; i < completed.length; i++) {
+    if (completed.charAt(i) === "\n") {
+      dropped++;
+      if (dropped === linesToDrop) {
+        return completed.slice(i + 1);
+      }
     }
-    trimmed = trimmed.slice(firstNewline + 1);
   }
-  return trimmed;
+  return completed;
 }
 function trimTerminalState(state, limits) {
   let { completed, currentLine } = state;
@@ -551,25 +590,28 @@ function resolveTerminalBufferOptions(options) {
     stripAnsi: merged.stripAnsi
   };
 }
-var initialTerminalState = {
-  completed: "",
-  currentLine: ""
-};
 function createTerminalBuffer(receive$, options) {
   const resolved = resolveTerminalBufferOptions(options);
   const limits = {
     maxLines: resolved.maxLines,
     maxChars: resolved.maxChars
   };
-  const ansiStripper = resolved.stripAnsi ? createAnsiStripper() : null;
+  const parser = createTerminalParser({ stripAnsi: resolved.stripAnsi });
   const text$ = receive$.pipe(
-    scan((state, chunk) => {
-      const normalized = ansiStripper !== null ? ansiStripper.feed(chunk) : chunk;
-      const next = applyTerminalChunk(state, normalized);
-      return trimTerminalState(next, limits);
-    }, initialTerminalState),
+    scan((_state, chunk) => {
+      parser.feed(chunk);
+      const trimmed = trimTerminalState(parser.getState(), limits);
+      parser.restoreState(trimmed);
+      return trimmed;
+    }, emptyTerminalState),
     map(terminalDisplayText),
-    shareReplay({ bufferSize: 1, refCount: true })
+    finalize(() => {
+      parser.reset();
+    }),
+    share({
+      connector: () => new ReplaySubject(1),
+      resetOnRefCountZero: true
+    })
   );
   return { text$ };
 }
@@ -579,9 +621,156 @@ function isWebSerialSupported() {
   return typeof navigator !== "undefined" && "serial" in navigator && navigator.serial !== void 0 && navigator.serial !== null;
 }
 
+// src/session/session-runtime.ts
+import { BehaviorSubject } from "rxjs";
+
+// src/session/serial-session-state.ts
+var SerialSessionStatus = {
+  Idle: "idle",
+  Connecting: "connecting",
+  Connected: "connected",
+  Disconnecting: "disconnecting",
+  Unsupported: "unsupported",
+  Error: "error",
+  Disposed: "disposed"
+};
+
+// src/session/session-runtime.ts
+var S = SerialSessionStatus;
+var ALLOWED_TRANSITIONS = {
+  [S.Idle]: [S.Connecting, S.Error, S.Disposed],
+  [S.Connecting]: [S.Connected, S.Error, S.Idle, S.Disposed],
+  [S.Connected]: [S.Disconnecting, S.Error, S.Disposed],
+  [S.Disconnecting]: [S.Idle, S.Error, S.Disposed],
+  [S.Error]: [S.Idle, S.Connecting, S.Disposed],
+  [S.Unsupported]: [S.Disposed],
+  [S.Disposed]: []
+};
+function runtimeToSessionStatus(runtime) {
+  return runtime.status;
+}
+function runtimeToPublicState(runtime) {
+  switch (runtime.status) {
+    case S.Idle:
+      return { status: S.Idle };
+    case S.Connecting:
+      return { status: S.Connecting };
+    case S.Connected:
+      return { status: S.Connected, portInfo: runtime.port.getInfo() };
+    case S.Disconnecting:
+      return { status: S.Disconnecting };
+    case S.Unsupported:
+      return { status: S.Unsupported };
+    case S.Error:
+      return { status: S.Error, error: runtime.error };
+    case S.Disposed:
+      return { status: S.Disposed };
+    default:
+      return assertNever(runtime);
+  }
+}
+function isValidTransition(from, to) {
+  if (from === to) {
+    return false;
+  }
+  return ALLOWED_TRANSITIONS[from].includes(
+    to
+  );
+}
+function createIdleRuntime() {
+  return { status: S.Idle };
+}
+function createConnectingRuntime(cancel) {
+  return { status: S.Connecting, cancel };
+}
+function createConnectedRuntime(port, pump) {
+  return { status: S.Connected, port, pump };
+}
+function createDisconnectingRuntime(port) {
+  return { status: S.Disconnecting, port };
+}
+function createErrorRuntime(error) {
+  return { status: S.Error, error };
+}
+function createUnsupportedRuntime() {
+  return { status: S.Unsupported };
+}
+function createDisposedRuntime() {
+  return { status: S.Disposed };
+}
+function createInitialRuntime(supported) {
+  return supported ? createIdleRuntime() : createUnsupportedRuntime();
+}
+function getRuntimePort(runtime) {
+  switch (runtime.status) {
+    case S.Connected:
+      return runtime.port;
+    case S.Disconnecting:
+      return runtime.port;
+    default:
+      return null;
+  }
+}
+function getRuntimePump(runtime) {
+  if (runtime.status === S.Connected) {
+    return runtime.pump;
+  }
+  return null;
+}
+function createSessionRuntimeController(initial) {
+  let runtime = initial;
+  const subject = new BehaviorSubject(
+    runtimeToPublicState(initial)
+  );
+  const transition = (next) => {
+    const from = runtimeToSessionStatus(runtime);
+    const to = runtimeToSessionStatus(next);
+    if (from === to) {
+      return false;
+    }
+    if (!isValidTransition(from, to)) {
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn(
+          `[web-serial-rxjs] Ignoring invalid SerialSession transition ${from} -> ${to}`
+        );
+      }
+      return false;
+    }
+    const publicState = runtimeToPublicState(next);
+    runtime = next;
+    subject.next(publicState);
+    return true;
+  };
+  return {
+    get runtime() {
+      return runtime;
+    },
+    get status() {
+      return runtimeToSessionStatus(runtime);
+    },
+    get state$() {
+      return subject.asObservable();
+    },
+    transition,
+    complete() {
+      subject.complete();
+    }
+  };
+}
+
 // src/session/internal/port-teardown.ts
+function captureResources(runtime) {
+  const resources = {
+    port: getRuntimePort(runtime),
+    pump: getRuntimePump(runtime)
+  };
+  if (runtime.status === SerialSessionStatus.Connecting) {
+    resources.cancelConnect = runtime.cancel;
+  }
+  return resources;
+}
 function createPortTeardown(deps) {
-  const { receivePipeline } = deps;
+  const { receivePipeline, sendQueue } = deps;
   const teardownPump = async (pump) => {
     receivePipeline.clearLineBuffer();
     if (pump) {
@@ -597,7 +786,36 @@ function createPortTeardown(deps) {
     } catch {
     }
   };
-  return { teardownPump, closePortSafely };
+  const teardownResources = async (resources, options = {}) => {
+    const closeMode = options.closeMode ?? "safe";
+    const cancelInFlightConnect = options.cancelInFlightConnect ?? true;
+    if (cancelInFlightConnect) {
+      resources.cancelConnect?.();
+    }
+    sendQueue.clear();
+    await teardownPump(resources.pump);
+    if (!resources.port) {
+      return;
+    }
+    if (closeMode === "safe") {
+      await closePortSafely(resources.port);
+      return;
+    }
+    try {
+      await resources.port.close();
+    } catch (error) {
+      if (options.onCloseError) {
+        options.onCloseError(error);
+      }
+      throw error;
+    }
+  };
+  return {
+    teardownPump,
+    closePortSafely,
+    captureResources,
+    teardownResources
+  };
 }
 
 // src/session/internal/receive-pipeline.ts
@@ -739,155 +957,14 @@ function normalizeSerialError(error, options) {
   );
 }
 
-// src/session/session-runtime.ts
-import { BehaviorSubject } from "rxjs";
-
-// src/session/serial-session-state.ts
-var SerialSessionStatus = {
-  Idle: "idle",
-  Connecting: "connecting",
-  Connected: "connected",
-  Disconnecting: "disconnecting",
-  Unsupported: "unsupported",
-  Error: "error",
-  Disposed: "disposed"
-};
-
-// src/session/session-runtime.ts
-var S = SerialSessionStatus;
-var ALLOWED_TRANSITIONS = {
-  [S.Idle]: [S.Connecting, S.Error, S.Disposed],
-  [S.Connecting]: [S.Connected, S.Error, S.Idle, S.Disposed],
-  [S.Connected]: [S.Disconnecting, S.Error, S.Disposed],
-  [S.Disconnecting]: [S.Idle, S.Error, S.Disposed],
-  [S.Error]: [S.Idle, S.Connecting, S.Disposed],
-  [S.Unsupported]: [S.Disposed],
-  [S.Disposed]: []
-};
-function runtimeToSessionStatus(runtime) {
-  return runtime.status;
-}
-function runtimeToPublicState(runtime) {
-  switch (runtime.status) {
-    case S.Idle:
-      return { status: S.Idle };
-    case S.Connecting:
-      return { status: S.Connecting };
-    case S.Connected:
-      return { status: S.Connected, portInfo: runtime.port.getInfo() };
-    case S.Disconnecting:
-      return { status: S.Disconnecting };
-    case S.Unsupported:
-      return { status: S.Unsupported };
-    case S.Error:
-      return { status: S.Error, error: runtime.error };
-    case S.Disposed:
-      return { status: S.Disposed };
-    default:
-      return assertNeverRuntime(runtime);
-  }
-}
-function isValidTransition(from, to) {
-  if (from === to) {
-    return false;
-  }
-  return ALLOWED_TRANSITIONS[from].includes(
-    to
-  );
-}
-function createIdleRuntime() {
-  return { status: S.Idle };
-}
-function createConnectingRuntime(cancel) {
-  return { status: S.Connecting, cancel };
-}
-function createConnectedRuntime(port, pump) {
-  return { status: S.Connected, port, pump };
-}
-function createDisconnectingRuntime(port) {
-  return { status: S.Disconnecting, port };
-}
-function createErrorRuntime(error) {
-  return { status: S.Error, error };
-}
-function createUnsupportedRuntime() {
-  return { status: S.Unsupported };
-}
-function createDisposedRuntime() {
-  return { status: S.Disposed };
-}
-function createInitialRuntime(supported) {
-  return supported ? createIdleRuntime() : createUnsupportedRuntime();
-}
-function getRuntimePort(runtime) {
-  switch (runtime.status) {
-    case S.Connected:
-      return runtime.port;
-    case S.Disconnecting:
-      return runtime.port;
-    default:
-      return null;
-  }
-}
-function getRuntimePump(runtime) {
-  if (runtime.status === S.Connected) {
-    return runtime.pump;
-  }
-  return null;
-}
-function createSessionRuntimeController(initial) {
-  let runtime = initial;
-  const subject = new BehaviorSubject(
-    runtimeToPublicState(initial)
-  );
-  const transition = (next) => {
-    const from = runtimeToSessionStatus(runtime);
-    const to = runtimeToSessionStatus(next);
-    if (from === to) {
-      return false;
-    }
-    if (!isValidTransition(from, to)) {
-      if (typeof console !== "undefined" && console.warn) {
-        console.warn(
-          `[web-serial-rxjs] Ignoring invalid SerialSession transition ${from} -> ${to}`
-        );
-      }
-      return false;
-    }
-    const publicState = runtimeToPublicState(next);
-    runtime = next;
-    subject.next(publicState);
-    return true;
-  };
-  return {
-    get runtime() {
-      return runtime;
-    },
-    get status() {
-      return runtimeToSessionStatus(runtime);
-    },
-    get state$() {
-      return subject.asObservable();
-    },
-    transition,
-    complete() {
-      subject.complete();
-    }
-  };
-}
-function assertNeverRuntime(value) {
-  return assertNever(value);
-}
-
 // src/session/internal/session-error-reporter.ts
 function createSessionErrorReporter(deps) {
   const {
     controller,
     errorsSubject,
-    sendQueue,
     isDisposed,
-    teardownPump,
-    closePortSafely
+    captureResources: captureResources2,
+    teardownResources
   } = deps;
   const createDisposedError = () => new SerialError(
     SerialErrorCode.SESSION_DISPOSED,
@@ -900,12 +977,12 @@ function createSessionErrorReporter(deps) {
     }
     errorsSubject.next(serialError);
     if (resolveErrorSeverity(serialError.code) === "fatal") {
-      const runtime = controller.runtime;
-      const portToClose = getRuntimePort(runtime);
-      const pump = getRuntimePump(runtime);
+      const resources = captureResources2(controller.runtime);
       controller.transition(createErrorRuntime(serialError));
-      sendQueue.clear();
-      void teardownPump(pump).then(() => closePortSafely(portToClose));
+      void teardownResources(resources, {
+        closeMode: "safe",
+        cancelInFlightConnect: false
+      });
     }
     return serialError;
   };
@@ -1030,22 +1107,11 @@ function createSessionLifecycle(deps) {
     isDisposed,
     teardownPump,
     closePortSafely,
+    captureResources: captureResources2,
+    teardownResources,
     reportError,
     createDisposedError
   } = deps;
-  const teardownFromSnapshot = async (snapshot) => {
-    if (snapshot.status === SerialSessionStatus.Connecting) {
-      snapshot.cancel();
-    }
-    sendQueue.clear();
-    if (snapshot.status === SerialSessionStatus.Connected || snapshot.status === SerialSessionStatus.Disconnecting || snapshot.status === SerialSessionStatus.Error) {
-      const portToClose = getRuntimePort(snapshot);
-      const pump = getRuntimePump(snapshot);
-      await teardownPump(pump);
-      await closePortSafely(portToClose);
-    }
-    receivePipeline.clearLineBuffer();
-  };
   const completeSubjects = () => {
     controller.complete();
     errorsSubject.complete();
@@ -1058,10 +1124,11 @@ function createSessionLifecycle(deps) {
       return;
     }
     const snapshot = controller.runtime;
+    const resources = captureResources2(snapshot);
     controller.transition(createDisposedRuntime());
     const run = async () => {
       try {
-        await teardownFromSnapshot(snapshot);
+        await teardownResources(resources, { closeMode: "safe" });
         completeSubjects();
         subscriber.next();
         subscriber.complete();
@@ -1227,31 +1294,29 @@ function createSessionLifecycle(deps) {
       subscriber.error(error);
       return;
     }
-    const portToClose = getRuntimePort(runtime);
-    controller.transition(createDisconnectingRuntime(portToClose));
-    sendQueue.clear();
+    const resources = captureResources2(runtime);
+    controller.transition(createDisconnectingRuntime(resources.port));
     const run = async () => {
       try {
-        const pump = getRuntimePump(controller.runtime);
-        await teardownPump(pump);
-        if (portToClose) {
-          try {
-            await portToClose.close();
-          } catch (error) {
-            const serialError = reportError(error, {
+        await teardownResources(resources, {
+          closeMode: "report",
+          onCloseError: (error) => {
+            throw reportError(error, {
               fallbackCode: SerialErrorCode.CONNECTION_LOST,
               messagePrefix: "Failed to close port"
             });
-            subscriber.error(serialError);
-            return;
           }
-        }
+        });
         if (!isDisposed()) {
           controller.transition(createIdleRuntime());
         }
         subscriber.next();
         subscriber.complete();
       } catch (error) {
+        if (error instanceof SerialError) {
+          subscriber.error(error);
+          return;
+        }
         const serialError = reportError(error, {
           fallbackCode: SerialErrorCode.UNKNOWN,
           messagePrefix: "Unexpected disconnect failure"
@@ -1443,16 +1508,21 @@ function createSerialSession(options) {
   const textEncoder = new TextEncoder();
   const isDisposed = () => controller.status === SerialSessionStatus.Disposed;
   const receivePipeline = createReceivePipeline({ resolvedOptions });
-  const { teardownPump, closePortSafely } = createPortTeardown({
-    receivePipeline
+  const {
+    teardownPump,
+    closePortSafely,
+    captureResources: captureResources2,
+    teardownResources
+  } = createPortTeardown({
+    receivePipeline,
+    sendQueue
   });
   const { reportError, createDisposedError } = createSessionErrorReporter({
     controller,
     errorsSubject,
-    sendQueue,
     isDisposed,
-    teardownPump,
-    closePortSafely
+    captureResources: captureResources2,
+    teardownResources
   });
   receivePipeline.bufferErrors$.subscribe(
     (error) => reportError(error, { fallbackCode: error.code })
@@ -1466,6 +1536,8 @@ function createSerialSession(options) {
     isDisposed,
     teardownPump,
     closePortSafely,
+    captureResources: captureResources2,
+    teardownResources,
     reportError,
     createDisposedError
   });