nexus-shared 3.2.0 → 4.0.0

package/dist/Helpers/InputConditions.js

@@ -0,0 +1,168 @@
+import { EInputTypes } from "../Interfaces/FormInterfaces.js";
+import { formatNumber } from "./NumberHelpers.js";
+/*
+ * When an input shows (`showWhen`), when it is read-only (`readOnlyWhen`), what it is called (`labelWhen`), how wide it
+ * is (`spanWhen`) and what it shows when it is worked out from others (`compute`): declared in its params on other
+ * inputs' values, so a page never writes a getter for `hidden`, `readOnly`, `label` or `span`. The form gives each such
+ * input a live `hidden` / `readOnly` / `label` / `span` that reads its store, and follows the inputs they name as
+ * `dependsOn` would (this file, pure, so Node tests run it).
+ */
+/** No value: null, undefined, an empty or blank text, an empty list. `false` and `0` are values. */
+export function isEmptyValue(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === "string")
+        return value.trim() === "";
+    return Array.isArray(value) && value.length === 0;
+}
+/** The same value whatever its type on the way: 1 and "1" match, as a radio group's and a dropdown's do. */
+const same = (a, b) => a === b || (a !== null && a !== undefined && b !== null && b !== undefined && String(a) === String(b));
+/**
+ * Whether one condition holds for the other input's value. A list value (a multiple choice) holds `in` when any of its
+ * items is listed, and `notIn` when none is. Every key the condition has must hold; one with none holds always.
+ */
+export function conditionHolds(condition, value) {
+    const items = Array.isArray(value) ? value : [value];
+    if (condition.in && !items.some(item => condition.in.some(wanted => same(item, wanted))))
+        return false;
+    if (condition.notIn && items.some(item => condition.notIn.some(unwanted => same(item, unwanted))))
+        return false;
+    if (condition.filled !== undefined && condition.filled === isEmptyValue(value))
+        return false;
+    return true;
+}
+/** The conditions of a `showWhen` or a `readOnlyWhen`, as a list. */
+export function conditionsOf(conditions) {
+    if (!conditions)
+        return [];
+    return Array.isArray(conditions) ? conditions : [conditions];
+}
+/** Whether every condition holds, reading the other inputs' values with `read`. None holds always. */
+export function conditionsHold(conditions, read) {
+    return conditionsOf(conditions).every(condition => conditionHolds(condition, read(condition.name)));
+}
+/** Whether an input with this `showWhen` shows, reading the other inputs' values with `read`: every condition must hold. */
+export function inputShown(showWhen, read) {
+    return conditionsHold(showWhen, read);
+}
+/** Whether an input with this `readOnlyWhen` is read-only, reading the other inputs' values with `read`: every condition must hold. */
+export function inputReadOnly(readOnlyWhen, read) {
+    return Boolean(readOnlyWhen) && conditionsHold(readOnlyWhen, read);
+}
+/** The text of `texts` for the other input's value (compared as text), or undefined when none is listed for it. */
+export function textFor(texts, value) {
+    if (!texts || value === null || value === undefined || Array.isArray(value))
+        return undefined;
+    return Object.prototype.hasOwnProperty.call(texts, String(value)) ? texts[String(value)] : undefined;
+}
+/** The label an input with this `labelWhen` shows for the other input's value: listed, else `otherwise`, else its own. */
+export function labelFor(labelWhen, value, own) {
+    return textFor(labelWhen.labels, value) ?? labelWhen.otherwise ?? own;
+}
+/**
+ * The columns an input with this `spanWhen` spans, reading the other inputs' values with `read`: `spanWhen.span` while
+ * every condition of `when` holds, else its own `span` (none: undefined, the whole row).
+ */
+export function spanFor(spanWhen, read, own) {
+    return spanWhen && conditionsHold(spanWhen.when, read) ? spanWhen.span : own;
+}
+/** The params' own value of `key` - a value or a getter, asked on the copy so `this` is the copy. */
+function ownValue(params, copy, key) {
+    const own = Object.getOwnPropertyDescriptor(params, key);
+    return () => (own?.get ? own.get.call(copy) : own?.value);
+}
+/** The params' own value of `key` - a value or a getter, asked on the copy so `this` is the copy - as a boolean. */
+function ownFlag(params, copy, key) {
+    const own = Object.getOwnPropertyDescriptor(params, key);
+    return () => Boolean(own?.get ? own.get.call(copy) : own?.value);
+}
+/**
+ * The inputs with a live `hidden` for each one that has `showWhen`, a live `readOnly` for each one that has
+ * `readOnlyWhen` - its own `hidden` / `readOnly` (a value or a getter), or else the conditions, read through `read` as
+ * the values are now - a live `label` (and `placeholder`) for each one that has `labelWhen`, and a live `span` for each
+ * one that has `spanWhen` (its own `span`, a value or a getter, while the conditions do not hold); and its `dependsOn`
+ * joined by the names they read (and by the inputs a `compute` is worked out from), so the form draws it again (and asks
+ * its rule again) when they change. The other params are copied with their getters as they are. The same array when no
+ * input has any.
+ *
+ * @example withInputConditions(inputs, name => store.get(name))
+ */
+export function withInputConditions(inputs, read) {
+    if (!inputs.some(params => params.showWhen || params.readOnlyWhen || params.labelWhen || params.spanWhen || params.compute))
+        return inputs;
+    return inputs.map(params => {
+        if (!params.showWhen && !params.readOnlyWhen && !params.labelWhen && !params.spanWhen && !params.compute)
+            return params;
+        const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(params));
+        const names = [...conditionsOf(params.showWhen), ...conditionsOf(params.readOnlyWhen)].map(condition => condition.name);
+        if (params.labelWhen)
+            names.push(params.labelWhen.name);
+        // A width that follows values draws again when they change; its own name, when listed, follows its own typing.
+        if (params.spanWhen)
+            names.push(...conditionsOf(params.spanWhen.when).map(condition => condition.name));
+        // A worked-out input draws again, and is worked out again, when an input it is worked out from changes.
+        if (params.compute)
+            names.push(...params.compute.from);
+        const follows = [...new Set([...(params.dependsOn ?? []), ...names])];
+        if (params.showWhen) {
+            const ownHidden = ownFlag(params, copy, "hidden");
+            Object.defineProperty(copy, "hidden", { get: () => ownHidden() || !inputShown(copy.showWhen, read), enumerable: true, configurable: true });
+        }
+        if (params.readOnlyWhen) {
+            const ownReadOnly = ownFlag(params, copy, "readOnly");
+            Object.defineProperty(copy, "readOnly", { get: () => ownReadOnly() || inputReadOnly(copy.readOnlyWhen, read), enumerable: true, configurable: true });
+        }
+        if (params.labelWhen) {
+            const ownLabel = ownValue(params, copy, "label");
+            const ownPlaceholder = ownValue(params, copy, "placeholder");
+            Object.defineProperty(copy, "label", { get: () => (copy.labelWhen ? labelFor(copy.labelWhen, read(copy.labelWhen.name), ownLabel()) : ownLabel()), enumerable: true, configurable: true });
+            if (params.labelWhen.placeholders) {
+                Object.defineProperty(copy, "placeholder", { get: () => (copy.labelWhen ? (textFor(copy.labelWhen.placeholders, read(copy.labelWhen.name)) ?? ownPlaceholder()) : ownPlaceholder()), enumerable: true, configurable: true });
+            }
+        }
+        if (params.spanWhen) {
+            const ownSpan = ownValue(params, copy, "span");
+            Object.defineProperty(copy, "span", { get: () => spanFor(copy.spanWhen, read, ownSpan()), enumerable: true, configurable: true });
+        }
+        Object.defineProperty(copy, "dependsOn", { value: follows, enumerable: true, configurable: true, writable: true });
+        return copy;
+    });
+}
+/* Inputs worked out from others (`compute`) */
+/** Whether the input is worked out from others (`compute`): it holds no value of the form's and is never typed in. */
+export function isComputedInput(params) {
+    return Boolean(params?.compute);
+}
+/**
+ * What a worked-out input (`compute`) shows for these values and the form's `computeWith`. A page's rule that throws
+ * shows nothing, and says so in the console, so one bad figure never takes the form down with it.
+ */
+export function computedValue(params, values, withValue) {
+    if (!params.compute)
+        return undefined;
+    try {
+        return params.compute.value(values, withValue);
+    }
+    catch (error) {
+        console.error(`The worked-out value of "${params.name}" failed:`, error);
+        return undefined;
+    }
+}
+/**
+ * A worked-out value as its box writes it: a Number input's figure with its `decimals` always written (1,073.50), grouped,
+ * in `locale` (the person's, unless the params name their own); any other input's value as text. Null, undefined, "",
+ * NaN, or a figure that is not finite, write nothing, so the box is blank rather than "NaN" or "0.00".
+ */
+export function computedText(params, value, locale) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "number" && !Number.isFinite(value))
+        return "";
+    if (params.type !== EInputTypes.Number)
+        return String(value).trim();
+    const figure = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+    if (!Number.isFinite(figure))
+        return "";
+    const { decimals, fixedDecimals, grouping } = params;
+    return formatNumber(figure, { decimals, fixedDecimals: fixedDecimals ?? decimals !== undefined, grouping: grouping ?? true, locale: params.locale ?? locale });
+}

package/dist/Helpers/InputMemory.d.ts

@@ -0,0 +1,106 @@
+import { type InputParams, type InputRemember } from "../Interfaces/FormInterfaces.ts";
+/** Where an input's value is kept: `nx-input:{key}:{viewer}`, or `nx-input:{key}-{per value}:{viewer}` with `per`. */
+export declare const INPUT_MEMORY_PREFIX = "nx-input:";
+/** Reads another value beside the input: the form's values for a form's input, the row's for an input in rows. */
+export type InputMemoryRead = (name: string) => unknown;
+/**
+ * The other values a remembered input's opening is judged on: the input that narrows its options (`narrowedBy`), the one
+ * its value is kept per (`per`), and the ones its `when` names. A picker's late answer opens nothing once any of them
+ * changed since it was asked: it answered for values the form no longer holds.
+ */
+export declare function rememberDependencies(params: InputParams): string[];
+/** Whether the input remembers among these values: its `when` holds (none: always). */
+export declare function remembersHere(remember: InputRemember | null | undefined, read?: InputMemoryRead): boolean;
+/**
+ * The storage key of a remembered input, or null when nothing is kept here: no key, no viewer to keep it for, its `when`
+ * does not hold, or its `per` input holds no single value. With `per`, the other value ends the key: one value kept per
+ * group, `nx-input:subscription-package-{group}:{viewer}`.
+ */
+export declare function inputMemoryKey(remember: InputRemember | null | undefined, read?: InputMemoryRead): string | null;
+/** What `getItem`/`setItem`/`removeItem` a memory needs: `localStorage`, or a map in a test. */
+export type InputMemoryStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+/** This browser's local storage, or nothing where it cannot be reached (on a server, storage switched off). */
+export declare function browserInputMemory(): InputMemoryStorage | null;
+/**
+ * The event a `SubmitForm` sends its `<form>` once a save went through, before the form resets: the rows inside it keep
+ * their remembered values then (`RowsStore.rememberAdded`), as the form's own inputs do.
+ */
+export declare const FORM_SAVED_EVENT = "nx-form-saved";
+/** The value kept for this input, or undefined: none kept, no viewer, or storage that cannot be read. */
+export declare function readInputMemory(storage: InputMemoryStorage | null, remember: InputRemember | null | undefined, read?: InputMemoryRead): unknown;
+/** Keeps a saved value for the input; an empty one forgets it. Storage that cannot be written keeps nothing. */
+export declare function writeInputMemory(storage: InputMemoryStorage | null, params: InputParams, value: unknown, read?: InputMemoryRead): void;
+/** Forgets the input's kept value: one its list no longer offers. */
+export declare function forgetInputMemory(storage: InputMemoryStorage | null, remember: InputRemember | null | undefined, read?: InputMemoryRead): void;
+/** Whether a value is the input's empty one: nothing, "", an empty list, or a switch that is off. */
+export declare function isEmptyInputValue(params: InputParams, value: unknown): boolean;
+/**
+ * The part of a value the input offers now, or undefined when it offers none of it. An input with a list of its own
+ * (radio and checkbox groups, a dropdown's `options`) must list it, neither disabled nor inactive; a list of values
+ * keeps the ones it lists. An input whose options come from a server, or that has no options, takes any value here: a
+ * picker is asked by `keptStandingNow` / `findKeptStanding`.
+ */
+export declare function offeredInputValue(params: InputParams, value: unknown): unknown;
+/** A dropdown whose options come from `loadOptions` and that has no list of its own: it is asked what it offers. */
+export declare function isPickerInput(params: InputParams): boolean;
+/** How a kept (or preferred) value stands with its input now. */
+export type KeptStanding = 
+/** Offered: open on it (for a list of values, the part offered). */
+{
+    status: "offered";
+    value: unknown;
+}
+/** Not offered - gone, inactive, disabled, or outside the narrowing: open nothing, and forget a kept value. */
+ | {
+    status: "gone";
+}
+/** Could not be told now (the picker could not be read, nothing to narrow by yet): open nothing, keep it for next time. */
+ | {
+    status: "unknown";
+};
+/**
+ * How a value stands with the input at once, with no call: an input's own list (narrowed as its `narrowedBy` says among
+ * these values) offers it or not; a picker by what it holds already (`peekOption`, fresh only); any other input takes
+ * it. Null when a picker must be asked (`findKeptStanding`).
+ */
+export declare function keptStandingNow(params: InputParams, value: unknown, read?: InputMemoryRead): KeptStanding | null;
+/**
+ * How a value stands with the input, asking a picker when it must: by the value's key (`resolveOptions`, as a saved
+ * value is named) - a record found is judged on its own state and narrowing field - and, for a key it did not answer or
+ * a record without its narrowing's field, through its own pages narrowed as the form narrows them (a picker that names
+ * only what it already holds, such as a `crudPicker` with another `valueKey` and no `find`, answers nothing for a list
+ * not loaded yet: its pages tell). Never rejects: a picker that cannot be read answers `unknown`.
+ */
+export declare function findKeptStanding(params: InputParams, value: unknown, read: InputMemoryRead, signal: AbortSignal): Promise<KeptStanding>;
+/** What a remembered input opens on. */
+export interface KeptOpening {
+    /** The value it opens on; undefined: none (it keeps its own default). */
+    value: unknown;
+    /** The kept choice is no longer offered: forget it. */
+    forget: boolean;
+    /** A picker must be asked first (`findRememberedOpening`); nothing opens until it answers. */
+    ask: boolean;
+}
+/**
+ * What a remembered input opens on among these values, at once where it can be told: the company's `preferred` value
+ * while the input offers it, else the person's last saved choice while it offers that, else none. `ask` when a picker
+ * must be asked first (`findRememberedOpening`). Nothing while its `when` does not hold.
+ */
+export declare function rememberedOpeningNow(params: InputParams, stored: unknown, read?: InputMemoryRead): KeptOpening;
+/**
+ * The same, asking a picker by the values' keys where it must (`findKeptStanding`). Never rejects: a picker that could
+ * not be read opens nothing and forgets nothing.
+ */
+export declare function findRememberedOpening(params: InputParams, stored: unknown, read: InputMemoryRead, signal: AbortSignal): Promise<KeptOpening>;
+/**
+ * What a remembered input opens on when the form's values leave it empty, from its own list alone: the company's
+ * `preferred` value while the input offers it, else the person's last saved choice while it offers that, else undefined
+ * (the input keeps its own default). A value no longer offered is dropped without a word, never shown as a broken one.
+ * A picker's values are taken as they are here; a form asks the picker (`rememberedOpeningNow`).
+ */
+export declare function rememberedOpening(params: InputParams, stored: unknown): unknown;
+/**
+ * The row of a list a save keeps a row input's value from: the one added last that is still there, else none (no row
+ * was added, so no new choice was made). Keys in the order they were added.
+ */
+export declare function lastAddedRowKey(added: readonly string[], present: (key: string) => boolean): string | null;

package/dist/Helpers/InputMemory.js

@@ -0,0 +1,385 @@
+import { EInputTypes } from "../Interfaces/FormInterfaces.js";
+import { isDisabledItem, isInactiveItem, optionKey, readField } from "./DropdownHelpers.js";
+import { conditionsHold, conditionsOf } from "./InputConditions.js";
+import { narrowInputParams, narrowingValue } from "./InputNarrowing.js";
+import { emptyInputValue, inputValuesEqual } from "./InputParamsHelpers.js";
+/*
+ * An input's last saved value, kept in this browser per viewer (`InputLayoutParams.remember`): what a form opens an
+ * input on when its own values leave it empty - the company's preferred value first, then the person's last choice, each
+ * only while the input still offers it. A picker (a dropdown whose options come from `loadOptions`) is asked first, by
+ * the value's key, whether it still offers it; a kept choice it no longer offers is forgotten. Pure: the storage is
+ * passed in, so a test runs on a map.
+ */
+/** Where an input's value is kept: `nx-input:{key}:{viewer}`, or `nx-input:{key}-{per value}:{viewer}` with `per`. */
+export const INPUT_MEMORY_PREFIX = "nx-input:";
+const readNothing = () => undefined;
+/**
+ * The other values a remembered input's opening is judged on: the input that narrows its options (`narrowedBy`), the one
+ * its value is kept per (`per`), and the ones its `when` names. A picker's late answer opens nothing once any of them
+ * changed since it was asked: it answered for values the form no longer holds.
+ */
+export function rememberDependencies(params) {
+    const names = new Set();
+    if (params.narrowedBy?.name !== undefined)
+        names.add(params.narrowedBy.name);
+    if (params.remember?.per)
+        names.add(params.remember.per);
+    for (const condition of conditionsOf(params.remember?.when))
+        names.add(condition.name);
+    names.delete(params.name);
+    return [...names];
+}
+/** Whether the input remembers among these values: its `when` holds (none: always). */
+export function remembersHere(remember, read = readNothing) {
+    if (!remember)
+        return false;
+    return !remember.when || conditionsHold(remember.when, read);
+}
+/**
+ * The storage key of a remembered input, or null when nothing is kept here: no key, no viewer to keep it for, its `when`
+ * does not hold, or its `per` input holds no single value. With `per`, the other value ends the key: one value kept per
+ * group, `nx-input:subscription-package-{group}:{viewer}`.
+ */
+export function inputMemoryKey(remember, read = readNothing) {
+    if (!remember?.key || !remember.viewer || !remembersHere(remember, read))
+        return null;
+    if (!remember.per)
+        return `${INPUT_MEMORY_PREFIX}${remember.key}:${remember.viewer}`;
+    const per = narrowingValue(read(remember.per));
+    return per === null ? null : `${INPUT_MEMORY_PREFIX}${remember.key}-${String(per)}:${remember.viewer}`;
+}
+/** This browser's local storage, or nothing where it cannot be reached (on a server, storage switched off). */
+export function browserInputMemory() {
+    try {
+        return typeof window === "undefined" ? null : window.localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The event a `SubmitForm` sends its `<form>` once a save went through, before the form resets: the rows inside it keep
+ * their remembered values then (`RowsStore.rememberAdded`), as the form's own inputs do.
+ */
+export const FORM_SAVED_EVENT = "nx-form-saved";
+/** The value kept for this input, or undefined: none kept, no viewer, or storage that cannot be read. */
+export function readInputMemory(storage, remember, read = readNothing) {
+    const key = inputMemoryKey(remember, read);
+    if (!storage || !key)
+        return undefined;
+    try {
+        const text = storage.getItem(key);
+        if (!text)
+            return undefined;
+        const kept = JSON.parse(text);
+        return kept && typeof kept === "object" ? kept.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Keeps a saved value for the input; an empty one forgets it. Storage that cannot be written keeps nothing. */
+export function writeInputMemory(storage, params, value, read = readNothing) {
+    const key = inputMemoryKey(params.remember, read);
+    if (!storage || !key)
+        return;
+    try {
+        if (isEmptyInputValue(params, value))
+            storage.removeItem(key);
+        else
+            storage.setItem(key, JSON.stringify({ value }));
+    }
+    catch {
+        // Storage full or blocked: the form works without it.
+    }
+}
+/** Forgets the input's kept value: one its list no longer offers. */
+export function forgetInputMemory(storage, remember, read = readNothing) {
+    const key = inputMemoryKey(remember, read);
+    if (!storage || !key)
+        return;
+    try {
+        storage.removeItem(key);
+    }
+    catch {
+        // Blocked: it is asked about again next time.
+    }
+}
+/** Whether a value is the input's empty one: nothing, "", an empty list, or a switch that is off. */
+export function isEmptyInputValue(params, value) {
+    if (value === undefined || value === null || value === "")
+        return true;
+    if (Array.isArray(value) && value.length === 0)
+        return true;
+    return inputValuesEqual(value, emptyInputValue(params));
+}
+/** An input's own list of options, when it holds one: a choice group's, a dropdown's `options` (not a server's pages). */
+function listedOptions(params) {
+    const options = params.options;
+    return Array.isArray(options) ? options : null;
+}
+/**
+ * The part of a value the input offers now, or undefined when it offers none of it. An input with a list of its own
+ * (radio and checkbox groups, a dropdown's `options`) must list it, neither disabled nor inactive; a list of values
+ * keeps the ones it lists. An input whose options come from a server, or that has no options, takes any value here: a
+ * picker is asked by `keptStandingNow` / `findKeptStanding`.
+ */
+export function offeredInputValue(params, value) {
+    if (isEmptyInputValue(params, value))
+        return undefined;
+    const options = listedOptions(params);
+    if (!options)
+        return value;
+    const valueKey = params.type === EInputTypes.Dropdown ? (params.valueKey ?? "value") : "value";
+    const inactive = params.isOptionInactive;
+    const offered = new Set(options
+        .filter(item => item && typeof item === "object" && !isDisabledItem(item) && !(inactive ? inactive(item) : isInactiveItem(item)))
+        .map(item => optionKey(readField(item, valueKey))));
+    if (Array.isArray(value)) {
+        const kept = value.filter(one => offered.has(optionKey(one)));
+        return kept.length ? kept : undefined;
+    }
+    return offered.has(optionKey(value)) ? value : undefined;
+}
+/** A dropdown whose options come from `loadOptions` and that has no list of its own: it is asked what it offers. */
+export function isPickerInput(params) {
+    return params.type === EInputTypes.Dropdown && !listedOptions(params) && typeof params.loadOptions === "function";
+}
+/** The narrowing an input's options follow among these values (`narrowedBy`), or null when they follow none. */
+function narrowingAmong(params, read) {
+    const narrowing = params.narrowedBy;
+    if (!narrowing)
+        return null;
+    const fixed = narrowing.name === undefined;
+    const value = narrowingValue(fixed ? narrowing.value : read(narrowing.name));
+    return { key: narrowing.key ?? narrowing.name ?? "", value, orUnset: narrowing.orUnset === true };
+}
+const GONE = { status: "gone" };
+const UNKNOWN = { status: "unknown" };
+/** A value as its keys: a list's items, or the one value. */
+function keysOf(value) {
+    return (Array.isArray(value) ? value : [value]).map(optionKey).filter(key => key !== "");
+}
+/** The part of `value` whose keys are offered, in its own shape: the value, a shorter list, or undefined for none. */
+function offeredPart(value, offered) {
+    if (Array.isArray(value)) {
+        const kept = value.filter(one => offered.has(optionKey(one)));
+        return kept.length ? kept : undefined;
+    }
+    return offered.has(optionKey(value)) ? value : undefined;
+}
+/** A record the picker would let a person pick, its narrowing aside: not disabled, not inactive. */
+function pickable(params, record) {
+    const own = params;
+    return !isDisabledItem(record) && !(own.isOptionInactive ? own.isOptionInactive(record) : isInactiveItem(record));
+}
+/**
+ * Whether a record the picker answered is one it offers among these values: not disabled, not inactive (its
+ * `isOptionInactive`, else `inactive`/`isActive: false`), and inside its narrowing - the record's field holds the other
+ * input's value (or is empty, with `orUnset`). Undefined when the record does not carry the narrowing's field: only the
+ * picker's narrowed pages can tell then.
+ */
+function offersRecord(params, record, read) {
+    if (!pickable(params, record))
+        return false;
+    const narrowing = narrowingAmong(params, read);
+    if (!narrowing)
+        return true;
+    if (narrowing.value === null && !narrowing.orUnset)
+        return false;
+    if (!(narrowing.key in record))
+        return undefined;
+    const field = record[narrowing.key];
+    return (narrowing.value !== null && String(field) === String(narrowing.value)) || (narrowing.orUnset && (field === null || field === undefined || field === ""));
+}
+/** The records among `items` by key, each judged: true offered, false not, undefined not to be told from the record. */
+function judge(params, items, keys, read) {
+    const valueKey = params.valueKey ?? "value";
+    const found = new Map();
+    for (const key of keys) {
+        const record = items.find(item => optionKey(item[valueKey]) === key);
+        if (record)
+            found.set(key, offersRecord(params, record, read));
+    }
+    return found;
+}
+/**
+ * How a value stands with the input at once, with no call: an input's own list (narrowed as its `narrowedBy` says among
+ * these values) offers it or not; a picker by what it holds already (`peekOption`, fresh only); any other input takes
+ * it. Null when a picker must be asked (`findKeptStanding`).
+ */
+export function keptStandingNow(params, value, read = readNothing) {
+    if (isEmptyInputValue(params, value))
+        return GONE;
+    // Nothing to narrow by yet (the other input is empty): judged once it has a value, so neither opened nor forgotten.
+    const narrowing = narrowingAmong(params, read);
+    if (narrowing && narrowing.value === null && !narrowing.orUnset)
+        return UNKNOWN;
+    if (!isPickerInput(params)) {
+        const offered = offeredInputValue(narrowInputParams(params, params.narrowedBy?.name === undefined ? undefined : read(params.narrowedBy.name)), value);
+        return offered === undefined ? GONE : { status: "offered", value: offered };
+    }
+    const peek = params.peekOption;
+    if (!peek)
+        return null;
+    const keys = keysOf(value);
+    const records = keys.map(key => peek(key)).filter((record) => Boolean(record));
+    const judged = judge(params, records, keys, read);
+    if (keys.some(key => judged.get(key) === undefined))
+        return null;
+    const offered = offeredPart(value, new Set(keys.filter(key => judged.get(key) === true)));
+    return offered === undefined ? GONE : { status: "offered", value: offered };
+}
+/** The page size a kept value is looked for in, when the picker cannot name a record by its key. */
+const FIND_PAGE_SIZE = 50;
+/**
+ * Pages looked through for a kept value. A key not seen in them is no longer offered only when the list ended there; a
+ * longer list leaves it untold (`unknown`: neither opened nor forgotten).
+ */
+const FIND_PAGES = 20;
+/**
+ * The keys the picker's own pages (narrowed as the form narrows them) offer, read until each key showed or they end.
+ * A page ends the list as the box itself reads one: `hasMore: false`, an empty page, or (no `hasMore`) fewer items than
+ * the page size asked - the box would offer nothing past it either.
+ */
+async function offeredInPages(params, keys, read, signal) {
+    const narrowed = narrowInputParams(params, params.narrowedBy?.name === undefined ? undefined : read(params.narrowedBy.name));
+    const load = narrowed.loadOptions;
+    const offered = new Set();
+    if (!load)
+        return { offered, ended: true };
+    const valueKey = narrowed.valueKey ?? "value";
+    const wanted = new Set(keys);
+    for (let page = 1; page <= FIND_PAGES && wanted.size; page++) {
+        if (signal.aborted)
+            break;
+        const skip = (page - 1) * FIND_PAGE_SIZE;
+        const answer = await load({ search: "", page, skip, pageSize: FIND_PAGE_SIZE, signal });
+        for (const item of answer.items) {
+            const key = optionKey(item[valueKey]);
+            if (!wanted.has(key))
+                continue;
+            wanted.delete(key);
+            // The narrowed pages hold only the narrowing's records: one read there is judged on its own state alone.
+            if (pickable(params, item))
+                offered.add(key);
+        }
+        const more = answer.hasMore ?? answer.items.length >= FIND_PAGE_SIZE;
+        if (!more || answer.items.length === 0)
+            return { offered, ended: true };
+    }
+    // Every key showed (the rest of the list is not needed), or the pages ran out (or the ask stopped) before the end.
+    return { offered, ended: wanted.size === 0 };
+}
+/**
+ * How a value stands with the input, asking a picker when it must: by the value's key (`resolveOptions`, as a saved
+ * value is named) - a record found is judged on its own state and narrowing field - and, for a key it did not answer or
+ * a record without its narrowing's field, through its own pages narrowed as the form narrows them (a picker that names
+ * only what it already holds, such as a `crudPicker` with another `valueKey` and no `find`, answers nothing for a list
+ * not loaded yet: its pages tell). Never rejects: a picker that cannot be read answers `unknown`.
+ */
+export async function findKeptStanding(params, value, read, signal) {
+    const now = keptStandingNow(params, value, read);
+    if (now)
+        return now;
+    const own = params;
+    const keys = keysOf(value);
+    try {
+        let judged = new Map();
+        if (own.resolveOptions) {
+            const records = await own.resolveOptions(keys);
+            if (signal.aborted)
+                return UNKNOWN;
+            judged = judge(params, records, keys, read);
+        }
+        const untold = keys.filter(key => judged.get(key) === undefined);
+        if (untold.length) {
+            if (signal.aborted)
+                return UNKNOWN;
+            const pages = await offeredInPages(params, untold, read, signal);
+            if (signal.aborted)
+                return UNKNOWN;
+            // A key not seen before the pages ran out may stand further on: not known, so neither opened nor forgotten.
+            if (!pages.ended && untold.some(key => !pages.offered.has(key)))
+                return UNKNOWN;
+            for (const key of untold)
+                judged.set(key, pages.offered.has(key));
+        }
+        const offered = offeredPart(value, new Set(keys.filter(key => judged.get(key) === true)));
+        return offered === undefined ? GONE : { status: "offered", value: offered };
+    }
+    catch {
+        return UNKNOWN;
+    }
+}
+const NO_OPENING = { value: undefined, forget: false, ask: false };
+/**
+ * What a remembered input opens on among these values, at once where it can be told: the company's `preferred` value
+ * while the input offers it, else the person's last saved choice while it offers that, else none. `ask` when a picker
+ * must be asked first (`findRememberedOpening`). Nothing while its `when` does not hold.
+ */
+export function rememberedOpeningNow(params, stored, read = readNothing) {
+    const remember = params.remember;
+    if (!remember || !remembersHere(remember, read))
+        return NO_OPENING;
+    if (!isEmptyInputValue(params, remember.preferred)) {
+        const standing = keptStandingNow(params, remember.preferred, read);
+        if (!standing)
+            return { ...NO_OPENING, ask: true };
+        if (standing.status === "offered")
+            return { value: standing.value, forget: false, ask: false };
+    }
+    if (isEmptyInputValue(params, stored))
+        return NO_OPENING;
+    const standing = keptStandingNow(params, stored, read);
+    if (!standing)
+        return { ...NO_OPENING, ask: true };
+    if (standing.status === "offered")
+        return { value: standing.value, forget: false, ask: false };
+    return { value: undefined, forget: standing.status === "gone", ask: false };
+}
+/**
+ * The same, asking a picker by the values' keys where it must (`findKeptStanding`). Never rejects: a picker that could
+ * not be read opens nothing and forgets nothing.
+ */
+export async function findRememberedOpening(params, stored, read, signal) {
+    const remember = params.remember;
+    if (!remember || !remembersHere(remember, read))
+        return NO_OPENING;
+    if (!isEmptyInputValue(params, remember.preferred)) {
+        const standing = await findKeptStanding(params, remember.preferred, read, signal);
+        if (standing.status === "offered")
+            return { value: standing.value, forget: false, ask: false };
+    }
+    if (isEmptyInputValue(params, stored) || signal.aborted)
+        return NO_OPENING;
+    const standing = await findKeptStanding(params, stored, read, signal);
+    if (standing.status === "offered")
+        return { value: standing.value, forget: false, ask: false };
+    return { value: undefined, forget: standing.status === "gone", ask: false };
+}
+/**
+ * What a remembered input opens on when the form's values leave it empty, from its own list alone: the company's
+ * `preferred` value while the input offers it, else the person's last saved choice while it offers that, else undefined
+ * (the input keeps its own default). A value no longer offered is dropped without a word, never shown as a broken one.
+ * A picker's values are taken as they are here; a form asks the picker (`rememberedOpeningNow`).
+ */
+export function rememberedOpening(params, stored) {
+    const remember = params.remember;
+    if (!remember)
+        return undefined;
+    const preferred = offeredInputValue(params, remember.preferred);
+    if (preferred !== undefined)
+        return preferred;
+    return offeredInputValue(params, stored);
+}
+/**
+ * The row of a list a save keeps a row input's value from: the one added last that is still there, else none (no row
+ * was added, so no new choice was made). Keys in the order they were added.
+ */
+export function lastAddedRowKey(added, present) {
+    for (let index = added.length - 1; index >= 0; index--)
+        if (present(added[index]))
+            return added[index];
+    return null;
+}