nexus-shared 1.1.21 → 3.0.0

package/dist/Helpers/ChatStore.js

@@ -0,0 +1,394 @@
+import { isAbortError } from "./ApiResponses.js";
+import { EMPTY_CHAT_SUMMARY, firstUnreadChatId, mergeChatMessages, sameChatId, summarizeChatMessages } from "./ChatHelpers.js";
+import { nowUtcDateTime } from "./DateTimeHelpers.js";
+/** What a source can do, read from the source itself. */
+export function chatFeaturesOf(source) {
+    return {
+        participants: typeof source.participants === "function",
+        addParticipants: typeof source.addParticipants === "function",
+        markRead: typeof source.markRead === "function",
+        remove: typeof source.remove === "function",
+        watch: typeof source.watch === "function",
+    };
+}
+const DEFAULT_PAGE_SIZE = 30;
+const DEFAULT_POLL = 15_000;
+const failureText = (error, fallback) => {
+    const message = error instanceof Error ? error.message.trim() : typeof error === "string" ? error.trim() : "";
+    return message || fallback;
+};
+/** A call the store itself dropped — the panel closed, the conversation changed — says nothing. */
+const shown = (error, fallback) => (isAbortError(error) ? null : failureText(error, fallback));
+export class ChatStore {
+    options;
+    listeners = new Set();
+    snapshot;
+    messages = [];
+    pending = new Map();
+    revision = 0;
+    loaded = false;
+    poll = 0;
+    unwatch = null;
+    running = false;
+    // Reading caught up with the conversation: the line already drawn has done its job, and the next message to arrive
+    // gets a line of its own rather than leaving the old one stranded above messages that have been read.
+    readPast = false;
+    aborts = new Set();
+    clientSequence = 0;
+    constructor(options) {
+        this.options = options;
+        this.snapshot = {
+            messages: [],
+            participants: [],
+            summary: options.summary ?? EMPTY_CHAT_SUMMARY,
+            canSend: true,
+            features: chatFeaturesOf(options.source),
+            loading: false,
+            loaded: false,
+            loadingOlder: false,
+            hasMore: false,
+            error: null,
+            sending: 0,
+            failed: 0,
+            unreadFrom: null,
+            revision: 0,
+        };
+    }
+    // Reading
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getSnapshot = () => this.snapshot;
+    /** The newest message the server knows about: what the read mark and a refresh count from. */
+    newestSaved() {
+        for (let index = this.messages.length - 1; index >= 0; index--) {
+            const message = this.messages[index];
+            if (message.status !== "sending" && message.status !== "failed")
+                return message;
+        }
+        return undefined;
+    }
+    oldest() {
+        return this.messages.find(message => message.status !== "sending" && message.status !== "failed");
+    }
+    // Writing
+    set(changes) {
+        this.snapshot = { ...this.snapshot, ...changes, revision: ++this.revision };
+        for (const listener of this.listeners)
+            listener();
+    }
+    /** Puts the messages and the ones still on their way together, newest last, and tells the snapshot. */
+    commit(changes = {}) {
+        const waiting = [...this.pending.values()].map(entry => entry.message);
+        const sending = waiting.filter(message => message.status === "sending").length;
+        this.set({
+            ...changes,
+            messages: mergeChatMessages(this.messages, waiting),
+            sending,
+            failed: waiting.length - sending,
+        });
+    }
+    announce(summary) {
+        this.set({ summary });
+        this.options.onSummary?.(summary);
+    }
+    /** The counts after the messages changed: the server's, with what this browser knows added. */
+    recount(given) {
+        const held = summarizeChatMessages(this.messages, this.options.userId, null);
+        const summary = {
+            ...this.snapshot.summary,
+            ...given,
+            // The server counts the whole conversation; the browser only the part it holds, so the larger count is the true one.
+            messageCount: Math.max(given?.messageCount ?? 0, this.snapshot.summary.messageCount, held.messageCount),
+            unreadCount: given?.unreadCount ?? this.snapshot.summary.unreadCount,
+            lastMessageAt: held.lastMessageAt ?? given?.lastMessageAt ?? this.snapshot.summary.lastMessageAt ?? null,
+            lastMessageText: held.lastMessageText ?? given?.lastMessageText ?? null,
+            lastMessageBy: held.lastMessageBy ?? given?.lastMessageBy ?? null,
+        };
+        this.announce(summary);
+    }
+    track(run) {
+        const controller = new AbortController();
+        this.aborts.add(controller);
+        return run(controller.signal).finally(() => this.aborts.delete(controller));
+    }
+    // Loading
+    /** The newest page. Call it when the conversation opens, and again to start over. */
+    async load() {
+        this.set({ loading: true, error: null });
+        try {
+            const page = await this.track(signal => this.options.source.history({ take: this.pageSize(), signal }));
+            this.messages = mergeChatMessages([], page.messages);
+            this.loaded = true;
+            this.readPast = false;
+            const unread = page.summary?.unreadCount ?? this.snapshot.summary.unreadCount;
+            this.commit({
+                loading: false,
+                loaded: true,
+                hasMore: page.hasMore ?? page.messages.length >= this.pageSize(),
+                participants: page.participants ?? this.snapshot.participants,
+                canSend: page.canSend ?? true,
+                // Fixed here, so the line stays put while the conversation is read.
+                unreadFrom: firstUnreadChatId(this.messages, this.options.userId, unread),
+            });
+            this.recount(page.summary);
+        }
+        catch (error) {
+            this.set({ loading: false, error: shown(error, "The conversation could not be loaded.") });
+        }
+    }
+    /** One page of older messages, above the ones held. */
+    async loadOlder() {
+        if (this.snapshot.loadingOlder || !this.snapshot.hasMore)
+            return;
+        const before = this.oldest()?.id;
+        if (before === undefined)
+            return;
+        this.set({ loadingOlder: true, error: null });
+        try {
+            const page = await this.track(signal => this.options.source.history({ before, take: this.pageSize(), signal }));
+            this.messages = mergeChatMessages(this.messages, page.messages);
+            this.commit({ loadingOlder: false, hasMore: page.hasMore ?? page.messages.length >= this.pageSize() });
+            this.recount(page.summary);
+        }
+        catch (error) {
+            this.set({ loadingOlder: false, error: shown(error, "The older messages could not be loaded.") });
+        }
+    }
+    /** Whatever was written since the newest message held. Polling and the Retry button both call it. */
+    async refresh() {
+        if (!this.loaded)
+            return this.load();
+        const after = this.newestSaved()?.id;
+        try {
+            const page = await this.track(signal => this.options.source.history({ after: after ?? null, take: this.pageSize(), signal }));
+            if (page.messages.length === 0) {
+                if (this.snapshot.error)
+                    this.set({ error: null });
+                if (page.summary)
+                    this.recount(page.summary);
+                return;
+            }
+            this.take(page.messages, page);
+        }
+        catch (error) {
+            this.set({ error: shown(error, "New messages could not be loaded.") });
+        }
+    }
+    /** Messages that arrived on their own: a poll, or a source that watches. */
+    take = (incoming, page) => {
+        const fresh = incoming.filter(message => !sameChatId(message.authorId, this.options.userId) && !message.isSystem);
+        // Someone else wrote while the panel was open: the line goes before the first of them, unless a line is already
+        // standing in front of messages this reader has not caught up with yet.
+        const line = fresh.length > 0 && (this.snapshot.unreadFrom === null || this.readPast);
+        if (line)
+            this.readPast = false;
+        this.messages = mergeChatMessages(this.messages, incoming);
+        this.commit({
+            error: null,
+            ...(page?.participants && { participants: page.participants }),
+            ...(line && { unreadFrom: fresh[0].id }),
+        });
+        this.recount({
+            ...page?.summary,
+            unreadCount: page?.summary?.unreadCount ?? this.snapshot.summary.unreadCount + fresh.length,
+            messageCount: page?.summary?.messageCount ?? this.snapshot.summary.messageCount + incoming.length,
+        });
+    };
+    pageSize() {
+        return this.options.pageSize ?? DEFAULT_PAGE_SIZE;
+    }
+    // Sending
+    /** Sends a message. It is on screen before the call starts; if the call fails it stays, with Retry beside it. */
+    async send(body, extras = {}) {
+        const written = body.trim();
+        if (!written && !extras.files?.length)
+            return false;
+        const clientId = `nx-chat-${Date.now().toString(36)}-${++this.clientSequence}`;
+        const draft = { body: written, clientId, ...(extras.replyToId && { replyToId: extras.replyToId }), ...(extras.files?.length && { files: extras.files }) };
+        // The sender's own name and photo, from whoever knows them: the participants, else their last message here.
+        const me = this.snapshot.participants.find(person => sameChatId(person.id, this.options.userId));
+        const author = this.messages.find(message => sameChatId(message.authorId, this.options.userId));
+        this.pending.set(clientId, {
+            draft,
+            message: {
+                id: clientId,
+                clientId,
+                authorId: this.options.userId,
+                authorName: me?.name ?? author?.authorName ?? null,
+                authorAvatar: me?.avatar ?? author?.authorAvatar ?? null,
+                body: written,
+                createdAt: (this.options.now ?? nowUtcDateTime)(),
+                status: "sending",
+                replyToId: draft.replyToId ?? null,
+                ...(draft.files?.length && { attachments: draft.files.map(file => ({ name: file.name, size: file.size, contentType: file.type })) }),
+            },
+        });
+        this.commit();
+        return this.deliver(clientId);
+    }
+    /** Sends a failed message again, with the text it was written with. */
+    retry = (clientId) => {
+        const entry = this.pending.get(clientId);
+        if (!entry || entry.message.status === "sending")
+            return Promise.resolve(false);
+        this.pending.set(clientId, { ...entry, message: { ...entry.message, status: "sending", error: null } });
+        this.commit();
+        return this.deliver(clientId);
+    };
+    /** Drops a failed message. Nothing was saved, so nothing is deleted. */
+    discard = (clientId) => {
+        if (!this.pending.delete(clientId))
+            return;
+        this.messages = this.messages.filter(message => message.clientId !== clientId);
+        this.commit();
+    };
+    /** The text of a failed message, so the composer can put it back for editing. */
+    draftOf(clientId) {
+        return this.pending.get(clientId)?.draft;
+    }
+    async deliver(clientId) {
+        const entry = this.pending.get(clientId);
+        if (!entry)
+            return false;
+        try {
+            const saved = await this.track(signal => this.options.source.send(entry.draft, signal));
+            this.pending.delete(clientId);
+            this.messages = mergeChatMessages(this.messages, [{ ...saved, clientId, status: "sent" }]);
+            this.commit();
+            this.recount();
+            return true;
+        }
+        catch (error) {
+            const failed = this.pending.get(clientId);
+            // Dropped while it was on its way: nothing to mark.
+            if (failed) {
+                this.pending.set(clientId, { ...failed, message: { ...failed.message, status: "failed", error: shown(error, "Not sent.") ?? "Not sent." } });
+                this.commit();
+            }
+            return false;
+        }
+    }
+    /** Removes a message the user may remove. */
+    async remove(messageId) {
+        const source = this.options.source;
+        if (!source.remove)
+            return false;
+        const held = this.messages;
+        this.messages = this.messages.filter(message => !sameChatId(message.id, messageId));
+        this.commit();
+        try {
+            await this.track(signal => source.remove(messageId, signal));
+            this.recount({ ...this.snapshot.summary, messageCount: Math.max(0, this.snapshot.summary.messageCount - 1) });
+            return true;
+        }
+        catch (error) {
+            this.messages = held;
+            this.commit({ error: shown(error, "The message could not be removed.") });
+            return false;
+        }
+    }
+    // Reading marks
+    /** Says the user has read everything held. Clears the count; the line stays until the conversation is opened again. */
+    async markRead() {
+        const newest = this.newestSaved();
+        if (!newest || this.snapshot.summary.unreadCount === 0)
+            return;
+        this.announce({ ...this.snapshot.summary, unreadCount: 0 });
+        this.readPast = true;
+        const mark = this.options.source.markRead;
+        // A source without a read mark still clears the count here, so the icon in the list behind the panel stops shouting.
+        if (!mark)
+            return;
+        try {
+            await this.track(signal => mark(newest.id, signal));
+        }
+        catch {
+            // A read mark that did not reach the server is not worth a message: the next load counts again.
+        }
+    }
+    /** Takes the "New messages" line away, once it has been seen. */
+    clearUnreadLine = () => {
+        if (this.snapshot.unreadFrom !== null)
+            this.set({ unreadFrom: null });
+    };
+    // Participants
+    /** Searches the people in the conversation and the ones who could join. Empty when the source has no search. */
+    searchParticipants = async (query) => {
+        if (!this.options.source.participants)
+            return { items: [], hasMore: false, total: 0 };
+        return this.options.source.participants(query);
+    };
+    /** Adds people, and keeps the ones the source answers with. */
+    async addParticipants(ids) {
+        const source = this.options.source;
+        if (!source.addParticipants || ids.length === 0)
+            return false;
+        try {
+            const added = await this.track(signal => source.addParticipants(ids, signal));
+            const known = new Set(this.snapshot.participants.map(person => String(person.id)));
+            this.set({ participants: [...this.snapshot.participants, ...added.filter(person => !known.has(String(person.id)))] });
+            return true;
+        }
+        catch (error) {
+            this.set({ error: shown(error, "The people could not be added.") });
+            return false;
+        }
+    }
+    /** Participants the page already has, so the panel needs no call. */
+    setParticipants = (participants) => {
+        this.set({ participants });
+    };
+    /**
+     * Points the store at another source, keeping the messages it holds. A page that builds its source while it renders
+     * hands in a new object every time; this takes it without starting the conversation over, and keeps the store's own
+     * reading of what the source can do (a search, a read mark, Delete) true.
+     */
+    setSource = (source) => {
+        if (source === this.options.source)
+            return;
+        this.options = { ...this.options, source };
+        const features = chatFeaturesOf(source);
+        const held = this.snapshot.features;
+        const same = Object.keys(features).every(key => features[key] === held[key]);
+        if (!same)
+            this.set({ features });
+    };
+    // Watching
+    /** Starts watching for new messages: the source's own watch, else a poll. */
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        if (this.options.source.watch) {
+            this.unwatch = this.options.source.watch(messages => this.take(messages));
+            return;
+        }
+        const every = this.options.pollInterval ?? DEFAULT_POLL;
+        if (every <= 0)
+            return;
+        this.poll = setInterval(() => {
+            if (this.options.isActive?.() === false)
+                return;
+            void this.refresh();
+        }, every);
+    }
+    /** Stops watching. The messages stay. */
+    stop() {
+        this.running = false;
+        if (this.poll)
+            clearInterval(this.poll);
+        this.poll = 0;
+        this.unwatch?.();
+        this.unwatch = null;
+    }
+    /** Stops everything and drops the calls on their way. The messages and unsent drafts stay, for a panel that reopens. */
+    dispose() {
+        this.stop();
+        for (const controller of this.aborts)
+            controller.abort();
+        this.aborts.clear();
+        this.listeners.clear();
+    }
+}

package/dist/Helpers/ChatSummaries.d.ts

@@ -0,0 +1,39 @@
+import type { AnyChatScope, ChatDomainValue, ChatId, ChatSummary } from "../Interfaces/ChatInterfaces.ts";
+/** Asks a backend for the counts of many records of one domain. The answer is keyed by parent id as text. */
+export type ChatSummaryLoader = (domain: ChatDomainValue, parentIds: readonly ChatId[], userId: ChatId) => Promise<Map<string, ChatSummary>>;
+/** Whether a record's counts are known, on their way, or could not be read. */
+export type ChatSummaryState = "unknown" | "loading" | "ready" | "failed";
+export interface ChatSummaryCacheOptions {
+    load: ChatSummaryLoader;
+    /** Milliseconds to wait for more icons before asking, so a table's rows go in one call. Default 20. */
+    window?: number;
+    /** Most parent ids in one call. Default 200. */
+    batchSize?: number;
+}
+export declare class ChatSummaryCache {
+    private options;
+    private summaries;
+    private states;
+    private listeners;
+    private queued;
+    private timer;
+    constructor(options: ChatSummaryCacheOptions);
+    /** The key a record's counts are held under. The reader is part of it: unread is counted per person. */
+    private keyOf;
+    /** The counts, when they are known. */
+    get(scope: AnyChatScope): ChatSummary | undefined;
+    stateOf(scope: AnyChatScope): ChatSummaryState;
+    /** Asks for a record's counts, unless they are known or already on their way. Several calls collapse into one request. */
+    readonly want: (scope: AnyChatScope) => void;
+    /** Writes a record's counts, and tells its icon: after a panel read them, or from a list's own rows. */
+    readonly set: (scope: AnyChatScope, summary: ChatSummary) => void;
+    /** Forgets a record's counts, so the next icon that wants them asks again. */
+    readonly forget: (scope: AnyChatScope) => void;
+    /** Forgets everything: after signing in as somebody else, or reloading a list. */
+    readonly clear: () => void;
+    /** Called whenever a record's counts change. */
+    readonly subscribe: (scope: AnyChatScope, listener: () => void) => (() => void);
+    private tell;
+    private flush;
+    private ask;
+}

package/dist/Helpers/ChatSummaries.js

@@ -0,0 +1,118 @@
+import { chatScopeKey, EMPTY_CHAT_SUMMARY } from "./ChatHelpers.js";
+const DEFAULT_WINDOW = 20;
+const DEFAULT_BATCH = 200;
+export class ChatSummaryCache {
+    options;
+    summaries = new Map();
+    states = new Map();
+    listeners = new Map();
+    queued = new Map();
+    timer = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    /** The key a record's counts are held under. The reader is part of it: unread is counted per person. */
+    keyOf(scope) {
+        return `${chatScopeKey(scope)}:${String(scope.userId)}`;
+    }
+    /** The counts, when they are known. */
+    get(scope) {
+        return this.summaries.get(this.keyOf(scope));
+    }
+    stateOf(scope) {
+        return this.states.get(this.keyOf(scope)) ?? "unknown";
+    }
+    /** Asks for a record's counts, unless they are known or already on their way. Several calls collapse into one request. */
+    want = (scope) => {
+        const key = this.keyOf(scope);
+        const state = this.states.get(key);
+        if (state === "loading" || state === "ready")
+            return;
+        this.states.set(key, "loading");
+        const batch = `${String(scope.domain)}\u0000${String(scope.userId)}`;
+        const queued = this.queued.get(batch) ?? { domain: scope.domain, userId: scope.userId, ids: new Map() };
+        queued.ids.set(String(scope.parentId), scope.parentId);
+        this.queued.set(batch, queued);
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = 0;
+            void this.flush();
+        }, this.options.window ?? DEFAULT_WINDOW);
+    };
+    /** Writes a record's counts, and tells its icon: after a panel read them, or from a list's own rows. */
+    set = (scope, summary) => {
+        const key = this.keyOf(scope);
+        const held = this.summaries.get(key);
+        if (held && held.messageCount === summary.messageCount && held.unreadCount === summary.unreadCount && held.lastMessageAt === summary.lastMessageAt) {
+            this.states.set(key, "ready");
+            return;
+        }
+        this.summaries.set(key, summary);
+        this.states.set(key, "ready");
+        this.tell(key);
+    };
+    /** Forgets a record's counts, so the next icon that wants them asks again. */
+    forget = (scope) => {
+        const key = this.keyOf(scope);
+        this.summaries.delete(key);
+        this.states.delete(key);
+        this.tell(key);
+    };
+    /** Forgets everything: after signing in as somebody else, or reloading a list. */
+    clear = () => {
+        const keys = [...this.states.keys()];
+        this.summaries.clear();
+        this.states.clear();
+        this.queued.clear();
+        for (const key of keys)
+            this.tell(key);
+    };
+    /** Called whenever a record's counts change. */
+    subscribe = (scope, listener) => {
+        const key = this.keyOf(scope);
+        const set = this.listeners.get(key) ?? new Set();
+        set.add(listener);
+        this.listeners.set(key, set);
+        return () => {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(key);
+        };
+    };
+    tell(key) {
+        for (const listener of this.listeners.get(key) ?? [])
+            listener();
+    }
+    async flush() {
+        const batches = [...this.queued.values()];
+        this.queued.clear();
+        const size = this.options.batchSize ?? DEFAULT_BATCH;
+        await Promise.all(batches.flatMap(batch => {
+            const ids = [...batch.ids.values()];
+            const chunks = [];
+            for (let at = 0; at < ids.length; at += size)
+                chunks.push(ids.slice(at, at + size));
+            return chunks.map(chunk => this.ask(batch, chunk));
+        }));
+    }
+    async ask(batch, ids) {
+        const keyOf = (parentId) => this.keyOf({ domain: batch.domain, parentId, userId: batch.userId });
+        try {
+            const answer = await this.options.load(batch.domain, ids, batch.userId);
+            for (const parentId of ids) {
+                // A record the answer leaves out has no messages: that is the quiet icon, not a failure.
+                this.summaries.set(keyOf(parentId), answer.get(String(parentId)) ?? EMPTY_CHAT_SUMMARY);
+                this.states.set(keyOf(parentId), "ready");
+                this.tell(keyOf(parentId));
+            }
+        }
+        catch {
+            // The icon stays quiet and says nothing: counts are not worth a message of their own. The next want asks again.
+            for (const parentId of ids) {
+                this.states.set(keyOf(parentId), "failed");
+                this.tell(keyOf(parentId));
+            }
+        }
+    }
+}

package/dist/Helpers/ClassHelpers.d.ts

@@ -0,0 +1,3 @@
+export type ClassValue = string | false | null | undefined | 0;
+/** Joins class names, skipping empty and false values: `cx("nx-btn", active && "is-active")`. */
+export declare function cx(...classes: ClassValue[]): string;

package/dist/Helpers/ClassHelpers.js

@@ -0,0 +1,4 @@
+/** Joins class names, skipping empty and false values: `cx("nx-btn", active && "is-active")`. */
+export function cx(...classes) {
+    return classes.filter(Boolean).join(" ");
+}

package/dist/Helpers/CrudBackend.d.ts

@@ -0,0 +1,98 @@
+import type { CrudMassActionName, CrudMode } from "../Interfaces/CrudInterfaces.ts";
+import type { TableKey, TablePage, TableQuery, TableRow } from "../Interfaces/TableInterfaces.ts";
+type Row = Record<string, unknown>;
+export declare abstract class CrudBackend {
+    /** What a server table sends for one page, from the query. `sortKey` is the sorted column's server name. */
+    abstract pageRequest(query: TableQuery, sortKey: string | undefined): unknown;
+    /** Reads the page a pagination endpoint answered. */
+    abstract readPage<TRow extends TableRow>(result: unknown): TablePage<TRow>;
+    /** Reads a whole list: an array, or the rows of a page. */
+    readList<TRow extends TableRow>(result: unknown): TRow[];
+    /** What a mass action sends: the selected keys, and for `description` the new text. */
+    abstract massRequest(action: CrudMassActionName, keys: TableKey[], values?: Row): unknown;
+    abstract isFlagged(row: TableRow): boolean;
+    /** The row with its flag set or cleared. */
+    abstract withFlag<TRow extends TableRow>(row: TRow, on: boolean): TRow;
+    abstract isPinned(row: TableRow): boolean;
+    /** The row with its pin set or cleared. */
+    abstract withPin<TRow extends TableRow>(row: TRow, on: boolean): TRow;
+    /**
+     * Changes an action's answer makes to rows, by key: a mass flag that answers each record's new status. Rows without
+     * an entry take the change the action stands for (a toggled flag). Default: none.
+     */
+    answeredChanges(result: unknown, rowKey: string): Map<string, Row>;
+    /**
+     * The keys of the records an action changed, when its answer lists them: a mass trash where some records could not
+     * move. `null` when the answer does not say, and every record sent counts as changed. Default `null`.
+     */
+    answeredKeys(result: unknown, rowKey: string): Set<string> | null;
+    /**
+     * What an answer says about the one record an action wrote: the record itself, or only the fields that changed.
+     * `null` when it says nothing about it - a bare key, an empty body - and then the caller keeps what it has.
+     *
+     * **This is what spares a page its reload.** A save or a mark whose answer carries the record is written into the
+     * table, the pinned band and every list kept in the cache, and nothing is loaded again. Only answers of actions on
+     * **one** record are read here; a mass answer goes through `answeredChanges`, record by record.
+     */
+    answeredRow<TRow extends TableRow>(result: unknown): Partial<TRow> | null;
+    /**
+     * The key an answer gives in place of the record: `Create` answering the new record's id. `null` when the answer
+     * is the record itself, or says nothing. With a key the new record goes straight into the list, and where there is
+     * a `details` endpoint it is read back on its own - one small request, never the whole list again.
+     */
+    answeredKey(result: unknown): TableKey | null;
+    /**
+     * Whether a record belongs in a list, read from the record itself. It is what lets one answer be written into the
+     * lists that are **not** on screen: a flagged record joins the flagged list, a trashed one leaves the active list
+     * and joins the trash, in the cache as well as in the table.
+     *
+     * `undefined` when the record does not say, and a list it cannot answer for is dropped from the cache and loads
+     * again when it is shown. Default: nothing is known, which is how every list behaved before.
+     */
+    listMembership(row: TableRow, mode: CrudMode): boolean | undefined;
+}
+/** The Nexus record status of a flagged record (`ERecordStatus.Flagged`), the bottom of the 25–29 flag band. */
+export declare const NEXUS_FLAGGED_STATUS = 25;
+/** The Nexus record status of an active record (`ERecordStatus.Active`), the bottom of the 0–39 active band. */
+export declare const NEXUS_ACTIVE_STATUS = 0;
+/** The Nexus record status of a record in the trash (`ERecordStatus.Trash`), the bottom of the 40–59 trash band. */
+export declare const NEXUS_TRASH_STATUS = 40;
+/** The Nexus record status of a deleted record (`ERecordStatus.PermanentDeleted`), the bottom of the 60+ delete band. */
+export declare const NEXUS_DELETED_STATUS = 60;
+/**
+ * The Nexus backend: pages as `{ searchKeyword, skipCount, maxCount, sorting, sortType }` answered with
+ * `{ results, totalCount, filterCount }`, newest first unless a column is sorted; mass actions send the ids
+ * (`{ description, accountIds }` for descriptions); a flagged record has `recordStatus` 25, a pinned one `isPinned`.
+ */
+export declare class NexusCrudBackend extends CrudBackend {
+    pageRequest(query: TableQuery, sortKey: string | undefined): unknown;
+    readPage<TRow extends TableRow>(result: unknown): TablePage<TRow>;
+    massRequest(action: CrudMassActionName, keys: TableKey[], values?: Row): unknown;
+    isFlagged(row: TableRow): boolean;
+    withFlag<TRow extends TableRow>(row: TRow, on: boolean): TRow;
+    isPinned(row: TableRow): boolean;
+    withPin<TRow extends TableRow>(row: TRow, on: boolean): TRow;
+    /** Mass answers list the records they changed, with their new `recordStatus` and `isPinned`. */
+    answeredChanges(result: unknown, rowKey: string): Map<string, Row>;
+    /**
+     * A write answers the record it wrote, or a value that is not one. `Create` and `Update` answer the new record's
+     * **id token**, which says nothing the caller does not already hold, so it is read as nothing; a mark answers the
+     * record's new **`ERecordStatus`**, which is the one field that changed and is what puts the record in the right
+     * list without loading one. A backend that answers the whole record is read as that record.
+     */
+    answeredRow<TRow extends TableRow>(result: unknown): Partial<TRow> | null;
+    /** `Create` and `Update` answer the record's id: a token when ids are encrypted, the number as text when not. */
+    answeredKey(result: unknown): TableKey | null;
+    /**
+     * The bands the owner settled on: under 40 is live, 25–29 of that is flagged, 40–59 is the trash, and 60 and up is
+     * deleted. A row without a `recordStatus` says nothing, and the lists it cannot answer for load again.
+     */
+    listMembership(row: TableRow, mode: CrudMode): boolean | undefined;
+    /** Mass answers list the records they changed (as records, or as ids); other answers say nothing. */
+    answeredKeys(result: unknown, rowKey: string): Set<string> | null;
+}
+/** Registers the app's backend conventions, once, beside its API modules. */
+export declare function defineCrudBackend<T extends CrudBackend>(backend: T): T;
+/** The registered backend conventions, or the Nexus ones. */
+export declare function getCrudBackend(): CrudBackend;
+export {};