@swifttui/web 0.0.14 → 0.0.16

package/src/WebHostApp.test.ts

@@ -1,222 +0,0 @@
-import { expect, test } from "bun:test";
-
-import { createWebHostApp, type WebHostAppOptions } from "./WebHostApp.ts";
-import type { WebSocketSceneSocket } from "./WebSocketSceneBridge.ts";
-import type {
-  ResolvedWebHostTerminalStyle,
-  WebHostTerminalStyle,
-} from "./WebHostTerminalStyle.ts";
-import type { WebHostSceneRuntimeOptions } from "./WebHostSceneRuntime.ts";
-
-class FakeRuntime {
-  readonly descriptorId: string;
-  mountCount = 0;
-  visible = false;
-  styleUpdates: Array<WebHostTerminalStyle | ResolvedWebHostTerminalStyle> = [];
-  disposed = false;
-
-  constructor(descriptorId: string) {
-    this.descriptorId = descriptorId;
-  }
-
-  async mount(): Promise<void> {
-    this.mountCount += 1;
-  }
-
-  setVisible(visible: boolean): void {
-    this.visible = visible;
-  }
-
-  setStyle(
-    style: WebHostTerminalStyle | ResolvedWebHostTerminalStyle
-  ): void {
-    this.styleUpdates.push(style);
-  }
-
-  resize(_columns: number, _rows: number): void {}
-
-  writeOutput(_text: string): void {}
-
-  sendInput(_chunk: Uint8Array): void {}
-
-  dispose(): void {
-    this.disposed = true;
-  }
-}
-
-test("app controller switches scenes and propagates active styles", async () => {
-  const runtimes = new Map<string, FakeRuntime>();
-  const seenRuntimeOptions = new Map<string, WebHostSceneRuntimeOptions>();
-  const mount = makeElement("div");
-  const options: WebHostAppOptions = {
-    mount: mount as unknown as HTMLElement,
-    manifest: {
-      defaultSceneId: "dashboard",
-      scenes: [
-        { id: "dashboard", title: "Dashboard", isDefault: true },
-        { id: "controls", title: "Controls", isDefault: false },
-      ],
-    },
-    style: {
-      theme: {
-        foreground: "#111111",
-        background: "#f0f0f0",
-        tint: "#0057b8",
-        separator: "#cccccc",
-        selection: "#ddeeff",
-        placeholder: "#666666",
-        link: "#0057b8",
-        fill: "#f7f7f7",
-        windowBackground: "#ffffff",
-        success: "#1a7f37",
-        warning: "#9a6700",
-        danger: "#cf222e",
-        info: "#0969da",
-        muted: "#57606a",
-      },
-    },
-    createElement: (tagName: string) => makeElement(tagName) as unknown as HTMLElement,
-    sceneRuntimeFactory: (runtimeOptions: WebHostSceneRuntimeOptions) => {
-      const runtime = new FakeRuntime(runtimeOptions.descriptor.id);
-      runtimes.set(runtimeOptions.descriptor.id, runtime);
-      seenRuntimeOptions.set(runtimeOptions.descriptor.id, runtimeOptions);
-      return runtime as unknown as never;
-    },
-  };
-
-  const controller = await createWebHostApp(options);
-  const dashboardRuntime = runtimes.get("dashboard");
-  const dashboardOptions = seenRuntimeOptions.get("dashboard");
-
-  expect(controller.selectedSceneId).toBe("dashboard");
-  expect(dashboardOptions?.style.theme?.background).toBe("#f0f0f0");
-  expect(dashboardRuntime?.visible).toBe(true);
-  expect(dashboardRuntime?.mountCount).toBe(1);
-
-  await controller.switchScene("controls");
-  const controlsRuntime = runtimes.get("controls");
-
-  expect(controller.selectedSceneId).toBe("controls");
-  expect(dashboardRuntime?.visible).toBe(false);
-  expect(controlsRuntime?.visible).toBe(true);
-  expect(controlsRuntime?.mountCount).toBe(1);
-
-  await controller.switchScene("dashboard");
-  expect(runtimes.get("dashboard")).toBe(dashboardRuntime);
-  expect(dashboardRuntime?.mountCount).toBe(1);
-
-  controller.setStyle({
-    cursorBlink: true,
-  });
-
-  expect(dashboardRuntime?.styleUpdates.at(-1)?.cursorBlink).toBe(true);
-  expect(controlsRuntime?.styleUpdates.at(-1)?.cursorBlink).toBe(true);
-
-  await controller.dispose();
-  expect(dashboardRuntime?.disposed).toBe(true);
-  expect(controlsRuntime?.disposed).toBe(true);
-});
-
-test("app controller uses the embedded WebSocket bridge when configured", async () => {
-  const socket = new FakeSocket();
-  let socketURL = "";
-  let runtimeOptions: WebHostSceneRuntimeOptions | undefined;
-  const mount = makeElement("div");
-
-  const controller = await createWebHostApp({
-    mount: mount as unknown as HTMLElement,
-    manifest: {
-      defaultSceneId: "main",
-      scenes: [{ id: "main", title: "Main", isDefault: true }],
-    },
-    embeddedHost: {
-      token: "test-token",
-      webSocketBaseURL: "http://127.0.0.1:9123/",
-      webSocketFactory: (url) => {
-        socketURL = String(url);
-        return socket;
-      },
-    },
-    createElement: (tagName: string) => makeElement(tagName) as unknown as HTMLElement,
-    sceneRuntimeFactory: (options: WebHostSceneRuntimeOptions) => {
-      runtimeOptions = options;
-      return new FakeRuntime(options.descriptor.id) as unknown as never;
-    },
-  });
-
-  expect(socketURL).toBe("ws://127.0.0.1:9123/ws/scene/main?token=test-token");
-
-  socket.open();
-  runtimeOptions?.onInput(new TextEncoder().encode("input-record"));
-  expect(new TextDecoder().decode(socket.sent[0])).toBe("input-record");
-
-  await controller.dispose();
-  expect(socket.closed).toBe(true);
-});
-
-function makeElement(
-  tagName: string
-): Record<string, unknown> {
-  return {
-    tagName,
-    className: "",
-    dataset: {},
-    hidden: false,
-    style: {},
-    replaceChildren: () => {},
-    appendChild: () => {},
-    remove: () => {},
-    hasAttribute: () => false,
-    setAttribute: () => {},
-  };
-}
-
-class FakeSocket implements WebSocketSceneSocket {
-  binaryType: BinaryType = "blob";
-  readyState = 0;
-  readonly sent: Uint8Array[] = [];
-  closed = false;
-
-  private readonly listeners = new Map<string, Set<(event: unknown) => void>>();
-
-  send(
-    data: string | ArrayBufferLike | Blob | ArrayBufferView
-  ): void {
-    if (typeof data === "string") {
-      this.sent.push(new TextEncoder().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));
-    }
-  }
-
-  close(): void {
-    this.closed = true;
-  }
-
-  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;
-    for (const listener of this.listeners.get("open") ?? []) {
-      listener({});
-    }
-  }
-}

package/src/WebHostApp.ts

@@ -1,269 +0,0 @@
-import { BrowserWASIBridge } from "./wasi/BrowserWASIBridge.ts";
-import {
-  WebSocketSceneBridge,
-  type WebSocketSceneBridgeOptions,
-} from "./WebSocketSceneBridge.ts";
-import {
-  loadWebHostSceneManifest,
-  normalizeWebHostSceneManifest,
-  type WebHostSceneDescriptor,
-  type WebHostSceneManifest,
-  type WebHostSceneManifestSource,
-} from "./WebHostSceneManifest.ts";
-import {
-  mergeWebHostTerminalStyle,
-  normalizeWebHostTerminalStyle,
-  type ResolvedWebHostTerminalStyle,
-  type WebHostTerminalStyle,
-} from "./WebHostTerminalStyle.ts";
-import {
-  WebHostSceneRuntime,
-  type WebHostSceneBridge,
-  type WebHostSceneRuntimeOptions,
-} from "./WebHostSceneRuntime.ts";
-
-export interface WebHostEmbeddedHostConfig {
-  token: string;
-  webSocketBaseURL?: string | URL;
-  webSocketFactory?: WebSocketSceneBridgeOptions["webSocketFactory"];
-}
-
-export interface WebHostBridgeFactoryOptions {
-  sceneId: string;
-  descriptor: WebHostSceneDescriptor;
-  style: WebHostTerminalStyle;
-  environment?: Record<string, string>;
-}
-
-export type WebHostBridgeFactory = (options: WebHostBridgeFactoryOptions) => WebHostSceneBridge;
-
-export interface WebHostAppOptions {
-  mount: HTMLElement;
-  manifest?: WebHostSceneManifestSource;
-  manifestUrl?: string | URL;
-  initialSceneId?: string;
-  style?: WebHostTerminalStyle;
-  environment?: Record<string, string>;
-  embeddedHost?: WebHostEmbeddedHostConfig;
-  bridgeFactory?: WebHostBridgeFactory;
-  createElement?: (tagName: string) => HTMLElement;
-  sceneRuntimeFactory?: (options: WebHostSceneRuntimeOptions) => WebHostSceneRuntime;
-}
-
-export interface WebHostAppController {
-  scenes: WebHostSceneDescriptor[];
-  selectedSceneId: string;
-  switchScene(id: string): Promise<void>;
-  setStyle(style: WebHostTerminalStyle): void;
-  dispose(): Promise<void>;
-}
-
-type RuntimeFactory = (options: WebHostSceneRuntimeOptions) => WebHostSceneRuntime;
-
-export async function createWebHostApp(
-  options: WebHostAppOptions
-): Promise<WebHostAppController> {
-  const manifest = await resolveManifest(options);
-  const controller = new InternalWebHostAppController({
-    mount: options.mount,
-    manifest,
-    style: options.style,
-    environment: options.environment,
-    embeddedHost: options.embeddedHost,
-    bridgeFactory: options.bridgeFactory,
-    initialSceneId: options.initialSceneId,
-    createElement: options.createElement,
-    sceneRuntimeFactory: options.sceneRuntimeFactory ?? ((runtimeOptions) => new WebHostSceneRuntime(runtimeOptions)),
-  });
-  await controller.initialize();
-  return controller;
-}
-
-class InternalWebHostAppController implements WebHostAppController {
-  readonly scenes: WebHostSceneDescriptor[];
-  selectedSceneId: string;
-
-  private readonly mount: HTMLElement;
-  private readonly sceneRoot: HTMLElement;
-  private style: ResolvedWebHostTerminalStyle;
-  private readonly environment?: Record<string, string>;
-  private readonly embeddedHost?: WebHostEmbeddedHostConfig;
-  private readonly bridgeFactory?: WebHostBridgeFactory;
-  private readonly sceneRuntimeFactory: RuntimeFactory;
-  private readonly runtimes = new Map<string, WebHostSceneRuntime>();
-  private readonly bridges = new Map<string, WebHostSceneBridge>();
-
-  constructor(options: {
-    mount: HTMLElement;
-    manifest: WebHostSceneManifest;
-    style?: WebHostTerminalStyle;
-    environment?: Record<string, string>;
-    embeddedHost?: WebHostEmbeddedHostConfig;
-    bridgeFactory?: WebHostBridgeFactory;
-    initialSceneId?: string;
-    createElement?: (tagName: string) => HTMLElement;
-    sceneRuntimeFactory: RuntimeFactory;
-  }) {
-    this.mount = options.mount;
-    this.style = normalizeWebHostTerminalStyle(options.style ?? {});
-    this.environment = options.environment;
-    this.embeddedHost = options.embeddedHost;
-    this.bridgeFactory = options.bridgeFactory;
-    this.sceneRuntimeFactory = options.sceneRuntimeFactory;
-    this.scenes = options.manifest.scenes;
-    this.selectedSceneId =
-      options.initialSceneId &&
-      options.manifest.scenes.some((scene) => scene.id === options.initialSceneId)
-        ? options.initialSceneId
-        : options.manifest.scenes.find((scene) => scene.id === options.manifest.defaultSceneId)?.id ??
-          options.manifest.defaultSceneId;
-
-    this.sceneRoot = (options.createElement ?? defaultCreateElement)("div");
-    this.sceneRoot.className = "webhost-scene-root";
-    this.mount.replaceChildren(this.sceneRoot);
-    this.applyHostFrameStyle();
-  }
-
-  async initialize(): Promise<void> {
-    await this.ensureRuntime(this.selectedSceneId);
-    await this.switchScene(this.selectedSceneId);
-  }
-
-  async switchScene(
-    id: string
-  ): Promise<void> {
-    const descriptor = this.scenes.find((scene) => scene.id === id);
-    if (!descriptor) {
-      throw new Error(`Unknown scene: ${id}`);
-    }
-
-    for (const [sceneId, runtime] of this.runtimes) {
-      runtime.setVisible(sceneId === id);
-    }
-
-    const runtime = await this.ensureRuntime(id);
-    runtime.setVisible(true);
-    this.selectedSceneId = id;
-  }
-
-  setStyle(
-    style: WebHostTerminalStyle
-  ): void {
-    const merged = mergeWebHostTerminalStyle(this.style, style);
-    this.style = merged;
-
-    for (const runtime of this.runtimes.values()) {
-      runtime.setStyle(this.style);
-    }
-    this.applyHostFrameStyle();
-  }
-
-  async dispose(): Promise<void> {
-    for (const runtime of this.runtimes.values()) {
-      runtime.dispose();
-    }
-    for (const bridge of this.bridges.values()) {
-      bridge.dispose();
-    }
-    this.runtimes.clear();
-    this.bridges.clear();
-    this.mount.replaceChildren();
-  }
-
-  private async ensureRuntime(
-    id: string
-  ): Promise<WebHostSceneRuntime> {
-    const existing = this.runtimes.get(id);
-    if (existing) {
-      return existing;
-    }
-
-    const descriptor = this.scenes.find((scene) => scene.id === id);
-    if (!descriptor) {
-      throw new Error(`Unknown scene: ${id}`);
-    }
-
-    const bridge = this.makeBridge(id, descriptor);
-    const runtime = this.sceneRuntimeFactory({
-      mount: this.sceneRoot,
-      descriptor,
-      style: this.style,
-      bridge,
-      onInput: (chunk) => bridge.sendInput(chunk),
-    });
-
-    this.bridges.set(id, bridge);
-    this.runtimes.set(id, runtime);
-    await runtime.mount();
-    runtime.setVisible(id === this.selectedSceneId);
-    return runtime;
-  }
-
-  private makeBridge(
-    sceneId: string,
-    descriptor: WebHostSceneDescriptor
-  ): WebHostSceneBridge {
-    if (this.bridgeFactory) {
-      return this.bridgeFactory({
-        sceneId,
-        descriptor,
-        style: this.style,
-        environment: this.environment,
-      });
-    }
-
-    if (this.embeddedHost) {
-      return new WebSocketSceneBridge({
-        sceneId,
-        token: this.embeddedHost.token,
-        baseURL: this.embeddedHost.webSocketBaseURL,
-        webSocketFactory: this.embeddedHost.webSocketFactory,
-      });
-    }
-
-    return new BrowserWASIBridge({
-      sceneId,
-      columns: 80,
-      rows: 24,
-      environment: this.environment,
-      renderStyle: this.style,
-    });
-  }
-
-  private applyHostFrameStyle(): void {
-    this.mount.style.background = "linear-gradient(180deg, #0f172a 0%, #111827 100%)";
-    this.mount.style.minHeight = "100%";
-    this.mount.style.display = "block";
-    this.mount.style.padding = "1rem";
-  }
-}
-
-function defaultCreateElement(
-  tagName: string
-): HTMLElement {
-  if (typeof document === "undefined") {
-    throw new Error("document is not available");
-  }
-
-  return document.createElement(tagName);
-}
-
-async function resolveManifest(
-  options: WebHostAppOptions
-): Promise<WebHostSceneManifest> {
-  if (options.manifest) {
-    return loadWebHostSceneManifest(options.manifest);
-  }
-
-  if (options.manifestUrl) {
-    return loadWebHostSceneManifest(options.manifestUrl);
-  }
-
-  return normalizeWebHostSceneManifest([
-    {
-      id: "main",
-      title: "Main",
-      isDefault: true,
-    },
-  ]);
-}

package/src/WebHostSceneManifest.test.ts

@@ -1,38 +0,0 @@
-import { expect, test } from "bun:test";
-
-import {
-  normalizeWebHostSceneManifest,
-  webTUISceneManifestToJSON,
-} from "./WebHostSceneManifest.ts";
-
-test("scene manifests preserve declaration order and default scene", () => {
-  const manifest = normalizeWebHostSceneManifest([
-    { id: "dashboard", title: "Dashboard", isDefault: true },
-    { id: "controls", title: "Controls", isDefault: false },
-  ]);
-
-  expect(manifest.defaultSceneId).toBe("dashboard");
-  expect(manifest.scenes.map((scene) => scene.id)).toEqual([
-    "dashboard",
-    "controls",
-  ]);
-  expect(webTUISceneManifestToJSON(manifest)).toBe(
-    JSON.stringify({
-      defaultSceneId: "dashboard",
-      scenes: [
-        { id: "dashboard", title: "Dashboard", isDefault: true },
-        { id: "controls", title: "Controls", isDefault: false },
-      ],
-    })
-  );
-});
-
-test("scene manifests infer a default scene when one is not marked", () => {
-  const manifest = normalizeWebHostSceneManifest([
-    { id: "primary", title: "Primary", isDefault: false },
-    { id: "secondary", title: "Secondary", isDefault: false },
-  ]);
-
-  expect(manifest.defaultSceneId).toBe("primary");
-  expect(manifest.scenes[0]?.isDefault).toBe(true);
-});

package/src/WebHostSceneManifest.ts

@@ -1,156 +0,0 @@
-export interface WebHostSceneDescriptor {
-  id: string;
-  title?: string;
-  isDefault: boolean;
-}
-
-export interface WebHostSceneManifest {
-  defaultSceneId: string;
-  scenes: WebHostSceneDescriptor[];
-}
-
-export type WebHostSceneManifestSource =
-  | WebHostSceneManifest
-  | WebHostSceneDescriptor[]
-  | string
-  | URL
-  | Request
-  | Response;
-
-export function normalizeWebHostSceneManifest(
-  source: unknown
-): WebHostSceneManifest {
-  const scenes = normalizeSceneDescriptors(source);
-  if (scenes.length === 0) {
-    throw new Error("scene manifest must contain at least one scene");
-  }
-
-  const defaultScene = scenes.find((scene) => scene.isDefault) ?? scenes[0];
-  return {
-    defaultSceneId: defaultScene.id,
-    scenes: scenes.map((scene, index) => ({
-      ...scene,
-      isDefault: scene.id === defaultScene.id || (index === 0 && !scenes.some((entry) => entry.isDefault)),
-    })),
-  };
-}
-
-export function webTUISceneManifestToJSON(
-  manifest: WebHostSceneManifest
-): string {
-  return JSON.stringify({
-    defaultSceneId: manifest.defaultSceneId,
-    scenes: manifest.scenes.map((scene) => ({
-      id: scene.id,
-      ...(scene.title ? { title: scene.title } : {}),
-      isDefault: scene.isDefault,
-    })),
-  });
-}
-
-export function webTUISceneManifestFromDescriptors(
-  descriptors: WebHostSceneDescriptor[]
-): WebHostSceneManifest {
-  return normalizeWebHostSceneManifest(descriptors);
-}
-
-export async function loadWebHostSceneManifest(
-  source: WebHostSceneManifestSource
-): Promise<WebHostSceneManifest> {
-  if (Array.isArray(source) || isSceneManifest(source)) {
-    return normalizeWebHostSceneManifest(source);
-  }
-
-  if (source instanceof URL) {
-    return loadWebHostSceneManifestFromResponse(await fetch(source));
-  }
-
-  if (source instanceof Request) {
-    return loadWebHostSceneManifestFromResponse(await fetch(source));
-  }
-
-  if (source instanceof Response) {
-    return loadWebHostSceneManifestFromResponse(source);
-  }
-
-  if (typeof source === "string") {
-    const trimmed = source.trim();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-      return normalizeWebHostSceneManifest(JSON.parse(trimmed));
-    }
-
-    return loadWebHostSceneManifest(new URL(source, import.meta.url));
-  }
-
-  return normalizeWebHostSceneManifest(source);
-}
-
-function normalizeSceneDescriptors(
-  source: unknown
-): WebHostSceneDescriptor[] {
-  if (Array.isArray(source)) {
-    return source.map(normalizeDescriptor);
-  }
-
-  if (isSceneManifest(source)) {
-    return source.scenes.map(normalizeDescriptor);
-  }
-
-  if (isObject(source) && Array.isArray((source as { scenes?: unknown }).scenes)) {
-    return ((source as { scenes: unknown[] }).scenes ?? []).map(normalizeDescriptor);
-  }
-
-  throw new Error("scene manifest must be an array or an object with scenes");
-}
-
-function normalizeDescriptor(
-  value: unknown,
-  index?: number
-): WebHostSceneDescriptor {
-  if (!isObject(value)) {
-    throw new Error(`scene descriptor at index ${index ?? 0} must be an object`);
-  }
-
-  const id = String((value as { id?: unknown }).id ?? "").trim();
-  if (!id) {
-    throw new Error(`scene descriptor at index ${index ?? 0} is missing an id`);
-  }
-
-  const titleValue = (value as { title?: unknown }).title;
-  const isDefaultValue = Boolean((value as { isDefault?: unknown }).isDefault);
-
-  return {
-    id,
-    title:
-      typeof titleValue === "string" && titleValue.trim().length > 0
-        ? titleValue.trim()
-        : undefined,
-    isDefault: isDefaultValue,
-  };
-}
-
-function isSceneManifest(
-  value: unknown
-): value is WebHostSceneManifest {
-  return (
-    isObject(value) &&
-    typeof (value as { defaultSceneId?: unknown }).defaultSceneId === "string" &&
-    Array.isArray((value as { scenes?: unknown }).scenes)
-  );
-}
-
-function isObject(
-  value: unknown
-): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-async function loadWebHostSceneManifestFromResponse(
-  response: Response
-): Promise<WebHostSceneManifest> {
-  if (!response.ok) {
-    throw new Error(`failed to load scene manifest: ${response.status} ${response.statusText}`);
-  }
-
-  return normalizeWebHostSceneManifest(await response.json());
-}