pi-weave 0.3.0 → 0.3.1

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; }
-}