@swifttui/web 0.0.14 → 0.0.16

package/src/wasi/BrowserWASIBridge.ts

@@ -1,167 +0,0 @@
-import { StdIOPipe } from "./StdIOPipe.ts";
-import {
-  encodeWebHostTerminalRenderStyleBase64,
-  type WebHostTerminalStyle,
-} from "../WebHostTerminalStyle.ts";
-import {
-  WebHostOutputDecoder,
-  encodeRenderStyleControlMessage,
-  encodeResizeControlMessage,
-  type WebHostOutputSink,
-} from "../WebHostSurfaceTransport.ts";
-
-export interface BrowserWASIBridgeOptions {
-  sceneId: string;
-  columns: number;
-  rows: number;
-  environment?: Record<string, string>;
-  renderStyle?: WebHostTerminalStyle;
-}
-
-export type BrowserWASIOutputSink = WebHostOutputSink;
-
-export class BrowserWASIBridge {
-  readonly stdin = new StdIOPipe();
-  readonly stdout = new StdIOPipe();
-  readonly stderr = new StdIOPipe();
-  readonly environment: Record<string, string>;
-
-  private detachStdout?: () => void;
-  private detachStderr?: () => void;
-  private readonly resizeListeners = new Set<(
-    columns: number,
-    rows: number,
-    cellWidth?: number,
-    cellHeight?: number
-  ) => void>();
-  private latestResize: {
-    columns: number;
-    rows: number;
-    cellWidth?: number;
-    cellHeight?: number;
-  };
-
-  constructor(options: BrowserWASIBridgeOptions) {
-    this.environment = {
-      TUIGUI_MODE: "browser",
-      TUIGUI_TRANSPORT: "surface",
-      TUIGUI_SURFACE_DELTA: "1",
-      TUIGUI_SCENE: options.sceneId,
-      TUIGUI_COLUMNS: String(Math.max(1, options.columns)),
-      TUIGUI_ROWS: String(Math.max(1, options.rows)),
-      ...options.environment,
-      ...(options.renderStyle
-        ? {
-            TUIGUI_RENDER_STYLE: encodeWebHostTerminalRenderStyleBase64(
-              options.renderStyle
-            ),
-          }
-        : {}),
-    };
-    this.latestResize = {
-      columns: Math.max(1, options.columns),
-      rows: Math.max(1, options.rows),
-    };
-  }
-
-  bindOutput(
-    sink: BrowserWASIOutputSink
-  ): void {
-    this.detachStdout?.();
-    this.detachStderr?.();
-    const decoder = new WebHostOutputDecoder();
-    this.detachStdout = this.stdout.subscribe((chunk) => {
-      for (const record of decoder.feed(chunk)) {
-        switch (record.type) {
-        case "surface":
-          sink.presentSurface(record.frame);
-          break;
-        case "clipboard":
-          void sink.writeClipboard?.(record.text);
-          break;
-        case "runtimeIssue":
-          sink.notifyRuntimeIssue?.(record.issue);
-          break;
-        case "frameDiagnostic":
-          sink.recordFrameDiagnostic?.(record.diagnostic);
-          break;
-        case "text":
-          sink.writeOutput?.(record.text);
-          break;
-        }
-      }
-    });
-    this.detachStderr = this.stderr.subscribe((chunk) => {
-      sink.writeError?.(new TextDecoder().decode(chunk));
-    });
-  }
-
-  resize(
-    columns: number,
-    rows: number,
-    cellWidth?: number,
-    cellHeight?: number
-  ): void {
-    const normalizedColumns = Math.max(1, columns);
-    const normalizedRows = Math.max(1, rows);
-    this.environment.TUIGUI_COLUMNS = String(normalizedColumns);
-    this.environment.TUIGUI_ROWS = String(normalizedRows);
-    this.latestResize = {
-      columns: normalizedColumns,
-      rows: normalizedRows,
-      cellWidth,
-      cellHeight,
-    };
-    this.stdin.write(encodeResizeControlMessage(columns, rows, cellWidth, cellHeight));
-    for (const listener of this.resizeListeners) {
-      listener(normalizedColumns, normalizedRows, cellWidth, cellHeight);
-    }
-  }
-
-  updateRenderStyle(
-    style: WebHostTerminalStyle
-  ): void {
-    this.environment.TUIGUI_RENDER_STYLE = encodeWebHostTerminalRenderStyleBase64(style);
-    this.stdin.write(encodeRenderStyleControlMessage(style));
-  }
-
-  sendInput(
-    chunk: Uint8Array
-  ): void {
-    this.stdin.write(chunk);
-  }
-
-  subscribeResize(
-    listener: (
-      columns: number,
-      rows: number,
-      cellWidth?: number,
-      cellHeight?: number
-    ) => void
-  ): () => void {
-    this.resizeListeners.add(listener);
-    listener(
-      this.latestResize.columns,
-      this.latestResize.rows,
-      this.latestResize.cellWidth,
-      this.latestResize.cellHeight
-    );
-    return () => {
-      this.resizeListeners.delete(listener);
-    };
-  }
-
-  dispose(): void {
-    this.detachStdout?.();
-    this.detachStderr?.();
-    this.resizeListeners.clear();
-    this.stdin.close();
-    this.stdout.close();
-    this.stderr.close();
-  }
-}
-
-export {
-  encodeRenderStyleControlMessage,
-  encodeResizeControlMessage,
-};

package/src/wasi/SharedInputQueue.test.ts

@@ -1,146 +0,0 @@
-import { expect, test } from "bun:test";
-import { Worker } from "node:worker_threads";
-
-import {
-  SharedInputQueueReader,
-  SharedInputQueueWriter,
-  type SharedInputQueueBuffers,
-  createSharedInputQueue,
-} from "./SharedInputQueue.ts";
-
-test("shared input queue preserves write order across partial reads", () => {
-  const queue = createSharedInputQueue(8);
-  const writer = new SharedInputQueueWriter(queue);
-  const reader = new SharedInputQueueReader(queue);
-
-  writer.write("abcdef");
-
-  expect(decode(reader.readAvailable(2))).toBe("ab");
-  expect(decode(reader.readAvailable(4))).toBe("cdef");
-  expect(reader.readAvailable(4)).toBeUndefined();
-});
-
-test("shared input queue wraps around the ring buffer", () => {
-  const queue = createSharedInputQueue(8);
-  const writer = new SharedInputQueueWriter(queue);
-  const reader = new SharedInputQueueReader(queue);
-
-  writer.write("abcdef");
-  expect(decode(reader.readAvailable(4))).toBe("abcd");
-
-  writer.write("gh");
-  expect(decode(reader.readAvailable(4))).toBe("efgh");
-  expect(reader.readAvailable(4)).toBeUndefined();
-});
-
-test("shared input queue reports EOF after close once buffered data is drained", () => {
-  const queue = createSharedInputQueue(8);
-  const writer = new SharedInputQueueWriter(queue);
-  const reader = new SharedInputQueueReader(queue);
-
-  writer.write("ok");
-  writer.close();
-
-  expect(decode(reader.readAvailable(8))).toBe("ok");
-  expect(reader.readAvailable(8)).toBeUndefined();
-  expect(reader.read(8)).toBeUndefined();
-});
-
-test("shared input queue reports readable bytes without consuming them", () => {
-  const queue = createSharedInputQueue(8);
-  const writer = new SharedInputQueueWriter(queue);
-  const reader = new SharedInputQueueReader(queue);
-
-  expect(reader.availableBytes()).toBe(0);
-
-  writer.write("abc");
-
-  expect(reader.availableBytes()).toBe(3);
-  expect(decode(reader.readAvailable(2))).toBe("ab");
-  expect(reader.availableBytes()).toBe(1);
-});
-
-test("shared input queue timed readiness wait wakes on write", async () => {
-  const queue = createSharedInputQueue(8);
-  const reader = new SharedInputQueueReader(queue);
-  const worker = writeInputFromWorker(queue, "x", 10);
-
-  try {
-    expect(reader.waitForReadable(250)).toBe("readable");
-    expect(decode(reader.readAvailable(1))).toBe("x");
-  } finally {
-    await worker.terminate();
-  }
-});
-
-test("shared input queue timed readiness wait returns timedOut", () => {
-  const queue = createSharedInputQueue(8);
-  const reader = new SharedInputQueueReader(queue);
-
-  expect(reader.waitForReadable(1)).toBe("timedOut");
-});
-
-test("shared input queue readiness wait wakes on close", async () => {
-  const queue = createSharedInputQueue(8);
-  const reader = new SharedInputQueueReader(queue);
-  const worker = closeInputFromWorker(queue, 10);
-
-  try {
-    expect(reader.waitForReadable(250)).toBe("closed");
-  } finally {
-    await worker.terminate();
-  }
-});
-
-function decode(
-  chunk: Uint8Array | undefined
-): string | undefined {
-  return chunk ? new TextDecoder().decode(chunk) : undefined;
-}
-
-function writeInputFromWorker(
-  queue: SharedInputQueueBuffers,
-  text: string,
-  delayMilliseconds: number
-): Worker {
-  return new Worker(`
-    const { workerData } = require("node:worker_threads");
-    const control = new Int32Array(workerData.controlBuffer);
-    const data = new Uint8Array(workerData.dataBuffer);
-    const bytes = new TextEncoder().encode(workerData.text);
-    setTimeout(() => {
-      const writeIndex = Atomics.load(control, 1);
-      data.set(bytes, writeIndex % data.length);
-      Atomics.store(control, 1, writeIndex + bytes.length);
-      Atomics.notify(control, 1);
-    }, workerData.delayMilliseconds);
-  `, {
-    eval: true,
-    workerData: {
-      controlBuffer: queue.controlBuffer,
-      dataBuffer: queue.dataBuffer,
-      delayMilliseconds,
-      text,
-    },
-  });
-}
-
-function closeInputFromWorker(
-  queue: SharedInputQueueBuffers,
-  delayMilliseconds: number
-): Worker {
-  return new Worker(`
-    const { workerData } = require("node:worker_threads");
-    const control = new Int32Array(workerData.controlBuffer);
-    setTimeout(() => {
-      Atomics.store(control, 2, 1);
-      Atomics.notify(control, 1);
-    }, workerData.delayMilliseconds);
-  `, {
-    eval: true,
-    workerData: {
-      controlBuffer: queue.controlBuffer,
-      delayMilliseconds,
-    },
-  });
-}

package/src/wasi/SharedInputQueue.ts

@@ -1,199 +0,0 @@
-const controlSlots = 3;
-
-const enum ControlSlot {
-  readIndex = 0,
-  writeIndex = 1,
-  closed = 2,
-}
-
-export const sharedInputQueueDefaultCapacity = 64 * 1024;
-
-export interface SharedInputQueueBuffers {
-  readonly controlBuffer: SharedArrayBuffer;
-  readonly dataBuffer: SharedArrayBuffer;
-}
-
-export type SharedInputReadiness = "readable" | "closed" | "timedOut";
-
-interface SharedInputQueueState {
-  readonly control: Int32Array;
-  readonly data: Uint8Array;
-}
-
-export function createSharedInputQueue(
-  capacity: number = sharedInputQueueDefaultCapacity
-): SharedInputQueueBuffers {
-  if (typeof SharedArrayBuffer === "undefined") {
-    throw new Error(
-      "SharedArrayBuffer is unavailable. Serve the app with COOP/COEP headers so browser WASI stdin can stay live."
-    );
-  }
-
-  if (!Number.isInteger(capacity) || capacity <= 0) {
-    throw new Error(`Shared input queue capacity must be a positive integer, received ${capacity}.`);
-  }
-
-  return {
-    controlBuffer: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * controlSlots),
-    dataBuffer: new SharedArrayBuffer(capacity),
-  };
-}
-
-export function hydrateSharedInputQueue(
-  buffers: SharedInputQueueBuffers
-): SharedInputQueueState {
-  return {
-    control: new Int32Array(buffers.controlBuffer),
-    data: new Uint8Array(buffers.dataBuffer),
-  };
-}
-
-export class SharedInputQueueWriter {
-  private readonly queue: SharedInputQueueState;
-
-  constructor(buffers: SharedInputQueueBuffers) {
-    this.queue = hydrateSharedInputQueue(buffers);
-  }
-
-  write(chunk: Uint8Array | string): void {
-    if (Atomics.load(this.queue.control, ControlSlot.closed) !== 0) {
-      return;
-    }
-
-    const bytes = normalizeChunk(chunk);
-    if (bytes.length == 0) {
-      return;
-    }
-
-    const readIndex = Atomics.load(this.queue.control, ControlSlot.readIndex);
-    const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);
-    const usedCapacity = writeIndex - readIndex;
-    const availableCapacity = this.queue.data.length - usedCapacity;
-
-    if (bytes.length > availableCapacity) {
-      throw new Error(
-        `Shared input queue overflow: cannot enqueue ${bytes.length} byte(s) into ${availableCapacity} byte(s) of free space.`
-      );
-    }
-
-    writeToRingBuffer(this.queue.data, bytes, writeIndex);
-    Atomics.store(this.queue.control, ControlSlot.writeIndex, writeIndex + bytes.length);
-    Atomics.notify(this.queue.control, ControlSlot.writeIndex);
-  }
-
-  close(): void {
-    Atomics.store(this.queue.control, ControlSlot.closed, 1);
-    Atomics.notify(this.queue.control, ControlSlot.writeIndex);
-  }
-}
-
-export class SharedInputQueueReader {
-  private readonly queue: SharedInputQueueState;
-
-  constructor(buffers: SharedInputQueueBuffers) {
-    this.queue = hydrateSharedInputQueue(buffers);
-  }
-
-  read(maxBytes: number): Uint8Array | undefined {
-    while (true) {
-      const next = this.readAvailable(maxBytes);
-      if (next) {
-        return next;
-      }
-
-      if (this.isClosed()) {
-        return undefined;
-      }
-
-      const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);
-      Atomics.wait(this.queue.control, ControlSlot.writeIndex, writeIndex);
-    }
-  }
-
-  readAvailable(maxBytes: number): Uint8Array | undefined {
-    if (!Number.isInteger(maxBytes) || maxBytes <= 0) {
-      return new Uint8Array();
-    }
-
-    const readIndex = Atomics.load(this.queue.control, ControlSlot.readIndex);
-    const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);
-    const availableBytes = writeIndex - readIndex;
-
-    if (availableBytes <= 0) {
-      return undefined;
-    }
-
-    const byteCount = Math.min(maxBytes, availableBytes);
-    const chunk = readFromRingBuffer(this.queue.data, readIndex, byteCount);
-    Atomics.store(this.queue.control, ControlSlot.readIndex, readIndex + byteCount);
-    return chunk;
-  }
-
-  availableBytes(): number {
-    const readIndex = Atomics.load(this.queue.control, ControlSlot.readIndex);
-    const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);
-    return Math.max(0, writeIndex - readIndex);
-  }
-
-  waitForReadable(
-    timeoutMilliseconds?: number
-  ): SharedInputReadiness {
-    while (true) {
-      if (this.availableBytes() > 0) {
-        return "readable";
-      }
-      if (this.isClosed()) {
-        return "closed";
-      }
-
-      const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);
-      const result = Atomics.wait(
-        this.queue.control,
-        ControlSlot.writeIndex,
-        writeIndex,
-        timeoutMilliseconds
-      );
-      if (result === "timed-out") {
-        return "timedOut";
-      }
-    }
-  }
-
-  isClosed(): boolean {
-    return Atomics.load(this.queue.control, ControlSlot.closed) !== 0;
-  }
-}
-
-function normalizeChunk(
-  chunk: Uint8Array | string
-): Uint8Array {
-  return typeof chunk == "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
-}
-
-function writeToRingBuffer(
-  buffer: Uint8Array,
-  chunk: Uint8Array,
-  startIndex: number
-): void {
-  const offset = startIndex % buffer.length;
-  const firstSegmentLength = Math.min(chunk.length, buffer.length - offset);
-  buffer.set(chunk.subarray(0, firstSegmentLength), offset);
-  if (firstSegmentLength < chunk.length) {
-    buffer.set(chunk.subarray(firstSegmentLength), 0);
-  }
-}
-
-function readFromRingBuffer(
-  buffer: Uint8Array,
-  startIndex: number,
-  byteCount: number
-): Uint8Array {
-  const chunk = new Uint8Array(byteCount);
-  const offset = startIndex % buffer.length;
-  const firstSegmentLength = Math.min(byteCount, buffer.length - offset);
-  chunk.set(buffer.subarray(offset, offset + firstSegmentLength), 0);
-  if (firstSegmentLength < byteCount) {
-    chunk.set(buffer.subarray(0, byteCount - firstSegmentLength), firstSegmentLength);
-  }
-  return chunk;
-}

package/src/wasi/StdIOPipe.ts

@@ -1,72 +0,0 @@
-export class StdIOPipe implements AsyncIterable<Uint8Array> {
-  private readonly chunks: Uint8Array[] = [];
-  private readonly waiters: Array<(value: IteratorResult<Uint8Array>) => void> = [];
-  private readonly listeners = new Set<(chunk: Uint8Array) => void>();
-  private closed = false;
-
-  write(chunk: Uint8Array | string): void {
-    if (this.closed) {
-      return;
-    }
-
-    const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter({ done: false, value: bytes });
-      return;
-    }
-
-    this.chunks.push(bytes);
-    for (const listener of this.listeners) {
-      listener(bytes);
-    }
-  }
-
-  close(): void {
-    if (this.closed) {
-      return;
-    }
-
-    this.closed = true;
-    while (this.waiters.length > 0) {
-      const waiter = this.waiters.shift();
-      waiter?.({ done: true, value: undefined as never });
-    }
-  }
-
-  async read(): Promise<Uint8Array | undefined> {
-    const next = this.chunks.shift();
-    if (next) {
-      return next;
-    }
-
-    if (this.closed) {
-      return undefined;
-    }
-
-    return await new Promise<Uint8Array | undefined>((resolve) => {
-      this.waiters.push((result) => {
-        resolve(result.done ? undefined : result.value);
-      });
-    });
-  }
-
-  subscribe(
-    listener: (chunk: Uint8Array) => void
-  ): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<Uint8Array> {
-    while (true) {
-      const next = await this.read();
-      if (!next) {
-        return;
-      }
-      yield next;
-    }
-  }
-}