react-native-web-serial-api 0.0.1

package/src/index.ts

@@ -0,0 +1,23 @@
+// Platform-resolved Web Serial API instance.
+// On React Native (Android) this is the USB-serial-backed polyfill; on web it
+// is the browser's native navigator.serial. (See serial.android.ts / serial.web.ts)
+export {default as serial} from './serial';
+export type {
+  SerialInputSignals,
+  SerialOptions,
+  SerialOutputSignals,
+  SerialPortFilter,
+  SerialPortInfo,
+  SerialPortRequestOptions,
+} from './WebSerial';
+// W3C Web Serial API classes
+export {Serial, SerialPort} from './WebSerial';
+
+// Lower-level access to the raw USB-serial TurboModule (Android only).
+// (Imported + re-exported rather than `export * as` so older Babel presets
+// without @babel/plugin-transform-export-namespace-from can consume the source.)
+import * as UsbSerial from './UsbSerial';
+
+// Web Serial API event/exception primitives used by the polyfill
+export {Event, EventTarget} from './lib/event-target';
+export {UsbSerial};

package/src/lib/dom-exception.ts

@@ -0,0 +1,161 @@
+/**
+ * DOMException Polyfill
+ *
+ * Provides a spec-compliant DOMException implementation for environments
+ * where it is missing or incomplete (e.g. Node.js < 17, some older browsers).
+ *
+ * Spec: https://webidl.spec.whatwg.org/#idl-DOMException
+ */
+
+const DOM_EXCEPTION_CODES: Record<string, number> = {
+  IndexSizeError: 1,
+  HierarchyRequestError: 3,
+  WrongDocumentError: 4,
+  InvalidCharacterError: 5,
+  NoModificationAllowedError: 7,
+  NotFoundError: 8,
+  NotSupportedError: 9,
+  InUseAttributeError: 10,
+  InvalidStateError: 11,
+  SyntaxError: 12,
+  InvalidModificationError: 13,
+  NamespaceError: 14,
+  InvalidAccessError: 15,
+  TypeMismatchError: 17,
+  SecurityError: 18,
+  NetworkError: 19,
+  AbortError: 20,
+  URLMismatchError: 21,
+  QuotaExceededError: 22,
+  TimeoutError: 23,
+  InvalidNodeTypeError: 24,
+  DataCloneError: 25,
+};
+
+const DOM_EXCEPTION_NAMES: Record<number, string> = Object.fromEntries(
+  Object.entries(DOM_EXCEPTION_CODES).map(([name, code]) => [code, name])
+);
+
+export interface DOMExceptionConstructor {
+  new (message?: string, name?: string): DOMException;
+  readonly prototype: DOMException;
+
+  readonly INDEX_SIZE_ERR: 1;
+  readonly DOMSTRING_SIZE_ERR: 2;
+  readonly HIERARCHY_REQUEST_ERR: 3;
+  readonly WRONG_DOCUMENT_ERR: 4;
+  readonly INVALID_CHARACTER_ERR: 5;
+  readonly NO_DATA_ALLOWED_ERR: 6;
+  readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+  readonly NOT_FOUND_ERR: 8;
+  readonly NOT_SUPPORTED_ERR: 9;
+  readonly INUSE_ATTRIBUTE_ERR: 10;
+  readonly INVALID_STATE_ERR: 11;
+  readonly SYNTAX_ERR: 12;
+  readonly INVALID_MODIFICATION_ERR: 13;
+  readonly NAMESPACE_ERR: 14;
+  readonly INVALID_ACCESS_ERR: 15;
+  readonly VALIDATION_ERR: 16;
+  readonly TYPE_MISMATCH_ERR: 17;
+  readonly SECURITY_ERR: 18;
+  readonly NETWORK_ERR: 19;
+  readonly ABORT_ERR: 20;
+  readonly URL_MISMATCH_ERR: 21;
+  readonly QUOTA_EXCEEDED_ERR: 22;
+  readonly TIMEOUT_ERR: 23;
+  readonly INVALID_NODE_TYPE_ERR: 24;
+  readonly DATA_CLONE_ERR: 25;
+}
+
+// ---------------------------------------------------------------------------
+// Polyfill class
+// ---------------------------------------------------------------------------
+
+class DOMExceptionPolyfill extends Error {
+  // Instance numeric legacy code (0 when name has no legacy code)
+  readonly code: number;
+  // Error name (defaults to "Error" per spec)
+  readonly name: string;
+
+  // --- Static legacy-code constants ---
+  static readonly INDEX_SIZE_ERR             = 1  as const;
+  static readonly DOMSTRING_SIZE_ERR         = 2  as const;
+  static readonly HIERARCHY_REQUEST_ERR      = 3  as const;
+  static readonly WRONG_DOCUMENT_ERR         = 4  as const;
+  static readonly INVALID_CHARACTER_ERR      = 5  as const;
+  static readonly NO_DATA_ALLOWED_ERR        = 6  as const;
+  static readonly NO_MODIFICATION_ALLOWED_ERR = 7 as const;
+  static readonly NOT_FOUND_ERR              = 8  as const;
+  static readonly NOT_SUPPORTED_ERR          = 9  as const;
+  static readonly INUSE_ATTRIBUTE_ERR        = 10 as const;
+  static readonly INVALID_STATE_ERR          = 11 as const;
+  static readonly SYNTAX_ERR                 = 12 as const;
+  static readonly INVALID_MODIFICATION_ERR   = 13 as const;
+  static readonly NAMESPACE_ERR              = 14 as const;
+  static readonly INVALID_ACCESS_ERR         = 15 as const;
+  static readonly VALIDATION_ERR             = 16 as const;
+  static readonly TYPE_MISMATCH_ERR          = 17 as const;
+  static readonly SECURITY_ERR               = 18 as const;
+  static readonly NETWORK_ERR                = 19 as const;
+  static readonly ABORT_ERR                  = 20 as const;
+  static readonly URL_MISMATCH_ERR           = 21 as const;
+  static readonly QUOTA_EXCEEDED_ERR         = 22 as const;
+  static readonly TIMEOUT_ERR                = 23 as const;
+  static readonly INVALID_NODE_TYPE_ERR      = 24 as const;
+  static readonly DATA_CLONE_ERR             = 25 as const;
+
+  constructor(message = "", name = "Error") {
+    super(message);
+
+    // Restore the correct prototype chain when transpiled to ES5
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    this.name    = name;
+    this.message = message;
+    this.code    = DOM_EXCEPTION_CODES[name] ?? 0;
+
+    // Provide a useful stack trace in V8 / SpiderMonkey
+    if (typeof (Error as any).captureStackTrace === "function") {
+      (Error as any).captureStackTrace(this, new.target);
+    }
+  }
+
+  /** Mirror static constants on the prototype (spec §3.1.2) */
+  get INDEX_SIZE_ERR()              { return 1; }
+  get DOMSTRING_SIZE_ERR()          { return 2; }
+  get HIERARCHY_REQUEST_ERR()       { return 3; }
+  get WRONG_DOCUMENT_ERR()          { return 4; }
+  get INVALID_CHARACTER_ERR()       { return 5; }
+  get NO_DATA_ALLOWED_ERR()         { return 6; }
+  get NO_MODIFICATION_ALLOWED_ERR() { return 7; }
+  get NOT_FOUND_ERR()               { return 8; }
+  get NOT_SUPPORTED_ERR()           { return 9; }
+  get INUSE_ATTRIBUTE_ERR()         { return 10; }
+  get INVALID_STATE_ERR()           { return 11; }
+  get SYNTAX_ERR()                  { return 12; }
+  get INVALID_MODIFICATION_ERR()    { return 13; }
+  get NAMESPACE_ERR()               { return 14; }
+  get INVALID_ACCESS_ERR()          { return 15; }
+  get VALIDATION_ERR()              { return 16; }
+  get TYPE_MISMATCH_ERR()           { return 17; }
+  get SECURITY_ERR()                { return 18; }
+  get NETWORK_ERR()                 { return 19; }
+  get ABORT_ERR()                   { return 20; }
+  get URL_MISMATCH_ERR()            { return 21; }
+  get QUOTA_EXCEEDED_ERR()          { return 22; }
+  get TIMEOUT_ERR()                 { return 23; }
+  get INVALID_NODE_TYPE_ERR()       { return 24; }
+  get DATA_CLONE_ERR()              { return 25; }
+
+  /** Canonical string representation */
+  toString(): string {
+    return `${this.name}: ${this.message}`;
+  }
+}
+
+export const DOMExceptionImpl = (globalThis as any).DOMException
+    ? (globalThis as any).DOMException as DOMExceptionConstructor
+    : DOMExceptionPolyfill as DOMExceptionConstructor;
+
+export { DOM_EXCEPTION_CODES, DOM_EXCEPTION_NAMES };
+export { DOMExceptionImpl as DOMException };

package/src/lib/event-target.ts

@@ -0,0 +1,170 @@
+
+export interface EventInit {
+  bubbles?: boolean;
+  cancelable?: boolean;
+  composed?: boolean;
+}
+
+export class Event {
+  readonly type: string;
+  readonly bubbles: boolean;
+  readonly cancelable: boolean;
+  readonly composed: boolean;
+
+  target: EventTarget | null = null;
+  currentTarget: EventTarget | null = null;
+
+  defaultPrevented: boolean = false;
+  cancelBubble: boolean = false;
+  _stopImmediatePropagationFlag: boolean = false;
+
+  readonly timeStamp: number = Date.now();
+  readonly isTrusted: boolean = false;
+
+  static readonly NONE = 0;
+  static readonly CAPTURING_PHASE = 1;
+  static readonly AT_TARGET = 2;
+  static readonly BUBBLING_PHASE = 3;
+
+  readonly NONE = 0;
+  readonly CAPTURING_PHASE = 1;
+  readonly AT_TARGET = 2;
+  readonly BUBBLING_PHASE = 3;
+
+  eventPhase: number = Event.NONE;
+
+  constructor(type: string, options?: EventInit) {
+    this.type = type;
+    this.bubbles = options?.bubbles ?? false;
+    this.cancelable = options?.cancelable ?? false;
+    this.composed = options?.composed ?? false;
+  }
+
+  preventDefault(): void {
+    if (this.cancelable) {
+      this.defaultPrevented = true;
+    }
+  }
+
+  stopPropagation(): void {
+    this.cancelBubble = true;
+  }
+
+  stopImmediatePropagation(): void {
+    this.cancelBubble = true;
+    this._stopImmediatePropagationFlag = true;
+  }
+
+  composedPath(): EventTarget[] {
+    return this.currentTarget ? [this.currentTarget] : [];
+  }
+
+  initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void {
+    (this as Mutable<Event>).type = type;
+    (this as Mutable<Event>).bubbles = bubbles ?? false;
+    (this as Mutable<Event>).cancelable = cancelable ?? false;
+  }
+}
+
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+
+type EventListener = (event: Event) => void;
+
+interface EventListenerObject {
+  handleEvent(event: Event): void;
+}
+
+type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
+type ListenerOptions =
+  | { once?: boolean; capture?: boolean; passive?: boolean }
+  | boolean
+  | undefined;
+
+interface ListenerInfo {
+  target: EventTarget;
+  listener: EventListenerOrEventListenerObject;
+  options: ListenerOptions;
+}
+
+type SecretMap = Record<string, ListenerInfo[]>;
+
+const wm = new WeakMap<object, SecretMap>();
+
+function define<T extends object>(target: T, name: string, value: unknown): void {
+  Object.defineProperty(target, name, {
+    configurable: true,
+    writable: true,
+    value,
+  });
+}
+
+function dispatch(this: Event, info: ListenerInfo): boolean {
+  const options = info.options;
+  const once =
+    typeof options === "object" && options !== null ? options.once : false;
+
+  if (once) {
+    info.target.removeEventListener(this.type, info.listener);
+  }
+
+  if (typeof info.listener === "function") {
+    info.listener.call(info.target, this);
+  } else {
+    info.listener.handleEvent(this);
+  }
+
+  return this._stopImmediatePropagationFlag;
+}
+
+export class EventTarget {
+  constructor() {
+    wm.set(this, Object.create(null) as SecretMap);
+  }
+
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: ListenerOptions
+  ): void {
+    const secret = wm.get(this)!;
+    const listeners: ListenerInfo[] = secret[type] ?? (secret[type] = []);
+
+    for (let i = 0; i < listeners.length; i++) {
+      if (listeners[i].listener === listener) return;
+    }
+
+    listeners.push({ target: this, listener, options });
+  }
+
+  dispatchEvent(event: Event): boolean {
+    const secret = wm.get(this)!;
+    const listeners = secret[event.type];
+
+    if (listeners) {
+      define(event, "target", this);
+      define(event, "currentTarget", this);
+      listeners.slice(0).some(dispatch, event);
+      define(event, "target", null);
+      define(event, "currentTarget", null);
+    }
+
+    return true;
+  }
+
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    _options?: ListenerOptions
+  ): void {
+    const secret = wm.get(this)!;
+    const listeners: ListenerInfo[] = secret[type] ?? (secret[type] = []);
+
+    for (let i = 0; i < listeners.length; i++) {
+      if (listeners[i].listener === listener) {
+        listeners.splice(i, 1);
+        return;
+      }
+    }
+  }
+}

package/src/lib/promise.ts

@@ -0,0 +1,19 @@
+type DeferredPromise<T> = {
+  promise: Promise<T>;
+  resolve: (value?: T) => void;
+  reject: (reason?: any) => void;
+};
+
+/**
+ * @returns An object containing a promise and its resolve/reject methods.
+ */
+export function createDeferredPromise<T>(): DeferredPromise<T> {
+  let res: any;
+  let rej: any;
+  const promise = new Promise<T>((resolve, reject) => {
+    res = resolve
+    rej = reject
+  })
+
+  return { promise, resolve: res, reject: rej } as DeferredPromise<T>;
+}

package/src/serial.android.ts

@@ -0,0 +1 @@
+export {serial as default} from './WebSerial';

package/src/serial.ts

@@ -0,0 +1 @@
+export {serial as default} from './WebSerial';

package/src/serial.web.ts

@@ -0,0 +1,6 @@
+import type {Serial} from './WebSerial';
+
+// On web, delegate to the browser's native Web Serial API implementation.
+// (navigator.serial is not part of TypeScript's standard DOM lib types, so we
+// cast through our own structurally-compatible Serial type.)
+export default (navigator as unknown as {serial: Serial}).serial;

package/tsconfig.build.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig",
+  "compilerOptions": {
+    "noEmit": false
+  },
+  "exclude": ["example", "lib", "node_modules"]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "rootDir": ".",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react-jsx",
+    "lib": ["ESNext", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ESNext",
+    "noEmit": true
+  },
+  "include": ["src"],
+  "exclude": ["example", "lib", "node_modules"]
+}