@mrck-labs/vanaheim-shared 0.1.1 → 0.2.1

package/dist/index.js

@@ -36,29 +36,73 @@ __export(src_exports, {
   LINEAR_PRIORITY_COLORS: () => LINEAR_PRIORITY_COLORS,
   LINEAR_PRIORITY_LABELS: () => LINEAR_PRIORITY_LABELS,
   SETTING_KEYS: () => SETTING_KEYS,
+  activeSessionAtom: () => activeSessionAtom,
+  addDays: () => addDays,
   calculateFocusStats: () => calculateFocusStats,
   calculateLieuBalance: () => calculateLieuBalance,
   calculateMonthlyExpenses: () => calculateMonthlyExpenses,
   calculateMonthlyIncome: () => calculateMonthlyIncome,
   calculateMonthlySavings: () => calculateMonthlySavings,
   calculateSavingsRate: () => calculateSavingsRate,
+  elapsedSecondsAtom: () => elapsedSecondsAtom,
   formatCurrency: () => formatCurrency,
   formatDate: () => formatDate,
+  formatDateHeader: () => formatDateHeader,
+  formatDateLocalized: () => formatDateLocalized,
+  formatDateLong: () => formatDateLong,
+  formatDateString: () => formatDateString,
   formatDueDate: () => formatDueDate,
+  formatDueDateString: () => formatDueDateString,
+  formatDuration: () => formatDuration,
+  formatFullDate: () => formatFullDate,
+  formatMonthYear: () => formatMonthYear,
+  formatRelativeDueDate: () => formatRelativeDueDate,
+  formatRelativePayDate: () => formatRelativePayDate,
   formatRelativeTime: () => formatRelativeTime,
+  formatRelativeTimeExtended: () => formatRelativeTimeExtended,
   formatTime: () => formatTime,
+  formatTimeHHMM: () => formatTimeHHMM,
+  formatTimeLocalized: () => formatTimeLocalized,
+  formatTimeWithSeconds: () => formatTimeWithSeconds,
   formatTotalTime: () => formatTotalTime,
+  formatWeekRange: () => formatWeekRange,
+  formattedElapsedAtom: () => formattedElapsedAtom,
+  formattedRemainingAtom: () => formattedRemainingAtom,
   generateId: () => generateId,
   generateRandomColor: () => generateRandomColor,
   generateShortId: () => generateShortId,
+  getEndOfDayISO: () => getEndOfDayISO,
+  getNextWeek: () => getNextWeek,
+  getPreviousWeek: () => getPreviousWeek,
   getRepoName: () => getRepoName,
+  getStartOfDayISO: () => getStartOfDayISO,
+  getTodayMidnight: () => getTodayMidnight,
+  getTodayString: () => getTodayString,
+  getTomorrowString: () => getTomorrowString,
+  getWeekEnd: () => getWeekEnd,
+  getWeekEndString: () => getWeekEndString,
+  getWeekStart: () => getWeekStart,
+  getWeekStartString: () => getWeekStartString,
+  getYesterdayString: () => getYesterdayString,
+  isDueSoon: () => isDueSoon,
   isNonEmptyString: () => isNonEmptyString,
+  isOverdue: () => isOverdue,
   isPositiveNumber: () => isPositiveNumber,
+  isToday: () => isToday,
   isValidCurrency: () => isValidCurrency,
   isValidEmail: () => isValidEmail,
   isValidFrequency: () => isValidFrequency,
   isValidISODate: () => isValidISODate,
   isValidUrl: () => isValidUrl,
+  normalizeToMidnight: () => normalizeToMidnight,
+  parseLocalDate: () => parseLocalDate,
+  progressAtom: () => progressAtom,
+  progressPercentAtom: () => progressPercentAtom,
+  queryKeys: () => queryKeys,
+  remainingSecondsAtom: () => remainingSecondsAtom,
+  subtractDays: () => subtractDays,
+  targetSecondsAtom: () => targetSecondsAtom,
+  timerStatusAtom: () => timerStatusAtom,
   toMonthlyAmount: () => toMonthlyAmount,
   toYearlyAmount: () => toYearlyAmount,
   truncate: () => truncate
@@ -179,7 +223,19 @@ function formatTotalTime(seconds) {
   }
   return `${mins}m`;
 }
-function formatCurrency(amount, currency, locale = "en-CH") {
+function formatDuration(seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const secs = seconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m${secs > 0 ? ` ${secs}s` : ""}`;
+  } else {
+    return `${secs}s`;
+  }
+}
+function formatCurrency(amount, currency = "CHF", locale = "de-CH") {
   return new Intl.NumberFormat(locale, {
     style: "currency",
     currency,
@@ -216,12 +272,12 @@ function formatDueDate(dueDate) {
   tomorrow.setDate(tomorrow.getDate() + 1);
   const dueDay = new Date(due);
   dueDay.setHours(0, 0, 0, 0);
-  const isOverdue = dueDay < today;
+  const isOverdue2 = dueDay < today;
   if (dueDay.getTime() === today.getTime()) {
     return { text: "Today", isOverdue: false };
   } else if (dueDay.getTime() === tomorrow.getTime()) {
     return { text: "Tomorrow", isOverdue: false };
-  } else if (isOverdue) {
+  } else if (isOverdue2) {
     const daysAgo = Math.ceil(
       (today.getTime() - dueDay.getTime()) / (1e3 * 60 * 60 * 24)
     );
@@ -363,6 +419,517 @@ function calculateFocusStats(sessions) {
     completionRate
   };
 }
+
+// src/query/index.ts
+var queryKeys = {
+  // -------------------------------------------------------------------------
+  // Expenses
+  // -------------------------------------------------------------------------
+  expenses: {
+    all: ["expenses"],
+    lists: () => [...queryKeys.expenses.all, "list"],
+    list: (filters) => [...queryKeys.expenses.lists(), filters],
+    detail: (id) => [...queryKeys.expenses.all, "detail", id]
+  },
+  // Expense Categories
+  expenseCategories: {
+    all: ["expenseCategories"],
+    list: () => [...queryKeys.expenseCategories.all, "list"]
+  },
+  // Expense Payments
+  expensePayments: {
+    all: ["expensePayments"],
+    lists: () => [...queryKeys.expensePayments.all, "list"],
+    list: (filters) => [...queryKeys.expensePayments.lists(), filters],
+    detail: (id) => [...queryKeys.expensePayments.all, "detail", id]
+  },
+  // -------------------------------------------------------------------------
+  // Income
+  // -------------------------------------------------------------------------
+  incomes: {
+    all: ["incomes"],
+    lists: () => [...queryKeys.incomes.all, "list"],
+    list: (filters) => [...queryKeys.incomes.lists(), filters],
+    detail: (id) => [...queryKeys.incomes.all, "detail", id]
+  },
+  // Income Categories
+  incomeCategories: {
+    all: ["incomeCategories"],
+    list: () => [...queryKeys.incomeCategories.all, "list"]
+  },
+  // Income Payments
+  incomePayments: {
+    all: ["incomePayments"],
+    lists: () => [...queryKeys.incomePayments.all, "list"],
+    list: (filters) => [...queryKeys.incomePayments.lists(), filters],
+    detail: (id) => [...queryKeys.incomePayments.all, "detail", id]
+  },
+  // Exchange Rates
+  exchangeRates: {
+    all: ["exchangeRates"],
+    list: () => [...queryKeys.exchangeRates.all, "list"]
+  },
+  // -------------------------------------------------------------------------
+  // Focus
+  // -------------------------------------------------------------------------
+  focusSessions: {
+    all: ["focusSessions"],
+    lists: () => [...queryKeys.focusSessions.all, "list"],
+    list: (filters) => [...queryKeys.focusSessions.lists(), filters],
+    today: () => [...queryKeys.focusSessions.all, "today"],
+    active: () => [...queryKeys.focusSessions.all, "active"],
+    detail: (id) => [...queryKeys.focusSessions.all, "detail", id]
+  },
+  // Focus Categories
+  focusCategories: {
+    all: ["focusCategories"],
+    list: () => [...queryKeys.focusCategories.all, "list"]
+  },
+  // -------------------------------------------------------------------------
+  // Settings
+  // -------------------------------------------------------------------------
+  settings: {
+    all: ["settings"],
+    detail: (key) => [...queryKeys.settings.all, key]
+  },
+  // -------------------------------------------------------------------------
+  // EF Work (Lieu Days & Links)
+  // -------------------------------------------------------------------------
+  lieuDays: {
+    all: ["lieuDays"],
+    list: () => [...queryKeys.lieuDays.all, "list"],
+    balance: () => [...queryKeys.lieuDays.all, "balance"],
+    detail: (id) => [...queryKeys.lieuDays.all, "detail", id]
+  },
+  efLinks: {
+    all: ["efLinks"],
+    list: () => [...queryKeys.efLinks.all, "list"],
+    detail: (id) => [...queryKeys.efLinks.all, "detail", id]
+  },
+  // -------------------------------------------------------------------------
+  // Banking
+  // -------------------------------------------------------------------------
+  bankConnections: {
+    all: ["bankConnections"],
+    list: () => [...queryKeys.bankConnections.all, "list"],
+    detail: (id) => [...queryKeys.bankConnections.all, "detail", id]
+  },
+  bankTransactions: {
+    all: ["bankTransactions"],
+    lists: () => [...queryKeys.bankTransactions.all, "list"],
+    list: (filters) => [...queryKeys.bankTransactions.lists(), filters],
+    stats: (connectionId) => [...queryKeys.bankTransactions.all, "stats", connectionId]
+  },
+  // -------------------------------------------------------------------------
+  // Health
+  // -------------------------------------------------------------------------
+  healthCategories: {
+    all: ["healthCategories"],
+    list: () => [...queryKeys.healthCategories.all, "list"],
+    detail: (id) => [...queryKeys.healthCategories.all, "detail", id]
+  },
+  healthHabits: {
+    all: ["healthHabits"],
+    lists: () => [...queryKeys.healthHabits.all, "list"],
+    list: (filters) => [...queryKeys.healthHabits.lists(), filters],
+    detail: (id) => [...queryKeys.healthHabits.all, "detail", id]
+  },
+  healthCompletions: {
+    all: ["healthCompletions"],
+    lists: () => [...queryKeys.healthCompletions.all, "list"],
+    list: (filters) => [...queryKeys.healthCompletions.lists(), filters],
+    forHabit: (habitId) => [...queryKeys.healthCompletions.all, "habit", habitId],
+    forDate: (date) => [...queryKeys.healthCompletions.all, "date", date]
+  },
+  healthStats: {
+    all: ["healthStats"],
+    forDate: (date) => [...queryKeys.healthStats.all, date ?? "today"]
+  },
+  // -------------------------------------------------------------------------
+  // Prompts
+  // -------------------------------------------------------------------------
+  promptCategories: {
+    all: ["promptCategories"],
+    list: () => [...queryKeys.promptCategories.all, "list"],
+    detail: (id) => [...queryKeys.promptCategories.all, "detail", id]
+  },
+  promptLabels: {
+    all: ["promptLabels"],
+    list: () => [...queryKeys.promptLabels.all, "list"],
+    detail: (id) => [...queryKeys.promptLabels.all, "detail", id]
+  },
+  prompts: {
+    all: ["prompts"],
+    lists: () => [...queryKeys.prompts.all, "list"],
+    list: (filters) => [...queryKeys.prompts.lists(), filters],
+    detail: (id) => [...queryKeys.prompts.all, "detail", id]
+  },
+  // -------------------------------------------------------------------------
+  // Training
+  // -------------------------------------------------------------------------
+  trainingActivities: {
+    all: ["trainingActivities"],
+    list: () => [...queryKeys.trainingActivities.all, "list"],
+    detail: (id) => [...queryKeys.trainingActivities.all, "detail", id],
+    byStravaType: (stravaType) => [...queryKeys.trainingActivities.all, "strava", stravaType]
+  },
+  trainingSessions: {
+    all: ["trainingSessions"],
+    lists: () => [...queryKeys.trainingSessions.all, "list"],
+    list: (filters) => [...queryKeys.trainingSessions.lists(), filters],
+    detail: (id) => [...queryKeys.trainingSessions.all, "detail", id],
+    byStravaId: (stravaActivityId) => [...queryKeys.trainingSessions.all, "strava", stravaActivityId]
+  },
+  plannedSessions: {
+    all: ["plannedSessions"],
+    lists: () => [...queryKeys.plannedSessions.all, "list"],
+    list: (filters) => [...queryKeys.plannedSessions.lists(), filters],
+    detail: (id) => [...queryKeys.plannedSessions.all, "detail", id],
+    upcoming: () => [...queryKeys.plannedSessions.all, "upcoming"]
+  },
+  races: {
+    all: ["races"],
+    lists: () => [...queryKeys.races.all, "list"],
+    list: (filters) => [...queryKeys.races.lists(), filters],
+    detail: (id) => [...queryKeys.races.all, "detail", id],
+    next: () => [...queryKeys.races.all, "next"]
+  },
+  trainingStats: {
+    all: ["trainingStats"],
+    forRange: (dateFrom, dateTo) => [...queryKeys.trainingStats.all, dateFrom, dateTo]
+  },
+  // Strava
+  strava: {
+    all: ["strava"],
+    athlete: () => [...queryKeys.strava.all, "athlete"],
+    connected: () => [...queryKeys.strava.all, "connected"],
+    activities: (options) => [...queryKeys.strava.all, "activities", options]
+  },
+  // -------------------------------------------------------------------------
+  // Journal
+  // -------------------------------------------------------------------------
+  journalEntries: {
+    all: ["journalEntries"],
+    lists: () => [...queryKeys.journalEntries.all, "list"],
+    list: (filters) => [...queryKeys.journalEntries.lists(), filters],
+    forDate: (date) => [...queryKeys.journalEntries.all, "date", date]
+  },
+  // Journal data (aggregated)
+  journalData: {
+    all: ["journalData"],
+    forDate: (date) => [...queryKeys.journalData.all, date]
+  },
+  // -------------------------------------------------------------------------
+  // Chat
+  // -------------------------------------------------------------------------
+  chatConversations: {
+    all: ["chatConversations"],
+    list: () => [...queryKeys.chatConversations.all, "list"],
+    detail: (id) => [...queryKeys.chatConversations.all, "detail", id]
+  },
+  chatMessages: {
+    all: ["chatMessages"],
+    forConversation: (conversationId) => [...queryKeys.chatMessages.all, "conversation", conversationId]
+  },
+  // -------------------------------------------------------------------------
+  // Google Calendar
+  // -------------------------------------------------------------------------
+  googleCalendar: {
+    all: ["googleCalendar"],
+    calendars: () => [...queryKeys.googleCalendar.all, "calendars"],
+    events: (calendarId, timeMin, timeMax) => [...queryKeys.googleCalendar.all, "events", calendarId, timeMin, timeMax]
+  },
+  // -------------------------------------------------------------------------
+  // Linear
+  // -------------------------------------------------------------------------
+  linear: {
+    all: ["linear"],
+    issues: (filters) => [...queryKeys.linear.all, "issues", filters],
+    projects: () => [...queryKeys.linear.all, "projects"]
+  }
+};
+
+// src/atoms/focus.ts
+var import_jotai = require("jotai");
+var timerStatusAtom = (0, import_jotai.atom)("idle");
+var targetSecondsAtom = (0, import_jotai.atom)(25 * 60);
+var elapsedSecondsAtom = (0, import_jotai.atom)(0);
+var activeSessionAtom = (0, import_jotai.atom)(null);
+var remainingSecondsAtom = (0, import_jotai.atom)((get) => {
+  const target = get(targetSecondsAtom);
+  const elapsed = get(elapsedSecondsAtom);
+  return Math.max(0, target - elapsed);
+});
+var progressAtom = (0, import_jotai.atom)((get) => {
+  const target = get(targetSecondsAtom);
+  const elapsed = get(elapsedSecondsAtom);
+  if (target === 0) return 0;
+  return Math.min(1, elapsed / target);
+});
+var formattedRemainingAtom = (0, import_jotai.atom)((get) => {
+  return formatTime(get(remainingSecondsAtom));
+});
+var formattedElapsedAtom = (0, import_jotai.atom)((get) => {
+  return formatTime(get(elapsedSecondsAtom));
+});
+var progressPercentAtom = (0, import_jotai.atom)((get) => {
+  return get(progressAtom) * 100;
+});
+
+// src/date/index.ts
+function normalizeToMidnight(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function getTodayMidnight() {
+  return normalizeToMidnight(/* @__PURE__ */ new Date());
+}
+function formatDateString(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function getTodayString() {
+  return formatDateString(/* @__PURE__ */ new Date());
+}
+function parseLocalDate(dateStr) {
+  return /* @__PURE__ */ new Date(dateStr + "T00:00:00");
+}
+function isToday(dateStr) {
+  if (!dateStr) return false;
+  return dateStr === getTodayString();
+}
+function isOverdue(dateStr) {
+  if (!dateStr) return false;
+  return dateStr < getTodayString();
+}
+function isDueSoon(dateStr, daysThreshold = 7) {
+  if (!dateStr) return false;
+  if (isOverdue(dateStr)) return false;
+  const today = getTodayMidnight();
+  const targetDate = parseLocalDate(dateStr);
+  const diffMs = targetDate.getTime() - today.getTime();
+  const diffDays = Math.ceil(diffMs / (1e3 * 60 * 60 * 24));
+  return diffDays >= 0 && diffDays <= daysThreshold;
+}
+function addDays(dateStr, days) {
+  const date = parseLocalDate(dateStr);
+  date.setDate(date.getDate() + days);
+  return formatDateString(date);
+}
+function subtractDays(dateStr, days) {
+  return addDays(dateStr, -days);
+}
+function getYesterdayString() {
+  return subtractDays(getTodayString(), 1);
+}
+function getTomorrowString() {
+  return addDays(getTodayString(), 1);
+}
+function getStartOfDayISO(dateStr) {
+  const date = parseLocalDate(dateStr);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate()).toISOString();
+}
+function getEndOfDayISO(dateStr) {
+  const date = parseLocalDate(dateStr);
+  return new Date(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    23,
+    59,
+    59,
+    999
+  ).toISOString();
+}
+function getWeekStart(date) {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = d.getDate() - day + (day === 0 ? -6 : 1);
+  d.setDate(diff);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function getWeekEnd(weekStart) {
+  const d = new Date(weekStart);
+  d.setDate(d.getDate() + 6);
+  return d;
+}
+function getPreviousWeek(weekStart) {
+  const d = new Date(weekStart);
+  d.setDate(d.getDate() - 7);
+  return d;
+}
+function getNextWeek(weekStart) {
+  const d = new Date(weekStart);
+  d.setDate(d.getDate() + 7);
+  return d;
+}
+function getWeekStartString(baseDate = /* @__PURE__ */ new Date()) {
+  return formatDateString(getWeekStart(baseDate));
+}
+function getWeekEndString(baseDate = /* @__PURE__ */ new Date()) {
+  return formatDateString(getWeekEnd(getWeekStart(baseDate)));
+}
+function formatWeekRange(weekStart) {
+  const weekEnd = getWeekEnd(weekStart);
+  const startMonth = weekStart.toLocaleDateString("en-US", { month: "short" });
+  const endMonth = weekEnd.toLocaleDateString("en-US", { month: "short" });
+  if (startMonth === endMonth) {
+    return `${startMonth} ${weekStart.getDate()} - ${weekEnd.getDate()}, ${weekStart.getFullYear()}`;
+  }
+  return `${startMonth} ${weekStart.getDate()} - ${endMonth} ${weekEnd.getDate()}, ${weekStart.getFullYear()}`;
+}
+function formatFullDate(dateStr) {
+  const date = parseLocalDate(dateStr);
+  return date.toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function formatDateLong(dateStr) {
+  const date = parseLocalDate(dateStr);
+  return date.toLocaleDateString("en-GB", {
+    weekday: "long",
+    day: "numeric",
+    month: "long"
+  });
+}
+function formatMonthYear(date) {
+  return date.toLocaleDateString("en-US", {
+    month: "long",
+    year: "numeric"
+  });
+}
+function formatTimeHHMM(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
+function formatTimeWithSeconds(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+function formatDateHeader(dateStr) {
+  const today = getTodayString();
+  if (dateStr < today) {
+    return "Overdue";
+  }
+  if (dateStr === today) {
+    return "Today";
+  }
+  const tomorrowStr = getTomorrowString();
+  if (dateStr === tomorrowStr) {
+    return "Tomorrow";
+  }
+  const date = parseLocalDate(dateStr);
+  return date.toLocaleDateString("en-US", {
+    weekday: "long",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatDueDateString(dateStr) {
+  if (!dateStr) return "No due date";
+  const today = getTodayString();
+  const tomorrowStr = getTomorrowString();
+  if (dateStr < today) {
+    const date2 = parseLocalDate(dateStr);
+    return `Overdue \u2022 ${date2.toLocaleDateString("en-US", { month: "short", day: "numeric" })}`;
+  }
+  if (dateStr === today) {
+    return "Today";
+  }
+  if (dateStr === tomorrowStr) {
+    return "Tomorrow";
+  }
+  const date = parseLocalDate(dateStr);
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const dateYear = date.getFullYear();
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: dateYear !== currentYear ? "numeric" : void 0
+  });
+}
+function formatRelativeTimeExtended(dateStr) {
+  const date = typeof dateStr === "string" ? new Date(dateStr) : dateStr;
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffMins < 1) return "Just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+function formatRelativeDueDate(dateStr, options) {
+  const { duePrefix = "Due", overduePrefix = "" } = options || {};
+  const date = parseLocalDate(dateStr);
+  const now = normalizeToMidnight(/* @__PURE__ */ new Date());
+  const diffMs = date.getTime() - now.getTime();
+  const diffDays = Math.round(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays < 0) {
+    const absDays = Math.abs(diffDays);
+    return overduePrefix ? `${overduePrefix} ${absDays} day${absDays !== 1 ? "s" : ""} overdue` : `${absDays} day${absDays !== 1 ? "s" : ""} overdue`;
+  }
+  if (diffDays === 0) return `${duePrefix} today`;
+  if (diffDays === 1) return `${duePrefix} tomorrow`;
+  if (diffDays <= 7) return `${duePrefix} in ${diffDays} days`;
+  return date.toLocaleDateString("en-GB", { day: "numeric", month: "short" });
+}
+function formatRelativePayDate(dateStr) {
+  const date = parseLocalDate(dateStr);
+  const now = normalizeToMidnight(/* @__PURE__ */ new Date());
+  const diffMs = date.getTime() - now.getTime();
+  const diffDays = Math.round(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays < 0) {
+    const absDays = Math.abs(diffDays);
+    return `${absDays} day${absDays !== 1 ? "s" : ""} ago`;
+  }
+  if (diffDays === 0) return "Today";
+  if (diffDays === 1) return "Tomorrow";
+  if (diffDays <= 7) return `In ${diffDays} days`;
+  return date.toLocaleDateString("en-GB", { day: "numeric", month: "short" });
+}
+function formatDateLocalized(date, format = "medium") {
+  const d = typeof date === "string" ? new Date(date) : date;
+  switch (format) {
+    case "short":
+      return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    case "medium":
+      return d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+    case "long":
+      return d.toLocaleDateString("en-US", {
+        weekday: "long",
+        month: "long",
+        day: "numeric",
+        year: "numeric"
+      });
+    case "weekday":
+      return d.toLocaleDateString("en-US", { weekday: "short" });
+    default:
+      return d.toLocaleDateString();
+  }
+}
+function formatTimeLocalized(date, format = "short") {
+  const d = typeof date === "string" ? new Date(date) : date;
+  switch (format) {
+    case "short":
+      return d.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: true });
+    case "withSeconds":
+      return d.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: true
+      });
+    default:
+      return d.toLocaleTimeString();
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   API_URLS,
@@ -381,29 +948,73 @@ function calculateFocusStats(sessions) {
   LINEAR_PRIORITY_COLORS,
   LINEAR_PRIORITY_LABELS,
   SETTING_KEYS,
+  activeSessionAtom,
+  addDays,
   calculateFocusStats,
   calculateLieuBalance,
   calculateMonthlyExpenses,
   calculateMonthlyIncome,
   calculateMonthlySavings,
   calculateSavingsRate,
+  elapsedSecondsAtom,
   formatCurrency,
   formatDate,
+  formatDateHeader,
+  formatDateLocalized,
+  formatDateLong,
+  formatDateString,
   formatDueDate,
+  formatDueDateString,
+  formatDuration,
+  formatFullDate,
+  formatMonthYear,
+  formatRelativeDueDate,
+  formatRelativePayDate,
   formatRelativeTime,
+  formatRelativeTimeExtended,
   formatTime,
+  formatTimeHHMM,
+  formatTimeLocalized,
+  formatTimeWithSeconds,
   formatTotalTime,
+  formatWeekRange,
+  formattedElapsedAtom,
+  formattedRemainingAtom,
   generateId,
   generateRandomColor,
   generateShortId,
+  getEndOfDayISO,
+  getNextWeek,
+  getPreviousWeek,
   getRepoName,
+  getStartOfDayISO,
+  getTodayMidnight,
+  getTodayString,
+  getTomorrowString,
+  getWeekEnd,
+  getWeekEndString,
+  getWeekStart,
+  getWeekStartString,
+  getYesterdayString,
+  isDueSoon,
   isNonEmptyString,
+  isOverdue,
   isPositiveNumber,
+  isToday,
   isValidCurrency,
   isValidEmail,
   isValidFrequency,
   isValidISODate,
   isValidUrl,
+  normalizeToMidnight,
+  parseLocalDate,
+  progressAtom,
+  progressPercentAtom,
+  queryKeys,
+  remainingSecondsAtom,
+  subtractDays,
+  targetSecondsAtom,
+  timerStatusAtom,
   toMonthlyAmount,
   toYearlyAmount,
   truncate