@multiplatform.one/frappe 6.0.0

package/dist/esm/sync/virtualPageManager.spec.native.js

@@ -0,0 +1,871 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { NormalizedCache } from "./normalizedCache.native.js";
+import { Order } from "./types.native.js";
+import { PlacementStrategy, VirtualPageManager } from "./virtualPageManager.native.js";
+function getCache(sub) {
+  return sub.progressiveCache;
+}
+function setCache(sub, patch) {
+  var cache = sub.progressiveCache;
+  Object.assign(cache, patch);
+}
+describe("VirtualPageManager", function () {
+  var virtualPageManager;
+  var mockNormalizedCache;
+  var mockDb;
+  var mockDocs = Array.from({
+    length: 100
+  }, function (_, i) {
+    return {
+      name: `doc-${i}`,
+      doctype: "TestDoc",
+      owner: "user",
+      modified: new Date(2024, 0, 1, 0, 0, i).toISOString(),
+      creation: new Date(2024, 0, 1).toISOString(),
+      modified_by: "user",
+      value: i,
+      title: `Document ${i}`
+    };
+  });
+  beforeEach(function () {
+    mockNormalizedCache = {
+      get: vi.fn(function (param) {
+        var {
+          name
+        } = param;
+        var doc = mockDocs.find(function (d) {
+          return d.name === name;
+        });
+        return doc || null;
+      }),
+      upsert: vi.fn(),
+      delete: vi.fn(),
+      clear: vi.fn(),
+      getAll: vi.fn(),
+      hasDoc: vi.fn(),
+      getAllByDoctype: vi.fn(),
+      batchUpsert: vi.fn(),
+      batchDelete: vi.fn(),
+      clearByDoctype: vi.fn(),
+      size: vi.fn(),
+      sizeByDoctype: vi.fn()
+    };
+    mockDb = {
+      getDocList: vi.fn(async function (doctype, options) {
+        var _options_orderBy;
+        var limit = (options === null || options === void 0 ? void 0 : options.limit) || 20;
+        var start = (options === null || options === void 0 ? void 0 : options.limitStart) || 0;
+        if (options === null || options === void 0 ? void 0 : options.cursor) {
+          var cursorIdx = mockDocs.findIndex(function (d) {
+            return d.name === options.cursor;
+          });
+          if (cursorIdx >= 0) start = cursorIdx + 1;
+        }
+        var result = mockDocs.slice(start, start + limit);
+        if ((options === null || options === void 0 ? void 0 : (_options_orderBy = options.orderBy) === null || _options_orderBy === void 0 ? void 0 : _options_orderBy.order) === "desc") {
+          return result.reverse();
+        }
+        return result;
+      }),
+      getCount: vi.fn(async function () {
+        return mockDocs.length;
+      }),
+      getDoc: vi.fn(),
+      createDoc: vi.fn(),
+      updateDoc: vi.fn(),
+      deleteDoc: vi.fn()
+    };
+    virtualPageManager = new VirtualPageManager(mockNormalizedCache, mockDb, {
+      batchSize: 50
+    });
+  });
+  describe("initializeSubscription", function () {
+    it("should initialize a subscription with progressive cache", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "modified",
+          order: Order.Asc
+        }
+      };
+      var subscription = await virtualPageManager.initializeSubscription("sub-1", query);
+      expect(subscription).toBeDefined();
+      expect(subscription.id).toBe("sub-1");
+      expect(subscription.query).toEqual(query);
+      expect(getCache(subscription)).toBeDefined();
+      expect(getCache(subscription).docIds).toHaveLength(50);
+      expect(subscription.viewWindow.pageSize).toBe(20);
+      expect(subscription.viewWindow.currentPage).toBe(1);
+    });
+    it("should fetch initial batch of documents", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-2", query);
+      expect(mockDb.getDocList).toHaveBeenCalledWith("TestDoc", {
+        fields: void 0,
+        filters: void 0,
+        orderBy: void 0,
+        cursor: void 0,
+        limit: 50
+      });
+    });
+    it("should store subscription for later retrieval", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-3", query);
+      var subscription = virtualPageManager.getSubscription("sub-3");
+      expect(subscription).toBeDefined();
+      expect(subscription === null || subscription === void 0 ? void 0 : subscription.id).toBe("sub-3");
+    });
+  });
+  describe("getPage", function () {
+    it("should return documents for requested page", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-4", query);
+      var page = await virtualPageManager.getPage("sub-4", 1);
+      expect(page).toHaveLength(10);
+      expect(page[0].name).toBe("doc-0");
+      expect(page[9].name).toBe("doc-9");
+    });
+    it("should update current page in view window", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-5", query);
+      await virtualPageManager.getPage("sub-5", 3);
+      var subscription = virtualPageManager.getSubscription("sub-5");
+      expect(subscription === null || subscription === void 0 ? void 0 : subscription.viewWindow.currentPage).toBe(3);
+    });
+    it("should fetch more data when accessing pages beyond cache", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-6", query);
+      var page = await virtualPageManager.getPage("sub-6", 7);
+      expect(mockDb.getDocList).toHaveBeenCalledTimes(2);
+      expect(page).toHaveLength(10);
+      expect(page[0].name).toBe("doc-60");
+    });
+    it("should return empty array for non-existent subscription", async function () {
+      var page = await virtualPageManager.getPage("non-existent", 1);
+      expect(page).toEqual([]);
+    });
+  });
+  describe("getNextBatch", function () {
+    it("should return documents after cursor", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-7", query);
+      var docs = await virtualPageManager.getNextBatch("sub-7", "doc-10", 5);
+      expect(docs).toHaveLength(5);
+      expect(docs[0].name).toBe("doc-11");
+      expect(docs[4].name).toBe("doc-15");
+    });
+    it("should return empty array if cursor not found", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-8", query);
+      var docs = await virtualPageManager.getNextBatch("sub-8", "non-existent", 5);
+      expect(docs).toEqual([]);
+    });
+    it("should fetch more data if needed", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-9", query);
+      var docs = await virtualPageManager.getNextBatch("sub-9", "doc-45", 10);
+      expect(docs).toHaveLength(10);
+      expect(docs[0].name).toBe("doc-46");
+      expect(docs[9].name).toBe("doc-55");
+    });
+  });
+  describe("getPageInfo", function () {
+    it("should return correct page information", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-10", query);
+      var pageInfo = virtualPageManager.getPageInfo("sub-10");
+      expect(pageInfo.currentPage).toBe(1);
+      expect(pageInfo.pageSize).toBe(10);
+      expect(pageInfo.itemsInCache).toBe(50);
+      expect(pageInfo.knownPages).toBe(5);
+      expect(pageInfo.hasMore).toBe(true);
+    });
+    it("should return default info for non-existent subscription", function () {
+      var pageInfo = virtualPageManager.getPageInfo("non-existent");
+      expect(pageInfo.currentPage).toBe(1);
+      expect(pageInfo.knownPages).toBe(0);
+      expect(pageInfo.totalPages).toBe("unknown");
+      expect(pageInfo.hasMore).toBe(false);
+      expect(pageInfo.itemsInCache).toBe(0);
+      expect(pageInfo.pageSize).toBe(20);
+    });
+    it("should calculate total pages when count is known", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 15
+      };
+      await virtualPageManager.initializeSubscription("sub-11", query);
+      var subscription = virtualPageManager.getSubscription("sub-11");
+      if (subscription) {
+        setCache(subscription, {
+          totalCount: 100
+        });
+      }
+      var pageInfo = virtualPageManager.getPageInfo("sub-11");
+      expect(pageInfo.totalPages).toBe(7);
+    });
+  });
+  describe("getTotalPages", function () {
+    it("should return total pages when all data is fetched", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 100
+      };
+      await virtualPageManager.initializeSubscription("sub-12", query);
+      var subscription = virtualPageManager.getSubscription("sub-12");
+      if (subscription) {
+        setCache(subscription, {
+          hasMore: false,
+          docIds: mockDocs.map(function (d) {
+            return d.name;
+          })
+        });
+      }
+      var totalPages = await virtualPageManager.getTotalPages("sub-12");
+      expect(totalPages).toBe(1);
+    });
+    it("should fetch count from server when needed", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10
+      };
+      await virtualPageManager.initializeSubscription("sub-13", query);
+      var totalPages = await virtualPageManager.getTotalPages("sub-13");
+      expect(mockDb.getCount).toHaveBeenCalledWith("TestDoc", void 0);
+      expect(totalPages).toBe(10);
+    });
+    it("should return unknown for non-existent subscription", async function () {
+      var totalPages = await virtualPageManager.getTotalPages("non-existent");
+      expect(totalPages).toBe("unknown");
+    });
+  });
+  describe("determineOptimisticPlacement", function () {
+    it("should determine WITHIN_RANGE placement correctly", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-14", query);
+      var subscription = virtualPageManager.getSubscription("sub-14");
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: 25,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.WithinRange);
+      expect(placement.position).toBeDefined();
+      expect(placement.position).toBeGreaterThanOrEqual(25);
+      expect(placement.position).toBeLessThanOrEqual(26);
+    });
+    it("should determine BEFORE_RANGE placement", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-15", query);
+      var subscription = virtualPageManager.getSubscription("sub-15");
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: -1,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.BeforeRange);
+    });
+    it("should determine AFTER_RANGE placement", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-16", query);
+      var subscription = virtualPageManager.getSubscription("sub-16");
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: 200,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.AfterRange);
+    });
+    it("should return UNCERTAIN when no sort field", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-17", query);
+      var subscription = virtualPageManager.getSubscription("sub-17");
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.Uncertain);
+    });
+    it("should handle DESC order correctly", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Desc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-18", query);
+      var subscription = virtualPageManager.getSubscription("sub-18");
+      setCache(subscription, {
+        docIds: mockDocs.slice(0, 50).reverse().map(function (d) {
+          return d.name;
+        })
+      });
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: 200,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.BeforeRange);
+    });
+  });
+  describe("handleRemoteCreate", function () {
+    it("should add document in correct position", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-19", query);
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: 25,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var result = await virtualPageManager.handleRemoteCreate("sub-19", newDoc);
+      var subscription = virtualPageManager.getSubscription("sub-19");
+      expect(result).toBe(true);
+      expect(getCache(subscription).docIds).toContain("new-doc");
+    });
+    it("should handle BEFORE_RANGE placement", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-20", query);
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: -1,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var result = await virtualPageManager.handleRemoteCreate("sub-20", newDoc);
+      var subscription = virtualPageManager.getSubscription("sub-20");
+      expect(result).toBe(true);
+      expect(getCache(subscription).docIds[0]).toBe("new-doc");
+    });
+    it("should handle UNCERTAIN placement", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-21", query);
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var result = await virtualPageManager.handleRemoteCreate("sub-21", newDoc);
+      var subscription = virtualPageManager.getSubscription("sub-21");
+      expect(result).toBe(false);
+      expect(subscription.needsRehydration).toBe(true);
+    });
+  });
+  describe("handleRemoteDelete", function () {
+    it("should remove document from cache", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-22", query);
+      var result = await virtualPageManager.handleRemoteDelete("sub-22", "doc-10");
+      var subscription = virtualPageManager.getSubscription("sub-22");
+      expect(result).toBe(true);
+      expect(getCache(subscription).docIds).not.toContain("doc-10");
+      expect(subscription.pendingBackfill).toBe(true);
+    });
+    it("should return false for non-existent document", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-23", query);
+      var result = await virtualPageManager.handleRemoteDelete("sub-23", "non-existent");
+      expect(result).toBe(false);
+    });
+  });
+  describe("handleRemoteUpdate", function () {
+    it("should update document position when sort value changes", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-24", query);
+      var updatedDoc = {
+        name: "doc-10",
+        doctype: "TestDoc",
+        value: 45,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var result = await virtualPageManager.handleRemoteUpdate("sub-24", updatedDoc);
+      var subscription = virtualPageManager.getSubscription("sub-24");
+      expect(result).toBe(true);
+      var index = getCache(subscription).docIds.indexOf("doc-10");
+      expect(index).toBeGreaterThan(10);
+    });
+    it("should handle document not in cache", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-25", query);
+      var updatedDoc = {
+        name: "doc-200",
+        doctype: "TestDoc",
+        value: 999,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var result = await virtualPageManager.handleRemoteUpdate("sub-25", updatedDoc);
+      expect(result).toBe(false);
+    });
+    it("should not reposition if sort value unchanged", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-26", query);
+      var subscription = virtualPageManager.getSubscription("sub-26");
+      var originalIndex = getCache(subscription).docIds.indexOf("doc-10");
+      var updatedDoc = {
+        name: "doc-10",
+        doctype: "TestDoc",
+        value: 10,
+        title: "Updated Title",
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var result = await virtualPageManager.handleRemoteUpdate("sub-26", updatedDoc);
+      var newIndex = getCache(subscription).docIds.indexOf("doc-10");
+      expect(result).toBe(true);
+      expect(newIndex).toBe(originalIndex);
+    });
+  });
+  describe("invalidateCache", function () {
+    it("should clear page cache and increment generation", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-27", query);
+      var system = virtualPageManager;
+      var initialGeneration = system.cacheGeneration;
+      virtualPageManager.invalidateCache();
+      expect(system.cacheGeneration).toBe(initialGeneration + 1);
+      expect(system.pageCache.size).toBe(0);
+    });
+  });
+  describe("updateProgressiveCache", function () {
+    it("should update subscription cache", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20
+      };
+      await virtualPageManager.initializeSubscription("sub-28", query);
+      var newDocIds = ["doc-100", "doc-101", "doc-102"];
+      virtualPageManager.updateProgressiveCache("sub-28", newDocIds, "cursor-102", false);
+      var subscription = virtualPageManager.getSubscription("sub-28");
+      expect(getCache(subscription).docIds).toEqual(newDocIds);
+      expect(getCache(subscription).nextCursor).toBe("cursor-102");
+      expect(getCache(subscription).hasMore).toBe(false);
+    });
+    it("should handle non-existent subscription", function () {
+      expect(function () {
+        virtualPageManager.updateProgressiveCache("non-existent", [], null, false);
+      }).not.toThrow();
+    });
+  });
+  describe("hybrid pagination", function () {
+    var pageSize = 20;
+    function createMockDbForHybrid() {
+      var getDocList = vi.fn().mockImplementation(async function (_doctype, options) {
+        var limit = (options === null || options === void 0 ? void 0 : options.limit) || pageSize;
+        var start;
+        if ((options === null || options === void 0 ? void 0 : options.limitStart) !== void 0 && (options === null || options === void 0 ? void 0 : options.limitStart) !== null) {
+          start = options.limitStart;
+        } else if (options === null || options === void 0 ? void 0 : options.cursor) {
+          var match = String(options.cursor).match(/doc-(\d+)/);
+          start = match ? Number.parseInt(match[1], 10) + 1 : 0;
+        } else {
+          start = 0;
+        }
+        return Array.from({
+          length: limit
+        }, function (_, i) {
+          return {
+            name: `doc-${start + i}`,
+            doctype: "TestDoc",
+            modified: "2026-01-01 00:00:00"
+          };
+        });
+      });
+      return {
+        getDocList,
+        getCount: vi.fn().mockResolvedValue(1e3),
+        getDoc: vi.fn(),
+        createDoc: vi.fn(),
+        updateDoc: vi.fn(),
+        deleteDoc: vi.fn()
+      };
+    }
+    beforeEach(function () {
+      mockNormalizedCache = new NormalizedCache();
+      mockDb = createMockDbForHybrid();
+      virtualPageManager = new VirtualPageManager(mockNormalizedCache, mockDb, {
+        batchSize: 100
+      });
+    });
+    it("sequential page access uses cursor-based fetch", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h1", query);
+      await virtualPageManager.getPage("sub-h1", 1);
+      await virtualPageManager.getPage("sub-h1", 2);
+      var calls = mockDb.getDocList.mock.calls;
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = calls[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var [, options] = _step.value;
+          expect(options).not.toHaveProperty("limitStart");
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    });
+    it("non-contiguous page jump uses offset-based fetch", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h2", query);
+      await virtualPageManager.getPage("sub-h2", 1);
+      await virtualPageManager.getPage("sub-h2", 50);
+      var calls = mockDb.getDocList.mock.calls;
+      var offsetCall = calls.find(function (call) {
+        var _call_;
+        return ((_call_ = call[1]) === null || _call_ === void 0 ? void 0 : _call_.limitStart) === (50 - 1) * pageSize;
+      });
+      expect(offsetCall).toBeDefined();
+      expect(offsetCall[1]).toMatchObject({
+        limitStart: 980,
+        limit: pageSize
+      });
+    });
+    it("after offset jump, contiguous access uses cursor", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h3", query);
+      await virtualPageManager.getPage("sub-h3", 1);
+      await virtualPageManager.getPage("sub-h3", 50);
+      mockDb.getDocList.mockClear();
+      await virtualPageManager.getPage("sub-h3", 51);
+      var calls = mockDb.getDocList.mock.calls;
+      expect(calls.length).toBeGreaterThan(0);
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = calls[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var [, options] = _step.value;
+          expect(options).not.toHaveProperty("limitStart");
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    });
+    it("gap placeholders after offset jump", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h4", query);
+      await virtualPageManager.getPage("sub-h4", 1);
+      await virtualPageManager.getPage("sub-h4", 50);
+      var subscription = virtualPageManager.getSubscription("sub-h4");
+      var docIds = getCache(subscription).docIds;
+      var limitStart = (50 - 1) * pageSize;
+      expect(docIds.length).toBeGreaterThanOrEqual(limitStart + pageSize);
+      var gapRange = docIds.slice(pageSize, limitStart);
+      expect(gapRange.some(function (id) {
+        return id === "";
+      })).toBe(true);
+      expect(docIds[limitStart]).not.toBe("");
+      expect(docIds.slice(limitStart, limitStart + pageSize).every(function (id) {
+        return id !== "";
+      })).toBe(true);
+    });
+    it("mapIdsToDocuments filters gaps", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h5", query);
+      await virtualPageManager.getPage("sub-h5", 1);
+      await virtualPageManager.getPage("sub-h5", 50);
+      var page = await virtualPageManager.getPage("sub-h5", 50);
+      expect(page.every(function (doc) {
+        return doc !== void 0 && doc !== null;
+      })).toBe(true);
+      expect(page.length).toBe(pageSize);
+      expect(page[0].name).toBe("doc-980");
+    });
+    it("getPageIslands returns correct islands", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h6", query);
+      await virtualPageManager.getPage("sub-h6", 1);
+      await virtualPageManager.getPage("sub-h6", 50);
+      var islands = virtualPageManager.getPageIslands("sub-h6");
+      expect(islands.length).toBe(2);
+      var cursorIsland = islands.find(function (i) {
+        return i.fetchedVia === "cursor";
+      });
+      var offsetIsland = islands.find(function (i) {
+        return i.fetchedVia === "offset";
+      });
+      expect(cursorIsland).toBeDefined();
+      expect(offsetIsland).toBeDefined();
+      expect(offsetIsland).toMatchObject({
+        startPage: 50,
+        endPage: 50,
+        startIndex: 980,
+        endIndex: 1e3,
+        fetchedVia: "offset"
+      });
+    });
+    it("island merging when adjacent pages fetched", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: pageSize
+      };
+      await virtualPageManager.initializeSubscription("sub-h7", query);
+      await virtualPageManager.getPage("sub-h7", 1);
+      await virtualPageManager.getPage("sub-h7", 2);
+      await virtualPageManager.getPage("sub-h7", 3);
+      var islands = virtualPageManager.getPageIslands("sub-h7");
+      expect(islands.length).toBe(1);
+      expect(islands[0].startPage).toBe(1);
+      expect(islands[0].endPage).toBeGreaterThanOrEqual(3);
+      expect(islands[0].fetchedVia).toBe("cursor");
+    });
+  });
+  describe("edge cases and error handling", function () {
+    it("should handle empty progressive cache", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-29", query);
+      var subscription = virtualPageManager.getSubscription("sub-29");
+      setCache(subscription, {
+        docIds: []
+      });
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: 10,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.WithinRange);
+      expect(placement.position).toBe(0);
+    });
+    it("should handle null values in comparison", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 20,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-30", query);
+      var subscription = virtualPageManager.getSubscription("sub-30");
+      var newDoc = {
+        name: "new-doc",
+        doctype: "TestDoc",
+        value: null,
+        owner: "user",
+        modified: (/* @__PURE__ */new Date()).toISOString(),
+        creation: (/* @__PURE__ */new Date()).toISOString(),
+        modified_by: "user"
+      };
+      var placement = virtualPageManager.determineOptimisticPlacement(subscription, newDoc);
+      expect(placement.strategy).toBe(PlacementStrategy.WithinRange);
+      expect(placement.position).toBe(0);
+    });
+    it("should limit cache size appropriately", async function () {
+      var query = {
+        doctype: "TestDoc",
+        limit: 10,
+        orderBy: {
+          field: "value",
+          order: Order.Asc
+        }
+      };
+      await virtualPageManager.initializeSubscription("sub-31", query);
+      var subscription = virtualPageManager.getSubscription("sub-31");
+      var bigCache = Array.from({
+        length: 1001
+      }, function (_, i) {
+        return `doc-${i % 100}`;
+      });
+      setCache(subscription, {
+        docIds: bigCache
+      });
+      expect(virtualPageManager.shouldLimitCacheSize(subscription)).toBe(true);
+    });
+  });
+});
+//# sourceMappingURL=virtualPageManager.spec.native.js.map