zidane-ui 9.1.1 → 9.1.4

package/src/app/headless/app-host.ts

@@ -1,61 +0,0 @@
-/**
- * The host of a whole app built on the kit: one optional host per area. An app
- * builds it once (over IPC, over zidane-server, in memory) and hands it to
- * `AppHostProvider`, which provides each area's host to its components.
- *
- * Each new area adds its host here, optional like the others (approvals,
- * workspace, files…): an app that leaves an area's host out doesn't show that
- * area.
- */
-import type { AppearanceHost } from '../../appearance/headless/host';
-import type { ApprovalsHost } from '../../approvals/headless/host';
-import type { ComposerHost } from '../../chat/headless/composer/host';
-import type { ExtensionsHost } from '../../extensions/headless/host';
-import type { ChatHost } from '../../chat/headless/host';
-import type { SidebarHost } from '../../chat/headless/sidebar/host';
-import type { FilesHost } from '../../files/headless/host';
-import type { GitHost } from '../../git/headless/host';
-import type { KeybindingsHost } from '../../keybindings/headless/host';
-import type { MachinesHost } from '../../machines/headless/host';
-import type { OnboardingHost } from '../../onboarding/headless/host';
-import type { PaletteHost } from '../../palette/headless/host';
-import type { SessionHost } from '../../session/headless/host';
-import type { SettingsHost } from '../../settings/headless/host';
-import type { TerminalHost } from '../../terminal/headless/host';
-import type { WorkspaceHost } from '../../workspace/headless/host';
-
-/** Every area's host an app offers. An area whose host is absent is not shown. */
-export interface AppHost {
-  /** Where the appearance preferences live, the extra themes, the pre-paint snapshot and the window effects. Absent: the app applies no appearance (the stylesheet's defaults). */
-  appearance?: AppearanceHost;
-  /** Tool approvals (safe mode): the pending approvals, the decisions and the safelist. Absent: no approval UI. */
-  approvals?: ApprovalsHost;
-  /** The chat area: sessions, transcripts, sending and interactions. Absent: no chat. */
-  chat?: ChatHost;
-  /** The rich composer's host: shared drafts, completions, ghost text and next-prompt suggestions. Absent: those stay off (`zidane-ui/chat/rich-composer`). */
-  composer?: ComposerHost;
-  /** What the extensions behind the app contribute (slots, screens, renderers, dialogs, settings pages, webviews) and the way back to them. Absent: no extension UI. */
-  extensions?: ExtensionsHost;
-  /** The Files and Diffs tabs' host: listing, reading, writing and searching files, git status, the working-tree diff and the editor preferences. Absent: no Files or Diffs tab. */
-  files?: FilesHost;
-  /** The git area's host: branches and pull requests, worktrees, environment kinds and remote folders. Absent: no branch menu, no remote folder picker. */
-  git?: GitHost;
-  /** Where the user's keybinding overrides live. Absent: the default bindings. */
-  keybindings?: KeybindingsHost;
-  /** Which agent hosts the app talks to and how they are: servers, machines, self-update, tokens, the local daemon. Absent: no host status, banners or server settings. */
-  machines?: MachinesHost;
-  /** The setup wizard's host: detection, settings, sign-in and the commit. Absent: no onboarding. */
-  onboarding?: OnboardingHost;
-  /** The command palette's host: commands, files, extension items, settings and recents. Absent: the palette lists only the app's own sources. */
-  palette?: PaletteHost;
-  /** The session panels' host: todos, the message queue and artifacts. Absent: no session panels. */
-  session?: SessionHost;
-  /** The zidane settings document: read, written through when this connection may. Absent: no settings rows. */
-  settings?: SettingsHost;
-  /** The session sidebar's platform members: Finder, standalone windows, environment commands. Absent: those menu rows hide. */
-  sidebar?: SidebarHost;
-  /** The terminals: listing, opening and viewing them per scope. Absent: no terminal drawer or tab. */
-  terminal?: TerminalHost;
-  /** Where the side panel's layouts live, and the extension panels. Absent: layouts last as long as the page, no extension panels. */
-  workspace?: WorkspaceHost;
-}

package/src/app/headless/index.ts

@@ -1,6 +0,0 @@
-/**
- * `zidane-ui/app/headless`: the React-free half of the app area. The
- * `AppHost` type that composes every area's host.
- */
-export * from './app-host';
-export * from './resource';

package/src/app/headless/resource.ts

@@ -1,444 +0,0 @@
-/**
- * Reads that stay current: one store of entries keyed by the serialized key,
- * shared by every view and module asking for the same data. A read is
- * described by a {@link ResourceSpec} (key, fetcher, options), declared once
- * per kind of data. React-free; `useResource` (`zidane-ui/app`) reads it in
- * a component.
- *
- * - `store.subscribe(spec, onChange)` → unsubscribe, for module code:
- *   keeps the resource live like a mounted hook and calls `onChange` with the
- *   current snapshot right away, then on every change.
- * - `store.fetch(spec)` → a promise of the data, for a read on demand (a
- *   fresh value is reused, an in-flight one joined); rejects on error.
- * - `store.subscribeInvalidation(options, listener)` → unsubscribe: the
- *   matching invalidation events themselves, for views that refresh their own way.
- *
- * Behavior: one request per key at a time (concurrent readers share it); the
- * last data stays while a refetch runs (`stale` says it is out of date) and
- * when a refetch fails; errors land in `error`, never as an empty value. An
- * invalidation event (from the `invalidation` source) whose topic is in
- * `options.topics` and whose `cwd` / `hostId` / `sessionId` don't contradict
- * `options.scope` marks the entry stale and refetches it when someone reads it
- * (otherwise on the next read). Topics in `watchedTopics` (only emitted while
- * watched) are watched for `scope.cwd` while the entry has readers.
- * `revalidateOnFocus` refetches when the window regains focus. A new reader
- * refetches data older than `ttl` (default 2 s). Entries without readers are
- * dropped after a minute. Snapshots are immutable and only replaced when
- * something changed, and `refresh` keeps its identity for the life of the
- * entry, so a reader's result is safe in effect and memo deps. Reading never
- * touches the store: entries are made by subscribing and fetching.
- */
-
-/** A resource's identity: a string, or values serialized as JSON. */
-export type ResourceKey = string | readonly unknown[];
-
-/** What a resource's data is about; an event naming another folder, server or session leaves it alone. */
-export interface ResourceScope {
-  /** The folder (an event about a folder that holds it, or that it holds, concerns it). */
-  cwd?: string;
-  /** The host (this computer's or a server's id). */
-  hostId?: string;
-  /** The session. */
-  sessionId?: string;
-}
-
-/** An invalidation event: a topic, and the scope it is about (absent fields: any). */
-export interface ResourceEvent<Topic extends string = string> extends ResourceScope {
-  /** What changed. */
-  topic: Topic;
-}
-
-/** How a resource stays current. */
-export interface ResourceOptions<Topic extends string = string> {
-  /** Topics whose events stale this resource. */
-  topics?: readonly Topic[];
-  /** What the data is about. */
-  scope?: ResourceScope;
-  /** A new reader refetches data older than this (ms). */
-  ttl?: number;
-  /** Refetch (when old) as the window regains focus. */
-  revalidateOnFocus?: boolean;
-}
-
-/** One kind of data: the same key and fetcher wherever it is read. */
-export interface ResourceSpec<T, Topic extends string = string> {
-  /** The resource's identity. */
-  key: ResourceKey;
-  /** Reads the data. */
-  fetcher: () => Promise<T>;
-  /** How it stays current; the first read of a key decides. */
-  options?: ResourceOptions<Topic>;
-}
-
-/** Where a resource is: `idle` (nothing asked), `loading` (the first fetch runs), then the last fetch's outcome. */
-export type ResourceStatus = 'idle' | 'loading' | 'success' | 'error';
-
-/** A resource as read: immutable, replaced only when something changed. */
-export interface ResourceSnapshot<T> {
-  /** The last data fetched. */
-  data: T | undefined;
-  /** The last fetch's error. */
-  error: unknown;
-  /** See {@link ResourceStatus}. */
-  status: ResourceStatus;
-  /** `data` is known out of date (invalidated, refetching). */
-  stale: boolean;
-  /** Refetch now; keeps its identity for the life of the entry. */
-  refresh: () => Promise<void>;
-}
-
-/** Where invalidation events come from (an app's IPC, a server's signals). */
-export interface ResourceInvalidation<Topic extends string = string> {
-  /** Calls `listener` with each event; returns the unsubscribe. */
-  onInvalidate(listener: (event: ResourceEvent<Topic>) => void): () => void;
-  /** Start emitting a watched topic for a folder. */
-  watch?(topic: Topic, cwd: string): unknown;
-  /** Stop emitting it. */
-  unwatch?(topic: Topic, cwd: string): unknown;
-}
-
-/** Options of {@link createResourceStore}. */
-export interface ResourceStoreOptions<Topic extends string = string> {
-  /**
-   * The event source, read when the store first needs it (and again after `reset`), so an app can
-   * install it after the store is made. Absent or `undefined`: no invalidation, only TTL and refresh.
-   */
-  invalidation?: () => ResourceInvalidation<Topic> | undefined;
-  /** Topics only emitted while watched for a folder. */
-  watchedTopics?: readonly Topic[];
-  /** Calls `listener` when the window regains focus; returns the unsubscribe. Default: the window's `focus` event. */
-  onFocus?: (listener: () => void) => () => void;
-}
-
-/** A store of resources; see the top of this file. */
-export interface ResourceStore<Topic extends string = string> {
-  /** The serialized form of a key: what {@link ResourceStore.peekKey} takes. */
-  keyOf(key: ResourceKey): string;
-  /** The snapshot a serialized key holds now (`loading` before anyone subscribed). */
-  peekKey(id: string): ResourceSnapshot<unknown>;
-  /** The snapshot `spec` holds now, without reading or subscribing. */
-  peek<T>(spec: ResourceSpec<T, Topic>): ResourceSnapshot<T>;
-  /** Keep `spec` live; `listener` hears each new snapshot (not the current one). Returns the unsubscribe. */
-  watch<T>(spec: ResourceSpec<T, Topic>, listener: () => void): () => void;
-  /** Keep `spec` live; `onChange` gets the current snapshot now and every new one. Returns the unsubscribe. */
-  subscribe<T>(spec: ResourceSpec<T, Topic>, onChange: (snapshot: ResourceSnapshot<T>) => void): () => void;
-  /** `listener` hears the events `options` matches (as a resource with them would), watched topics watched meanwhile. */
-  subscribeInvalidation(options: ResourceOptions<Topic>, listener: (event: ResourceEvent<Topic>) => void): () => void;
-  /** The data now: a fresh value is reused and an in-flight fetch joined. Rejects with the fetch's error. */
-  fetch<T>(spec: ResourceSpec<T, Topic>): Promise<T>;
-  /** Forget every entry and listener, and unhook the event source (tests). */
-  reset(): void;
-}
-
-const DEFAULT_TTL_MS = 2_000;
-const GC_MS = 60_000;
-
-/** What a null spec reads. */
-export const IDLE_RESOURCE: ResourceSnapshot<never> = Object.freeze({
-  data: undefined,
-  error: undefined,
-  status: 'idle',
-  stale: false,
-  refresh: () => Promise.resolve(),
-});
-
-/** What a reader sees before its first subscribe makes the entry. */
-const PENDING: ResourceSnapshot<never> = Object.freeze({ ...IDLE_RESOURCE, status: 'loading' });
-
-function isAtOrUnder(path: string, dir: string): boolean {
-  const root = dir.replace(/\/+$/, '');
-  return path === root || path.startsWith(`${root}/`);
-}
-
-/**
- * Whether `event` concerns a resource with `options`: its topic is listed, and absent fields on either side
- * mean "any"; folders match when one holds the other (a repo root vs a subfolder).
- *
- * @param event - An invalidation event.
- * @param options - A resource's options.
- */
-export function resourceEventMatches<Topic extends string>(
-  event: ResourceEvent<Topic>,
-  options: ResourceOptions<Topic>,
-): boolean {
-  if (!options.topics?.includes(event.topic)) return false;
-  const scope = options.scope ?? {};
-  if (event.cwd && scope.cwd && !(isAtOrUnder(event.cwd, scope.cwd) || isAtOrUnder(scope.cwd, event.cwd))) {
-    return false;
-  }
-  if (event.hostId && scope.hostId && event.hostId !== scope.hostId) return false;
-  if (event.sessionId && scope.sessionId && event.sessionId !== scope.sessionId) return false;
-  return true;
-}
-
-/** JSON data: equal when it serializes the same. */
-function sameData(a: unknown, b: unknown): boolean {
-  if (Object.is(a, b)) return true;
-  try {
-    return JSON.stringify(a) === JSON.stringify(b);
-  } catch {
-    return false;
-  }
-}
-
-function serializeKey(key: ResourceKey): string {
-  return typeof key === 'string' ? key : JSON.stringify(key);
-}
-
-function windowFocus(listener: () => void): () => void {
-  if (typeof window === 'undefined') return () => undefined;
-  window.addEventListener('focus', listener);
-  return () => window.removeEventListener('focus', listener);
-}
-
-/**
- * A new resource store over an invalidation source.
- *
- * @param options - The event source, the watched topics and the focus signal.
- */
-export function createResourceStore<Topic extends string = string>(
-  options: ResourceStoreOptions<Topic> = {},
-): ResourceStore<Topic> {
-  type Options = ResourceOptions<Topic>;
-  type Snapshot = ResourceSnapshot<unknown>;
-  interface Entry {
-    key: string;
-    fetcher: () => Promise<unknown>;
-    /** The spec's, from the read that made the entry: one key names one kind of data. */
-    options: Options;
-    snapshot: Snapshot;
-    inflight: Promise<void> | null;
-    /** Invalidated while a fetch ran: its result may predate the change. */
-    again: boolean;
-    fetchedAt: number;
-    readers: Set<(snapshot: Snapshot) => void>;
-    watches: string[];
-    gc: ReturnType<typeof setTimeout> | null;
-  }
-  interface InvalidationListener {
-    options: Options;
-    listener: (event: ResourceEvent<Topic>) => void;
-  }
-
-  const watched: ReadonlySet<Topic> = new Set(options.watchedTopics ?? []);
-  const onFocusSignal = options.onFocus ?? windowFocus;
-  const entries = new Map<string, Entry>();
-  const invalidationListeners = new Set<InvalidationListener>();
-  const watchCounts = new Map<string, number>();
-  let wired = false;
-  let unwire: (() => void) | null = null;
-
-  const source = () => options.invalidation?.();
-
-  function setSnapshot(entry: Entry, patch: Partial<Snapshot>): void {
-    const prev = entry.snapshot;
-    const changed = (Object.keys(patch) as (keyof Snapshot)[]).some((k) => !Object.is(prev[k], patch[k]));
-    if (!changed) return;
-    entry.snapshot = Object.freeze({ ...prev, ...patch });
-    for (const reader of [...entry.readers]) reader(entry.snapshot);
-  }
-
-  /**
-   * `quiet`: a check only because the data aged (a new reader, window focus), not because something
-   * changed: readers hear nothing unless the answer differs (no `stale` flip, no re-render).
-   */
-  function revalidate(entry: Entry, quiet = false): Promise<void> {
-    if (entry.inflight) {
-      if (!quiet) entry.again = true;
-      return entry.inflight;
-    }
-    entry.again = false;
-    if (!quiet) {
-      if (entry.snapshot.data !== undefined) setSnapshot(entry, { stale: true });
-      else if (entry.snapshot.status !== 'loading') setSnapshot(entry, { status: 'loading' });
-    }
-    let run: Promise<unknown>;
-    try {
-      run = Promise.resolve(entry.fetcher());
-    } catch (err) {
-      run = Promise.reject(err);
-    }
-    const done = run.then(
-      (data) => {
-        entry.fetchedAt = Date.now();
-        // The same answer keeps its identity, so readers' memoized work (a 300-model list) stays valid.
-        const same = entry.snapshot.data !== undefined && sameData(entry.snapshot.data, data);
-        setSnapshot(entry, { ...(same ? {} : { data }), error: undefined, status: 'success', stale: entry.again });
-      },
-      (error: unknown) => {
-        entry.fetchedAt = Date.now();
-        setSnapshot(entry, { error, status: 'error', stale: entry.again || entry.snapshot.data !== undefined });
-      },
-    );
-    entry.inflight = done.finally(() => {
-      entry.inflight = null;
-      if (entry.again && entries.get(entry.key) === entry && entry.readers.size > 0) void revalidate(entry);
-    });
-    return entry.inflight;
-  }
-
-  function wire(): void {
-    if (wired) return;
-    wired = true;
-    const off = source()?.onInvalidate((event) => {
-      for (const { options: o, listener } of [...invalidationListeners]) {
-        if (resourceEventMatches(event, o)) listener(event);
-      }
-      for (const entry of entries.values()) {
-        if (!resourceEventMatches(event, entry.options)) continue;
-        if (entry.inflight) entry.again = true;
-        else if (entry.readers.size > 0) void revalidate(entry);
-        else setSnapshot(entry, { stale: true });
-      }
-    });
-    const offFocus = onFocusSignal(() => {
-      for (const entry of entries.values()) {
-        if (entry.readers.size > 0 && entry.options.revalidateOnFocus && isOld(entry)) void revalidate(entry, true);
-      }
-    });
-    unwire = () => {
-      off?.();
-      offFocus();
-    };
-  }
-
-  function isOld(entry: Entry): boolean {
-    return entry.fetchedAt === 0 || Date.now() - entry.fetchedAt >= (entry.options.ttl ?? DEFAULT_TTL_MS);
-  }
-
-  function scheduleGc(entry: Entry): void {
-    if (entry.gc) clearTimeout(entry.gc);
-    entry.gc = setTimeout(() => {
-      entry.gc = null;
-      if (entry.readers.size === 0 && !entry.inflight && entries.get(entry.key) === entry) entries.delete(entry.key);
-    }, GC_MS);
-  }
-
-  function ensureEntry<T>(spec: ResourceSpec<T, Topic>): Entry {
-    const key = serializeKey(spec.key);
-    const existing = entries.get(key);
-    if (existing) return existing;
-    const entry: Entry = {
-      key,
-      fetcher: spec.fetcher,
-      options: spec.options ?? {},
-      snapshot: PENDING,
-      inflight: null,
-      again: false,
-      fetchedAt: 0,
-      readers: new Set(),
-      watches: [],
-      gc: null,
-    };
-    entry.snapshot = Object.freeze({ ...PENDING, refresh: () => revalidate(entry) });
-    entries.set(key, entry);
-    return entry;
-  }
-
-  /** Starts the watchers `o` needs (counted per topic and folder); returns their ids for {@link stopWatches}. */
-  function startWatches(o: Options): string[] {
-    const cwd = o.scope?.cwd;
-    const api = source();
-    if (!cwd || !api) return [];
-    const ids: string[] = [];
-    for (const topic of o.topics ?? []) {
-      if (!watched.has(topic)) continue;
-      const id = `${topic}\0${cwd}`;
-      ids.push(id);
-      const count = watchCounts.get(id) ?? 0;
-      watchCounts.set(id, count + 1);
-      if (count === 0) void Promise.resolve(api.watch?.(topic, cwd)).catch(() => undefined);
-    }
-    return ids;
-  }
-
-  function stopWatches(ids: readonly string[]): void {
-    const api = source();
-    for (const id of ids) {
-      const count = (watchCounts.get(id) ?? 1) - 1;
-      if (count > 0) {
-        watchCounts.set(id, count);
-        continue;
-      }
-      watchCounts.delete(id);
-      const [topic, cwd] = id.split('\0') as [Topic, string];
-      void Promise.resolve(api?.unwatch?.(topic, cwd)).catch(() => undefined);
-    }
-  }
-
-  function attach(entry: Entry, reader: (snapshot: Snapshot) => void): () => void {
-    wire();
-    if (entry.gc) {
-      clearTimeout(entry.gc);
-      entry.gc = null;
-    }
-    if (entry.readers.size === 0) entry.watches = startWatches(entry.options);
-    entry.readers.add(reader);
-    if (!entry.inflight && (entry.snapshot.stale || isOld(entry))) void revalidate(entry, !entry.snapshot.stale);
-    return () => {
-      if (!entry.readers.delete(reader) || entry.readers.size > 0) return;
-      stopWatches(entry.watches);
-      entry.watches = [];
-      scheduleGc(entry);
-    };
-  }
-
-  return {
-    keyOf: serializeKey,
-    peekKey: (id) => entries.get(id)?.snapshot ?? PENDING,
-    peek: <T>(spec: ResourceSpec<T, Topic>) =>
-      (entries.get(serializeKey(spec.key))?.snapshot ?? PENDING) as ResourceSnapshot<T>,
-    watch: (spec, listener) => attach(ensureEntry(spec), listener),
-    subscribe<T>(spec: ResourceSpec<T, Topic>, onChange: (snapshot: ResourceSnapshot<T>) => void) {
-      const entry = ensureEntry(spec);
-      const detach = attach(entry, onChange as (snapshot: Snapshot) => void);
-      onChange(entry.snapshot as ResourceSnapshot<T>);
-      return detach;
-    },
-    subscribeInvalidation(o, listener) {
-      wire();
-      const entry: InvalidationListener = { options: o, listener };
-      invalidationListeners.add(entry);
-      const watches = startWatches(o);
-      return () => {
-        if (!invalidationListeners.delete(entry)) return;
-        stopWatches(watches);
-      };
-    },
-    async fetch<T>(spec: ResourceSpec<T, Topic>): Promise<T> {
-      wire();
-      const entry = ensureEntry(spec);
-      if (entry.inflight) await entry.inflight;
-      if (entry.snapshot.stale || isOld(entry) || entry.snapshot.status === 'error') {
-        await revalidate(entry);
-      }
-      if (entry.readers.size === 0) scheduleGc(entry);
-      const snapshot = entry.snapshot;
-      if (snapshot.status === 'error') throw snapshot.error;
-      return snapshot.data as T;
-    },
-    reset() {
-      for (const entry of entries.values()) if (entry.gc) clearTimeout(entry.gc);
-      entries.clear();
-      invalidationListeners.clear();
-      watchCounts.clear();
-      unwire?.();
-      unwire = null;
-      wired = false;
-    },
-  };
-}
-
-/**
- * One resource of a store as a readable value (`get` + `subscribe`, the shape hosts hand to components):
- * subscribing keeps it live like a mounted reader. Both methods keep their identity.
- *
- * @param store - The store holding it.
- * @param spec - The resource.
- */
-export function readableResource<T, Topic extends string = string>(
-  store: ResourceStore<Topic>,
-  spec: ResourceSpec<T, Topic>,
-): { get(): ResourceSnapshot<T>; subscribe(listener: () => void): () => void } {
-  return { get: () => store.peek(spec), subscribe: (listener) => store.watch(spec, listener) };
-}

package/src/app/index.ts

@@ -1,9 +0,0 @@
-/**
- * `zidane-ui/app`: the app area. `AppHostProvider` puts every area's host in
- * context in one wrap, `useAppHost` reads it back. The `AppHost` type is
- * `zidane-ui/app/headless`.
- */
-export * from './AppHostProvider';
-export * from './ModalProvider';
-export * from './useConfirm';
-export * from './useResource';

package/src/app/testing/index.ts

@@ -1,90 +0,0 @@
-/**
- * `zidane-ui/app/testing`: an `AppHost` that runs in memory
- * (`createFixtureAppHost`), composed of each area's fixture host, for docs,
- * demos and an app's own tests. Not for production hosts.
- */
-import { createFixtureAppearanceHost, type FixtureAppearanceOptions } from '../../appearance/testing';
-import { createFixtureApprovalsHost, type FixtureApprovalsOptions } from '../../approvals/testing';
-import {
-  createFixtureComposerHost,
-  createFixtureHost,
-  createFixtureSidebarHost,
-  type ChatFixture,
-  type FixtureComposerHostOptions,
-  type FixtureHostOptions,
-  type FixtureSidebarHostOptions,
-} from '../../chat/testing';
-import { createFixtureFilesHost, type FixtureFilesHostOptions } from '../../files/testing';
-import { createFixtureGitHost, type FixtureGitOptions } from '../../git/testing';
-import { createFixtureKeybindingsHost, type FixtureKeybindingsOptions } from '../../keybindings/testing';
-import { createFixtureMachinesHost, type FixtureMachinesOptions } from '../../machines/testing';
-import { createFixtureOnboardingHost, type FixtureOnboardingOptions } from '../../onboarding/testing';
-import { createFixturePaletteHost, type FixturePaletteOptions } from '../../palette/testing';
-import { createFixtureSessionHost, type SessionFixture } from '../../session/testing';
-import { createFixtureSettingsHost, type FixtureSettingsOptions } from '../../settings/testing';
-import { createFixtureTerminalHost, type FixtureTerminalOptions } from '../../terminal/testing';
-import { createFixtureWorkspaceHost, type FixtureWorkspaceOptions } from '../../workspace/testing';
-import type { AppHost } from '../headless/app-host';
-
-/** Options for {@link createFixtureAppHost}: each area's fixture, or `false` to leave the area out. */
-export interface FixtureAppHostOptions {
-  /** The appearance fixture host's options. Default: none, the app applies no appearance. */
-  appearance?: FixtureAppearanceOptions | false;
-  /** The approvals fixture host's options: pending approvals and the safelist. Default: none pending. `false`: no approvals host. */
-  approvals?: FixtureApprovalsOptions | false;
-  /** The chat fixture's sessions, transcripts, models and interactions. Default: no sessions. `false`: no chat host. */
-  chat?: ChatFixture | false;
-  /** How the chat fixture host behaves: editable, scripted replies, streaming pace. */
-  chatOptions?: FixtureHostOptions;
-  /** The rich composer's fixture host: drafts, completions, ghost text. Default: none, no composer host. */
-  composer?: FixtureComposerHostOptions | false;
-  /** The files fixture host's options: the folder's files, git status and patches. Default: none, no files host. */
-  files?: FixtureFilesHostOptions | false;
-  /** The git fixture host's options: branches, pull requests, environment kinds and remote folders. Default: none, no git host. */
-  git?: FixtureGitOptions | false;
-  /** The keybindings fixture host's options: stored overrides. Default: none, the default bindings. */
-  keybindings?: FixtureKeybindingsOptions | false;
-  /** The machines fixture host's options: hosts, machines, updates, tokens, the daemon. Default: none, no machines host. */
-  machines?: FixtureMachinesOptions | false;
-  /** The onboarding fixture host's options. Default: its defaults. `false`: no onboarding host. */
-  onboarding?: FixtureOnboardingOptions | false;
-  /** The palette fixture host's options. Default: its demo data. `false`: no palette host. */
-  palette?: FixturePaletteOptions | false;
-  /** The session panels' fixture: todos, queues and artifacts. Default: none. `false`: no session host. */
-  session?: SessionFixture | false;
-  /** The sidebar fixture host's options: environment commands, Finder and windows. Default: none, no sidebar host. */
-  sidebar?: FixtureSidebarHostOptions | false;
-  /** The settings fixture host's options: stored settings, read-only. Default: none, no settings host. */
-  settings?: FixtureSettingsOptions | false;
-  /** The terminal fixture host's options: terminals per scope. Default: none, no terminal host. */
-  terminal?: FixtureTerminalOptions | false;
-  /** The workspace fixture host's options: stored layouts and extension panels. Default: none stored. `false`: no workspace host. */
-  workspace?: FixtureWorkspaceOptions | false;
-}
-
-/**
- * Creates an {@link AppHost} held in memory, with each area's fixture host (`createFixtureHost`, `createFixtureOnboardingHost`).
- *
- * @param options - Each area's fixture, or `false` to leave that area out.
- */
-export function createFixtureAppHost(options: FixtureAppHostOptions = {}): AppHost {
-  const { chat = { sessions: [] }, chatOptions, onboarding = {}, palette = {}, session = {} } = options;
-  const { approvals = {}, appearance = false, git = false, keybindings = false } = options;
-  return {
-    ...(appearance ? { appearance: createFixtureAppearanceHost(appearance) } : {}),
-    ...(keybindings ? { keybindings: createFixtureKeybindingsHost(keybindings) } : {}),
-    ...(options.machines ? { machines: createFixtureMachinesHost(options.machines) } : {}),
-    ...(git ? { git: createFixtureGitHost(git) } : {}),
-    ...(approvals ? { approvals: createFixtureApprovalsHost(approvals) } : {}),
-    ...(chat ? { chat: createFixtureHost(chat, chatOptions) } : {}),
-    ...(options.composer ? { composer: createFixtureComposerHost(options.composer) } : {}),
-    ...(options.sidebar ? { sidebar: createFixtureSidebarHost(options.sidebar) } : {}),
-    ...(options.files ? { files: createFixtureFilesHost(options.files) } : {}),
-    ...(onboarding ? { onboarding: createFixtureOnboardingHost(onboarding) } : {}),
-    ...(palette ? { palette: createFixturePaletteHost(palette) } : {}),
-    ...(session ? { session: createFixtureSessionHost(session) } : {}),
-    ...(options.settings ? { settings: createFixtureSettingsHost(options.settings) } : {}),
-    ...(options.terminal ? { terminal: createFixtureTerminalHost(options.terminal) } : {}),
-    ...(options.workspace !== false ? { workspace: createFixtureWorkspaceHost(options.workspace ?? {}) } : {}),
-  };
-}

package/src/app/useConfirm.tsx

@@ -1,65 +0,0 @@
-/**
- * The in-app replacement for `window.confirm()`: the design system's ConfirmDialog
- * on the modal layer (`ModalProvider.openLayer`), so asking from inside
- * Settings or another modal stacks above it instead of replacing it.
- *
- *   const confirm = useConfirm();
- *   if (!(await confirm({ title: 'Delete session?', destructive: true }))) return;
- *
- * Esc, a scrim click, Cancel, or the surface underneath closing all resolve
- * `false`. Focus returns to where it was.
- */
-import { useCallback } from 'react';
-import { CONFIRM_TITLE_ID, ConfirmDialog, type ConfirmOptions } from '../components/ConfirmDialog';
-import { useModal, useOptionalModal, type ModalContextValue } from './ModalProvider';
-
-/** Opens a ConfirmDialog on `modal`'s layer and resolves with the choice. */
-function askOn(modal: Pick<ModalContextValue, 'openLayer' | 'closeLayer'>, options: ConfirmOptions): Promise<boolean> {
-  const { openLayer, closeLayer } = modal;
-  return new Promise<boolean>((resolve) => {
-    const previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
-    const settle = (value: boolean) => {
-      resolve(value);
-      // After the layer unmounts and the surface underneath is no longer inert.
-      requestAnimationFrame(() => previousFocus?.focus());
-    };
-    openLayer(
-      <ConfirmDialog
-        {...options}
-        titleId={CONFIRM_TITLE_ID}
-        className="zg-modal-panel"
-        onConfirm={() => {
-          closeLayer();
-          settle(true);
-        }}
-        onCancel={() => {
-          closeLayer();
-          settle(false);
-        }}
-      />,
-      { onDismiss: () => settle(false), labelledBy: CONFIRM_TITLE_ID },
-    );
-  });
-}
-
-/** A function that opens a ConfirmDialog above whatever is open and resolves with the choice. Needs a `ModalProvider`. */
-export function useConfirm(): (options: ConfirmOptions) => Promise<boolean> {
-  const { openLayer, closeLayer } = useModal();
-  return useCallback((options: ConfirmOptions) => askOn({ openLayer, closeLayer }, options), [openLayer, closeLayer]);
-}
-
-/**
- * {@link useConfirm} where a `ModalProvider` may be missing (a component mounted on its own, a gallery):
- * `null` there, so the caller leaves out what must ask first.
- */
-export function useOptionalConfirm(): ((options: ConfirmOptions) => Promise<boolean>) | null {
-  const modal = useOptionalModal();
-  const openLayer = modal?.openLayer;
-  const closeLayer = modal?.closeLayer;
-  const ask = useCallback(
-    (options: ConfirmOptions) =>
-      openLayer && closeLayer ? askOn({ openLayer, closeLayer }, options) : Promise.resolve(false),
-    [openLayer, closeLayer],
-  );
-  return modal ? ask : null;
-}