pi-weave 0.3.0 → 0.3.2

package/src/web/client/shell/Header.tsx

@@ -1,119 +0,0 @@
-/**
- * The header bar (weave-workspace §1.2).
- *
- * Title, the `⌘K` search button, the `vault:N · repo:… · N nodes` summary,
- * the refresh button. Every string comes from `shell.model.ts`.
- *
- * The search control was `disabled` through P1–P3 because search was P4 and
- * an affordance that looks live but is not would be the dishonest option. P4
- * landed, so it is live — and it is a `<button>`, not an `<input>`: the
- * palette owns the only text field in the workspace, and a header box you
- * could type into whose contents were then thrown away when the overlay
- * opened would be a worse lie than the disabled version it replaced.
- */
-
-import { useState } from "preact/hooks";
-import { LOGO_MARK_B64, LOGO_MARK_MIME } from "../../shared/logo";
-import type { ThemeButtonView } from "./theme.model";
-import type { HeaderSummary } from "./shell.model";
-import { REFRESH_ICON_PATHS, SEARCH_PLACEHOLDER, searchHint, summaryParts } from "./shell.model";
-
-export interface HeaderProps {
-  summary: HeaderSummary;
-  shortcut: string;
-  onRefresh: () => void;
-  /** Opens the ⌘K palette. The same action the global key performs. */
-  onSearch: () => void;
-  /** The theme control's face (glyph + hint), from `shell.model.ts`'s friend in `theme.model.ts`. */
-  theme: ThemeButtonView;
-  /** Advance the theme choice one step in its cycle. The same action the `t` key performs. */
-  onTheme: () => void;
-}
-
-/**
- * The refresh control, drawn rather than typed.
- *
- * The `⟳` it replaces was a text character, so its weight and shape were
- * whatever the platform's font felt like — the one glyph in the header that
- * the theme did not own. These two strokes (`REFRESH_ICON_PATHS`, in
- * `shell.model.ts`) are stroked in `currentColor`, so hover recolours them
- * like any other text glyph.
- *
- * The spin is one 600 ms turn on click, restarted only by the next click —
- * it says "the request left", which is the truth, and stops rather than
- * pretending to know when the refetch lands (the refetch is fire-and-forget
- * by §7's register, and a spinner that waits for a signal a 304 may never
- * fire would hang forever). Reduced-motion users get the static glyph back,
- * as everywhere else in the sheet.
- */
-function RefreshButton({ onRefresh }: { onRefresh: () => void }) {
-  const [spinning, setSpinning] = useState(false);
-  return (
-    <button
-      type="button"
-      class="weave-refresh"
-      onClick={() => {
-        onRefresh();
-        setSpinning(true);
-      }}
-      onAnimationEnd={() => setSpinning(false)}
-      title="Refetch everything"
-      aria-busy={spinning ? "true" : undefined}
-    >
-      <svg
-        class={spinning ? "weave-refresh-glyph weave-refresh-spinning" : "weave-refresh-glyph"}
-        viewBox="0 0 24 24"
-        width={14}
-        height={14}
-        fill="none"
-        stroke="currentColor"
-        stroke-width={2}
-        stroke-linecap="round"
-        stroke-linejoin="round"
-        aria-hidden="true"
-      >
-        {REFRESH_ICON_PATHS.map((d) => (
-          <path key={d} d={d} />
-        ))}
-      </svg>
-    </button>
-  );
-}
-
-export function Header(props: HeaderProps) {
-  return (
-    <header class="weave-header">
-      <span class="weave-brand">
-        <img
-          class="weave-brand-mark"
-          src={`data:${LOGO_MARK_MIME};base64,${LOGO_MARK_B64}`}
-          alt=""
-          width={18}
-          height={18}
-        />
-        pi-weave
-      </span>
-      <button type="button" class="weave-search" title={searchHint(props.shortcut)} onClick={props.onSearch}>
-        <span class="weave-search-text">{SEARCH_PLACEHOLDER}</span>
-        <kbd>{props.shortcut}</kbd>
-      </button>
-      <span class="weave-summary">
-        {summaryParts(props.summary).map((part) => (
-          <span key={part} class="weave-summary-part">
-            {part}
-          </span>
-        ))}
-      </span>
-      <button
-        type="button"
-        class="weave-theme"
-        onClick={props.onTheme}
-        title={props.theme.hint}
-        aria-label={props.theme.hint}
-      >
-        {props.theme.glyph}
-      </button>
-      <RefreshButton onRefresh={props.onRefresh} />
-    </header>
-  );
-}

package/src/web/client/shell/drag.model.ts

@@ -1,35 +0,0 @@
-import { COLUMNS, resizeAt } from "./layout.model";
-import type { DividerId, LayoutState } from "./layout.model";
-
-export interface DragState { readonly divider: DividerId; readonly origin: number; readonly base: LayoutState }
-export function beginDrag(divider: DividerId, origin: number, base: LayoutState): DragState { return { divider, origin, base }; }
-export function dragTo(drag: DragState, clientX: number, available: number): LayoutState { return resizeAt(drag.base, drag.divider, clientX - drag.origin, available); }
-export function dragChanged(drag: DragState, final: LayoutState): boolean {
-  return COLUMNS.some((id) => drag.base.fractions[id] !== final.fractions[id]);
-}
-export const NUDGE_PX = 24;
-export function nudgeFor(key: string): number { return key === "ArrowLeft" ? -NUDGE_PX : key === "ArrowRight" ? NUDGE_PX : 0; }
-
-export function dividerHandlers(host: {
-  layout(): LayoutState;
-  width(): number;
-  setLayout(next: LayoutState): void;
-  persist(layout: LayoutState): void;
-}) {
-  let active: DragState | null = null;
-  return {
-    onDown(divider: DividerId, clientX: number) { active = beginDrag(divider, clientX, host.layout()); },
-    onMove(clientX: number) { if (active !== null) host.setLayout(dragTo(active, clientX, host.width())); },
-    onUp() {
-      const drag = active;
-      active = null;
-      if (drag !== null && dragChanged(drag, host.layout())) host.persist(host.layout());
-    },
-    onKey(divider: DividerId, key: string) {
-      const next = resizeAt(host.layout(), divider, nudgeFor(key), host.width());
-      if (next === host.layout()) return;
-      host.setLayout(next);
-      host.persist(next);
-    },
-  };
-}

package/src/web/client/shell/layout.model.ts

@@ -1,132 +0,0 @@
-/** Pure model for the resizable workspace columns. */
-
-export type ColumnId = "tree" | "note" | "graph";
-export const COLUMNS: readonly ColumnId[] = ["tree", "note", "graph"];
-export type Columns<T> = { readonly [K in ColumnId]: T };
-export const MIN_WIDTHS: Columns<number> = { tree: 180, note: 320, graph: 260 };
-export const DEFAULT_FRACTIONS: Columns<number> = { tree: 0.22, note: 0.46, graph: 0.32 };
-
-export type Breakpoint = "wide" | "medium" | "narrow";
-export const BREAKPOINT_MEDIUM = 1100;
-export const BREAKPOINT_NARROW = 800;
-
-export function breakpointFor(width: number): Breakpoint {
-  if (!Number.isFinite(width) || width < BREAKPOINT_NARROW) return "narrow";
-  return width < BREAKPOINT_MEDIUM ? "medium" : "wide";
-}
-
-export function columnsAt(breakpoint: Breakpoint): readonly ColumnId[] {
-  return breakpoint === "wide" ? COLUMNS : breakpoint === "medium" ? ["tree", "note"] : ["note"];
-}
-
-export function isCollapsed(breakpoint: Breakpoint, column: ColumnId): boolean {
-  return !columnsAt(breakpoint).includes(column);
-}
-
-export interface LayoutState { readonly fractions: Columns<number> }
-
-function normalizeOver(ids: readonly ColumnId[], fractions: Columns<number>, floors: Columns<number>): Columns<number> {
-  const clean: Record<ColumnId, number> = { tree: 0, note: 0, graph: 0 };
-  let total = 0;
-  for (const id of ids) {
-    const value = fractions[id];
-    clean[id] = Number.isFinite(value) && value > 0 ? value : DEFAULT_FRACTIONS[id];
-    total += clean[id];
-  }
-  for (const id of ids) clean[id] /= total;
-  let deficit = 0;
-  let slack = 0;
-  const atFloor: Record<ColumnId, boolean> = { tree: false, note: false, graph: false };
-  for (const id of ids) {
-    const floor = floors[id];
-    if (clean[id] < floor) {
-      deficit += floor - clean[id];
-      clean[id] = floor;
-      atFloor[id] = true;
-    } else slack += clean[id] - floor;
-  }
-  if (deficit > 0 && slack > 0) {
-    const rate = Math.min(deficit, slack) / slack;
-    for (const id of ids) if (!atFloor[id]) clean[id] -= (clean[id] - floors[id]) * rate;
-  }
-  return { tree: clean.tree, note: clean.note, graph: clean.graph };
-}
-
-export function normalizeFractions(fractions: Columns<number>, minShare: Columns<number>): Columns<number> {
-  return normalizeOver(COLUMNS, fractions, minShare);
-}
-
-export function minShares(available: number): Columns<number> {
-  const width = Number.isFinite(available) && available > 0 ? available : 1;
-  const raw = { tree: MIN_WIDTHS.tree / width, note: MIN_WIDTHS.note / width, graph: MIN_WIDTHS.graph / width };
-  const total = raw.tree + raw.note + raw.graph;
-  if (total <= 0.9) return raw;
-  const scale = 0.9 / total;
-  return { tree: raw.tree * scale, note: raw.note * scale, graph: raw.graph * scale };
-}
-
-export function makeLayout(fractions: Columns<number>, available: number): LayoutState {
-  return { fractions: normalizeFractions(fractions, minShares(available)) };
-}
-
-export function defaultLayout(available: number): LayoutState {
-  return makeLayout(DEFAULT_FRACTIONS, available);
-}
-
-export interface ResolvedColumn { readonly id: ColumnId; readonly width: number }
-
-export function resolveColumns(state: LayoutState, available: number, breakpoint: Breakpoint): readonly ResolvedColumn[] {
-  const width = Number.isFinite(available) && available > 0 ? available : 0;
-  const shares = normalizeOver(columnsAt(breakpoint), state.fractions, minShares(width));
-  return columnsAt(breakpoint).map((id) => ({ id, width: shares[id] * width }));
-}
-
-export type DividerId = "tree" | "note";
-export const DIVIDERS: readonly DividerId[] = ["tree", "note"];
-export function dividerPair(divider: DividerId): readonly [ColumnId, ColumnId] {
-  return divider === "tree" ? ["tree", "note"] : ["note", "graph"];
-}
-
-export function resizeAt(state: LayoutState, divider: DividerId, deltaPx: number, available: number): LayoutState {
-  const width = Number.isFinite(available) && available > 0 ? available : 0;
-  if (width === 0 || !Number.isFinite(deltaPx) || deltaPx === 0) return state;
-  const [left, right] = dividerPair(divider);
-  const floors = minShares(width);
-  const delta = Math.max(-(Math.max(0, state.fractions[left] - floors[left])), Math.min(Math.max(0, state.fractions[right] - floors[right]), deltaPx / width));
-  if (delta === 0) return state;
-  return { fractions: normalizeFractions({ ...state.fractions, [left]: state.fractions[left] + delta, [right]: state.fractions[right] - delta }, floors) };
-}
-
-export interface LayoutStorage { getItem(key: string): string | null; setItem(key: string, value: string): void }
-export const LAYOUT_STORAGE_KEY = "pi-weave.layout.v1";
-const round4 = (value: number): number => Math.round(value * 10000) / 10000;
-
-export function serializeLayout(state: LayoutState): string {
-  return JSON.stringify({ v: 1, tree: round4(state.fractions.tree), note: round4(state.fractions.note), graph: round4(state.fractions.graph) });
-}
-
-export function deserializeLayout(raw: string | null, available: number): LayoutState | null {
-  if (raw === null) return null;
-  let parsed: unknown;
-  try { parsed = JSON.parse(raw); } catch { return null; }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
-  const record = parsed as Record<string, unknown>;
-  if (record["v"] !== 1) return null;
-  const fractions = {} as Record<ColumnId, number>;
-  for (const id of COLUMNS) {
-    const value = record[id];
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
-    fractions[id] = value;
-  }
-  return makeLayout(fractions, available);
-}
-
-export function loadLayout(storage: LayoutStorage, available: number): LayoutState {
-  try { return deserializeLayout(storage.getItem(LAYOUT_STORAGE_KEY), available) ?? defaultLayout(available); }
-  catch { return defaultLayout(available); }
-}
-
-export function saveLayout(storage: LayoutStorage, state: LayoutState): boolean {
-  try { storage.setItem(LAYOUT_STORAGE_KEY, serializeLayout(state)); return true; }
-  catch { return false; }
-}