@50arms/ui 0.0.0-stage → 35.2.0

package/dist/lib/paged-window/store.js

@@ -0,0 +1,562 @@
+import { getRecordStoreTenant as c, recordStoreVersion as g } from "../records/store.js";
+import { RecordsBinding as w } from "./records-binding.js";
+const q = 200, f = Object.freeze([]);
+function d(u) {
+  u.stale = !0, u.lossRead = !1;
+}
+function y(u, e, t) {
+  const s = Math.floor((t - 1) / 2), r = Math.max(0, u - s), i = Math.min(e - 1, u + (t - 1 - s)), n = [];
+  for (let o = r; o <= i; o++) n.push(o);
+  return n;
+}
+function p(u) {
+  return u.stale || u.refreshing;
+}
+class m {
+  pageSize;
+  windowPages;
+  settleMs;
+  getKey;
+  loadPage;
+  loadCount;
+  /** The resident pages: the window around the applied anchor. */
+  resident = /* @__PURE__ */ new Map();
+  /** DX-5521: ready pages outside the window, rows kept (see the header). */
+  retained = /* @__PURE__ */ new Map();
+  total = null;
+  /** Where the viewer is; moves the instant they do. */
+  anchor = 0;
+  /** The anchor the resident pages' READS were last synced to; differs from `anchor` while the viewer is still moving, or frozen. */
+  appliedAnchor = 0;
+  /** Moves the window to `anchor` once it has been still for `settleMs`; null when no move is waiting. */
+  settleTimer = null;
+  mode;
+  frozen = !1;
+  epoch = 0;
+  nextToken = 1;
+  countRequest = null;
+  /** Answers that arrived while frozen, applied in arrival order on thaw. */
+  heldAnswers = [];
+  /** Pages whose refresh was asked for while frozen. */
+  queuedPages = /* @__PURE__ */ new Set();
+  /** The length's refresh (count mode) was asked for while frozen. */
+  queuedCount = !1;
+  countError = void 0;
+  /** DXUI-83: the token of the last count read that settled, answered or failed; a count window's placed rows wait on it like a page window's on its pages' `readSeq`. */
+  countSettledSeq = 0;
+  snapshot;
+  listeners = /* @__PURE__ */ new Set();
+  /** DXUI-77: the record mode, or null when the window holds its rows itself. */
+  rec;
+  /** DXUI-77: a record changed while frozen; the thaw looks at it once. */
+  recordsPending = !1;
+  /** DXUI-77: the store tenant the pages were last requested under; a different one now means the store was cleared under them. */
+  tenantSeen = void 0;
+  /** DXUI-77: the store version the window last looked at; one flush calls the handler once per changed key, and one look covers them all. */
+  recordsVersion = -1;
+  /** DXUI-77: a held key unknown to the store already sent the window to re-read; no answer has made every key known since. */
+  unknownReread = !1;
+  constructor({
+    pageSize: e,
+    getKey: t,
+    windowPages: s = 3,
+    loadPage: r,
+    loadCount: i,
+    mode: n = "pages",
+    settleMs: o = q,
+    records: a
+  }) {
+    if (!Number.isInteger(e) || e < 1)
+      throw new Error(`PagedWindowStore: pageSize must be a positive integer, got ${e}.`);
+    if (!Number.isInteger(s) || s < 1)
+      throw new Error(`PagedWindowStore: windowPages must be a positive integer, got ${s}.`);
+    if (typeof t != "function")
+      throw new Error("PagedWindowStore: getKey is required; it names a row so one row is never drawn on two pages.");
+    if (!Number.isInteger(o) || o < 0)
+      throw new Error(`PagedWindowStore: settleMs must be a non-negative integer, got ${o}.`);
+    this.pageSize = e, this.windowPages = s, this.settleMs = o, this.getKey = t, this.loadPage = r, this.loadCount = i, this.requireCountLoader(n), this.mode = n, this.rec = a ? new w(a, this.onRecordsChanged, t) : null, this.snapshot = this.build();
+  }
+  /**
+   * Replace the loaders. The React binding calls this after every commit so a
+   * consumer's loaders can close over fresh state without the store being
+   * rebuilt (rebuilding drops every resident page). A change in WHAT is loaded is a
+   * `reset`, never this.
+   */
+  setLoaders(e, t, s) {
+    if (this.loadPage = e, this.loadCount = t, s !== void 0) {
+      if (!this.rec) throw new Error("PagedWindowStore: records cannot be added after the window is created; mount a new list.");
+      this.rec.update(s);
+    }
+  }
+  getSnapshot = () => this.snapshot;
+  subscribe = (e) => (this.listeners.add(e), () => {
+    this.listeners.delete(e);
+  });
+  /**
+   * The viewer moved to another page. The window follows once they have stayed
+   * there for `settleMs`; while frozen it follows on thaw.
+   */
+  setAnchorPage(e) {
+    if (!Number.isInteger(e) || e < 0)
+      throw new Error(`PagedWindowStore: anchor page must be a non-negative integer, got ${e}.`);
+    if (e !== this.anchor) {
+      if (this.anchor = e, this.clearSettle(), this.frozen) return this.publish();
+      if (e === this.appliedAnchor || this.settleMs === 0) return this.applyAnchor();
+      this.drawFromMemory(), this.settleTimer = setTimeout(() => {
+        this.settleTimer = null, this.applyAnchor();
+      }, this.settleMs), this.publish();
+    }
+  }
+  /**
+   * While true nothing about the window changes: it neither loads nor drops
+   * pages, starts no refresh and applies no answer, whatever the anchor or the
+   * total does (all of it waits for the thaw). A drag needs it: the carried card
+   * is mounted in its page, and dropping that page mid-drag would unmount the
+   * card and cancel the drag. Only `reset()` ignores it — a query change is a
+   * different list.
+   */
+  setFrozen(e) {
+    e !== this.frozen && (this.frozen = e, this.clearSettle(), e || this.thaw(), this.publish());
+  }
+  /** `count` holds and requests no cards, only the length (see the file header). */
+  setMode(e) {
+    e !== this.mode && (this.requireCountLoader(e), this.mode = e, e === "count" ? (this.rec?.reset(), this.requestCount()) : (this.abortCount(), this.queuedCount = !1), this.sync());
+  }
+  /** The query changed: forget everything, return to the first page. */
+  reset() {
+    this.dropAll(), this.total = null, this.anchor = 0, this.appliedAnchor = 0, this.epoch += 1, this.mode === "count" && this.requestCount(), this.reconcile(!0), this.publish();
+  }
+  /** Re-read one resident page in place. A retained page is marked stale and re-read in place when it re-enters the window; a page never loaded loads fresh when it is next wanted. */
+  invalidatePage(e) {
+    const t = this.resident.get(e);
+    if (!t) {
+      const s = this.retained.get(e);
+      s && d(s);
+      return;
+    }
+    this.refreshResident(e, t), this.publishUnlessFrozen();
+  }
+  /**
+   * DX-5521: invalidate every page, resident or retained, that has a row passing `rowTest`: a resident one is re-read in place, a retained
+   * one is marked stale and re-read when it re-enters the window. Returns whether any page matched.
+   */
+  invalidateWhere(e) {
+    let t = !1;
+    for (const [s, r] of this.resident)
+      this.loadedRows(r).some(e) && (t = !0, this.refreshResident(s, r));
+    for (const s of this.retained.values())
+      this.loadedRows(s).some(e) && (t = !0, d(s));
+    return t && this.publishUnlessFrozen(), t;
+  }
+  /**
+   * DX-5521: whether any CURRENT loaded row, resident or retained, passes `rowTest`. A stale page, in the window or kept, does not count:
+   * something already said its rows changed, so a row it shows may no longer be where it shows it (`invalidateWhere` still marks it). Changes
+   * nothing.
+   */
+  holdsRow(e) {
+    for (const t of this.resident.values()) if (!t.stale && this.loadedRows(t).some(e)) return !0;
+    for (const t of this.retained.values()) if (!t.stale && this.loadedRows(t).some(e)) return !0;
+    return !1;
+  }
+  /** Re-read every resident page in place and mark every retained one stale; in `count` mode, re-ask the length. */
+  invalidateAll() {
+    for (const e of this.retained.values()) d(e);
+    this.mode === "count" && (this.frozen ? this.queuedCount = !0 : this.requestCount());
+    for (const [e, t] of this.resident) this.refreshResident(e, t);
+    this.publishUnlessFrozen();
+  }
+  /**
+   * A resident page's rows are out of date: read it again now, or at the thaw when frozen (a page that leaves the window by then is kept stale,
+   * see `release`). No notification: callers publish. A page drawn from memory by a move (`readDue`) is read at the settle already, so it is not
+   * read earlier. A page outside the drawing that is only finishing a read (`outside`) is nobody's to look at: the read, whose answer now
+   * predates the invalidation, is abandoned and the page is kept stale, to be re-read if the viewer returns. Whichever read follows answers an
+   * invalidation, so a loss re-read's damping is lifted (`lossRead`).
+   */
+  refreshResident(e, t) {
+    t.lossRead = !1, !t.readDue && (this.frozen ? this.queuedPages.add(e) : t.outside ? this.leave(e, t, !0) : this.request(e, t));
+  }
+  /** Nothing a view draws changes while frozen (the refreshes wait for the thaw), so nobody is told. */
+  publishUnlessFrozen() {
+    this.frozen || this.publish();
+  }
+  /** Load the first window (or the length). The binding calls it on mount, and again after a `stop`. */
+  start() {
+    this.rec?.attach(() => [...this.heldKeys()], () => this.invalidateAll()), this.mode === "count" && this.requestCount(), this.applyAnchor();
+  }
+  /** Abort every request and release every page. The binding calls it on unmount. */
+  stop() {
+    this.dropAll(), this.rec?.detach();
+  }
+  requireCountLoader(e) {
+    if (e === "count" && this.loadCount === void 0)
+      throw new Error("PagedWindowStore: count mode needs a loadCount; none was given.");
+  }
+  pageCount() {
+    return this.total === null ? 0 : Math.ceil(this.total / this.pageSize);
+  }
+  /**
+   * Pages to hold now. None in `count` mode. Page 0 alone before the first
+   * response (the count is unknown) and for an empty list: an empty page is
+   * still resident, because it is what `invalidateAll` re-reads when the list gets
+   * its first item — an empty lane that holds nothing could never find out it
+   * was no longer empty.
+   */
+  wanted(e = this.appliedAnchor) {
+    if (this.mode === "count") return [];
+    if (this.total === null || this.total === 0) return [0];
+    const t = Math.min(e, this.pageCount() - 1);
+    return y(t, this.pageCount(), this.windowPages);
+  }
+  /** Bring the resident pages to the wanted ones — unless frozen, when that waits for the thaw. */
+  sync() {
+    this.reconcile(), this.publish();
+  }
+  /** The viewer has settled on `anchor`: the window moves to it, in one step. */
+  applyAnchor() {
+    this.clearSettle(), !this.frozen && (this.appliedAnchor = this.anchor, this.sync());
+  }
+  clearSettle() {
+    this.settleTimer !== null && (clearTimeout(this.settleTimer), this.settleTimer = null);
+  }
+  /**
+   * Moves the resident pages to the window around `appliedAnchor` - which only
+   * `applyAnchor`, `thaw` and `reset` move, so a response arriving while the
+   * viewer is still moving brings in no READ for a page of the unsettled position
+   * (it only draws what memory already holds, `drawFromMemory`).
+   * `force` is `reset()`'s alone: it brings the window to its (new) list even
+   * while frozen.
+   */
+  reconcile(e = !1) {
+    if (this.frozen && !e) return;
+    if (this.anchor !== this.appliedAnchor && !e) return this.drawFromMemory();
+    const t = new Set(this.wanted());
+    this.release((s) => !t.has(s), !1);
+    for (const s of t) {
+      const r = this.resident.get(s);
+      if (r) {
+        r.readDue && this.request(s, r, r.lossRead);
+        continue;
+      }
+      const i = this.promote(s);
+      if (i) {
+        i.stale && this.request(s, i, i.lossRead);
+        continue;
+      }
+      const n = { status: "loading", items: [], keys: f, tenant: void 0, refreshing: !1, stale: !1, readDue: !1, outside: !1, lossRead: !1, error: void 0, readSeq: 0, token: 0, controller: null };
+      this.resident.set(s, n), this.request(s, n);
+    }
+  }
+  /**
+   * DX-5521: a move the viewer has not settled on draws what memory already holds for it: the retained pages of the destination window become
+   * resident (a stale one with its old rows and its read due at the settle) and the pages outside that window leave the drawing. No read starts
+   * and none is aborted, so a return before the settle costs nothing (DX-4614). When nothing of the destination is in memory the window stays
+   * where it is, so the old pages remain on screen until the settle.
+   */
+  drawFromMemory() {
+    const e = new Set(this.wanted(this.anchor)), t = [...e].filter((s) => this.resident.has(s) || this.retained.has(s));
+    if (t.length !== 0) {
+      this.release((s) => !e.has(s), !0);
+      for (const s of t) {
+        const r = this.promote(s);
+        r?.stale && (r.readDue = !0);
+      }
+    }
+  }
+  /**
+   * Resident pages that fail `leaves` go: a ready one keeps its rows in `retained` (stale if they may be out of date); one never loaded has
+   * none to keep. A read in flight is aborted, unless `keepReads` (a move not yet settled): that page stays resident but `outside` the drawing,
+   * so the viewer coming back finds its read still running. Then the rows past the list's end (it shrank), and every row in count mode (no rows
+   * are tracked there), are dropped: they belong to no list anyone can scroll.
+   */
+  release(e, t) {
+    for (const [s, r] of this.resident)
+      if (r.outside = !1, !!e(s)) {
+        if (t && r.controller !== null) {
+          r.outside = !0;
+          continue;
+        }
+        this.leave(s, r, !1);
+      }
+    if (this.mode === "count") this.retained.clear();
+    else if (this.total !== null)
+      for (const s of [...this.retained.keys()]) s >= this.pageCount() && this.retained.delete(s);
+  }
+  /**
+   * DX-5521: a resident page goes: a read in flight is aborted, a ready page keeps its rows in `retained`. They are stale if a read was cut short,
+   * if the page was already stale, if an invalidation was queued for it while frozen (the queue is dropped with the page, so the mark is the only
+   * trace), or if `stale` says an invalidation has just arrived. A page never loaded has no rows to keep. A loss re-read's damping goes with
+   * the rows unless one of those invalidations lifts it.
+   */
+  leave(e, t, s) {
+    t.controller?.abort(), this.resident.delete(e);
+    const r = this.queuedPages.delete(e);
+    if (t.status !== "ready") return;
+    const i = s || r;
+    this.retained.set(e, {
+      items: t.items,
+      keys: t.keys,
+      stale: i || t.refreshing || t.stale,
+      lossRead: !i && t.lossRead,
+      readSeq: t.readSeq
+    });
+  }
+  /** DX-5521: a retained page back in the window: resident at once and `ready` with its old rows, never `loading`. Undefined when nothing is kept for it. */
+  promote(e) {
+    const t = this.retained.get(e);
+    if (!t) return;
+    this.retained.delete(e);
+    const s = { status: "ready", items: t.items, keys: t.keys, tenant: void 0, refreshing: !1, stale: t.stale, readDue: !1, outside: !1, lossRead: t.lossRead, error: void 0, readSeq: t.readSeq, token: 0, controller: null };
+    return this.resident.set(e, s), s;
+  }
+  /** Everything the frozen window put off, in the order the header promises. */
+  thaw() {
+    const e = this.heldAnswers;
+    this.heldAnswers = [];
+    for (const s of e) s();
+    this.appliedAnchor = this.anchor, this.reconcile();
+    const t = [...this.queuedPages];
+    this.queuedPages.clear();
+    for (const s of t) {
+      const r = this.resident.get(s);
+      r && this.request(s, r);
+    }
+    this.queuedCount && (this.queuedCount = !1, this.requestCount()), this.recordsPending && (this.recordsPending = !1, this.applyRecordsChange());
+  }
+  /** Start (or restart) a page's request; whatever was in flight is abandoned. `forLoss`: it is sent because the page lost a row (DX-5521). */
+  request(e, t, s = !1) {
+    t.controller?.abort();
+    const r = new AbortController(), i = this.nextToken++;
+    t.controller = r, t.token = i, this.rec && (t.tenant = c(), this.tenantSeen = t.tenant), t.stale = !1, t.readDue = !1, t.lossRead = s, t.status === "ready" ? t.refreshing = !0 : (t.status = "loading", t.error = void 0), this.loadPage(e, { signal: r.signal }).then(
+      (n) => this.settle(e, i, { ok: !0, response: n }),
+      (n) => this.settle(e, i, { ok: !1, error: n })
+    );
+  }
+  settle(e, t, s) {
+    const r = this.resident.get(e);
+    if (!(!r || r.token !== t)) {
+      if (this.frozen) {
+        this.heldAnswers.push(() => this.applyPage(e, t, s));
+        return;
+      }
+      this.applyPage(e, t, s), this.sync();
+    }
+  }
+  /**
+   * Record an answer on its page — no window change, no notification: callers
+   * sync once. Re-checks the token because a entry answer is replayed on thaw,
+   * after which its request may have been abandoned.
+   */
+  applyPage(e, t, s) {
+    const r = this.resident.get(e);
+    if (!(!r || r.token !== t)) {
+      if (r.controller = null, s.ok) {
+        let i = f;
+        if (this.rec) {
+          if (!w.tenantIsCurrent(r.tenant)) return this.request(e, r);
+          i = this.rec.write(s.response.items, r.tenant), this.unknownReread && !i.some((n) => this.rec.isUnknown(n)) && (this.unknownReread = !1);
+        }
+        if (r.status = "ready", r.items = this.rec ? [] : s.response.items, r.keys = i, r.readSeq = t, r.refreshing = !1, r.error = void 0, this.total !== null && this.total !== s.response.total) {
+          for (const n of this.retained.values()) d(n);
+          for (const [n, o] of this.resident) n !== e && o.controller === null && d(o);
+        }
+        this.total = s.response.total;
+        return;
+      }
+      r.status = "error", r.items = [], r.keys = f, r.refreshing = !1, r.error = s.error;
+    }
+  }
+  requestCount() {
+    this.requireCountLoader("count"), this.countRequest?.controller.abort();
+    const e = new AbortController(), t = this.nextToken++;
+    this.countRequest = { token: t, controller: e }, this.rec && (this.tenantSeen = c()), this.loadCount({ signal: e.signal }).then(
+      (s) => this.settleCount(t, { ok: !0, total: s }),
+      (s) => this.settleCount(t, { ok: !1, error: s })
+    );
+  }
+  settleCount(e, t) {
+    if (this.countRequest?.token === e) {
+      if (this.frozen) {
+        this.heldAnswers.push(() => this.applyCount(e, t));
+        return;
+      }
+      this.applyCount(e, t), this.publish();
+    }
+  }
+  applyCount(e, t) {
+    this.countRequest?.token === e && (this.countRequest = null, this.countSettledSeq = e, t.ok ? (this.total = t.total, this.countError = void 0) : this.countError = t.error);
+  }
+  abortCount() {
+    this.countRequest?.controller.abort(), this.countRequest = null;
+  }
+  dropAll() {
+    this.clearSettle();
+    for (const e of this.resident.values()) e.controller?.abort();
+    this.resident.clear(), this.retained.clear(), this.abortCount(), this.queuedPages.clear(), this.queuedCount = !1, this.recordsPending = !1, this.rec?.reset();
+  }
+  /* --- Record mode (DXUI-77) --------------------------------------------------- */
+  /** A held record changed, or a layer moved on a record of the type. */
+  onRecordsChanged = () => {
+    if (this.frozen) {
+      this.recordsPending = !0;
+      return;
+    }
+    g() !== this.recordsVersion && this.applyRecordsChange();
+  };
+  applyRecordsChange() {
+    const e = this.rec;
+    if (!e) return;
+    this.recordsVersion = g(), e.followLayers(this.heldKeys(), this.nextToken) || this.storeWasCleared(e) ? this.invalidateAll() : this.publish();
+  }
+  /**
+   * A tenant change or a clear leaves the window holding keys to nothing, and `reissueMountedReads` does not cover it (it runs on the realtime
+   * epoch, which neither bumps). So the window looks for itself: the store serves another tenant than the pages were requested under, or a page
+   * that is current (not being read) holds a key the store knows nothing of.
+   */
+  storeWasCleared(e) {
+    const t = c();
+    if (t !== this.tenantSeen)
+      return this.tenantSeen = t, !0;
+    if (this.unknownReread) return !1;
+    for (const s of this.resident.values())
+      if (!(s.status !== "ready" || s.refreshing || s.stale) && s.keys.some((r) => e.isUnknown(r)))
+        return this.unknownReread = !0, !0;
+    return !1;
+  }
+  /** Every key a page holds, resident or retained. */
+  heldKeys() {
+    const e = /* @__PURE__ */ new Set();
+    for (const t of this.resident.values()) for (const s of t.keys) e.add(s);
+    for (const t of this.retained.values()) for (const s of t.keys) e.add(s);
+    return e;
+  }
+  /** The rows a page draws from its own position: its held rows, or in record mode the held keys read from the store. */
+  pageRows(e) {
+    return this.rec ? this.rec.rowsOf(e.keys) : e.items;
+  }
+  /** Every loaded row of a page, for a consumer's row test: whether or not it belongs here now. */
+  loadedRows(e) {
+    return this.rec ? this.rec.loadedRowsOf(e.keys) : e.items;
+  }
+  /** Every resident page (a count window: its length) has been answered by a read sent at or after `seq` (a read that failed has nothing to wait for). */
+  answeredSince(e) {
+    if (this.mode === "count") return this.countSettledSeq >= e;
+    for (const t of this.resident.values())
+      if (t.status !== "error" && (t.status !== "ready" || t.readSeq < e))
+        return !1;
+    return !0;
+  }
+  /** The list's length as the window shows it: the server's, less each held row that left its page, plus each arrived row no page holds yet (a count window holds no row: it adds arrivals only). */
+  visibleTotal() {
+    if (this.total === null || !this.rec) return this.total;
+    const e = this.heldKeys();
+    return Math.max(0, this.total - this.rec.countLeftOut(e) + this.rec.countArrived(e));
+  }
+  /** Placement and the store subscriptions follow the keys the window holds now. */
+  syncRecords() {
+    const e = this.rec;
+    if (!e) return;
+    const t = this.heldKeys();
+    e.refreshPlacement(t), e.settlePlacement((i) => this.answeredSince(i));
+    const s = e.placedKeys(), r = new Set(s);
+    for (const i of this.resident.values()) for (const n of i.keys) r.add(n);
+    e.reconcile(r, /* @__PURE__ */ new Set([...t, ...s]));
+  }
+  /** The resident pages the snapshot draws: the window, without the pages that only stay to finish a read (`outside`). */
+  drawn() {
+    return [...this.resident.entries()].filter(([, e]) => !e.outside);
+  }
+  /**
+   * The longest unbroken stretch of ready pages inside the list, lowest on a
+   * tie. Pages past the list's end (it shrank while the window was frozen) are
+   * not part of any run.
+   */
+  loadedRun() {
+    const e = Math.max(1, this.pageCount()), t = this.drawn().filter(([i, n]) => n.status === "ready" && i < e).map(([i]) => i).sort((i, n) => i - n);
+    let s = [], r = [];
+    for (const i of t)
+      r = r.length > 0 && i === r[r.length - 1] + 1 ? [...r, i] : [i], r.length > s.length && (s = r);
+    return s;
+  }
+  /**
+   * DX-5521: each drawn page's items with every row key on one page only (ONE ROW KEY, ONE PAGE in the header). Pages claim their rows in
+   * order of how current they are - a page with current rows before a stale or refreshing one, then the newer read first - and a row whose
+   * key an earlier claimant took is left out. A page that loses nothing keeps its own array.
+   */
+  uniqueItems(e, t) {
+    const s = [...e].sort(([, n], [, o]) => Number(p(n)) - Number(p(o)) || o.readSeq - n.readSeq), r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map();
+    for (const [n] of s) {
+      const o = t.get(n), a = o.filter((h) => {
+        const l = this.getKey(h);
+        return r.has(l) ? !1 : (r.add(l), !0);
+      });
+      i.set(n, a.length === o.length ? o : a);
+    }
+    return i;
+  }
+  /**
+   * DX-5521: a drawn page whose rows are current but lost a row to another page is out of date, since two right pages cannot share a row:
+   * re-read it in place, so the page is not left one row short until some other event. One pass finds every such page: marking a page out of
+   * date only lowers its rank, so it never makes another page lose a row. A page whose latest read was already a loss re-read is not re-read
+   * again (ONE RE-READ PER LOSS in the header). Settled, the read starts now; while the viewer is still moving the page is marked stale and read
+   * at the settle (DX-4614). Frozen, it looks for nothing: every answer is held, so no page can lose a row until the thaw publishes again.
+   */
+  rereadLosers() {
+    if (this.frozen) return;
+    const e = this.drawn(), t = this.rowsByPage(e), s = this.uniqueItems(e, t), r = this.anchor === this.appliedAnchor;
+    for (const [i, n] of e)
+      p(n) || n.lossRead || s.get(i).length !== t.get(i).length && (r ? this.request(i, n, !0) : (n.stale = !0, n.readDue = !0, n.lossRead = !0));
+  }
+  /** Each drawn page's rows, before the one-key-one-page rule: its held rows, or its keys read from the store. */
+  rowsByPage(e) {
+    return new Map(e.map(([t, s]) => [t, this.pageRows(s)]));
+  }
+  /**
+   * DXUI-77: the loaded run with the placed rows (arrived and moved) drawn at the place `placeIn` gives. Returns `items` itself when nothing
+   * moved, else the same map with each shown page's rows regrouped by the page a row now sits in.
+   */
+  withPlacedRows(e, t) {
+    const s = this.rec;
+    if (!s || this.mode !== "pages" || t.size === 0) return e;
+    const r = [...t].sort((h, l) => h - l), i = r.flatMap((h) => e.get(h).map((l) => ({ row: l, page: h }))), n = Math.max(0, this.pageCount() - 1), o = s.place(i, r[0], r[r.length - 1], n);
+    if (o === i) return e;
+    const a = new Map(e);
+    for (const h of r) a.set(h, o.filter((l) => l.page === h).map((l) => l.row));
+    return a;
+  }
+  /** DXUI-77: a page whose rows did not change keeps its items array, which `useSyncExternalStore` needs from a snapshot it did not change. */
+  static sameRows(e, t) {
+    return e.length === t.length && e.every((s, r) => s === t[r]);
+  }
+  build() {
+    const e = new Set(this.loadedRun()), t = this.drawn(), s = this.withPlacedRows(this.uniqueItems(t, this.rowsByPage(t)), e), r = this.snapshot, i = (a, h) => this.rec && h && m.sameRows(a, h) ? h : a, n = t.sort(([a], [h]) => a - h).map(([a, h]) => ({
+      page: a,
+      status: h.status,
+      items: i(s.get(a), r?.pages.find((l) => l.page === a)?.items),
+      refreshing: h.refreshing,
+      error: h.error,
+      shown: e.has(a)
+    })), o = n.filter((a) => a.shown);
+    return {
+      mode: this.mode,
+      total: this.visibleTotal(),
+      pageSize: this.pageSize,
+      pageCount: this.pageCount(),
+      anchorPage: this.anchor,
+      epoch: this.epoch,
+      pages: n,
+      items: i(o.flatMap((a) => a.items), r?.items),
+      offset: o.length > 0 ? o[0].page * this.pageSize : 0,
+      countError: this.countError
+    };
+  }
+  publish() {
+    this.syncRecords(), this.rereadLosers(), this.snapshot = this.build();
+    for (const e of this.listeners) e();
+  }
+}
+export {
+  q as PAGED_WINDOW_SETTLE_MS,
+  m as PagedWindowStore,
+  y as windowPageNumbers
+};
+//# sourceMappingURL=store.js.map