@swifttui/web 0.0.13 → 0.0.15

package/src/WebSocketSceneBridge.test.ts

@@ -1,198 +0,0 @@
-import { expect, test } from "bun:test";
-
-import {
-  WebSocketSceneBridge,
-  webSocketSceneURL,
-  type WebSocketSceneSocket,
-} from "./WebSocketSceneBridge.ts";
-
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-class FakeWebSocket implements WebSocketSceneSocket {
-  binaryType: BinaryType = "blob";
-  readyState = 0;
-  readonly sent: Uint8Array[] = [];
-  closeCode?: number;
-  closeReason?: string;
-
-  private readonly listeners = new Map<string, Set<(event: unknown) => void>>();
-
-  send(
-    data: string | ArrayBufferLike | Blob | ArrayBufferView
-  ): void {
-    if (typeof data === "string") {
-      this.sent.push(encoder.encode(data));
-    } else if (data instanceof Uint8Array) {
-      this.sent.push(new Uint8Array(data));
-    } else if (data instanceof ArrayBuffer) {
-      this.sent.push(new Uint8Array(data));
-    } else if (ArrayBuffer.isView(data)) {
-      this.sent.push(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-    } else {
-      throw new Error("fake socket does not support Blob sends");
-    }
-  }
-
-  close(
-    code?: number,
-    reason?: string
-  ): void {
-    this.closeCode = code;
-    this.closeReason = reason;
-    this.readyState = 3;
-  }
-
-  addEventListener(
-    type: string,
-    listener: (event: unknown) => void
-  ): void {
-    const listeners = this.listeners.get(type) ?? new Set();
-    listeners.add(listener);
-    this.listeners.set(type, listeners);
-  }
-
-  removeEventListener(
-    type: string,
-    listener: (event: unknown) => void
-  ): void {
-    this.listeners.get(type)?.delete(listener);
-  }
-
-  open(): void {
-    this.readyState = 1;
-    this.emit("open", {});
-  }
-
-  message(
-    data: unknown
-  ): void {
-    this.emit("message", { data });
-  }
-
-  private emit(
-    type: string,
-    event: unknown
-  ): void {
-    for (const listener of this.listeners.get(type) ?? []) {
-      listener(event);
-    }
-  }
-}
-
-test("websocket scene URLs use the embedded host path and token", () => {
-  expect(String(webSocketSceneURL({
-    sceneId: "main",
-    token: "test-token",
-    baseURL: "http://127.0.0.1:9123/",
-  }))).toBe("ws://127.0.0.1:9123/ws/scene/main?token=test-token");
-
-  expect(String(webSocketSceneURL({
-    sceneId: "main",
-    token: "secure-token",
-    baseURL: "https://localhost:9443/app/",
-  }))).toBe("wss://localhost:9443/app/ws/scene/main?token=secure-token");
-});
-
-test("bridge decodes websocket output and sends queued input when the socket opens", async () => {
-  const socket = new FakeWebSocket();
-  const bridge = new WebSocketSceneBridge({
-    sceneId: "main",
-    token: "test-token",
-    baseURL: "http://127.0.0.1:9123/",
-    webSocketFactory: () => socket,
-  });
-  const frames: unknown[] = [];
-  const text: string[] = [];
-  const clipboard: string[] = [];
-  const runtimeIssues: unknown[] = [];
-  const frameDiagnostics: unknown[] = [];
-
-  bridge.bindOutput({
-    presentSurface: (frame) => frames.push(frame),
-    writeClipboard: (value) => clipboard.push(value),
-    notifyRuntimeIssue: (issue) => runtimeIssues.push(issue),
-    recordFrameDiagnostic: (diagnostic) => frameDiagnostics.push(diagnostic),
-    writeOutput: (chunk) => text.push(chunk),
-  });
-
-  bridge.resize(100, 32, 9, 18);
-  expect(socket.sent).toHaveLength(0);
-
-  socket.open();
-  expect(decoder.decode(socket.sent[0])).toBe("\u001Eresize:100:32:9:18\n");
-
-  socket.message(encoder.encode(
-    '\u001Esurface:{"version":2,"width":2,"height":1,"styles":[null],"rows":[[]],'
-      + '"accessibilityTree":[{"id":"root","rect":[0,0,2,1],"role":"group"}]}\n'
-      + '\u001Eclipboard:{"text":"copied text"}\n'
-      + '\u001EruntimeIssue:{"severity":"warning","code":"toolbar.unhostedItems",'
-      + '"message":"Toolbar item was not rendered",'
-      + '"description":"SwiftTUI runtime warning [toolbar.unhostedItems] Toolbar item was not rendered"}\n'
-      + '\u001EframeDiagnostic:{"format":"swift-tui-frame-diagnostics-v1",'
-      + '"header":["frame","total_ms"],"fields":["7","14.20"]}\n'
-      + "legacy output\n"
-  ));
-  await Promise.resolve();
-
-  expect(frames).toHaveLength(1);
-  expect(frames[0]).toMatchObject({
-    version: 2,
-    width: 2,
-    accessibilityTree: [{ id: "root", role: "group" }],
-  });
-  expect(clipboard).toEqual(["copied text"]);
-  expect(runtimeIssues).toEqual([
-    {
-      severity: "warning",
-      code: "toolbar.unhostedItems",
-      message: "Toolbar item was not rendered",
-      description: "SwiftTUI runtime warning [toolbar.unhostedItems] Toolbar item was not rendered",
-    },
-  ]);
-  expect(frameDiagnostics).toEqual([
-    {
-      format: "swift-tui-frame-diagnostics-v1",
-      header: ["frame", "total_ms"],
-      fields: ["7", "14.20"],
-    },
-  ]);
-  expect(text).toEqual(["legacy output\n"]);
-
-  bridge.sendInput(encoder.encode("\u001Ekey:return:0\n"));
-  expect(decoder.decode(socket.sent.at(-1))).toBe("\u001Ekey:return:0\n");
-
-  bridge.dispose();
-  expect(socket.closeCode).toBe(1000);
-  expect(socket.closeReason).toBe("WebHost scene disposed");
-});
-
-test("bridge buffers output until a runtime binds a sink", async () => {
-  const socket = new FakeWebSocket();
-  const bridge = new WebSocketSceneBridge({
-    sceneId: "main",
-    token: "test-token",
-    baseURL: "http://127.0.0.1:9123/",
-    webSocketFactory: () => socket,
-  });
-  const frames: unknown[] = [];
-
-  socket.message(encoder.encode(
-    '\u001Esurface:{"version":1,"width":3,"height":1,"styles":[null],"rows":[[]]}\n'
-  ));
-  await Promise.resolve();
-
-  bridge.bindOutput({
-    presentSurface: (frame) => frames.push(frame),
-  });
-
-  expect(frames).toEqual([
-    {
-      version: 1,
-      width: 3,
-      height: 1,
-      styles: [null],
-      rows: [[]],
-    },
-  ]);
-});

package/src/WebSocketSceneBridge.ts

@@ -1,233 +0,0 @@
-import {
-  WebHostOutputDecoder,
-  encodeRenderStyleControlMessage,
-  encodeResizeControlMessage,
-  type WebHostOutputRecord,
-  type WebHostOutputSink,
-} from "./WebHostSurfaceTransport.ts";
-import type { WebHostTerminalStyle } from "./WebHostTerminalStyle.ts";
-import type { WebHostSceneBridge } from "./WebHostSceneRuntime.ts";
-
-export interface WebSocketSceneBridgeOptions {
-  sceneId: string;
-  token: string;
-  baseURL?: string | URL;
-  webSocketURL?: string | URL;
-  webSocketFactory?: WebSocketSceneBridgeFactory;
-}
-
-export type WebSocketSceneBridgeFactory = (url: string | URL) => WebSocketSceneSocket;
-
-export interface WebSocketSceneSocket {
-  binaryType: BinaryType;
-  readonly readyState: number;
-  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-  close(code?: number, reason?: string): void;
-  addEventListener(type: "open", listener: (event: Event) => void): void;
-  addEventListener(type: "message", listener: (event: MessageEvent) => void): void;
-  addEventListener(type: "close", listener: (event: CloseEvent) => void): void;
-  addEventListener(type: "error", listener: (event: Event) => void): void;
-  removeEventListener(type: "open", listener: (event: Event) => void): void;
-  removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
-  removeEventListener(type: "close", listener: (event: CloseEvent) => void): void;
-  removeEventListener(type: "error", listener: (event: Event) => void): void;
-}
-
-const socketOpenState = 1;
-const textEncoder = new TextEncoder();
-
-export class WebSocketSceneBridge implements WebHostSceneBridge {
-  readonly url: URL;
-
-  private readonly socket: WebSocketSceneSocket;
-  private readonly decoder = new WebHostOutputDecoder();
-  private readonly queuedInput: Uint8Array[] = [];
-  private readonly queuedOutput: WebHostOutputRecord[] = [];
-  private sink?: WebHostOutputSink;
-  private disposed = false;
-
-  private readonly handleOpen = () => {
-    this.flushQueuedInput();
-  };
-
-  private readonly handleMessage = (event: MessageEvent) => {
-    void this.receive(event.data);
-  };
-
-  private readonly handleClose = () => {
-    for (const record of this.decoder.flush()) {
-      this.deliver(record);
-    }
-  };
-
-  private readonly handleError = () => {};
-
-  constructor(options: WebSocketSceneBridgeOptions) {
-    this.url = webSocketSceneURL(options);
-    this.socket = (options.webSocketFactory ?? defaultWebSocketFactory)(this.url);
-    this.socket.binaryType = "arraybuffer";
-    this.socket.addEventListener("open", this.handleOpen);
-    this.socket.addEventListener("message", this.handleMessage);
-    this.socket.addEventListener("close", this.handleClose);
-    this.socket.addEventListener("error", this.handleError);
-  }
-
-  bindOutput(
-    sink: WebHostOutputSink
-  ): void {
-    this.sink = sink;
-    while (this.queuedOutput.length > 0) {
-      this.deliver(this.queuedOutput.shift()!);
-    }
-  }
-
-  resize(
-    columns: number,
-    rows: number,
-    cellWidth?: number,
-    cellHeight?: number
-  ): void {
-    this.sendInput(encodeResizeControlMessage(columns, rows, cellWidth, cellHeight));
-  }
-
-  updateRenderStyle(
-    style: WebHostTerminalStyle
-  ): void {
-    this.sendInput(encodeRenderStyleControlMessage(style));
-  }
-
-  sendInput(
-    chunk: Uint8Array
-  ): void {
-    if (this.disposed) {
-      return;
-    }
-
-    const copy = new Uint8Array(chunk);
-    if (this.socket.readyState === socketOpenState) {
-      this.socket.send(copy);
-    } else {
-      this.queuedInput.push(copy);
-    }
-  }
-
-  dispose(): void {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    this.socket.removeEventListener("open", this.handleOpen);
-    this.socket.removeEventListener("message", this.handleMessage);
-    this.socket.removeEventListener("close", this.handleClose);
-    this.socket.removeEventListener("error", this.handleError);
-    this.queuedInput.length = 0;
-    this.queuedOutput.length = 0;
-    this.socket.close(1000, "WebHost scene disposed");
-  }
-
-  private async receive(
-    message: unknown
-  ): Promise<void> {
-    if (this.disposed) {
-      return;
-    }
-
-    const bytes = await bytesFromWebSocketMessage(message);
-    if (!bytes) {
-      return;
-    }
-
-    for (const record of this.decoder.feed(bytes)) {
-      this.deliver(record);
-    }
-  }
-
-  private deliver(
-    record: WebHostOutputRecord
-  ): void {
-    const sink = this.sink;
-    if (!sink) {
-      this.queuedOutput.push(record);
-      return;
-    }
-
-    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;
-    }
-  }
-
-  private flushQueuedInput(): void {
-    if (this.disposed || this.socket.readyState !== socketOpenState) {
-      return;
-    }
-    while (this.queuedInput.length > 0) {
-      this.socket.send(this.queuedInput.shift()!);
-    }
-  }
-}
-
-export function webSocketSceneURL(
-  options: Pick<WebSocketSceneBridgeOptions, "baseURL" | "webSocketURL" | "sceneId" | "token">
-): URL {
-  if (options.webSocketURL) {
-    const explicit = new URL(String(options.webSocketURL), currentPageURL());
-    explicit.searchParams.set("token", options.token);
-    return explicit;
-  }
-
-  const url = new URL(String(options.baseURL ?? currentPageURL()), currentPageURL());
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  const basePath = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-  url.pathname = `${basePath}/ws/scene/${encodeURIComponent(options.sceneId)}`;
-  url.search = "";
-  url.searchParams.set("token", options.token);
-  return url;
-}
-
-async function bytesFromWebSocketMessage(
-  message: unknown
-): Promise<Uint8Array | undefined> {
-  if (typeof message === "string") {
-    return textEncoder.encode(message);
-  }
-  if (message instanceof Uint8Array) {
-    return message;
-  }
-  if (message instanceof ArrayBuffer) {
-    return new Uint8Array(message);
-  }
-  if (ArrayBuffer.isView(message)) {
-    return new Uint8Array(message.buffer, message.byteOffset, message.byteLength);
-  }
-  if (typeof Blob !== "undefined" && message instanceof Blob) {
-    return new Uint8Array(await message.arrayBuffer());
-  }
-  return undefined;
-}
-
-function defaultWebSocketFactory(
-  url: string | URL
-): WebSocketSceneSocket {
-  if (typeof WebSocket === "undefined") {
-    throw new Error("WebSocket is not available");
-  }
-  return new WebSocket(url) as WebSocketSceneSocket;
-}
-
-function currentPageURL(): string {
-  return globalThis.location?.href ?? "http://127.0.0.1/";
-}

package/src/browser.ts

@@ -1,59 +0,0 @@
-import { createWebHostApp, type WebHostTerminalStyle } from "./WebHostApp.ts";
-
-declare global {
-  interface Window {
-    __WEBTUI__?: {
-      manifestUrl?: string;
-      initialSceneId?: string;
-      style?: WebHostTerminalStyle;
-      embeddedHost?: {
-        token?: string;
-        webSocketBaseURL?: string;
-      };
-    };
-    __WEBTUI_APP__?: Awaited<ReturnType<typeof createWebHostApp>>;
-  }
-}
-
-async function bootstrap(): Promise<void> {
-  const mount = document.getElementById("webhost-root");
-  if (!mount) {
-    throw new Error("webhost root element not found");
-  }
-
-  const config = window.__WEBTUI__ ?? {};
-  const pageURL = new URL(globalThis.location?.href ?? import.meta.url);
-  const embeddedToken = config.embeddedHost?.token ?? pageURL.searchParams.get("token") ?? undefined;
-  const manifestUrl = tokenizedURL(
-    config.manifestUrl ?? new URL("./scene-manifest.json", pageURL),
-    embeddedToken
-  );
-  const controller = await createWebHostApp({
-    mount,
-    manifestUrl,
-    initialSceneId: config.initialSceneId,
-    style: config.style,
-    embeddedHost: embeddedToken
-      ? {
-          token: embeddedToken,
-          webSocketBaseURL: config.embeddedHost?.webSocketBaseURL ?? new URL("./", pageURL).href,
-        }
-      : undefined,
-  });
-
-  window.__WEBTUI_APP__ = controller;
-}
-
-void bootstrap();
-
-function tokenizedURL(
-  value: string | URL,
-  token: string | undefined
-): string | URL {
-  if (!token) {
-    return value;
-  }
-  const url = new URL(String(value), globalThis.location?.href ?? import.meta.url);
-  url.searchParams.set("token", token);
-  return url;
-}

package/src/wasi/BrowserWASIBridge.test.ts

@@ -1,168 +0,0 @@
-import { expect, test } from "bun:test";
-
-import {
-  BrowserWASIBridge,
-  encodeRenderStyleControlMessage,
-  encodeResizeControlMessage,
-} from "./BrowserWASIBridge.ts";
-import {
-  decodeWebHostTerminalRenderStyleBase64,
-  encodeWebHostTerminalRenderStyleBase64,
-} from "../WebHostTerminalStyle.ts";
-
-test("bridge seeds initial render style and emits runtime style updates", async () => {
-  const style = {
-    theme: {
-      foreground: "#ededed",
-      background: "#111111",
-      tint: "#56b6c2",
-      separator: "#4c566a",
-      selection: "#2e3440",
-      placeholder: "#8c92ac",
-      link: "#5ba3ff",
-      fill: "#2b303b",
-      windowBackground: "#15181e",
-      success: "#61c67b",
-      warning: "#ebb33c",
-      danger: "#e05757",
-      info: "#56b6c2",
-      muted: "#8c92ac",
-    },
-  };
-
-  const bridge = new BrowserWASIBridge({
-    sceneId: "main",
-    columns: 80,
-    rows: 24,
-    renderStyle: style,
-  });
-
-  expect(
-    decodeWebHostTerminalRenderStyleBase64(bridge.environment.TUIGUI_RENDER_STYLE ?? "")
-      ?.appearance.backgroundColor
-  ).toBe("#111111");
-  expect(
-    bridge.environment.TUIGUI_RENDER_STYLE
-  ).toBe(encodeWebHostTerminalRenderStyleBase64(style));
-  expect(bridge.environment.TUIGUI_TRANSPORT).toBe("surface");
-  expect(bridge.environment.TUIGUI_SURFACE_DELTA).toBe("1");
-
-  bridge.updateRenderStyle(style);
-  const input = await bridge.stdin.read();
-  expect(Array.from(input ?? [])).toEqual(
-    Array.from(encodeRenderStyleControlMessage(style))
-  );
-});
-
-test("bridge allows callers to disable surface delta support", () => {
-  const bridge = new BrowserWASIBridge({
-    sceneId: "main",
-    columns: 80,
-    rows: 24,
-    environment: {
-      TUIGUI_SURFACE_DELTA: "0",
-    },
-  });
-
-  expect(bridge.environment.TUIGUI_SURFACE_DELTA).toBe("0");
-});
-
-test("bridge resize updates environment, emits control input, and notifies listeners", async () => {
-  const bridge = new BrowserWASIBridge({
-    sceneId: "main",
-    columns: 80,
-    rows: 24,
-  });
-  const seen: Array<[number, number, number | undefined, number | undefined]> = [];
-  const unsubscribe = bridge.subscribeResize((columns, rows, cellWidth, cellHeight) => {
-    seen.push([columns, rows, cellWidth, cellHeight]);
-  });
-
-  expect(seen).toEqual([[80, 24, undefined, undefined]]);
-
-  bridge.resize(132, 41, 9, 18);
-
-  expect(bridge.environment.TUIGUI_COLUMNS).toBe("132");
-  expect(bridge.environment.TUIGUI_ROWS).toBe("41");
-  expect(seen).toEqual([
-    [80, 24, undefined, undefined],
-    [132, 41, 9, 18],
-  ]);
-
-  const input = await bridge.stdin.read();
-  expect(Array.from(input ?? [])).toEqual(Array.from(encodeResizeControlMessage(132, 41, 9, 18)));
-
-  unsubscribe();
-  bridge.resize(90, 30);
-  expect(seen).toEqual([
-    [80, 24, undefined, undefined],
-    [132, 41, 9, 18],
-  ]);
-
-  const replayed: Array<[number, number, number | undefined, number | undefined]> = [];
-  bridge.subscribeResize((columns, rows, cellWidth, cellHeight) => {
-    replayed.push([columns, rows, cellWidth, cellHeight]);
-  })();
-  expect(replayed).toEqual([[90, 30, undefined, undefined]]);
-});
-
-test("bridge delivers typed clipboard output to sinks", () => {
-  const bridge = new BrowserWASIBridge({
-    sceneId: "main",
-    columns: 80,
-    rows: 24,
-  });
-  const clipboard: string[] = [];
-
-  bridge.bindOutput({
-    presentSurface: () => {},
-    writeClipboard: (text) => clipboard.push(text),
-  });
-
-  bridge.stdout.write(new TextEncoder().encode('\u001Eclipboard:{"text":"copied text"}\n'));
-
-  expect(clipboard).toEqual(["copied text"]);
-});
-
-test("bridge delivers typed runtime issues and frame diagnostics to sinks", () => {
-  const bridge = new BrowserWASIBridge({
-    sceneId: "main",
-    columns: 80,
-    rows: 24,
-  });
-  const runtimeIssues: unknown[] = [];
-  const frameDiagnostics: unknown[] = [];
-  const text: string[] = [];
-
-  bridge.bindOutput({
-    presentSurface: () => {},
-    notifyRuntimeIssue: (issue) => runtimeIssues.push(issue),
-    recordFrameDiagnostic: (diagnostic) => frameDiagnostics.push(diagnostic),
-    writeOutput: (chunk) => text.push(chunk),
-  });
-
-  bridge.stdout.write(new TextEncoder().encode(
-    '\u001EruntimeIssue:{"severity":"warning","code":"toolbar.unhostedItems",'
-      + '"message":"Toolbar item was not rendered",'
-      + '"description":"SwiftTUI runtime warning [toolbar.unhostedItems] Toolbar item was not rendered"}\n'
-      + '\u001EframeDiagnostic:{"format":"swift-tui-frame-diagnostics-v1",'
-      + '"header":["frame","total_ms"],"fields":["7","14.20"]}\n'
-  ));
-
-  expect(runtimeIssues).toEqual([
-    {
-      severity: "warning",
-      code: "toolbar.unhostedItems",
-      message: "Toolbar item was not rendered",
-      description: "SwiftTUI runtime warning [toolbar.unhostedItems] Toolbar item was not rendered",
-    },
-  ]);
-  expect(frameDiagnostics).toEqual([
-    {
-      format: "swift-tui-frame-diagnostics-v1",
-      header: ["frame", "total_ms"],
-      fields: ["7", "14.20"],
-    },
-  ]);
-  expect(text).toEqual([]);
-});