@nxgt/material 3.75.0 → 3.76.0

package/dist/lib/components/ui/widgets/calculator/currency.d.ts

@@ -0,0 +1,9 @@
+import { Decimal } from '@nxgt/material-core/calculator';
+/** An amount as plain text with `digits` decimals and no grouping (`'12.50'`). */
+export declare const formatPlain: (d: Decimal, digits: number) => string;
+/** An amount in `locale` with `digits` decimals, then the currency code after a no-break space. */
+export declare function formatMoney(d: Decimal, o: {
+    locale?: string;
+    currency?: string;
+    digits: number;
+}): string;

package/dist/lib/components/ui/widgets/calculator/engine.d.ts

@@ -0,0 +1,22 @@
+import { AngleMode, CalcOptions, Notation, PercentMode, RoundingMode } from '@nxgt/material-core/calculator';
+import { ProgrammerState } from './variants/programmer/programmer-word.js';
+/** How a result is written: `auto` switches to powers of ten when it must. */
+export type ResultNotation = 'auto' | 'sci' | 'eng';
+/** The props that decide how the engine calculates and how it is shown. */
+export type EngineSettings = {
+    readonly locale?: string;
+    readonly percent: PercentMode;
+    readonly precision?: number;
+    readonly rounding?: RoundingMode;
+    /** The scientific functions and constants (the Scientific variant). */
+    readonly scientific?: boolean;
+    /** The unit of `sin`, `cos`, `tan` and their inverses; degrees by default. */
+    readonly angle?: AngleMode;
+    readonly notation?: ResultNotation;
+    /** The word and the base of the Programmer variant. */
+    readonly programmer?: ProgrammerState;
+};
+/** The engine options for `settings`; unset fields keep the engine's defaults. */
+export declare function engineOptions(settings: EngineSettings): CalcOptions;
+/** The core formatter's notation for a result notation. */
+export declare const formatNotation: (n: ResultNotation | undefined) => Notation;

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

@@ -0,0 +1,3 @@
+export { Calculator } from './calculator.js';
+export { CALCULATOR_VARIANTS, type CalculatorConversionProps, type CalculatorCurrencyRates, type CalculatorFeedback, type CalculatorPosProps, type CalculatorProps, type CalculatorRatesSource, type CalculatorVariant, } from './types.js';
+export type { PosTicket, PosTicketDiscount, } from './variants/pos/pos-ticket-data.js';

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

@@ -0,0 +1,2 @@
+/** The polite live region: results, errors, memory, copy and paste; not every key. */
+export declare function CalculatorAnnouncer(): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function CalculatorDisplay({ tapeId }: {
+    tapeId: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+import { Ref } from 'react';
+import { KeyDef } from '../variants/key-layout.js';
+export type CalculatorKeyProps = {
+    def: KeyDef;
+    row: number;
+    index: number;
+    tabIndex: 0 | -1;
+    /** What the decimal key draws: the locale's separator. */
+    decimal: string;
+    /** A digit the base does not have: it stays focusable, says so, and presses nothing. */
+    unavailable?: boolean;
+    onPress: (def: KeyDef) => void;
+    onFocus: (row: number, index: number) => void;
+    buttonRef: Ref<HTMLButtonElement>;
+};
+/** 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;

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

@@ -0,0 +1,8 @@
+/**
+ * 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 CalculatorKeypad({ helpId }: {
+    helpId: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+/**
+ * The body of a variant whose code is loading: a display and a keypad of
+ * skeleton blocks sized like Standard's, so the frame keeps its size when the
+ * variant arrives. A polite status says so; a failed load offers a retry.
+ */
+export declare function CalculatorLoading(): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+/** The "M" chip: shown while the memory holds a value, and spoken with it. */
+export declare function CalculatorMemory(): import("react").JSX.Element | null;

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+/**
+ * The panel's one polite live region: a result is read once the fields stop
+ * changing, not at every digit typed.
+ */
+export declare function AnnounceProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Says `text` after the quiet delay; nothing while `text` is empty or the tab is hidden. */
+export declare function useAnnounce(text: string | null, active: boolean): void;

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

@@ -0,0 +1,9 @@
+import { ComponentType } from 'react';
+/**
+ * The body of a variant that has a panel instead of the display and the
+ * keypad: typing and pasting in its fields must not reach the calculator's
+ * own keys, so both events stop here.
+ */
+export declare function CalculatorPanelBody({ panel: Panel, }: {
+    panel: ComponentType;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+/** How long the big line is, so CSS can shrink it instead of clipping it. */
+export declare const sizeOf: (text: string) => "long" | "short" | "xlong";
+/** The expression and the result: named, not a tab stop (keys are typed from the keypad). */
+export declare function CalculatorScreen(): import("react").JSX.Element;

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

@@ -0,0 +1,21 @@
+import { useMaterialTranslation } from '../../../../../i18n/use-material-translation.js';
+export type Choice<T extends string> = {
+    readonly id: T;
+    readonly glyph: string;
+    readonly name: string;
+    /** The spoken name when the application already translated it. */
+    readonly spoken?: string;
+};
+type SegmentProps<T extends string> = {
+    label: string;
+    choices: readonly Choice<T>[];
+    value: T;
+    nameKey?: (id: T) => Parameters<ReturnType<typeof useMaterialTranslation>['t']>[0];
+    onChange: (id: T) => void;
+};
+/**
+ * One choice among a few: native buttons with `aria-pressed` in a named group
+ * (no inline style, unlike a roving-focus group), each its own tab stop.
+ */
+export declare function Segment<T extends string>({ label, choices, value, nameKey, onChange, }: SegmentProps<T>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { ClipboardEventHandler, KeyboardEventHandler } from 'react';
+export type CalculatorShellProps = {
+    className?: string;
+    'aria-label'?: string;
+    onKeyDown: KeyboardEventHandler<HTMLDivElement>;
+    onPaste: ClipboardEventHandler<HTMLDivElement>;
+};
+/** The frame: switcher, display, keypad, tape and the live region. */
+export declare function CalculatorShell({ className, 'aria-label': ariaLabel, onKeyDown, onPaste, }: CalculatorShellProps): import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+/** The variant tabs; the variant's body is the open panel. */
+export declare function CalculatorSwitcher({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+/** The tape: every `=`, newest first, each replayable and its result reusable. */
+export declare function CalculatorTape({ id }: {
+    id: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+/** Above the screen: the memory chip, copy, paste and the history toggle. */
+export declare function CalculatorTools({ tapeId }: {
+    tapeId: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,24 @@
+import { KeyLayout } from '../variants/key-layout.js';
+export type Cell = {
+    readonly row: number;
+    readonly index: number;
+};
+type Placed = {
+    start: number;
+    end: number;
+};
+/** Each key's first and last column, for moving up and down a grid with wide keys. */
+export declare function placeKeys(layout: KeyLayout): Placed[][];
+/**
+ * Where an arrow key, Home or End leads from `cell`; `undefined` when it goes
+ * nowhere (the edge). Up and down keep the column the key starts in.
+ */
+export declare function moveCell(placed: readonly (readonly Placed[])[], cell: Cell, key: string, ctrl?: boolean, 
+/** With the function pane beside the keys: how many rows it has. */
+split?: number): Cell | undefined;
+/**
+ * True when the two panes sit side by side. Stacked, a pane is
+ * `display: contents` (it has no box of its own), so its first key stands in.
+ */
+export declare function panesBeside(keypad: Pick<HTMLElement, 'querySelectorAll'>): boolean;
+export {};

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

@@ -0,0 +1,102 @@
+import { PercentMode, RoundingMode } from '@nxgt/material-core/calculator';
+import { WordSize } from '@nxgt/material-core/calculator/programmer';
+import { CurrencyRates } from '@nxgt/material-core/calculator/units';
+import { MaterialLocaleKey } from '../../../../i18n/types.js';
+import { PosTicket } from './variants/pos/pos-ticket-data.js';
+export declare const CALCULATOR_VARIANTS: readonly ["standard", "scientific", "pos", "financial", "conversion", "programmer"];
+export type CalculatorVariant = (typeof CALCULATOR_VARIANTS)[number];
+/** A UI string: the `material.*` key and the English text used without a provider. */
+export type CalculatorMessage = {
+    readonly key: MaterialLocaleKey;
+    readonly fallback: string;
+};
+/** Haptics and sound on a key press. Both are off unless asked for. */
+export type CalculatorFeedback = {
+    /** `navigator.vibrate(8)` on a key press, never under reduced motion. */
+    haptics?: boolean;
+    /** A short tick from the Web Audio API, created on the first press. */
+    sound?: boolean;
+};
+/** What the point-of-sale variant is told by the application; no other variant reads it. */
+export type CalculatorPosProps = {
+    /** The VAT rates, in percent (`20`, `'5.5'`); the first is the default. None: no VAT. */
+    vatRates?: readonly (number | string)[];
+    /** The bills and coins, for the round amounts offered as tendered (`[5, 10, 20, 50]`). */
+    denominations?: readonly (number | string)[];
+    /** Whether the prices typed include the VAT (default) or the VAT is added to them. */
+    pricesIncludeVat?: boolean;
+    /** The Charge button: the exact total (`'12.50'`) and the ticket as plain data. */
+    onCharge?: (total: string, ticket: PosTicket) => void;
+};
+/** What the Programmer variant is told by the application; no other variant reads it. */
+export type CalculatorProgrammerProps = {
+    /** The word the Programmer variant starts with: 8, 16, 32 or 64 bits (default 64). */
+    defaultWordSize?: WordSize;
+    /** Whether that word is signed (two's complement, default) or unsigned. */
+    defaultSigned?: boolean;
+};
+/** Exchange rates as the application quotes them: `{ base, rates, asOf? }`. */
+export type CalculatorCurrencyRates = CurrencyRates;
+/** What the conversion variant is told by the application; no other variant reads it. */
+export type CalculatorConversionProps = {
+    /**
+     * Exchange rates for the Currency category: an object
+     * `{ base, rates, asOf? }` (`rates[code]` is how much of `code` one `base`
+     * buys), or a function that fetches them and must stop when `signal`
+     * aborts. None: the Currency category is not offered.
+     */
+    currencyRates?: CalculatorRatesSource;
+};
+export type CalculatorRatesSource = CalculatorCurrencyRates | ((signal: AbortSignal) => Promise<CalculatorCurrencyRates>);
+export type CalculatorProps = CalculatorPosProps & CalculatorConversionProps & CalculatorProgrammerProps & {
+    /**
+     * ISO 4217 code of the amounts (the point of sale's and the Financial
+     * variant's): sets the decimals (JPY 0, EUR 2, KWD 3) and is written beside
+     * them. None: two decimals and no code.
+     */
+    currency?: string;
+    /** The variant shown (controlled). Pair it with `onVariantChange`. */
+    variant?: CalculatorVariant;
+    /** The variant shown first (uncontrolled). Defaults to `standard`. */
+    defaultVariant?: CalculatorVariant;
+    onVariantChange?: (variant: CalculatorVariant) => void;
+    /**
+     * The variants the switcher offers; one or none hides the switcher. Every
+     * registered variant by default, a list that grows with each variant the
+     * library adds: pass `variants` for a fixed set.
+     */
+    variants?: readonly CalculatorVariant[];
+    /** Number format and separators (BCP 47). Defaults to the page's language. */
+    locale?: string;
+    /** Significant digits kept by the engine, 34 by default. */
+    precision?: number;
+    rounding?: RoundingMode;
+    /** `contextual` (`100 + 10%` is 110) or `literal` (`/100`); contextual by default. */
+    percent?: PercentMode;
+    /**
+     * Keep the tape and the memory in `localStorage` (after mount; versioned).
+     * `true` by default; `{ key }` names the slot when several calculators
+     * live on one origin; `false` keeps nothing.
+     */
+    persist?: boolean | {
+        key: string;
+    };
+    feedback?: CalculatorFeedback;
+    /** Also take the keys typed anywhere on the page (never in a field). */
+    globalKeyboard?: boolean;
+    /**
+     * A number the calculator opens with (`'12.5'`), as a finished result: a
+     * digit starts a new number, an operator carries on from it.
+     */
+    defaultValue?: string;
+    /**
+     * Called with the exact value of the display (the result, or the live
+     * preview of the expression) each time it changes; `''` when there is
+     * none (empty, error, unfinished).
+     */
+    onValueChange?: (value: string) => void;
+    /** Called with the exact result and its canonical expression after each `=`. */
+    onResult?: (value: string, expression: string) => void;
+    className?: string;
+    'aria-label'?: string;
+};

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

@@ -0,0 +1,19 @@
+import { Announcement } from './calculator-announce.js';
+import { ProgrammerState } from './variants/programmer/programmer-word.js';
+type ClipboardActions = {
+    announce: (m: Announcement | null) => void;
+    paste: (p: {
+        text: string;
+        locale?: string;
+    }) => void;
+};
+/**
+ * The copy and paste buttons and the copy key. A keyboard paste is the
+ * root's `onPaste` (it reads the event's data, no permission needed).
+ */
+export declare function useCalculatorClipboard(value: string, locale: string | undefined, actions: ClipboardActions, programmer?: ProgrammerState): {
+    copy: () => Promise<boolean>;
+    paste: () => Promise<void>;
+    pasteEvent: (text: string) => void;
+};
+export {};

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

@@ -0,0 +1,4 @@
+import { CalculatorContextValue } from './calculator-context.js';
+import { CalculatorProps } from './types.js';
+/** What the conversion variant reads from the props, stable between renders. */
+export declare function useConversionProps(props: Pick<CalculatorProps, 'currencyRates' | 'precision' | 'rounding'>): CalculatorContextValue['conversion'];

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

@@ -0,0 +1,3 @@
+import { CalculatorFeedback } from './types.js';
+/** `feel()` for each key press: a short vibration and/or tick when asked for. */
+export declare function useCalculatorFeedback(feedback: CalculatorFeedback | undefined): () => void;

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

@@ -0,0 +1,22 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { KeyboardEvent } from 'react';
+import { CalculatorKeyEvent } from './calculator-keyboard.js';
+type Handlers = {
+    locale?: string;
+    accepts: (key: CalcKey) => boolean;
+    global?: boolean;
+    programmer?: boolean;
+    onKey: (key: CalcKey) => void;
+    onCopy: () => void;
+    /** First look at an event; `true` means it was used (Escape closing the tape). */
+    beforeKey?: (ev: CalculatorKeyEvent) => boolean;
+};
+/**
+ * The keyboard: `onKeyDown` for the calculator's root, and, with `global`, a
+ * window listener that also takes the keys typed elsewhere on the page (never
+ * in a field). A key the calculator uses has its default prevented, which is
+ * how the two listeners avoid taking one event twice. A paste is not a key
+ * here: the browser's paste event reaches the root's `onPaste`.
+ */
+export declare function useCalculatorKeyboard(h: Handlers): (ev: KeyboardEvent<HTMLElement>) => void;
+export {};

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

@@ -0,0 +1,14 @@
+import { CalculatorState } from './calculator.slice.js';
+import { CalculatorProps } from './types.js';
+/**
+ * Reads the tape and the memory after mount (never during render, so the
+ * server and the first client frame agree), then writes them back, debounced,
+ * whenever they change. `persist={false}` reads and writes nothing.
+ */
+export declare function useCalculatorPersistence(persist: CalculatorProps['persist'], state: CalculatorState, actions: {
+    restore: (p: {
+        history: CalculatorState['history'];
+        memory: string;
+    }) => void;
+    markRestored: () => void;
+}): void;

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

@@ -0,0 +1,25 @@
+import { CalculatorPosProps } from './types.js';
+import { PosFormat } from './variants/pos/pos-announce.js';
+import { PosAction, PosEnv, PosState } from './variants/pos/pos-types.js';
+import { PosView } from './variants/pos/pos-view.js';
+/** The props the point of sale reads: its own and the shared `currency`. */
+export type PosProps = CalculatorPosProps & {
+    currency?: string;
+};
+/** What the point-of-sale panel is given: options, the ticket's view, actions. */
+export type PosModel = {
+    props: PosProps;
+    env: PosEnv;
+    format: PosFormat;
+    /** `null` while another variant is shown or this one loads: nothing is computed then. */
+    view: PosView | null;
+    dispatch: (action: PosAction) => void;
+};
+type Send = (payload: {
+    action: PosAction;
+    env: PosEnv;
+    format: PosFormat;
+}) => void;
+/** The options, the engine's view of the ticket and the dispatcher of the POS actions. */
+export declare function useCalculatorPos(props: PosProps, locale: string | undefined, state: PosState, active: boolean, send: Send): PosModel;
+export {};

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

@@ -0,0 +1,26 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { EngineSettings } from './engine.js';
+import { PosAction } from './variants/pos/pos-types.js';
+import { unavailableDigit } from './variants/programmer/programmer-announce.js';
+type Deps = {
+    actions: {
+        press: (p: {
+            key: CalcKey;
+            settings: EngineSettings;
+            id: string;
+        }) => void;
+        announce: (m: ReturnType<typeof unavailableDigit>) => void;
+    };
+    feel: () => void;
+    settings: EngineSettings;
+    isPos: boolean;
+    dispatchPos: (action: PosAction) => void;
+    t: Parameters<typeof unavailableDigit>[1];
+};
+/**
+ * The key press of the keypad and the keyboard: a digit the Programmer base
+ * does not have presses nothing and says so; the point of sale takes its keys
+ * itself; every other key moves the session.
+ */
+export declare function useCalculatorPress(d: Deps): (key: CalcKey) => void;
+export {};

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

@@ -0,0 +1,29 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+/** The part of the history toggle `closeOverlay` uses; a button fits. */
+export type ToggleLike = {
+    getClientRects: () => {
+        length: number;
+    };
+    focus: () => void;
+};
+/**
+ * Closes the tape and hands focus to the toggle, when the tape is open and the
+ * toggle is on screen (it only is while the tape lies over the keypad).
+ * Returns whether it did.
+ */
+export declare function closeOverlay(open: boolean, toggle: ToggleLike | null | undefined, close: () => void): boolean;
+/** Tells `onResult` about a finished calculation; nothing otherwise. */
+export declare function reportResult(onResult: ((value: string, expression: string) => void) | undefined, justEvaluated: boolean, result: string, expression: string): void;
+/**
+ * The tape's focus: it moves into the tape when it opens, and Escape closes
+ * it back to the history toggle while it lies over the keypad (the toggle is
+ * only on screen then, under 720px); on a wide calculator the tape is always
+ * there and Escape means `C`.
+ */
+export declare function useCalculatorTape(open: boolean, close: () => void): {
+    toggleRef: import('react').RefObject<HTMLButtonElement | null>;
+    tapeRef: import('react').RefObject<HTMLDivElement | null>;
+    closeTapeOverlay: () => boolean;
+};
+/** Calls `onResult` with the exact result and its expression after each `=`. */
+export declare function useResultCallback(onResult: ((value: string, expression: string) => void) | undefined, { justEvaluated, result, expression }: CalcSession): void;

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

@@ -0,0 +1,9 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+/**
+ * The session a calculator opens with: `value` (a plain decimal, `'12.5'`) as
+ * a finished result, so a digit starts a new number and an operator carries on
+ * from it. Anything that is not a number opens an empty calculator.
+ */
+export declare function seedSession(value: string | undefined): CalcSession;
+/** Tells `onValueChange` the display's exact value each time it changes. */
+export declare function useValueCallback(onValueChange: ((value: string) => void) | undefined, value: string): void;

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

@@ -0,0 +1,23 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { CalculatorProps, CalculatorVariant } from './types.js';
+import { VariantDefinition } from './variants/registry.js';
+export type ResolvedVariant = {
+    variant: CalculatorVariant;
+    variants: readonly CalculatorVariant[];
+    definition: VariantDefinition;
+    accepts: (key: CalcKey) => boolean;
+};
+/**
+ * The variant shown: `variant` when controlled, else the chrome's, held to the
+ * ones that are registered and listed in `variants`; Standard otherwise. A
+ * variant other than Standard loads on demand: its `definition` is a pending
+ * one until its chunk arrives.
+ */
+export declare function useCalculatorVariant(props: Pick<CalculatorProps, 'variant' | 'variants'>, chrome: CalculatorVariant): ResolvedVariant;
+/**
+ * Switches to `next` and tells `onChange`, once: choosing the variant already
+ * shown does nothing.
+ */
+export declare function changeVariant(next: CalculatorVariant, current: CalculatorVariant, set: (variant: CalculatorVariant) => void, onChange?: (variant: CalculatorVariant) => void): void;
+/** `changeVariant` as a stable callback for the switcher. */
+export declare function useVariantChange(current: CalculatorVariant, set: (variant: CalculatorVariant) => void, onChange?: (variant: CalculatorVariant) => void): (variant: CalculatorVariant) => void;

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

@@ -0,0 +1,10 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { CalculatorContextValue } from './calculator-context.js';
+import { CalculatorProps } from './types.js';
+export type CalculatorModel = CalculatorContextValue & {
+    accepts: (key: CalcKey) => boolean;
+    /** Closes the tape when it lays over the keypad (Escape); `false` when not. */
+    closeTapeOverlay: () => boolean;
+};
+/** The calculator's state, wired to its props: thin over the slice and the engine. */
+export declare function useCalculator(props: CalculatorProps): CalculatorModel;

package/dist/lib/components/ui/widgets/calculator/use-engine-settings.d.ts

@@ -0,0 +1,10 @@
+import { CalculatorState } from './calculator.slice.js';
+import { EngineSettings } from './engine.js';
+import { CalculatorProps } from './types.js';
+import { VariantDefinition } from './variants/registry.js';
+/**
+ * What the engine and the display are told: the props, and for the Scientific
+ * variant its angle unit and notation. Scientific is `literal` for percent
+ * (`100 + 10%` is `100.1`) unless the `percent` prop says otherwise.
+ */
+export declare function useEngineSettings(props: Pick<CalculatorProps, 'percent' | 'precision' | 'rounding'>, locale: string | undefined, state: Pick<CalculatorState, 'angle' | 'notation' | 'programmer'>, definition: Pick<VariantDefinition, 'scientific' | 'programmer'>): EngineSettings;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-fields.d.ts

@@ -0,0 +1,19 @@
+type Option = {
+    readonly id: string;
+    readonly label: string;
+};
+/** A labelled native `<select>`, the library's field box. */
+export declare function ChoiceSelect({ label, value, options, disabled, onChange, slot, }: {
+    label: string;
+    value: string;
+    options: readonly Option[];
+    disabled?: boolean;
+    onChange: (id: string) => void;
+    slot: string;
+}): import("react").JSX.Element;
+/** Swaps the two units; its glyph turns a half turn each time. */
+export declare function SwapButton({ onClick, disabled, }: {
+    onClick: () => void;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-labels.d.ts

@@ -0,0 +1,17 @@
+export type UnitLabel = {
+    /** `Kilometre`, `Euro`. */
+    readonly name: string;
+    /** `km`, `EUR`. */
+    readonly symbol: string;
+    /** `Kilometre (km)`: the option's text. */
+    readonly option: string;
+};
+/**
+ * The names of the categories and units, in the application's i18n language
+ * (the one the unit names are translated in; `locale` only formats numbers
+ * and dates).
+ */
+export declare function useConversionLabels(category: string): {
+    unit: (id: string) => UnitLabel;
+    categoryName: (id: string) => string;
+};

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-math.d.ts

@@ -0,0 +1,31 @@
+import { CalcErrorCode, Decimal, DecimalContext, RoundingMode } from '@nxgt/material-core/calculator';
+import { ParsedRates } from '@nxgt/material-core/calculator/units';
+export type ConversionOutcome = null | {
+    readonly ok: true;
+    readonly text: string;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly error: CalcErrorCode;
+};
+export type ConversionInput = {
+    /** The value as typed, in the locale's own separators. */
+    readonly text: string;
+    readonly category: string;
+    readonly from: string;
+    readonly to: string;
+    readonly locale?: string;
+    readonly rates?: ParsedRates;
+    readonly ctx?: Partial<DecimalContext>;
+};
+/** The text as an exact decimal, or `undefined` when it is not a number. */
+export declare function readValue(text: string, locale?: string): Decimal | undefined;
+/**
+ * `text` converted from `from` to `to`: `null` while there is nothing to
+ * convert, else the result as shown (`text`, in the locale, up to 16
+ * significant digits) and its exact digits (`value`), or the engine's error
+ * code. A currency is rounded to the minor unit of `to`. Never throws.
+ */
+export declare function convertText(i: ConversionInput): ConversionOutcome;
+/** The engine's context for the `precision` and `rounding` props (34 digits at most). */
+export declare function engineContext(precision?: number, rounding?: RoundingMode): Partial<DecimalContext>;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-names.d.ts

@@ -0,0 +1,4 @@
+/** The English name and the symbol of each unit; the name is the `material.calculator.conversion.unit.*` fallback. */
+export declare const UNIT_NAMES: Readonly<Record<string, readonly [name: string, symbol: string]>>;
+/** The English name of each category; the `material.calculator.conversion.category.*` fallback. */
+export declare const CATEGORY_NAMES: Readonly<Record<string, string>>;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-panel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The Conversion variant's body, in place of the display and the keypad: a
+ * category, a value, the unit it is in and the unit wanted, and the exact
+ * result. The tables and the maths are `@nxgt/material-core/calculator/units`;
+ * the Currency category exists only with `currencyRates`.
+ */
+export declare function ConversionPanel(): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/calculator/variants/conversion/conversion-rates.d.ts

@@ -0,0 +1,29 @@
+import { CalcErrorCode } from '@nxgt/material-core/calculator';
+import { ParsedRates } from '@nxgt/material-core/calculator/units';
+import { CalculatorRatesSource } from '../../types.js';
+export type RatesState = {
+    readonly status: 'none';
+} | {
+    readonly status: 'idle';
+} | {
+    readonly status: 'loading';
+} | {
+    readonly status: 'error';
+    readonly code?: CalcErrorCode;
+} | {
+    readonly status: 'ready';
+    readonly rates: ParsedRates;
+};
+/** The rates checked, or the engine's reason for refusing them. */
+export declare function readRates(source: unknown): RatesState;
+/**
+ * The exchange rates of the `currencyRates` prop. An object is checked at
+ * once. A function is called the first time the Currency category is chosen, with an `AbortSignal` that
+ * aborts when it closes or the call is repeated: `loading`, then `ready` or
+ * `error`; `retry` calls it again. The function's identity does not matter
+ * (an inline arrow is fine): only a retry calls it again.
+ */
+export declare function useCurrencyRates(source: CalculatorRatesSource | undefined, wanted: boolean): {
+    state: RatesState;
+    retry: (() => void) | undefined;
+};