@gurezo/web-serial-rxjs 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,595 @@
+// packages/web-serial-rxjs/src/client/serial-client.ts
+import { Observable as Observable2, defer, 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["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/browser/browser-detection.ts
+var BrowserType = /* @__PURE__ */ ((BrowserType2) => {
+  BrowserType2["CHROME"] = "chrome";
+  BrowserType2["EDGE"] = "edge";
+  BrowserType2["OPERA"] = "opera";
+  BrowserType2["UNKNOWN"] = "unknown";
+  return BrowserType2;
+})(BrowserType || {});
+function hasWebSerialSupport() {
+  return typeof navigator !== "undefined" && "serial" in navigator && navigator.serial !== void 0 && navigator.serial !== null;
+}
+function detectBrowserType() {
+  if (typeof navigator === "undefined" || !navigator.userAgent) {
+    return "unknown" /* UNKNOWN */;
+  }
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.includes("edg/")) {
+    return "edge" /* EDGE */;
+  }
+  if (ua.includes("opr/") || ua.includes("opera/")) {
+    return "opera" /* OPERA */;
+  }
+  if (ua.includes("chrome/")) {
+    return "chrome" /* CHROME */;
+  }
+  return "unknown" /* UNKNOWN */;
+}
+function isChromiumBased() {
+  const browserType = detectBrowserType();
+  return browserType === "chrome" /* CHROME */ || browserType === "edge" /* EDGE */ || browserType === "opera" /* OPERA */;
+}
+
+// packages/web-serial-rxjs/src/browser/browser-support.ts
+function checkBrowserSupport() {
+  if (!hasWebSerialSupport()) {
+    const browserType = detectBrowserType();
+    const browserName = browserType === "unknown" /* UNKNOWN */ ? "your browser" : browserType.toUpperCase();
+    throw new SerialError(
+      "BROWSER_NOT_SUPPORTED" /* BROWSER_NOT_SUPPORTED */,
+      `Web Serial API is not supported in ${browserName}. Please use a Chromium-based browser (Chrome, Edge, or Opera).`
+    );
+  }
+}
+function isBrowserSupported() {
+  return hasWebSerialSupport();
+}
+
+// packages/web-serial-rxjs/src/filters/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/io/observable-to-writable.ts
+function observableToWritable(observable) {
+  let writer = null;
+  let subscription = null;
+  let stream = null;
+  stream = new WritableStream({
+    async start() {
+      if (!stream) {
+        return;
+      }
+      writer = stream.getWriter();
+      subscription = observable.subscribe({
+        next: async (chunk) => {
+          if (writer) {
+            try {
+              await writer.write(chunk);
+            } catch (error) {
+              subscription?.unsubscribe();
+              if (writer) {
+                writer.releaseLock();
+              }
+              throw error;
+            }
+          }
+        },
+        error: async (error) => {
+          if (writer) {
+            try {
+              await writer.abort(error);
+            } catch {
+            } finally {
+              writer.releaseLock();
+              writer = null;
+            }
+          }
+        },
+        complete: async () => {
+          if (writer) {
+            try {
+              await writer.close();
+            } catch {
+            } finally {
+              writer.releaseLock();
+              writer = null;
+            }
+          }
+        }
+      });
+    },
+    abort(reason) {
+      if (subscription) {
+        subscription.unsubscribe();
+        subscription = null;
+      }
+      if (writer) {
+        writer.abort(reason).catch(() => {
+        });
+        writer.releaseLock();
+        writer = null;
+      }
+    }
+  });
+  return stream;
+}
+function subscribeToWritable(observable, stream) {
+  const writer = stream.getWriter();
+  const errorHandler = async (error) => {
+    try {
+      await writer.abort(error);
+    } catch {
+    } finally {
+      writer.releaseLock();
+    }
+  };
+  const subscription = observable.subscribe({
+    next: async (chunk) => {
+      try {
+        await writer.write(chunk);
+      } catch (error) {
+        subscription.unsubscribe();
+        writer.releaseLock();
+        const serialError = new SerialError(
+          "WRITE_FAILED" /* WRITE_FAILED */,
+          `Failed to write to stream: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        await errorHandler(serialError);
+      }
+    },
+    error: errorHandler,
+    complete: async () => {
+      try {
+        await writer.close();
+      } catch {
+      } finally {
+        writer.releaseLock();
+      }
+    }
+  });
+  return {
+    unsubscribe: () => {
+      subscription.unsubscribe();
+      writer.releaseLock();
+    }
+  };
+}
+
+// packages/web-serial-rxjs/src/io/readable-to-observable.ts
+import { Observable } from "rxjs";
+function readableToObservable(stream) {
+  return new Observable((subscriber) => {
+    const reader = stream.getReader();
+    const pump = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            subscriber.complete();
+            break;
+          }
+          if (value) {
+            subscriber.next(value);
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          subscriber.error(
+            new SerialError(
+              "READ_FAILED" /* READ_FAILED */,
+              `Failed to read from stream: ${error.message}`,
+              error
+            )
+          );
+        } else {
+          subscriber.error(
+            new SerialError(
+              "READ_FAILED" /* READ_FAILED */,
+              "Failed to read from stream: Unknown error",
+              error
+            )
+          );
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    };
+    pump().catch((error) => {
+      if (!subscriber.closed) {
+        subscriber.error(error);
+      }
+    });
+    return () => {
+      reader.releaseLock();
+    };
+  });
+}
+
+// packages/web-serial-rxjs/src/types/options.ts
+var DEFAULT_SERIAL_CLIENT_OPTIONS = {
+  baudRate: 9600,
+  dataBits: 8,
+  stopBits: 1,
+  parity: "none",
+  bufferSize: 255,
+  flowControl: "none",
+  filters: void 0
+};
+
+// packages/web-serial-rxjs/src/client/serial-client.ts
+var SerialClientImpl = class {
+  /**
+   * 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) {
+    /** @internal */
+    this.port = null;
+    /** @internal */
+    this.isOpen = false;
+    /** @internal */
+    this.readSubscription = null;
+    /** @internal */
+    this.writeSubscription = null;
+    checkBrowserSupport();
+    this.options = {
+      ...DEFAULT_SERIAL_CLIENT_OPTIONS,
+      ...options,
+      filters: options?.filters
+    };
+  }
+  /**
+   * Request a serial port from the user.
+   *
+   * @returns Observable that emits the selected SerialPort
+   * @internal
+   */
+  requestPort() {
+    return defer(() => {
+      checkBrowserSupport();
+      return navigator.serial.requestPort(buildRequestOptions(this.options)).catch((error) => {
+        if (error instanceof DOMException && error.name === "NotFoundError") {
+          throw new SerialError(
+            "OPERATION_CANCELLED" /* OPERATION_CANCELLED */,
+            "Port selection was cancelled by the user",
+            error
+          );
+        }
+        throw new SerialError(
+          "PORT_NOT_AVAILABLE" /* PORT_NOT_AVAILABLE */,
+          `Failed to request port: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      });
+    });
+  }
+  /**
+   * Get available serial ports.
+   *
+   * @returns Observable that emits an array of available SerialPorts
+   * @internal
+   */
+  getPorts() {
+    return defer(() => {
+      checkBrowserSupport();
+      return navigator.serial.getPorts().catch((error) => {
+        throw new SerialError(
+          "PORT_NOT_AVAILABLE" /* PORT_NOT_AVAILABLE */,
+          `Failed to get ports: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      });
+    });
+  }
+  /**
+   * 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) {
+    checkBrowserSupport();
+    if (this.isOpen) {
+      return new Observable2((subscriber) => {
+        subscriber.error(
+          new SerialError(
+            "PORT_ALREADY_OPEN" /* PORT_ALREADY_OPEN */,
+            "Port is already open"
+          )
+        );
+      });
+    }
+    const port$ = port ? new Observable2((subscriber) => {
+      subscriber.next(port);
+      subscriber.complete();
+    }) : this.requestPort();
+    return port$.pipe(
+      switchMap((selectedPort) => {
+        return defer(() => {
+          this.port = selectedPort;
+          return this.port.open({
+            baudRate: this.options.baudRate,
+            dataBits: this.options.dataBits,
+            stopBits: this.options.stopBits,
+            parity: this.options.parity,
+            bufferSize: this.options.bufferSize,
+            flowControl: this.options.flowControl
+          }).then(() => {
+            this.isOpen = true;
+          }).catch((error) => {
+            this.port = null;
+            this.isOpen = false;
+            if (error instanceof SerialError) {
+              throw error;
+            }
+            throw new SerialError(
+              "PORT_OPEN_FAILED" /* PORT_OPEN_FAILED */,
+              `Failed to open port: ${error instanceof Error ? error.message : String(error)}`,
+              error instanceof Error ? error : new Error(String(error))
+            );
+          });
+        });
+      })
+    );
+  }
+  /**
+   * Disconnect from the serial port.
+   *
+   * @returns Observable that completes when the port is closed
+   * @internal
+   */
+  disconnect() {
+    return defer(() => {
+      if (!this.isOpen || !this.port) {
+        return Promise.resolve();
+      }
+      if (this.readSubscription) {
+        this.readSubscription.unsubscribe();
+        this.readSubscription = null;
+      }
+      if (this.writeSubscription) {
+        this.writeSubscription.unsubscribe();
+        this.writeSubscription = null;
+      }
+      return this.port.close().then(() => {
+        this.port = null;
+        this.isOpen = false;
+      }).catch((error) => {
+        this.port = null;
+        this.isOpen = false;
+        throw new SerialError(
+          "CONNECTION_LOST" /* CONNECTION_LOST */,
+          `Failed to close port: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      });
+    });
+  }
+  /**
+   * Get an Observable that emits data read from the serial port.
+   *
+   * @returns Observable that emits Uint8Array chunks
+   * @internal
+   */
+  getReadStream() {
+    if (!this.isOpen || !this.port || !this.port.readable) {
+      throw new SerialError(
+        "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
+        "Port is not open or readable stream is not available"
+      );
+    }
+    return readableToObservable(this.port.readable);
+  }
+  /**
+   * 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$) {
+    if (!this.isOpen || !this.port || !this.port.writable) {
+      throw new SerialError(
+        "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
+        "Port is not open or writable stream is not available"
+      );
+    }
+    if (this.writeSubscription) {
+      this.writeSubscription.unsubscribe();
+    }
+    this.writeSubscription = subscribeToWritable(data$, this.port.writable);
+    return new Observable2((subscriber) => {
+      if (!this.writeSubscription) {
+        subscriber.error(
+          new SerialError(
+            "WRITE_FAILED" /* WRITE_FAILED */,
+            "Write subscription is not available"
+          )
+        );
+        return;
+      }
+      const originalUnsubscribe = this.writeSubscription.unsubscribe;
+      this.writeSubscription = {
+        unsubscribe: () => {
+          originalUnsubscribe();
+          subscriber.complete();
+        }
+      };
+      data$.subscribe({
+        complete: () => {
+          if (this.writeSubscription) {
+            this.writeSubscription.unsubscribe();
+            this.writeSubscription = null;
+          }
+          subscriber.complete();
+        },
+        error: (error) => {
+          if (this.writeSubscription) {
+            this.writeSubscription.unsubscribe();
+            this.writeSubscription = null;
+          }
+          subscriber.error(error);
+        }
+      });
+    });
+  }
+  /**
+   * 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) {
+    return defer(() => {
+      if (!this.isOpen || !this.port || !this.port.writable) {
+        throw new SerialError(
+          "PORT_NOT_OPEN" /* PORT_NOT_OPEN */,
+          "Port is not open or writable stream is not available"
+        );
+      }
+      const writer = this.port.writable.getWriter();
+      return writer.write(data).then(() => {
+        writer.releaseLock();
+      }).catch((error) => {
+        writer.releaseLock();
+        throw new SerialError(
+          "WRITE_FAILED" /* WRITE_FAILED */,
+          `Failed to write data: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      });
+    });
+  }
+  /**
+   * Check if the port is currently open.
+   *
+   * @returns `true` if a port is currently open, `false` otherwise
+   * @internal
+   */
+  get connected() {
+    return this.isOpen;
+  }
+  /**
+   * Get the current SerialPort instance.
+   *
+   * @returns The current SerialPort instance, or `null` if no port is open
+   * @internal
+   */
+  get currentPort() {
+    return this.port;
+  }
+};
+
+// packages/web-serial-rxjs/src/client/index.ts
+function createSerialClient(options) {
+  return new SerialClientImpl(options);
+}
+export {
+  BrowserType,
+  SerialError,
+  SerialErrorCode,
+  buildRequestOptions,
+  checkBrowserSupport,
+  createSerialClient,
+  detectBrowserType,
+  hasWebSerialSupport,
+  isBrowserSupported,
+  isChromiumBased,
+  observableToWritable,
+  readableToObservable,
+  subscribeToWritable
+};