@antelopejs/dms 0.7.9 → 0.7.10

package/frontend-vue/layers/dms-ui/app/build/composables/live/liveCadence.ts

@@ -0,0 +1,42 @@
+import type { PageLiveOptions, PageLivePeriod } from "../../../types/live";
+
+const MS_PER_SECOND = 1000;
+const MS_PER_UNIT: Record<string, number> = {
+  m: 60 * MS_PER_SECOND,
+  h: 60 * 60 * MS_PER_SECOND,
+  d: 24 * 60 * 60 * MS_PER_SECOND,
+};
+const PERIOD_PATTERN = /^(\d+)([mhd])$/;
+
+/**
+ * The length of a `slowRateAfter.period` in ms, `null` when it does not read
+ * like `"30m"`, `"24h"` or `"7d"`.
+ *
+ * @internal
+ */
+export function livePeriodMs(period: PageLivePeriod | string): number | null {
+  const match = PERIOD_PATTERN.exec(period);
+  if (!match) return null;
+  const [, amount, unit] = match;
+  return Number(amount) * (MS_PER_UNIT[unit!] ?? 0) || null;
+}
+
+/**
+ * The shortest interval between two reads of one block, in ms, for a page
+ * showing a period spanning `periodSpanMs` (`null` without a period): the
+ * slower `slowRateAfter` once the span reaches its period, `maxRate` else,
+ * 0 for no cap.
+ *
+ * @internal
+ */
+export function liveIntervalMs(
+  options: PageLiveOptions,
+  periodSpanMs: number | null,
+): number {
+  const slow = options.slowRateAfter;
+  const slowFrom = slow ? livePeriodMs(slow.period) : null;
+  if (slow && slowFrom !== null && periodSpanMs !== null) {
+    if (periodSpanMs >= slowFrom) return slow.maxRate * MS_PER_SECOND;
+  }
+  return (options.maxRate ?? 0) * MS_PER_SECOND;
+}

package/frontend-vue/layers/dms-ui/app/build/composables/live/liveHolds.ts

@@ -0,0 +1,66 @@
+import { computed, shallowRef, type ComputedRef } from "vue";
+import type { PageLiveNote, PageLiveNoteInput } from "../../../types/live";
+
+interface HoldEntry {
+  note: PageLiveNote;
+  /** The user resumed over this hold: it no longer pauses the page. */
+  isLifted: boolean;
+}
+
+/**
+ * A note given as its text alone, as a full note.
+ *
+ * @internal
+ */
+export function toLiveNote(input: PageLiveNoteInput): PageLiveNote {
+  return typeof input === "string" ? { text: input } : input;
+}
+
+/**
+ * The components holding a live page paused, each with its reason. A hold the
+ * user resumed over is lifted: it stays lifted while its owner keeps holding,
+ * and pauses again once released and taken anew.
+ *
+ * @internal
+ */
+export class LiveHolds {
+  private readonly entries = shallowRef(new Map<symbol, HoldEntry>());
+
+  /** The reason of the first hold still pausing the page, `null` without one. */
+  readonly activeNote: ComputedRef<PageLiveNote | null> = computed(() => {
+    for (const entry of this.entries.value.values()) {
+      if (!entry.isLifted) return entry.note;
+    }
+    return null;
+  });
+
+  get isActive(): boolean {
+    return this.activeNote.value !== null;
+  }
+
+  set(owner: symbol, note: PageLiveNoteInput): void {
+    const isLifted = this.entries.value.get(owner)?.isLifted ?? false;
+    this.replace((entries) =>
+      entries.set(owner, { note: toLiveNote(note), isLifted }),
+    );
+  }
+
+  release(owner: symbol): void {
+    if (!this.entries.value.has(owner)) return;
+    this.replace((entries) => entries.delete(owner));
+  }
+
+  liftAll(): void {
+    this.replace((entries) => {
+      for (const entry of entries.values()) entry.isLifted = true;
+    });
+  }
+
+  private replace(change: (entries: Map<symbol, HoldEntry>) => void): void {
+    const next = new Map(
+      [...this.entries.value].map(([owner, entry]) => [owner, { ...entry }]),
+    );
+    change(next);
+    this.entries.value = next;
+  }
+}

package/frontend-vue/layers/dms-ui/app/build/composables/live/livePoller.ts

@@ -0,0 +1,42 @@
+import { readonly, ref, type Ref } from "vue";
+
+/**
+ * Reads the page's blocks on a clock while the realtime stream is down: the
+ * fallback of a live page with a cadence. Each tick asks the interval again,
+ * so a period changed meanwhile applies from the next one.
+ *
+ * @internal
+ */
+export class LivePoller {
+  private readonly active = ref(false);
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  /** The poller is running: the stream is down and the page reads by itself. */
+  readonly isPolling: Readonly<Ref<boolean>> = readonly(this.active);
+
+  constructor(
+    private readonly intervalMs: () => number,
+    private readonly poll: () => void,
+  ) {}
+
+  /** Runs while `shouldRun` holds and the page has a cadence; stops else. */
+  update(shouldRun: boolean): void {
+    const isRunning = shouldRun && this.intervalMs() > 0;
+    if (isRunning === this.active.value) return;
+    this.active.value = isRunning;
+    if (isRunning) this.schedule();
+    else this.stop();
+  }
+
+  stop(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    this.active.value = false;
+  }
+
+  private schedule(): void {
+    this.timer = setTimeout(() => {
+      this.poll();
+      if (this.active.value) this.schedule();
+    }, this.intervalMs());
+  }
+}

package/frontend-vue/layers/dms-ui/app/build/composables/live/liveStorage.ts

@@ -0,0 +1,42 @@
+const STORAGE_KEY_PREFIX = "dms.live.paused:";
+const REMEMBER_KEY_PREFIX = "key:";
+const PAUSED_VALUE = "1";
+
+/** Browser storage of the paused pages; absent on the server or when denied. */
+function liveStorage(): Storage | undefined {
+  try {
+    return typeof window === "undefined" ? undefined : window.localStorage;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The storage key of a page's Live / Pause choice: its `live.rememberKey` when it
+ * shares one, its own id else.
+ *
+ * @internal
+ */
+export function liveStorageKey(pageId: string, rememberKey?: string): string {
+  return (
+    STORAGE_KEY_PREFIX +
+    (rememberKey ? REMEMBER_KEY_PREFIX + rememberKey : pageId)
+  );
+}
+
+/** @internal */
+export function readStoredPause(key: string): boolean {
+  return liveStorage()?.getItem(key) === PAUSED_VALUE;
+}
+
+/** @internal */
+export function storePause(key: string, isPaused: boolean): void {
+  const storage = liveStorage();
+  if (!storage) return;
+  try {
+    if (isPaused) storage.setItem(key, PAUSED_VALUE);
+    else storage.removeItem(key);
+  } catch {
+    // A full or locked storage only loses the memory of the choice.
+  }
+}

package/frontend-vue/layers/dms-ui/app/build/composables/live/missedTally.ts

@@ -0,0 +1,65 @@
+import { readonly, ref, type Ref } from "vue";
+
+interface PublishedEvent {
+  topic?: unknown;
+  payload?: { ids?: unknown; count?: unknown };
+}
+
+function rowKeysOf(event: PublishedEvent): string[] {
+  const ids = event.payload?.ids;
+  if (!Array.isArray(ids)) return [];
+  const topic = typeof event.topic === "string" ? event.topic : "";
+  return ids
+    .filter((id) => typeof id === "string" || typeof id === "number")
+    .map((id) => JSON.stringify([topic, id]));
+}
+
+function batchCountOf(event: PublishedEvent): number | null {
+  const count = event.payload?.count;
+  return typeof count === "number" && Number.isInteger(count) && count > 0
+    ? count
+    : null;
+}
+
+/**
+ * What the events received since the pause stand for, published rows rather
+ * than messages: a message naming rows in `payload.ids` counts each row once
+ * (a table view's row events, a bulk write), a batch announcing
+ * `payload.count` counts that many (a module publishing its requests every
+ * second or so), anything else counts one. The same event object reaching
+ * the tally twice (one event, several blocks) counts once.
+ *
+ * @internal
+ */
+export class MissedTally {
+  private readonly count = ref(0);
+  private events = new WeakSet<object>();
+  private rows = new Set<string>();
+  /** The rows and events counted since the last reset. */
+  readonly total: Readonly<Ref<number>> = readonly(this.count);
+
+  add(event: object | undefined): void {
+    if (event) {
+      if (this.events.has(event)) return;
+      this.events.add(event);
+    }
+    this.count.value += this.weightOf(event as PublishedEvent | undefined);
+  }
+
+  reset(): void {
+    this.count.value = 0;
+    this.events = new WeakSet();
+    this.rows = new Set();
+  }
+
+  private weightOf(event: PublishedEvent | undefined): number {
+    if (!event) return 1;
+    const rowKeys = rowKeysOf(event);
+    if (rowKeys.length > 0) {
+      const fresh = rowKeys.filter((key) => !this.rows.has(key));
+      fresh.forEach((key) => this.rows.add(key));
+      return fresh.length;
+    }
+    return batchCountOf(event) ?? 1;
+  }
+}