@recordtimelabel/core 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recordtimelabel/core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "Shared RecordTimeLabel data model, merge logic, operations, and sync engine.",
   "main": "./src/index.js",

package/src/index.js

@@ -989,6 +989,146 @@ const mapValuesArray = (value = {}) => {
   return Object.values(value);
 };
 
+const buildLiveV2RecordIdsByFolder = (recordDocuments = {}) => {
+  const liveRecordIdsByFolder = {};
+  const liveRecordIdSetsByFolder = {};
+
+  Object.values(recordDocuments || {}).forEach((recordDoc) => {
+    const recordId = normalizeId(recordDoc?.id);
+    const folderId = safeFolderId(recordDoc?.folderId);
+    if (!recordId) return;
+
+    if (!liveRecordIdsByFolder[folderId]) {
+      liveRecordIdsByFolder[folderId] = [];
+      liveRecordIdSetsByFolder[folderId] = new Set();
+    }
+
+    if (liveRecordIdSetsByFolder[folderId].has(recordId)) return;
+    liveRecordIdSetsByFolder[folderId].add(recordId);
+    liveRecordIdsByFolder[folderId].push(recordId);
+  });
+
+  return {
+    liveRecordIdsByFolder,
+    liveRecordIdSetsByFolder
+  };
+};
+
+const buildV2RecordOrderByFolder = (records = {}, recordDocuments = {}) => {
+  const {
+    liveRecordIdsByFolder,
+    liveRecordIdSetsByFolder
+  } = buildLiveV2RecordIdsByFolder(recordDocuments);
+  const hasLiveRecordDocuments = Object.keys(recordDocuments || {}).length > 0;
+  const orders = {};
+  const seenByFolder = {};
+
+  Object.keys(liveRecordIdsByFolder).forEach((folderId) => {
+    orders[folderId] = [];
+    seenByFolder[folderId] = new Set();
+  });
+
+  Object.entries(records || {}).forEach(([folderId, folderRecords]) => {
+    const normalizedFolderId = safeFolderId(folderId);
+    if (hasLiveRecordDocuments && !liveRecordIdSetsByFolder[normalizedFolderId]) return;
+
+    const seen = seenByFolder[normalizedFolderId] || new Set();
+    orders[normalizedFolderId] = orders[normalizedFolderId] || [];
+
+    toArray(folderRecords).forEach((record) => {
+      const recordId = normalizeId(record?.id);
+      if (!recordId || seen.has(recordId)) return;
+      if (
+        liveRecordIdSetsByFolder[normalizedFolderId] &&
+        !liveRecordIdSetsByFolder[normalizedFolderId].has(recordId)
+      ) {
+        return;
+      }
+
+      seen.add(recordId);
+      orders[normalizedFolderId].push(recordId);
+    });
+
+    seenByFolder[normalizedFolderId] = seen;
+  });
+
+  Object.entries(liveRecordIdsByFolder).forEach(([folderId, liveRecordIds]) => {
+    const seen = seenByFolder[folderId] || new Set();
+    orders[folderId] = orders[folderId] || [];
+
+    liveRecordIds.forEach((recordId) => {
+      if (seen.has(recordId)) return;
+      seen.add(recordId);
+      orders[folderId].push(recordId);
+    });
+  });
+
+  return orders;
+};
+
+const extractV2RecordOrderByFolder = (folderDocuments = {}) => {
+  const orders = {};
+
+  Object.entries(folderDocuments || {}).forEach(([rawFolderId, folderDoc]) => {
+    const folderId = normalizeId(folderDoc?.id || rawFolderId);
+    if (!folderId || !Array.isArray(folderDoc?.recordOrder)) return;
+
+    const seen = new Set();
+    orders[folderId] = [];
+
+    folderDoc.recordOrder.forEach((recordId) => {
+      const normalized = normalizeId(recordId);
+      if (!normalized || seen.has(normalized)) return;
+      seen.add(normalized);
+      orders[folderId].push(normalized);
+    });
+  });
+
+  return orders;
+};
+
+const reorderV2RecordsByFolderRecordOrder = (records = {}, recordOrderByFolder = {}) => {
+  const nextRecords = {};
+
+  Object.entries(records || {}).forEach(([folderId, folderRecords]) => {
+    const fallbackRecords = toArray(folderRecords);
+    const recordOrder = recordOrderByFolder[folderId];
+
+    if (!Array.isArray(recordOrder)) {
+      nextRecords[folderId] = fallbackRecords;
+      return;
+    }
+
+    const recordsById = new Map();
+    fallbackRecords.forEach((record) => {
+      const recordId = normalizeId(record?.id);
+      if (recordId && !recordsById.has(recordId)) {
+        recordsById.set(recordId, { ...record, id: recordId });
+      }
+    });
+
+    const seen = new Set();
+    const orderedRecords = [];
+    recordOrder.forEach((recordId) => {
+      const record = recordsById.get(recordId);
+      if (!record || seen.has(recordId)) return;
+      seen.add(recordId);
+      orderedRecords.push(record);
+    });
+
+    fallbackRecords.forEach((record) => {
+      const recordId = normalizeId(record?.id);
+      if (!recordId || seen.has(recordId)) return;
+      seen.add(recordId);
+      orderedRecords.push(record);
+    });
+
+    nextRecords[folderId] = orderedRecords;
+  });
+
+  return nextRecords;
+};
+
 const cleanV2RecordDocument = (record = {}, folderId, now) => {
   const recordId = normalizeId(record.id);
   if (!recordId) return null;
@@ -1005,8 +1145,15 @@ const cleanV2RecordDocument = (record = {}, folderId, now) => {
 const cleanV2FolderDocument = (folder = {}, now) => {
   const folderId = normalizeId(folder.id);
   if (!folderId) return null;
+  const {
+    schemaVersion,
+    recordOrder,
+    groupOrder,
+    folderOrder,
+    ...folderFields
+  } = folder || {};
   return {
-    ...folder,
+    ...folderFields,
     id: folderId,
     updatedAt: folder.updatedAt || folder.createdAt || now,
     schemaVersion: 2
@@ -1035,10 +1182,16 @@ export const buildFirestoreV2DocumentsFromState = (state = {}, options = {}) =>
     });
   });
 
+  const recordOrderByFolder = buildV2RecordOrderByFolder(normalized.records || {}, records);
   const folders = {};
   toArray(normalized.folders).forEach((folder) => {
     const folderDoc = cleanV2FolderDocument(folder, now);
-    if (folderDoc) folders[folderDoc.id] = folderDoc;
+    if (folderDoc) {
+      folders[folderDoc.id] = {
+        ...folderDoc,
+        recordOrder: recordOrderByFolder[folderDoc.id] || []
+      };
+    }
   });
 
   const ops = {};
@@ -1094,11 +1247,12 @@ export const buildStateFromFirestoreV2Documents = (documents = {}, options = {})
     ];
   });
 
+  const recordOrderByFolder = extractV2RecordOrderByFolder(documents?.folders);
   const folders = mapValuesArray(documents?.folders)
     .map((folderDoc) => {
       const folderId = normalizeId(folderDoc?.id);
       if (!folderId) return null;
-      const { schemaVersion, ...folder } = folderDoc;
+      const { schemaVersion, recordOrder, groupOrder, folderOrder, ...folder } = folderDoc;
       return { ...folder, id: folderId };
     })
     .filter(Boolean);
@@ -1114,7 +1268,7 @@ export const buildStateFromFirestoreV2Documents = (documents = {}, options = {})
 
   const state = normalizeState({
     folders,
-    records,
+    records: reorderV2RecordsByFolderRecordOrder(records, recordOrderByFolder),
     settings: rootDoc.settings || {},
     groupOrder: normalizeGroupOrderForOption(rootDoc.groupOrder, options.groupOrderNormalizer),
     folderOrder: rootDoc.folderOrder || [],