zidane-ui 9.0.4 → 9.1.3

package/src/chat/sidebar/usePinnedProjects.ts

@@ -1,36 +0,0 @@
-import { useCallback, useState } from 'react';
-
-import { readPersisted, writePersisted } from '../../hooks/usePersistedState';
-import {
-  parsePinnedProjects,
-  PINNED_PROJECTS_KEY,
-  withPinnedProject,
-  type PinsBySpace,
-} from '../headless/sidebar/pinned-projects';
-
-const NONE: readonly string[] = [];
-
-const loadPins = (): PinsBySpace => readPersisted(PINNED_PROJECTS_KEY, parsePinnedProjects) ?? {};
-
-/**
- * The space's pinned project folders and a setter that persists them.
- *
- * @param spaceId - The space whose pins to read and change.
- */
-export function usePinnedProjects(spaceId: string): {
-  pinned: readonly string[];
-  setPinned: (fullPath: string, pinned: boolean) => void;
-} {
-  const [pins, setPins] = useState<PinsBySpace>(loadPins);
-  const setPinned = useCallback(
-    (fullPath: string, pin: boolean) => {
-      setPins((current) => {
-        const next = withPinnedProject(current, spaceId, fullPath, pin);
-        if (next !== current) writePersisted(PINNED_PROJECTS_KEY, JSON.stringify(next));
-        return next;
-      });
-    },
-    [spaceId],
-  );
-  return { pinned: pins[spaceId] ?? NONE, setPinned };
-}

package/src/chat/sidebar/useSessionActivity.ts

@@ -1,24 +0,0 @@
-import { useCallback, useSyncExternalStore } from 'react';
-
-import type { SessionActivity, SessionActivityStore } from '../headless/sidebar/activity';
-
-const noSubscription = () => () => undefined;
-
-/**
- * What the session's run is doing, `null` when nothing of a run was seen (or
- * it ended). An entry can outlive a run whose end was missed: show it only
- * while the session is running.
- *
- * @param store - The app's {@link SessionActivityStore}.
- * @param sessionId - The session to follow.
- * @param enabled - False: nothing is followed (and `null` returned).
- */
-export function useSessionActivity(
-  store: SessionActivityStore,
-  sessionId: string,
-  enabled = true,
-): SessionActivity | null {
-  const follow = useCallback((l: () => void) => store.subscribe(sessionId, l), [store, sessionId]);
-  const read = () => (enabled ? store.get(sessionId) : null);
-  return useSyncExternalStore(enabled ? follow : noSubscription, read, read);
-}

package/src/chat/sidebar/useSessionBadges.ts

@@ -1,26 +0,0 @@
-import { useCallback, useEffect, useSyncExternalStore } from 'react';
-
-import type { SessionBadgesEntry, SessionBadgesStore } from '../headless/sidebar/badges';
-
-const noSubscription = () => () => undefined;
-
-/**
- * The session's badges, `null` until first read (asked for on first use).
- *
- * @param store - The app's {@link SessionBadgesStore}.
- * @param sessionId - The session whose badges to read.
- * @param enabled - False: nothing is asked or followed.
- */
-export function useSessionBadges(
-  store: SessionBadgesStore,
-  sessionId: string,
-  enabled = true,
-): SessionBadgesEntry | null {
-  const follow = useCallback((l: () => void) => store.subscribe(sessionId, l), [store, sessionId]);
-  const read = () => (enabled ? store.get(sessionId) : null);
-  const entry = useSyncExternalStore(enabled ? follow : noSubscription, read, read);
-  useEffect(() => {
-    if (enabled && !store.has(sessionId)) store.request(sessionId);
-  }, [store, sessionId, enabled]);
-  return entry;
-}

package/src/chat/sidebar/useSessionDirectoryView.ts

@@ -1,86 +0,0 @@
-import { useEffect, useMemo } from 'react';
-import { sessionSpaceFilter } from 'zidane/chat/pure';
-
-import {
-  availableProjectsOf,
-  filterDirectorySessions,
-  sessionRefsOf,
-  type SessionDirectory,
-  type SessionDirectoryState,
-  type SessionRef,
-} from '../headless/sidebar/directory';
-import type { SidebarListSession, SidebarView } from '../headless/sidebar/types';
-import { DEFAULT_SIDEBAR_VIEW } from '../headless/sidebar/view';
-import { useReadable } from '../headless/store';
-
-/** The directory as the sidebar reads it: its state plus the shown space's filtered list and view. */
-export interface SessionDirectoryView<S extends SidebarListSession> extends SessionDirectoryState<S> {
-  /** The sessions the list shows (space, project and activity filters applied). */
-  sessions: readonly S[];
-  /**
-   * The space the list shows: `activeSpace`, in the same render. Deferring it
-   * time-sliced the new rows behind the switcher's spring, ~3 frames late.
-   */
-  listSpaceId: string;
-  /** The shown space's archive axis. */
-  archiveFilter: SidebarView['archive'];
-  /** The shown space's project axis (a folder name, or `null` for all). */
-  projectFilter: SidebarView['project'];
-  /** The shown space's activity axis. */
-  activityFilter: SidebarView['activity'];
-  /** The shown space's grouping. */
-  groupBy: SidebarView['groupBy'];
-  /** The shown space's sort. */
-  sortBy: SidebarView['sortBy'];
-  /** Every project the listed sessions belong to (by folder name), sorted. */
-  availableProjects: string[];
-  /** How a reference names each session. */
-  sessionRefs: ReadonlyMap<string, SessionRef>;
-}
-
-/**
- * Subscribe to a session directory.
- *
- * @param directory - The {@link SessionDirectory} to read.
- * @param unfiltered - List every session whatever the filters say (a window that only shows one session).
- */
-export function useSessionDirectoryView<S extends SidebarListSession, C>(
-  directory: SessionDirectory<S, C>,
-  unfiltered = false,
-): SessionDirectoryView<S> {
-  const base = useReadable(directory.state);
-  const listSpaceId = base.activeSpace.id;
-  const views = useReadable(directory.views.views);
-  const view = views[listSpaceId] ?? DEFAULT_SIDEBAR_VIEW;
-  const { archive, project, activity, groupBy, sortBy } = view;
-
-  useEffect(() => directory.setArchive(archive), [directory, archive]);
-
-  const raw = base.allSessions;
-  const inSpace = useMemo(
-    () => sessionSpaceFilter<S>({ spaces: base.spacesOn, spaceList: base.spaces as never }, listSpaceId),
-    [base.spacesOn, base.spaces, listSpaceId],
-  );
-  const sessions = useMemo(
-    () => (unfiltered ? raw : filterDirectorySessions(raw, { inSpace, project, activity })),
-    [unfiltered, raw, inSpace, project, activity],
-  );
-  const availableProjects = useMemo(() => availableProjectsOf(raw), [raw]);
-  const sessionRefs = useMemo(() => sessionRefsOf(raw), [raw]);
-
-  return useMemo(
-    () => ({
-      ...base,
-      sessions,
-      listSpaceId,
-      archiveFilter: archive,
-      projectFilter: project,
-      activityFilter: activity,
-      groupBy,
-      sortBy,
-      availableProjects,
-      sessionRefs,
-    }),
-    [base, sessions, listSpaceId, archive, project, activity, groupBy, sortBy, availableProjects, sessionRefs],
-  );
-}

package/src/chat/sidebar/useSessionSearch.ts

@@ -1,94 +0,0 @@
-/**
- * Sidebar search: titles match instantly (every query term, locally);
- * conversation content goes through the host's debounced content search
- * (`ChatHost.sessions.search`). Content hits are resolved against the
- * caller's FILTERED list, which dedupes title matches and drops hits outside
- * the active scope.
- */
-import { useEffect, useMemo, useRef, useState } from 'react';
-
-import type { SessionSearchHit } from '../headless/host';
-import type { SessionArchiveFilter, SidebarListSession } from '../headless/sidebar/types';
-
-/**
- * Debounce between the last search keystroke and the content search. Title
- * matching is local and instant; only the content scan waits it out.
- */
-const SEARCH_DEBOUNCE_MS = 200;
-
-/** The host's content search; absent, only titles match. */
-export type SessionContentSearch = (
-  query: string,
-  filter: { archive: SessionArchiveFilter },
-) => Promise<readonly SessionSearchHit[]>;
-
-/**
- * The sidebar's search: the query, its title matches and its content matches.
- *
- * @param sessions - The filtered list the matches come from.
- * @param archiveFilter - The archive axis the content search reads.
- * @param search - The host's content search; absent, only titles match.
- */
-export function useSessionSearch<S extends SidebarListSession>(
-  sessions: readonly S[],
-  archiveFilter: SessionArchiveFilter,
-  search: SessionContentSearch | undefined,
-) {
-  const [searchQuery, setSearchQuery] = useState('');
-  const [contentHits, setContentHits] = useState<readonly SessionSearchHit[]>([]);
-  const [searching, setSearching] = useState(false);
-  /** The newest search sent: an answer to an older one is a stale scan a newer keystroke superseded. */
-  const latest = useRef(0);
-  const trimmedQuery = searchQuery.trim();
-  const searchMode = trimmedQuery.length > 0;
-
-  useEffect(() => {
-    if (!searchMode || !search) {
-      setContentHits([]);
-      setSearching(false);
-      return;
-    }
-    setSearching(true);
-    const timer = setTimeout(() => {
-      const ask = ++latest.current;
-      void search(trimmedQuery, { archive: archiveFilter })
-        .then((hits) => {
-          if (ask !== latest.current) return;
-          setContentHits(hits);
-          setSearching(false);
-        })
-        .catch(() => {
-          if (ask === latest.current) setSearching(false);
-        });
-    }, SEARCH_DEBOUNCE_MS);
-    return () => clearTimeout(timer);
-  }, [searchMode, trimmedQuery, archiveFilter, search]);
-
-  /** Local (instant) axis of the merged results: sessions whose TITLE contains every query term. */
-  const titleMatches = useMemo<S[]>(() => {
-    if (!searchMode) return [];
-    const terms = trimmedQuery.toLowerCase().split(/\s+/).filter(Boolean);
-    return sessions.filter((s) => {
-      const title = (s.title || '').toLowerCase();
-      return terms.every((term) => title.includes(term));
-    });
-  }, [searchMode, trimmedQuery, sessions]);
-
-  /**
-   * Content hits resolved against the FILTERED session list — dedupes title
-   * matches and drops hits outside the active project / activity scope
-   * (those axes apply on this side, so the host can't).
-   */
-  const contentMatches = useMemo<{ session: S; hit: SessionSearchHit }[]>(() => {
-    if (!searchMode) return [];
-    const titleIds = new Set(titleMatches.map((s) => s.id));
-    const byId = new Map(sessions.map((s) => [s.id, s]));
-    return contentHits.flatMap((hit) => {
-      if (titleIds.has(hit.sessionId)) return [];
-      const session = byId.get(hit.sessionId);
-      return session ? [{ session, hit }] : [];
-    });
-  }, [searchMode, titleMatches, sessions, contentHits]);
-
-  return { searchQuery, setSearchQuery, trimmedQuery, searchMode, searching, titleMatches, contentMatches };
-}

package/src/chat/sidebar/useSidebarKeyboardNav.ts

@@ -1,165 +0,0 @@
-/**
- * The sidebar's keyboard: ↑ / ↓ walk the chats in the order the list shows
- * them, ⌘N / Ctrl+N starts a new one.
- *
- * A tentative cursor moves at CSS speed: each press sets
- * `data-tentative-active` on the row (`[data-session-id]`) straight in the
- * DOM, no React render in the burst, and scrolls it into view
- * (`block: 'nearest'`). Only once the presses stop for `NAV_COMMIT_MS` does
- * the session open (`onActivate`), so the heavy switch runs once per burst.
- * Clicks, ⌘N and outside changes commit at once (`commitImmediate`).
- *
- * The keydown listener binds ONCE: every value it reads goes through refs, so
- * a list refresh never re-attaches it.
- */
-import { useCallback, useEffect, useRef, type RefObject } from 'react';
-
-import { keyScopeOf } from '../../keybindings/headless/key-scope';
-
-/**
- * Debounce window (ms) between the last arrow-key tick and the committed switch. Short enough that a single
- * press commits at once, long enough to coalesce ticks that arrive closer together.
- */
-const NAV_COMMIT_MS = 20;
-
-/** What {@link useSidebarKeyboardNav} reads. */
-export interface SidebarKeyboardNavOptions<K extends string> {
-  /** The list that holds the rows (`[data-session-id]`). */
-  listRef: RefObject<HTMLElement | null>;
-  /** The sessions in on-screen order. */
-  sessions: readonly { id: K }[];
-  /** The open session. */
-  activeSessionId: K | null;
-  /** Opens a session (`null`: none, the new-session surface). */
-  onActivate: (sessionId: K | null) => void;
-  /** Starts a new session (⌘N / Ctrl+N). */
-  onNewSession: () => void;
-  /** The keys belong elsewhere now (a modal is open). Read at each key. */
-  blocked?: () => boolean;
-}
-
-/**
- * Binds the sidebar's keyboard navigation.
- *
- * @param options - The list, its sessions, the open one and what to do.
- * @returns `commitImmediate`: open a session now, cancelling a pending arrow commit.
- */
-export function useSidebarKeyboardNav<K extends string>(
-  options: SidebarKeyboardNavOptions<K>,
-): { commitImmediate: (sessionId: K | null) => void } {
-  const { listRef, sessions, activeSessionId, onActivate, onNewSession, blocked } = options;
-
-  const navRef = useRef<{ tentativeId: K | null; commitTimer: ReturnType<typeof setTimeout> | null }>({
-    tentativeId: null,
-    commitTimer: null,
-  });
-
-  // What the once-bound listener reads, current as of the last render.
-  const latest = useRef({ sessions, onActivate, onNewSession, blocked });
-  // eslint-disable-next-line react-hooks/refs -- the listener binds once and reads the latest values
-  latest.current = { sessions, onActivate, onNewSession, blocked };
-  const activeSessionIdRef = useRef(activeSessionId);
-  // eslint-disable-next-line react-hooks/refs -- a commit writes it ahead of the render, a render catches it up
-  activeSessionIdRef.current = activeSessionId;
-
-  /** Direct-DOM tentative highlight: `.zg-session-row[data-tentative-active='true']` in the stylesheet. */
-  const applyTentative = useCallback(
-    (id: K | null) => {
-      const list = listRef.current;
-      if (!list) return;
-      const prev = navRef.current.tentativeId;
-      if (prev) {
-        const prevEl = list.querySelector<HTMLElement>(`[data-session-id="${CSS.escape(prev)}"]`);
-        prevEl?.removeAttribute('data-tentative-active');
-      }
-      navRef.current.tentativeId = id;
-      if (id) {
-        const el = list.querySelector<HTMLElement>(`[data-session-id="${CSS.escape(id)}"]`);
-        if (el) {
-          el.setAttribute('data-tentative-active', 'true');
-          el.scrollIntoView({ block: 'nearest' });
-        }
-      }
-    },
-    [listRef],
-  );
-
-  const cancelCommitTimer = useCallback(() => {
-    if (navRef.current.commitTimer !== null) {
-      clearTimeout(navRef.current.commitTimer);
-      navRef.current.commitTimer = null;
-    }
-  }, []);
-
-  /**
-   * Debounced commit (arrow keys). The id check in the timer rejects a stale commit (the cursor moved on
-   * between scheduling and firing).
-   */
-  const commitDebounced = useCallback(
-    (id: K) => {
-      applyTentative(id);
-      cancelCommitTimer();
-      navRef.current.commitTimer = setTimeout(() => {
-        navRef.current.commitTimer = null;
-        if (navRef.current.tentativeId === id) {
-          activeSessionIdRef.current = id;
-          latest.current.onActivate(id);
-        }
-      }, NAV_COMMIT_MS);
-    },
-    [applyTentative, cancelCommitTimer],
-  );
-
-  /**
-   * Synchronous commit (clicks, ⌘N). Updates the ref BEFORE the state setter so a keydown in the same tick
-   * reads the new value.
-   */
-  const commitImmediate = useCallback(
-    (id: K | null) => {
-      cancelCommitTimer();
-      applyTentative(null);
-      activeSessionIdRef.current = id;
-      latest.current.onActivate(id);
-    },
-    [applyTentative, cancelCommitTimer],
-  );
-
-  // The open session changed (our own commit settled, or from outside): drop the cursor and any pending commit.
-  useEffect(() => {
-    cancelCommitTimer();
-    applyTentative(null);
-  }, [activeSessionId, applyTentative, cancelCommitTimer]);
-
-  // A pending commit must not fire after unmount.
-  useEffect(() => () => cancelCommitTimer(), [cancelCommitTimer]);
-
-  useEffect(() => {
-    function onKey(e: KeyboardEvent) {
-      if (latest.current.blocked?.()) return;
-      // Typing surfaces and open menus own their arrows and ⌘N (`keyScopeOf` sees through portals and shadow roots).
-      if (keyScopeOf(e) !== 'app') return;
-      if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'n') {
-        e.preventDefault();
-        commitImmediate(null);
-        latest.current.onNewSession();
-        return;
-      }
-      if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp') return;
-      const list = latest.current.sessions;
-      if (list.length === 0) return;
-      e.preventDefault();
-      // Advance from the tentative cursor when one is set, so a held arrow walks on from the last row it visited.
-      const cursorId = navRef.current.tentativeId ?? activeSessionIdRef.current;
-      const currentIdx = list.findIndex((s) => s.id === cursorId);
-      const delta = e.key === 'ArrowDown' ? 1 : -1;
-      const nextIdx = currentIdx === -1 ? 0 : Math.max(0, Math.min(list.length - 1, currentIdx + delta));
-      const nextId = list[nextIdx]!.id;
-      if (nextId === cursorId) return;
-      commitDebounced(nextId);
-    }
-    window.addEventListener('keydown', onKey);
-    return () => window.removeEventListener('keydown', onKey);
-  }, [commitDebounced, commitImmediate]);
-
-  return { commitImmediate };
-}

package/src/chat/sidebar/useSidebarLabels.ts

@@ -1,10 +0,0 @@
-import { useMemo } from 'react';
-
-import { useLabels } from '../../labels';
-import { DEFAULT_SIDEBAR_LABELS, type SidebarLabels } from '../headless/sidebar/labels';
-
-/** The sidebar's strings: {@link DEFAULT_SIDEBAR_LABELS} under the app's `LabelsProvider` overrides. */
-export function useSidebarLabels(): SidebarLabels {
-  const overrides = useLabels() as Partial<SidebarLabels>;
-  return useMemo(() => ({ ...DEFAULT_SIDEBAR_LABELS, ...overrides }), [overrides]);
-}