@nxgt/material 3.75.0 → 3.76.0

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-reduce.d.ts

@@ -0,0 +1,29 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+import { Base, WordSize } from '@nxgt/material-core/calculator/programmer';
+import { Announcement } from '../../calculator-announce.js';
+import { ProgrammerState } from './programmer-state.js';
+/** What the chrome can do: change the base or the word, flip one bit. */
+export type ProgrammerAction = {
+    type: 'base';
+    base: Base;
+} | {
+    type: 'size';
+    size: WordSize;
+} | {
+    type: 'signed';
+    signed: boolean;
+} | {
+    type: 'bit';
+    index: number;
+};
+export type ProgrammerStep = {
+    programmer: ProgrammerState;
+    session: CalcSession;
+    announcement: Announcement | null;
+};
+/**
+ * One chrome action. The number being edited follows: a new base rewrites it
+ * in that base, a narrower or re-signed word cuts it (and says so), a bit
+ * flips in the word's two's complement. Pure; strings and numbers only.
+ */
+export declare function reduceProgrammer(session: CalcSession, p: ProgrammerState, action: ProgrammerAction): ProgrammerStep;

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-state.d.ts

@@ -0,0 +1,22 @@
+import { CalcSession } from '@nxgt/material-core/calculator';
+import { Base, Word } from '@nxgt/material-core/calculator/programmer';
+import { ProgrammerState } from './programmer-word.js';
+export { aboveBase, INITIAL_PROGRAMMER, type ProgrammerState, startingWord, } from './programmer-word.js';
+export declare const wordOf: (p: ProgrammerState) => Word;
+/** The `calculate` / `press` options of `p`. */
+export declare const programmerEngine: (p: ProgrammerState) => import('@nxgt/material-core/calculator').CalcOptions;
+/** The expression without the operator the user is about to follow with a number. */
+export declare const withoutOperator: (expression: string) => string;
+/** The canonical integer text as a bigint; `undefined` when it is not one. */
+export declare const toBigInt: (canonical: string) => bigint | undefined;
+/**
+ * The value the display stands for: the last result, or what the expression
+ * calculates now; `undefined` while it does not calculate (or is empty).
+ */
+export declare function sessionValue(session: CalcSession, p: ProgrammerState): bigint | undefined;
+/** `value` as the digits the keys type in `base` (no grouping, lower case). */
+export declare const typedIn: (value: bigint, base: Base, word: Word) => string;
+/** `value` as it is read: upper case, grouped. */
+export declare const readIn: (value: bigint, base: Base, word: Word) => string;
+/** The session holding `value` as the number being edited. */
+export declare function holding(session: CalcSession, value: bigint, p: ProgrammerState): CalcSession;

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-toolbar.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Above the keys: the value in four bases (the one chosen is the base the
+ * digits are typed in), the word size and sign, and the bit pad.
+ */
+export declare function ProgrammerToolbar(): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { VariantModule } from '../variant-loader.js';
+/** The Programmer variant as one on-demand chunk: its keys, readouts and word maths. */
+export declare const variant: VariantModule;

package/dist/lib/components/ui/widgets/calculator/variants/programmer/programmer-word.d.ts

@@ -0,0 +1,15 @@
+import { Base, WordSize } from '@nxgt/material-core/calculator/programmer';
+/** The Programmer variant's chrome: the base the keys type in, and the word. */
+export type ProgrammerState = {
+    readonly base: Base;
+    readonly size: WordSize;
+    readonly signed: boolean;
+};
+export declare const INITIAL_PROGRAMMER: ProgrammerState;
+/** The word the props start with. */
+export declare const startingWord: (props: {
+    defaultWordSize?: WordSize;
+    defaultSigned?: boolean;
+}) => ProgrammerState;
+/** A digit key above the base: `9` in octal, `a` in decimal. */
+export declare function aboveBase(key: string, base: Base): boolean;

package/dist/lib/components/ui/widgets/calculator/variants/registry.d.ts

@@ -0,0 +1,21 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { CalculatorMessage, CalculatorVariant } from '../types.js';
+import { loadedPart } from './variant-loader.js';
+import { VariantDefinition } from './variant-types.js';
+export type { VariantDefinition } from './variant-types.js';
+/**
+ * The variants and their labels. Light on purpose: only Standard has its keys
+ * here; the others bring theirs when their chunk loads (`variant-loader`).
+ */
+export declare const VARIANT_LABELS: Readonly<Record<CalculatorVariant, CalculatorMessage>>;
+/** The variants that exist now, in the order of `CALCULATOR_VARIANTS`. */
+export declare function availableVariants(): readonly CalculatorVariant[];
+/**
+ * The definition of `id` from what is loaded: a variant whose chunk has not
+ * arrived (or failed) is a `pending` one, with no keys and no body of its own.
+ */
+export declare function resolveDefinition(id: CalculatorVariant, entry: ReturnType<typeof loadedPart>): VariantDefinition;
+/** The definition of `id` as loaded now (see `resolveDefinition`). */
+export declare const variantDefinition: (id: CalculatorVariant) => VariantDefinition;
+/** The keys `definition` takes: its keypad's, and its extras. */
+export declare function acceptedKeys(definition: VariantDefinition): ReadonlySet<CalcKey>;

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

@@ -0,0 +1,3 @@
+import { KeyLayout } from '../key-layout.js';
+/** Scientific functions, then the Standard grid (two panes of twelve units). */
+export declare const SCIENTIFIC_LAYOUT: KeyLayout;

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

@@ -0,0 +1,2 @@
+/** The spoken names of the scientific keys: `material.calculator.keys.<name>`. */
+export declare const SCIENTIFIC_NAMES: readonly ["sine", "cosine", "tangent", "arcsine", "arccosine", "arctangent", "sinh", "cosh", "tanh", "arsinh", "arcosh", "artanh", "ln", "log", "log2", "ten-power", "exp", "abs", "square", "power", "sqrt", "root", "factorial", "reciprocal", "pi", "euler", "exponent", "modulo", "separator", "answer"];

package/dist/lib/components/ui/widgets/calculator/variants/scientific/scientific-toolbar.d.ts

@@ -0,0 +1,2 @@
+/** Above the keys: the angle unit, the 2nd page and the result notation. */
+export declare function ScientificToolbar(): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { VariantModule } from '../variant-loader.js';
+/** The Scientific variant as one on-demand chunk: its keys, toolbar and engine. */
+export declare const variant: VariantModule;

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

@@ -0,0 +1,3 @@
+import { KeyLayout } from '../key-layout.js';
+/** Twelve grid units: brackets and memory, then C ± % ÷ over the digits, and `0 . ⌫ =` last. */
+export declare const STANDARD_LAYOUT: KeyLayout;

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

@@ -0,0 +1,34 @@
+import { CalculatorVariant } from '../types.js';
+import { VariantLogic } from './variant-logic.js';
+import { VariantPart } from './variant-types.js';
+/** What a variant's chunk exports: its part of the definition, and its logic. */
+export type VariantModule = {
+    readonly part: VariantPart;
+    readonly logic?: VariantLogic;
+};
+type Loader = () => Promise<{
+    variant: VariantModule;
+}>;
+/**
+ * Every variant but Standard is its own chunk, fetched the first time it is
+ * shown (by the `variant` prop, `defaultVariant`, or the switcher). Its UI and
+ * its `@nxgt/material-core/calculator/*` engine come in with it.
+ */
+export declare const VARIANT_LOADERS: Partial<Record<CalculatorVariant, Loader>>;
+declare const FAILED = "failed";
+type Entry = VariantPart | typeof FAILED;
+/** Loads `id` (once); resolves when its part and logic are in place, even on failure. */
+export declare function loadVariant(id: CalculatorVariant): Promise<void>;
+/** The loaded part of `id`, `'failed'` after a failure, `undefined` while it loads. */
+export declare const loadedPart: (id: CalculatorVariant) => Entry | undefined;
+/** Listens to the store like a component does. Tests only. */
+export declare const subscribeForTest: (listener: () => void) => () => void;
+/**
+ * The part of `id`, loading it on first use. The server and the hydration pass
+ * see `undefined` (the loading state), so the markup matches; a part already
+ * loaded by another calculator shows right after.
+ */
+export declare function useVariantPart(id: CalculatorVariant): Entry | undefined;
+/** Forgets what was loaded, so a test can watch a variant arrive again. Tests only. */
+export declare function resetVariantsForTest(): void;
+export {};

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

@@ -0,0 +1,40 @@
+import { CalcOptions } from '@nxgt/material-core/calculator';
+import { DisplayModel } from '../calculator.selectors.js';
+import { CalculatorState } from '../calculator.slice.js';
+import { EngineSettings } from '../engine.js';
+import { CalculatorVariant } from '../types.js';
+import { announcePos } from './pos/pos-announce.js';
+import { reducePos } from './pos/pos-state.js';
+import { selectPos } from './pos/pos-view.js';
+import { programmerResult, unavailableDigit } from './programmer/programmer-announce.js';
+import { reduceProgrammer } from './programmer/programmer-reduce.js';
+import { ProgrammerState } from './programmer/programmer-word.js';
+/**
+ * What a variant adds to the shared pipeline (engine options, display, copy,
+ * announcements, reducers). A variant loaded on demand registers its logic
+ * when its code arrives; until then the pipeline behaves as Standard, which is
+ * all a variant that is not shown can need.
+ */
+export type VariantLogic = {
+    /** The engine options of the variant, on top of the shared `base`. */
+    options?: (base: CalcOptions, settings: EngineSettings) => CalcOptions;
+    /** Another display model than the expression and the result. */
+    display?: (state: CalculatorState, settings: EngineSettings) => DisplayModel;
+    /** The result announcement, with the value written as the variant shows it. */
+    said?: typeof programmerResult;
+    /** The text Copy writes for a canonical `value`, or `undefined`. */
+    copy?: (value: string, p: ProgrammerState) => string | undefined;
+    /** What a digit refused by the base says. */
+    refused?: typeof unavailableDigit;
+    /** One Programmer action: the state it changes. */
+    reduce?: typeof reduceProgrammer;
+    /** The point-of-sale ticket: its reducer, announcements and view. */
+    reducePos?: typeof reducePos;
+    announcePos?: typeof announcePos;
+    selectPos?: typeof selectPos;
+};
+export declare const registerVariantLogic: (id: CalculatorVariant, logic: VariantLogic) => void;
+/** The logic of `id` once its code is loaded; `undefined` before. */
+export declare const logicOf: (id: CalculatorVariant) => VariantLogic | undefined;
+/** Drops every registered logic. Tests only. */
+export declare const resetVariantLogic: () => void;

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

@@ -0,0 +1,62 @@
+import { CalcKey } from '@nxgt/material-core/calculator';
+import { ComponentType } from 'react';
+import { CalculatorMessage, CalculatorVariant } from '../types.js';
+import { KeyLayout } from './key-layout.js';
+export type VariantBase = {
+    readonly id: CalculatorVariant;
+    readonly label: CalculatorMessage;
+};
+/** A variant on the shared display and keypad. */
+export type KeypadVariant = VariantBase & {
+    readonly layout: KeyLayout;
+    /** Keys the physical keyboard takes beyond the ones on the keypad. */
+    readonly extraKeys: readonly CalcKey[];
+    /** Calculates with the scientific functions and constants. */
+    readonly scientific?: boolean;
+    /** Calculates in a word of 8 to 64 bits (bitwise operators, a base per digit). */
+    readonly programmer?: boolean;
+    /** Controls above the keys (angle unit, 2nd, notation). */
+    readonly toolbar?: ComponentType;
+    /** Another display than the expression and the result (point of sale). */
+    readonly display?: ComponentType;
+    /** Beside the keypad (below on a phone), in place of the tape (point of sale). */
+    readonly aside?: ComponentType;
+    readonly panel?: undefined;
+    readonly pending?: undefined;
+};
+/**
+ * A variant with a body of its own, in place of the display, the keypad and
+ * the tape (the Financial forms). It has no keys: the engine keys, the paste
+ * and the global keyboard do not reach it. POS and Programmer keep the keypad
+ * and add a `toolbar` instead.
+ */
+export type PanelVariant = VariantBase & {
+    readonly panel: ComponentType;
+    readonly layout?: undefined;
+    readonly extraKeys?: undefined;
+    readonly scientific?: undefined;
+    readonly programmer?: undefined;
+    readonly toolbar?: undefined;
+    readonly display?: undefined;
+    readonly aside?: undefined;
+    readonly pending?: undefined;
+};
+/**
+ * A variant whose code is still loading (or failed to load): no keys, no body
+ * of its own; the shell shows a loading state in its place.
+ */
+export type PendingVariant = VariantBase & {
+    readonly pending: 'loading' | 'failed';
+    readonly layout?: undefined;
+    readonly extraKeys?: undefined;
+    readonly scientific?: undefined;
+    readonly programmer?: undefined;
+    readonly toolbar?: undefined;
+    readonly display?: undefined;
+    readonly aside?: undefined;
+    readonly panel?: undefined;
+};
+/** What a variant brings to the shell. */
+export type VariantDefinition = KeypadVariant | PanelVariant | PendingVariant;
+/** A variant's definition without its id and label, which stay in the registry. */
+export type VariantPart = Omit<KeypadVariant, 'id' | 'label'> | Omit<PanelVariant, 'id' | 'label'>;