nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/CrudRowForms.js

@@ -0,0 +1,76 @@
+import { CRUD_ROW_ACTIONS } from "./CrudHelpers.js";
+import { isApiEndpoint } from "./ApiRoutes.js";
+import { formConfirmQuestion } from "./FormConfirm.js";
+/*
+ * The pure half of a row action that opens a form of its own for the record (`Crud` `rowForms`,
+ * Components/Forms/CrudRowForms.tsx): where it is offered, what it asks before saving, and what of a save's answer is
+ * written back into the record. Pure, so Node tests run it.
+ */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * Whether a row form is offered on a record: on its lists (default the lists that offer Edit), to a person who may call
+ * its `submit` and, when it is an endpoint, its `load`, and by the page's own `when`.
+ */
+export function crudRowFormOffered(form, row, mode, can) {
+    const modes = form.modes ?? Object.keys(CRUD_ROW_ACTIONS).filter(list => CRUD_ROW_ACTIONS[list].includes("edit"));
+    if (!modes.includes(mode))
+        return false;
+    if (!can(form.submit))
+        return false;
+    if (isApiEndpoint(form.load) && !can(form.load))
+        return false;
+    return form.when ? form.when(row, mode) : true;
+}
+/**
+ * What a save changes on the record, as `writes` says: the answer's fields it names (each one the answer carries; an
+ * answer that is not a record changes nothing), or what its function answers. Never the record as the form was opened
+ * on: the CRUD merges this over the record as it holds it when the answer lands, so a change made meanwhile (an Edit
+ * while the popup was minimized) stays.
+ */
+export function crudRowFormWrites(writes, result, row, values) {
+    if (!writes)
+        return null;
+    if (typeof writes === "function") {
+        const patch = writes(result, row, values);
+        return patch && Object.keys(patch).length ? patch : null;
+    }
+    if (!isRecord(result))
+        return null;
+    const patch = {};
+    for (const field of writes)
+        if (result[field] !== undefined)
+            patch[field] = result[field];
+    return Object.keys(patch).length ? patch : null;
+}
+/**
+ * Whether a row form is its question alone: it gives no inputs. Choosing it asks (its `confirm`, else "{label} {name}?")
+ * and sends on Confirm, with no popup form.
+ */
+export function crudRowFormAsksOnly(form) {
+    return form.inputs === undefined;
+}
+/**
+ * The question a row form asks for this record: its `confirm` as given, or made from the record and what `load` read;
+ * for a question alone that gives none, "{label} {name}?" (`name` is the record's, as its row is named). `null`: a form
+ * that saves without asking.
+ */
+export function crudRowFormConfirm(form, row, loaded, name) {
+    const given = typeof form.confirm === "function" ? form.confirm(row, loaded) : form.confirm;
+    if (given)
+        return given;
+    return crudRowFormAsksOnly(form) ? { title: `${form.label} ${name}?` } : null;
+}
+/**
+ * The question settled for these values and this body (`formConfirmQuestion`). A question alone has no form to go back
+ * to: its buttons are the action's own word (`submitLabel`, else `label`) and "Cancel", unless the page names them.
+ */
+export function crudRowFormQuestion(form, confirm, values, body) {
+    const question = formConfirmQuestion(confirm, values, body);
+    if (!crudRowFormAsksOnly(form))
+        return question;
+    return {
+        ...question,
+        confirmLabel: confirm.confirmLabel === undefined ? (form.submitLabel ?? form.label) : question.confirmLabel,
+        cancelLabel: confirm.cancelLabel ?? "Cancel",
+    };
+}

package/dist/Helpers/CrudScopes.d.ts

@@ -0,0 +1,32 @@
+import type { CrudProps, CrudScope, CrudScopes } from "../Interfaces/CrudInterfaces.ts";
+import type { FormValues } from "../Interfaces/FormInterfaces.ts";
+/**
+ * The scopes offered now: those whose `when` (the page's own rule) allows them and whose lists the person may call
+ * (`callable`, the CRUD's permission test on the scope's endpoints). None while the permissions are not known.
+ */
+export declare function offeredCrudScopes<TRow extends FormValues>(scopes: CrudScopes<TRow> | undefined, callable: (scope: CrudScope<TRow>) => boolean): CrudScope<TRow>[];
+/** The scope shown: the one chosen while it is offered, else the CRUD's own list (`null`). */
+export declare function shownCrudScope<TRow extends FormValues>(offered: readonly CrudScope<TRow>[], chosen: string | null): CrudScope<TRow> | null;
+/**
+ * The CRUD's props on a scope: its endpoints, and its columns, inputs, forms, table settings and name where it gives its
+ * own (`form` and `table` over the CRUD's, field by field). The CRUD's own list is the props as they are given.
+ */
+export declare function crudScopeProps<TRow extends FormValues>(given: CrudProps<TRow>, scope: CrudScope<TRow> | null): CrudProps<TRow>;
+/**
+ * Where a scope keeps its table's settings: the scope's own `table.stateKey`, else the CRUD's key and the scope's id, so
+ * each list keeps the columns shown, their order and widths, its sort and its page size apart (a Branch column hidden
+ * on one branch's list and shown on every branch's). The CRUD's own list keeps the CRUD's key.
+ */
+export declare function crudScopeStateKey<TRow extends FormValues>(ownKey: string, scope: CrudScope<TRow> | null): string;
+/** Where this browser keeps the choice: `nx-crud-scope:{key}:{viewer}`; nothing without a viewer. */
+export declare function crudScopeStorageKey(remember: {
+    key: string;
+    viewer?: string | null;
+} | undefined): string | null;
+/**
+ * The scope kept: its id, `null` for the CRUD's own list (kept as nothing), `undefined` when nothing could be read (no
+ * storage, no key). A kept scope the CRUD no longer offers stays kept and opens the CRUD's own list until it is offered.
+ */
+export declare function readCrudScope(storage: Pick<Storage, "getItem"> | null, key: string | null): string | null | undefined;
+/** Keeps the choice; the CRUD's own list is kept as nothing. A browser that keeps nothing opens the CRUD's own list. */
+export declare function writeCrudScope(storage: Pick<Storage, "setItem" | "removeItem"> | null, key: string | null, scope: string | null): void;

package/dist/Helpers/CrudScopes.js

@@ -0,0 +1,79 @@
+/*
+ * The pure half of a CRUD whose list can be widened (`Crud` `scopes`, Components/Forms/CrudScopes.tsx): which lists are
+ * offered, which one shows, the props it gives the CRUD, and where this browser keeps the choice. Pure, so Node tests
+ * run it.
+ */
+/**
+ * The scopes offered now: those whose `when` (the page's own rule) allows them and whose lists the person may call
+ * (`callable`, the CRUD's permission test on the scope's endpoints). None while the permissions are not known.
+ */
+export function offeredCrudScopes(scopes, callable) {
+    if (!scopes)
+        return [];
+    return scopes.options.filter(scope => (scope.when ? scope.when() : true) && callable(scope));
+}
+/** The scope shown: the one chosen while it is offered, else the CRUD's own list (`null`). */
+export function shownCrudScope(offered, chosen) {
+    return chosen === null ? null : (offered.find(scope => scope.id === chosen) ?? null);
+}
+/**
+ * The CRUD's props on a scope: its endpoints, and its columns, inputs, forms, table settings and name where it gives its
+ * own (`form` and `table` over the CRUD's, field by field). The CRUD's own list is the props as they are given.
+ */
+export function crudScopeProps(given, scope) {
+    if (!scope)
+        return given;
+    return {
+        ...given,
+        api: scope.api,
+        columns: scope.columns ?? given.columns,
+        inputs: scope.inputs ?? given.inputs,
+        form: scope.form ? { ...given.form, ...scope.form } : given.form,
+        table: scope.table ? { ...given.table, ...scope.table } : given.table,
+        "aria-label": scope["aria-label"] ?? given["aria-label"],
+    };
+}
+/**
+ * Where a scope keeps its table's settings: the scope's own `table.stateKey`, else the CRUD's key and the scope's id, so
+ * each list keeps the columns shown, their order and widths, its sort and its page size apart (a Branch column hidden
+ * on one branch's list and shown on every branch's). The CRUD's own list keeps the CRUD's key.
+ */
+export function crudScopeStateKey(ownKey, scope) {
+    if (!scope)
+        return ownKey;
+    return scope.table?.stateKey ?? `${ownKey}:${scope.id}`;
+}
+/** Where this browser keeps the choice: `nx-crud-scope:{key}:{viewer}`; nothing without a viewer. */
+export function crudScopeStorageKey(remember) {
+    const viewer = remember?.viewer?.trim();
+    return remember?.key && viewer ? `nx-crud-scope:${remember.key}:${viewer}` : null;
+}
+/**
+ * The scope kept: its id, `null` for the CRUD's own list (kept as nothing), `undefined` when nothing could be read (no
+ * storage, no key). A kept scope the CRUD no longer offers stays kept and opens the CRUD's own list until it is offered.
+ */
+export function readCrudScope(storage, key) {
+    if (!storage || !key)
+        return undefined;
+    try {
+        const kept = storage.getItem(key);
+        return kept ? kept : null;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Keeps the choice; the CRUD's own list is kept as nothing. A browser that keeps nothing opens the CRUD's own list. */
+export function writeCrudScope(storage, key, scope) {
+    if (!storage || !key)
+        return;
+    try {
+        if (scope)
+            storage.setItem(key, scope);
+        else
+            storage.removeItem(key);
+    }
+    catch {
+        // Not kept: the CRUD opens its own list next time.
+    }
+}

package/dist/Helpers/DashboardHelpers.d.ts

@@ -0,0 +1,115 @@
+import type { DashboardLayout, DashboardLayoutItem, WidgetContext, WidgetDefinition, WidgetModuleLoader, WidgetSize } from "../Interfaces/DashboardInterfaces.ts";
+/** Each size's span on the 12-column grid, and its name in the size menu. */
+export declare const WIDGET_SPANS: Readonly<Record<WidgetSize, {
+    readonly columns: number;
+    readonly rows: number;
+    readonly label: string;
+}>>;
+/** The sizes in the order a size menu lists them. */
+export declare const WIDGET_SIZES: readonly WidgetSize[];
+/** "Medium (6 × 2)". */
+export declare const widgetSizeLabel: (size: WidgetSize) => string;
+/** Whether a widget may go on a place's board: an `anywhere` widget everywhere, an `own` one on its module's board only. */
+export declare function widgetAllowedIn(widget: Pick<WidgetDefinition, "placement" | "module">, placeModule: string | null | undefined): boolean;
+/**
+ * The widgets a place's board may draw now, by code: allowed in the place and seen by the person (`canSee`: the module
+ * held, the key held). Duplicate codes keep the first.
+ */
+export declare function drawableWidgets(widgets: readonly WidgetDefinition<any>[], placeModule: string | null | undefined, canSee?: (widget: WidgetDefinition<any>) => boolean): Map<string, WidgetDefinition<any>>;
+/**
+ * A layout as the board keeps it: each code once (the first), each size one its widget takes (else its first). A code
+ * the board does not know now (a widget hidden, removed from the app, or not allowed here) is kept as it was, so it
+ * comes back if it can be drawn again.
+ */
+export declare function normaliseLayout(layout: readonly DashboardLayoutItem[] | null | undefined, widgets: readonly WidgetDefinition<any>[]): DashboardLayoutItem[];
+/** The items of a layout the board draws now, in order. */
+export declare function drawnItems(layout: DashboardLayout, drawable: ReadonlyMap<string, unknown>): DashboardLayoutItem[];
+/**
+ * A layout to save after an edit of the drawn items: the edited items in their new order, and every item that was not
+ * drawn (hidden now) back in its place - after the drawn item it followed, or at the start. One whose drawn neighbour
+ * was removed follows the drawn item before that one. Nothing hidden is lost by a save.
+ */
+export declare function mergeHidden(full: DashboardLayout, edited: DashboardLayout, drawable: ReadonlyMap<string, unknown>): DashboardLayoutItem[];
+/** The list with the item at `from` moved to `to` (both clamped). */
+export declare function moveItem<T>(list: readonly T[], from: number, to: number): T[];
+/** Whether two layouts are the same widgets, sizes and order. */
+export declare function sameLayout(a: DashboardLayout | null | undefined, b: DashboardLayout | null | undefined): boolean;
+/** A widget's box on the screen, as the keyboard and the drag read it. */
+export interface WidgetRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/**
+ * The widget an arrow key up or down moves to: in the nearest row above (or below) the one at `index`, the one whose
+ * middle is nearest across. `null` when there is no row that way. Rows are told apart by their tops.
+ */
+export declare function neighbourInColumn(rects: readonly WidgetRect[], index: number, direction: "up" | "down"): number | null;
+/** The widget under a point, leaving out `skip` (the one being dragged). `null` over a gap. */
+export declare function widgetAtPoint(rects: readonly WidgetRect[], x: number, y: number, skip: number): number | null;
+/** A module's widgets in the Add list. */
+export interface WidgetGroup {
+    module: string;
+    widgets: {
+        widget: WidgetDefinition<any>;
+        onBoard: boolean;
+    }[];
+}
+/**
+ * The Add list: every widget the place may draw now, grouped by module - the place's own module first, the rest in the
+ * order the app declared them - each marked when it is on the board already.
+ */
+export declare function addableWidgets(drawable: ReadonlyMap<string, WidgetDefinition<any>>, layout: DashboardLayout, placeModule: string | null | undefined): WidgetGroup[];
+/** Whether a widget's data is nothing to show: its own `isEmpty`, else `null`, `undefined` or an empty list. */
+export declare function widgetDataEmpty(widget: Pick<WidgetDefinition<any>, "isEmpty">, data: unknown): boolean;
+/** Whether a widget reads data at all (`load` or `batch`). */
+export declare const widgetNeedsData: (widget: Pick<WidgetDefinition<any>, "load" | "batch">) => boolean;
+/** What `createWidgetBatcher` answers. */
+export interface WidgetBatcher {
+    /**
+     * The widget's data: from the cache while fresh (unless `force`), from a call already on its way, else asked. Batched
+     * widgets asked in the same task go to their module together, one call per module.
+     */
+    request(widget: WidgetDefinition<any>, context: WidgetContext, options?: {
+        force?: boolean;
+    }): Promise<unknown>;
+    /** The widget's data as kept, and when it came. */
+    cached(code: string): {
+        data: unknown;
+        at: number;
+    } | undefined;
+    /** Keeps data read elsewhere (with the page, on the server) as if it had been asked now. */
+    prime(code: string, data: unknown): void;
+    /** Whether the widget's kept data is still fresh (its `refresh` seconds; no `refresh`: the page's life). */
+    isFresh(widget: Pick<WidgetDefinition<any>, "code" | "refresh">): boolean;
+    /** Forgets the kept data (of these codes, or all), so the next request asks again. */
+    clear(codes?: readonly string[]): void;
+    /** How many calls went out: each module call and each own `load` count one. */
+    readonly calls: number;
+}
+export interface WidgetBatcherOptions {
+    /** The clock, for tests. Default `Date.now`. */
+    now?: () => number;
+    /** When the gathered requests go out. Default: the next task (`setTimeout(0)`), so one draw's requests go together. */
+    defer?: (flush: () => void) => void;
+}
+/**
+ * One cache and one queue for a board's widgets: every batched widget asked while one draw runs goes to its module in
+ * one call (`loadModule(module, codes)`), each answer is kept for the page's life (or the widget's `refresh` seconds),
+ * and a widget asked twice while its call is on its way waits for that call.
+ */
+export declare function createWidgetBatcher(loadModule: WidgetModuleLoader | undefined, options?: WidgetBatcherOptions): WidgetBatcher;
+/** A typed mark on a calendar widget's day: a holiday, a leave, an event, or a kind of the app's own. */
+export interface CalendarMark {
+    /** The first day, an ISO date. */
+    date: string;
+    /** The last day of a mark over several days (a leave), an ISO date; none for one day. */
+    until?: string;
+    /** `holiday`, `leave`, `event`, or the app's own kind (give it in `kinds`). */
+    kind: string;
+    /** What it is: "Dashain", "Sita Rai - annual leave". */
+    label: string;
+}
+/** Each day's marks, by ISO date: a mark over several days is on each of them. A mark with a broken date is left out. */
+export declare function marksByDay(marks: readonly CalendarMark[]): Map<string, CalendarMark[]>;

package/dist/Helpers/DashboardHelpers.js

@@ -0,0 +1,305 @@
+/*
+ * A dashboard board's rules, kept apart from React so they can be tested alone: the size presets, which widgets a place
+ * may draw, a layout kept whole through edits (the widgets a person cannot see now keep their places), moving in the
+ * list by keyboard and by pointer, the Add list, and the batcher that asks each module once per draw.
+ */
+import { addDays, isIsoDate } from "./DateHelpers.js";
+/** Each size's span on the 12-column grid, and its name in the size menu. */
+export const WIDGET_SPANS = {
+    S: { columns: 3, rows: 1, label: "Small" },
+    M: { columns: 6, rows: 2, label: "Medium" },
+    L: { columns: 6, rows: 4, label: "Large" },
+    W: { columns: 12, rows: 2, label: "Wide" },
+    T: { columns: 12, rows: 4, label: "Tall" },
+};
+/** The sizes in the order a size menu lists them. */
+export const WIDGET_SIZES = ["S", "M", "L", "W", "T"];
+/** "Medium (6 × 2)". */
+export const widgetSizeLabel = (size) => `${WIDGET_SPANS[size].label} (${WIDGET_SPANS[size].columns} × ${WIDGET_SPANS[size].rows})`;
+/** Whether a widget may go on a place's board: an `anywhere` widget everywhere, an `own` one on its module's board only. */
+export function widgetAllowedIn(widget, placeModule) {
+    return widget.placement === "anywhere" || (placeModule !== null && placeModule !== undefined && widget.module === placeModule);
+}
+/**
+ * The widgets a place's board may draw now, by code: allowed in the place and seen by the person (`canSee`: the module
+ * held, the key held). Duplicate codes keep the first.
+ */
+export function drawableWidgets(widgets, placeModule, canSee) {
+    const drawable = new Map();
+    for (const widget of widgets) {
+        if (drawable.has(widget.code) || widget.sizes.length === 0)
+            continue;
+        if (!widgetAllowedIn(widget, placeModule))
+            continue;
+        if (canSee && !canSee(widget))
+            continue;
+        drawable.set(widget.code, widget);
+    }
+    return drawable;
+}
+/**
+ * A layout as the board keeps it: each code once (the first), each size one its widget takes (else its first). A code
+ * the board does not know now (a widget hidden, removed from the app, or not allowed here) is kept as it was, so it
+ * comes back if it can be drawn again.
+ */
+export function normaliseLayout(layout, widgets) {
+    const byCode = new Map(widgets.map(widget => [widget.code, widget]));
+    const seen = new Set();
+    const items = [];
+    for (const item of layout ?? []) {
+        if (!item || typeof item.code !== "string" || seen.has(item.code))
+            continue;
+        seen.add(item.code);
+        const widget = byCode.get(item.code);
+        const size = widget && !widget.sizes.includes(item.size) ? widget.sizes[0] : item.size;
+        items.push({ code: item.code, size });
+    }
+    return items;
+}
+/** The items of a layout the board draws now, in order. */
+export function drawnItems(layout, drawable) {
+    return layout.filter(item => drawable.has(item.code));
+}
+/**
+ * A layout to save after an edit of the drawn items: the edited items in their new order, and every item that was not
+ * drawn (hidden now) back in its place - after the drawn item it followed, or at the start. One whose drawn neighbour
+ * was removed follows the drawn item before that one. Nothing hidden is lost by a save.
+ */
+export function mergeHidden(full, edited, drawable) {
+    const editedCodes = new Set(edited.map(item => item.code));
+    // Each hidden item and the drawn items before it, nearest first: it follows the nearest that is still there.
+    const anchored = new Map();
+    const before = [];
+    for (const item of full) {
+        if (drawable.has(item.code)) {
+            before.push(item.code);
+            continue;
+        }
+        if (editedCodes.has(item.code))
+            continue;
+        let anchor = null;
+        for (let index = before.length - 1; index >= 0; index--)
+            if (editedCodes.has(before[index])) {
+                anchor = before[index];
+                break;
+            }
+        anchored.set(anchor, [...(anchored.get(anchor) ?? []), item]);
+    }
+    const result = [...(anchored.get(null) ?? [])];
+    for (const item of edited) {
+        result.push(item);
+        result.push(...(anchored.get(item.code) ?? []));
+    }
+    return result;
+}
+/** The list with the item at `from` moved to `to` (both clamped). */
+export function moveItem(list, from, to) {
+    const result = [...list];
+    if (from < 0 || from >= result.length)
+        return result;
+    const target = Math.max(0, Math.min(result.length - 1, to));
+    const [item] = result.splice(from, 1);
+    result.splice(target, 0, item);
+    return result;
+}
+/** Whether two layouts are the same widgets, sizes and order. */
+export function sameLayout(a, b) {
+    const left = a ?? [];
+    const right = b ?? [];
+    return left.length === right.length && left.every((item, index) => item.code === right[index].code && item.size === right[index].size);
+}
+/**
+ * The widget an arrow key up or down moves to: in the nearest row above (or below) the one at `index`, the one whose
+ * middle is nearest across. `null` when there is no row that way. Rows are told apart by their tops.
+ */
+export function neighbourInColumn(rects, index, direction) {
+    const from = rects[index];
+    if (!from)
+        return null;
+    const middle = from.left + from.width / 2;
+    let rowTop = null;
+    for (const rect of rects) {
+        const wanted = direction === "up" ? rect.top < from.top - 1 : rect.top > from.top + 1;
+        if (!wanted)
+            continue;
+        if (rowTop === null || (direction === "up" ? rect.top > rowTop : rect.top < rowTop))
+            rowTop = rect.top;
+    }
+    if (rowTop === null)
+        return null;
+    let best = null;
+    let bestDistance = Infinity;
+    rects.forEach((rect, at) => {
+        if (Math.abs(rect.top - rowTop) > 1)
+            return;
+        const distance = Math.abs(rect.left + rect.width / 2 - middle);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = at;
+        }
+    });
+    return best;
+}
+/** The widget under a point, leaving out `skip` (the one being dragged). `null` over a gap. */
+export function widgetAtPoint(rects, x, y, skip) {
+    for (let index = 0; index < rects.length; index++) {
+        if (index === skip)
+            continue;
+        const rect = rects[index];
+        if (x >= rect.left && x < rect.left + rect.width && y >= rect.top && y < rect.top + rect.height)
+            return index;
+    }
+    return null;
+}
+/**
+ * The Add list: every widget the place may draw now, grouped by module - the place's own module first, the rest in the
+ * order the app declared them - each marked when it is on the board already.
+ */
+export function addableWidgets(drawable, layout, placeModule) {
+    const onBoard = new Set(layout.map(item => item.code));
+    const groups = new Map();
+    if (placeModule)
+        groups.set(placeModule, { module: placeModule, widgets: [] });
+    for (const widget of drawable.values()) {
+        const group = groups.get(widget.module) ?? {
+            module: widget.module,
+            widgets: [],
+        };
+        group.widgets.push({ widget, onBoard: onBoard.has(widget.code) });
+        groups.set(widget.module, group);
+    }
+    return [...groups.values()].filter(group => group.widgets.length > 0);
+}
+/** Whether a widget's data is nothing to show: its own `isEmpty`, else `null`, `undefined` or an empty list. */
+export function widgetDataEmpty(widget, data) {
+    if (widget.isEmpty)
+        return widget.isEmpty(data);
+    return data === null || data === undefined || (Array.isArray(data) && data.length === 0);
+}
+/** Whether a widget reads data at all (`load` or `batch`). */
+export const widgetNeedsData = (widget) => Boolean(widget.load || widget.batch);
+/**
+ * One cache and one queue for a board's widgets: every batched widget asked while one draw runs goes to its module in
+ * one call (`loadModule(module, codes)`), each answer is kept for the page's life (or the widget's `refresh` seconds),
+ * and a widget asked twice while its call is on its way waits for that call.
+ */
+export function createWidgetBatcher(loadModule, options = {}) {
+    const now = options.now ?? Date.now;
+    const defer = options.defer ?? (flush => void setTimeout(flush, 0));
+    const cache = new Map();
+    const inFlight = new Map();
+    let pending = new Map();
+    let scheduled = false;
+    let calls = 0;
+    function keep(code, data) {
+        cache.set(code, { data, at: now() });
+    }
+    function flush() {
+        scheduled = false;
+        const batches = pending;
+        pending = new Map();
+        for (const [module, waiting] of batches) {
+            const codes = [...new Set(waiting.flatMap(one => one.widget.batch?.codes ?? [one.widget.code]))];
+            calls++;
+            let call;
+            try {
+                call = loadModule ? Promise.resolve(loadModule(module, codes)) : Promise.reject(new Error(`No loadModule for ${module}.`));
+            }
+            catch (error) {
+                call = Promise.reject(error);
+            }
+            call.then(answer => {
+                for (const one of waiting) {
+                    const own = one.widget.batch?.codes ?? [one.widget.code];
+                    const parts = {};
+                    for (const code of own)
+                        if (answer && Object.prototype.hasOwnProperty.call(answer, code))
+                            parts[code] = answer[code];
+                    let data;
+                    try {
+                        data = one.widget.batch?.pick ? one.widget.batch.pick(parts) : own.length === 1 ? parts[own[0]] : parts;
+                    }
+                    catch (error) {
+                        one.reject(error);
+                        continue;
+                    }
+                    keep(one.widget.code, data);
+                    one.resolve(data);
+                }
+            }, error => waiting.forEach(one => one.reject(error)));
+        }
+    }
+    const batcher = {
+        request(widget, context, requestOptions = {}) {
+            if (!requestOptions.force && batcher.isFresh(widget))
+                return Promise.resolve(cache.get(widget.code).data);
+            const running = inFlight.get(widget.code);
+            if (running)
+                return running;
+            let promise;
+            if (widget.batch) {
+                promise = new Promise((resolve, reject) => {
+                    const module = widget.batch.module;
+                    pending.set(module, [...(pending.get(module) ?? []), { widget, resolve, reject }]);
+                    if (!scheduled) {
+                        scheduled = true;
+                        defer(flush);
+                    }
+                });
+            }
+            else if (widget.load) {
+                calls++;
+                promise = Promise.resolve()
+                    .then(() => widget.load(context))
+                    .then(data => {
+                    keep(widget.code, data);
+                    return data;
+                });
+            }
+            else {
+                keep(widget.code, undefined);
+                return Promise.resolve(undefined);
+            }
+            inFlight.set(widget.code, promise);
+            const done = () => {
+                if (inFlight.get(widget.code) === promise)
+                    inFlight.delete(widget.code);
+            };
+            promise.then(done, done);
+            return promise;
+        },
+        cached: code => cache.get(code),
+        prime: (code, data) => keep(code, data),
+        isFresh(widget) {
+            const kept = cache.get(widget.code);
+            if (!kept)
+                return false;
+            return widget.refresh === undefined || widget.refresh <= 0 || now() - kept.at < widget.refresh * 1000;
+        },
+        clear(codes) {
+            if (!codes)
+                cache.clear();
+            else
+                codes.forEach(code => cache.delete(code));
+        },
+        get calls() {
+            return calls;
+        },
+    };
+    return batcher;
+}
+/** At most this many days of one mark are drawn, so a broken range never fills a year of cells. */
+const MAX_MARK_DAYS = 366;
+/** Each day's marks, by ISO date: a mark over several days is on each of them. A mark with a broken date is left out. */
+export function marksByDay(marks) {
+    const days = new Map();
+    for (const mark of marks) {
+        if (!isIsoDate(mark.date))
+            continue;
+        const last = mark.until && isIsoDate(mark.until) && mark.until > mark.date ? mark.until : mark.date;
+        let day = mark.date;
+        for (let count = 0; day <= last && count < MAX_MARK_DAYS; count++, day = addDays(day, 1))
+            days.set(day, [...(days.get(day) ?? []), mark]);
+    }
+    return days;
+}