tuiboard 0.5.0

package/src/store/parsers.ts

@@ -0,0 +1,243 @@
+/**
+ * Natural-language parsers for modal inputs.
+ *
+ * Date input shortcuts:
+ *   t                 → today
+ *   tm | tom          → tomorrow
+ *   -N                → N days ago
+ *   +N                → N days ahead
+ *   lun/mar/.../dom   → next weekday (Italian short)
+ *   mon/tue/.../sun   → next weekday (English short)
+ *   YYYY-MM-DD        → literal
+ *   DD                → next DD of current or next month
+ *   DD-MM             → DD of MM of current or next year
+ *   ""                → clear (returns undefined)
+ *
+ * Time-block input shortcuts:
+ *   n                 → now → now+30min
+ *   HH:MM             → HH:MM → HH:MM+30min
+ *   HH:MM-HH:MM       → literal range
+ *   HH:MM HH:MM       → range (space-separated)
+ *   -                 → clear (returns undefined)
+ *
+ * Quick-add task input: free text with inline metadata
+ *   "Fix auth @nazza t 9-11 #pr #urgent 🔺"
+ *   Parses the metadata tokens, leaves the rest as title.
+ */
+
+import { isoDate, isoToday, isoTomorrow } from "~/store/index";
+import type { PriorityLevel, TimeBlock } from "~/types";
+
+// ─── Date ────────────────────────────────────────────────────────────────────
+
+const WEEKDAYS_IT: Record<string, number> = {
+  dom: 0, lun: 1, mar: 2, mer: 3, gio: 4, ven: 5, sab: 6,
+};
+const WEEKDAYS_EN: Record<string, number> = {
+  sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6,
+};
+
+export function parseDateShortcut(input: string): string | undefined | null {
+  // Returns:
+  //   string         → ISO date
+  //   undefined      → clear date
+  //   null           → parse failed (caller shows error)
+  const s = input.trim().toLowerCase();
+  if (s === "") return undefined;
+  if (s === "-") return undefined;
+
+  if (s === "t" || s === "today" || s === "oggi") return isoToday();
+  if (s === "tm" || s === "tom" || s === "tomorrow" || s === "domani") return isoTomorrow();
+
+  // Relative ±N
+  const rel = s.match(/^([+-])(\d+)$/);
+  if (rel) {
+    const sign = rel[1] === "+" ? 1 : -1;
+    const n = parseInt(rel[2]!, 10);
+    const d = new Date();
+    d.setDate(d.getDate() + sign * n);
+    return isoDate(d);
+  }
+
+  // ISO YYYY-MM-DD
+  const iso = s.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+  if (iso) {
+    const d = new Date(
+      parseInt(iso[1]!, 10),
+      parseInt(iso[2]!, 10) - 1,
+      parseInt(iso[3]!, 10),
+    );
+    if (Number.isNaN(d.getTime())) return null;
+    return isoDate(d);
+  }
+
+  // DD-MM (current or next year if past)
+  const ddmm = s.match(/^(\d{1,2})-(\d{1,2})$/);
+  if (ddmm) {
+    const day = parseInt(ddmm[1]!, 10);
+    const mon = parseInt(ddmm[2]!, 10);
+    const now = new Date();
+    let candidate = new Date(now.getFullYear(), mon - 1, day);
+    if (Number.isNaN(candidate.getTime())) return null;
+    if (candidate < now) {
+      candidate = new Date(now.getFullYear() + 1, mon - 1, day);
+    }
+    return isoDate(candidate);
+  }
+
+  // DD only
+  const dd = s.match(/^(\d{1,2})$/);
+  if (dd) {
+    const day = parseInt(dd[1]!, 10);
+    if (day < 1 || day > 31) return null;
+    const now = new Date();
+    let candidate = new Date(now.getFullYear(), now.getMonth(), day);
+    if (candidate < now) {
+      candidate = new Date(now.getFullYear(), now.getMonth() + 1, day);
+    }
+    return isoDate(candidate);
+  }
+
+  // Weekday
+  const wd = WEEKDAYS_IT[s] ?? WEEKDAYS_EN[s];
+  if (wd !== undefined) {
+    const now = new Date();
+    const cur = now.getDay();
+    let delta = wd - cur;
+    if (delta <= 0) delta += 7;
+    const d = new Date();
+    d.setDate(d.getDate() + delta);
+    return isoDate(d);
+  }
+
+  return null;
+}
+
+// ─── Time block ──────────────────────────────────────────────────────────────
+
+export function parseTimeBlockShortcut(input: string): TimeBlock | undefined | null {
+  const s = input.trim();
+  if (s === "" || s === "-") return undefined;
+
+  if (s.toLowerCase() === "n" || s.toLowerCase() === "now") {
+    const now = new Date();
+    const start = now.getHours() * 60 + now.getMinutes();
+    return { startMin: start, endMin: Math.min(start + 30, 24 * 60) };
+  }
+
+  // HH:MM-HH:MM  or  HH:MM HH:MM  or  HHMM-HHMM (with - or space)
+  const range = s.match(/^(\d{1,2}):?(\d{2})\s*[- ]\s*(\d{1,2}):?(\d{2})$/);
+  if (range) {
+    return makeBlock(range[1]!, range[2]!, range[3]!, range[4]!);
+  }
+  // Loose `H-H` (e.g. "9-11") → 9:00 to 11:00
+  const hh = s.match(/^(\d{1,2})\s*[- ]\s*(\d{1,2})$/);
+  if (hh) {
+    return makeBlock(hh[1]!, "00", hh[2]!, "00");
+  }
+  // Single HH:MM → HH:MM to HH:MM+30
+  const single = s.match(/^(\d{1,2}):(\d{2})$/);
+  if (single) {
+    const start = parseInt(single[1]!, 10) * 60 + parseInt(single[2]!, 10);
+    return { startMin: start, endMin: Math.min(start + 30, 24 * 60) };
+  }
+  return null;
+}
+
+function makeBlock(h1: string, m1: string, h2: string, m2: string): TimeBlock | null {
+  const s = parseInt(h1, 10) * 60 + parseInt(m1, 10);
+  const e = parseInt(h2, 10) * 60 + parseInt(m2, 10);
+  if (!Number.isFinite(s) || !Number.isFinite(e)) return null;
+  if (s < 0 || s >= 24 * 60 || e < 0 || e > 24 * 60 || e <= s) return null;
+  return { startMin: s, endMin: e };
+}
+
+// ─── Quick add ───────────────────────────────────────────────────────────────
+
+export interface QuickAddResult {
+  title: string;
+  assignee?: string;
+  tags: string[];
+  scheduled?: string;
+  timeBlock?: TimeBlock;
+  priority: PriorityLevel;
+}
+
+/**
+ * Parse a free-form quick-add string. Recognized tokens:
+ *   @name        → assignee
+ *   #tag         → tag
+ *   t, tm, +N    → scheduled date shortcut
+ *   YYYY-MM-DD   → scheduled date literal
+ *   HH:MM-HH:MM  → time block (also sets scheduled to today if missing)
+ *   9-11         → 09:00-11:00 time block
+ *   🔺⏫🔼🔽⏬ → priority
+ *
+ * Tokens are stripped from the title. Order doesn't matter except that the
+ * first scheduling token wins.
+ */
+export function parseQuickAdd(input: string): QuickAddResult {
+  const result: QuickAddResult = {
+    title: "",
+    tags: [],
+    priority: "none",
+  };
+
+  // Match priority emoji first and remove
+  const priorityMap: Record<string, PriorityLevel> = {
+    "🔺": "highest",
+    "⏫": "high",
+    "🔼": "medium",
+    "🔽": "low",
+    "⏬": "lowest",
+  };
+  let s = input;
+  for (const [emoji, lvl] of Object.entries(priorityMap)) {
+    if (s.includes(emoji)) {
+      result.priority = lvl;
+      s = s.replaceAll(emoji, " ");
+    }
+  }
+
+  const tokens = s.split(/\s+/).filter(Boolean);
+  const remaining: string[] = [];
+
+  for (const tok of tokens) {
+    if (tok.startsWith("@") && tok.length > 1) {
+      result.assignee = tok.slice(1);
+      continue;
+    }
+    if (tok.startsWith("#") && tok.length > 1) {
+      result.tags.push(tok.slice(1));
+      continue;
+    }
+    // Time block: HH:MM-HH:MM or H-H
+    const tb = parseTimeBlockShortcut(tok);
+    if (tb && tb !== null) {
+      if (!result.timeBlock) {
+        result.timeBlock = tb;
+        if (!result.scheduled) result.scheduled = isoToday();
+      }
+      continue;
+    }
+    // Date: t, tm, +N, YYYY-MM-DD
+    const lower = tok.toLowerCase();
+    if (
+      lower === "t" || lower === "tm" || lower === "tom" ||
+      lower === "today" || lower === "tomorrow" ||
+      lower === "oggi" || lower === "domani" ||
+      /^[+-]\d+$/.test(lower) ||
+      /^\d{4}-\d{2}-\d{2}$/.test(lower)
+    ) {
+      const d = parseDateShortcut(lower);
+      if (typeof d === "string" && !result.scheduled) {
+        result.scheduled = d;
+        continue;
+      }
+    }
+    remaining.push(tok);
+  }
+
+  result.title = remaining.join(" ").trim();
+  return result;
+}

package/src/store/timeline.test.ts

@@ -0,0 +1,279 @@
+import { describe, expect, it } from "bun:test";
+
+import type { Board, Task } from "~/types";
+import {
+  DAY_START_HOUR,
+  MINS_PER_ROW,
+  TOTAL_ROWS,
+  buildRowMap,
+  buildTimelineEntries,
+  countOverlaps,
+  formatHm,
+  type TimelineEntry,
+} from "./timeline";
+
+/** Build a minimal Task object for testing. Only fields touched by timeline. */
+function makeTask(opts: Partial<Task> & Pick<Task, "displayTitle">): Task {
+  const base: Partial<Task> = {
+    id: "0:0",
+    rawBody: opts.displayTitle,
+    rawLine: `- [ ] ${opts.displayTitle}`,
+    done: false,
+    priority: "none",
+    tags: [],
+    wikilinks: [],
+    dirty: false,
+  };
+  return { ...base, ...opts } as Task;
+}
+
+function makeBoard(name: string, filepath: string, tasks: Task[]): Board {
+  return {
+    name,
+    filepath,
+    frontmatter: "",
+    preamble: "",
+    trailer: "",
+    lineEnding: "\n",
+    originalContent: "",
+    columns: [
+      {
+        name: "Inbox",
+        headerLevel: 2,
+        rawHeading: "## Inbox",
+        children: tasks,
+      },
+    ],
+  };
+}
+
+describe("buildTimelineEntries", () => {
+  const today = "2026-05-27";
+
+  it("returns empty when no tasks are time-blocked today", () => {
+    const t = makeTask({ displayTitle: "no time block", scheduled: today });
+    const board = makeBoard("R3PLICA", "r3.md", [t]);
+    expect(buildTimelineEntries([board], today)).toEqual([]);
+  });
+
+  it("includes a scheduled, time-blocked, non-done task for today", () => {
+    const t = makeTask({
+      displayTitle: "outreach",
+      scheduled: today,
+      timeBlock: { startMin: 9 * 60, endMin: 10 * 60 + 30 },
+    });
+    const board = makeBoard("R3PLICA", "r3.md", [t]);
+    const entries = buildTimelineEntries([board], today);
+    expect(entries.length).toBe(1);
+    expect(entries[0]!.startMin).toBe(540);
+    expect(entries[0]!.endMin).toBe(630);
+    // 9:00 = row 8 (since DAY_START=7, 60min/15 = 4 rows per hour)
+    expect(entries[0]!.startRow).toBe(8);
+    // 90min duration = 6 rows
+    expect(entries[0]!.endRow).toBe(14);
+  });
+
+  it("excludes done tasks", () => {
+    const t = makeTask({
+      displayTitle: "done deal",
+      done: true,
+      scheduled: today,
+      timeBlock: { startMin: 9 * 60, endMin: 10 * 60 },
+    });
+    const board = makeBoard("R3PLICA", "r3.md", [t]);
+    expect(buildTimelineEntries([board], today)).toEqual([]);
+  });
+
+  it("excludes tasks scheduled for a different date", () => {
+    const t = makeTask({
+      displayTitle: "tomorrow",
+      scheduled: "2026-05-28",
+      timeBlock: { startMin: 9 * 60, endMin: 10 * 60 },
+    });
+    const board = makeBoard("R3PLICA", "r3.md", [t]);
+    expect(buildTimelineEntries([board], today)).toEqual([]);
+  });
+
+  it("clips blocks that span outside the rendered window", () => {
+    const t = makeTask({
+      displayTitle: "early",
+      scheduled: today,
+      // 6:30-7:30 → only 7:00-7:30 visible (rows 0-1)
+      timeBlock: { startMin: 6 * 60 + 30, endMin: 7 * 60 + 30 },
+    });
+    const board = makeBoard("R3PLICA", "r3.md", [t]);
+    const entries = buildTimelineEntries([board], today);
+    expect(entries.length).toBe(1);
+    expect(entries[0]!.startRow).toBe(0); // clipped at top
+  });
+
+  it("skips blocks entirely outside the window", () => {
+    const t = makeTask({
+      displayTitle: "midnight",
+      scheduled: today,
+      timeBlock: { startMin: 0, endMin: 30 },
+    });
+    const board = makeBoard("R3PLICA", "r3.md", [t]);
+    expect(buildTimelineEntries([board], today)).toEqual([]);
+  });
+
+  it("sorts entries by startMin", () => {
+    const t1 = makeTask({
+      displayTitle: "afternoon",
+      scheduled: today,
+      timeBlock: { startMin: 14 * 60, endMin: 15 * 60 },
+    });
+    const t2 = makeTask({
+      displayTitle: "morning",
+      scheduled: today,
+      timeBlock: { startMin: 9 * 60, endMin: 10 * 60 },
+    });
+    const board = makeBoard("R3PLICA", "r3.md", [t1, t2]);
+    const entries = buildTimelineEntries([board], today);
+    expect(entries.map((e) => e.task.displayTitle)).toEqual([
+      "morning",
+      "afternoon",
+    ]);
+  });
+});
+
+describe("buildRowMap", () => {
+  function entryAt(startRow: number, endRow: number, title = "block"): TimelineEntry {
+    return {
+      ref: { boardPath: "x", columnIndex: 0, taskIndex: 0 },
+      task: makeTask({ displayTitle: title }),
+      boardName: "R3PLICA",
+      boardIndex: 0,
+      columnName: "Inbox",
+      startMin: 0,
+      endMin: 0,
+      startRow,
+      endRow,
+    };
+  }
+
+  it("returns TOTAL_ROWS row pairs", () => {
+    const result = buildRowMap([], 0);
+    expect(result.rows.length).toBe(TOTAL_ROWS);
+    expect(result.overflow).toBe(0);
+  });
+
+  it("marks hour-anchor rows on the left lane with kind=hour", () => {
+    const { rows } = buildRowMap([], 0);
+    expect(rows[0]!.left).toEqual({ kind: "hour", hour: DAY_START_HOUR });
+    expect(rows[4]!.left).toEqual({ kind: "hour", hour: DAY_START_HOUR + 1 });
+    expect(rows[1]!.left.kind).toBe("empty");
+    // Right lane is always empty when no overlap.
+    expect(rows[0]!.right.kind).toBe("empty");
+  });
+
+  it("places a single entry on the left lane as head/body/fill", () => {
+    const { rows } = buildRowMap([entryAt(8, 14)], 0);
+    expect(rows[8]!.left.kind).toBe("head");
+    expect(rows[9]!.left.kind).toBe("body");
+    expect(rows[10]!.left.kind).toBe("fill");
+    expect(rows[13]!.left.kind).toBe("fill");
+    expect(rows[14]!.left.kind).not.toBe("fill"); // end exclusive
+    // No overlap → right lane all empty.
+    for (let r = 8; r < 14; r++) {
+      expect(rows[r]!.right.kind).toBe("empty");
+    }
+  });
+
+  it("places overlapping entries on left and right lanes side-by-side", () => {
+    // A: rows 5-10, B: rows 7-12 → overlap on rows 7-9.
+    const a = entryAt(5, 10, "A");
+    const b = entryAt(7, 12, "B");
+    const { rows, overflow } = buildRowMap([a, b], 0);
+    expect(overflow).toBe(0);
+    // Lane 0 (left) gets A.
+    expect(rows[5]!.left.kind).toBe("head");
+    expect(rows[5]!.left.entry?.task.displayTitle).toBe("A");
+    // Lane 1 (right) gets B starting at row 7.
+    expect(rows[7]!.right.kind).toBe("head");
+    expect(rows[7]!.right.entry?.task.displayTitle).toBe("B");
+    // Row 10 is past A's end but inside B → left empty, right fill.
+    expect(rows[10]!.left.kind).toBe("empty");
+    expect(rows[10]!.right.entry?.task.displayTitle).toBe("B");
+  });
+
+  it("counts third+ overlapping entry as overflow", () => {
+    // Three blocks overlapping at row 8.
+    const a = entryAt(5, 12, "A");
+    const b = entryAt(6, 11, "B");
+    const c = entryAt(7, 10, "C");
+    const { overflow } = buildRowMap([a, b, c], 0);
+    expect(overflow).toBe(1); // C didn't fit either lane
+  });
+
+  it("reuses a lane after its block ends", () => {
+    // A: rows 5-8, C: rows 10-15 → both can use lane 0.
+    const a = entryAt(5, 8, "A");
+    const c = entryAt(10, 15, "C");
+    const { rows, overflow } = buildRowMap([a, c], 0);
+    expect(overflow).toBe(0);
+    expect(rows[5]!.left.entry?.task.displayTitle).toBe("A");
+    expect(rows[10]!.left.entry?.task.displayTitle).toBe("C");
+    // Right lane stayed empty throughout.
+    for (let r = 0; r < TOTAL_ROWS; r++) {
+      expect(rows[r]!.right.kind).toBe("empty");
+    }
+  });
+
+  it("overlays a now marker on the left lane (and clears the right)", () => {
+    const nowMin = 10 * 60 + 30; // 10:30 → row 14
+    const { rows } = buildRowMap([], nowMin);
+    expect(rows[14]!.left.kind).toBe("now");
+    expect(rows[14]!.left.nowMin).toBe(nowMin);
+    expect(rows[14]!.right.kind).toBe("empty");
+  });
+
+  it("does not place a now marker when out of window", () => {
+    const { rows } = buildRowMap([], 3 * 60); // 03:00, before DAY_START
+    expect(rows.some((r) => r.left.kind === "now")).toBe(false);
+  });
+});
+
+describe("countOverlaps", () => {
+  function entry(s: number, e: number): TimelineEntry {
+    return {
+      ref: { boardPath: "x", columnIndex: 0, taskIndex: 0 },
+      task: makeTask({ displayTitle: "x" }),
+      boardName: "X",
+      boardIndex: 0,
+      columnName: "X",
+      startMin: s,
+      endMin: e,
+      startRow: 0,
+      endRow: 0,
+    };
+  }
+
+  it("returns 0 for non-overlapping blocks", () => {
+    expect(
+      countOverlaps([entry(540, 600), entry(600, 660), entry(720, 780)]),
+    ).toBe(0);
+  });
+
+  it("counts overlapping pairs", () => {
+    expect(countOverlaps([entry(540, 660), entry(600, 720)])).toBe(1);
+  });
+
+  it("counts every overlapping pair in a 3-way overlap", () => {
+    expect(
+      countOverlaps([entry(540, 660), entry(600, 720), entry(630, 700)]),
+    ).toBe(3);
+  });
+});
+
+describe("formatHm", () => {
+  it("zero-pads hours and minutes", () => {
+    expect(formatHm(0)).toBe("00:00");
+    expect(formatHm(540)).toBe("09:00");
+    expect(formatHm(615)).toBe("10:15");
+    expect(formatHm(23 * 60 + 59)).toBe("23:59");
+  });
+});
+
+// silence unused-var lint about MINS_PER_ROW import
+void MINS_PER_ROW;