nexus-shared 2.0.0 → 3.1.0

package/dist/Helpers/ExcelHelpers.js

@@ -0,0 +1,344 @@
+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.
+ *
+ * Two rules decide every reading below, and both come from the backend:
+ *   - every value travels as **text**, the way it reads in the sheet, because one wire shape serves a verify and an
+ *     import and the import reads it with the same parser that read the file;
+ *   - a choice travels as its **key** and never as an id, so a reference cell is shown as the words the person picked
+ *     and the key beside it is carried through untouched.
+ */
+/** What a spreadsheet file is called in a file picker. */
+export const EXCEL_FILE_ACCEPT = ".xlsx,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+/** The field of an editor row that holds the sheet row it came from. Not a column, so no input is drawn for it. */
+export const EXCEL_ROW_NUMBER = "__excelRow";
+/** The field of an editor row that holds each reference column's key, which the person never sees or types. */
+export 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 const EXCEL_ROW_SENT = "__excelSent";
+/* Texts of the spreadsheet side. One table, so a word is changed or translated in one place. */
+const DEFAULT_TEXT = {
+    template: "Download template",
+    templateHint: "The file to fill in: every list is a dropdown, and the ids beside a choice fill themselves.",
+    choose: "Choose file",
+    change: "Choose another file",
+    checking: "Checking",
+    nothingPicked: "No file picked yet.",
+    verifyFailed: "The file could not be read.",
+    newRows: "New rows",
+    duplicates: "Already there",
+    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.",
+    generated: "The file fills this in.",
+    importLabel: "Import",
+    importNothing: "There is no row to import.",
+    importedNone: "Nothing was written.",
+    refused: "Not written",
+    exportWarning: "Export is cut short",
+    close: "Close",
+    startOver: "Start over",
+};
+let texts = { ...DEFAULT_TEXT };
+/** Rewords or translates the spreadsheet side's own texts. Names only what changes. */
+export function configureExcelText(changes) {
+    texts = { ...texts, ...changes };
+}
+/** One of the spreadsheet side's texts. */
+export function excelText(key) {
+    return texts[key];
+}
+/* Columns as inputs */
+/** How wide a column is drawn, by what it holds. The template sizes its own columns the same way. */
+const COLUMN_WIDTH = {
+    [ExcelDataType.Text]: "12rem",
+    [ExcelDataType.Note]: "20rem",
+    [ExcelDataType.WholeNumber]: "8rem",
+    [ExcelDataType.Decimal]: "8rem",
+    [ExcelDataType.Amount]: "9rem",
+    [ExcelDataType.Date]: "9.5rem",
+    [ExcelDataType.DateTime]: "12rem",
+    [ExcelDataType.Time]: "7.5rem",
+    [ExcelDataType.YesNo]: "7rem",
+    [ExcelDataType.List]: "16rem",
+};
+/** The shapes a zone-less moment may be written in, as the backend reads them. */
+const MOMENT_PATTERN = {
+    source: "[0-9]{4}[-/][0-9]{2}[-/][0-9]{2}([ T][0-9]{2}:[0-9]{2}(:[0-9]{2})?)?",
+    message: "Write a date and time as 2026-09-29 14:30.",
+};
+const YES_NO = [
+    { value: "Yes", label: "Yes" },
+    { value: "No", label: "No" },
+];
+/**
+ * One column of a sheet as an input of the review editors. The rules are the ones the sheet told the person about and
+ * no others, so a fix made here is checked the way the file was.
+ *
+ * Three columns are read-only on purpose:
+ * - a **reference**, because its list is the backend's and is picked in the spreadsheet; the cell shows the words the
+ *   person picked and the key travels back untouched (a key read out of an answer is never typed, and never an id);
+ * - a column the **file** fills;
+ * - and a **date and time** is a text box rather than a picker, because the sheet's moment is a zone-less wall clock
+ *   while the picker's value is a UTC moment: a picker here would shift every value by the person's own offset.
+ */
+export function excelColumnInput(column) {
+    const shared = {
+        name: column.field,
+        label: column.header,
+        width: COLUMN_WIDTH[column.dataType] ?? "12rem",
+        ...(column.note ? { hint: column.note } : {}),
+    };
+    const required = column.isRequired === true;
+    const lengths = {
+        ...(column.minLength && column.minLength > 0 ? { minLength: column.minLength } : {}),
+        ...(column.maxLength && column.maxLength > 0 ? { maxLength: column.maxLength } : {}),
+    };
+    const limits = {
+        ...(column.minimum === null || column.minimum === undefined ? {} : { min: column.minimum }),
+        ...(column.maximum === null || column.maximum === undefined ? {} : { max: column.maximum }),
+    };
+    if (column.isReference)
+        return { ...shared, type: "text", readOnly: true, readOnlyMessage: excelText("referenceLocked") };
+    if (column.isReadOnly)
+        return { ...shared, type: "text", readOnly: true, readOnlyMessage: excelText("generated") };
+    switch (column.dataType) {
+        case ExcelDataType.Note:
+            return { ...shared, type: "textarea", rows: 2, required, ...lengths };
+        case ExcelDataType.WholeNumber:
+            return { ...shared, type: "number", required, decimals: 0, ...limits };
+        case ExcelDataType.Decimal:
+            return { ...shared, type: "number", required, ...limits };
+        case ExcelDataType.Amount:
+            return { ...shared, type: "number", required, decimals: 2, fixedDecimals: true, grouping: true, ...limits };
+        case ExcelDataType.Date:
+            return { ...shared, type: "date", required };
+        case ExcelDataType.DateTime:
+            return { ...shared, type: "text", required, pattern: MOMENT_PATTERN, placeholder: "2026-09-29 14:30" };
+        case ExcelDataType.Time:
+            return { ...shared, type: "time", required };
+        case ExcelDataType.YesNo:
+            return { ...shared, type: "dropdown", required, options: YES_NO, searchable: false };
+        default:
+            return { ...shared, type: "text", required, ...lengths };
+    }
+}
+/** Every column of a sheet as the inputs of one editor row, in the order they read. */
+export function excelColumnInputs(columns) {
+    return columns.map(excelColumnInput);
+}
+/* Rows, both ways */
+/** Whether the person edits this column's cell at all, or only reads it. */
+export function isExcelColumnEditable(column) {
+    return column.isReference !== true && column.isReadOnly !== true;
+}
+/**
+ * A verify's rows as the editors' rows: a value per column, the sheet's row number, and - held beside them, never
+ * drawn - each reference column's key and the values the verify answered with.
+ *
+ * A reference cell shows the **words** the person picked, because its key is not something anybody reads or types.
+ */
+export function excelEditorRows(rows, columns) {
+    return rows.map(row => {
+        const keys = {};
+        const editor = { [EXCEL_ROW_NUMBER]: row.number, [EXCEL_ROW_KEYS]: keys, [EXCEL_ROW_SENT]: { ...row.values } };
+        for (const column of columns) {
+            const value = row.values[column.field] ?? null;
+            if (column.isReference) {
+                keys[column.field] = value;
+                editor[column.field] = row.labels?.[column.field] ?? "";
+                continue;
+            }
+            editor[column.field] = toInputValue(column, value);
+        }
+        return editor;
+    });
+}
+/** 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, 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 === "")
+        return NUMBER_TYPES.has(column.dataType) ? null : column.dataType === ExcelDataType.YesNo ? undefined : "";
+    switch (column.dataType) {
+        case ExcelDataType.WholeNumber:
+        case ExcelDataType.Decimal:
+        case ExcelDataType.Amount: {
+            const number = Number(value.replace(/,/g, ""));
+            return Number.isFinite(number) ? number : null;
+        }
+        case ExcelDataType.YesNo: {
+            const upper = value.trim().toUpperCase();
+            if (upper === "YES" || upper === "Y" || upper === "TRUE" || upper === "1")
+                return "Yes";
+            if (upper === "NO" || upper === "N" || upper === "FALSE" || upper === "0")
+                return "No";
+            return value;
+        }
+        case ExcelDataType.Date:
+            return toIsoDate(value) ?? value;
+        case ExcelDataType.Time:
+            return toIsoTime(value) ?? value;
+        default:
+            return value;
+    }
+}
+/** A cell as it travels: text, the way it reads in the sheet. A value the editors could not hold is sent back as it came. */
+function toSheetValue(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === "boolean")
+        return value ? "Yes" : "No";
+    const written = String(value).trim();
+    return written.length ? written : null;
+}
+/**
+ * Whether a cell still holds what the verify answered for it.
+ *
+ * It is not a comparison of texts, because a cell goes through an input on the way: a sheet that read `38450.50` comes
+ * back from a number box as `38450.5`, and `TRUE` comes back from the Yes/No choice as `Yes`. Both are the same value
+ * and neither is an edit, so the two are compared the way the input holds them.
+ */
+function isSameCell(column, current, sent) {
+    const asSheet = toSheetValue(current);
+    if (asSheet === (sent ?? null))
+        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, 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) {
+            if (column.isReference) {
+                values[column.field] = keys[column.field] ?? null;
+                labels[column.field] = toSheetValue(row[column.field]);
+                continue;
+            }
+            values[column.field] = isSameCell(column, row[column.field], sent[column.field]) ? (sent[column.field] ?? null) : toSheetValue(row[column.field]);
+        }
+        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] ?? {};
+    for (const column of columns) {
+        if (!isExcelColumnEditable(column))
+            continue;
+        if (!isSameCell(column, row[column.field], sent[column.field]))
+            return true;
+    }
+    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"). 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) {
+    return rows.flatMap(row => row.problems ?? []);
+}
+/** The rows of one kind. */
+export function excelRowsOfKind(rows, ...kinds) {
+    return rows.filter(row => kinds.includes(row.kind));
+}
+/** The rows an import would try to write: the new ones, and the ones still waiting on a fix. */
+export function excelWritableRows(rows) {
+    return excelRowsOfKind(rows, ExcelRowKind.New, ExcelRowKind.Invalid);
+}
+/** More than one of the subject: "cities", "boxes", "rows". An English ending, which a text change can replace. */
+export function excelPlural(subject, plural) {
+    if (plural)
+        return plural;
+    if (/(s|x|z|ch|sh)$/i.test(subject))
+        return `${subject}es`;
+    if (/[^aeiou]y$/i.test(subject))
+        return `${subject.slice(0, -1)}ies`;
+    return `${subject}s`;
+}
+/** A count said in the subject's own words: "1 city", "12 cities". */
+export function excelCount(rows, subject, plural) {
+    if (rows === 1)
+        return `1 ${subject}`;
+    return `${rows.toLocaleString("en-US")} ${excelPlural(subject, plural)}`;
+}
+/**
+ * What to tell the person before an export that will be cut short, as the owner asked: what is on screen, what will be
+ * written, and that filtering is how they get the rest.
+ */
+export function excelExportWarning(rows, limit, subject) {
+    return `The search on screen leaves ${excelCount(rows, subject)}, and one export writes at most ${limit.toLocaleString("en-US")}. The first ${limit.toLocaleString("en-US")} are written and the rest are left out. Search or filter for the rows you need to get them all.`;
+}
+/* The file itself */
+/** Hands the person a file to save, under the name the answer gave it. */
+export function saveExcelFile(download) {
+    const url = URL.createObjectURL(download.blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = download.fileName;
+    link.rel = "noopener";
+    document.body.append(link);
+    link.click();
+    link.remove();
+    // Firefox needs the object URL a moment longer than the click.
+    setTimeout(() => URL.revokeObjectURL(url), 10_000);
+}

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;
@@ -209,6 +213,8 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     /** Inputs that were not there, or were hidden, get their value in the input's type, as a load gives it. */
     private adoptNewInputs;
     private change;
+    /** The inputs whose `dependsOn` names any of `names`. */
+    private followersOf;
     private checkRule;
     private checkAllRules;
     /** Runs the form's own rule; returns the inputs whose message from it changed. */

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 */
@@ -572,12 +592,19 @@ export class FormStore {
                             write(field, value, "code");
             }
         }
+        // Inputs that follow a changed one (`dependsOn`) draw again with their params read afresh, and their rule is asked
+        // again: a getter may have just made one required, read-only or hidden.
+        const followers = this.followersOf(written);
+        for (const name of followers) {
+            remember(name);
+            this.checkRule(name);
+        }
         // The form's rule runs again: an input it now names, or no longer names, shows the change even if nobody typed in it.
         for (const name of this.checkCross())
             if (!shown.has(name))
                 shown.set(name, this.shownWith(name, crossBefore));
         for (const [name, before] of shown)
-            if (remounted.has(name) || this.shownError(name) !== before)
+            if (remounted.has(name) || followers.has(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);
@@ -586,6 +613,17 @@ export class FormStore {
             this.draftDropped = false;
         this.scheduleDraft();
     }
+    /** The inputs whose `dependsOn` names any of `names`. */
+    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)))
+                found.add(params.name);
+        return found;
+    }
     checkRule(name) {
         const params = this.inputByName.get(name);
         if (params && isRowsInput(params)) {

package/dist/Helpers/MessageBuilder.js

@@ -11,7 +11,6 @@ const DEFAULT_WORDS = {
     update: { verb: "update", done: "updated", doing: "Updating", object: "the record", sendsValues: true },
     delete: { verb: "delete", done: "deleted", doing: "Deleting", object: "the record" },
     trash: { verb: "move {object} to the trash", done: "moved to the trash", doing: "Moving {object} to the trash", object: "the record" },
-    archive: { verb: "archive", done: "archived", doing: "Archiving", object: "the record" },
     restore: { verb: "restore", done: "restored", doing: "Restoring", object: "the record" },
     recover: { verb: "recover", done: "recovered", doing: "Recovering", object: "the record" },
     flag: { verb: "flag", done: "flagged", doing: "Flagging", object: "the record" },
@@ -44,7 +43,7 @@ const DEFAULT_TEXTS = {
     confirmDetails: {
         delete: "This cannot be undone.",
         trash: "It can be restored from the trash.",
-        archive: "It can be restored from the archive.",
+        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/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.