nexus-shared 4.0.0 → 4.1.0

package/dist/Helpers/FormStore.js

@@ -1,5 +1,6 @@
 import { deleteFormDraft, readFormDraft, writeFormDraft } from "./FormDrafts.js";
 import { isComputedInput } from "./InputConditions.js";
+import { formNarrowingNames, inputNarrowingsOf, isEmptyNarrowed, narrowedFollowers } from "./InputNarrowing.js";
 import { findRememberedOpening, forgetInputMemory, isEmptyInputValue, isPickerInput, readInputMemory, rememberDependencies, rememberedOpeningNow, writeInputMemory } from "./InputMemory.js";
 import { holdsValue, initialInputValue, inputValuesEqual, isRowsInput, keepsTyping, normalizeInputValue, validateInput } from "./InputParamsHelpers.js";
 const INITIAL_STATUS = {
@@ -376,6 +377,21 @@ export class FormStore {
     setValues(values) {
         this.change(Object.entries(values), "code");
     }
+    /**
+     * Values a person set through another input - one worked out from them and typed in (`compute.solve`) - as one change.
+     * Their inputs show them at once, as values from code do, and they are taken as the person's own: the form's
+     * `onFieldChange` runs for them, and inputs narrowed by them lose what they picked. Nothing is taken while the values
+     * load. Answers whether anything changed.
+     */
+    setFromPerson(values) {
+        if (this.status.loading) {
+            this.refusedWhileLoading = true;
+            return false;
+        }
+        const before = this.values;
+        this.change(Object.entries(values), "person");
+        return this.values !== before;
+    }
     /**
      * A value the user typed or picked, from the input rendered with `stamp`, with what a choice input reported beside it
      * (`item`: a dropdown's option, kept for `pickedItem`). An input that was replaced since (by a value from code, a load,
@@ -812,7 +828,11 @@ export class FormStore {
                 this.changedNames.add(name);
         }
     }
-    change(entries, source) {
+    change(entries, changedBy) {
+        // A person's change through another input (`setFromPerson`) is written as code writes (its inputs mount again with
+        // it) and followed as typing is.
+        const source = changedBy === "code" ? "code" : "input";
+        const writtenAs = changedBy === "input" ? "input" : "code";
         const crossBefore = this.crossErrors;
         const shown = new Map();
         const remounted = new Set();
@@ -850,7 +870,7 @@ export class FormStore {
             written.push(name);
         };
         for (const [name, value] of entries)
-            write(name, value, source);
+            write(name, value, writtenAs);
         if (!written.length)
             return;
         // Values derived from the ones the user changed, such as an amount from a quantity and a rate.
@@ -869,20 +889,37 @@ export class FormStore {
         // chain too: a Country change clears the Region, and with it the District picked among that Region's (each input
         // once, whatever order the form lists them in; one the person set in this same change keeps its value).
         if (source === "input") {
-            const changed = new Set(written);
-            let cleared = true;
-            while (cleared) {
-                cleared = false;
-                for (const params of this.options.inputs) {
-                    const other = params.narrowedBy?.name;
-                    if (!other || !changed.has(other) || changed.has(params.name))
-                        continue;
-                    changed.add(params.name);
-                    cleared = true;
-                    const kept = this.values[params.name];
-                    if (kept !== undefined && kept !== null && kept !== "" && !(Array.isArray(kept) && kept.length === 0))
-                        write(params.name, null, "code");
-                }
+            const followers = narrowedFollowers(this.options.inputs, written, "form");
+            for (const name of followers) {
+                if (!isEmptyNarrowed(this.values[name]))
+                    write(name, null, "code");
+            }
+            // Rows whose inputs follow a form value (`from: "form"`, a line's Tags of the form's Store): every row loses what
+            // it picked among the old value's options, and down the row's own chain.
+            const changedNow = new Set([...written, ...followers]);
+            for (const params of this.options.inputs) {
+                if (!isRowsInput(params))
+                    continue;
+                const rowInputs = params.inputs ?? [];
+                if (!formNarrowingNames(rowInputs).some(name => changedNow.has(name)))
+                    continue;
+                const clear = narrowedFollowers(rowInputs, changedNow, "rows-of-form");
+                const rows = this.values[params.name];
+                if (!clear.length || !Array.isArray(rows))
+                    continue;
+                let touched = false;
+                const next = rows.map(row => {
+                    if (row === null || typeof row !== "object")
+                        return row;
+                    const filled = clear.filter(name => !isEmptyNarrowed(row[name]));
+                    if (!filled.length)
+                        return row;
+                    touched = true;
+                    // Each cleared as its input holds nothing: an empty list for a picker of several.
+                    return { ...row, ...Object.fromEntries(filled.map(name => [name, emptyRowValue(rowInputs, name)])) };
+                });
+                if (touched)
+                    write(params.name, next, "code");
             }
         }
         // Inputs that follow a changed one (`dependsOn`) draw again with their params read afresh, and their rule is asked
@@ -900,20 +937,25 @@ export class FormStore {
             if (remounted.has(name) || followers.has(name) || unasked.includes(name) || this.shownError(name) !== before)
                 this.bump(name);
         this.patchStatus({ changed: this.changedNames.size > 0, message: this.formMessage(), problems: this.problemList() });
-        this.emit(source === "input" ? written[0] : written.length === 1 ? written[0] : null);
+        this.emit(changedBy === "input" ? written[0] : written.length === 1 ? written[0] : null);
         // A change after a cancel is worth keeping again.
         if (source === "input")
             this.draftDropped = false;
         this.scheduleDraft();
     }
-    /** The inputs whose `dependsOn` (or `narrowedBy`) names any of `names`. */
+    /**
+     * The inputs whose `dependsOn` (or `narrowedBy`) names any of `names`, and the rows inputs whose row inputs are narrowed
+     * by one of them `from: "form"`: their rows draw again with the form's value as it is now.
+     */
     followersOf(names) {
         const found = new Set();
         if (!names.length)
             return found;
         const changed = new Set(names);
         for (const params of this.options.inputs) {
-            if (params.dependsOn?.some(name => changed.has(name)) || (params.narrowedBy?.name !== undefined && changed.has(params.narrowedBy.name)))
+            if (params.dependsOn?.some(name => changed.has(name)) || inputNarrowingsOf(params).some(narrowing => changed.has(narrowing.name)))
+                found.add(params.name);
+            else if (isRowsInput(params) && formNarrowingNames(params.inputs ?? []).some(name => changed.has(name)))
                 found.add(params.name);
         }
         return found;
@@ -1066,3 +1108,8 @@ export class FormStore {
         this.patchStatus({ restored: { savedAt: draft.savedAt, names: entries.map(([name]) => name), conflicts }, draftSavedAt: draft.savedAt });
     }
 }
+/** A row input's value when nothing is picked: as the rows hold it (an empty list for a picker of several). */
+function emptyRowValue(rowInputs, name) {
+    const params = rowInputs.find(input => input.name === name);
+    return params ? normalizeInputValue(params, null) : null;
+}

package/dist/Helpers/InputConditions.d.ts

@@ -35,6 +35,12 @@ export declare function spanFor(spanWhen: InputSpanWhen | undefined, read: (name
  * @example withInputConditions(inputs, name => store.get(name))
  */
 export declare function withInputConditions(inputs: readonly InputParams[], read: (name: string) => unknown): readonly InputParams[];
+/**
+ * The inputs with each worked-out one's `dependsOn` joined by the inputs it is worked out from (`compute.from`), so what
+ * follows `dependsOn` - a row's cells (`RowsStore`), as a form's do through `withInputConditions` - draws it again when
+ * one of them changes. The same array when none is worked out from another, and the same copy for the same array.
+ */
+export declare function withComputeSources(inputs: readonly InputParams[]): readonly InputParams[];
 /** Whether the input is worked out from others (`compute`): it holds no value of the form's and is never typed in. */
 export declare function isComputedInput(params: InputParams | undefined): boolean;
 /**

package/dist/Helpers/InputConditions.js

@@ -129,6 +129,30 @@ export function withInputConditions(inputs, read) {
     });
 }
 /* Inputs worked out from others (`compute`) */
+const joinedSources = new WeakMap();
+/**
+ * The inputs with each worked-out one's `dependsOn` joined by the inputs it is worked out from (`compute.from`), so what
+ * follows `dependsOn` - a row's cells (`RowsStore`), as a form's do through `withInputConditions` - draws it again when
+ * one of them changes. The same array when none is worked out from another, and the same copy for the same array.
+ */
+export function withComputeSources(inputs) {
+    if (!inputs.some(params => params.compute?.from.length))
+        return inputs;
+    let joined = joinedSources.get(inputs);
+    if (!joined) {
+        joined = inputs.map(params => {
+            if (!params.compute?.from.length)
+                return params;
+            // Descriptors, never a spread: a getter (`get readOnly()`) is still read as the input draws.
+            const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(params));
+            const follows = [...new Set([...(params.dependsOn ?? []), ...params.compute.from])];
+            Object.defineProperty(copy, "dependsOn", { value: follows, enumerable: true, configurable: true, writable: true });
+            return copy;
+        });
+        joinedSources.set(inputs, joined);
+    }
+    return joined;
+}
 /** 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);

package/dist/Helpers/InputMemory.js

@@ -1,7 +1,7 @@
 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 { inputNarrowingsOf, narrowInputParamsBy, narrowingsOf, 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
@@ -20,8 +20,8 @@ const readNothing = () => undefined;
  */
 export function rememberDependencies(params) {
     const names = new Set();
-    if (params.narrowedBy?.name !== undefined)
-        names.add(params.narrowedBy.name);
+    for (const narrowing of inputNarrowingsOf(params))
+        names.add(narrowing.name);
     if (params.remember?.per)
         names.add(params.remember.per);
     for (const condition of conditionsOf(params.remember?.when))
@@ -145,15 +145,16 @@ export function offeredInputValue(params, value) {
 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 };
+/** The narrowings an input's options follow among these values (`narrowedBy`, one or several): none when they follow none. */
+function narrowingsAmong(params, read) {
+    return narrowingsOf(params).map(narrowing => {
+        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 };
+    });
 }
+/** The input's params narrowed among these values, as the form narrows them as it draws. */
+const narrowedAmong = (params, read) => narrowInputParamsBy(params, narrowing => ({ value: read(narrowing.name) }));
 const GONE = { status: "gone" };
 const UNKNOWN = { status: "unknown" };
 /** A value as its keys: a list's items, or the one value. */
@@ -182,15 +183,20 @@ function pickable(params, record) {
 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 === ""));
+    // Inside every narrowing: false at the first it falls outside, undefined when one cannot be told from the record.
+    let told = true;
+    for (const narrowing of narrowingsAmong(params, read)) {
+        if (narrowing.value === null && !narrowing.orUnset)
+            return false;
+        if (!(narrowing.key in record)) {
+            told = undefined;
+            continue;
+        }
+        const field = record[narrowing.key];
+        if (!((narrowing.value !== null && String(field) === String(narrowing.value)) || (narrowing.orUnset && (field === null || field === undefined || field === ""))))
+            return false;
+    }
+    return told;
 }
 /** 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) {
@@ -212,11 +218,10 @@ 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)
+    if (narrowingsAmong(params, read).some(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);
+        const offered = offeredInputValue(narrowedAmong(params, read), value);
         return offered === undefined ? GONE : { status: "offered", value: offered };
     }
     const peek = params.peekOption;
@@ -230,7 +235,10 @@ export function keptStandingNow(params, value, read = readNothing) {
     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. */
+/**
+ * The page size a kept value is looked for in, when the picker cannot name a record by its key and gives no `pageSize`
+ * of its own: the box's default.
+ */
 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
@@ -239,22 +247,24 @@ const FIND_PAGE_SIZE = 50;
 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.
+ * The pages are asked in the box's own size (its `pageSize`), and one ends the list as the box itself reads it:
+ * `hasMore: false`, an empty page, or (no `hasMore`) fewer items than that size - the box would offer nothing past it
+ * either. So a loader that pages by the size it is asked, or by the box's, ends where the box's list ends.
  */
 async function offeredInPages(params, keys, read, signal) {
-    const narrowed = narrowInputParams(params, params.narrowedBy?.name === undefined ? undefined : read(params.narrowedBy.name));
+    const narrowed = narrowedAmong(params, read);
     const load = narrowed.loadOptions;
     const offered = new Set();
     if (!load)
         return { offered, ended: true };
     const valueKey = narrowed.valueKey ?? "value";
+    const size = typeof narrowed.pageSize === "number" && narrowed.pageSize >= 1 ? Math.floor(narrowed.pageSize) : FIND_PAGE_SIZE;
     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 });
+        const skip = (page - 1) * size;
+        const answer = await load({ search: "", page, skip, pageSize: size, signal });
         for (const item of answer.items) {
             const key = optionKey(item[valueKey]);
             if (!wanted.has(key))
@@ -264,7 +274,7 @@ async function offeredInPages(params, keys, read, signal) {
             if (pickable(params, item))
                 offered.add(key);
         }
-        const more = answer.hasMore ?? answer.items.length >= FIND_PAGE_SIZE;
+        const more = answer.hasMore ?? answer.items.length >= size;
         if (!more || answer.items.length === 0)
             return { offered, ended: true };
     }

package/dist/Helpers/InputNarrowing.d.ts

@@ -1,18 +1,50 @@
-import type { InputNarrowing, InputParams } from "../Interfaces/FormInterfaces.ts";
+import type { InputNarrowing, InputNarrowingByInput, InputParams } from "../Interfaces/FormInterfaces.ts";
 import type { OptionValue } from "../Interfaces/InputInterfaces.ts";
 /** The value that narrows, or null while the other input has none: an empty text, an empty list and `false` count as none. */
 export declare function narrowingValue(value: unknown): OptionValue | null;
+/** Every narrowing of an input's options: none, one, or several at once (a list). */
+export declare function narrowingsOf(params: Pick<InputParams, "narrowedBy">): readonly InputNarrowing[];
+/** The narrowings that follow another input (not a fixed value). */
+export declare function inputNarrowingsOf(params: Pick<InputParams, "narrowedBy">): readonly InputNarrowingByInput[];
 /** What a narrowed box says while the other input is empty: "Pick a group first". */
 export declare function narrowingPlaceholder(narrowing: InputNarrowing, otherLabel: unknown): string;
 /** A narrowing by a fixed value (`{ key, value }`), not by another input. */
 export declare function isFixedNarrowing(narrowing: InputNarrowing): boolean;
+/** What a narrowing by another input reads: that input's value now, and its label for "Pick a store first". */
+export type NarrowingRead = (narrowing: InputNarrowingByInput) => {
+    value: unknown;
+    label?: unknown;
+};
 /**
- * An input's params narrowed by the other input's value as it is now (or by the fixed `value` the narrowing gives): static `options` filtered to the records whose
- * `key` field holds it; `loadOptions` asked with `request.narrow` (crudPicker reads it: from the server when its
- * endpoint takes the parent, else from the list it keeps, narrowed in the browser), and a `loadKey` of its own per
- * value, so the list loads afresh when the other value changes. While the other input is empty, no option is offered
- * and the box says what to pick first. Params without `narrowedBy` are answered as they are.
+ * An input's params narrowed by the other inputs' values as they are now (and by the fixed values its narrowings give):
+ * static `options` filtered to the records whose fields hold every value; `loadOptions` asked with `request.narrow` (the
+ * first) and, for several, `request.narrows` (every one) - crudPicker reads them: from the server when its endpoint takes
+ * them, else from the list it keeps, narrowed in the browser - and a `loadKey` of its own per values, so the list loads
+ * afresh when any changes. While one is empty no option is offered and the box says what to pick first. Params without
+ * `narrowedBy` are answered as they are.
+ *
+ * @example narrowInputParamsBy(tagsParams, narrowing => ({ value: narrowing.from === "form" ? form.get(narrowing.name) : row[narrowing.name] }))
+ */
+export declare function narrowInputParamsBy(params: InputParams, read: NarrowingRead): InputParams;
+/**
+ * An input's params narrowed by one other input's value as it is now (or by the fixed `value` its narrowing gives), as
+ * `narrowInputParamsBy` does: every narrowing by an input reads `otherValue`. For several other inputs, use that.
  *
  * @example narrowInputParams(packageParams, form.get("subscriptionGroupId"), "Group")
  */
 export declare function narrowInputParams(params: InputParams, otherValue: unknown, otherLabel?: unknown): InputParams;
+/** Whether a narrowed input holds nothing to clear: no value, an empty text or an empty list. */
+export declare function isEmptyNarrowed(value: unknown): boolean;
+/** The inputs of the form around rows that the rows' inputs narrow by (`from: "form"`): the document's Store. */
+export declare function formNarrowingNames(rowInputs: readonly InputParams[]): string[];
+/**
+ * The inputs whose value a person's change of `changed` clears: those narrowed by one of them, and down the chain (a
+ * Country clears the Region, and with it the District picked among that Region's), each once, in the inputs' order;
+ * one in `changed` itself keeps its value. Where the change is:
+ *
+ * - `form`: in a form, its inputs' narrowings by name;
+ * - `row`: in a row, the row's own (`from` left out, or `"row"`);
+ * - `rows-of-form`: in every row, after a change of the form around them - first the row inputs narrowed `from: "form"`
+ *   by one of `changed`, then down the row's own chain.
+ */
+export declare function narrowedFollowers(inputs: readonly InputParams[], changed: Iterable<string>, where: "form" | "row" | "rows-of-form"): string[];

package/dist/Helpers/InputNarrowing.js

@@ -1,7 +1,8 @@
 /*
  * Options narrowed by another input's value (`narrowedBy`): a Package list of the Group picked, a Sub-region list of the
- * Country picked. The form reads the other value as it draws and hands the input its params narrowed by it (this file,
- * pure, so Node tests run it); the form's store clears the input's value when the other one changes (FormStore).
+ * Country picked, a line's asset Tags of the line's Item in the form's Store. The form (or the rows) reads the other
+ * values as it draws and hands the input its params narrowed by them (this file, pure, so Node tests run it); the form's
+ * store, and the rows' for a row's own, clear a value when a person changes one it follows (`narrowedFollowers`).
  */
 /** The value that narrows, or null while the other input has none: an empty text, an empty list and `false` count as none. */
 export function narrowingValue(value) {
@@ -13,6 +14,17 @@ export function narrowingValue(value) {
         return value;
     return null;
 }
+/** Every narrowing of an input's options: none, one, or several at once (a list). */
+export function narrowingsOf(params) {
+    const given = params.narrowedBy;
+    if (!given)
+        return [];
+    return Array.isArray(given) ? given : [given];
+}
+/** The narrowings that follow another input (not a fixed value). */
+export function inputNarrowingsOf(params) {
+    return narrowingsOf(params).filter((narrowing) => narrowing.name !== undefined);
+}
 /** What a narrowed box says while the other input is empty: "Pick a group first". */
 export function narrowingPlaceholder(narrowing, otherLabel) {
     if (narrowing.placeholder)
@@ -28,40 +40,109 @@ export function isFixedNarrowing(narrowing) {
     return narrowing.name === undefined;
 }
 /**
- * An input's params narrowed by the other input's value as it is now (or by the fixed `value` the narrowing gives): static `options` filtered to the records whose
- * `key` field holds it; `loadOptions` asked with `request.narrow` (crudPicker reads it: from the server when its
- * endpoint takes the parent, else from the list it keeps, narrowed in the browser), and a `loadKey` of its own per
- * value, so the list loads afresh when the other value changes. While the other input is empty, no option is offered
- * and the box says what to pick first. Params without `narrowedBy` are answered as they are.
+ * An input's params narrowed by the other inputs' values as they are now (and by the fixed values its narrowings give):
+ * static `options` filtered to the records whose fields hold every value; `loadOptions` asked with `request.narrow` (the
+ * first) and, for several, `request.narrows` (every one) - crudPicker reads them: from the server when its endpoint takes
+ * them, else from the list it keeps, narrowed in the browser - and a `loadKey` of its own per values, so the list loads
+ * afresh when any changes. While one is empty no option is offered and the box says what to pick first. Params without
+ * `narrowedBy` are answered as they are.
  *
- * @example narrowInputParams(packageParams, form.get("subscriptionGroupId"), "Group")
+ * @example narrowInputParamsBy(tagsParams, narrowing => ({ value: narrowing.from === "form" ? form.get(narrowing.name) : row[narrowing.name] }))
  */
-export function narrowInputParams(params, otherValue, otherLabel) {
-    const narrowing = params.narrowedBy;
-    if (!narrowing)
+export function narrowInputParamsBy(params, read) {
+    const narrowings = narrowingsOf(params);
+    if (narrowings.length === 0)
         return params;
-    const fixed = narrowing.name === undefined;
-    const key = narrowing.key ?? narrowing.name ?? "";
-    const value = narrowingValue(fixed ? narrowing.value : otherValue);
-    const orUnset = narrowing.orUnset === true;
+    const parts = narrowings.map(narrowing => {
+        const other = narrowing.name === undefined ? null : read(narrowing);
+        return {
+            narrowing,
+            key: narrowing.key ?? narrowing.name ?? "",
+            value: narrowingValue(other === null ? narrowing.value : other.value),
+            orUnset: narrowing.orUnset === true,
+            label: other?.label,
+        };
+    });
     const keeps = (item) => {
         if (item === null || typeof item !== "object")
             return false;
-        const field = item[key];
-        return (value !== null && String(field) === String(value)) || (orUnset && (field === null || field === undefined || field === ""));
+        return parts.every(({ key, value, orUnset }) => {
+            const field = item[key];
+            return (value !== null && String(field) === String(value)) || (orUnset && (field === null || field === undefined || field === ""));
+        });
     };
     const own = params;
-    const narrowed = { ...own, loadKey: `${own.loadKey === undefined ? "" : String(own.loadKey)}|${narrowing.name ?? key}=${value === null ? "" : String(value)}` };
-    const placeholder = value === null ? narrowingPlaceholder(narrowing, otherLabel) : "";
+    const keyed = parts.map(part => `|${part.narrowing.name ?? part.key}=${part.value === null ? "" : String(part.value)}`).join("");
+    const narrowed = { ...own, loadKey: `${own.loadKey === undefined ? "" : String(own.loadKey)}${keyed}` };
+    // The first narrowing with nothing to narrow by says what to pick first.
+    const waiting = parts.find(part => part.value === null);
+    const placeholder = waiting ? narrowingPlaceholder(waiting.narrowing, waiting.label) : "";
     if (placeholder)
         narrowed.placeholder = placeholder;
     // Nothing to narrow by offers nothing, unless the options with no value in the field are offered too (`orUnset`).
-    const none = value === null && !orUnset;
+    const none = parts.some(part => part.value === null && !part.orUnset);
     if (Array.isArray(own.options))
         narrowed.options = none ? [] : own.options.filter(keeps);
     const load = own.loadOptions;
     if (load) {
-        narrowed.loadOptions = (request) => (none ? Promise.resolve(EMPTY_PAGE) : load({ ...request, narrow: { key, value, ...(orUnset && { orUnset }) } }));
+        const asked = parts.map(({ key, value, orUnset }) => ({ key, value, ...(orUnset && { orUnset }) }));
+        narrowed.loadOptions = (request) => (none ? Promise.resolve(EMPTY_PAGE) : load({ ...request, narrow: asked[0], ...(asked.length > 1 && { narrows: asked }) }));
     }
     return narrowed;
 }
+/**
+ * An input's params narrowed by one other input's value as it is now (or by the fixed `value` its narrowing gives), as
+ * `narrowInputParamsBy` does: every narrowing by an input reads `otherValue`. For several other inputs, use that.
+ *
+ * @example narrowInputParams(packageParams, form.get("subscriptionGroupId"), "Group")
+ */
+export function narrowInputParams(params, otherValue, otherLabel) {
+    return narrowInputParamsBy(params, () => ({ value: otherValue, label: otherLabel }));
+}
+/** Whether a narrowed input holds nothing to clear: no value, an empty text or an empty list. */
+export function isEmptyNarrowed(value) {
+    return value === undefined || value === null || value === "" || (Array.isArray(value) && value.length === 0);
+}
+/** The inputs of the form around rows that the rows' inputs narrow by (`from: "form"`): the document's Store. */
+export function formNarrowingNames(rowInputs) {
+    const names = new Set();
+    for (const params of rowInputs)
+        for (const narrowing of inputNarrowingsOf(params))
+            if (narrowing.from === "form")
+                names.add(narrowing.name);
+    return [...names];
+}
+/**
+ * The inputs whose value a person's change of `changed` clears: those narrowed by one of them, and down the chain (a
+ * Country clears the Region, and with it the District picked among that Region's), each once, in the inputs' order;
+ * one in `changed` itself keeps its value. Where the change is:
+ *
+ * - `form`: in a form, its inputs' narrowings by name;
+ * - `row`: in a row, the row's own (`from` left out, or `"row"`);
+ * - `rows-of-form`: in every row, after a change of the form around them - first the row inputs narrowed `from: "form"`
+ *   by one of `changed`, then down the row's own chain.
+ */
+export function narrowedFollowers(inputs, changed, where) {
+    const fromForm = where === "rows-of-form" ? new Set(changed) : new Set();
+    const done = where === "rows-of-form" ? new Set() : new Set(changed);
+    const followers = [];
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const params of inputs) {
+            if (done.has(params.name))
+                continue;
+            const follows = inputNarrowingsOf(params).some(narrowing => {
+                if (where === "form")
+                    return done.has(narrowing.name);
+                return narrowing.from === "form" ? fromForm.has(narrowing.name) : done.has(narrowing.name);
+            });
+            if (!follows)
+                continue;
+            done.add(params.name);
+            followers.push(params.name);
+            grew = true;
+        }
+    }
+    return followers;
+}