zidane-ui 9.0.4 → 9.1.3

package/src/workspace/headless/panel-tree.ts

@@ -1,259 +0,0 @@
-/**
- * The side panel's stored layout (`SessionLayout.panelTree`): the tab groups
- * (`tree.ts`), the focused group, and the counter new ids come from.
- *
- * The focused group is where new tabs land and what the tab keys walk; the
- * tab it shows is the panel's active tab. Ids come from `seq` and are never
- * reused, even after their group closed, so a group on screen is always the
- * same group. Every operation is pure and returns its input when nothing
- * changes; `PanelsProvider` applies them to the stored tree
- * (`updateScopeLayout`), never to a copy of its own.
- */
-import {
-  activateTab,
-  closeTab as closeNodeTab,
-  dropOnGroup,
-  findGroup,
-  groupById,
-  groupsOf,
-  moveTab,
-  parseTree,
-  pinTab as pinNodeTab,
-  resizeShownSplit,
-  setGroupTabs,
-  singleGroup,
-  splitTab as splitNodeTab,
-  type DropZone,
-  type NewIds,
-  type PanelNode,
-  type SplitSide,
-} from './tree';
-
-/** The side panel's layout document: the tab groups, the focused one and the id counter. */
-export interface PanelTree {
-  /** The groups and splits. */
-  root: PanelNode;
-  /** The focused group's id (always one of the tree's groups). */
-  focused: string;
-  /** The number the next new id takes (groups `g<n>`, splits `s<n>`). */
-  seq: number;
-}
-
-/** Where a dragged tab is dropped: a strip (before a tab, null: at its end), or a group's body. */
-export type TabDrop = { groupId: string; before: string | null } | { groupId: string; zone: DropZone };
-
-/**
- * One group holding `tabs`, showing `active`.
- *
- * @param tabs - The group's tab ids, in order.
- * @param active - The tab it shows (null: its first).
- */
-export function panelTreeOf(tabs: readonly string[], active: string | null = null): PanelTree {
-  const root = singleGroup(tabs, active);
-  return { root, focused: root.id, seq: nextSeq(root) };
-}
-
-/** Past every numbered id in the tree, so a fresh one never collides. */
-function nextSeq(root: PanelNode, at = 1): number {
-  let max = at - 1;
-  const walk = (n: PanelNode) => {
-    const num = Number(n.id.slice(1));
-    if (Number.isInteger(num) && num > max) max = num;
-    if (n.t === 'split') n.children.forEach(walk);
-  };
-  walk(root);
-  return max + 1;
-}
-
-/**
- * The focused group (the first one if the stored id is stale).
- *
- * @param t - The stored tree.
- */
-export function focusedGroup(t: PanelTree) {
-  return groupById(t.root, t.focused) ?? groupsOf(t.root)[0]!;
-}
-
-/**
- * The tab the panel shows: the focused group's pick, else its first.
- *
- * @param t - The stored tree.
- */
-export function activeTabOf(t: PanelTree): string | null {
-  const g = focusedGroup(t);
-  return g.active ?? g.tabs[0] ?? null;
-}
-
-function withRoot(t: PanelTree, root: PanelNode, focused = t.focused, seq = t.seq): PanelTree {
-  const f = groupById(root, focused) ? focused : groupsOf(root)[0]!.id;
-  return root === t.root && f === t.focused && seq === t.seq ? t : { root, focused: f, seq };
-}
-
-/**
- * Show `tabId` in its group and focus that group (no-op when the tree lacks it).
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- */
-export function focusTab(t: PanelTree, tabId: string): PanelTree {
-  const group = findGroup(t.root, tabId);
-  return group ? withRoot(t, activateTab(t.root, tabId), group.id) : t;
-}
-
-/**
- * Add `tabId` to `groupId` (default: the focused group) unless the tree has it.
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- * @param groupId - The group it joins.
- */
-export function pinTab(t: PanelTree, tabId: string, groupId?: string): PanelTree {
-  return withRoot(t, pinNodeTab(t.root, tabId, groupId ?? t.focused));
-}
-
-/**
- * Pin `tabId` (into `groupId`, default the focused group) and show it.
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- * @param groupId - The group it joins when the tree lacks it.
- */
-export function pickTab(t: PanelTree, tabId: string, groupId?: string): PanelTree {
-  return focusTab(pinTab(t, tabId, groupId), tabId);
-}
-
-/**
- * Remove a tab. A group left empty collapses; when it was focused, the group before it takes the focus.
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- */
-export function closeTab(t: PanelTree, tabId: string): PanelTree {
-  const before = groupsOf(t.root);
-  const root = closeNodeTab(t.root, tabId);
-  if (root === t.root || groupById(root, t.focused)) return withRoot(t, root);
-  const i = before.findIndex((g) => g.id === t.focused);
-  const survivor = before
-    .slice(0, Math.max(0, i))
-    .reverse()
-    .find((g) => groupById(root, g.id));
-  return withRoot(t, root, survivor?.id ?? groupsOf(root)[0]!.id);
-}
-
-/**
- * `tabId` moved `delta` slots within `visible` (its group's tabs on screen, in order); hidden tabs keep theirs.
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- * @param visible - Its group's tabs on screen, in order.
- * @param delta - Slots to move: negative is left.
- */
-export function moveTabBy(t: PanelTree, tabId: string, visible: readonly string[], delta: number): PanelTree {
-  const group = findGroup(t.root, tabId);
-  const from = visible.indexOf(tabId);
-  if (!group || from < 0) return t;
-  const to = Math.max(0, Math.min(visible.length - 1, from + delta));
-  if (to === from) return t;
-  const order = visible.filter((id) => id !== tabId);
-  order.splice(to, 0, tabId);
-  return withRoot(t, setGroupTabs(t.root, group.id, fillSlots(group.tabs, order)));
-}
-
-/** `order` (the visible tabs) laid into `tabs`' slots; tabs not in it keep their slots. */
-function fillSlots(tabs: readonly string[], order: readonly string[]): string[] {
-  const shown = new Set(order);
-  let next = 0;
-  return tabs.map((id) => (shown.has(id) ? order[next++]! : id));
-}
-
-/**
- * A dragged tab dropped. On its own strip it is a reorder: nothing else
- * changes (the group keeps showing what it showed). Anywhere else it moves
- * (or splits off) and is shown, focused, where it lands.
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- * @param to - Where it was dropped.
- */
-export function dropTab(t: PanelTree, tabId: string, to: TabDrop): PanelTree {
-  const from = findGroup(t.root, tabId);
-  const target = groupById(t.root, to.groupId);
-  if (!from || !target) return t;
-  if ('before' in to) {
-    if (from.id !== target.id)
-      return focusTab(withRoot(t, moveTab(t.root, tabId, target.id, insertAt(target.tabs, tabId, to.before))), tabId);
-    const rest = target.tabs.filter((id) => id !== tabId);
-    return withRoot(t, setGroupTabs(t.root, target.id, insertBefore(rest, tabId, to.before)));
-  }
-  const ids = newIds(t);
-  return focusTab(withSeq(t, dropOnGroup(t.root, tabId, target.id, to.zone, ids), ids), tabId);
-}
-
-/**
- * Take `tabId` out into a new group beside (`right`) or below (`bottom`) its own, focused.
- *
- * @param t - The stored tree.
- * @param tabId - The tab.
- * @param side - Where the new group goes.
- */
-export function splitTab(t: PanelTree, tabId: string, side: SplitSide): PanelTree {
-  const ids = newIds(t);
-  return focusTab(withSeq(t, splitNodeTab(t.root, tabId, side, undefined, ids), ids), tabId);
-}
-
-/**
- * New shares for split `splitId` as shown: `shown` lists each shown child's group ids (`resizeShownSplit`).
- *
- * @param t - The stored tree.
- * @param splitId - The split.
- * @param shown - Each shown child's group ids.
- * @param sizes - The shown children's new shares.
- */
-export function resizeSplit(
-  t: PanelTree,
-  splitId: string,
-  shown: readonly (readonly string[])[],
-  sizes: readonly number[],
-): PanelTree {
-  return withRoot(t, resizeShownSplit(t.root, splitId, shown, sizes));
-}
-
-function newIds(t: PanelTree): NewIds {
-  return { group: `g${t.seq}`, split: `s${t.seq + 1}` };
-}
-
-/** The new root, the counter moved past `ids` when the operation used them. */
-function withSeq(t: PanelTree, root: PanelNode, ids: NewIds): PanelTree {
-  return withRoot(t, root, t.focused, groupById(root, ids.group) ? t.seq + 2 : t.seq);
-}
-
-function insertAt(tabs: readonly string[], tabId: string, before: string | null): number {
-  const rest = tabs.filter((id) => id !== tabId);
-  const at = before === null ? -1 : rest.indexOf(before);
-  return at < 0 ? rest.length : at;
-}
-
-function insertBefore(rest: readonly string[], tabId: string, before: string | null): string[] {
-  const out = [...rest];
-  out.splice(insertAt(rest, tabId, before), 0, tabId);
-  return out;
-}
-
-/**
- * A stored panel tree, validated. Older layouts migrate once, on read: a bare
- * group tree (no focus, no counter) and, before groups, the flat strip
- * (`panelTabs` + `panelActiveId`), which becomes one group.
- *
- * @param raw - What was stored.
- * @param legacy - The flat strip an older record kept, used when `raw` has no tree.
- */
-export function parsePanelTree(raw: unknown, legacy: { tabs: readonly string[]; active: string | null }): PanelTree {
-  const o = raw && typeof raw === 'object' ? (raw as Record<string, unknown>) : null;
-  const bare = o && 'root' in o ? null : parseTree(raw);
-  const root = o && 'root' in o ? parseTree(o.root) : bare;
-  if (!root) return panelTreeOf(legacy.tabs, legacy.active);
-  const seq = nextSeq(root, typeof o?.seq === 'number' && Number.isInteger(o.seq) ? o.seq : 1);
-  const focused = typeof o?.focused === 'string' && groupById(root, o.focused) ? o.focused : groupsOf(root)[0]!.id;
-  const tree: PanelTree = { root, focused, seq };
-  return bare && legacy.active ? focusTab(tree, legacy.active) : tree;
-}

package/src/workspace/headless/resolve.ts

@@ -1,146 +0,0 @@
-/**
- * The window's horizontal budget: sidebar | chat | side panel.
- *
- * The chat never drops below its floor (`CHAT_MIN`). When the wanted widths do not fit,
- * give way in this order: shrink the panel to its minimum, shrink the
- * sidebar to its minimum, float the panel over the chat (`overlay`), and
- * finally collapse the sidebar. Pure; the App applies the result.
- *
- * A panel dragged wider than that floor allows is kept as a share of the
- * room beside the sidebar (`panel.share`): it follows the window's width,
- * and the chat's floor drops to `CHAT_MIN_SHARE` of the window.
- */
-export const CHAT_MIN = 480;
-/** The chat's floor once the user has dragged the panel past `CHAT_MIN`. */
-export const CHAT_MIN_SHARE = 0.1;
-/** A floating panel always leaves this much of the chat visible to click on. */
-export const OVERLAY_CHAT_PEEK = 160;
-
-/** What {@link resolveLayout} fits: the window, and each column's wanted width and floor. */
-export interface LayoutWants {
-  /** The window's width (px). */
-  windowWidth: number;
-  /** The sidebar: shown, its wanted width, its minimum. */
-  sidebar: { open: boolean; width: number; min: number };
-  /** `share`: the panel's share of the window minus the sidebar, set when dragged past `CHAT_MIN`. */
-  panel: { open: boolean; width: number; min: number; share?: number | null };
-}
-
-/**
- * The narrowest the chat may get with `share` set or not.
- *
- * @param windowWidth - The window's width (px).
- * @param wide - The panel was dragged past `CHAT_MIN` (its `share` is set).
- */
-export function chatFloor(windowWidth: number, wide: boolean): number {
-  return wide ? Math.ceil(windowWidth * CHAT_MIN_SHARE) : CHAT_MIN;
-}
-
-/** The columns' effective widths and modes. */
-export interface LayoutResolved {
-  /** The sidebar's width (px); 0 when closed. */
-  sidebarWidth: number;
-  /** The sidebar had to close for the chat to fit. */
-  sidebarForcedCollapsed: boolean;
-  /** The panel's width (px): the room it takes docked, its drawn width floating; 0 when closed. */
-  panelWidth: number;
-  /** `overlay`: drawn over the chat at its wanted width instead of taking room. */
-  panelMode: 'docked' | 'overlay';
-  /** The room left to the chat (px). */
-  chatWidth: number;
-  /** The floor the chat was held to (`chatFloor`). */
-  chatMin: number;
-}
-
-/**
- * Fits the sidebar, the chat and the side panel into the window (see the module comment for the order things give).
- *
- * @param w - The window's width and each column's wanted width.
- */
-export function resolveLayout(w: LayoutWants): LayoutResolved {
-  const sidebarWanted = w.sidebar.open ? w.sidebar.width : 0;
-  const wide = w.panel.open && w.panel.share != null;
-  const chatMin = chatFloor(w.windowWidth, wide);
-  const panelWanted = !w.panel.open
-    ? 0
-    : wide
-      ? Math.round(w.panel.share! * (w.windowWidth - sidebarWanted))
-      : w.panel.width;
-  let sidebar = sidebarWanted;
-  let panel = panelWanted;
-  const room = () => w.windowWidth - sidebar - panel;
-
-  if (room() < chatMin && w.panel.open)
-    panel = Math.max(w.panel.min, Math.min(panel, w.windowWidth - sidebar - chatMin));
-  if (room() < chatMin && w.sidebar.open)
-    sidebar = Math.max(w.sidebar.min, Math.min(sidebar, w.windowWidth - panel - chatMin));
-
-  let panelMode: LayoutResolved['panelMode'] = 'docked';
-  if (room() < chatMin && w.panel.open) {
-    panelMode = 'overlay';
-    panel = 0;
-    // With the panel floating, the sidebar can take its wanted width again.
-    sidebar = w.sidebar.open ? Math.max(w.sidebar.min, Math.min(sidebarWanted, w.windowWidth - chatMin)) : 0;
-  }
-  let sidebarForcedCollapsed = false;
-  if (room() < chatMin && w.sidebar.open) {
-    sidebarForcedCollapsed = true;
-    sidebar = 0;
-  }
-
-  return {
-    sidebarWidth: sidebar,
-    sidebarForcedCollapsed,
-    panelWidth:
-      panelMode === 'overlay'
-        ? Math.max(w.panel.min, Math.min(panelWanted, w.windowWidth - sidebar - OVERLAY_CHAT_PEEK))
-        : panel,
-    panelMode,
-    chatWidth: Math.max(0, w.windowWidth - sidebar - panel),
-    chatMin,
-  };
-}
-
-/**
- * The width a panel opens at when its project never sized it: half the room
- * the sidebar leaves, so the panel and the chat start side by side at 50/50.
- * A plain width, recomputed as the window changes: the chat's floor still
- * squeezes it, then floats it, in a narrow window.
- *
- * @param windowWidth - The window's width (px).
- * @param sidebarWidth - The sidebar's width (px), 0 when closed.
- * @param min - The panel's minimum (px).
- */
-export function splitPanelWidth(windowWidth: number, sidebarWidth: number, min: number): number {
-  return Math.max(min, Math.round((windowWidth - sidebarWidth) / 2));
-}
-
-/**
- * Largest width a column may take while the chat keeps `chatMin`.
- *
- * @param windowWidth - The window's width (px).
- * @param otherColumn - The other column's width (px).
- * @param hardMax - The column's own maximum (px).
- * @param chatMin - The chat's floor (px).
- */
-export function maxColumnWidth(windowWidth: number, otherColumn: number, hardMax: number, chatMin = CHAT_MIN): number {
-  return Math.max(0, Math.min(hardMax, windowWidth - otherColumn - chatMin));
-}
-
-/**
- * What a panel drag to `width` saves: past the usual chat floor it becomes a
- * share of the room beside the sidebar, otherwise a plain width.
- *
- * @param windowWidth - The window's width (px).
- * @param sidebarWidth - The sidebar's width (px).
- * @param width - Where the drag ended (px).
- */
-export function panelDragResult(
-  windowWidth: number,
-  sidebarWidth: number,
-  width: number,
-): { panelWidth: number; panelShare: number | null } {
-  const room = windowWidth - sidebarWidth;
-  const share = room - width < CHAT_MIN && room > 0 ? Math.round((width / room) * 1000) / 1000 : null;
-  return { panelWidth: width, panelShare: share };
-}

package/src/workspace/headless/reveal-at.ts

@@ -1,27 +0,0 @@
-/**
- * A position to reveal once the Files tab opens a file handed over through
- * the panel (terminal links: `src/app.ts:12:5`). Keyed by the absolute path
- * so a stale entry never lands on another file. One queue per window.
- */
-const pending = new Map<string, { line: number; column: number }>();
-
-/**
- * Remembers where to reveal `absPath` when the Files tab opens it next.
- *
- * @param absPath - The file's absolute path.
- * @param at - The position (1-based; the column defaults to 1).
- */
-export function setPendingReveal(absPath: string, at: { line: number; column?: number }): void {
-  pending.set(absPath, { line: at.line, column: at.column ?? 1 });
-}
-
-/**
- * The position waiting for `absPath`, removed as it is returned; `null` when none waits.
- *
- * @param absPath - The file's absolute path.
- */
-export function takePendingReveal(absPath: string): { line: number; column: number } | null {
-  const at = pending.get(absPath) ?? null;
-  pending.delete(absPath);
-  return at;
-}

package/src/workspace/headless/strip-drop.ts

@@ -1,81 +0,0 @@
-/**
- * Where a tab dragged over a strip lands, and where one dropped on a group's
- * body does, under the band that takes no drop. Pure: the strip reads its
- * pills' layout positions (offsets, never `getBoundingClientRect`, which
- * includes a pill's in-flight reorder transform and would flip the answer
- * back and forth mid-slide).
- */
-import { dropTarget, type DropZone } from './tree';
-
-/** A viewport rectangle. */
-export interface Rect {
-  left: number;
-  top: number;
-  width: number;
-  height: number;
-}
-
-/** A viewport point. */
-export interface Point {
-  x: number;
-  y: number;
-}
-
-/** The part of a rect a zone stands for: a half for an edge, all of it for the center. */
-export function zoneRect(r: Rect, zone: DropZone): Rect {
-  switch (zone) {
-    case 'left':
-      return { ...r, width: r.width / 2 };
-    case 'right':
-      return { ...r, left: r.left + r.width / 2, width: r.width / 2 };
-    case 'top':
-      return { ...r, height: r.height / 2 };
-    case 'bottom':
-      return { ...r, top: r.top + r.height / 2, height: r.height / 2 };
-    default:
-      return r;
-  }
-}
-
-/** A pill's layout box along the strip, in viewport x. */
-export interface PillSlot {
-  id: string;
-  left: number;
-  width: number;
-}
-
-/**
- * The tab a drop at `x` goes before: the first pill whose middle is right
- * of it; null (the end) past the last, or right of the track's visible
- * edge `end` (a scrolled strip's `+` and buttons append too).
- */
-export function insertBefore(pills: readonly PillSlot[], x: number, end = Infinity): string | null {
-  if (x >= end) return null;
-  return pills.find((p) => p.left < end && x < p.left + p.width / 2)?.id ?? null;
-}
-
-/** The viewport x of the caret marking a drop before `before` (null: after the last pill), kept inside the track. */
-export function caretX(
-  pills: readonly PillSlot[],
-  before: string | null,
-  track: { left: number; right: number },
-): number {
-  const at = before === null ? -1 : pills.findIndex((p) => p.id === before);
-  const last = pills[pills.length - 1];
-  const x = at >= 0 ? pills[at]!.left - 3 : last ? last.left + last.width + 3 : track.left + 4;
-  return Math.min(Math.max(x, track.left + 1), track.right - 1);
-}
-
-/** Height (px) of the band under a strip where a drop does nothing: aiming at the strip a little low never splits. */
-export const DEAD_BAND = 24;
-
-/**
- * A tab dropped on a group's body at `p`: nothing in the band, else the
- * zone of the body below it (the band never eats a short group's top zone).
- * The preview is the part of the whole body the drop takes.
- */
-export function bodyDrop(body: Rect, p: Point): { zone: DropZone; preview: Rect } | null {
-  if (p.y < body.top + DEAD_BAND) return null;
-  const zone = dropTarget({ ...body, top: body.top + DEAD_BAND, height: body.height - DEAD_BAND }, p);
-  return { zone, preview: zoneRect(body, zone) };
-}