nexus-shared 1.1.20 → 2.0.0

package/dist/Helpers/TableStore.js

@@ -0,0 +1,530 @@
+import { errorMessage, isAbortError } from "./ApiResponses.js";
+import { DEFAULT_MAX_SELECTION, DEFAULT_PAGE_SIZE, MIN_COLUMN_WIDTH, clampPage, moveColumnKey, nextSort, queryRows, readTablePage, rowKeyText } from "./TableHelpers.js";
+/** How long a changed or added row stays highlighted. */
+export const TABLE_FLASH_MS = 1600;
+const EMPTY_MAP = new Map();
+const EMPTY_SET = new Set();
+const EMPTY_LIST = [];
+const NO_WIDTHS = {};
+const NO_PINS = {};
+function initialState(pageSize) {
+    return {
+        status: "loading",
+        refreshing: false,
+        error: null,
+        rows: [],
+        offset: 0,
+        total: 0,
+        matches: 0,
+        query: { search: "", sort: null, page: 1, pageSize },
+        selected: EMPTY_MAP,
+        busy: EMPTY_SET,
+        flashed: EMPTY_SET,
+        hidden: EMPTY_SET,
+        order: EMPTY_LIST,
+        widths: NO_WIDTHS,
+        pinned: NO_PINS,
+    };
+}
+export class TableStore {
+    options = { columns: [], rowKey: "id", paging: "client" };
+    state;
+    listeners = new Set();
+    /** Every row, when the table has them all. */
+    all = [];
+    /** Whether `all` holds rows given by the page (not loaded). */
+    given = null;
+    texts = new WeakMap();
+    controller = null;
+    seq = 0;
+    flashTimer;
+    reloadTimer;
+    /** A load was stopped by `dispose`. */
+    interrupted = false;
+    constructor(pageSize = DEFAULT_PAGE_SIZE) {
+        this.state = initialState(pageSize);
+    }
+    /* Reading */
+    getState = () => this.state;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    get paging() {
+        return this.options.paging;
+    }
+    get columns() {
+        return this.options.columns;
+    }
+    /** A row's key as text. */
+    keyOf(row) {
+        return rowKeyText(row, this.options.rowKey);
+    }
+    /** Every row the table has: all of them in a client table, the page's in a server table. */
+    getRows() {
+        return this.options.paging === "server" ? [...this.state.rows] : [...this.all];
+    }
+    /** The row with this key, if the table has it. */
+    getRow(key) {
+        const text = String(key);
+        const list = this.options.paging === "server" ? this.state.rows : this.all;
+        return list.find(row => this.keyOf(row) === text) ?? this.state.selected.get(text);
+    }
+    getSelected() {
+        return [...this.state.selected.values()];
+    }
+    /**
+     * Every row the table would show for its query, in order: the whole searched and sorted list for a client table, the
+     * page a server sent for a server table. An export and a print write these.
+     */
+    getViewRows() {
+        if (this.options.paging === "server")
+            return [...this.state.rows];
+        return queryRows(this.all, this.options.columns, { ...this.state.query, page: 1, pageSize: Number.MAX_SAFE_INTEGER }, this.texts).rows;
+    }
+    isSelected(row) {
+        return this.state.selected.has(this.keyOf(row));
+    }
+    /* Setting up */
+    /** Takes the component's props. Tells nobody: the component calls it while rendering. */
+    configure(options) {
+        if (options.columns !== this.options.columns)
+            this.texts = new WeakMap();
+        this.options = options;
+    }
+    set(changes) {
+        const previous = this.state;
+        this.state = { ...previous, ...changes };
+        for (const listener of this.listeners)
+            listener();
+        if (changes.selected && changes.selected !== previous.selected)
+            this.options.onSelectionChange?.(this.getSelected());
+    }
+    /** Puts back what was saved on this device (page size, sort, columns), before the first load. Tells nobody. */
+    restore(saved) {
+        const query = { ...this.state.query };
+        if (saved.pageSize && saved.pageSize > 0)
+            query.pageSize = saved.pageSize;
+        if (saved.sort !== undefined)
+            query.sort = saved.sort;
+        this.state = {
+            ...this.state,
+            query,
+            hidden: saved.hidden ? new Set(saved.hidden) : this.state.hidden,
+            order: saved.order ?? this.state.order,
+            widths: saved.widths ?? this.state.widths,
+            pinned: saved.pinned ?? this.state.pinned,
+        };
+    }
+    /* Rows given by the page */
+    /** Shows these rows: every row there is. The table searches, sorts, and pages them. */
+    setRows(rows) {
+        if (rows === this.given)
+            return;
+        this.given = rows;
+        this.all = [...rows];
+        this.dropMissingSelection();
+        this.view({ status: "ready", error: null, refreshing: false });
+    }
+    /* Loading */
+    /**
+     * Loads the rows again: every row for a client table, the page for a server table. A newer load stops an older one,
+     * so the table always shows the answer to its latest query. Resolves when the rows are in (or the load failed).
+     */
+    async reload({ quiet, reset = false } = {}) {
+        const load = this.options.load;
+        if (!load) {
+            if (this.given)
+                this.view();
+            return;
+        }
+        clearTimeout(this.reloadTimer);
+        this.interrupted = false;
+        this.controller?.abort();
+        const controller = new AbortController();
+        this.controller = controller;
+        const seq = ++this.seq;
+        if (reset) {
+            this.state = { ...this.state, query: { ...this.state.query, search: "", page: 1 } };
+            if (this.state.selected.size)
+                this.set({ selected: EMPTY_MAP });
+        }
+        const keepRows = quiet ?? (this.state.status === "ready" && !reset);
+        const query = this.state.query;
+        const request = this.options.paging === "server" ? query : { ...query, page: 1, pageSize: Number.MAX_SAFE_INTEGER };
+        let answer;
+        try {
+            answer = load(request, controller.signal);
+        }
+        catch (error) {
+            this.fail(error, seq);
+            return;
+        }
+        // An answer without a promise (a cache) shows at once: no placeholders, no second paint.
+        if (!(answer instanceof Promise)) {
+            this.take(answer, seq);
+            return;
+        }
+        if (keepRows)
+            this.set({ refreshing: true });
+        else
+            this.set({ status: "loading", refreshing: false, error: null, rows: [] });
+        try {
+            const result = await answer;
+            if (controller.signal.aborted)
+                return;
+            this.take(result, seq);
+        }
+        catch (error) {
+            if (controller.signal.aborted || isAbortError(error))
+                return;
+            this.fail(error, seq);
+        }
+    }
+    take(answer, seq) {
+        if (seq !== this.seq)
+            return;
+        this.controller = null;
+        const page = readTablePage(answer);
+        if (this.options.paging === "server") {
+            const query = { ...this.state.query, page: clampPage(this.state.query.page, page.matches, this.state.query.pageSize) };
+            // A page past the end (rows were removed elsewhere) loads the last page instead.
+            if (query.page !== this.state.query.page && page.rows.length === 0 && page.matches > 0) {
+                this.state = { ...this.state, query };
+                void this.reload({ quiet: true });
+                return;
+            }
+            this.set({
+                status: "ready",
+                refreshing: false,
+                error: null,
+                rows: page.rows,
+                total: page.total,
+                matches: page.matches,
+                offset: (query.page - 1) * query.pageSize,
+                query,
+                selected: this.refreshSelected(page.rows),
+            });
+            return;
+        }
+        this.all = page.rows;
+        this.given = null;
+        this.dropMissingSelection();
+        this.view({ status: "ready", refreshing: false, error: null });
+    }
+    fail(error, seq) {
+        if (seq !== this.seq)
+            return;
+        this.controller = null;
+        this.set({ status: "error", refreshing: false, error: errorMessage(error, "The rows could not be loaded.") });
+    }
+    /** Searches, sorts, and pages every row (client tables), then tells the table. */
+    view(extra = {}) {
+        if (this.options.paging === "server") {
+            this.set(extra);
+            return;
+        }
+        const query = { ...this.state.query, ...extra.query };
+        const result = queryRows(this.all, this.options.columns, query, this.texts);
+        const page = result.page;
+        this.set({
+            ...extra,
+            rows: result.rows,
+            total: this.all.length,
+            matches: result.matches,
+            offset: (page - 1) * query.pageSize,
+            query: page === query.page ? query : { ...query, page },
+        });
+    }
+    /** Changes the query: a client table shows it at once, a server table loads it. */
+    query(changes) {
+        const query = { ...this.state.query, ...changes };
+        if (this.options.paging === "server" && this.options.load) {
+            this.state = { ...this.state, query };
+            void this.reload({ quiet: this.state.status === "ready" });
+        }
+        else
+            this.view({ query });
+    }
+    setSearch(search) {
+        const text = search.trim();
+        if (text === this.state.query.search)
+            return;
+        this.query({ search: text, page: 1 });
+    }
+    setSort(sort) {
+        this.query({ sort, page: 1 });
+    }
+    /** Sorts by a column: ascending, then descending, then back to no sort. */
+    toggleSort(key) {
+        this.setSort(nextSort(this.state.query.sort, key));
+    }
+    setPage(page) {
+        const next = clampPage(page, this.state.matches, this.state.query.pageSize);
+        if (next === this.state.query.page)
+            return;
+        this.query({ page: next });
+    }
+    /** Changes the rows per page, keeping the first row of the page in view. */
+    setPageSize(pageSize) {
+        if (pageSize === this.state.query.pageSize || pageSize < 1)
+            return;
+        const first = this.state.offset;
+        this.query({ pageSize, page: Math.floor(first / pageSize) + 1 });
+    }
+    /* Changing rows from outside: a saved record, a deleted one */
+    /**
+     * Adds a row, or replaces the row with its key. A new row goes first (a server page grows by one until the next load),
+     * and is highlighted for a moment.
+     */
+    upsert(row, { at = "start", flash = true } = {}) {
+        const key = this.keyOf(row);
+        if (this.options.paging === "server") {
+            const index = this.state.rows.findIndex(candidate => this.keyOf(candidate) === key);
+            const rows = [...this.state.rows];
+            let { total, matches } = this.state;
+            if (index >= 0)
+                rows[index] = row;
+            else {
+                if (at === "start")
+                    rows.unshift(row);
+                else
+                    rows.push(row);
+                total++;
+                matches++;
+            }
+            this.set({ rows, total, matches, selected: this.replaceSelected(key, row), status: "ready" });
+        }
+        else {
+            const index = this.all.findIndex(candidate => this.keyOf(candidate) === key);
+            if (index >= 0)
+                this.all[index] = row;
+            else if (at === "start")
+                this.all.unshift(row);
+            else
+                this.all.push(row);
+            this.all = [...this.all];
+            this.view({ selected: this.replaceSelected(key, row), status: "ready" });
+        }
+        if (flash && key)
+            this.flash([key]);
+    }
+    /**
+     * Changes fields of the row with this key: an object of new values, or a function of the row. Quiet by default; pass
+     * `{ flash: true }` to highlight the row, such as after an action the user took on it.
+     */
+    patch(key, changes, { flash = false } = {}) {
+        const text = String(key);
+        const row = this.getRow(text);
+        if (!row)
+            return;
+        const next = typeof changes === "function" ? changes(row) : { ...row, ...changes };
+        this.upsert(next, { flash });
+    }
+    /**
+     * Takes rows out: they moved to another list or were deleted. A server table loads its page again in the background,
+     * so the page fills up and the counts stay right.
+     */
+    remove(keys) {
+        if (keys.length === 0)
+            return;
+        const gone = new Set(keys.map(String));
+        const selected = new Map(this.state.selected);
+        for (const key of gone)
+            selected.delete(key);
+        const busy = new Set([...this.state.busy].filter(key => !gone.has(key)));
+        if (this.options.paging === "server") {
+            const rows = this.state.rows.filter(row => !gone.has(this.keyOf(row)));
+            const removed = this.state.rows.length - rows.length;
+            this.set({
+                rows,
+                total: Math.max(0, this.state.total - removed),
+                matches: Math.max(0, this.state.matches - removed),
+                selected: selected.size === this.state.selected.size ? this.state.selected : selected,
+                busy,
+            });
+            // A short wait lets several removals (a mass action's rows) share one load.
+            clearTimeout(this.reloadTimer);
+            this.reloadTimer = setTimeout(() => void this.reload({ quiet: true }), 60);
+            return;
+        }
+        this.all = this.all.filter(row => !gone.has(this.keyOf(row)));
+        this.view({ selected: selected.size === this.state.selected.size ? this.state.selected : selected, busy });
+    }
+    /* Selection */
+    /** Selects or unselects rows, up to `maxSelection`. Returns how many rows it could not select. */
+    select(rows, on) {
+        const selected = new Map(this.state.selected);
+        const most = this.options.maxSelection ?? DEFAULT_MAX_SELECTION;
+        let refused = 0;
+        for (const row of rows) {
+            const key = this.keyOf(row);
+            if (!key)
+                continue;
+            if (!on)
+                selected.delete(key);
+            else if (selected.has(key))
+                selected.set(key, row);
+            else if (selected.size < most)
+                selected.set(key, row);
+            else
+                refused++;
+        }
+        this.set({ selected });
+        return refused;
+    }
+    /** Selects or unselects every row on the page. */
+    selectPage(on) {
+        return this.select(this.state.rows, on);
+    }
+    clearSelection() {
+        if (this.state.selected.size)
+            this.set({ selected: EMPTY_MAP });
+    }
+    // Selected rows keep their newest values, so a mass action sends what the table shows.
+    replaceSelected(key, row) {
+        if (!this.state.selected.has(key))
+            return this.state.selected;
+        const selected = new Map(this.state.selected);
+        selected.set(key, row);
+        return selected;
+    }
+    refreshSelected(rows) {
+        if (!this.state.selected.size)
+            return this.state.selected;
+        let selected = null;
+        for (const row of rows) {
+            const key = this.keyOf(row);
+            if (this.state.selected.has(key) && this.state.selected.get(key) !== row)
+                (selected ??= new Map(this.state.selected)).set(key, row);
+        }
+        return selected ?? this.state.selected;
+    }
+    /** A client table forgets selected rows that are gone from its rows. */
+    dropMissingSelection() {
+        if (!this.state.selected.size)
+            return;
+        const byKey = new Map(this.all.map(row => [this.keyOf(row), row]));
+        const selected = new Map();
+        let changed = false;
+        for (const [key, old] of this.state.selected) {
+            const row = byKey.get(key);
+            if (row)
+                selected.set(key, row);
+            changed ||= row !== old;
+        }
+        if (!changed)
+            return;
+        this.state = { ...this.state, selected: selected.size ? selected : EMPTY_MAP };
+        this.options.onSelectionChange?.(this.getSelected());
+    }
+    /* Rows with an action running, and rows to highlight */
+    setBusy(keys, on) {
+        const busy = new Set(this.state.busy);
+        for (const key of keys) {
+            if (on)
+                busy.add(String(key));
+            else
+                busy.delete(String(key));
+        }
+        this.set({ busy });
+    }
+    flash(keys) {
+        this.set({ flashed: new Set([...this.state.flashed, ...keys.map(String)]) });
+        clearTimeout(this.flashTimer);
+        this.flashTimer = setTimeout(() => this.set({ flashed: EMPTY_SET }), TABLE_FLASH_MS);
+    }
+    /* Columns: shown or hidden, their order, their widths, and the ones pinned to a side */
+    setHidden(key, hidden) {
+        if (this.state.hidden.has(key) === hidden)
+            return;
+        const next = new Set(this.state.hidden);
+        if (hidden)
+            next.add(key);
+        else
+            next.delete(key);
+        this.set({ hidden: next });
+    }
+    /** The order of every column, by key. Keys the columns do not have are kept, in case the column comes back. */
+    setOrder(order) {
+        this.set({ order: [...order] });
+    }
+    /** Moves a column to just before another one, or to the end when `beforeKey` is null. */
+    moveColumn(key, beforeKey) {
+        const keys = this.state.order.length ? this.state.order : this.options.columns.map(column => column.key);
+        const next = moveColumnKey(keys, key, beforeKey);
+        if (next.join() === keys.join())
+            return;
+        this.set({ order: next });
+    }
+    /** Sets the width of one column in pixels, or takes the width away (`null`), letting the content size it again. */
+    setWidth(key, width) {
+        const widths = { ...this.state.widths };
+        if (width === null) {
+            if (widths[key] === undefined)
+                return;
+            delete widths[key];
+        }
+        else {
+            const rounded = Math.round(Math.max(MIN_COLUMN_WIDTH, width));
+            if (widths[key] === rounded)
+                return;
+            widths[key] = rounded;
+        }
+        this.set({ widths });
+    }
+    /** Sets several widths at once: what the table measured when the user started to resize a column. */
+    setWidths(widths) {
+        this.set({ widths: { ...this.state.widths, ...widths } });
+    }
+    /** Back to widths that follow the content. */
+    clearWidths() {
+        if (Object.keys(this.state.widths).length === 0)
+            return;
+        this.set({ widths: NO_WIDTHS });
+    }
+    /** Keeps a column on the left or the right while the others scroll, or lets it scroll again (`null`). */
+    setPinned(key, side) {
+        if ((this.state.pinned[key] ?? null) === side)
+            return;
+        const pinned = { ...this.state.pinned };
+        if (side === null)
+            delete pinned[key];
+        else
+            pinned[key] = side;
+        this.set({ pinned });
+    }
+    /** Every column back as its params say: the given order, widths from the content, no pins, and the hidden ones. */
+    resetColumns() {
+        this.set({ order: EMPTY_LIST, widths: NO_WIDTHS, pinned: NO_PINS, hidden: new Set(this.options.columns.filter(column => column.hidden).map(column => column.key)) });
+    }
+    /** Whether the user has arranged the columns: an order, a width, a pin, or a hidden column of their own. */
+    hasColumnChanges() {
+        const { order, widths, pinned, hidden } = this.state;
+        if (order.length || Object.keys(widths).length || Object.keys(pinned).length)
+            return true;
+        const byParams = this.options.columns.filter(column => column.hidden).map(column => column.key);
+        return hidden.size !== byParams.length || byParams.some(key => !hidden.has(key));
+    }
+    /** Stops a load that runs and the timers. The table calls it when it goes away. */
+    dispose() {
+        if (this.controller)
+            this.interrupted = true;
+        this.controller?.abort();
+        this.controller = null;
+        clearTimeout(this.flashTimer);
+        clearTimeout(this.reloadTimer);
+    }
+    /**
+     * Loads again what `dispose` stopped, when the table comes back: React's Strict Mode unmounts and mounts every table
+     * once in development, and a store given as `table` can move to another place on the page.
+     */
+    resume() {
+        if (!this.interrupted)
+            return;
+        this.interrupted = false;
+        void this.reload();
+    }
+}

package/dist/Helpers/ThemeHelpers.d.ts

@@ -0,0 +1,15 @@
+import { type ThemeMode, type ThemeOption } from "../Interfaces/ThemeInterfaces.ts";
+export declare const THEME_ID_PATTERN: RegExp;
+export interface ThemeScriptOptions {
+    /** Themes a saved choice may name. Default: every built-in theme. */
+    themes?: readonly ThemeOption[];
+    /** Theme before the visitor chooses one. Default `nexus`. */
+    defaultTheme?: string;
+    /** Mode before the visitor chooses one. Default `system`. */
+    defaultMode?: ThemeMode;
+}
+/**
+ * JavaScript that sets the saved theme and mode on `<html>` before the page paints, so a page never flashes
+ * the default colors first. `ThemeScript` renders it; use this directly only outside React.
+ */
+export declare function themeScript({ themes, defaultTheme, defaultMode }?: ThemeScriptOptions): string;

package/dist/Helpers/ThemeHelpers.js

@@ -0,0 +1,16 @@
+import { DEFAULT_THEME, NEXUS_THEMES, THEME_ATTRIBUTE, THEME_MODE_ATTRIBUTE, THEME_MODE_STORAGE_KEY, THEME_STORAGE_KEY, } from "../Interfaces/ThemeInterfaces.js";
+export const THEME_ID_PATTERN = /^[a-z0-9-]+$/;
+/**
+ * JavaScript that sets the saved theme and mode on `<html>` before the page paints, so a page never flashes
+ * the default colors first. `ThemeScript` renders it; use this directly only outside React.
+ */
+export function themeScript({ themes = NEXUS_THEMES, defaultTheme = DEFAULT_THEME, defaultMode = "system" } = {}) {
+    const ids = themes.map(theme => theme.id).filter(id => THEME_ID_PATTERN.test(id));
+    const config = [ids, defaultTheme, defaultMode, THEME_STORAGE_KEY, THEME_MODE_STORAGE_KEY, THEME_ATTRIBUTE, THEME_MODE_ATTRIBUTE];
+    // "<" is escaped so no value can close the <script> element.
+    const json = JSON.stringify(config).replace(/</g, "\\u003c");
+    return ("(function(c){var d=document.documentElement,t=c[1],m=c[2];" +
+        "try{var s=localStorage,a=s.getItem(c[3]),b=s.getItem(c[4]);if(c[0].indexOf(a)>-1)t=a;if(b==='light'||b==='dark'||b==='system')m=b}catch(e){}" +
+        "if(c[0].indexOf(t)>-1)d.setAttribute(c[5],t);if(m==='light'||m==='dark')d.setAttribute(c[6],m)" +
+        `})(${json})`);
+}

package/dist/Helpers/TimeHelpers.d.ts

@@ -0,0 +1,73 @@
+import { type DateScript, type TimeInput } from "../Interfaces/DateInterfaces.ts";
+export declare const SECONDS_PER_DAY = 86400;
+/** "14:30" or "14:30:15": hours 00 to 23, a two-digit minute, an optional two-digit second. */
+export declare const ISO_TIME_PATTERN: RegExp;
+/** Options of `formatTime` and `parseTimeText`. */
+export interface TimeFormatOptions {
+    /** Tokens `HH` `H` 24-hour, `hh` `h` 12-hour, `mm` `m` minute, `ss` `s` second, `A` AM/PM, `a` am/pm. Default `hh:mm A`. */
+    format?: string;
+    /** `devanagari` writes Nepali digits and पूर्वाह्न/अपराह्न. Default `latin`. */
+    script?: DateScript;
+    /** Whether the time has seconds: `true` adds them to a format without them, `false` removes them. Default: as the format says. */
+    seconds?: boolean;
+}
+/** Whether text is an ISO time: "14:30" or "14:30:15". */
+export declare function isIsoTime(text: unknown): text is string;
+/** Seconds since midnight of an ISO time. The text must be an ISO time (`isIsoTime`). */
+export declare function timeToSeconds(iso: string): number;
+/** The ISO time of seconds since midnight, wrapping past midnight both ways: "HH:mm", or "HH:mm:ss" with `seconds`. */
+export declare function secondsToIsoTime(total: number, seconds?: boolean): string;
+/**
+ * Turns anything a time can arrive as into an ISO time, or `null`:
+ * - "14:30", "9:05", "14:30:15", "14:30:15.250" (a .NET `TimeOnly` or SQL `time`);
+ * - an ISO date-time with a zone, "2026-09-17T08:45:00Z", becomes the browser's local time of that instant;
+ * - one without a zone, "2026-09-17T14:30:00", keeps its time part;
+ * - a `Date` gives its local time, like `new Date()` for now.
+ * Without `seconds` the result is "HH:mm" and any seconds are dropped; with it, "HH:mm:ss".
+ */
+export declare function toIsoTime(input: TimeInput, seconds?: boolean): string | null;
+/** The time now where the browser is. */
+export declare function nowIsoTime(seconds?: boolean): string;
+/** Adds minutes (negative to go back), wrapping past midnight: `addMinutes("23:30", 45)` is "00:15". Keeps the value's seconds. */
+export declare function addMinutes(iso: string, minutes: number): string;
+/** Negative when `a` is earlier than `b`. "14:30" and "14:30:00" are the same time. */
+export declare const compareIsoTimes: (a: string, b: string) => number;
+/**
+ * Whether a time lies within inclusive limits, given as seconds since midnight. With `max` earlier than `min` the
+ * range runs past midnight: 22:00 to 06:00 allows 23:00 and 05:00, not 12:00.
+ */
+export declare function isSecondsInRange(value: number, min: number | null, max: number | null): boolean;
+/** Whether an ISO time lies within limits given as time inputs; see `isSecondsInRange` for ranges past midnight. */
+export declare function isTimeInRange(iso: string, min?: TimeInput, max?: TimeInput): boolean;
+/** A step in seconds as the components use it: a whole number from 1 to a day, 60 when missing or invalid. */
+export declare function normalizeTimeStep(step: number | undefined): number;
+/** Whether a step needs seconds: any step that is not a whole number of minutes. */
+export declare const stepHasSeconds: (step: number | undefined) => boolean;
+/** "15 minutes", "1 hour", "30 seconds", "1 minute 30 seconds": a step as words, for messages. */
+export declare function describeTimeStep(step: number): string;
+/** Whether a time format is on a 12-hour clock: it has an `hh` or `h` token. */
+export declare const isTwelveHourFormat: (format: string) => boolean;
+/** The names of the two halves of the day: AM and PM, or पूर्वाह्न and अपराह्न. */
+export declare function getMeridiemNames(script?: DateScript): readonly [string, string];
+/**
+ * A format with or without seconds: `true` adds ":ss" after the minutes of a format that has none ("hh:mm A" gives
+ * "hh:mm:ss A"), `false` removes the seconds and the separator before them. `undefined` keeps the format.
+ */
+export declare function timeFormatWithSeconds(format: string, seconds: boolean | undefined): string;
+/**
+ * Writes a time with a format of tokens: `HH` `H` 24-hour, `hh` `h` 12-hour, `mm` `m` minute, `ss` `s` second, `A`
+ * AM/PM, `a` am/pm. "hh:mm A" gives 02:30 PM; "HH:mm" gives 14:30. With the Devanagari script, digits and the
+ * halves of the day are Nepali: ०२:३० अपराह्न. Returns "" for an empty or invalid input.
+ */
+export declare function formatTime(input: TimeInput, options?: TimeFormatOptions): string;
+/**
+ * Reads a time the user typed, on either clock: "14:30", "2:30 pm", "2.30p", "230 PM", "1430", "9", "12 am",
+ * "14:30:15", "०२:३० अपराह्न". Without AM or PM the hours are read on a 24-hour clock, so "2:30" is 02:30. Returns the
+ * ISO time, "HH:mm" (typed seconds are dropped) or "HH:mm:ss" with `seconds`, or `null` for text that is not a time.
+ */
+export declare function parseTimeText(text: string, options?: Pick<TimeFormatOptions, "seconds">): string | null;
+/**
+ * The times a list of slots offers: every `step` seconds from `min` (or midnight) to `max` (or the end of the day),
+ * past midnight when `max` is earlier than `min`. Returns ISO times, with seconds when the step needs them.
+ */
+export declare function listTimeSlots(step: number, min?: TimeInput, max?: TimeInput): string[];