trekoon 0.3.6 → 0.3.8

package/src/board/assets/state/utils.js

@@ -27,10 +27,23 @@ function normalizeArray(value) {
 
 /**
  * @param {{ id?: string }} record
- * @returns {string}
+ * @returns {string|null}
  */
 function getId(record) {
-  return typeof record?.id === "string" && record.id.length > 0 ? record.id : crypto.randomUUID();
+  return typeof record?.id === "string" && record.id.length > 0 ? record.id : null;
+}
+
+function normalizeTimestamp(value, fallback) {
+  const normalized = Number(value);
+  return Number.isFinite(normalized) && normalized > 0 ? normalized : fallback;
+}
+
+function normalizeText(value, fallback = "") {
+  return String(value ?? fallback).replace(/\\n/g, "\n");
+}
+
+function normalizeOwner(value) {
+  return typeof value === "string" ? value : null;
 }
 
 /**
@@ -55,19 +68,27 @@ export function normalizeSnapshot(rawSnapshot) {
   const rawTasks = normalizeArray(rawSnapshot?.tasks);
   const rawSubtasks = normalizeArray(rawSnapshot?.subtasks);
   const rawDependencies = normalizeArray(rawSnapshot?.dependencies);
+
   const taskIndex = new Map();
   const subtaskIndex = new Map();
 
-  const tasks = rawTasks.map((task) => {
+  const tasks = rawTasks.flatMap((task) => {
+    const taskId = getId(task);
+    if (!taskId) {
+      return [];
+    }
+
+    const createdAt = normalizeTimestamp(task.createdAt, Date.now());
     const normalizedTask = {
-      id: getId(task),
+      id: taskId,
       kind: "task",
       epicId: task.epicId ?? task.epic?.id ?? null,
-      title: String(task.title ?? "Untitled task"),
-      description: String(task.description ?? "").replace(/\\n/g, "\n"),
+      title: normalizeText(task.title, "Untitled task"),
+      description: normalizeText(task.description),
       status: normalizeStatus(task.status),
-      createdAt: Number(task.createdAt ?? Date.now()),
-      updatedAt: Number(task.updatedAt ?? task.createdAt ?? Date.now()),
+      owner: normalizeOwner(task.owner),
+      createdAt,
+      updatedAt: normalizeTimestamp(task.updatedAt, createdAt),
       blockedBy: [],
       blocks: [],
       dependencyIds: [],
@@ -77,19 +98,26 @@ export function normalizeSnapshot(rawSnapshot) {
     };
 
     taskIndex.set(normalizedTask.id, normalizedTask);
-    return normalizedTask;
+    return [normalizedTask];
   });
 
-  const subtasks = rawSubtasks.map((subtask) => {
+  const subtasks = rawSubtasks.flatMap((subtask) => {
+    const subtaskId = getId(subtask);
+    if (!subtaskId) {
+      return [];
+    }
+
+    const createdAt = normalizeTimestamp(subtask.createdAt, Date.now());
     const normalizedSubtask = {
-      id: getId(subtask),
+      id: subtaskId,
       kind: "subtask",
       taskId: subtask.taskId ?? subtask.task?.id ?? null,
-      title: String(subtask.title ?? "Untitled subtask"),
-      description: String(subtask.description ?? "").replace(/\\n/g, "\n"),
+      title: normalizeText(subtask.title, "Untitled subtask"),
+      description: normalizeText(subtask.description),
       status: normalizeStatus(subtask.status),
-      createdAt: Number(subtask.createdAt ?? Date.now()),
-      updatedAt: Number(subtask.updatedAt ?? subtask.createdAt ?? Date.now()),
+      owner: normalizeOwner(subtask.owner),
+      createdAt,
+      updatedAt: normalizeTimestamp(subtask.updatedAt, createdAt),
       blockedBy: [],
       blocks: [],
       dependencyIds: [],
@@ -98,7 +126,7 @@ export function normalizeSnapshot(rawSnapshot) {
     };
 
     subtaskIndex.set(normalizedSubtask.id, normalizedSubtask);
-    return normalizedSubtask;
+    return [normalizedSubtask];
   });
 
   for (const subtask of subtasks) {
@@ -108,13 +136,22 @@ export function normalizeSnapshot(rawSnapshot) {
     }
   }
 
-  const dependencies = rawDependencies.map((dependency) => ({
-    id: getId(dependency),
-    sourceId: String(dependency.sourceId ?? ""),
-    sourceKind: dependency.sourceKind === "subtask" ? "subtask" : "task",
-    dependsOnId: String(dependency.dependsOnId ?? ""),
-    dependsOnKind: dependency.dependsOnKind === "subtask" ? "subtask" : "task",
-  }));
+  const dependencies = rawDependencies.flatMap((dependency) => {
+    const dependencyId = getId(dependency);
+    const sourceId = typeof dependency?.sourceId === "string" && dependency.sourceId.length > 0 ? dependency.sourceId : null;
+    const dependsOnId = typeof dependency?.dependsOnId === "string" && dependency.dependsOnId.length > 0 ? dependency.dependsOnId : null;
+    if (!dependencyId || !sourceId || !dependsOnId) {
+      return [];
+    }
+
+    return [{
+      id: dependencyId,
+      sourceId,
+      sourceKind: dependency.sourceKind === "subtask" ? "subtask" : "task",
+      dependsOnId,
+      dependsOnKind: dependency.dependsOnKind === "subtask" ? "subtask" : "task",
+    }];
+  });
 
   const lookupNode = (kind, id) => {
     if (kind === "subtask") {
@@ -136,23 +173,28 @@ export function normalizeSnapshot(rawSnapshot) {
     }
   }
 
-  const epics = rawEpics.map((epic) => {
+  const epics = rawEpics.flatMap((epic) => {
     const epicId = getId(epic);
+    if (!epicId) {
+      return [];
+    }
+
     const epicTasks = tasks.filter((task) => task.epicId === epicId);
+    const createdAt = normalizeTimestamp(epic.createdAt, Date.now());
     const normalizedEpic = {
       id: epicId,
       title: String(epic.title ?? "Untitled epic"),
-      description: String(epic.description ?? "").replace(/\\n/g, "\n"),
+      description: normalizeText(epic.description),
       status: normalizeStatus(String(epic.status ?? "todo")),
-      createdAt: Number(epic.createdAt ?? Date.now()),
-      updatedAt: Number(epic.updatedAt ?? epic.createdAt ?? Date.now()),
+      createdAt,
+      updatedAt: normalizeTimestamp(epic.updatedAt, createdAt),
       taskIds: epicTasks.map((task) => task.id),
       counts: deriveCounts(epicTasks),
       searchText: "",
     };
 
     normalizedEpic.searchText = [normalizedEpic.title, normalizedEpic.description, ...epicTasks.map((task) => task.title)].join(" ").toLowerCase();
-    return normalizedEpic;
+    return [normalizedEpic];
   });
 
   for (const subtask of subtasks) {
@@ -195,6 +237,51 @@ export function normalizeSnapshot(rawSnapshot) {
   };
 }
 
+function mergeRecordsById(existingRecords, incomingRecords, deletedIds = []) {
+  const deletedIdSet = new Set(deletedIds);
+  const nextRecords = existingRecords.filter((record) => !deletedIdSet.has(record.id));
+  const indexById = new Map(nextRecords.map((record, index) => [record.id, index]));
+
+  for (const record of incomingRecords) {
+    if (typeof record?.id !== "string" || record.id.length === 0) {
+      continue;
+    }
+
+    const existingIndex = indexById.get(record.id);
+    if (existingIndex === undefined) {
+      indexById.set(record.id, nextRecords.length);
+      nextRecords.push(record);
+      continue;
+    }
+
+    nextRecords[existingIndex] = record;
+  }
+
+  return nextRecords;
+}
+
+export function applySnapshotDelta(snapshot, delta) {
+  const baseSnapshot = snapshot && typeof snapshot === "object"
+    ? snapshot
+    : { generatedAt: null, epics: [], tasks: [], subtasks: [], dependencies: [] };
+
+  if (!delta || typeof delta !== "object") {
+    return baseSnapshot;
+  }
+
+  return {
+    generatedAt: delta.generatedAt ?? baseSnapshot.generatedAt ?? null,
+    epics: mergeRecordsById(baseSnapshot.epics ?? [], normalizeArray(delta.epics), normalizeArray(delta.deletedEpicIds)),
+    tasks: mergeRecordsById(baseSnapshot.tasks ?? [], normalizeArray(delta.tasks), normalizeArray(delta.deletedTaskIds)),
+    subtasks: mergeRecordsById(baseSnapshot.subtasks ?? [], normalizeArray(delta.subtasks), normalizeArray(delta.deletedSubtaskIds)),
+    dependencies: mergeRecordsById(
+      baseSnapshot.dependencies ?? [],
+      normalizeArray(delta.dependencies),
+      normalizeArray(delta.deletedDependencyIds),
+    ),
+  };
+}
+
 const dateFormatter = new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short" });
 
 /**
@@ -204,8 +291,14 @@ const dateFormatter = new Intl.DateTimeFormat(undefined, { dateStyle: "medium",
  * @returns {string}
  */
 export function formatDate(timestamp) {
-  if (!timestamp) return "Unknown";
-  return dateFormatter.format(timestamp);
+  const normalized = Number(timestamp);
+  if (!Number.isFinite(normalized) || normalized <= 0) return "Unknown";
+
+  try {
+    return dateFormatter.format(normalized);
+  } catch {
+    return "Unknown";
+  }
 }
 
 /**