@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/virtualPageManager.native.js

@@ -0,0 +1,1125 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var virtualPageManager_exports = {};
+__export(virtualPageManager_exports, {
+  PlacementStrategy: () => PlacementStrategy,
+  VirtualPageManager: () => VirtualPageManager,
+  VirtualSubscription: () => VirtualSubscription
+});
+module.exports = __toCommonJS(virtualPageManager_exports);
+var import_types = require("./types.native.js");
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function calculateCheckpointFromDocs(docs) {
+  if (docs.length === 0) return void 0;
+  var maxTimestamp = "";
+  var maxDate = null;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = docs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var doc = _step.value;
+      var modified = doc.modified;
+      if (!modified) continue;
+      try {
+        var date = new Date(modified);
+        if (Number.isNaN(date.getTime())) continue;
+        if (!maxDate || date > maxDate) {
+          maxDate = date;
+          maxTimestamp = modified;
+        }
+      } catch (unused) {
+        if (!maxTimestamp || modified > maxTimestamp) {
+          maxTimestamp = modified;
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return maxTimestamp || void 0;
+}
+var PlacementStrategy = /* @__PURE__ */function (PlacementStrategy2) {
+  PlacementStrategy2["AfterRange"] = "after-range";
+  PlacementStrategy2["BeforeRange"] = "before-range";
+  PlacementStrategy2["Uncertain"] = "uncertain";
+  PlacementStrategy2["WithinRange"] = "within-range";
+  return PlacementStrategy2;
+}({});
+var VirtualSubscription = /* @__PURE__ */function () {
+  "use strict";
+
+  function VirtualSubscription2(subscription, progressiveCache, viewWindow) {
+    _class_call_check(this, VirtualSubscription2);
+    _define_property(this, "progressiveCache", void 0);
+    _define_property(this, "needsRehydration", void 0);
+    _define_property(this, "pendingBackfill", void 0);
+    _define_property(this, "viewWindow", void 0);
+    _define_property(this, "id", void 0);
+    _define_property(this, "query", void 0);
+    _define_property(this, "checkpoint", void 0);
+    _define_property(this, "cursor", void 0);
+    _define_property(this, "docIds", void 0);
+    _define_property(this, "boundaries", void 0);
+    _define_property(this, "lockExpiry", void 0);
+    _define_property(this, "pendingRehydration", void 0);
+    _define_property(this, "metadata", void 0);
+    _define_property(this, "tombstones", void 0);
+    this.id = subscription.id;
+    this.query = subscription.query;
+    this.checkpoint = subscription.checkpoint;
+    this.cursor = subscription.cursor;
+    this.docIds = subscription.docIds;
+    this.boundaries = subscription.boundaries;
+    this.lockExpiry = subscription.lockExpiry;
+    this.pendingRehydration = subscription.pendingRehydration;
+    this.metadata = subscription.metadata;
+    this.tombstones = subscription.tombstones;
+    this.progressiveCache = progressiveCache;
+    this.viewWindow = viewWindow;
+  }
+  _create_class(VirtualSubscription2, [{
+    /**
+    * Update progressive cache with new data
+    */
+    key: "updateProgressiveCache",
+    value: function updateProgressiveCache(options) {
+      if (options.docIds) {
+        this.progressiveCache.docIds = options.docIds;
+      }
+      if (options.nextCursor !== void 0) {
+        this.progressiveCache.nextCursor = options.nextCursor;
+      }
+      if (options.hasMore !== void 0) {
+        this.progressiveCache.hasMore = options.hasMore;
+      }
+      if (options.lastFetchedAt) {
+        this.progressiveCache.lastFetchedAt = options.lastFetchedAt;
+      }
+      if (typeof options.totalCount === "number") {
+        this.progressiveCache.totalCount = options.totalCount;
+      }
+    }
+  }, {
+    /**
+    * Get the progressive cache (read-only access)
+    */
+    key: "getProgressiveCache",
+    value: function getProgressiveCache() {
+      return {
+        ...this.progressiveCache
+      };
+    }
+  }, {
+    // Return copy to prevent external mutation
+    /**
+    * Process documents and update caches
+    */
+    key: "processDocuments",
+    value: function processDocuments(docs, normalizedCache) {
+      var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      var {
+        calculateCheckpoint = true,
+        updateNormalizedCache = true
+      } = options;
+      this.updateProgressiveCache({
+        docIds: docs.map(function (doc2) {
+          return doc2.name;
+        }),
+        nextCursor: docs.length > 0 ? docs[docs.length - 1].name : void 0,
+        lastFetchedAt: /* @__PURE__ */new Date()
+      });
+      if (updateNormalizedCache) {
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = docs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var doc = _step.value;
+            normalizedCache.upsert(doc);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+      }
+      if (calculateCheckpoint) {
+        this.checkpoint = calculateCheckpointFromDocs(docs);
+      }
+    }
+  }, {
+    /**
+    * Remove documents from progressive cache
+    */
+    key: "removeDocuments",
+    value: function removeDocuments(docIds, normalizedCache) {
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = docIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var docId = _step.value;
+          var index = this.progressiveCache.docIds.indexOf(docId);
+          if (index !== -1) {
+            this.progressiveCache.docIds.splice(index, 1);
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = docIds[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var docId1 = _step1.value;
+          normalizedCache.remove({
+            doctype: this.query.doctype,
+            name: docId1
+          });
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+  }]);
+  return VirtualSubscription2;
+}();
+var VirtualPageManager = /* @__PURE__ */function () {
+  "use strict";
+
+  function VirtualPageManager2(normalizedCache, db) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    _class_call_check(this, VirtualPageManager2);
+    _define_property(this, "normalizedCache", void 0);
+    _define_property(this, "db", void 0);
+    _define_property(this, "subscriptions", void 0);
+    _define_property(this, "pageCache", void 0);
+    _define_property(this, "cacheGeneration", void 0);
+    _define_property(this, "batchSize", void 0);
+    _define_property(this, "islands", void 0);
+    this.normalizedCache = normalizedCache;
+    this.db = db;
+    this.subscriptions = /* @__PURE__ */new Map();
+    this.pageCache = /* @__PURE__ */new Map();
+    this.cacheGeneration = 0;
+    this.islands = /* @__PURE__ */new Map();
+    this.batchSize = options.batchSize || 100;
+  }
+  _create_class(VirtualPageManager2, [{
+    key: "getOrderByField",
+    value: (
+    /**
+    * Helper to get the primary sort field from OrderBy
+    */
+    function getOrderByField(subscription) {
+      var orderBy = subscription.query.orderBy;
+      if (!orderBy) return void 0;
+      return Array.isArray(orderBy) ? orderBy[0] : orderBy;
+    })
+  }, {
+    /**
+    * Registers a subscription with pre-fetched data, avoiding a duplicate
+    * initial fetch. Used by SubscriptionManager when `progressive: true`.
+    */
+    key: "registerSubscription",
+    value: function registerSubscription(subscriptionId, subscription, initialDocIds, cursor, hasMore) {
+      var pageSize = subscription.query.limit || 20;
+      var virtualSub = new VirtualSubscription(subscription, {
+        docIds: [...initialDocIds],
+        nextCursor: cursor !== null && cursor !== void 0 ? cursor : initialDocIds.length > 0 ? initialDocIds[initialDocIds.length - 1] : void 0,
+        hasMore: hasMore !== null && hasMore !== void 0 ? hasMore : initialDocIds.length >= pageSize,
+        totalCount: void 0,
+        lastFetchedAt: /* @__PURE__ */new Date()
+      }, {
+        currentPage: 1,
+        pageSize
+      });
+      this.subscriptions.set(subscriptionId, virtualSub);
+      if (initialDocIds.length > 0) {
+        this.recordIsland(subscriptionId, {
+          startPage: 1,
+          endPage: Math.ceil(initialDocIds.length / pageSize) || 1,
+          startIndex: 0,
+          endIndex: initialDocIds.length,
+          fetchedVia: "cursor"
+        });
+      }
+      return virtualSub;
+    }
+  }, {
+    key: "initializeSubscription",
+    value: async function initializeSubscription(subscriptionId, query) {
+      var subscription = new VirtualSubscription({
+        id: subscriptionId,
+        query,
+        docIds: []
+      }, {
+        docIds: [],
+        nextCursor: void 0,
+        hasMore: true,
+        totalCount: void 0
+      }, {
+        currentPage: 1,
+        pageSize: query.limit || 20
+      });
+      this.subscriptions.set(subscriptionId, subscription);
+      await this.fetchInitialBatch(subscription);
+      return subscription;
+    }
+  }, {
+    key: "getPage",
+    value: async function getPage(subscriptionId, page) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return [];
+      var pageSize = subscription.viewWindow.pageSize;
+      var start = (page - 1) * pageSize;
+      var end = start + pageSize;
+      var cache = subscription.getProgressiveCache();
+      if (cache.docIds.length >= start) {
+        await this.ensureCached(subscription, end);
+      } else {
+        await this.fetchPageByOffset(subscription, page);
+      }
+      subscription.viewWindow.currentPage = page;
+      var pageDocIds = subscription.getProgressiveCache().docIds.slice(start, end);
+      return this.mapIdsToDocuments(subscription.query.doctype, pageDocIds);
+    }
+  }, {
+    key: "getNextBatch",
+    value: async function getNextBatch(subscriptionId, cursorDocId, limit) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return [];
+      var index = subscription.getProgressiveCache().docIds.indexOf(cursorDocId);
+      if (index === -1) {
+        await this.fetchFromCursor(subscription, cursorDocId);
+        index = subscription.getProgressiveCache().docIds.indexOf(cursorDocId);
+        if (index === -1) {
+          return [];
+        }
+      }
+      var start = index + 1;
+      var end = start + limit;
+      await this.ensureCached(subscription, end);
+      var docIds = subscription.getProgressiveCache().docIds.slice(start, end);
+      return this.mapIdsToDocuments(subscription.query.doctype, docIds);
+    }
+  }, {
+    /**
+    * Get page information for UI
+    */
+    key: "getPageInfo",
+    value: function getPageInfo(subscriptionId) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) {
+        return {
+          currentPage: 1,
+          knownPages: 0,
+          totalPages: "unknown",
+          hasMore: false,
+          itemsInCache: 0,
+          pageSize: 20
+        };
+      }
+      var knownPages = Math.ceil(subscription.getProgressiveCache().docIds.length / subscription.viewWindow.pageSize);
+      return {
+        currentPage: subscription.viewWindow.currentPage,
+        knownPages,
+        totalPages: subscription.getProgressiveCache().totalCount !== void 0 ? Math.ceil(subscription.getProgressiveCache().totalCount / subscription.viewWindow.pageSize) : "unknown",
+        hasMore: subscription.getProgressiveCache().hasMore,
+        itemsInCache: subscription.getProgressiveCache().docIds.length,
+        pageSize: subscription.viewWindow.pageSize
+      };
+    }
+  }, {
+    key: "getTotalPages",
+    value: (
+    /**
+    * Get total page count (expensive - may require server call)
+    */
+    async function getTotalPages(subscriptionId) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return "unknown";
+      if (subscription.getProgressiveCache().totalCount === void 0) {
+        if (!subscription.getProgressiveCache().hasMore) {
+          subscription.updateProgressiveCache({
+            totalCount: subscription.getProgressiveCache().docIds.length
+          });
+        } else {
+          try {
+            var count = await this.db.getCount(subscription.query.doctype, subscription.query.filters);
+            subscription.updateProgressiveCache({
+              totalCount: count
+            });
+          } catch (unused) {
+            return "unknown";
+          }
+        }
+      }
+      return Math.ceil(subscription.getProgressiveCache().totalCount / subscription.viewWindow.pageSize);
+    })
+  }, {
+    /**
+    * Handle optimistic document placement
+    */
+    key: "determineOptimisticPlacement",
+    value: function determineOptimisticPlacement(subscription, newDoc) {
+      var orderByField = this.getOrderByField(subscription);
+      var sortField = orderByField === null || orderByField === void 0 ? void 0 : orderByField.field;
+      if (!sortField || !(sortField in newDoc)) {
+        return {
+          strategy: "uncertain"
+        };
+      }
+      var newValue = newDoc[sortField];
+      var docIds = subscription.getProgressiveCache().docIds;
+      if (docIds.length === 0) {
+        return {
+          strategy: "within-range",
+          position: 0
+        };
+      }
+      var firstDoc = this.normalizedCache.get({
+        doctype: subscription.query.doctype,
+        name: docIds[0]
+      });
+      var lastDoc = this.normalizedCache.get({
+        doctype: subscription.query.doctype,
+        name: docIds[docIds.length - 1]
+      });
+      if (!firstDoc || !lastDoc) {
+        return {
+          strategy: "uncertain"
+        };
+      }
+      var firstValue = firstDoc[sortField];
+      var lastValue = lastDoc[sortField];
+      var isAscending = (orderByField === null || orderByField === void 0 ? void 0 : orderByField.order) === import_types.Order.Asc;
+      if (isAscending) {
+        if (newValue != null && firstValue != null && newValue < firstValue) {
+          return {
+            strategy: "before-range"
+          };
+        }
+        if (newValue != null && lastValue != null && newValue > lastValue) {
+          return {
+            strategy: "after-range"
+          };
+        }
+      } else {
+        if (newValue != null && firstValue != null && newValue > firstValue) {
+          return {
+            strategy: "before-range"
+          };
+        }
+        if (newValue != null && lastValue != null && newValue < lastValue) {
+          return {
+            strategy: "after-range"
+          };
+        }
+      }
+      var position = this.binarySearchPosition(subscription, newDoc, sortField);
+      return {
+        strategy: "within-range",
+        position
+      };
+    }
+  }, {
+    key: "handleRemoteCreate",
+    value: (
+    /**
+    * Update subscription after remote create
+    */
+    async function handleRemoteCreate(subscriptionId, newDoc) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return false;
+      var placement = this.determineOptimisticPlacement(subscription, newDoc);
+      switch (placement.strategy) {
+        case "within-range":
+          if (placement.position !== void 0) {
+            var currentDocIds = subscription.getProgressiveCache().docIds;
+            var newDocIds = [...currentDocIds];
+            newDocIds.splice(placement.position, 0, newDoc.name);
+            subscription.updateProgressiveCache({
+              docIds: newDocIds
+            });
+            return true;
+          }
+          break;
+        case "before-range":
+          {
+            var currentDocIds1 = subscription.getProgressiveCache().docIds;
+            var newDocIds1 = [newDoc.name, ...currentDocIds1];
+            if (this.shouldLimitCacheSize(subscription)) {
+              newDocIds1.pop();
+            }
+            subscription.updateProgressiveCache({
+              docIds: newDocIds1
+            });
+            return true;
+          }
+        case "after-range":
+          if (this.isViewingLastPage(subscription)) {
+            await this.fetchMorePages(subscription, 1);
+          }
+          return false;
+        case "uncertain":
+          subscription.needsRehydration = true;
+          return false;
+      }
+      return false;
+    })
+  }, {
+    key: "handleRemoteDelete",
+    value: (
+    /**
+    * Update subscription after remote delete
+    */
+    async function handleRemoteDelete(subscriptionId, docName) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return false;
+      var currentDocIds = subscription.getProgressiveCache().docIds;
+      var index = currentDocIds.indexOf(docName);
+      if (index === -1) return false;
+      var newDocIds = [...currentDocIds];
+      newDocIds.splice(index, 1);
+      subscription.updateProgressiveCache({
+        docIds: newDocIds
+      });
+      subscription.pendingBackfill = true;
+      return true;
+    })
+  }, {
+    key: "handleRemoteUpdate",
+    value: (
+    /**
+    * Update subscription after remote update
+    */
+    async function handleRemoteUpdate(subscriptionId, updatedDoc) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return false;
+      var currentIndex = subscription.getProgressiveCache().docIds.indexOf(updatedDoc.name);
+      var orderByField = this.getOrderByField(subscription);
+      var sortField = orderByField === null || orderByField === void 0 ? void 0 : orderByField.field;
+      if (!sortField || !(sortField in updatedDoc)) {
+        return currentIndex !== -1;
+      }
+      if (currentIndex === -1) {
+        var placement = this.determineOptimisticPlacement(subscription, updatedDoc);
+        if (placement.strategy === "within-range" && placement.position !== void 0) {
+          var currentDocIds = subscription.getProgressiveCache().docIds;
+          var newDocIds = [...currentDocIds];
+          newDocIds.splice(placement.position, 0, updatedDoc.name);
+          subscription.updateProgressiveCache({
+            docIds: newDocIds
+          });
+          return true;
+        }
+        return false;
+      }
+      var oldDoc = this.normalizedCache.get({
+        doctype: subscription.query.doctype,
+        name: updatedDoc.name
+      });
+      if (oldDoc && oldDoc[sortField] !== updatedDoc[sortField]) {
+        var currentDocIds1 = subscription.getProgressiveCache().docIds;
+        var newDocIds1 = [...currentDocIds1];
+        newDocIds1.splice(currentIndex, 1);
+        var placement1 = this.determineOptimisticPlacement(subscription, updatedDoc);
+        if (placement1.strategy === "within-range" && placement1.position !== void 0) {
+          newDocIds1.splice(placement1.position, 0, updatedDoc.name);
+          subscription.updateProgressiveCache({
+            docIds: newDocIds1
+          });
+        } else {
+          subscription.updateProgressiveCache({
+            docIds: newDocIds1
+          });
+          subscription.pendingBackfill = true;
+        }
+      }
+      return true;
+    })
+  }, {
+    /**
+    * Invalidate page cache (call after any change)
+    */
+    key: "invalidateCache",
+    value: function invalidateCache() {
+      this.cacheGeneration++;
+      this.pageCache.clear();
+    }
+  }, {
+    /**
+    * Get subscription by ID
+    */
+    key: "getSubscription",
+    value: function getSubscription(subscriptionId) {
+      return this.subscriptions.get(subscriptionId);
+    }
+  }, {
+    key: "getPageIslands",
+    value: function getPageIslands(subscriptionId) {
+      return this.islands.get(subscriptionId) || [];
+    }
+  }, {
+    /**
+    * Check if a specific index is within a cached island
+    */
+    key: "isIndexCached",
+    value: function isIndexCached(subscriptionId, index) {
+      var islands = this.islands.get(subscriptionId) || [];
+      return islands.some(function (island) {
+        return index >= island.startIndex && index < island.endIndex;
+      });
+    }
+  }, {
+    /**
+    * Find all gaps between cached islands
+    */
+    key: "findGaps",
+    value: function findGaps(subscriptionId) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return [];
+      var islands = this.islands.get(subscriptionId) || [];
+      if (islands.length === 0) return [];
+      var gaps = [];
+      var pageSize = subscription.viewWindow.pageSize;
+      var sorted = [...islands].sort(function (a, b) {
+        return a.startIndex - b.startIndex;
+      });
+      if (sorted[0].startIndex > 0) {
+        gaps.push({
+          startIndex: 0,
+          endIndex: sorted[0].startIndex,
+          startPage: 1,
+          endPage: Math.ceil(sorted[0].startIndex / pageSize)
+        });
+      }
+      for (var i = 0; i < sorted.length - 1; i++) {
+        var currentEnd = sorted[i].endIndex;
+        var nextStart = sorted[i + 1].startIndex;
+        if (nextStart > currentEnd) {
+          gaps.push({
+            startIndex: currentEnd,
+            endIndex: nextStart,
+            startPage: Math.floor(currentEnd / pageSize) + 1,
+            endPage: Math.ceil(nextStart / pageSize)
+          });
+        }
+      }
+      return gaps;
+    }
+  }, {
+    /**
+    * Get the gap that contains a specific index, if any
+    */
+    key: "getGapForIndex",
+    value: function getGapForIndex(subscriptionId, index) {
+      var gaps = this.findGaps(subscriptionId);
+      return gaps.find(function (gap) {
+        return index >= gap.startIndex && index < gap.endIndex;
+      }) || null;
+    }
+  }, {
+    /**
+    * Clear all islands for a subscription (used during full refresh)
+    */
+    key: "clearIslands",
+    value: function clearIslands(subscriptionId) {
+      this.islands.delete(subscriptionId);
+    }
+  }, {
+    /**
+    * Get coverage statistics for a subscription
+    */
+    key: "getIslandCoverage",
+    value: function getIslandCoverage(subscriptionId) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      var islands = this.islands.get(subscriptionId) || [];
+      if (!subscription || islands.length === 0) {
+        return {
+          totalCached: 0,
+          islandCount: 0,
+          gaps: 0,
+          largestGap: 0
+        };
+      }
+      var gaps = this.findGaps(subscriptionId);
+      var totalCached = islands.reduce(function (sum, island) {
+        return sum + (island.endIndex - island.startIndex);
+      }, 0);
+      var largestGap = gaps.length > 0 ? Math.max(...gaps.map(function (g) {
+        return g.endIndex - g.startIndex;
+      })) : 0;
+      return {
+        totalCached,
+        islandCount: islands.length,
+        gaps: gaps.length,
+        largestGap
+      };
+    }
+  }, {
+    /**
+    * Update subscription's progressive cache
+    */
+    key: "updateProgressiveCache",
+    value: function updateProgressiveCache(subscriptionId, docIds, nextCursor, hasMore) {
+      var subscription = this.subscriptions.get(subscriptionId);
+      if (!subscription) return;
+      var updates = {};
+      if (docIds !== void 0) updates.docIds = docIds;
+      if (nextCursor !== void 0) updates.nextCursor = nextCursor !== null && nextCursor !== void 0 ? nextCursor : void 0;
+      if (hasMore !== void 0) updates.hasMore = hasMore;
+      if (Object.keys(updates).length > 0) {
+        subscription.updateProgressiveCache(updates);
+      }
+      this.invalidateCache();
+    }
+  }, {
+    key: "fetchInitialBatch",
+    value:
+    // Private helper methods
+    async function fetchInitialBatch(subscription) {
+      var fetchedDocs = [];
+      var hasMore = true;
+      var currentCursor;
+      var targetSize = subscription.viewWindow.pageSize;
+      while (fetchedDocs.length < targetSize && hasMore) {
+        var res = await this.db.getDocList(subscription.query.doctype, {
+          fields: subscription.query.fields,
+          filters: subscription.query.filters,
+          orderBy: subscription.query.orderBy,
+          cursor: currentCursor,
+          limit: this.batchSize
+        });
+        if (res.length === 0) {
+          hasMore = false;
+          break;
+        }
+        fetchedDocs = [...fetchedDocs, ...res];
+        currentCursor = res.length > 0 ? res[res.length - 1].name : void 0;
+        hasMore = res.length === this.batchSize;
+      }
+      subscription.processDocuments(fetchedDocs, this.normalizedCache);
+      subscription.updateProgressiveCache({
+        hasMore
+      });
+      var pagesLoaded = Math.ceil(fetchedDocs.length / subscription.viewWindow.pageSize) || 1;
+      this.recordIsland(subscription.id, {
+        startPage: 1,
+        endPage: pagesLoaded,
+        startIndex: 0,
+        endIndex: fetchedDocs.length,
+        fetchedVia: "cursor"
+      });
+    }
+  }, {
+    key: "fetchMorePages",
+    value: async function fetchMorePages(subscription, pageCount) {
+      var cache = subscription.getProgressiveCache();
+      if (!cache.hasMore) return;
+      var targetDocCount = subscription.viewWindow.pageSize * pageCount;
+      var currentCount = cache.docIds.length;
+      var neededCount = targetDocCount - currentCount;
+      if (neededCount <= 0) return;
+      var fetchedDocs = [];
+      var hasMore = cache.hasMore;
+      var currentCursor = cache.nextCursor;
+      while (fetchedDocs.length < neededCount && hasMore) {
+        var remainingNeeded = neededCount - fetchedDocs.length;
+        var fetchSize = Math.min(this.batchSize, remainingNeeded);
+        var response = await this.db.getDocList(subscription.query.doctype, {
+          fields: subscription.query.fields,
+          filters: subscription.query.filters,
+          orderBy: subscription.query.orderBy,
+          cursor: currentCursor || void 0,
+          limit: fetchSize
+        });
+        if (response.length === 0) {
+          hasMore = false;
+          break;
+        }
+        fetchedDocs = [...fetchedDocs, ...response];
+        currentCursor = response.length > 0 ? response[response.length - 1].name : void 0;
+        hasMore = response.length === fetchSize && fetchedDocs.length < neededCount;
+      }
+      var newDocIds = fetchedDocs.map(function (doc2) {
+        return doc2.name;
+      });
+      var currentDocIds = subscription.getProgressiveCache().docIds;
+      var updatedDocIds = [...currentDocIds, ...newDocIds];
+      subscription.updateProgressiveCache({
+        docIds: updatedDocIds,
+        nextCursor: fetchedDocs.length > 0 ? fetchedDocs[fetchedDocs.length - 1].name : void 0,
+        hasMore,
+        lastFetchedAt: /* @__PURE__ */new Date()
+      });
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = fetchedDocs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var doc = _step.value;
+          this.normalizedCache.upsert(doc);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      var startIndex = currentCount;
+      var endIndex = startIndex + fetchedDocs.length;
+      var pageSize = subscription.viewWindow.pageSize;
+      var startPage = Math.floor(startIndex / pageSize) + 1;
+      var endPage = Math.ceil(endIndex / pageSize);
+      this.recordIsland(subscription.id, {
+        startPage,
+        endPage,
+        startIndex,
+        endIndex,
+        fetchedVia: "cursor"
+      });
+    }
+  }, {
+    key: "fetchPageByOffset",
+    value: async function fetchPageByOffset(subscription, page) {
+      var pageSize = subscription.viewWindow.pageSize;
+      var limitStart = (page - 1) * pageSize;
+      var response = await this.db.getDocList(subscription.query.doctype, {
+        fields: subscription.query.fields,
+        filters: subscription.query.filters,
+        orderBy: subscription.query.orderBy,
+        limitStart,
+        limit: pageSize
+      });
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = response[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var doc = _step.value;
+          if (!doc.doctype) doc.doctype = subscription.query.doctype;
+          this.normalizedCache.upsert(doc);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      var currentDocIds = [...subscription.getProgressiveCache().docIds];
+      while (currentDocIds.length < limitStart) {
+        currentDocIds.push("");
+      }
+      for (var i = 0; i < response.length; i++) {
+        currentDocIds[limitStart + i] = response[i].name;
+      }
+      subscription.updateProgressiveCache({
+        docIds: currentDocIds,
+        nextCursor: response.length > 0 ? response[response.length - 1].name : void 0,
+        hasMore: response.length === pageSize,
+        lastFetchedAt: /* @__PURE__ */new Date()
+      });
+      this.recordIsland(subscription.id, {
+        startPage: page,
+        endPage: page,
+        startIndex: limitStart,
+        endIndex: limitStart + response.length,
+        fetchedVia: "offset"
+      });
+    }
+  }, {
+    key: "fetchFromCursor",
+    value: async function fetchFromCursor(subscription, cursorDocId) {
+      var response = await this.db.getDocList(subscription.query.doctype, {
+        fields: subscription.query.fields,
+        filters: subscription.query.filters,
+        orderBy: subscription.query.orderBy,
+        cursor: cursorDocId,
+        limit: this.batchSize
+      });
+      if (response.length === 0) return;
+      var existingIds = new Set(subscription.getProgressiveCache().docIds);
+      var newDocs = response.filter(function (doc2) {
+        return !existingIds.has(doc2.name);
+      });
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = newDocs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var doc = _step.value;
+          if (!doc.doctype) doc.doctype = subscription.query.doctype;
+          this.normalizedCache.upsert(doc);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      var newDocIds = newDocs.map(function (doc2) {
+        return doc2.name;
+      });
+      var updatedDocIds = [...subscription.getProgressiveCache().docIds, ...newDocIds];
+      subscription.updateProgressiveCache({
+        docIds: updatedDocIds,
+        nextCursor: response.length > 0 ? response[response.length - 1].name : void 0,
+        hasMore: response.length === this.batchSize,
+        lastFetchedAt: /* @__PURE__ */new Date()
+      });
+    }
+  }, {
+    key: "ensureCached",
+    value: async function ensureCached(subscription, requiredIndex) {
+      var cache = subscription.getProgressiveCache();
+      if (cache.docIds.length >= requiredIndex || !cache.hasMore) return;
+      var pageSize = subscription.viewWindow.pageSize;
+      var pagesNeeded = Math.ceil(requiredIndex / pageSize);
+      await this.fetchMorePages(subscription, pagesNeeded);
+    }
+  }, {
+    key: "recordIsland",
+    value: function recordIsland(subscriptionId, island) {
+      var existing = this.islands.get(subscriptionId) || [];
+      existing.push(island);
+      existing.sort(function (a, b) {
+        return a.startIndex - b.startIndex;
+      });
+      var merged = [];
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = existing[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var current = _step.value;
+          if (merged.length === 0) {
+            merged.push({
+              ...current
+            });
+            continue;
+          }
+          var last = merged[merged.length - 1];
+          var indexOverlap = current.startIndex <= last.endIndex + 1;
+          var pageOverlap = current.startPage <= last.endPage + 1;
+          if (indexOverlap || pageOverlap) {
+            last.endIndex = Math.max(last.endIndex, current.endIndex);
+            last.startIndex = Math.min(last.startIndex, current.startIndex);
+            last.endPage = Math.max(last.endPage, current.endPage);
+            last.startPage = Math.min(last.startPage, current.startPage);
+            if (current.fetchedVia === "cursor" && last.fetchedVia === "offset") {
+              last.fetchedVia = "cursor";
+            }
+          } else {
+            merged.push({
+              ...current
+            });
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      this.islands.set(subscriptionId, merged);
+    }
+  }, {
+    key: "mapIdsToDocuments",
+    value: function mapIdsToDocuments(doctype, docIds) {
+      var _this = this;
+      return docIds.filter(function (id) {
+        return id !== "";
+      }).map(function (id) {
+        return _this.normalizedCache.get({
+          doctype,
+          name: id
+        });
+      }).filter(Boolean);
+    }
+  }, {
+    key: "binarySearchPosition",
+    value: function binarySearchPosition(subscription, newDoc, sortField) {
+      var docIds = subscription.getProgressiveCache().docIds;
+      var orderByField = this.getOrderByField(subscription);
+      var isAscending = (orderByField === null || orderByField === void 0 ? void 0 : orderByField.order) === import_types.Order.Asc;
+      var left = 0;
+      var right = docIds.length - 1;
+      while (left <= right) {
+        var mid = Math.floor((left + right) / 2);
+        var midDoc = this.normalizedCache.get({
+          doctype: subscription.query.doctype,
+          name: docIds[mid]
+        });
+        if (!midDoc) {
+          left = mid + 1;
+          continue;
+        }
+        var midValue = midDoc[sortField];
+        var newValue = newDoc[sortField];
+        var comparison = this.compareValues(midValue, newValue, isAscending);
+        if (comparison < 0) {
+          left = mid + 1;
+        } else {
+          right = mid - 1;
+        }
+      }
+      return left;
+    }
+  }, {
+    key: "compareValues",
+    value: function compareValues(a, b, ascending) {
+      if (a === b) return 0;
+      if (a == null) return ascending ? -1 : 1;
+      if (b == null) return ascending ? 1 : -1;
+      var result = a < b ? -1 : 1;
+      return ascending ? result : -result;
+    }
+  }, {
+    key: "shouldLimitCacheSize",
+    value: function shouldLimitCacheSize(subscription) {
+      var maxItems = Math.max(1e3, subscription.viewWindow.pageSize * 50);
+      return subscription.getProgressiveCache().docIds.length > maxItems;
+    }
+  }, {
+    key: "isViewingLastPage",
+    value: function isViewingLastPage(subscription) {
+      var totalCached = subscription.getProgressiveCache().docIds.length;
+      var pageSize = subscription.viewWindow.pageSize;
+      var lastPage = Math.ceil(totalCached / pageSize);
+      return subscription.viewWindow.currentPage >= lastPage;
+    }
+  }]);
+  return VirtualPageManager2;
+}();
+//# sourceMappingURL=virtualPageManager.native.js.map