super-time-tracker-ui 0.1.2

package/lib/merge_tags_across_db.ts

@@ -0,0 +1,79 @@
+import { collect_tag_stats } from '@/lib/collect_tag_stats'
+import { normalize_stored_tag } from '@/lib/normalize_stored_tag'
+import { read_db } from '@/lib/read_db'
+import { tags_are_equal } from '@/lib/tags_are_equal'
+import { type TagStat } from '@/lib/types/tag_management'
+import { write_db } from '@/lib/write_db'
+
+export interface MergeTagsAcrossDbResult {
+  entries_updated: number
+  tags: TagStat[]
+}
+
+/**
+ * Replaces source tags with a target tag on every entry and deduplicates tag lists.
+ */
+export async function merge_tags_across_db(
+  source_tags: string[],
+  target_tag: string,
+): Promise<MergeTagsAcrossDbResult> {
+  const normalized_target = normalize_stored_tag(target_tag)
+  const normalized_sources = [
+    ...new Set(
+      source_tags
+        .map((tag) => normalize_stored_tag(tag))
+        .filter((tag) => !tags_are_equal(tag, normalized_target)),
+    ),
+  ]
+
+  if (normalized_sources.length === 0) {
+    throw new Error('Choose at least one source tag different from the target.')
+  }
+
+  const db = await read_db()
+  let entries_updated = 0
+
+  for (const sheet of db.sheets) {
+    for (const entry of sheet.entries) {
+      let changed = false
+      const next_tags: string[] = []
+      const seen = new Set<string>()
+
+      for (const tag of entry.tags) {
+        let next_tag: string
+
+        try {
+          next_tag = normalize_stored_tag(tag)
+        } catch {
+          next_tag = tag
+        }
+
+        if (
+          normalized_sources.some((source_tag) => tags_are_equal(source_tag, next_tag))
+        ) {
+          next_tag = normalized_target
+          changed = true
+        }
+
+        if (!seen.has(next_tag)) {
+          seen.add(next_tag)
+          next_tags.push(next_tag)
+        }
+      }
+
+      if (changed) {
+        entry.tags = next_tags
+        entries_updated += 1
+      }
+    }
+  }
+
+  if (entries_updated > 0) {
+    await write_db(db)
+  }
+
+  return {
+    entries_updated,
+    tags: collect_tag_stats(db),
+  }
+}

package/lib/migrate_json_db.ts

@@ -0,0 +1,56 @@
+import { DB_VERSION } from "@/lib/config";
+import { migrate_json_db_to_version_three } from "@/lib/migrate_json_db_to_version_three";
+import { migrate_json_db_to_version_two } from "@/lib/migrate_json_db_to_version_two";
+import { type JSONTimeTrackerDB } from "@/lib/types";
+
+const MIGRATIONS_BY_TARGET_VERSION: Record<
+  number,
+  (json_db: JSONTimeTrackerDB) => JSONTimeTrackerDB
+> = {
+  2: migrate_json_db_to_version_two,
+  3: migrate_json_db_to_version_three,
+};
+
+export interface MigrateJsonDbResult {
+  did_migrate: boolean;
+  json_db: JSONTimeTrackerDB;
+}
+
+/**
+ * Runs sequential migrations until the JSON DB reaches the current version.
+ */
+export function migrate_json_db(
+  json_db_input: JSONTimeTrackerDB,
+): MigrateJsonDbResult {
+  let json_db = json_db_input;
+  let did_migrate = false;
+  let current_version = json_db.version === undefined ? 1 : json_db.version;
+
+  if (current_version > DB_VERSION || current_version < 1) {
+    throw new Error(`Unknown DB version ${json_db.version}, cannot load.`);
+  }
+
+  while (current_version < DB_VERSION) {
+    const target_version = current_version + 1;
+    const migration = MIGRATIONS_BY_TARGET_VERSION[target_version];
+
+    if (migration === undefined) {
+      throw new Error(
+        `Missing migration from version ${current_version} to ${target_version}.`,
+      );
+    }
+
+    json_db = migration(json_db);
+
+    if (json_db.version !== target_version) {
+      throw new Error(
+        `Invalid migration output for version ${target_version}.`,
+      );
+    }
+
+    current_version = target_version;
+    did_migrate = true;
+  }
+
+  return { json_db, did_migrate };
+}

package/lib/migrate_json_db_to_version_three.ts

@@ -0,0 +1,51 @@
+import { type JSONTimeTrackerDB } from "@/lib/types";
+
+/**
+ * Adds a notes array to each entry for DB version 3.
+ */
+export function migrate_json_db_to_version_three(
+  json_db: JSONTimeTrackerDB,
+): JSONTimeTrackerDB {
+  const {
+    sheets: json_sheets,
+    version: json_version,
+    activeSheetName: json_active_sheet_name,
+  } = json_db;
+
+  if (json_version !== 2 && json_version !== undefined) {
+    throw new Error(
+      `DB is version ${json_version}, cannot migrate to version 3.`,
+    );
+  }
+
+  return {
+    version: 3,
+    activeSheetName: json_active_sheet_name,
+    sheets: json_sheets.map(
+      ({
+        name: json_name,
+        entries: json_entries,
+        activeEntryID: json_active_entry_id,
+      }) => ({
+        name: json_name,
+        activeEntryID: json_active_entry_id,
+        entries: json_entries.map(
+          ({
+            id: json_id,
+            start: json_start,
+            end: json_end,
+            description: json_description,
+            tags: json_tags,
+          }) => ({
+            notes: [],
+            tags: json_tags,
+            id: json_id,
+            end: json_end,
+            start: json_start,
+            description: json_description,
+          }),
+        ),
+      }),
+    ),
+  };
+}

package/lib/migrate_json_db_to_version_two.ts

@@ -0,0 +1,50 @@
+import { type JSONTimeTrackerDB } from "@/lib/types";
+
+/**
+ * Adds empty tag and note arrays to each entry for DB version 2.
+ */
+export function migrate_json_db_to_version_two(
+  json_db: JSONTimeTrackerDB,
+): JSONTimeTrackerDB {
+  const {
+    sheets: json_sheets,
+    version: json_version,
+    activeSheetName: json_active_sheet_name,
+  } = json_db;
+
+  if (json_version !== 1 && json_version !== undefined) {
+    throw new Error(
+      `DB is version ${json_version}, cannot migrate to version 2.`,
+    );
+  }
+
+  return {
+    version: 2,
+    activeSheetName: json_active_sheet_name,
+    sheets: json_sheets.map(
+      ({
+        name: json_name,
+        entries: json_entries,
+        activeEntryID: json_active_entry_id,
+      }) => ({
+        name: json_name,
+        activeEntryID: json_active_entry_id,
+        entries: json_entries.map(
+          ({
+            id: json_id,
+            start: json_start,
+            end: json_end,
+            description: json_description,
+          }) => ({
+            tags: [],
+            notes: [],
+            id: json_id,
+            end: json_end,
+            start: json_start,
+            description: json_description,
+          }),
+        ),
+      }),
+    ),
+  };
+}

package/lib/move_entries_to_sheet.ts

@@ -0,0 +1,152 @@
+import { gen_sheet } from "@/lib/gen_db";
+import { get_sheet } from "@/lib/get_sheet";
+import { read_db } from "@/lib/read_db";
+import { write_db } from "@/lib/write_db";
+import { type TimeSheetEntry } from "@/lib/types";
+
+export interface MoveEntryRef {
+  sheet_name: string;
+  entry_id: number;
+}
+
+export interface MoveEntriesToSheetArgs {
+  entries: MoveEntryRef[];
+  target_sheet_name: string;
+}
+
+interface PendingMove {
+  source_sheet_name: string;
+  entry: TimeSheetEntry;
+  is_active: boolean;
+}
+
+/**
+ * Moves multiple entries to another sheet in a single database write.
+ */
+export async function move_entries_to_sheet(
+  args: MoveEntriesToSheetArgs,
+): Promise<void> {
+  const { entries: entry_refs, target_sheet_name } = args;
+  const trimmed_target = target_sheet_name.trim();
+
+  if (entry_refs.length === 0) {
+    throw new Error("No entries selected");
+  }
+
+  if (trimmed_target.length === 0) {
+    throw new Error("Target sheet name is required");
+  }
+
+  const db = await read_db();
+  const pending_moves: PendingMove[] = [];
+  const seen = new Set<string>();
+
+  for (const { entry_id, sheet_name } of entry_refs) {
+    const key = `${sheet_name}:${entry_id}`;
+
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+
+    if (sheet_name === trimmed_target) {
+      continue;
+    }
+
+    const source_sheet = get_sheet(db, sheet_name);
+    const entry = source_sheet.entries.find(({ id }) => id === entry_id);
+
+    if (entry === undefined) {
+      throw new Error(`Entry ${entry_id} not found in sheet ${sheet_name}`);
+    }
+
+    pending_moves.push({
+      source_sheet_name: sheet_name,
+      entry: {
+        ...entry,
+        notes: [...entry.notes],
+        tags: [...entry.tags],
+      },
+      is_active: source_sheet.activeEntryID === entry_id,
+    });
+  }
+
+  if (pending_moves.length === 0) {
+    throw new Error("All selected entries are already on that sheet");
+  }
+
+  const active_moves = pending_moves.filter(({ is_active }) => is_active);
+
+  if (active_moves.length > 1) {
+    throw new Error("Cannot move multiple active entries at once");
+  }
+
+  const target_exists = db.sheets.some(({ name }) => name === trimmed_target);
+  const target_sheet = target_exists
+    ? get_sheet(db, trimmed_target)
+    : (() => {
+        const created = gen_sheet(trimmed_target);
+        db.sheets.push(created);
+        return created;
+      })();
+
+  if (active_moves.length === 1 && target_sheet.activeEntryID !== null) {
+    const active_entry = target_sheet.entries.find(
+      ({ id }) => id === target_sheet.activeEntryID,
+    );
+
+    if (active_entry !== undefined) {
+      throw new Error(
+        `Sheet ${trimmed_target} already has an active entry (${active_entry.description})`,
+      );
+    }
+  }
+
+  const by_source = new Map<string, PendingMove[]>();
+
+  for (const move of pending_moves) {
+    const list = by_source.get(move.source_sheet_name) ?? [];
+    list.push(move);
+    by_source.set(move.source_sheet_name, list);
+  }
+
+  for (const [source_sheet_name, moves] of by_source) {
+    const source_sheet = get_sheet(db, source_sheet_name);
+    const ids_to_remove = moves
+      .map(({ entry }) => entry.id)
+      .sort((left, right) => right - left);
+
+    for (const entry_id of ids_to_remove) {
+      const entry_index = source_sheet.entries.findIndex(
+        ({ id }) => id === entry_id,
+      );
+
+      if (entry_index === -1) {
+        continue;
+      }
+
+      source_sheet.entries.splice(entry_index, 1);
+
+      if (source_sheet.activeEntryID === entry_id) {
+        source_sheet.activeEntryID = null;
+      }
+    }
+  }
+
+  for (const move of pending_moves) {
+    const new_id = target_sheet.entries.length;
+
+    target_sheet.entries.push({
+      ...move.entry,
+      id: new_id,
+    });
+
+    if (move.is_active) {
+      target_sheet.activeEntryID = new_id;
+      db.activeSheetName = trimmed_target;
+    }
+  }
+
+  await write_db(db);
+}

package/lib/move_entry_to_sheet.ts

@@ -0,0 +1,82 @@
+import { gen_sheet } from "@/lib/gen_db";
+import { get_sheet } from "@/lib/get_sheet";
+import { read_db } from "@/lib/read_db";
+import { write_db } from "@/lib/write_db";
+import { type TimeSheetEntry } from "@/lib/types";
+
+export interface MoveEntryToSheetArgs {
+  sheet_name: string;
+  entry_id: number;
+  target_sheet_name: string;
+}
+
+/**
+ * Moves an entry from one sheet to another, preserving active status when applicable.
+ */
+export async function move_entry_to_sheet(
+  args: MoveEntryToSheetArgs,
+): Promise<void> {
+  const { entry_id, sheet_name, target_sheet_name } = args;
+  const trimmed_target = target_sheet_name.trim();
+
+  if (trimmed_target.length === 0) {
+    throw new Error("Target sheet name is required");
+  }
+
+  if (sheet_name === trimmed_target) {
+    throw new Error("Entry is already on that sheet");
+  }
+
+  const db = await read_db();
+  const source_sheet = get_sheet(db, sheet_name);
+  const entry_index = source_sheet.entries.findIndex(({ id }) => id === entry_id);
+
+  if (entry_index === -1) {
+    throw new Error(`Entry ${entry_id} not found in sheet ${sheet_name}`);
+  }
+
+  const entry = source_sheet.entries[entry_index];
+  const is_active = source_sheet.activeEntryID === entry_id;
+
+  const target_exists = db.sheets.some(({ name }) => name === trimmed_target);
+  const target_sheet = target_exists
+    ? get_sheet(db, trimmed_target)
+    : (() => {
+        const created = gen_sheet(trimmed_target);
+        db.sheets.push(created);
+        return created;
+      })();
+
+  if (target_sheet.activeEntryID !== null) {
+    const active_entry = target_sheet.entries.find(
+      ({ id }) => id === target_sheet.activeEntryID,
+    );
+
+    if (active_entry !== undefined) {
+      throw new Error(
+        `Sheet ${trimmed_target} already has an active entry (${active_entry.description})`,
+      );
+    }
+  }
+
+  source_sheet.entries.splice(entry_index, 1);
+
+  if (is_active) {
+    source_sheet.activeEntryID = null;
+  }
+
+  const new_id = target_sheet.entries.length;
+  const moved_entry: TimeSheetEntry = {
+    ...entry,
+    id: new_id,
+  };
+
+  target_sheet.entries.push(moved_entry);
+
+  if (is_active) {
+    target_sheet.activeEntryID = new_id;
+    db.activeSheetName = trimmed_target;
+  }
+
+  await write_db(db);
+}

package/lib/normalize_stored_tag.ts

@@ -0,0 +1,16 @@
+/**
+ * Normalizes user input into a stored @tag token.
+ */
+export function normalize_stored_tag(tag: string): string {
+  const without_at = tag.trim().replace(/^@+/, '')
+
+  if (without_at.length === 0) {
+    throw new Error('Tag name must not be empty.')
+  }
+
+  if (!/^\w+$/.test(without_at)) {
+    throw new Error('Tags may only contain letters, numbers, and underscores.')
+  }
+
+  return `@${without_at}`
+}

package/lib/notify_settings_saved.ts

@@ -0,0 +1,47 @@
+type SettingsSavedListener = (message: string) => void
+
+const listeners = new Set<SettingsSavedListener>()
+
+export const SETTINGS_SAVED_DEFAULT_MESSAGE = 'Settings saved'
+
+let debounce_timer: ReturnType<typeof setTimeout> | null = null
+let pending_message = SETTINGS_SAVED_DEFAULT_MESSAGE
+
+/**
+ * Subscribes to settings-saved toast events.
+ */
+export function subscribe_settings_saved(
+  listener: SettingsSavedListener,
+): () => void {
+  listeners.add(listener)
+
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+/**
+ * Queues a short debounced “settings saved” toast (settings UI only).
+ */
+export function notify_settings_saved(
+  message: string = SETTINGS_SAVED_DEFAULT_MESSAGE,
+): void {
+  if (typeof window === 'undefined') {
+    return
+  }
+
+  pending_message = message
+
+  if (debounce_timer !== null) {
+    clearTimeout(debounce_timer)
+  }
+
+  debounce_timer = setTimeout(() => {
+    debounce_timer = null
+    const next_message = pending_message
+
+    listeners.forEach((listener) => {
+      listener(next_message)
+    })
+  }, 200)
+}

package/lib/parse_default_sheet_session_mode.ts

@@ -0,0 +1,21 @@
+import {
+  DEFAULT_SHEET_SESSION_MODE_DEFAULT,
+  type DefaultSheetSessionMode,
+} from '@/lib/types/ui_settings'
+
+/**
+ * Parses a stored default sheet session mode value.
+ */
+export function parse_default_sheet_session_mode(
+  value: string | undefined | null,
+): DefaultSheetSessionMode {
+  if (
+    value === 'last_viewed' ||
+    value === 'active_timer' ||
+    value === 'fixed'
+  ) {
+    return value
+  }
+
+  return DEFAULT_SHEET_SESSION_MODE_DEFAULT
+}

package/lib/parse_entry_from_input.ts

@@ -0,0 +1,23 @@
+import { type TimeSheetEntry } from "@/lib/types";
+
+/**
+ * Parses a check-in description, extracting @tags from the text.
+ */
+export function parse_entry_from_input(
+  id: number,
+  input: string,
+  start?: Date,
+  end?: Date | null,
+): TimeSheetEntry {
+  const tags = input.match(/@\w+/g) ?? [];
+  const description = input.split(/@\w+/).join(" ").trim();
+
+  return {
+    id,
+    tags,
+    notes: [],
+    description,
+    start: start ?? new Date(),
+    end: end ?? null,
+  };
+}

package/lib/parse_natural_language_date.ts

@@ -0,0 +1,23 @@
+import parseDate, { InvalidInputError } from "time-speak";
+
+/**
+ * Parses a natural-language time expression into a Date.
+ */
+export function parse_natural_language_date(expression: string): Date {
+  const trimmed = expression.trim();
+
+  if (trimmed.length === 0) {
+    throw new Error("Time expression is required");
+  }
+
+  try {
+    const parsed = parseDate(trimmed);
+    return new Date(+parsed);
+  } catch (error: unknown) {
+    if (error instanceof InvalidInputError) {
+      throw new Error(`Could not parse time: ${trimmed}`, { cause: error });
+    }
+
+    throw error;
+  }
+}

package/lib/parse_reporting_source_sheets.ts

@@ -0,0 +1,22 @@
+import { type ReportingSourceSheet } from '@/lib/types/reporting'
+import { type TimeSheet } from '@/lib/types'
+
+/**
+ * Restores time sheets from reporting source payloads.
+ */
+export function parse_reporting_source_sheets(
+  source_sheets: ReportingSourceSheet[],
+): TimeSheet[] {
+  return source_sheets.map((sheet) => ({
+    name: sheet.name,
+    activeEntryID: sheet.activeEntryID,
+    entries: sheet.entries.map((entry) => ({
+      id: entry.id,
+      start: new Date(entry.start),
+      end: entry.end === null ? null : new Date(entry.end),
+      description: '',
+      tags: [],
+      notes: [],
+    })),
+  }))
+}

package/lib/partition_sheet_report_stats.ts

@@ -0,0 +1,30 @@
+import { is_idle_sheet_report } from '@/lib/is_idle_sheet_report'
+import { type SheetReportStats } from '@/lib/types/reporting'
+
+export interface PartitionedSheetReportStats {
+  activeSheets: SheetReportStats[]
+  idleSheets: SheetReportStats[]
+}
+
+/**
+ * Splits sheet report stats into tracked and empty or idle groups.
+ */
+export function partition_sheet_report_stats(
+  sheets: SheetReportStats[],
+): PartitionedSheetReportStats {
+  const active_sheets: SheetReportStats[] = []
+  const idle_sheets: SheetReportStats[] = []
+
+  for (const sheet of sheets) {
+    if (is_idle_sheet_report(sheet)) {
+      idle_sheets.push(sheet)
+    } else {
+      active_sheets.push(sheet)
+    }
+  }
+
+  return {
+    activeSheets: active_sheets,
+    idleSheets: idle_sheets,
+  }
+}

package/lib/patch_tracker_action.ts

@@ -0,0 +1,22 @@
+import { type TrackerState } from "@/lib/types/tracker_state";
+
+/**
+ * Sends a PATCH request to a tracker API route and returns updated state.
+ */
+export async function patch_tracker_action(
+  path: string,
+  body: unknown,
+): Promise<TrackerState> {
+  const response = await fetch(path, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const payload = (await response.json()) as { error?: string };
+    throw new Error(payload.error ?? "Request failed");
+  }
+
+  return (await response.json()) as TrackerState;
+}