nexus-shared 3.0.0 → 3.2.0

package/dist/Helpers/ExcelBackend.js

@@ -53,8 +53,8 @@ export class NexusExcelBackend extends ExcelBackend {
     get uploadField() {
         return "file";
     }
-    importRequest(rows) {
-        return { rows };
+    importRequest(rows, recordStatus) {
+        return recordStatus === undefined ? { rows } : { rows, recordStatus };
     }
     /**
      * The same request a Nexus listing takes, minus `skipCount` and `maxCount`: an export writes every row the search
@@ -79,6 +79,10 @@ export class NexusExcelBackend extends ExcelBackend {
             maxImportRows: count(answer.maxImportRows, DEFAULT_MAX_IMPORT_ROWS),
             columns: readColumns(answer.columns),
             inputs: Array.isArray(answer.inputs) ? answer.inputs : [],
+            recordStatuses: Array.isArray(answer.recordStatuses)
+                ? answer.recordStatuses.filter(isRecord).flatMap(status => (typeof status.value === "number" && typeof status.label === "string" ? [{ value: status.value, label: status.label }] : []))
+                : [],
+            defaultRecordStatus: typeof answer.defaultRecordStatus === "number" ? answer.defaultRecordStatus : undefined,
         };
     }
     readVerify(result) {
@@ -233,6 +237,8 @@ export function readExcelResponse(body, status) {
                 messageCode: text(first.messageCode) ?? undefined,
                 errorCode: first.errorCode === undefined ? undefined : count(first.errorCode),
                 ...(Object.keys(errors).length ? { errors } : {}),
+                // An import that wrote nothing still says, row by row, what it refused and why (XLS_X044): keep that report.
+                ...(isRecord(body.result) ? { result: body.result } : {}),
             };
         }
     }

package/dist/Helpers/ExcelHelpers.d.ts

@@ -8,11 +8,14 @@ export declare const EXCEL_ROW_NUMBER = "__excelRow";
 export declare const EXCEL_ROW_KEYS = "__excelKeys";
 /** The field of an editor row that holds what the verify answered for it, so an edit can be told from an untouched row. */
 export declare const EXCEL_ROW_SENT = "__excelSent";
-/** One row of a review editor: a value per column, plus the three fields the editor carries for itself. */
+/**
+ * One row of a review editor: a value per column, plus the three fields the editor carries for itself. A row added in
+ * the browser - by Add, Insert or Duplicate, or every row of a bulk insert - has none of the three, or only some.
+ */
 export interface ExcelEditorRow {
-    [EXCEL_ROW_NUMBER]: number;
-    [EXCEL_ROW_KEYS]: Record<string, string | null>;
-    [EXCEL_ROW_SENT]: Record<string, string | null>;
+    [EXCEL_ROW_NUMBER]?: number;
+    [EXCEL_ROW_KEYS]?: Record<string, string | null>;
+    [EXCEL_ROW_SENT]?: Record<string, string | null>;
     [field: string]: unknown;
 }
 declare const DEFAULT_TEXT: {
@@ -25,7 +28,15 @@ declare const DEFAULT_TEXT: {
     readonly verifyFailed: "The file could not be read.";
     readonly newRows: "New rows";
     readonly duplicates: "Already there";
-    readonly duplicateHint: "Nothing here is updated. Edit a row to add it as a new record instead.";
+    readonly duplicateHint: "Already records: these are skipped, and nothing here is updated.";
+    readonly failedHead: "Not written";
+    readonly skippedHead: "Skipped: already there";
+    readonly importAgain: "To import another file, start over.";
+    readonly addAgain: "To add more, start over.";
+    readonly bulkUnavailable: "The sheet's columns could not be read, so there is nothing to type the rows into.";
+    readonly discardTitle: "Discard what you typed?";
+    readonly discardLabel: "Discard";
+    readonly keepEditing: "Keep editing";
     readonly toFix: "What needs fixing";
     readonly whyDuplicate: "Why these are already there";
     readonly referenceLocked: "Picked in the spreadsheet: this list belongs to the server.";
@@ -66,18 +77,35 @@ export declare function isExcelColumnEditable(column: ExcelColumnInfo): boolean;
  * A reference cell shows the **words** the person picked, because its key is not something anybody reads or types.
  */
 export declare function excelEditorRows(rows: readonly ExcelReviewRow[], columns: readonly ExcelColumnInfo[]): ExcelEditorRow[];
+/** The sheet row a row came from, or 0 for a row added in the browser. */
+export declare function excelRowNumber(row: ExcelEditorRow): number;
 /**
  * The editors' rows as rows to send: every value as text, every reference as the key it came with, and the sheet's own
  * row number kept so a problem can still name where it is.
  *
  * A cell the person did not touch goes back **exactly** as it came, which is what makes the round trip faithful: the
  * backend reads its own text again, not a number an input rewrote on the way through.
+ *
+ * A row added in the browser has no sheet row, so it is numbered after the last one the sheet had: no two rows share a
+ * number, and a problem still names the row it is about. `after` is that last row - the file's, rows already there and
+ * rows taken out of the review included, which are not among the rows sent. A bulk insert, with no sheet at all,
+ * numbers its rows 1, 2, 3.
  */
-export declare function excelSheetRows(rows: readonly ExcelEditorRow[], columns: readonly ExcelColumnInfo[]): ExcelSheetRow[];
+export declare function excelSheetRows(rows: readonly ExcelEditorRow[], columns: readonly ExcelColumnInfo[], after?: number): ExcelSheetRow[];
 /** Whether the person changed anything in a row since the verify answered it. */
 export declare function isExcelRowEdited(row: ExcelEditorRow, columns: readonly ExcelColumnInfo[]): boolean;
-/** Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). */
-export declare function excelProblemPlace(problem: ExcelCellProblem): string;
+/** Whether a row has anything in a cell the person types in. A row added and left empty has not, and is not sent. */
+export declare function hasExcelValues(row: ExcelEditorRow, columns: readonly ExcelColumnInfo[]): boolean;
+/**
+ * Whether a row holds something only this screen has, which closing it would lose: a sheet's row the person edited, or
+ * a row added here with anything in it.
+ */
+export declare function isExcelRowTyped(row: ExcelEditorRow, columns: readonly ExcelColumnInfo[]): boolean;
+/**
+ * Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). Rows
+ * typed in the browser have no sheet, so `byRow` names the row instead ("Row 3 - City name").
+ */
+export declare function excelProblemPlace(problem: ExcelCellProblem, byRow?: boolean): string;
 /** Every problem of these rows, in the order the rows read. */
 export declare function excelProblems(rows: readonly ExcelReviewRow[]): ExcelCellProblem[];
 /** The rows of one kind. */

package/dist/Helpers/ExcelHelpers.js

@@ -1,4 +1,6 @@
 import { ExcelDataType, ExcelRowKind } from "../Interfaces/ExcelInterfaces.js";
+import { toIsoDate } from "./DateHelpers.js";
+import { toIsoTime } from "./TimeHelpers.js";
 /*
  * Turning a sheet's columns into inputs, a verify's rows into editable rows and back, and handing the person a file.
  * Nothing here calls anything: the calls are in Services/ExcelApi.ts.
@@ -28,7 +30,15 @@ const DEFAULT_TEXT = {
     verifyFailed: "The file could not be read.",
     newRows: "New rows",
     duplicates: "Already there",
-    duplicateHint: "Nothing here is updated. Edit a row to add it as a new record instead.",
+    duplicateHint: "Already records: these are skipped, and nothing here is updated.",
+    failedHead: "Not written",
+    skippedHead: "Skipped: already there",
+    importAgain: "To import another file, start over.",
+    addAgain: "To add more, start over.",
+    bulkUnavailable: "The sheet's columns could not be read, so there is nothing to type the rows into.",
+    discardTitle: "Discard what you typed?",
+    discardLabel: "Discard",
+    keepEditing: "Keep editing",
     toFix: "What needs fixing",
     whyDuplicate: "Why these are already there",
     referenceLocked: "Picked in the spreadsheet: this list belongs to the server.",
@@ -159,12 +169,15 @@ export function excelEditorRows(rows, columns) {
 /** Which types are drawn by a number box, whose empty value is `null`. */
 const NUMBER_TYPES = new Set([ExcelDataType.WholeNumber, ExcelDataType.Decimal, ExcelDataType.Amount]);
 /**
- * A cell's text as the input that draws it wants it: a number as a number, a choice unset rather than empty, and
- * everything else as it reads.
+ * A cell's text as the input that draws it wants it: a number as a number, a choice unset rather than empty, a date
+ * and a time as the inputs hold them, and everything else as it reads.
  *
  * The three empties are not interchangeable. A number box is empty at `null`; a **dropdown** given `""` treats it as a
  * value and reports it as one its list no longer offers ("Not found"), so an empty choice has to be left unset; a text
  * or date box is empty at `""`.
+ *
+ * A date and a time are read the way their inputs read them: the sheet's "09:30:00" is the time box's "09:30". Read
+ * any other way, a cell nobody touched would compare as an edit - and the panel would ask before closing over it.
  */
 function toInputValue(column, value) {
     if (value === null || value === "")
@@ -184,6 +197,10 @@ function toInputValue(column, value) {
                 return "No";
             return value;
         }
+        case ExcelDataType.Date:
+            return toIsoDate(value) ?? value;
+        case ExcelDataType.Time:
+            return toIsoTime(value) ?? value;
         default:
             return value;
     }
@@ -210,17 +227,28 @@ function isSameCell(column, current, sent) {
         return true;
     return toInputValue(column, asSheet) === toInputValue(column, sent ?? null);
 }
+/** The sheet row a row came from, or 0 for a row added in the browser. */
+export function excelRowNumber(row) {
+    const number = Number(row[EXCEL_ROW_NUMBER]);
+    return Number.isFinite(number) && number > 0 ? number : 0;
+}
 /**
  * The editors' rows as rows to send: every value as text, every reference as the key it came with, and the sheet's own
  * row number kept so a problem can still name where it is.
  *
  * A cell the person did not touch goes back **exactly** as it came, which is what makes the round trip faithful: the
  * backend reads its own text again, not a number an input rewrote on the way through.
+ *
+ * A row added in the browser has no sheet row, so it is numbered after the last one the sheet had: no two rows share a
+ * number, and a problem still names the row it is about. `after` is that last row - the file's, rows already there and
+ * rows taken out of the review included, which are not among the rows sent. A bulk insert, with no sheet at all,
+ * numbers its rows 1, 2, 3.
  */
-export function excelSheetRows(rows, columns) {
-    return rows.map((row, index) => {
-        const keys = (row[EXCEL_ROW_KEYS] ?? {});
-        const sent = (row[EXCEL_ROW_SENT] ?? {});
+export function excelSheetRows(rows, columns, after = 0) {
+    let next = rows.reduce((last, row) => Math.max(last, excelRowNumber(row)), Math.max(0, after));
+    return rows.map(row => {
+        const keys = row[EXCEL_ROW_KEYS] ?? {};
+        const sent = row[EXCEL_ROW_SENT] ?? {};
         const values = {};
         const labels = {};
         for (const column of columns) {
@@ -231,13 +259,12 @@ export function excelSheetRows(rows, columns) {
             }
             values[column.field] = isSameCell(column, row[column.field], sent[column.field]) ? (sent[column.field] ?? null) : toSheetValue(row[column.field]);
         }
-        const number = Number(row[EXCEL_ROW_NUMBER]);
-        return { number: Number.isFinite(number) && number > 0 ? number : index + 1, values, labels };
+        return { number: excelRowNumber(row) || ++next, values, labels };
     });
 }
 /** Whether the person changed anything in a row since the verify answered it. */
 export function isExcelRowEdited(row, columns) {
-    const sent = (row[EXCEL_ROW_SENT] ?? {});
+    const sent = row[EXCEL_ROW_SENT] ?? {};
     for (const column of columns) {
         if (!isExcelColumnEditable(column))
             continue;
@@ -246,10 +273,25 @@ export function isExcelRowEdited(row, columns) {
     }
     return false;
 }
+/** Whether a row has anything in a cell the person types in. A row added and left empty has not, and is not sent. */
+export function hasExcelValues(row, columns) {
+    return columns.some(column => isExcelColumnEditable(column) && toSheetValue(row[column.field]) !== null);
+}
+/**
+ * Whether a row holds something only this screen has, which closing it would lose: a sheet's row the person edited, or
+ * a row added here with anything in it.
+ */
+export function isExcelRowTyped(row, columns) {
+    return excelRowNumber(row) > 0 ? isExcelRowEdited(row, columns) : hasExcelValues(row, columns);
+}
 /* What is wrong, in the person's words */
-/** Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). */
-export function excelProblemPlace(problem) {
-    return problem.cell ? `${problem.cell} ${String.fromCharCode(183)} ${problem.header}` : problem.header;
+/**
+ * Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). Rows
+ * typed in the browser have no sheet, so `byRow` names the row instead ("Row 3 - City name").
+ */
+export function excelProblemPlace(problem, byRow = false) {
+    const place = byRow ? `Row ${problem.row}` : problem.cell;
+    return place ? `${place} ${String.fromCharCode(183)} ${problem.header}` : problem.header;
 }
 /** Every problem of these rows, in the order the rows read. */
 export function excelProblems(rows) {

package/dist/Helpers/FormStore.d.ts

@@ -25,7 +25,7 @@ export interface FormStatus {
     changed: boolean;
     /** A submit is running. */
     submitting: boolean;
-    /** The values are loading: the inputs show placeholders. */
+    /** The values are loading: the inputs show, disabled, and take nothing typed until the values are in. */
     loading: boolean;
     /** A submit ran and found problems: every message shows. */
     showAll: boolean;
@@ -85,6 +85,8 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     private draftSeq;
     /** The user cancelled: no draft is written until they change a value again. */
     private draftDropped;
+    /** An input reported a value while the values loaded and was refused: it is drawn again from the store when loading ends. */
+    private refusedWhileLoading;
     /** A load during a render tells nobody; `announce` does, once the form has mounted. */
     private quiet;
     private unannounced;
@@ -137,13 +139,15 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
      * Loads values, such as a record from a server. They become the values the form compares with, and every input shows
      * them. With `keepChanged`, the values the user changed stay (a refresh that merges): only the others change, and the
      * names returned are the changed values whose loaded ones also changed, so the page can say so. `draft: false` leaves
-     * a saved draft for a later load (the form's placeholders show while the real values load). `quiet` tells no listener
-     * until `announce()`, for a load during a render.
+     * a saved draft for a later load (the form shows disabled while the real values load). `quiet` tells no listener
+     * until `announce()`, for a load during a render. `loading` opens the form loading, so whatever reads its status in
+     * the same render — a `FormButtons` after it — draws its loading state from the first frame, on the server too.
      */
-    load(values?: Partial<TValues>, { keepChanged, draft, quiet }?: {
+    load(values?: Partial<TValues>, { keepChanged, draft, quiet, loading }?: {
         keepChanged?: boolean;
         draft?: boolean;
         quiet?: boolean;
+        loading?: boolean;
     }): string[];
     /** Tells listeners about a quiet load. */
     announce(): void;
@@ -197,7 +201,7 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     commit(saved: TValues, extra?: Partial<TValues>): void;
     /** @internal A save after which the form went back to its opening values (`resetOnSuccess`). */
     markSaved(): void;
-    /** @internal */
+    /** @internal While the values load, nothing typed is taken (`input`), and a submit waits (`SubmitForm`). */
     setLoading(loading: boolean): void;
     /** @internal */
     setFormId(formId: string | null): void;

package/dist/Helpers/FormStore.js

@@ -70,6 +70,8 @@ export class FormStore {
     draftSeq = 0;
     /** The user cancelled: no draft is written until they change a value again. */
     draftDropped = false;
+    /** An input reported a value while the values loaded and was refused: it is drawn again from the store when loading ends. */
+    refusedWhileLoading = false;
     /** A load during a render tells nobody; `announce` does, once the form has mounted. */
     quiet = false;
     unannounced = false;
@@ -216,14 +218,18 @@ export class FormStore {
      * Loads values, such as a record from a server. They become the values the form compares with, and every input shows
      * them. With `keepChanged`, the values the user changed stay (a refresh that merges): only the others change, and the
      * names returned are the changed values whose loaded ones also changed, so the page can say so. `draft: false` leaves
-     * a saved draft for a later load (the form's placeholders show while the real values load). `quiet` tells no listener
-     * until `announce()`, for a load during a render.
+     * a saved draft for a later load (the form shows disabled while the real values load). `quiet` tells no listener
+     * until `announce()`, for a load during a render. `loading` opens the form loading, so whatever reads its status in
+     * the same render — a `FormButtons` after it — draws its loading state from the first frame, on the server too.
      */
-    load(values = {}, { keepChanged = false, draft = true, quiet = false } = {}) {
+    load(values = {}, { keepChanged = false, draft = true, quiet = false, loading } = {}) {
         this.quiet = quiet;
         this.unannounced ||= quiet;
         try {
-            return this.loadValues(values, keepChanged, draft);
+            const changed = this.loadValues(values, keepChanged, draft);
+            if (loading !== undefined)
+                this.patchStatus({ loading });
+            return changed;
         }
         finally {
             this.quiet = false;
@@ -264,8 +270,10 @@ export class FormStore {
                     this.nextRevision(params.name);
         }
         else {
+            // Every input mounts again with its loaded value, one that was typed in while loading included.
             this.generation++;
             this.touched.clear();
+            this.refusedWhileLoading = false;
         }
         this.serverErrors.clear();
         this.serverMessage = null;
@@ -321,6 +329,12 @@ export class FormStore {
     input(name, value, stamp) {
         if (stamp !== this.stamp(name))
             return;
+        // Nothing is taken while the values load, not even from an input whose `disabled` was taken off by hand: the
+        // loaded values would land on top of it, and a change to a record that is not there yet means nothing.
+        if (this.status.loading) {
+            this.refusedWhileLoading = true;
+            return;
+        }
         this.change([[name, value]], "input");
     }
     /** Marks an input as left by the user: the form's rule messages on it show from now on. */
@@ -481,8 +495,14 @@ export class FormStore {
     markSaved() {
         this.patchStatus({ submitting: false, savedAt: Date.now() });
     }
-    /** @internal */
+    /** @internal While the values load, nothing typed is taken (`input`), and a submit waits (`SubmitForm`). */
     setLoading(loading) {
+        // Something was typed and refused, and no load has drawn the inputs again since: they show the store's values.
+        if (!loading && this.refusedWhileLoading) {
+            this.refusedWhileLoading = false;
+            this.generation++;
+            this.bumpAll();
+        }
         this.patchStatus({ loading });
     }
     /** @internal */

package/dist/Helpers/InputParamsHelpers.js

@@ -1,4 +1,5 @@
 import { DEFAULT_DATE_PREFERENCES } from "../Interfaces/DateInterfaces.js";
+import { formatCode, loadCode, validateCode } from "./CodeHelpers.js";
 import { formatDate, formatDateRange, toDateRange, toIsoDate, usesDevanagari } from "./DateHelpers.js";
 import { formatDateTime, toUtcDateTime } from "./DateTimeHelpers.js";
 import { formatNumber, parseNumber } from "./NumberHelpers.js";
@@ -108,6 +109,9 @@ export function normalizeInputValue(params, value) {
             return Array.isArray(value) && value.length === 2 ? value : emptyInputValue(params);
         case "radio-group":
             return value;
+        case "code":
+            // Only separators and case: a saved code that does not fit stays as it is, so its check refuses the save.
+            return loadCode(value, params);
         default:
             return typeof value === "string" ? value : String(value);
     }
@@ -197,6 +201,8 @@ export function validateInput(params, value, context = {}) {
                 seconds,
             });
         }
+        case "code":
+            return validateCode(value, params, name);
         case "slider":
             return params.validate?.(value) || null;
         case "range-slider":
@@ -369,6 +375,8 @@ export function formatInputValue(params, value, context = {}) {
             return formatTime(value, timeSettings(params, preferences));
         case "date-time":
             return formatDateTime(value, { ...dateSettings(params, preferences), timeFormat: params.timeFormat ?? preferences.timeFormat, timeZone: params.timeZone });
+        case "code":
+            return formatCode(value, params);
         case "slider":
             return formatNumber(value, params);
         case "range-slider":

package/dist/Helpers/MessageBuilder.js

@@ -17,6 +17,8 @@ const DEFAULT_WORDS = {
     unflag: { verb: "unflag", done: "unflagged", doing: "Unflagging", object: "the record" },
     pin: { verb: "pin", done: "pinned", doing: "Pinning", object: "the record" },
     unpin: { verb: "unpin", done: "unpinned", doing: "Unpinning", object: "the record" },
+    favorite: { verb: "add {object} to the favourites", done: "added to the favourites", doing: "Adding {object} to the favourites", object: "the record" },
+    unfavorite: { verb: "remove {object} from the favourites", done: "removed from the favourites", doing: "Removing {object} from the favourites", object: "the record" },
     send: { verb: "send", done: "sent", doing: "Sending", object: "the message", sendsValues: true },
     submit: { verb: "submit", done: "submitted", doing: "Submitting", object: "the form", sendsValues: true },
     upload: { verb: "upload", done: "uploaded", doing: "Uploading", object: "the file", sendsValues: true },
@@ -43,6 +45,7 @@ const DEFAULT_TEXTS = {
     confirmDetails: {
         delete: "This cannot be undone.",
         trash: "It can be restored from the trash.",
+        recover: "It goes back to the active list.",
     },
     reasons: {
         network: "The server cannot be reached. Check your internet connection and try again.",

package/dist/Helpers/NexusHelpers.js

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

package/dist/Helpers/NumberHelpers.d.ts

@@ -1,4 +1,5 @@
 import type { NumberFormatOptions } from "../Interfaces/InputInterfaces.ts";
+import { ENumberScales, type ThousandsSeparator } from "../Interfaces/PreferenceInterfaces.ts";
 /** Default locale for number text. Fixed rather than the browser's, so server-rendered text matches the browser's. */
 export declare const DEFAULT_NUMBER_LOCALE = "en-US";
 /** Most digits a number field takes. A JavaScript number holds 15 significant digits exactly; beyond that, digits change. */
@@ -15,7 +16,12 @@ export interface NumberTextRules {
     /** Allows a leading minus sign. */
     negative: boolean;
 }
-/** The decimal and group separators of a locale. */
+/**
+ * The locale for a number scale and a thousands separator: `en-US` (1,234,567.5) and `en-IN` (12,34,567.5) as they are,
+ * else a key such as "en-US|.|," (1.234.567,5) that `formatNumber`, `parseNumber` and `getNumberSymbols` read.
+ */
+export declare function numberLocale(scale: ENumberScales, thousands: ThousandsSeparator): string;
+/** The decimal and group separators of a locale (or of a key from `numberLocale`). */
 export declare function getNumberSymbols(locale?: string): NumberSymbols;
 /**
  * Formats a number for display: `formatNumber(1250, { decimals: 2, fixedDecimals: true, grouping: true })` gives "1,250.00".

package/dist/Helpers/NumberHelpers.js

@@ -1,3 +1,4 @@
+import { ENumberScales } from "../Interfaces/PreferenceInterfaces.js";
 /** Default locale for number text. Fixed rather than the browser's, so server-rendered text matches the browser's. */
 export const DEFAULT_NUMBER_LOCALE = "en-US";
 /** Most digits a number field takes. A JavaScript number holds 15 significant digits exactly; beyond that, digits change. */
@@ -9,9 +10,43 @@ const BIDI_MARKS = /[\u061c\u200e\u200f]/g;
 // U+2212, the typographic minus sign some locales use.
 const MINUS_SIGN = "\u2212";
 const SPACES = /\s/g;
-/** The decimal and group separators of a locale. */
+/*
+ * A person's number settings as a locale: the scale picks where the groups fall (en-US, or en-IN for lakh and crore)
+ * and the separator what marks them. A pair Intl already has is that locale; any other is a key of three parts,
+ * "en-IN|.|,", that the helpers here read as the base locale's grouping with these two marks. Everything that takes
+ * a `locale` (a number box, a table cell, a message) therefore takes the person's settings without knowing of them.
+ */
+const SEPARATOR_MARKS = {
+    period: { group: ".", decimal: "," },
+    space: { group: "\u00a0", decimal: "." },
+    none: { group: "", decimal: "." },
+};
+/**
+ * The locale for a number scale and a thousands separator: `en-US` (1,234,567.5) and `en-IN` (12,34,567.5) as they are,
+ * else a key such as "en-US|.|," (1.234.567,5) that `formatNumber`, `parseNumber` and `getNumberSymbols` read.
+ */
+export function numberLocale(scale, thousands) {
+    const base = scale === ENumberScales.SouthAsian ? "en-IN" : DEFAULT_NUMBER_LOCALE;
+    if (thousands === "comma" || !(thousands in SEPARATOR_MARKS))
+        return base;
+    const { group, decimal } = SEPARATOR_MARKS[thousands];
+    return `${base}|${group}|${decimal}`;
+}
+/** A locale key from `numberLocale`: its base locale and its own marks, or `null` for a plain locale. */
+function customMarks(locale) {
+    if (!locale.includes("|"))
+        return null;
+    const [base = DEFAULT_NUMBER_LOCALE, group = ",", decimal = "."] = locale.split("|");
+    return { base, group, decimal };
+}
+/** The decimal and group separators of a locale (or of a key from `numberLocale`). */
 export function getNumberSymbols(locale = DEFAULT_NUMBER_LOCALE) {
     let symbols = symbolsByLocale.get(locale);
+    const custom = symbols ? null : customMarks(locale);
+    if (custom) {
+        symbols = { decimal: custom.decimal, group: custom.group };
+        symbolsByLocale.set(locale, symbols);
+    }
     if (!symbols) {
         const parts = new Intl.NumberFormat(locale).formatToParts(1234567.5);
         symbols = {
@@ -33,9 +68,10 @@ export function formatNumber(value, options = {}) {
     const maxDecimals = decimals ?? MAX_NUMBER_DIGITS;
     const minDecimals = fixedDecimals ? maxDecimals : 0;
     const key = `${locale}|${minDecimals}|${maxDecimals}|${grouping}`;
+    const custom = customMarks(locale);
     let formatter = formatters.get(key);
     if (!formatter) {
-        formatter = new Intl.NumberFormat(locale, {
+        formatter = new Intl.NumberFormat(custom?.base ?? locale, {
             numberingSystem: "latn",
             useGrouping: grouping,
             minimumFractionDigits: minDecimals,
@@ -44,7 +80,9 @@ export function formatNumber(value, options = {}) {
         formatters.set(key, formatter);
     }
     // Rounded first, the same way as roundDecimal, which also turns -0.001 into 0 rather than "-0".
-    return formatter.format(roundDecimal(value, maxDecimals)).replace(BIDI_MARKS, "").replace(MINUS_SIGN, "-");
+    const text = formatter.format(roundDecimal(value, maxDecimals)).replace(BIDI_MARKS, "").replace(MINUS_SIGN, "-");
+    // The base locales write "," between groups and "." before decimals; a key's own marks take their places.
+    return custom ? text.replace(/[,.]/g, mark => (mark === "," ? custom.group : custom.decimal)) : text;
 }
 /**
  * Reads a number written in the locale's format: "1,250.50" gives 1250.5, and in `de-DE` "1.250,50" does.

package/dist/Helpers/PopoverHelpers.d.ts

@@ -20,8 +20,9 @@ export interface PlaceUnderAnchorOptions {
     arrowAt?: DOMRect;
 }
 /**
- * Places a panel under an anchor, or above it when there is no room below, aligned to the anchor's start or end
- * edge and kept inside the window, with an arrow aimed at the anchor. Returns whether the panel went above.
+ * Places a panel under an anchor, or above it when it fits only there, or on the side with more room when it fits on
+ * neither; aligned to the anchor's start or end edge and kept inside the window, with an arrow aimed at the anchor. A
+ * panel that scrolls (`.nx-popover__scroll`) is never taller than the room on its side. Returns whether it went above.
  */
 export declare function placeUnderAnchor(panel: HTMLElement, anchor: DOMRect, options?: PlaceUnderAnchorOptions): boolean;
 export interface PlaceListPanelOptions {
@@ -57,11 +58,22 @@ export interface PlaceAtPointOptions {
 /**
  * Places a panel at a point, such as where the user right-clicked: to the right of and below the point when there
  * is room, otherwise to the left of or above it, and never past the window's edges. With an arrow, the panel is set
- * back far enough along both axes for the arrow's tip to land on the point.
+ * back far enough along both axes for the arrow's tip to land on the point. A panel that scrolls is capped to the
+ * room on its side, as under an anchor.
  */
 export declare function placeAtPoint(panel: HTMLElement, x: number, y: number, options?: PlaceAtPointOptions): void;
-/** Runs `place` again, once per frame at most, while the page scrolls or the window changes size. Returns the stop function. */
-export declare function followAnchor(place: () => void): () => void;
+/**
+ * Runs `place` again, once per frame at most, while the page scrolls, the window changes size, or `panel` does (its
+ * content grew). Returns the stop function. A frame later, never inside the observer, so a panel that `place` resizes
+ * is measured once more and settles instead of looping.
+ */
+export declare function followAnchor(place: () => void, panel?: Element): () => void;
+/**
+ * Shows a panel with its scroller (`.nx-popover__scroll`) at the top. The browser keeps where a panel was scrolled
+ * while it was shut, and a list that opens part-way down has lost its heading and its first rows. Does nothing on
+ * browsers without popover support.
+ */
+export declare function showPanel(panel: HTMLElement): void;
 /** Whether the popover is shown. Safe on browsers without popover support, where it is never "open". */
 export declare function isPopoverOpen(panel: HTMLElement | null): boolean;
 /** How far the arrow reaches past the panel's edge: its depth, less the panel's border it is drawn over. */