@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/dashboardQuickSearchQuery.ts

@@ -0,0 +1,179 @@
+import type { DashboardSearchItem } from "@/lib/dashboardQuickSearch";
+
+export type DurationSearchPredicate = { op: "lt" | "gt"; seconds: number };
+
+function timeToSeconds2(m: number, s: number): number {
+  return m * 60 + s;
+}
+
+function timeToSeconds3(h: number, m: number, s: number): number {
+  return h * 3600 + m * 60 + s;
+}
+
+type Parsed = { op: "lt" | "gt"; seconds: number; match: string };
+
+function asOp(s: string): "lt" | "gt" | null {
+  if (s === ">") {
+    return "gt";
+  }
+  if (s === "<") {
+    return "lt";
+  }
+  return null;
+}
+
+/** Cherche le plus tôt { index, kind, groups } en essayant 4 formes, triées par longueur de match décroissante. */
+function findFirstDurationClause(s: string, from: number): Parsed | null {
+  const attempts: Array<() => Parsed | null> = [
+    () => {
+      const m = s.slice(from).match(/^(\d+):(\d+):(\d+)\s*([><])/);
+      if (!m) {
+        return null;
+      }
+      const o = asOp(m[4]!);
+      if (!o) {
+        return null;
+      }
+      const a = Number(m[1]);
+      const b = Number(m[2]);
+      const c = Number(m[3]);
+      if (![a, b, c].every((x) => Number.isFinite(x) && x >= 0)) {
+        return null;
+      }
+      return { op: o, seconds: timeToSeconds3(a, b, c), match: m[0]! };
+    },
+    () => {
+      const m = s.slice(from).match(/^([><])\s*(\d+):(\d+):(\d+)/);
+      if (!m) {
+        return null;
+      }
+      const o = asOp(m[1]!);
+      if (!o) {
+        return null;
+      }
+      const a = Number(m[2]);
+      const b = Number(m[3]);
+      const c = Number(m[4]);
+      if (![a, b, c].every((x) => Number.isFinite(x) && x >= 0)) {
+        return null;
+      }
+      return { op: o, seconds: timeToSeconds3(a, b, c), match: m[0]! };
+    },
+    () => {
+      const m = s.slice(from).match(/^(\d+):(\d+)\s*([><])/);
+      if (!m) {
+        return null;
+      }
+      const o = asOp(m[3]!);
+      if (!o) {
+        return null;
+      }
+      const a = Number(m[1]);
+      const b = Number(m[2]);
+      if (![a, b].every((x) => Number.isFinite(x) && x >= 0)) {
+        return null;
+      }
+      return { op: o, seconds: timeToSeconds2(a, b), match: m[0]! };
+    },
+    () => {
+      const m = s.slice(from).match(/^([><])\s*(\d+):(\d+)/);
+      if (!m) {
+        return null;
+      }
+      const o = asOp(m[1]!);
+      if (!o) {
+        return null;
+      }
+      const a = Number(m[2]);
+      const b = Number(m[3]);
+      if (![a, b].every((x) => Number.isFinite(x) && x >= 0)) {
+        return null;
+      }
+      return { op: o, seconds: timeToSeconds2(a, b), match: m[0]! };
+    },
+  ];
+  for (const tryAt of attempts) {
+    const p = tryAt();
+    if (p) {
+      return p;
+    }
+  }
+  return null;
+}
+
+/**
+ * Découpe la requête : prédicats de durée (tous requis) et
+ * le reste pour le filtrage sur le haystack.
+ */
+export function parseDataSearchQuery(raw: string): {
+  textPart: string;
+  durationPredicates: DurationSearchPredicate[];
+} {
+  const seen = new Set<string>();
+  const durationPredicates: DurationSearchPredicate[] = [];
+  const add = (p: Parsed) => {
+    const row: DurationSearchPredicate = { op: p.op, seconds: p.seconds };
+    const k = `${row.op}\0${row.seconds}`;
+    if (!seen.has(k)) {
+      seen.add(k);
+      durationPredicates.push(row);
+    }
+  };
+
+  let t = String(raw)
+    .replace(/\r\n/g, "\n")
+    .replace(/\n/g, " ");
+  let from = 0;
+  while (from < t.length) {
+    if (!/[\d><]/.test(t[from]!)) {
+      from += 1;
+      continue;
+    }
+    const p = findFirstDurationClause(t, from);
+    if (p) {
+      add(p);
+      t = `${t.slice(0, from)} ${t.slice(from + p.match.length)}`;
+      from = 0;
+    } else {
+      from += 1;
+    }
+  }
+  const textPart = t.replace(/\s+/g, " ").trim().toLowerCase();
+  return {
+    textPart,
+    durationPredicates,
+  };
+}
+
+function itemPassesDuration(
+  item: DashboardSearchItem,
+  predicates: DurationSearchPredicate[]
+): boolean {
+  if (predicates.length === 0) {
+    return true;
+  }
+  const sec = item.durationForSearchSec;
+  if (sec === undefined || !Number.isFinite(sec)) {
+    return false;
+  }
+  for (const p of predicates) {
+    if (p.op === "gt" && sec <= p.seconds) {
+      return false;
+    }
+    if (p.op === "lt" && sec >= p.seconds) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function dataSearchItemMatches(
+  item: DashboardSearchItem,
+  queryTrimmed: string
+): boolean {
+  const { textPart, durationPredicates } = parseDataSearchQuery(queryTrimmed);
+  if (textPart.length > 0 && !item.haystack.includes(textPart)) {
+    return false;
+  }
+  return itemPassesDuration(item, durationPredicates);
+}

package/lib/dashboardSessionNav.ts

@@ -0,0 +1,33 @@
+/**
+ * Ajoute `session` à l’URL pour conserver la session du tableau de bord lors des changements de route.
+ * La query est insérée avant le fragment (`#…`), conformément aux URI.
+ */
+export function withDashboardSessionParam(path: string, sessionId: string | null | undefined): string {
+  const id = typeof sessionId === "string" ? sessionId.trim() : "";
+  if (!id) {
+    return path;
+  }
+  const hashIndex = path.indexOf("#");
+  const base = hashIndex >= 0 ? path.slice(0, hashIndex) : path;
+  const hash = hashIndex >= 0 ? path.slice(hashIndex) : "";
+  const joiner = base.includes("?") ? "&" : "?";
+  return `${base}${joiner}session=${encodeURIComponent(id)}${hash}`;
+}
+
+/**
+ * Met à jour ou retire `session` dans la query en conservant les autres paramètres (ex. `tour`).
+ */
+export function pathnameWithUpdatedSessionQuery(
+  pathname: string,
+  currentSearch: string,
+  sessionId: string | null
+): string {
+  const next = new URLSearchParams(currentSearch);
+  if (sessionId === null || sessionId === "") {
+    next.delete("session");
+  } else {
+    next.set("session", sessionId);
+  }
+  const q = next.toString();
+  return q ? `${pathname}?${q}` : pathname;
+}

package/lib/dashboardShortcuts.ts

@@ -0,0 +1,268 @@
+/** Stockage local des raccourcis personnalisés (tableau de bord). */
+export const DASHBOARD_SHORTCUTS_STORAGE_KEY = "kronosys.dashboard.keybindings.v1";
+
+/** Combinaisons par défaut (identifiant d’action → chaîne `ctrl+alt+n`, etc.). */
+export const DEFAULT_DASHBOARD_COMBOS: Record<string, string> = {
+  "new-session": "alt+shift+n",
+  refresh: "alt+shift+r",
+  reporting: "alt+shift+g",
+  settings: "alt+shift+s",
+  "user-guide": "alt+shift+u",
+  "focus-sessions": "ctrl+alt+h",
+  "focus-tasks": "ctrl+alt+j",
+  "focus-tags": "ctrl+alt+y",
+  "toggle-theme": "alt+shift+t",
+  "toggle-lang": "alt+shift+l",
+  "end-live-session": "alt+shift+e",
+};
+
+export type ParsedCombo = {
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  alt: boolean;
+  /** Touche logique : lettre minuscule, `digit1`…`digit9`, ou noms `escape`, `enter`… */
+  key: string;
+};
+
+const MODS = new Set([
+  "ctrl",
+  "control",
+  "meta",
+  "cmd",
+  "command",
+  "shift",
+  "alt",
+  "option",
+]);
+
+export function parseComboString(raw: string): ParsedCombo | null {
+  const s = raw.trim().toLowerCase();
+  if (!s) {
+    return null;
+  }
+  const parts = s.split("+").map((x) => x.trim());
+  let ctrl = false;
+  let meta = false;
+  let shift = false;
+  let alt = false;
+  let key = "";
+  for (const p of parts) {
+    if (!p) {
+      continue;
+    }
+    if (MODS.has(p)) {
+      if (p === "ctrl" || p === "control") {
+        ctrl = true;
+      }
+      if (p === "meta" || p === "cmd" || p === "command") {
+        meta = true;
+      }
+      if (p === "shift") {
+        shift = true;
+      }
+      if (p === "alt" || p === "option") {
+        alt = true;
+      }
+      continue;
+    }
+    key = p;
+  }
+  if (!key) {
+    return null;
+  }
+  if (key === "space") {
+    key = " ";
+  }
+  const digit = key.match(/^digit([0-9])$/);
+  if (digit) {
+    key = digit[1] ?? key;
+  }
+  return { ctrl, meta, shift, alt, key };
+}
+
+function eventKeyToken(e: KeyboardEvent): string {
+  const code = typeof e.code === "string" ? e.code : "";
+  if (code.startsWith("Digit") && code.length === 6) {
+    return code.slice(5).toLowerCase();
+  }
+  if (code === "Space") {
+    return " ";
+  }
+  const key = typeof e.key === "string" ? e.key : "";
+  if (key.length === 1) {
+    return key.toLowerCase();
+  }
+  if (key) {
+    return key.toLowerCase();
+  }
+  if (code.startsWith("Key") && code.length === 4) {
+    return code.slice(3).toLowerCase();
+  }
+  return "";
+}
+
+/** Vérifie si `e` correspond à la combinaison (modificateurs + touche). */
+export function eventMatchesCombo(e: KeyboardEvent, combo: string): boolean {
+  const p = parseComboString(combo);
+  if (!p) {
+    return false;
+  }
+  const token = eventKeyToken(e);
+  const rawKey = typeof e.key === "string" ? e.key : "";
+  const rawCode = typeof e.code === "string" ? e.code : "";
+  if (token !== p.key && !(p.key === " " && (rawKey === " " || rawCode === "Space"))) {
+    return false;
+  }
+  if (e.ctrlKey !== p.ctrl) {
+    return false;
+  }
+  if (e.metaKey !== p.meta) {
+    return false;
+  }
+  if (e.shiftKey !== p.shift) {
+    return false;
+  }
+  if (e.altKey !== p.alt) {
+    return false;
+  }
+  return true;
+}
+
+/** Palette : Ctrl+K ou Cmd+K (sans autre modificateur). */
+export function eventOpensCommandPalette(e: KeyboardEvent): boolean {
+  const rawKey = typeof e.key === "string" ? e.key : "";
+  const rawCode = typeof e.code === "string" ? e.code : "";
+  const isK = rawKey.toLowerCase() === "k" || rawCode === "KeyK";
+  if (!isK) {
+    return false;
+  }
+  if (e.shiftKey || e.altKey) {
+    return false;
+  }
+  return e.ctrlKey || e.metaKey;
+}
+
+export function loadComboOverrides(): Record<string, string> {
+  if (typeof window === "undefined") {
+    return {};
+  }
+  try {
+    const raw = window.localStorage.getItem(DASHBOARD_SHORTCUTS_STORAGE_KEY);
+    if (!raw) {
+      return {};
+    }
+    const o = JSON.parse(raw) as unknown;
+    if (!o || typeof o !== "object" || Array.isArray(o)) {
+      return {};
+    }
+    const out: Record<string, string> = {};
+    for (const [k, v] of Object.entries(o as Record<string, unknown>)) {
+      if (typeof v === "string" && v.trim()) {
+        out[k] = v.trim().toLowerCase();
+      }
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+export function saveComboOverrides(overrides: Record<string, string>): void {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    window.localStorage.setItem(DASHBOARD_SHORTCUTS_STORAGE_KEY, JSON.stringify(overrides));
+  } catch {
+    /* quota / mode privé */
+  }
+}
+
+export function mergeCombos(overrides: Record<string, string>): Record<string, string> {
+  return { ...DEFAULT_DASHBOARD_COMBOS, ...overrides };
+}
+
+/** Sérialise un événement clavier (hors touches seules type Shift) pour enregistrement. */
+export function serializeEventAsCombo(e: KeyboardEvent): string | null {
+  if (e.repeat) {
+    return null;
+  }
+  const keyTok = eventKeyToken(e);
+  if (!keyTok || keyTok === "control" || keyTok === "meta" || keyTok === "shift" || keyTok === "alt") {
+    return null;
+  }
+  if (typeof e.key === "string" && e.key === "Escape") {
+    return null;
+  }
+  const parts: string[] = [];
+  if (e.ctrlKey) {
+    parts.push("ctrl");
+  }
+  if (e.metaKey) {
+    parts.push("meta");
+  }
+  if (e.shiftKey) {
+    parts.push("shift");
+  }
+  if (e.altKey) {
+    parts.push("alt");
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  const rawCode = typeof e.code === "string" ? e.code : "";
+  const rawKey = typeof e.key === "string" ? e.key : "";
+  const k =
+    rawCode.startsWith("Digit") && rawCode.length === 6
+      ? rawCode.slice(5).toLowerCase()
+      : rawCode === "Space" || rawKey === " "
+        ? "space"
+        : keyTok.length === 1
+          ? keyTok
+          : rawKey.length === 1
+            ? rawKey.toLowerCase()
+            : keyTok;
+  if (!k) {
+    return null;
+  }
+  parts.push(k);
+  return parts.join("+");
+}
+
+export function isReservedPaletteCombo(combo: string): boolean {
+  const p = parseComboString(combo);
+  if (!p) {
+    return true;
+  }
+  const mod = p.ctrl || p.meta;
+  return mod && !p.shift && !p.alt && p.key === "k";
+}
+
+export function formatComboForDisplay(combo: string, isMac: boolean): string {
+  const p = parseComboString(combo);
+  if (!p) {
+    return combo;
+  }
+  const bits: string[] = [];
+  if (p.ctrl) {
+    bits.push(isMac ? "⌃" : "Ctrl");
+  }
+  if (p.meta) {
+    bits.push(isMac ? "⌘" : "Win");
+  }
+  if (p.shift) {
+    bits.push(isMac ? "⇧" : "Shift");
+  }
+  if (p.alt) {
+    bits.push(isMac ? "⌥" : "Alt");
+  }
+  const k =
+    p.key === " "
+      ? "Space"
+      : p.key.length === 1
+        ? p.key.toUpperCase()
+        : p.key.charAt(0).toUpperCase() + p.key.slice(1);
+  bits.push(k);
+  return bits.join(isMac ? "" : "+");
+}

package/lib/dashboardTimeZone.ts

@@ -0,0 +1,91 @@
+/** Fuseau IANA par défaut : heure de l’Est (Amérique du Nord). */
+export const DEFAULT_DASHBOARD_TIME_ZONE = "America/Toronto";
+
+const CFG_KEY = "dashboardDisplayTimeZone";
+
+/** Libellés pour la liste déroulante des paramètres (clé = identifiant IANA). */
+export const DASHBOARD_TIME_ZONE_SELECT_OPTIONS: readonly {
+  id: string;
+  labelEn: string;
+  labelFr: string;
+}[] = [
+  { id: "America/Toronto", labelEn: "Eastern — Toronto", labelFr: "Heure de l’Est — Toronto" },
+  { id: "America/New_York", labelEn: "Eastern — New York", labelFr: "Heure de l’Est — New York" },
+  { id: "America/Chicago", labelEn: "Central — Chicago", labelFr: "Heure du Centre — Chicago" },
+  { id: "America/Denver", labelEn: "Mountain — Denver", labelFr: "Heure des Rocheuses — Denver" },
+  { id: "America/Los_Angeles", labelEn: "Pacific — Los Angeles", labelFr: "Heure du Pacifique — Los Angeles" },
+  { id: "America/Vancouver", labelEn: "Pacific — Vancouver", labelFr: "Heure du Pacifique — Vancouver" },
+  { id: "America/Halifax", labelEn: "Atlantic — Halifax", labelFr: "Heure de l’Atlantique — Halifax" },
+  { id: "America/St_Johns", labelEn: "Newfoundland — St. John’s", labelFr: "Terre-Neuve — Saint-Jean" },
+  { id: "America/Mexico_City", labelEn: "Central — Mexico City", labelFr: "Heure du Centre — Mexico" },
+  { id: "America/Sao_Paulo", labelEn: "São Paulo", labelFr: "São Paulo" },
+  { id: "Europe/London", labelEn: "London", labelFr: "Londres" },
+  { id: "Europe/Paris", labelEn: "Paris", labelFr: "Paris" },
+  { id: "Europe/Berlin", labelEn: "Berlin", labelFr: "Berlin" },
+  { id: "Europe/Madrid", labelEn: "Madrid", labelFr: "Madrid" },
+  { id: "Europe/Zurich", labelEn: "Zurich", labelFr: "Zurich" },
+  { id: "Asia/Tokyo", labelEn: "Tokyo", labelFr: "Tokyo" },
+  { id: "Asia/Seoul", labelEn: "Seoul", labelFr: "Séoul" },
+  { id: "Asia/Shanghai", labelEn: "Shanghai", labelFr: "Shanghai" },
+  { id: "Asia/Singapore", labelEn: "Singapore", labelFr: "Singapour" },
+  { id: "Asia/Kolkata", labelEn: "India", labelFr: "Inde" },
+  { id: "Australia/Sydney", labelEn: "Sydney", labelFr: "Sydney" },
+  { id: "Pacific/Auckland", labelEn: "Auckland", labelFr: "Auckland" },
+  { id: "UTC", labelEn: "UTC", labelFr: "UTC" },
+];
+
+export function isValidIanaTimeZone(tz: string): boolean {
+  const t = tz.trim();
+  if (!t) {
+    return false;
+  }
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: t }).format();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readDashboardTimeZoneFromCfg(cfg: Record<string, unknown> | undefined): string {
+  const raw = cfg?.[CFG_KEY];
+  if (typeof raw !== "string") {
+    return DEFAULT_DASHBOARD_TIME_ZONE;
+  }
+  const z = raw.trim();
+  return z && isValidIanaTimeZone(z) ? z : DEFAULT_DASHBOARD_TIME_ZONE;
+}
+
+/**
+ * Jour calendaire `YYYY-MM-DD` dans le fuseau donné (pour regroupements rapport / filtres).
+ */
+export function calendarDateKeyInTimeZone(iso: string | null | undefined, timeZone: string): string | null {
+  if (!iso || typeof iso !== "string") {
+    return null;
+  }
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) {
+    return null;
+  }
+  const tz = timeZone.trim() || DEFAULT_DASHBOARD_TIME_ZONE;
+  if (!isValidIanaTimeZone(tz)) {
+    return null;
+  }
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: tz,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    }).formatToParts(d);
+    const y = parts.find((p) => p.type === "year")?.value;
+    const m = parts.find((p) => p.type === "month")?.value;
+    const day = parts.find((p) => p.type === "day")?.value;
+    if (!y || !m || !day) {
+      return null;
+    }
+    return `${y}-${m}-${day}`;
+  } catch {
+    return null;
+  }
+}

package/lib/dashboardTourStorage.ts

@@ -0,0 +1,68 @@
+/** Indique que la visite guidée du tableau de bord a été vue (ou passée). */
+export const DASHBOARD_TOUR_COMPLETED_KEY = "kronosys.dashboard.tour.completed.v1";
+/** Indique que la visite guidée des paramètres a été vue (ou passée). */
+export const SETTINGS_TOUR_COMPLETED_KEY = "kronosys.settings.tour.completed.v1";
+/** Indique que la visite guidée de la page Rapports a été vue (ou passée). */
+export const REPORTING_TOUR_COMPLETED_KEY = "kronosys.reporting.tour.completed.v1";
+
+function isCompleted(key: string): boolean {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  try {
+    return window.localStorage.getItem(key) === "1";
+  } catch {
+    return false;
+  }
+}
+
+function markCompleted(key: string, value: boolean): void {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    if (value) {
+      window.localStorage.setItem(key, "1");
+    } else {
+      window.localStorage.removeItem(key);
+    }
+  } catch {
+    /* quota / navigation privée */
+  }
+}
+
+export function isDashboardTourCompleted(): boolean {
+  return isCompleted(DASHBOARD_TOUR_COMPLETED_KEY);
+}
+
+export function markDashboardTourCompleted(): void {
+  markCompleted(DASHBOARD_TOUR_COMPLETED_KEY, true);
+}
+
+export function resetDashboardTour(): void {
+  markCompleted(DASHBOARD_TOUR_COMPLETED_KEY, false);
+}
+
+export function isSettingsTourCompleted(): boolean {
+  return isCompleted(SETTINGS_TOUR_COMPLETED_KEY);
+}
+
+export function markSettingsTourCompleted(): void {
+  markCompleted(SETTINGS_TOUR_COMPLETED_KEY, true);
+}
+
+export function resetSettingsTour(): void {
+  markCompleted(SETTINGS_TOUR_COMPLETED_KEY, false);
+}
+
+export function isReportingTourCompleted(): boolean {
+  return isCompleted(REPORTING_TOUR_COMPLETED_KEY);
+}
+
+export function markReportingTourCompleted(): void {
+  markCompleted(REPORTING_TOUR_COMPLETED_KEY, true);
+}
+
+export function resetReportingTour(): void {
+  markCompleted(REPORTING_TOUR_COMPLETED_KEY, false);
+}