@nxgt/material 3.101.0 → 3.104.0

package/dist/lib/components/ui/selection/status-menu/use-status-change.d.ts

@@ -0,0 +1,18 @@
+import { StatusChoice, StatusMenuProps } from './types.js';
+export declare const isThenable: (v: unknown) => v is PromiseLike<unknown>;
+/**
+ * Runs a pick: an `onSelect` that returns a promise is pending until it
+ * settles (the old status stays), a rejection is announced and sent to
+ * `onError`. `message` is what the live region says; `confirming` is the
+ * choice waiting for its confirmation.
+ */
+export declare function useStatusChange<V extends string>(props: StatusMenuProps<V>, labelOf: (value: V) => string): {
+    pending: boolean;
+    message: string | null;
+    confirming: StatusChoice<V> | null;
+    start: (next: V) => void;
+    ask: (choice: StatusChoice<V>) => void;
+    cancelAsk: () => void;
+    /** What the confirm dialog runs: a throw stays in the dialog and goes to `onError`. */
+    confirmRun: (next: V) => Promise<void>;
+};

package/dist/lib/components/ui/selection/status-menu/use-status-menu.d.ts

@@ -0,0 +1,30 @@
+import { StatusChoice, StatusMenuProps } from './types.js';
+/** The model of a StatusMenu: its entries, names and the open state. */
+export declare function useStatusMenu<V extends string>(props: StatusMenuProps<V>): {
+    sheet: boolean;
+    change: {
+        pending: boolean;
+        message: string | null;
+        confirming: StatusChoice<V> | null;
+        start: (next: V) => void;
+        ask: (choice: StatusChoice<V>) => void;
+        cancelAsk: () => void;
+        confirmRun: (next: V) => Promise<void>;
+    };
+    busy: boolean;
+    entries: {
+        entry: import('@nxgt/material-core/status-menu').StatusEntry<V>;
+        choice: StatusChoice<V>;
+    }[];
+    current: StatusChoice<V> | undefined;
+    reasonId: string;
+    open: boolean;
+    reasonOf: ({ entry, choice }: {
+        entry: import('@nxgt/material-core/status-menu').StatusEntry<V>;
+        choice: StatusChoice<V>;
+    }) => string | undefined;
+    lockedReason: string | undefined;
+    name: string;
+    setOpen: (next: boolean) => void;
+    pick: (next: string) => void;
+};

package/dist/lib/components/ui/widgets/calculator/partials/calculator-keypad.d.ts

@@ -1,8 +1,4 @@
-/**
- * The keys as native buttons in one `role="group"`. The group is one tab
- * stop (a roving tabindex); the arrow keys move over the grid in two
- * dimensions, Home and End along a row, with Ctrl to the first and last key.
- */
+/** The calculator's keys: the shared keypad grid bound to the engine's press. */
 export declare function CalculatorKeypad({ helpId }: {
     helpId: string;
 }): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/key-layout.d.ts

@@ -1,51 +1,5 @@
-import { CalcKey } from '@nxgt/material-core/calculator';
-import { CalculatorMessage } from '../types.js';
-import { POS_NAMES } from './pos/pos-names.js';
-import { PROGRAMMER_NAMES } from './programmer/programmer-names.js';
-import { SCIENTIFIC_NAMES } from './scientific/scientific-names.js';
-/** What a key looks like: its shape and colour follow the role. */
-export type KeyRole = 'digit' | 'operator' | 'equals' | 'utility' | 'function' | 'memory'
-/** ( and ): small keys like the memory ones. */
- | 'bracket';
-export type KeyDef = {
-    readonly id: string;
-    /** The engine key it presses. */
-    readonly key: CalcKey;
-    /** What is drawn; `aria-hidden`, the spoken name is `name`. */
-    readonly glyph: string;
-    readonly role: KeyRole;
-    /** The spoken name, the button's `aria-label`. */
-    readonly name: CalculatorMessage;
-    /** Grid units spanned, 1 by default. */
-    readonly span?: number;
-    /** What the key is on the second page (2nd): same place, another key. */
-    readonly alt?: KeyAlt;
-    /** Keys pressed one after the other, instead of `key` (`EE` is `* 10 ^`). */
-    readonly sequence?: readonly CalcKey[];
-};
-/** A key's second-page face: it keeps the button, so focus stays put. */
-export type KeyAlt = Pick<KeyDef, 'key' | 'glyph' | 'name'>;
-/** Keys by rows on a grid of `columns`. */
-export type KeyLayout = {
-    readonly columns: number;
-    readonly rows: readonly (readonly KeyDef[])[];
-    /**
-     * The first `split` rows are a pane of their own (the scientific
-     * functions): above the rest on a phone, beside it from 600px.
-     */
-    readonly split?: number;
-};
-/** The spoken names, as the `material.calculator.keys.*` leaves. */
-export type KeyName = (typeof DIGIT_NAMES)[number] | 'decimal' | 'add' | 'subtract' | 'multiply' | 'divide' | 'equals' | 'clear' | 'backspace' | 'sign' | 'percent' | 'open-paren' | 'close-paren' | 'memory-clear' | 'memory-recall' | 'memory-add' | 'memory-subtract' | (typeof SCIENTIFIC_NAMES)[number] | (typeof POS_NAMES)[number] | (typeof PROGRAMMER_NAMES)[number];
-export declare const msg: (name: KeyName, fallback: string) => CalculatorMessage;
-export declare const key: (id: string, k: CalcKey, glyph: string, role: KeyRole, name: KeyName, fallback: string, span?: number) => KeyDef;
-export declare const DIGIT_NAMES: readonly ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
-export declare const digit: (n: number, span?: number) => KeyDef;
+import { KeyDef } from '../../keypad/key-layout.js';
 /** `( ) MC MR M+ M-`: six small keys, two grid units each (twelve units a row). */
 export declare const MEMORY_ROW: readonly KeyDef[];
-/** A row of four keys, three grid units each, on the twelve-unit grid. */
-export declare const wide: (keys: readonly KeyDef[]) => readonly KeyDef[];
-/** The key a pressed `def` stands for on page one or, with 2nd, page two. */
-export declare const faceOf: (def: KeyDef, second: boolean) => KeyDef;
-/** The keys a press of `def` sends to the engine, in order. */
-export declare const keysOf: (def: KeyDef) => readonly CalcKey[];
+export type { KeyAlt, KeyDef, KeyLayout, KeyName, KeyRole, } from '../../keypad/key-layout.js';
+export { DIGIT_NAMES, digit, faceOf, key, keysOf, msg, wide, } from '../../keypad/key-layout.js';

package/dist/lib/components/ui/widgets/keypad/cash-model.d.ts

@@ -0,0 +1,16 @@
+import { KeypadSettlement } from './keypad.types.js';
+/**
+ * The total as the till charges it: rounded half-up, once, to the decimals
+ * kept (a float sum such as `0.1 + 0.2` is `0.3`, `19.999` is `20`), as
+ * canonical text. `undefined` when it is missing or not a number. Settlement,
+ * shortcuts and the summary all start from this one amount.
+ */
+export declare function cashTotal(total: number | string | undefined, digits?: number): string | undefined;
+/** The settlement of `tendered` against `total`; `undefined` while nothing is tendered or an amount is invalid. */
+export declare function cashSettlement(total: number | string | undefined, tendered: string): KeypadSettlement | undefined;
+/**
+ * The amounts to offer as one-tap tenders: the exact total, then the round
+ * amounts above it, at most four, rounded to `digits` and none above `max`
+ * (the keypad would hold less than the button says).
+ */
+export declare function cashShortcuts(total: number | string | undefined, denominations: readonly number[] | undefined, max?: number, digits?: number, limit?: number): string[];

package/dist/lib/components/ui/widgets/keypad/index.d.ts

@@ -0,0 +1,5 @@
+export { Keypad } from './keypad.js';
+export type { KeypadBinding, KeypadEntry, KeypadOperation, KeypadProps, KeypadSettlement, KeypadVariant, } from './keypad.types.js';
+export type { UseKeypadNumberOptions } from './keypad-binding.js';
+export { useKeypadNumber } from './use-keypad-number.js';
+export { type UseKeypadQuantityOptions, useKeypadQuantity, } from './use-keypad-quantity.js';

package/dist/lib/components/ui/widgets/keypad/key-layout.d.ts

@@ -0,0 +1,56 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { MaterialLocaleKey } from '../../../../i18n/types.js';
+import { POS_NAMES } from '../calculator/variants/pos/pos-names.js';
+import { PROGRAMMER_NAMES } from '../calculator/variants/programmer/programmer-names.js';
+import { SCIENTIFIC_NAMES } from '../calculator/variants/scientific/scientific-names.js';
+/** What a key looks like: its shape and colour follow the role. */
+export type KeyRole = 'digit' | 'operator' | 'equals' | 'utility' | 'function' | 'memory'
+/** ( and ): small keys like the memory ones. */
+ | 'bracket';
+/** A UI string: the `material.*` key and the English text used without a provider. */
+export type KeyMessage = {
+    readonly key: MaterialLocaleKey;
+    readonly fallback: string;
+};
+export type KeyDef = {
+    readonly id: string;
+    /** The engine key it presses. */
+    readonly key: CalcKey;
+    /** What is drawn; `aria-hidden`, the spoken name is `name`. */
+    readonly glyph: string;
+    readonly role: KeyRole;
+    /** The spoken name, the button's `aria-label`. */
+    readonly name: KeyMessage;
+    /** An app's own spoken name, which replaces the translated `name`. */
+    readonly label?: string;
+    /** Grid units spanned, 1 by default. */
+    readonly span?: number;
+    /** What the key is on the second page (2nd): same place, another key. */
+    readonly alt?: KeyAlt;
+    /** Keys pressed one after the other, instead of `key` (`EE` is `* 10 ^`). */
+    readonly sequence?: readonly CalcKey[];
+};
+/** A key's second-page face: it keeps the button, so focus stays put. */
+export type KeyAlt = Pick<KeyDef, 'key' | 'glyph' | 'name'>;
+/** Keys by rows on a grid of `columns`. */
+export type KeyLayout = {
+    readonly columns: number;
+    readonly rows: readonly (readonly KeyDef[])[];
+    /**
+     * The first `split` rows are a pane of their own (the scientific
+     * functions): above the rest on a phone, beside it from 600px.
+     */
+    readonly split?: number;
+};
+/** A row of four keys, three grid units each, on the twelve-unit grid. */
+export declare const wide: (keys: readonly KeyDef[]) => readonly KeyDef[];
+/** The key a pressed `def` stands for on page one or, with 2nd, page two. */
+export declare const faceOf: (def: KeyDef, second: boolean) => KeyDef;
+/** The keys a press of `def` sends to the engine, in order. */
+export declare const keysOf: (def: KeyDef) => readonly CalcKey[];
+/** The spoken names, as the `material.calculator.keys.*` leaves. */
+export type KeyName = (typeof DIGIT_NAMES)[number] | 'decimal' | 'add' | 'subtract' | 'multiply' | 'divide' | 'equals' | 'clear' | 'backspace' | 'sign' | 'percent' | 'open-paren' | 'close-paren' | 'memory-clear' | 'memory-recall' | 'memory-add' | 'memory-subtract' | (typeof SCIENTIFIC_NAMES)[number] | (typeof POS_NAMES)[number] | (typeof PROGRAMMER_NAMES)[number];
+export declare const msg: (name: KeyName, fallback: string) => KeyMessage;
+export declare const key: (id: string, k: CalcKey, glyph: string, role: KeyRole, name: KeyName, fallback: string, span?: number) => KeyDef;
+export declare const DIGIT_NAMES: readonly ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
+export declare const digit: (n: number, span?: number) => KeyDef;

package/dist/lib/components/ui/widgets/keypad/keypad-binding.d.ts

@@ -0,0 +1,32 @@
+import { KeypadBinding, KeypadProps } from './keypad.types.js';
+export type UseKeypadNumberOptions = {
+    /** The field's number (`null` or `undefined` while empty). */
+    value: number | null | undefined;
+    onChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    /** Decimals kept; a `currency`'s own by default. */
+    fractionDigits?: number;
+    currency?: string;
+    /** The field holds whole minor units (CurrencyField's `minorUnits`): 1250 is 12.50. */
+    minorUnits?: boolean;
+};
+/** The decimals a binding keeps; `undefined` for any number of them. */
+export declare function bindingDigits(o: UseKeypadNumberOptions): number | undefined;
+/** A field number as the keypad's value text; `''` when empty or not a finite number. */
+export declare function numberToText(value: number | null | undefined, o: Pick<UseKeypadNumberOptions, 'minorUnits'> & {
+    digits?: number;
+}): string;
+/** The keypad's value text as the field's number: `null` when empty. */
+export declare function textToNumber(text: string, o: Pick<UseKeypadNumberOptions, 'minorUnits'> & {
+    digits?: number;
+}): number | null;
+/** The keypad binding of a number held by a field. */
+export declare function numberBinding(o: UseKeypadNumberOptions): KeypadBinding;
+/**
+ * The props a keypad runs with: an explicit prop wins over the binding's, both
+ * `onValueChange` handlers are called, and the display is off for a bound
+ * keypad unless asked for or `operations` are offered (the field shows the
+ * number, but not the calculation in progress).
+ */
+export declare function resolveBinding(props: KeypadProps): KeypadProps;

package/dist/lib/components/ui/widgets/keypad/keypad-cash.d.ts

@@ -0,0 +1,28 @@
+import { KeypadSettlement } from './keypad.types.js';
+type Format = {
+    digits: number | undefined;
+    locale?: string;
+    currency?: string;
+};
+/** The total, and under it the change or what is still due once something is tendered. */
+export declare function KeypadCashSummary({ total, settlement, digits, locale, currency, }: Format & {
+    total: string;
+    settlement: KeypadSettlement | undefined;
+}): import("react").JSX.Element;
+/** One-tap tendered amounts: the exact total, then the round amounts above it. */
+export declare function KeypadShortcuts({ amounts, onPick, disabled, digits, locale, currency, }: Format & {
+    amounts: readonly string[];
+    onPick: (amount: string) => void;
+    disabled?: boolean;
+}): import("react").JSX.Element | null;
+/** The cash variant's parts above the keys: the total with its settlement, then the shortcuts. */
+export declare function KeypadCash({ cash, total, onPick, disabled, digits, locale, currency, }: Format & {
+    cash: {
+        settlement: KeypadSettlement | undefined;
+        shortcuts: readonly string[];
+    };
+    total: string;
+    onPick: (amount: string) => void;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/keypad/keypad-display.d.ts

@@ -0,0 +1,11 @@
+import { useKeypad } from './use-keypad.js';
+/** A canonical amount for a locale at fixed decimals, with the currency's symbol when given. */
+export declare function formatAmount(text: string, digits: number | undefined, locale: string | undefined, currency: string | undefined): string;
+type Props = {
+    keypad: ReturnType<typeof useKeypad>;
+    locale?: string;
+    currency?: string;
+};
+/** The amount above the keys; after `=` it is the result, not the expression. */
+export declare function KeypadDisplay({ keypad: k, locale, currency }: Props): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/keypad/keypad-entry.d.ts

@@ -0,0 +1,39 @@
+import { CalcKey, CalcSession } from '@nxgt/material-core/calculator';
+import { KeypadOperation } from './keypad.types.js';
+export declare const ALL_OPERATIONS: readonly KeypadOperation[];
+/** The operations a keypad offers for its `operations` prop. */
+export declare function operationsOf(operations: boolean | readonly KeypadOperation[] | undefined): readonly KeypadOperation[];
+/** The operations a keypad runs with: none in minor entry nor in the cash variant. */
+export declare function keypadOperations(o: {
+    entry?: 'decimal' | 'minor';
+    variant?: 'standard' | 'cash';
+    operations?: boolean | readonly KeypadOperation[];
+}): readonly KeypadOperation[];
+export declare const operationKey: (o: KeypadOperation) => CalcKey;
+export type EntryConfig = {
+    entry: 'decimal' | 'minor';
+    /** Decimals kept; `undefined` for any number of them. */
+    digits: number | undefined;
+    operations: readonly KeypadOperation[];
+    max?: number;
+};
+/** A session that holds `value` as typed. */
+export declare function seedSession(value: string): CalcSession;
+/** The value text of a session: the result after `=`, the number typed, `''` mid-calculation. */
+export declare function sessionValue(s: CalcSession): string;
+/** True while the expression is more than one number (a calculation to evaluate). */
+export declare const isPending: (s: CalcSession) => boolean;
+/**
+ * One key of a keypad. Pure: the next session comes back, or the same one
+ * when the key does nothing here (an operation not offered, a decimal key at
+ * no decimals, a digit past `max` or past the decimals kept).
+ */
+export declare function pressEntry(s: CalcSession, key: CalcKey, cfg: EntryConfig): CalcSession;
+/** `value` held between `min` and `max` (either may be absent); `''` stays `''`. */
+export declare function clampValue(value: string, min?: number, max?: number): string;
+/**
+ * The value to tell the app after a key, or `undefined` when there is nothing
+ * to tell: while a calculation waits the field keeps the number it had, and a
+ * key that leaves the value as reported says nothing.
+ */
+export declare function valueToReport(next: CalcSession, reported: string): string | undefined;

package/dist/lib/components/ui/widgets/keypad/keypad-grid.d.ts

@@ -0,0 +1,27 @@
+import { KeyDef, KeyLayout } from './key-layout.js';
+export type KeypadGridProps = {
+    layout: KeyLayout;
+    /** The group's accessible name. */
+    label: string;
+    /** The id of the element that describes the group. */
+    describedBy?: string;
+    /** What the decimal key draws: the locale's separator. */
+    decimal: string;
+    /** The face a key shows (the calculator's 2nd page); the key itself by default. */
+    faceOf?: (def: KeyDef) => KeyDef;
+    /** A key that stays focusable, says so, and presses nothing. */
+    unavailable?: (def: KeyDef) => boolean;
+    onPress: (def: KeyDef) => void;
+    /** The group's `data-slot` and class, then its keys' and panes' (the calculator's by default). */
+    slot?: string;
+    className?: string;
+    keySlot?: string;
+    keyClassName?: string;
+    paneClassName?: string;
+};
+/**
+ * The keys as native buttons in one `role="group"`. The group is one tab
+ * stop (a roving tabindex); the arrow keys move over the grid in two
+ * dimensions, Home and End along a row, with Ctrl to the first and last key.
+ */
+export declare function KeypadGrid({ layout, label, describedBy, decimal, faceOf, unavailable, onPress, slot, className, keySlot, keyClassName, paneClassName, }: KeypadGridProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/{calculator/partials/calculator-key.d.ts → keypad/keypad-key.d.ts}

@@ -1,6 +1,6 @@
 import { Ref } from 'react';
-import { KeyDef } from '../variants/key-layout.js';
-export type CalculatorKeyProps = {
+import { KeyDef } from './key-layout.js';
+export type KeypadKeyProps = {
     def: KeyDef;
     row: number;
     index: number;
@@ -12,6 +12,9 @@ export type CalculatorKeyProps = {
     onPress: (def: KeyDef) => void;
     onFocus: (row: number, index: number) => void;
     buttonRef: Ref<HTMLButtonElement>;
+    /** The button's `data-slot` and class (the calculator's by default). */
+    slot?: string;
+    className?: string;
 };
 /** One native button. Its glyph is decoration; the spoken name is the label. */
-export declare function CalculatorKey({ def, row, index, tabIndex, decimal, unavailable, onPress, onFocus, buttonRef, }: CalculatorKeyProps): import("react").JSX.Element;
+export declare function KeypadKey({ def, row, index, tabIndex, decimal, unavailable, onPress, onFocus, buttonRef, slot, className, }: KeypadKeyProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/keypad/keypad-layout.d.ts

@@ -0,0 +1,19 @@
+import { KeyLayout } from './key-layout.js';
+import { KeypadOperation } from './keypad.types.js';
+export type KeypadLayoutOptions = {
+    operations: readonly KeypadOperation[];
+    /** The decimal key; off at no decimals, and when digits go in as minor units. */
+    decimal: boolean;
+    /** The commit key's text and name, when the app names it. */
+    commitLabel?: string;
+    /** True while a calculation waits: the commit key then reads "=". */
+    pending: boolean;
+    /** The cash variant: the commit key tenders. */
+    cash?: boolean;
+};
+/**
+ * Twelve grid units: 7 8 9 C / 4 5 6 ⌫ / 1 2 3 00 / 0 . and the commit key,
+ * with a row of the offered operations above. `wide` makes four keys of three
+ * units; the last row's `0` takes six.
+ */
+export declare function keypadLayout(o: KeypadLayoutOptions): KeyLayout;

package/dist/lib/components/ui/widgets/{calculator/partials → keypad}/keypad-navigation.d.ts

@@ -1,4 +1,4 @@
-import { KeyLayout } from '../variants/key-layout.js';
+import { KeyLayout } from './key-layout.js';
 export type Cell = {
     readonly row: number;
     readonly index: number;

package/dist/lib/components/ui/widgets/keypad/keypad.d.ts

@@ -0,0 +1,9 @@
+import { KeypadProps } from './keypad.types.js';
+/**
+ * `Keypad`: touch and keyboard numeric entry outside the Calculator widget,
+ * for a quantity, a price, a percentage. The digits go in as typed
+ * (`entry="decimal"`) or like a till (`entry="minor"`); `operations` adds
+ * calculation keys. The value is a canonical decimal string. Styled by
+ * `calculator.css`.
+ */
+export declare function Keypad(raw: KeypadProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/keypad/keypad.types.d.ts

@@ -0,0 +1,91 @@
+/** A calculation key the keypad can offer next to the digits. */
+export type KeypadOperation = 'add' | 'subtract' | 'multiply' | 'divide';
+/** What the keypad is for: plain `standard` entry, or a `cash` tender against a `total`. */
+export type KeypadVariant = 'standard' | 'cash';
+/**
+ * The outcome of a cash tender, amounts as canonical decimal text: the
+ * customer gave enough (`change` may be `'0'`), or still owes `due`.
+ */
+export type KeypadSettlement = {
+    readonly status: 'paid';
+    readonly change: string;
+} | {
+    readonly status: 'short';
+    readonly due: string;
+};
+/** How the digits go in: `decimal` as typed (`1`, `2`, `.`, `5` is 12.5), or `minor` like a till (`1`, `2`, `5` is 1.25). */
+export type KeypadEntry = 'decimal' | 'minor';
+/**
+ * A field's number as the keypad reads and writes it (from `useKeypadNumber`
+ * or `useKeypadQuantity`). Pass it whole as the `binding` prop. The field keeps its number while a calculation is typed; `onValueChange` is called with the result at `=`.
+ */
+export type KeypadBinding = {
+    /** The field's number as canonical decimal text (`''` when empty). */
+    value: string;
+    onValueChange: (value: string) => void;
+    /** The decimals the field keeps. */
+    fractionDigits?: number;
+    min?: number;
+    max?: number;
+};
+export type KeypadProps = {
+    /** The value as canonical decimal text (`'12.5'`, `''` when empty). Controlled with `onValueChange`. */
+    value?: string;
+    /** The value of an uncontrolled keypad. */
+    defaultValue?: string;
+    /** Called with the new value text whenever it changes (`''` when emptied); not while a calculation waits for `=`. */
+    onValueChange?: (value: string) => void;
+    /**
+     * The commit key (or Enter): the value, within `min` and `max`, and the
+     * expression that gave it (`'2+3'`; the value itself without operations).
+     * With operations, the key first evaluates a pending calculation.
+     */
+    onCommit?: (value: string, expression: string) => void;
+    /** Calculation keys: `true` offers all four, a list picks some. Off by default; `minor` entry and the `cash` variant take none. */
+    operations?: boolean | readonly KeypadOperation[];
+    /** The locale of the decimal separator, grouping and spoken results; the page's by default. */
+    locale?: string;
+    /** Decimals kept: further digits are refused, a calculation is rounded half-up to them. The currency's by default. */
+    fractionDigits?: number;
+    /** An ISO 4217 code: the amount shows its symbol and takes the currency's decimals. */
+    currency?: string;
+    /** The commit key clamps the value to this floor and ceiling; typing past `max` is refused. */
+    min?: number;
+    max?: number;
+    /**
+     * Where the physical keyboard works: `'focus'` (default) when focus is in
+     * the keypad, `'global'` anywhere on the page outside fields, `false` never.
+     */
+    keyboard?: 'focus' | 'global' | false;
+    /** Key height: `comfortable` (default) or `large` for a till. */
+    size?: 'comfortable' | 'large';
+    /** The commit key's name and text; the translated "Enter" by default. */
+    commitLabel?: string;
+    /** Keys do nothing and say so. */
+    disabled?: boolean;
+    /** `'standard'` (default) or `'cash'`: tender against `total`, with change, bill shortcuts and `onTender`. */
+    variant?: KeypadVariant;
+    /** `cash`: the amount due, as a number or exact decimal text. */
+    total?: number | string;
+    /** `cash`: the bills and coins (`[5, 10, 20, 50]`) whose next round amount at or above `total` is offered as an amount button after the exact total (four buttons at most, none above `max`). A button fills the amount; the commit key tenders. */
+    denominations?: readonly number[];
+    /**
+     * `cash`: the commit key (or Enter) with the amount tendered and the
+     * settlement, once a valid `total` is set and an amount is entered (a missing
+     * or negative `total` does nothing). `onCommit` is not called in this variant. The app owns the charge; the keypad only reports it. A
+     * short payment is a settlement too, not an error.
+     */
+    onTender?: (tendered: string, settlement: KeypadSettlement) => void;
+    /** `'decimal'` (default) or `'minor'`. */
+    entry?: KeypadEntry;
+    /**
+     * A field the keypad types into (`useKeypadNumber`, `useKeypadQuantity`).
+     * Its value, decimals, `min` and `max` apply unless the same prop is given.
+     */
+    binding?: KeypadBinding;
+    /** Shows the amount above the keys: by default when no `binding` is given or `operations` are offered (the field shows the number, not the calculation). */
+    display?: boolean;
+    /** The keypad's accessible name; "Keypad" by default. */
+    label?: string;
+    className?: string;
+};

package/dist/lib/components/ui/widgets/keypad/use-keypad-cash.d.ts

@@ -0,0 +1,14 @@
+import { KeypadProps } from './keypad.types.js';
+import { useKeypad } from './use-keypad.js';
+/**
+ * What the cash variant adds to the keypad: the settlement of what is
+ * tendered so far, the bill shortcuts, and the sentence the live region says
+ * ("Change 2.65", "Still due 1.00"). Nothing for the standard variant.
+ */
+export declare function useKeypadCash(p: Pick<KeypadProps, 'variant' | 'total' | 'denominations' | 'locale' | 'currency' | 'max'>, k: ReturnType<typeof useKeypad>): {
+    cash: boolean;
+    total: string | undefined;
+    settlement: import('./keypad.types.js').KeypadSettlement | undefined;
+    shortcuts: string[];
+    said: string | undefined;
+};

package/dist/lib/components/ui/widgets/keypad/use-keypad-keyboard.d.ts

@@ -0,0 +1,7 @@
+import { useKeypad } from './use-keypad.js';
+/**
+ * The physical keyboard: `onKeyDown` for the keypad's root (the `'focus'`
+ * mode), and with `global` a window listener too. Enter commits, the other
+ * keys press; a key the keypad does not offer is left to the page.
+ */
+export declare function useKeypadKeyboard(k: ReturnType<typeof useKeypad>, locale: string | undefined, global: boolean): (ev: import('react').KeyboardEvent<HTMLElement>) => void;

package/dist/lib/components/ui/widgets/keypad/use-keypad-number.d.ts

@@ -0,0 +1,10 @@
+import { KeypadBinding } from './keypad.types.js';
+import { UseKeypadNumberOptions } from './keypad-binding.js';
+/**
+ * Binds a Keypad to a number field's value (`NumberField`, `PercentField`,
+ * `CurrencyField`, including its `minorUnits`): pass the result as the
+ * keypad's `binding`. The keypad reads the field's number, writes each change
+ * back, holds `min` / `max` and the decimals, and hides its own display unless
+ * `operations` are offered.
+ */
+export declare function useKeypadNumber(options: UseKeypadNumberOptions): KeypadBinding;

package/dist/lib/components/ui/widgets/keypad/use-keypad-quantity.d.ts

@@ -0,0 +1,16 @@
+import { QuantityValue } from '../../fields/quantity-field/types.js';
+import { KeypadBinding } from './keypad.types.js';
+export type UseKeypadQuantityOptions = {
+    /** The QuantityField's value: the amount and its unit. */
+    value: QuantityValue | undefined;
+    /** Called on each change; `value` is `null` when the keypad is emptied. */
+    onChange?: (value: QuantityValue) => void;
+    min?: number;
+    max?: number;
+    fractionDigits?: number;
+};
+/**
+ * Binds a Keypad to a `QuantityField`'s amount: the keypad types the number,
+ * the unit stays as the field holds it.
+ */
+export declare function useKeypadQuantity(options: UseKeypadQuantityOptions): KeypadBinding;

package/dist/lib/components/ui/widgets/keypad/use-keypad-value.d.ts

@@ -0,0 +1,17 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+import { RefObject } from 'react';
+import { KeypadProps } from './keypad.types.js';
+type ValueOptions = Pick<KeypadProps, 'value' | 'defaultValue' | 'onValueChange'>;
+/**
+ * The keypad's session and its link to the app's value. A controlled `value`
+ * is the truth on every render: when it differs from the value the keypad
+ * last held or reported, the session is replaced by it (the app cleared, set
+ * or refused a change), even while a calculation waits. `report` tells the
+ * app the value, except while a calculation waits for `=`.
+ */
+export declare function useKeypadValue(o: ValueOptions, onValueChange: RefObject<ValueOptions['onValueChange']>): {
+    session: CalcSession;
+    setInner: import('react').Dispatch<import('react').SetStateAction<CalcSession>>;
+    report: (next: CalcSession) => void;
+};
+export {};

package/dist/lib/components/ui/widgets/keypad/use-keypad.d.ts

@@ -0,0 +1,23 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { KeypadProps } from './keypad.types.js';
+type Options = Pick<KeypadProps, 'value' | 'defaultValue' | 'onValueChange' | 'onCommit' | 'variant' | 'total' | 'onTender' | 'operations' | 'fractionDigits' | 'currency' | 'min' | 'max' | 'entry' | 'disabled'>;
+/**
+ * The keypad's state: a calculator session, held as typed. A controlled
+ * `value` is the truth on every render: when it differs from the value the
+ * keypad last held or reported, it replaces the session (the app cleared, set
+ * or refused a change), even while a calculation waits; `onValueChange` fires when a key changes the
+ * value text, not on every key (a `.` or an operator does not) and never
+ * while a calculation waits for `=`.
+ */
+export declare function useKeypad(o: Options): {
+    session: import('@nxgt/material-core/calculator').CalcSession;
+    value: string;
+    pending: boolean;
+    digits: number | undefined;
+    entry: import('./keypad.types.js').KeypadEntry;
+    operations: readonly import('./keypad.types.js').KeypadOperation[];
+    press: (key: CalcKey) => void;
+    commit: () => void;
+    set: (value: string) => void;
+};
+export {};

package/dist/lib/components/ui/widgets/native-charts/core/label-placement.d.ts

@@ -0,0 +1,25 @@
+/** A point of a series on the plot, in pixels. */
+export type PlotPoint = {
+    x: number;
+    y: number;
+};
+/**
+ * Where a threshold's label goes: the first of end-above, end-below, start-above
+ * and start-below whose text box stays inside the plot and meets no series
+ * segment nor marker within its x-range. When none is free, the label stays at
+ * the end, clamped inside the plot (`thresholdLabelBaseline`). `edge` is the x
+ * of the label's end side (its right edge), `startEdge` of its start side (its
+ * left edge); `width` is the text's width. The label box spans `edge - width`
+ * to `edge` at the end side, `startEdge` to `startEdge + width` at the start.
+ */
+export declare function placeThresholdLabel(input: {
+    lineY: number;
+    floor: number;
+    edge: number;
+    startEdge: number;
+    width: number;
+    series: readonly (readonly (PlotPoint | null)[])[];
+}): {
+    side: 'end' | 'start';
+    baseline: number;
+};

package/dist/lib/components/ui/widgets/native-charts/core/reference-geometry.d.ts

@@ -57,9 +57,10 @@ export declare function markersBetween(ys: readonly (number | null)[], x: (index
  * of the plot. `pointYs` are the y of the series' points under the label's
  * width: when one would sit on the label above the line and none would
  * under it, the label goes to the other side, so it never covers a point or
- * its marker.
+ * its marker. `floor` is the plot's height: the label stays inside the plot,
+ * so a side with no room is left for the other, or the baseline is clamped.
  */
-export declare function thresholdLabelBaseline(lineY: number, pointYs?: readonly number[]): number;
+export declare function thresholdLabelBaseline(lineY: number, pointYs?: readonly number[], floor?: number): number;
 /** How many of `values` lie outside `band` (a missing value is not counted, nor one in a row where a stepped band has no range), and how many there are. */
 export declare function outsideBand(values: readonly (number | null | undefined)[], band: Pick<RefBand, 'from' | 'to' | 'ranges'>): {
     outside: number;