saterminal 0.3.2 → 0.5.0

package/src/tui/app.ts

@@ -1,134 +0,0 @@
-import { defaultFocus } from "../focus.ts";
-import { ensureStateFiles, loadAttempts, loadFocus, stateDirExists } from "../state.ts";
-import { handleKey, loadNextQuestion } from "./input.ts";
-import { createFrameRenderer, render } from "./render.ts";
-import { term } from "./kit.ts";
-import type { AppState, KeyData } from "./types.ts";
-import type { Attempt } from "../types.ts";
-
-export type TuiOptions = {
-  mode?: "practice" | "review";
-};
-
-async function loadPersistedState(state: AppState, options: TuiOptions = {}): Promise<void> {
-  await ensureStateFiles();
-  state.attempts = await loadAttempts();
-  state.focus = await loadFocus();
-  state.focusIndex = 1;
-  state.focusColumn = 0;
-  state.focusRow = 1;
-  state.notice = undefined;
-
-  if (options.mode === "review") {
-    state.reviewMode = true;
-    state.reviewQuestionIds = reviewQuestionIds(state.attempts);
-    if (state.reviewQuestionIds.length === 0) {
-      state.notice = "No review queue yet. Miss or correct a question first.";
-      state.view = "history";
-      return;
-    }
-
-    await loadNextQuestion(state);
-    return;
-  }
-
-  state.view = "focus";
-}
-
-export async function runTui(options: TuiOptions = {}): Promise<void> {
-  const state: AppState = {
-    attempts: new Map(),
-    skippedIds: new Set(),
-    reviewMode: options.mode === "review",
-    focus: defaultFocus,
-    focusIndex: 1,
-    focusColumn: 0,
-    focusRow: 1,
-    view: "loading",
-    selected: 0,
-    questionScroll: 0,
-    answerScroll: 0,
-    activePane: "answers",
-    elapsedMs: 0,
-    timerPaused: false,
-    timerHidden: false,
-    historyIndex: 0,
-  };
-
-  term.fullscreen(true);
-  term.hideCursor();
-  term.grabInput(true);
-  const renderer = createFrameRenderer();
-  renderer.clear();
-  const tick = setInterval(() => {
-    if (state.view === "practice" && !state.timerPaused) {
-      render(renderer, state);
-    }
-  }, 1000);
-
-  const cleanup = () => {
-    clearInterval(tick);
-    term.grabInput(false);
-    term.hideCursor(false);
-    term.fullscreen(false);
-    term.processExit(0);
-  };
-
-  process.on("SIGINT", cleanup);
-  term.on("resize", () => {
-    renderer.clear();
-    render(renderer, state);
-  });
-
-  try {
-    if (await stateDirExists()) {
-      await loadPersistedState(state, options);
-    } else {
-      state.view = "setup";
-    }
-  } catch (error) {
-    state.view = "error";
-    state.error = error instanceof Error ? error.message : String(error);
-  }
-
-  render(renderer, state);
-
-  term.on("key", async (name: string, _matches?: string[], data?: KeyData) => {
-    try {
-      if (name === "CTRL_C" || name === "q") {
-        cleanup();
-        return;
-      }
-
-      if (state.view === "setup") {
-        if (name === "y" || name === "ENTER") {
-          await loadPersistedState(state, options);
-        } else if (name === "n") {
-          cleanup();
-          return;
-        }
-
-        render(renderer, state);
-        return;
-      }
-
-      await handleKey(state, name, data);
-      render(renderer, state);
-    } catch (error) {
-      state.view = "error";
-      state.error = error instanceof Error ? error.message : String(error);
-      render(renderer, state);
-    }
-  });
-}
-
-function reviewQuestionIds(attempts: Map<string, Attempt>): string[] {
-  return [...attempts.values()]
-    .filter((attempt) => attempt.outcome === "incorrect" || attempt.outcome === "corrected")
-    .sort((a, b) => reviewPriority(a) - reviewPriority(b) || a.updated_at.localeCompare(b.updated_at))
-    .map((attempt) => attempt.question_id);
-}
-
-function reviewPriority(attempt: Attempt): number {
-  return attempt.outcome === "incorrect" ? 0 : 1;
-}

package/src/tui/focus-grid.ts

@@ -1,113 +0,0 @@
-import {
-  difficultyLabels,
-  difficultyOptions,
-  domainLabels,
-  domainOptions,
-  skillsForDomain,
-  skillLabels,
-  toggleFocusRow,
-  type FocusRow,
-} from "../focus.ts";
-import type { Domain, Focus, Skill } from "../types.ts";
-
-export type FocusGridRow = Extract<FocusRow, { kind: "option" }>;
-
-export type FocusGridColumn = {
-  id: "difficulty" | Domain;
-  title: string;
-  rows: FocusGridRow[];
-};
-
-export type FocusGridPosition = {
-  column: number;
-  row: number;
-};
-
-export function focusGrid(focus: Focus): FocusGridColumn[] {
-  return [
-    {
-      id: "difficulty",
-      title: "Difficulty",
-      rows: difficultyOptions.map((value) => ({
-        kind: "option",
-        group: "difficulties",
-        value,
-        label: `${value}  ${difficultyLabels[value]}`,
-        checked: focus.difficulties.includes(value),
-        depth: 0,
-      })),
-    },
-    ...domainOptions.map((domain) => domainColumn(domain, focus)),
-  ];
-}
-
-export function normalizeFocusGridPosition(columns: FocusGridColumn[], position: FocusGridPosition): FocusGridPosition {
-  const column = clamp(position.column, 0, Math.max(0, columns.length - 1));
-  const row = clamp(position.row, 0, Math.max(0, (columns[column]?.rows.length ?? 1) - 1));
-  return { column, row };
-}
-
-export function moveFocusGridPosition(
-  columns: FocusGridColumn[],
-  position: FocusGridPosition,
-  direction: "up" | "down" | "next" | "previous",
-): FocusGridPosition {
-  const current = normalizeFocusGridPosition(columns, position);
-
-  if (direction === "up") {
-    return { ...current, row: Math.max(0, current.row - 1) };
-  }
-
-  if (direction === "down") {
-    return { ...current, row: Math.min(columns[current.column].rows.length - 1, current.row + 1) };
-  }
-
-  const delta = direction === "previous" ? -1 : 1;
-  const column = (current.column + delta + columns.length) % columns.length;
-  return normalizeFocusGridPosition(columns, { column, row: current.row });
-}
-
-export function selectedFocusGridRow(focus: Focus, position: FocusGridPosition): FocusGridRow {
-  const columns = focusGrid(focus);
-  const current = normalizeFocusGridPosition(columns, position);
-  return columns[current.column].rows[current.row];
-}
-
-export function toggleFocusGridRow(focus: Focus, position: FocusGridPosition): Focus {
-  return toggleFocusRow(focus, selectedFocusGridRow(focus, position));
-}
-
-function domainColumn(domain: Domain, focus: Focus): FocusGridColumn {
-  const skills = skillsForDomain(domain);
-  const selected = skills.filter((skill) => focus.skills.includes(skill));
-  const checked = selected.length > 0;
-  const partial = checked && selected.length < skills.length;
-
-  return {
-    id: domain,
-    title: `${domain}  ${domainLabels[domain]}`,
-    rows: [
-      {
-        kind: "option",
-        group: "domains",
-        value: domain,
-        label: "All skills",
-        checked,
-        partial,
-        depth: 0,
-      },
-      ...skills.map((skill) => ({
-        kind: "option" as const,
-        group: "skills" as const,
-        value: skill as Skill,
-        label: `${skill}  ${skillLabels[skill]}`,
-        checked: focus.skills.includes(skill),
-        depth: 1,
-      })),
-    ],
-  };
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}

package/src/tui/frame.ts

@@ -1,210 +0,0 @@
-import type { Terminal } from "terminal-kit";
-
-export type TextAttr = Record<string, unknown>;
-
-type FrameCell = {
-  char: string;
-  attr: TextAttr;
-};
-
-export type FrameRun = {
-  x: number;
-  text: string;
-  attr: TextAttr;
-};
-
-export type FrameOutput = {
-  clear(): void;
-  moveTo(x: number, y: number): void;
-  eraseLineAfter(): void;
-  reset(): void;
-  write(value: string, attr?: TextAttr): void;
-};
-
-const emptyAttr: TextAttr = {};
-
-export class Frame {
-  readonly rows: FrameCell[][];
-
-  constructor(readonly width: number, readonly height: number) {
-    this.rows = Array.from({ length: height }, () => []);
-  }
-
-  writeText(x: number, y: number, value: string, attr: TextAttr = {}, width = this.width - x): void {
-    if (y < 0 || y >= this.height || x >= this.width || width <= 0) {
-      return;
-    }
-
-    const start = Math.max(0, x);
-    const content = truncate(value, width);
-    if (!content) {
-      return;
-    }
-
-    const row = this.rows[y];
-    const chars = [...content].slice(Math.max(0, -x), Math.max(0, -x) + this.width - start);
-    for (const [offset, char] of chars.entries()) {
-      row[start + offset] = { char, attr };
-    }
-  }
-
-  rowRuns(y: number): FrameRun[] {
-    const row = this.rows[y] ?? [];
-    const runs: FrameRun[] = [];
-    let x = 0;
-
-    while (x < this.width) {
-      while (x < this.width && cellAt(row, x).char === " ") {
-        x++;
-      }
-
-      if (x >= this.width) {
-        break;
-      }
-
-      const start = x;
-      const attr = cellAt(row, x).attr;
-      const key = attrKey(attr);
-      const chars: string[] = [];
-
-      while (x < this.width && attrKey(cellAt(row, x).attr) === key) {
-        chars.push(cellAt(row, x).char);
-        x++;
-      }
-
-      const text = chars.join("").trimEnd();
-      if (text) {
-        runs.push({ x: start, text, attr });
-      }
-    }
-
-    return runs;
-  }
-
-  rowKey(y: number): string {
-    return this.rowRuns(y)
-      .map((run) => `${run.x}:${attrKey(run.attr)}:${run.text}`)
-      .join("\u001f");
-  }
-}
-
-export class FrameRenderer {
-  private previous?: {
-    width: number;
-    height: number;
-    rowKeys: string[];
-  };
-  private cleared = false;
-
-  constructor(private readonly output: FrameOutput) {}
-
-  clear(): void {
-    this.previous = undefined;
-    this.cleared = true;
-    this.output.reset();
-    this.output.clear();
-  }
-
-  draw(frame: Frame): void {
-    const rowKeys = Array.from({ length: frame.height }, (_, y) => frame.rowKey(y));
-    const force = !this.previous || this.previous.width !== frame.width || this.previous.height !== frame.height;
-    if (force && !this.cleared) {
-      this.output.reset();
-      this.output.clear();
-    }
-
-    const previous = force ? undefined : this.previous;
-    let changed = false;
-    for (let y = 0; y < frame.height; y++) {
-      if (previous && previous.rowKeys[y] === rowKeys[y]) {
-        continue;
-      }
-      if (!previous && !rowKeys[y]) {
-        continue;
-      }
-
-      this.output.moveTo(1, y + 1);
-      if (previous) {
-        this.output.reset();
-        this.output.eraseLineAfter();
-      }
-
-      for (const run of frame.rowRuns(y)) {
-        this.output.moveTo(run.x + 1, y + 1);
-        this.output.write(run.text, run.attr);
-      }
-      changed = true;
-    }
-
-    if (changed) {
-      this.output.reset();
-    }
-    this.previous = { width: frame.width, height: frame.height, rowKeys };
-    this.cleared = false;
-  }
-}
-
-type StyledTerminal = Terminal & Record<string, Terminal>;
-
-export class TerminalFrameOutput implements FrameOutput {
-  constructor(private readonly terminal: Terminal) {}
-
-  clear(): void {
-    this.terminal.clear();
-  }
-
-  moveTo(x: number, y: number): void {
-    this.terminal.moveTo(x, y);
-  }
-
-  eraseLineAfter(): void {
-    this.terminal.eraseLineAfter();
-  }
-
-  reset(): void {
-    this.terminal.styleReset();
-  }
-
-  write(value: string, attr: TextAttr = {}): void {
-    let output = this.terminal as StyledTerminal;
-
-    if (attr.bold) {
-      output = output.bold as StyledTerminal;
-    }
-    if (attr.underline) {
-      output = output.underline as StyledTerminal;
-    }
-    if (attr.italic) {
-      output = output.italic as StyledTerminal;
-    }
-
-    const color = typeof attr.color === "string" ? attr.color : undefined;
-    if (color && typeof output[color] === "function") {
-      output = output[color] as StyledTerminal;
-    }
-
-    output(value);
-  }
-}
-
-export function truncate(value: string, width: number): string {
-  const chars = [...value];
-  if (chars.length <= width) {
-    return value;
-  }
-  if (width <= 1) {
-    return chars.slice(0, width).join("");
-  }
-  return `${chars.slice(0, width - 1).join("")}…`;
-}
-
-function cellAt(row: FrameCell[], x: number): FrameCell {
-  return row[x] ?? { char: " ", attr: emptyAttr };
-}
-
-function attrKey(attr: TextAttr): string {
-  return Object.keys(attr)
-    .sort()
-    .map((key) => `${key}:${String(attr[key])}`)
-    .join(";");
-}

package/src/tui/history.ts

@@ -1,6 +0,0 @@
-import type { Attempt } from "../types.ts";
-import type { AppState } from "./types.ts";
-
-export function historyRows(state: AppState): Attempt[] {
-  return [...state.attempts.values()].sort((a, b) => b.updated_at.localeCompare(a.updated_at));
-}