@swiftbrowser/web 0.1.0 → 0.2.0

package/src/webSocket.ts

@@ -0,0 +1,148 @@
+/**
+ * `URLSessionWebSocketTask` over the browser's WebSocket (docs/ops-protocol.md,
+ * "WebSockets"). Each call the task makes is a `websocket` request:
+ *
+ * - `open` connects; it answers `{ socket }` (the socket's id) once the socket
+ *   is open, and fails like a fetch (`network: …`) when it cannot connect;
+ * - `send` sends `string` (text) or `data` (base64 bytes) and answers `{}`;
+ * - `receive` answers the next message, `{ string }` or `{ data }`. Messages
+ *   that arrive with nobody receiving wait in a queue. Once the socket has
+ *   closed and the queue is empty, it answers `{ closeCode, reason }`;
+ * - `close` closes with `code` and `reason` and answers `{}`.
+ */
+
+import type { WebSocketRequestParams } from './protocol';
+
+/** The part of `WebSocket` the requests use; tests substitute a fake. */
+export interface WebSocketLike {
+  binaryType: string;
+  readonly readyState: number;
+  onopen: ((event: unknown) => void) | null;
+  onmessage: ((event: { data: unknown }) => void) | null;
+  onerror: ((event: unknown) => void) | null;
+  onclose: ((event: { code: number; reason: string }) => void) | null;
+  send(data: string | ArrayBufferLike | Uint8Array): void;
+  close(code?: number, reason?: string): void;
+}
+
+export type WebSocketFactory = (url: string, protocols: string[]) => WebSocketLike;
+
+export type WebSocketMessage = { string: string } | { data: string } | { closeCode: number; reason: string };
+
+interface OpenSocket {
+  socket: WebSocketLike;
+  queue: WebSocketMessage[];
+  waiting: ((message: WebSocketMessage) => void)[];
+  closed?: { closeCode: number; reason: string };
+}
+
+function base64(bytes: Uint8Array): string {
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+function bytes(base64Text: string): Uint8Array {
+  const binary = atob(base64Text);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i);
+  return out;
+}
+
+/** The sockets one page has open, by id. */
+export class WebSocketHost {
+  private nextID = 1;
+  private readonly sockets = new Map<number, OpenSocket>();
+
+  constructor(private readonly create: WebSocketFactory) {}
+
+  perform(params: WebSocketRequestParams): Promise<Record<string, unknown>> {
+    switch (params.action) {
+      case 'open':
+        return this.open(params.url ?? '', params.protocols ?? []);
+      case 'send':
+        return Promise.resolve(this.send(params));
+      case 'receive':
+        return this.receive(params.socket ?? 0);
+      case 'close':
+        return Promise.resolve(this.close(params));
+      default:
+        return Promise.reject(new Error(`unsupported: websocket action ${String((params as { action: unknown }).action)}`));
+    }
+  }
+
+  private open(url: string, protocols: string[]): Promise<Record<string, unknown>> {
+    return new Promise((resolve, reject) => {
+      let socket: WebSocketLike;
+      try {
+        socket = this.create(url, protocols);
+      } catch (error) {
+        reject(new Error(`network: ${error instanceof Error ? error.message : String(error)}`));
+        return;
+      }
+      socket.binaryType = 'arraybuffer';
+      const id = this.nextID;
+      this.nextID += 1;
+      const entry: OpenSocket = { socket, queue: [], waiting: [] };
+      let opened = false;
+      socket.onopen = () => {
+        opened = true;
+        this.sockets.set(id, entry);
+        resolve({ socket: id });
+      };
+      socket.onmessage = (event) => {
+        const data = event.data;
+        const message: WebSocketMessage = typeof data === 'string'
+          ? { string: data }
+          : { data: base64(new Uint8Array(data as ArrayBuffer)) };
+        this.deliver(entry, message);
+      };
+      socket.onerror = () => {
+        if (!opened) reject(new Error(`network: cannot connect to ${url}`));
+      };
+      socket.onclose = (event) => {
+        if (!opened) {
+          reject(new Error(`network: the connection to ${url} closed (${event.code})`));
+          return;
+        }
+        entry.closed = { closeCode: event.code, reason: event.reason };
+        for (const wake of entry.waiting.splice(0)) wake(entry.closed);
+      };
+    });
+  }
+
+  private deliver(entry: OpenSocket, message: WebSocketMessage): void {
+    const wake = entry.waiting.shift();
+    if (wake) wake(message);
+    else entry.queue.push(message);
+  }
+
+  private receive(id: number): Promise<Record<string, unknown>> {
+    const entry = this.sockets.get(id);
+    if (!entry) return Promise.reject(new Error(`network: no open socket ${id}`));
+    const queued = entry.queue.shift();
+    if (queued) return Promise.resolve(queued);
+    if (entry.closed) return Promise.resolve(entry.closed);
+    return new Promise((resolve) => entry.waiting.push(resolve));
+  }
+
+  private send(params: WebSocketRequestParams): Record<string, unknown> {
+    const entry = this.sockets.get(params.socket ?? 0);
+    if (!entry || entry.closed) throw new Error(`network: socket ${params.socket ?? 0} is not open`);
+    if (params.string !== undefined) entry.socket.send(params.string);
+    else entry.socket.send(bytes(params.data ?? ''));
+    return {};
+  }
+
+  private close(params: WebSocketRequestParams): Record<string, unknown> {
+    const entry = this.sockets.get(params.socket ?? 0);
+    if (!entry) return {};
+    // Browsers accept 1000 and 3000–4999 from a page; other codes close normally.
+    const code = params.code === 1000 || (params.code !== undefined && params.code >= 3000 && params.code <= 4999) ? params.code : 1000;
+    entry.socket.close(code, params.reason ?? '');
+    this.sockets.delete(params.socket ?? 0);
+    const closed = { closeCode: code, reason: params.reason ?? '' };
+    for (const wake of entry.waiting.splice(0)) wake(closed);
+    return {};
+  }
+}

package/src/zoneinfo.ts

@@ -0,0 +1,269 @@
+/**
+ * Time zone files for the app, made from the browser's own time zone data.
+ *
+ * Foundation's CoreFoundation layer (`ISO8601DateFormatter`, `DateFormatter`
+ * with a calendar, `NSCalendar`) reads a zone as a TZif file under
+ * `/usr/share/zoneinfo`, as on Linux, and traps when it is missing: with the
+ * viewer's time zone in `TZ` (anything but GMT), Ice Cubes and TelemetryDeck
+ * stopped in their first date formatting. The page has no zoneinfo files, but
+ * `Intl` knows every IANA zone, so the directory mounted there makes each
+ * file the first time the app opens it: the zone's UTC offsets from 1970 to
+ * 2037, their abbreviations and whether each is daylight time (TZif version 1;
+ * later dates keep the last offset). Formatting and calendars themselves run
+ * on ICU's own zone data; this file is what CoreFoundation needs to make the
+ * zone object they are given.
+ */
+
+import { Directory, File, type Inode } from '@bjorn3/browser_wasi_shim';
+
+/** The first and last instants covered, in seconds (TZif version 1 times are 32-bit). */
+const FIRST = Date.UTC(1970, 0, 1) / 1000;
+const LAST = 2_147_483_647;
+/** Offsets are sampled this often; changes in between are found by bisection. */
+const STEP = 14 * 86_400;
+
+/** Whether `zone` is a time zone the browser knows (IANA names and their aliases). */
+export function isTimeZone(zone: string): boolean {
+  if (!/^[A-Za-z0-9_+\-/]+$/.test(zone)) return false;
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: zone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The local time zone's name, as `Intl` reports it. */
+function localZone(): string | null {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** A function giving `zone`'s offset from UTC in seconds at an instant (seconds since 1970). */
+function offsetFunction(zone: string): (seconds: number) => number {
+  if (zone === localZone()) {
+    // The page's own zone: `Date` answers without `Intl`'s formatting.
+    return (seconds) => -new Date(seconds * 1000).getTimezoneOffset() * 60;
+  }
+  const format = new Intl.DateTimeFormat('en-US', {
+    timeZone: zone,
+    hourCycle: 'h23',
+    year: 'numeric',
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+  });
+  return (seconds) => {
+    const parts: Record<string, number> = {};
+    for (const part of format.formatToParts(new Date(seconds * 1000))) {
+      if (part.type !== 'literal') parts[part.type] = Number(part.value);
+    }
+    const wall = Date.UTC(parts['year']!, parts['month']! - 1, parts['day']!, parts['hour']! % 24, parts['minute']!, parts['second']!) / 1000;
+    return Math.round((wall - seconds) / 60) * 60;
+  };
+}
+
+/** `zone`'s abbreviation at an instant: `PDT`, or `+0530` where the browser has no letters for it. */
+function abbreviationFunction(zone: string): (seconds: number, offset: number) => string {
+  let format: Intl.DateTimeFormat | null = null;
+  try {
+    format = new Intl.DateTimeFormat('en-US', { timeZone: zone, timeZoneName: 'short' });
+  } catch {
+    format = null;
+  }
+  return (seconds, offset) => {
+    const name = format?.formatToParts(new Date(seconds * 1000)).find((part) => part.type === 'timeZoneName')?.value ?? '';
+    if (/^[A-Za-z]{3,6}$/.test(name)) return name;
+    if (offset === 0) return zone === 'UTC' || zone.endsWith('/UTC') ? 'UTC' : 'GMT';
+    const sign = offset < 0 ? '-' : '+';
+    const minutes = Math.abs(offset) / 60;
+    const hh = String(Math.floor(minutes / 60)).padStart(2, '0');
+    const mm = minutes % 60;
+    return mm === 0 ? `${sign}${hh}` : `${sign}${hh}${String(mm).padStart(2, '0')}`;
+  };
+}
+
+interface Transition {
+  at: number;
+  offset: number;
+}
+
+/** The instants from 1970 to 2037 at which `offset` changes, and the offset from each. */
+export function transitions(offset: (seconds: number) => number): { initial: number; changes: Transition[] } {
+  const initial = offset(FIRST);
+  const changes: Transition[] = [];
+  let before = initial;
+  let from = FIRST;
+  while (from < LAST) {
+    const to = Math.min(from + STEP, LAST);
+    const after = offset(to);
+    if (after !== before) {
+      // The first second at which the offset is no longer `before`.
+      let lo = from;
+      let hi = to;
+      while (hi - lo > 1) {
+        const mid = Math.floor((lo + hi) / 2);
+        if (offset(mid) === before) lo = mid;
+        else hi = mid;
+      }
+      changes.push({ at: hi, offset: offset(hi) });
+      before = offset(hi);
+      // A second change inside the same step is found from here.
+      from = hi;
+      continue;
+    }
+    from = to;
+  }
+  return { initial, changes };
+}
+
+/** The TZif (version 1) file for `zone`, or null when the browser does not know it. */
+export function tzif(zone: string): Uint8Array | null {
+  if (!isTimeZone(zone)) return null;
+  const offset = offsetFunction(zone);
+  const abbreviation = abbreviationFunction(zone);
+  const { initial, changes } = transitions(offset);
+
+  // Local time types: one per distinct (offset, abbreviation, daylight).
+  const types: { offset: number; dst: boolean; abbr: string }[] = [];
+  const typeIndex = new Map<string, number>();
+  const standardOffset = (seconds: number): number => {
+    const year = new Date(seconds * 1000).getUTCFullYear();
+    return Math.min(offset(Date.UTC(year, 0, 1) / 1000), offset(Date.UTC(year, 6, 1) / 1000));
+  };
+  const typeFor = (at: number, value: number): number => {
+    const abbr = abbreviation(at, value);
+    const dst = value > standardOffset(at);
+    const key = `${value}|${dst}|${abbr}`;
+    let index = typeIndex.get(key);
+    if (index === undefined) {
+      index = types.length;
+      types.push({ offset: value, dst, abbr });
+      typeIndex.set(key, index);
+    }
+    return index;
+  };
+  // Type 0 is the one in force before the first transition.
+  typeFor(FIRST, initial);
+  const changeTypes = changes.map((change) => typeFor(change.at, change.offset));
+
+  const chars: number[] = [];
+  const abbrIndex = new Map<string, number>();
+  for (const type of types) {
+    if (abbrIndex.has(type.abbr)) continue;
+    abbrIndex.set(type.abbr, chars.length);
+    for (const c of type.abbr) chars.push(c.charCodeAt(0) & 0x7f);
+    chars.push(0);
+  }
+
+  const size = 44 + changes.length * 5 + types.length * 6 + chars.length;
+  const out = new Uint8Array(size);
+  const view = new DataView(out.buffer);
+  out.set([0x54, 0x5a, 0x69, 0x66], 0); // "TZif", version 1 (byte 4 zero), 15 reserved bytes
+  // isutcnt, isstdcnt, leapcnt, timecnt, typecnt, charcnt
+  const counts = [0, 0, 0, changes.length, types.length, chars.length];
+  counts.forEach((count, i) => view.setUint32(20 + i * 4, count));
+  let at = 44;
+  for (const change of changes) {
+    view.setInt32(at, change.at);
+    at += 4;
+  }
+  for (const index of changeTypes) out[at++] = index;
+  for (const type of types) {
+    view.setInt32(at, type.offset);
+    out[at + 4] = type.dst ? 1 : 0;
+    out[at + 5] = abbrIndex.get(type.abbr)!;
+    at += 6;
+  }
+  out.set(chars, at);
+  return out;
+}
+
+/** Every zone name the browser lists, for listing the directory. */
+function listedZones(): string[] {
+  const supported = (Intl as { supportedValuesOf?: (key: string) => string[] }).supportedValuesOf;
+  const zones = supported ? supported('timeZone') : [];
+  return [...new Set([...zones, 'UTC', 'GMT', 'Etc/UTC', 'Etc/GMT'])];
+}
+
+/**
+ * The entries under `prefix` (`""` for the root, `America/` …), made when
+ * looked up: a zone becomes its file, a name that only leads to zones a
+ * directory. Listing the directory lists the zones the browser names.
+ */
+class ZoneEntries extends Map<string, Inode> {
+  private listed = false;
+
+  constructor(private readonly prefix: string) {
+    super();
+  }
+
+  override get(name: string): Inode | undefined {
+    if (!super.has(name)) this.make(name);
+    return super.get(name);
+  }
+
+  override has(name: string): boolean {
+    return this.get(name) !== undefined;
+  }
+
+  private make(name: string): void {
+    if (!/^[A-Za-z0-9_+-]+$/.test(name)) return;
+    const path = this.prefix + name;
+    const data = tzif(path);
+    if (data) {
+      super.set(name, new File(data, { readonly: true }));
+      return;
+    }
+    if (listedZones().some((zone) => zone.startsWith(`${path}/`))) {
+      super.set(name, new Directory(new ZoneEntries(`${path}/`)));
+    }
+  }
+
+  /** Every entry, made (only when the app lists the directory). */
+  private fill(): void {
+    if (this.listed) return;
+    this.listed = true;
+    for (const zone of listedZones()) {
+      if (!zone.startsWith(this.prefix)) continue;
+      this.get(zone.slice(this.prefix.length).split('/')[0]!);
+    }
+  }
+
+  override get size(): number {
+    this.fill();
+    return super.size;
+  }
+
+  override entries(): MapIterator<[string, Inode]> {
+    this.fill();
+    return super.entries();
+  }
+
+  override keys(): MapIterator<string> {
+    this.fill();
+    return super.keys();
+  }
+
+  // `values()` is not filled: the shim's `Directory` walks it when made, to
+  // link its subdirectories; listing (`entries`, `size`) fills.
+
+  override [Symbol.iterator](): MapIterator<[string, Inode]> {
+    return this.entries();
+  }
+
+  override forEach(callback: (value: Inode, key: string, map: Map<string, Inode>) => void, thisArg?: unknown): void {
+    this.fill();
+    super.forEach(callback, thisArg);
+  }
+}
+
+/** The contents of `/usr/share/zoneinfo`: every zone the browser knows, made when opened. */
+export function zoneInfoEntries(): Map<string, Inode> {
+  return new ZoneEntries('');
+}