nexus-shared 3.1.0 → 3.2.0

package/dist/Helpers/MessageBuilder.js

@@ -17,6 +17,8 @@ const DEFAULT_WORDS = {
     unflag: { verb: "unflag", done: "unflagged", doing: "Unflagging", object: "the record" },
     pin: { verb: "pin", done: "pinned", doing: "Pinning", object: "the record" },
     unpin: { verb: "unpin", done: "unpinned", doing: "Unpinning", object: "the record" },
+    favorite: { verb: "add {object} to the favourites", done: "added to the favourites", doing: "Adding {object} to the favourites", object: "the record" },
+    unfavorite: { verb: "remove {object} from the favourites", done: "removed from the favourites", doing: "Removing {object} from the favourites", object: "the record" },
     send: { verb: "send", done: "sent", doing: "Sending", object: "the message", sendsValues: true },
     submit: { verb: "submit", done: "submitted", doing: "Submitting", object: "the form", sendsValues: true },
     upload: { verb: "upload", done: "uploaded", doing: "Uploading", object: "the file", sendsValues: true },

package/dist/Helpers/NexusHelpers.js

@@ -0,0 +1 @@
+"use strict";

package/dist/Helpers/RequestCache.d.ts

@@ -0,0 +1,35 @@
+/** How long an answer is kept by default: 5 minutes, the CRUD's and the joins' lifetime too. */
+export declare const REQUEST_CACHE_LIFETIME: number;
+/** Whether a value is a promise, or any object with a `then` (what `await` treats as one). */
+export declare function isPromiseLike<T>(value: unknown): value is PromiseLike<T>;
+export declare class RequestCache<T> {
+    private kept;
+    readonly lifetime: number;
+    private now;
+    constructor(lifetime?: number, now?: () => number);
+    /** The answer kept under `key` while it is fresh; `undefined` when there is none, it has aged, or it is still on its way. */
+    peek(key: string, lifetime?: number): T | undefined;
+    /** Whether a request for `key` is on its way. */
+    isLoading(key: string): boolean;
+    /**
+     * The answer under `key`: a fresh kept one at once, the request already on its way, or a new request from `load`.
+     * An answer `load` gives at once (not a promise) is kept and given back at once too, so a caller can draw it in the
+     * same frame. A failure is not kept. `lifetime` 0 or less shares a request on its way but keeps no answer.
+     *
+     * @example
+     * const page = cache.get(`regions|${parentId}|0`, signal => api.post(children, { parentId, skipCount: 0, maxCount: 50 }, { signal }));
+     */
+    get(key: string, load: (signal: AbortSignal) => T | PromiseLike<T>, lifetime?: number): T | Promise<T>;
+    /** Keeps an answer under `key`, as if it had just been loaded. */
+    set(key: string, value: T): void;
+    private keep;
+    /**
+     * Drops the answers - kept or on their way - under every key that starts with `prefix`, or that `test` passes, or
+     * every one when nothing is given. A request dropped on its way still answers whoever waits for it; its answer is
+     * just not kept. Returns how many were dropped.
+     */
+    drop(match?: string | ((key: string) => boolean)): number;
+    clear(): void;
+    /** Answers kept and requests on their way. */
+    get size(): number;
+}

package/dist/Helpers/RequestCache.js

@@ -0,0 +1,113 @@
+/*
+ * Answers kept by name for a lifetime, shared by every caller on the page: the tree view's pages of children, and any
+ * other request whose answer a page asks for more than once. These are the owner's caching rules
+ * (Project-Skills/README.RULES.md), the same as `tableJoins` keeps for looked-up records:
+ *
+ *   - an answer is kept for a lifetime (5 minutes by default, like JOIN_LIFETIME and CRUD_CACHE_LIFETIME), so leaving a
+ *     page and coming back, or a second component asking the same thing, makes no call;
+ *   - a request already on its way is waited for, never made twice;
+ *   - a failure is not kept, so the next ask (a Retry) tries again;
+ *   - a refresh drops what it names and nothing else, so only what is needed now is loaded again.
+ *
+ * Nothing here knows about React or the API: a caller names the answer and says how to load it. Kept in memory, for the
+ * life of the page; the browser database the rules ask for is still to come (Agent-Memory/project-address-joins.md).
+ */
+/** How long an answer is kept by default: 5 minutes, the CRUD's and the joins' lifetime too. */
+export const REQUEST_CACHE_LIFETIME = 5 * 60 * 1000;
+/** Whether a value is a promise, or any object with a `then` (what `await` treats as one). */
+export function isPromiseLike(value) {
+    return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+export class RequestCache {
+    kept = new Map();
+    lifetime;
+    now;
+    constructor(lifetime = REQUEST_CACHE_LIFETIME, now = Date.now) {
+        this.lifetime = lifetime;
+        this.now = now;
+    }
+    /** The answer kept under `key` while it is fresh; `undefined` when there is none, it has aged, or it is still on its way. */
+    peek(key, lifetime = this.lifetime) {
+        const entry = this.kept.get(key);
+        if (entry?.state !== "ready")
+            return undefined;
+        if (this.now() - entry.at >= lifetime) {
+            this.kept.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    /** Whether a request for `key` is on its way. */
+    isLoading(key) {
+        return this.kept.get(key)?.state === "loading";
+    }
+    /**
+     * The answer under `key`: a fresh kept one at once, the request already on its way, or a new request from `load`.
+     * An answer `load` gives at once (not a promise) is kept and given back at once too, so a caller can draw it in the
+     * same frame. A failure is not kept. `lifetime` 0 or less shares a request on its way but keeps no answer.
+     *
+     * @example
+     * const page = cache.get(`regions|${parentId}|0`, signal => api.post(children, { parentId, skipCount: 0, maxCount: 50 }, { signal }));
+     */
+    get(key, load, lifetime = this.lifetime) {
+        const entry = this.kept.get(key);
+        if (entry?.state === "loading")
+            return entry.promise;
+        if (entry?.state === "ready" && this.now() - entry.at < lifetime)
+            return entry.value;
+        // Nothing aborts a kept request: whoever else waits for it, or comes back for it, still wants the answer.
+        const answer = load(new AbortController().signal);
+        if (!isPromiseLike(answer)) {
+            this.keep(key, answer, lifetime);
+            return answer;
+        }
+        const loading = {
+            state: "loading",
+            promise: Promise.resolve(answer).then(value => {
+                // A drop while it was on its way: the answer goes to whoever waits, and is not kept.
+                if (this.kept.get(key) === loading)
+                    this.keep(key, value, lifetime);
+                return value;
+            }, (error) => {
+                if (this.kept.get(key) === loading)
+                    this.kept.delete(key);
+                throw error;
+            }),
+        };
+        this.kept.set(key, loading);
+        return loading.promise;
+    }
+    /** Keeps an answer under `key`, as if it had just been loaded. */
+    set(key, value) {
+        this.keep(key, value, this.lifetime);
+    }
+    keep(key, value, lifetime) {
+        if (lifetime > 0)
+            this.kept.set(key, { state: "ready", value, at: this.now() });
+        else
+            this.kept.delete(key);
+    }
+    /**
+     * Drops the answers - kept or on their way - under every key that starts with `prefix`, or that `test` passes, or
+     * every one when nothing is given. A request dropped on its way still answers whoever waits for it; its answer is
+     * just not kept. Returns how many were dropped.
+     */
+    drop(match) {
+        let dropped = 0;
+        for (const key of [...this.kept.keys()]) {
+            const hit = match === undefined || (typeof match === "string" ? key.startsWith(match) : match(key));
+            if (!hit)
+                continue;
+            this.kept.delete(key);
+            dropped++;
+        }
+        return dropped;
+    }
+    clear() {
+        this.kept.clear();
+    }
+    /** Answers kept and requests on their way. */
+    get size() {
+        return this.kept.size;
+    }
+}

package/dist/Helpers/TableExport.js

@@ -38,18 +38,18 @@ export function exportTableCsv(output) {
 }
 const escapeHtml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 /* Plain black on white, since the paper has no theme, and a header row that repeats on every page. */
-const PRINT_STYLE = `
-  * { box-sizing: border-box; }
-  body { margin: 16mm 12mm; color: #111; font: 11pt/1.45 system-ui, "Segoe UI", sans-serif; }
-  h1 { margin: 0 0 2mm; font-size: 15pt; }
-  p.nx-note { margin: 0 0 5mm; color: #555; font-size: 9pt; }
-  table { width: 100%; border-collapse: collapse; font-size: 9.5pt; }
-  thead { display: table-header-group; }
-  th, td { padding: 4px 6px; border-bottom: 1px solid #bbb; text-align: left; vertical-align: top; }
-  th { border-bottom: 1.5px solid #555; font-weight: 600; white-space: nowrap; }
-  td.nx-end, th.nx-end { text-align: right; }
-  td.nx-center, th.nx-center { text-align: center; }
-  tr { page-break-inside: avoid; }
+const PRINT_STYLE = `
+  * { box-sizing: border-box; }
+  body { margin: 16mm 12mm; color: #111; font: 11pt/1.45 system-ui, "Segoe UI", sans-serif; }
+  h1 { margin: 0 0 2mm; font-size: 15pt; }
+  p.nx-note { margin: 0 0 5mm; color: #555; font-size: 9pt; }
+  table { width: 100%; border-collapse: collapse; font-size: 9.5pt; }
+  thead { display: table-header-group; }
+  th, td { padding: 4px 6px; border-bottom: 1px solid #bbb; text-align: left; vertical-align: top; }
+  th { border-bottom: 1.5px solid #555; font-weight: 600; white-space: nowrap; }
+  td.nx-end, th.nx-end { text-align: right; }
+  td.nx-center, th.nx-center { text-align: center; }
+  tr { page-break-inside: avoid; }
 `;
 /** The print view's HTML: a heading, a note, and the table. */
 export function tableToPrintHtml({ columns, rows, cellOptions = {}, name = "Table", note }) {

package/dist/Helpers/TableHelpers.d.ts

@@ -11,7 +11,7 @@ export declare const DEFAULT_MAX_SELECTION = 500;
 export declare function readPath(row: unknown, path: string): unknown;
 /** A row's key as text, so 5 and "5" are the same row. */
 export declare function rowKeyText<TRow extends TableRow>(row: TRow, rowKey: string | ((row: TRow) => TableKey)): string;
-/** A column's value in a row. */
+/** A column's value in a row: its own `value`, the record a `join` looked up, or the field. */
 export declare function columnValue<TRow extends TableRow>(column: TableColumn<TRow>, row: TRow): unknown;
 /** The option a value stands for, if the column has options. Values compare as text, so 2 matches "2". */
 export declare function columnOption(column: TableColumn<never> | TableColumn, value: unknown): TableColumnOption | undefined;

package/dist/Helpers/TableHelpers.js

@@ -3,6 +3,7 @@ import { formatDateTime } from "./DateTimeHelpers.js";
 import { foldSearchText, searchWords } from "./DropdownHelpers.js";
 import { formatNumber } from "./NumberHelpers.js";
 import { filterMatcher } from "./TableFilters.js";
+import { joinedValue } from "./TableJoins.js";
 import { formatTime } from "./TimeHelpers.js";
 /*
  * Data table helpers, with no React: reading a column's value, its text, searching, sorting, and paging rows, and the
@@ -33,9 +34,13 @@ export function rowKeyText(row, rowKey) {
     const key = typeof rowKey === "function" ? rowKey(row) : readPath(row, rowKey);
     return key === undefined || key === null ? "" : String(key);
 }
-/** A column's value in a row. */
+/** A column's value in a row: its own `value`, the record a `join` looked up, or the field. */
 export function columnValue(column, row) {
-    return column.value ? column.value(row) : readPath(row, column.key);
+    if (column.value)
+        return column.value(row);
+    if (column.join)
+        return joinedValue(column.join, column.key, row);
+    return readPath(row, column.key);
 }
 /** The option a value stands for, if the column has options. Values compare as text, so 2 matches "2". */
 export function columnOption(column, value) {

package/dist/Helpers/TableJoins.d.ts

@@ -0,0 +1,70 @@
+import type { ApiEndpoint } from "../Interfaces/ApiInterfaces.ts";
+import type { TableJoin, TableJoinSource, TableJoinedRecord, TableRow } from "../Interfaces/TableInterfaces.ts";
+/** How long an answer is kept before the next request asks again: the CRUD's own cache lifetime. */
+export declare const JOIN_LIFETIME: number;
+/** What is known of one key: its record, that its source has none, that it is on its way, or that the call failed. */
+export type JoinedState = {
+    status: "ready";
+    record: TableJoinedRecord;
+} | {
+    status: "missing";
+} | {
+    status: "loading";
+} | {
+    status: "failed";
+};
+export declare class TableJoins {
+    private sources;
+    private lists;
+    private listeners;
+    private version;
+    /** Called after every answer, and after answers are marked old. For `useSyncExternalStore`. */
+    subscribe: (listener: () => void) => (() => void);
+    /** A number that changes with every answer, so a table knows to draw again. */
+    getVersion: () => number;
+    private notify;
+    private cacheOf;
+    /**
+     * What is known of `key` in the source called `name`, for drawing: its record - an aged one too, until the new one is
+     * in - or that it is missing, on its way, or could not be read. A key nobody has asked for yet reads as on its way.
+     */
+    peek(name: string, key: string): JoinedState;
+    /**
+     * Asks for every key the cache cannot answer fresh. The keys asked for in one moment - by every table and input on
+     * the page - go in one call per source, after the moment is over; a key already on its way is not asked again.
+     */
+    request(source: TableJoinSource, keys: Iterable<string>): void;
+    private queue;
+    private send;
+    /**
+     * The records behind these keys, once they are in: what a picker shows for the values a form already holds. The
+     * calls and the answers are the ones the tables share, so a form opened from a table costs nothing more.
+     */
+    records(source: TableJoinSource, keys: Iterable<string>): Promise<TableJoinedRecord[]>;
+    /**
+     * A whole list kept under `name` - a picker's options - loaded once per lifetime; a second ask while it loads waits for
+     * the same call. A list that failed is not kept, so the next ask tries again.
+     */
+    list(name: string, load: (signal: AbortSignal) => Promise<readonly TableJoinedRecord[]>, lifetime?: number): Promise<readonly TableJoinedRecord[]>;
+    /**
+     * Marks answers as old - a source's, some of its keys, or every one - after the records behind them may have changed:
+     * a save, a move to the trash, a Reload. They are still drawn, and asked for again at the next request.
+     */
+    expire(name?: string, keys?: Iterable<string>): void;
+    /** Drops a kept list (or every one), so the next ask loads it again. */
+    expireList(name?: string): void;
+    /** Forgets everything. For tests. */
+    clear(): void;
+}
+/** The page's one cache of looked-up records: every table and form shares it. */
+export declare const tableJoins: TableJoins;
+/** The name a source is kept under: its own, or an endpoint's module, method and path. */
+export declare function joinSourceName(source: ApiEndpoint | TableJoinSource): string;
+/** The key a row holds for a join, as text; null when it holds none. */
+export declare function joinKey(join: TableJoin, row: TableRow): string | null;
+/** What is known of the record a row's join names; null when the row names none. */
+export declare function joinedState(join: TableJoin, row: TableRow): JoinedState | null;
+/** A join column's value: the looked-up record's field, or undefined until it is in. */
+export declare function joinedValue(join: TableJoin, columnKey: string, row: TableRow): unknown;
+/** The keys rows hold for every join among these columns, by source: what one request per source asks for. */
+export declare function joinKeys(joins: readonly TableJoin[], rows: readonly TableRow[]): Map<ApiEndpoint | TableJoinSource, Set<string>>;

package/dist/Helpers/TableJoins.js

@@ -0,0 +1,250 @@
+import { isApiEndpoint } from "./ApiRoutes.js";
+// A cycle, and a harmless one: TableHelpers reads a join column through this module, and only calls are made across it.
+import { readPath } from "./TableHelpers.js";
+/*
+ * The records a page looks up by key, kept once for every table and form on it: a country's sub-region, named from the
+ * sub-regions' FindListing. It is the client side of a join - the database answers the row with the key alone, and the
+ * page names it - and these are its rules (the owner's caching rules, Project-Skills/README.RULES.md):
+ *
+ *   - one call per source for every key wanted in the same moment, however many tables and inputs ask;
+ *   - a call already out is waited for, never made twice;
+ *   - an answer is kept for a lifetime, and one that has aged is still drawn while the new one is asked for, so a
+ *     refresh never blanks a cell;
+ *   - a key the source does not answer is remembered as missing ("Not found"), and a call that failed is not made
+ *     again for a short while, so a backend that is down is not asked once per render.
+ *
+ * Nothing here knows about React or the API: a source loads, and whoever draws subscribes. Kept in memory, for the life
+ * of the page.
+ */
+/** How long an answer is kept before the next request asks again: the CRUD's own cache lifetime. */
+export const JOIN_LIFETIME = 5 * 60 * 1000;
+/** How long a key whose call failed waits before it is asked again. */
+const RETRY_AFTER = 30 * 1000;
+/** The most keys one call carries; more are sent in turn. A Nexus mass action takes 500, and so does a FindListing. */
+const KEYS_PER_CALL = 500;
+const LOADING = { status: "loading" };
+const MISSING = { status: "missing" };
+const FAILED = { status: "failed" };
+export class TableJoins {
+    sources = new Map();
+    lists = new Map();
+    listeners = new Set();
+    version = 0;
+    /** Called after every answer, and after answers are marked old. For `useSyncExternalStore`. */
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    /** A number that changes with every answer, so a table knows to draw again. */
+    getVersion = () => this.version;
+    notify() {
+        this.version++;
+        for (const listener of this.listeners)
+            listener();
+    }
+    cacheOf(name) {
+        let cache = this.sources.get(name);
+        if (!cache) {
+            cache = { entries: new Map(), pending: new Map(), failedAt: new Map(), queued: null };
+            this.sources.set(name, cache);
+        }
+        return cache;
+    }
+    /**
+     * What is known of `key` in the source called `name`, for drawing: its record - an aged one too, until the new one is
+     * in - or that it is missing, on its way, or could not be read. A key nobody has asked for yet reads as on its way.
+     */
+    peek(name, key) {
+        const cache = this.sources.get(name);
+        const entry = cache?.entries.get(key);
+        if (entry)
+            return entry.record ? { status: "ready", record: entry.record } : MISSING;
+        if (cache?.failedAt.has(key) && !cache.pending.has(key))
+            return FAILED;
+        return LOADING;
+    }
+    /**
+     * Asks for every key the cache cannot answer fresh. The keys asked for in one moment - by every table and input on
+     * the page - go in one call per source, after the moment is over; a key already on its way is not asked again.
+     */
+    request(source, keys) {
+        const cache = this.cacheOf(source.name);
+        const lifetime = source.lifetime ?? JOIN_LIFETIME;
+        const now = Date.now();
+        for (const key of keys) {
+            if (!key || cache.pending.has(key))
+                continue;
+            const entry = cache.entries.get(key);
+            if (entry && now - entry.at < lifetime)
+                continue;
+            const failed = cache.failedAt.get(key);
+            if (!entry && failed !== undefined && now - failed < RETRY_AFTER)
+                continue;
+            this.queue(source, cache, key);
+        }
+    }
+    queue(source, cache, key) {
+        let batch = cache.queued;
+        if (!batch) {
+            let finish = () => { };
+            const done = new Promise(resolve => (finish = resolve));
+            const queued = { keys: new Set(), done, finish };
+            cache.queued = batch = queued;
+            queueMicrotask(() => void this.send(source, cache, queued));
+        }
+        batch.keys.add(key);
+        cache.pending.set(key, batch.done);
+    }
+    async send(source, cache, batch) {
+        if (cache.queued === batch)
+            cache.queued = null;
+        const keys = [...batch.keys];
+        const keyField = source.key ?? "id";
+        let answered = 0;
+        try {
+            for (let start = 0; start < keys.length; start += KEYS_PER_CALL) {
+                const part = keys.slice(start, start + KEYS_PER_CALL);
+                const records = await source.load(part, new AbortController().signal);
+                const found = new Map();
+                for (const record of records) {
+                    const key = record[keyField];
+                    if (key !== undefined && key !== null)
+                        found.set(String(key), record);
+                }
+                const at = Date.now();
+                for (const key of part) {
+                    cache.entries.set(key, { record: found.get(key) ?? null, at });
+                    cache.failedAt.delete(key);
+                }
+                answered += part.length;
+            }
+        }
+        catch {
+            // A key with an older answer keeps it; one with none is "could not be read", and waits before it is asked again.
+            const at = Date.now();
+            for (const key of keys.slice(answered))
+                if (!cache.entries.has(key))
+                    cache.failedAt.set(key, at);
+        }
+        finally {
+            for (const key of keys)
+                if (cache.pending.get(key) === batch.done)
+                    cache.pending.delete(key);
+            batch.finish();
+            this.notify();
+        }
+    }
+    /**
+     * The records behind these keys, once they are in: what a picker shows for the values a form already holds. The
+     * calls and the answers are the ones the tables share, so a form opened from a table costs nothing more.
+     */
+    async records(source, keys) {
+        const wanted = [...new Set([...keys].filter(Boolean))];
+        this.request(source, wanted);
+        const cache = this.cacheOf(source.name);
+        await Promise.all(wanted.map(key => cache.pending.get(key)).filter(Boolean));
+        const found = [];
+        for (const key of wanted) {
+            const record = cache.entries.get(key)?.record;
+            if (record)
+                found.push(record);
+        }
+        return found;
+    }
+    /**
+     * A whole list kept under `name` - a picker's options - loaded once per lifetime; a second ask while it loads waits for
+     * the same call. A list that failed is not kept, so the next ask tries again.
+     */
+    list(name, load, lifetime = JOIN_LIFETIME) {
+        const kept = this.lists.get(name);
+        if (kept?.pending)
+            return kept.pending;
+        if (kept?.rows && Date.now() - kept.at < lifetime)
+            return Promise.resolve(kept.rows);
+        const pending = load(new AbortController().signal).then(rows => {
+            this.lists.set(name, { at: Date.now(), rows });
+            return rows;
+        }, (error) => {
+            this.lists.delete(name);
+            throw error;
+        });
+        this.lists.set(name, { ...kept, at: kept?.at ?? 0, pending });
+        return pending;
+    }
+    /**
+     * Marks answers as old - a source's, some of its keys, or every one - after the records behind them may have changed:
+     * a save, a move to the trash, a Reload. They are still drawn, and asked for again at the next request.
+     */
+    expire(name, keys) {
+        const caches = name === undefined ? [...this.sources.values()] : [this.sources.get(name)].filter((cache) => Boolean(cache));
+        for (const cache of caches) {
+            if (keys) {
+                for (const key of keys) {
+                    const entry = cache.entries.get(key);
+                    if (entry)
+                        entry.at = 0;
+                    cache.failedAt.delete(key);
+                }
+            }
+            else {
+                for (const entry of cache.entries.values())
+                    entry.at = 0;
+                cache.failedAt.clear();
+            }
+        }
+        if (caches.length)
+            this.notify();
+    }
+    /** Drops a kept list (or every one), so the next ask loads it again. */
+    expireList(name) {
+        if (name === undefined)
+            this.lists.clear();
+        else
+            this.lists.delete(name);
+    }
+    /** Forgets everything. For tests. */
+    clear() {
+        this.sources.clear();
+        this.lists.clear();
+        this.notify();
+    }
+}
+/** The page's one cache of looked-up records: every table and form shares it. */
+export const tableJoins = new TableJoins();
+/** The name a source is kept under: its own, or an endpoint's module, method and path. */
+export function joinSourceName(source) {
+    return isApiEndpoint(source) ? `${String(source.module)} ${source.method} ${source.path}` : source.name;
+}
+/** The key a row holds for a join, as text; null when it holds none. */
+export function joinKey(join, row) {
+    const key = readPath(row, join.from);
+    return key === undefined || key === null || key === "" ? null : String(key);
+}
+/** What is known of the record a row's join names; null when the row names none. */
+export function joinedState(join, row) {
+    const key = joinKey(join, row);
+    return key === null ? null : tableJoins.peek(joinSourceName(join.source), key);
+}
+/** A join column's value: the looked-up record's field, or undefined until it is in. */
+export function joinedValue(join, columnKey, row) {
+    const state = joinedState(join, row);
+    return state?.status === "ready" ? readPath(state.record, join.field ?? columnKey) : undefined;
+}
+/** The keys rows hold for every join among these columns, by source: what one request per source asks for. */
+export function joinKeys(joins, rows) {
+    const bySource = new Map();
+    for (const join of joins) {
+        const name = joinSourceName(join.source);
+        let entry = bySource.get(name);
+        if (!entry)
+            bySource.set(name, (entry = { source: join.source, keys: new Set() }));
+        for (const row of rows) {
+            const key = joinKey(join, row);
+            if (key !== null)
+                entry.keys.add(key);
+        }
+    }
+    return new Map([...bySource.values()].map(entry => [entry.source, entry.keys]));
+}

package/dist/Helpers/TableStore.d.ts

@@ -83,6 +83,11 @@ export declare class TableStore<TRow extends TableRow = TableRow> {
     private fail;
     /** Searches, filters, sorts, and pages every row (client tables), then tells the table. */
     private view;
+    /**
+     * Some columns' values changed while the rows did not: the names a `join` column reads came in. A client table reads
+     * its search text again and searches, filters, sorts and pages anew; a server table draws again. Nothing loads.
+     */
+    refreshValues(): void;
     /** Changes the query: a client table shows it at once, a server table loads it. */
     private query;
     setSearch(search: string): void;

package/dist/Helpers/TableStore.js

@@ -239,6 +239,15 @@ export class TableStore {
             query: page === query.page ? query : { ...query, page },
         });
     }
+    /**
+     * Some columns' values changed while the rows did not: the names a `join` column reads came in. A client table reads
+     * its search text again and searches, filters, sorts and pages anew; a server table draws again. Nothing loads.
+     */
+    refreshValues() {
+        this.texts = new WeakMap();
+        if (this.state.status === "ready")
+            this.view();
+    }
     /** Changes the query: a client table shows it at once, a server table loads it. */
     query(changes) {
         const query = { ...this.state.query, ...changes };