@nifrajs/web 5.5.1 → 5.6.0

package/src/internal/live-queries.ts

@@ -0,0 +1,60 @@
+/**
+ * The live client's side of the query seam. A mounted query with live keys registers here, and the
+ * live client matches its keys to the tags each live load grants. Importing this module installs the
+ * seam.
+ */
+import { installQuerySeam, type LiveQuery, queryClients } from "./query-seam.ts"
+
+export type { LiveQuery }
+
+let tick = 0
+
+/** Read by a query as each fetch starts. */
+export const liveTick = (): number => tick
+
+/**
+ * Advanced as each live load's response arrives, and as each query registers. A query whose fetch
+ * started after a load arrived read the server after that load took its watermark.
+ */
+export const advanceLiveTick = (): number => ++tick
+
+// Query to the live tick it registered at: a change before that never reached it.
+const queries = new Map<LiveQuery, number>()
+const watchers = new Set<() => void>()
+
+function changed(): void {
+  for (const watcher of watchers) watcher()
+}
+
+export function liveQueries(): Iterable<LiveQuery> {
+  return queries.keys()
+}
+
+/** The live tick `query` registered at, or `undefined` once it left. */
+export function registeredAt(query: LiveQuery): number | undefined {
+  return queries.get(query)
+}
+
+/** Returns the function that stops watching. */
+export function watchLiveQueries(watcher: () => void): () => void {
+  watchers.add(watcher)
+  return () => {
+    watchers.delete(watcher)
+  }
+}
+
+/** Another viewer: no query client keeps data loaded for the last one. */
+export function clearQueryClients(): void {
+  for (const ref of queryClients()) ref.deref()?.clear()
+}
+
+installQuerySeam({
+  tick: liveTick,
+  track(query, mounted) {
+    if (mounted && query.keys().length > 0) {
+      if (queries.has(query)) return
+      queries.set(query, advanceLiveTick())
+      changed()
+    } else if (queries.delete(query)) changed()
+  },
+})

package/src/internal/page-events.ts

@@ -0,0 +1,27 @@
+/** Dispatched on a kept page's element as the router hides it (`keepAlive`), while it is still in the
+ * document and before the router's subscribers see the state that hides it. */
+export const PAGE_HIDE_EVENT = "nifra:pagehide"
+/** Dispatched on a kept page's element once it is shown again. */
+export const PAGE_SHOW_EVENT = "nifra:pageshow"
+
+const releases = new WeakMap<object, Set<() => void>>()
+
+/** Run `release` once the kept page `page` leaves its view for good; the result cancels it. */
+export function onPageRelease(page: object, release: () => void): () => void {
+  let pending = releases.get(page)
+  if (pending === undefined) {
+    pending = new Set()
+    releases.set(page, pending)
+  }
+  pending.add(release)
+  return () => {
+    pending.delete(release)
+  }
+}
+
+/** The kept page `page` left its view: what its hidden content set aside goes. */
+export function releasePage(page: object): void {
+  const pending = releases.get(page)
+  releases.delete(page)
+  for (const release of pending ?? []) release()
+}