nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/DomainCards.d.ts

@@ -0,0 +1,140 @@
+import type { ChatDomainInfo, ChatDomainValue, ChatId } from "../Interfaces/ChatInterfaces.ts";
+import type { DatePreferences } from "../Interfaces/DateInterfaces.ts";
+import type { DomainCardContext, DomainCardDefinition, DomainCardField, DomainCardParams, DomainCardShape, DomainCardSnapshot, DomainCardValueKind } from "../Interfaces/DomainInterfaces.ts";
+/** How long a card's answer is kept for every card of the page that draws the same record, in milliseconds. */
+export declare const DOMAIN_CARD_LIFETIME = 30000;
+/**
+ * A kind's card, with `view` typed by what `load` answers.
+ *
+ * @example
+ * defineChatDomains([{ domain: EDomainTypes.LeaveRequest, key: "leave-request", label: "Leave request", card: domainCard({
+ *   load: (id, signal) => api.get<LeaveRequestCard>(REQUEST_CARD.leave(id), { signal }),
+ *   view: leave => ({ title: `${leave.leaveTypeName} · ${formatDays(leave.days)}`, code: leave.requestCode, ... }),
+ * }) }]);
+ */
+export declare function domainCard<TData>(definition: DomainCardDefinition<TData>): DomainCardDefinition<TData>;
+/** A kind's registered row and its card, or `undefined` when the app gave it none. */
+export declare function domainCardOf(domainType: ChatDomainValue): {
+    info: ChatDomainInfo<ChatDomainValue>;
+    card: DomainCardDefinition;
+} | undefined;
+/** The key a record's answer is kept under: its kind, its id, and who reads it (the same record reads otherwise for another). */
+export declare function domainCardKey(domainType: ChatDomainValue, id: ChatId, viewer?: ChatId | null): string;
+/** The start of every key of one record (every reader's), or of every record of a kind without an id. */
+export declare function domainCardRecordPrefix(domainType: ChatDomainValue, id?: ChatId): string;
+/** One wait for a read: its answer, and a way to stop waiting (the last to stop aborts it). */
+export interface DomainCardReading<T> {
+    promise: Promise<T>;
+    leave(): void;
+}
+/**
+ * Reads shared by every card on the page: one read of a record at a time, its answer kept for a lifetime, a failure not
+ * kept. A read nobody waits for any more is aborted.
+ */
+export declare class DomainCardReads {
+    private entries;
+    private now;
+    constructor(now?: () => number);
+    /** The answer kept under `key` while it is younger than `lifetime` and was read from a read started at or after `since`. */
+    peek<T>(key: string, lifetime?: number, since?: number): T | undefined;
+    /**
+     * The answer under `key`: a read on its way that started at or after `since`, else a kept fresh one, else a new read by
+     * `load`. `since` is the moment the record was seen to change: what was read before it does not answer.
+     */
+    read<T>(key: string, load: (signal: AbortSignal) => Promise<T>, options?: {
+        lifetime?: number;
+        since?: number;
+    }): DomainCardReading<T>;
+    private wait;
+    /**
+     * Drops what is kept or on its way under keys that start with `prefix` (every key when none); a read on its way still
+     * answers its waiters. `keptOnly` leaves the reads on their way, so cards reading again for the same change still share one.
+     */
+    drop(prefix?: string, keptOnly?: boolean): number;
+    /** Answers kept and reads on their way. */
+    get size(): number;
+}
+/** The reads every card of the page shares. */
+export declare const domainCardReads: DomainCardReads;
+/** A read the page called off (the card closed): not a failure to show. */
+export declare function isDomainCardAbort(error: unknown): boolean;
+/** Whether a failure means the reader may not open the record, or it is not there for them: 403 and 404 alike. */
+export declare function isDomainCardRefusal(error: unknown): boolean;
+/** What a run reads and how. */
+export interface DomainCardRunOptions<TData> {
+    domainType: ChatDomainValue;
+    id: ChatId;
+    /** Who reads: part of the key, and told to `load`. */
+    viewer?: ChatId | null;
+    load: (signal: AbortSignal) => Promise<TData>;
+    /** Default 30,000. */
+    lifetime?: number;
+    /** Default: the page's `domainCardReads`. */
+    reads?: DomainCardReads;
+    now?: () => number;
+}
+/**
+ * One card's read: loading, then the record, a refusal or a failure; read again when the record changes (the card stays
+ * on screen meanwhile, and says so when the record turned out different); tried again on Retry. Subscribe to draw it.
+ */
+export declare class DomainCardRun<TData = unknown> {
+    readonly domainType: ChatDomainValue;
+    readonly id: ChatId;
+    readonly key: string;
+    private options;
+    private reads;
+    private now;
+    private snapshot;
+    private listeners;
+    private reading;
+    private round;
+    constructor(options: DomainCardRunOptions<TData>);
+    private get lifetime();
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => DomainCardSnapshot<TData>;
+    private set;
+    /** The card is drawn: reads, unless it already shows a kept answer. */
+    start(): void;
+    /** The card is gone: stops waiting (the read is aborted when no other card waits for it). */
+    stop(): void;
+    /**
+     * The record changed: reads it again, from a read started now. The card on screen stays until the answer lands, and
+     * what other readers kept of the record is forgotten, since it changed for them too.
+     */
+    reload(): void;
+    /** After a failure: reads once more. */
+    retry(): void;
+    private read;
+}
+/**
+ * A record changed (the page approved it, a message said so): every card drawing it reads it again, and no answer kept
+ * from before is handed out. Without an id, every record of the kind.
+ */
+export declare function refreshDomainCards(domainType: ChatDomainValue, id?: ChatId, reads?: DomainCardReads): number;
+/** The kind's name inside a sentence: "Leave request" reads "leave request"; "HR letter" keeps its capitals. */
+export declare function domainCardNoun(kind?: string | null): string;
+/** What a reader the record's module refused reads: the same for "not yours" and "not there", so a stranger learns nothing. */
+export declare function domainCardRefusedText(kind?: string | null): string;
+/** What a failed read says, beside Try again. */
+export declare function domainCardFailedText(kind?: string | null): string;
+/** What a card's values are written with: the reader's date settings and zone, number locale and currency. */
+export interface DomainCardValueOptions {
+    preferences?: Partial<DatePreferences>;
+    timeZone?: string | null;
+    locale?: string;
+    currency?: string | null;
+}
+/** A value written by its kind, or "" when it is missing. A value its kind cannot read is written as it is. */
+export declare function domainCardValueText(value: string | number | null | undefined, kind?: DomainCardValueKind, options?: DomainCardValueOptions): string;
+/** The fields a card draws: the ones with a value, and the ones that say what stands in for a missing one. */
+export declare function domainCardFields(params: Pick<DomainCardParams, "fields">): DomainCardField[];
+/** What a placeholder holds when a kind gave nothing and none of its cards has loaded yet: a title, a state, four fields. */
+export declare const DEFAULT_DOMAIN_CARD_SHAPE: DomainCardShape;
+/** How many of each part a card drew. */
+export declare function domainCardShape(params: DomainCardParams): DomainCardShape;
+/** Keeps a kind's last drawn shape, so its next placeholder holds the same parts. */
+export declare function rememberDomainCardShape(domainType: ChatDomainValue, shape: DomainCardShape): void;
+/** The shape a kind's placeholder holds: its last card's, else what its card says, else the default. */
+export declare function heldDomainCardShape(domainType: ChatDomainValue, card?: Pick<DomainCardDefinition, "held"> | null): DomainCardShape;
+/** What `load`, `view` and `extra` are told about a record. */
+export declare function domainCardContext(domainType: ChatDomainValue, id: ChatId, extra?: Omit<DomainCardContext, "domainType" | "id">): DomainCardContext;

package/dist/Helpers/DomainCards.js

@@ -0,0 +1,370 @@
+import { getChatDomains } from "./ChatBackend.js";
+import { formatDate } from "./DateHelpers.js";
+import { formatDateTime } from "./DateTimeHelpers.js";
+import { formatDays, formatMoney, formatNumber } from "./NumberHelpers.js";
+/*
+ * A record's card outside React: which card a kind of record has, the reads every card on the page shares, one card's
+ * read from its first answer through reading it again, and the words and values it is drawn with. `DomainCard` draws
+ * a `DomainCardRun`'s snapshot; nothing here touches the DOM, so it is checked without a browser.
+ *
+ * The reads keep the owner's caching rules (as `RequestCache` does): one read of a record at a time however many cards
+ * draw it, an answer kept for a short life (30 seconds: a card is live, so less than the lists' five minutes), a
+ * failure never kept. A card read again because the record changed takes only a read started after the change.
+ */
+/** How long a card's answer is kept for every card of the page that draws the same record, in milliseconds. */
+export const DOMAIN_CARD_LIFETIME = 30_000;
+/**
+ * A kind's card, with `view` typed by what `load` answers.
+ *
+ * @example
+ * defineChatDomains([{ domain: EDomainTypes.LeaveRequest, key: "leave-request", label: "Leave request", card: domainCard({
+ *   load: (id, signal) => api.get<LeaveRequestCard>(REQUEST_CARD.leave(id), { signal }),
+ *   view: leave => ({ title: `${leave.leaveTypeName} · ${formatDays(leave.days)}`, code: leave.requestCode, ... }),
+ * }) }]);
+ */
+export function domainCard(definition) {
+    return definition;
+}
+/** A kind's registered row and its card, or `undefined` when the app gave it none. */
+export function domainCardOf(domainType) {
+    const info = getChatDomains().find(row => String(row.domain) === String(domainType));
+    return info?.card ? { info, card: info.card } : undefined;
+}
+/** The key a record's answer is kept under: its kind, its id, and who reads it (the same record reads otherwise for another). */
+export function domainCardKey(domainType, id, viewer) {
+    return [domainType, id, viewer ?? ""].map(part => encodeURIComponent(String(part))).join("|");
+}
+/** The start of every key of one record (every reader's), or of every record of a kind without an id. */
+export function domainCardRecordPrefix(domainType, id) {
+    const kind = `${encodeURIComponent(String(domainType))}|`;
+    return id === undefined ? kind : `${kind}${encodeURIComponent(String(id))}|`;
+}
+/**
+ * Reads shared by every card on the page: one read of a record at a time, its answer kept for a lifetime, a failure not
+ * kept. A read nobody waits for any more is aborted.
+ */
+export class DomainCardReads {
+    entries = new Map();
+    now;
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    /** The answer kept under `key` while it is younger than `lifetime` and was read from a read started at or after `since`. */
+    peek(key, lifetime = DOMAIN_CARD_LIFETIME, since = 0) {
+        const entry = this.entries.get(key);
+        if (entry?.state !== "ready")
+            return undefined;
+        if (this.now() - entry.at >= lifetime) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry.startedAt >= since ? entry.value : undefined;
+    }
+    /**
+     * The answer under `key`: a read on its way that started at or after `since`, else a kept fresh one, else a new read by
+     * `load`. `since` is the moment the record was seen to change: what was read before it does not answer.
+     */
+    read(key, load, options = {}) {
+        const { lifetime = DOMAIN_CARD_LIFETIME, since = 0 } = options;
+        const entry = this.entries.get(key);
+        if (entry?.state === "loading" && entry.startedAt >= since)
+            return this.wait(key, entry);
+        const kept = this.peek(key, lifetime, since);
+        if (kept !== undefined)
+            return { promise: Promise.resolve(kept), leave: () => { } };
+        const controller = new AbortController();
+        const startedAt = this.now();
+        let answer;
+        try {
+            answer = Promise.resolve(load(controller.signal));
+        }
+        catch (error) {
+            answer = Promise.reject(error);
+        }
+        const loading = { state: "loading", startedAt, controller, waiters: 0, promise: answer };
+        loading.promise = answer.then(value => {
+            // A read dropped or overtaken on its way answers whoever waits for it, and is not kept.
+            if (this.entries.get(key) === loading) {
+                if (lifetime > 0)
+                    this.entries.set(key, { state: "ready", value, startedAt, at: this.now() });
+                else
+                    this.entries.delete(key);
+            }
+            return value;
+        }, (error) => {
+            if (this.entries.get(key) === loading)
+                this.entries.delete(key);
+            throw error;
+        });
+        // Nobody may be waiting when it fails (every card left): that is not an unhandled rejection.
+        loading.promise.catch(() => { });
+        this.entries.set(key, loading);
+        return this.wait(key, loading);
+    }
+    wait(key, loading) {
+        loading.waiters++;
+        let waiting = true;
+        return {
+            promise: loading.promise,
+            leave: () => {
+                if (!waiting)
+                    return;
+                waiting = false;
+                loading.waiters--;
+                // A card that leaves and comes straight back (a remount) keeps the read: the abort waits a turn.
+                setTimeout(() => {
+                    if (loading.waiters > 0)
+                        return;
+                    if (this.entries.get(key) === loading)
+                        this.entries.delete(key);
+                    loading.controller.abort();
+                }, 0);
+            },
+        };
+    }
+    /**
+     * Drops what is kept or on its way under keys that start with `prefix` (every key when none); a read on its way still
+     * answers its waiters. `keptOnly` leaves the reads on their way, so cards reading again for the same change still share one.
+     */
+    drop(prefix = "", keptOnly = false) {
+        let dropped = 0;
+        for (const [key, entry] of [...this.entries]) {
+            if (!key.startsWith(prefix) || (keptOnly && entry.state !== "ready"))
+                continue;
+            this.entries.delete(key);
+            dropped++;
+        }
+        return dropped;
+    }
+    /** Answers kept and reads on their way. */
+    get size() {
+        return this.entries.size;
+    }
+}
+/** The reads every card of the page shares. */
+export const domainCardReads = new DomainCardReads();
+// Failures
+const statusOf = (error) => {
+    const status = error?.status;
+    return typeof status === "number" ? status : undefined;
+};
+/** A read the page called off (the card closed): not a failure to show. */
+export function isDomainCardAbort(error) {
+    return error?.name === "AbortError";
+}
+/** Whether a failure means the reader may not open the record, or it is not there for them: 403 and 404 alike. */
+export function isDomainCardRefusal(error) {
+    const status = statusOf(error);
+    return status === 403 || status === 404;
+}
+/** Every run that is drawn, for `refreshDomainCards`. */
+const drawn = new Set();
+/** Two answers of the same record: the same when their JSON is. */
+const sameData = (a, b) => {
+    try {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    catch {
+        return a === b;
+    }
+};
+/**
+ * One card's read: loading, then the record, a refusal or a failure; read again when the record changes (the card stays
+ * on screen meanwhile, and says so when the record turned out different); tried again on Retry. Subscribe to draw it.
+ */
+export class DomainCardRun {
+    domainType;
+    id;
+    key;
+    options;
+    reads;
+    now;
+    snapshot;
+    listeners = new Set();
+    reading = null;
+    round = 0;
+    constructor(options) {
+        this.options = options;
+        this.domainType = options.domainType;
+        this.id = options.id;
+        this.key = domainCardKey(options.domainType, options.id, options.viewer);
+        this.reads = options.reads ?? domainCardReads;
+        this.now = options.now ?? Date.now;
+        // A record read a moment ago by another card is drawn at once, without a placeholder.
+        const kept = this.reads.peek(this.key, this.lifetime);
+        this.snapshot = kept === undefined ? { status: "loading", refreshing: false, refreshFailed: false } : { status: "ready", data: kept, refreshing: false, refreshFailed: false };
+    }
+    get lifetime() {
+        return this.options.lifetime ?? DOMAIN_CARD_LIFETIME;
+    }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getSnapshot = () => this.snapshot;
+    set(next) {
+        this.snapshot = { ...this.snapshot, ...next };
+        for (const listener of this.listeners)
+            listener();
+    }
+    /** The card is drawn: reads, unless it already shows a kept answer. */
+    start() {
+        drawn.add(this);
+        if (this.snapshot.status === "ready" || this.reading)
+            return;
+        this.read(0);
+    }
+    /** The card is gone: stops waiting (the read is aborted when no other card waits for it). */
+    stop() {
+        drawn.delete(this);
+        this.round++;
+        this.reading?.leave();
+        this.reading = null;
+    }
+    /**
+     * The record changed: reads it again, from a read started now. The card on screen stays until the answer lands, and
+     * what other readers kept of the record is forgotten, since it changed for them too.
+     */
+    reload() {
+        this.reads.drop(domainCardRecordPrefix(this.domainType, this.id), true);
+        this.read(this.now());
+    }
+    /** After a failure: reads once more. */
+    retry() {
+        this.read(this.now());
+    }
+    read(since) {
+        const round = ++this.round;
+        this.reading?.leave();
+        const shown = this.snapshot.status === "ready" || this.snapshot.status === "refused";
+        if (shown)
+            this.set({ refreshing: true });
+        else
+            this.set({ status: "loading", refreshing: false, refreshFailed: false, error: undefined });
+        const reading = this.reads.read(this.key, this.options.load, { lifetime: this.lifetime, since });
+        this.reading = reading;
+        reading.promise.then(data => {
+            if (round !== this.round)
+                return;
+            this.reading = null;
+            const before = this.snapshot;
+            const changed = before.status === "ready" && before.data !== undefined && !sameData(before.data, data);
+            this.set({ status: "ready", data, refreshing: false, refreshFailed: false, error: undefined, ...(changed && { changedAt: this.now() }) });
+        }, (error) => {
+            if (round !== this.round)
+                return;
+            this.reading = null;
+            if (isDomainCardAbort(error)) {
+                this.set({ refreshing: false });
+                return;
+            }
+            if (isDomainCardRefusal(error)) {
+                // The reader lost the record, or it is gone: nothing of it stays on screen.
+                this.set({ status: "refused", data: undefined, refreshing: false, refreshFailed: false, changedAt: undefined, error });
+                return;
+            }
+            if (this.snapshot.status === "ready")
+                this.set({ refreshing: false, refreshFailed: true, error });
+            else
+                this.set({ status: "failed", refreshing: false, error });
+        });
+    }
+}
+/**
+ * A record changed (the page approved it, a message said so): every card drawing it reads it again, and no answer kept
+ * from before is handed out. Without an id, every record of the kind.
+ */
+export function refreshDomainCards(domainType, id, reads = domainCardReads) {
+    reads.drop(domainCardRecordPrefix(domainType, id));
+    let count = 0;
+    for (const run of drawn) {
+        if (String(run.domainType) !== String(domainType) || (id !== undefined && String(run.id) !== String(id)))
+            continue;
+        run.reload();
+        count++;
+    }
+    return count;
+}
+// Words
+/** The kind's name inside a sentence: "Leave request" reads "leave request"; "HR letter" keeps its capitals. */
+export function domainCardNoun(kind) {
+    const name = kind?.trim();
+    if (!name)
+        return "record";
+    return /^[A-Z][a-z]/.test(name) ? name[0].toLowerCase() + name.slice(1) : name;
+}
+/** What a reader the record's module refused reads: the same for "not yours" and "not there", so a stranger learns nothing. */
+export function domainCardRefusedText(kind) {
+    return `You cannot open this ${domainCardNoun(kind)}.`;
+}
+/** What a failed read says, beside Try again. */
+export function domainCardFailedText(kind) {
+    return `Could not load this ${domainCardNoun(kind)}.`;
+}
+const isMissing = (value) => value === null || value === undefined || (typeof value === "string" && value.trim() === "") || (typeof value === "number" && Number.isNaN(value));
+const numberOf = (value) => {
+    const number = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(number) ? number : null;
+};
+/** A value written by its kind, or "" when it is missing. A value its kind cannot read is written as it is. */
+export function domainCardValueText(value, kind = "text", options = {}) {
+    if (isMissing(value))
+        return "";
+    const held = value;
+    const { preferences, timeZone, locale, currency } = options;
+    switch (kind) {
+        case "number": {
+            const number = numberOf(held);
+            return number === null ? String(held) : formatNumber(number, { decimals: 2, grouping: true, locale });
+        }
+        case "days": {
+            const number = numberOf(held);
+            return number === null ? String(held) : formatDays(number, { locale });
+        }
+        case "money": {
+            const number = numberOf(held);
+            return number === null ? String(held) : formatMoney(number, { currency, locale });
+        }
+        case "date":
+            return formatDate(String(held), preferences) || String(held);
+        case "datetime":
+            return formatDateTime(String(held), { ...preferences, ...(timeZone && { timeZone }) }) || String(held);
+        default:
+            return String(held);
+    }
+}
+/** The fields a card draws: the ones with a value, and the ones that say what stands in for a missing one. */
+export function domainCardFields(params) {
+    return (params.fields ?? []).filter(field => !isMissing(field.value) || Boolean(field.empty));
+}
+// Shapes
+/** What a placeholder holds when a kind gave nothing and none of its cards has loaded yet: a title, a state, four fields. */
+export const DEFAULT_DOMAIN_CARD_SHAPE = { subtitle: false, state: true, fields: 4, figures: 0, hints: [], lines: 0, columns: 0, more: false, link: false };
+/** How many of each part a card drew. */
+export function domainCardShape(params) {
+    const lines = params.lines;
+    return {
+        subtitle: Boolean(params.subtitle || params.code || params.link),
+        state: Boolean(params.state),
+        fields: domainCardFields(params).length,
+        figures: params.figures?.length ?? 0,
+        hints: (params.figures ?? []).flatMap((figure, index) => (figure.hint ? [index] : [])),
+        lines: lines ? lines.rows.length : 0,
+        columns: lines && lines.rows.length > 0 ? lines.columns.length : 0,
+        more: Boolean(lines && (lines.more ?? 0) > 0),
+        link: Boolean(params.link),
+    };
+}
+const learned = new Map();
+/** Keeps a kind's last drawn shape, so its next placeholder holds the same parts. */
+export function rememberDomainCardShape(domainType, shape) {
+    learned.set(String(domainType), shape);
+}
+/** The shape a kind's placeholder holds: its last card's, else what its card says, else the default. */
+export function heldDomainCardShape(domainType, card) {
+    return learned.get(String(domainType)) ?? { ...DEFAULT_DOMAIN_CARD_SHAPE, ...card?.held };
+}
+/** What `load`, `view` and `extra` are told about a record. */
+export function domainCardContext(domainType, id, extra = {}) {
+    return { domainType, id, ...extra };
+}

package/dist/Helpers/DropdownHelpers.d.ts

@@ -45,8 +45,10 @@ export declare function filterItems<TItem extends DropdownItem>(items: readonly
 export declare function defaultSearchKeys(labelKey: string, descriptionKey: string, valueKey: string, columns?: readonly DropdownColumn<never>[]): string[];
 /** Whether a column draws a picture: an avatar, an image, or an icon. The first one also leads the value in the box. */
 export declare function isMediaColumn(column: Pick<DropdownColumn<never>, "type">): boolean;
-/** A column's grid track: its `width`, or `auto` for pictures and codes and `minmax(0, 1fr)` for text. */
+/** A column's grid track: its `width`, or `auto` for pictures, codes and money and `minmax(0, 1fr)` for text. */
 export declare function columnTrack(column: Pick<DropdownColumn<never>, "type" | "width">): string;
+/** Where a column's cells and heading sit: its own `align`, else at the end for money (figures line up), else at the start. */
+export declare function dropdownColumnAlign(column: Pick<DropdownColumn<never>, "type" | "align">): "start" | "center" | "end";
 /**
  * Up to two initials of a name, from its first and last words: "Ram Bahadur Sharma" → "RS", "admin" → "A",
  * "sita.rai" → "SR". Letters keep their script, so "राम शर्मा" → "रश".

package/dist/Helpers/DropdownHelpers.js

@@ -150,11 +150,15 @@ export function defaultSearchKeys(labelKey, descriptionKey, valueKey, columns) {
 export function isMediaColumn(column) {
     return column.type === "avatar" || column.type === "image" || column.type === "icon";
 }
-/** A column's grid track: its `width`, or `auto` for pictures and codes and `minmax(0, 1fr)` for text. */
+/** A column's grid track: its `width`, or `auto` for pictures, codes and money and `minmax(0, 1fr)` for text. */
 export function columnTrack(column) {
     if (column.width)
         return column.width;
-    return isMediaColumn(column) || column.type === "code" ? "auto" : "minmax(0, 1fr)";
+    return isMediaColumn(column) || column.type === "code" || column.type === "money" ? "auto" : "minmax(0, 1fr)";
+}
+/** Where a column's cells and heading sit: its own `align`, else at the end for money (figures line up), else at the start. */
+export function dropdownColumnAlign(column) {
+    return column.align ?? (column.type === "money" ? "end" : "start");
 }
 /**
  * Up to two initials of a name, from its first and last words: "Ram Bahadur Sharma" → "RS", "admin" → "A",

package/dist/Helpers/ExcelHelpers.d.ts

@@ -1,4 +1,4 @@
-import type { InputParams } from "../Interfaces/FormInterfaces.ts";
+import { type InputParams } from "../Interfaces/FormInterfaces.ts";
 import type { ExcelCellProblem, ExcelColumnInfo, ExcelDownload, ExcelReviewRow, ExcelSheetRow } from "../Interfaces/ExcelInterfaces.ts";
 /** What a spreadsheet file is called in a file picker. */
 export declare const EXCEL_FILE_ACCEPT = ".xlsx,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";

package/dist/Helpers/ExcelHelpers.js

@@ -1,3 +1,4 @@
+import { EInputTypes } from "../Interfaces/FormInterfaces.js";
 import { ExcelDataType, ExcelRowKind } from "../Interfaces/ExcelInterfaces.js";
 import { toIsoDate } from "./DateHelpers.js";
 import { toIsoTime } from "./TimeHelpers.js";
@@ -111,28 +112,28 @@ export function excelColumnInput(column) {
         ...(column.maximum === null || column.maximum === undefined ? {} : { max: column.maximum }),
     };
     if (column.isReference)
-        return { ...shared, type: "text", readOnly: true, readOnlyMessage: excelText("referenceLocked") };
+        return { ...shared, type: EInputTypes.Text, readOnly: true, readOnlyMessage: excelText("referenceLocked") };
     if (column.isReadOnly)
-        return { ...shared, type: "text", readOnly: true, readOnlyMessage: excelText("generated") };
+        return { ...shared, type: EInputTypes.Text, readOnly: true, readOnlyMessage: excelText("generated") };
     switch (column.dataType) {
         case ExcelDataType.Note:
-            return { ...shared, type: "textarea", rows: 2, required, ...lengths };
+            return { ...shared, type: EInputTypes.TextArea, rows: 2, required, ...lengths };
         case ExcelDataType.WholeNumber:
-            return { ...shared, type: "number", required, decimals: 0, ...limits };
+            return { ...shared, type: EInputTypes.Number, required, decimals: 0, ...limits };
         case ExcelDataType.Decimal:
-            return { ...shared, type: "number", required, ...limits };
+            return { ...shared, type: EInputTypes.Number, required, ...limits };
         case ExcelDataType.Amount:
-            return { ...shared, type: "number", required, decimals: 2, fixedDecimals: true, grouping: true, ...limits };
+            return { ...shared, type: EInputTypes.Number, required, decimals: 2, fixedDecimals: true, grouping: true, ...limits };
         case ExcelDataType.Date:
-            return { ...shared, type: "date", required };
+            return { ...shared, type: EInputTypes.Date, required };
         case ExcelDataType.DateTime:
-            return { ...shared, type: "text", required, pattern: MOMENT_PATTERN, placeholder: "2026-09-29 14:30" };
+            return { ...shared, type: EInputTypes.Text, required, pattern: MOMENT_PATTERN, placeholder: "2026-09-29 14:30" };
         case ExcelDataType.Time:
-            return { ...shared, type: "time", required };
+            return { ...shared, type: EInputTypes.Time, required };
         case ExcelDataType.YesNo:
-            return { ...shared, type: "dropdown", required, options: YES_NO, searchable: false };
+            return { ...shared, type: EInputTypes.Dropdown, required, options: YES_NO, searchable: false };
         default:
-            return { ...shared, type: "text", required, ...lengths };
+            return { ...shared, type: EInputTypes.Text, required, ...lengths };
     }
 }
 /** Every column of a sheet as the inputs of one editor row, in the order they read. */