@funstack/ui 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/meter/meter-value.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"meter-value.mjs","names":[],"sources":["../../src/meter/meter-value.tsx"],"sourcesContent":["\"use client\";\nimport type { ComponentPropsWithRef, CSSProperties, ReactNode } from \"react\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { useRender } from \"../internal/use-render.js\";\nimport { useMeterContext } from \"./meter-context.js\";\nimport type { MeterState } from \"./meter-root.js\";\n\nexport interface MeterValueProps extends Omit<\n  ComponentPropsWithRef<\"span\">,\n  \"className\" | \"style\" | \"children\"\n> {\n  className?: StateValue<string | undefined, MeterState>;\n  style?: StateValue<CSSProperties | undefined, MeterState>;\n  /** Default: `state.formattedValue`. */\n  children?: StateValue<ReactNode, MeterState>;\n  render?: RenderProp<ComponentPropsWithRef<\"span\">, MeterState>;\n}\n\n/**\n * `Meter.Value`: shows `state.formattedValue` or `children(state)`. `aria-hidden=\"true\"` is a default the consumer may override, not an owned key: the same text is in the Root's `aria-valuetext`. Owned keys: `data-region`.\n */\nexport function MeterValue({ className, style, children, render, ...rest }: MeterValueProps) {\n  const { state } = useMeterContext(\"Meter.Value\");\n  const props = { ...rest, \"aria-hidden\": rest[\"aria-hidden\"] ?? true };\n  return useRender<ComponentPropsWithRef<\"span\">, MeterState>({\n    defaultElement: \"span\",\n    render,\n    state,\n    className,\n    style,\n    children: children ?? state.formattedValue,\n    props,\n    libraryProps: {\n      \"data-region\": state.region,\n    },\n  });\n}\n\nMeterValue.displayName = \"MeterValue\";\n"],"mappings":";;;;;;;AAqBA,SAAgB,WAAW,EAAE,WAAW,OAAO,UAAU,QAAQ,GAAG,QAAyB;CAC3F,MAAM,EAAE,UAAU,gBAAgB,aAAa;CAC/C,MAAM,QAAQ;EAAE,GAAG;EAAM,eAAe,KAAK,kBAAkB;CAAK;CACpE,OAAO,UAAqD;EAC1D,gBAAgB;EAChB;EACA;EACA;EACA;EACA,UAAU,YAAY,MAAM;EAC5B;EACA,cAAc,EACZ,eAAe,MAAM,OACvB;CACF,CAAC;AACH;AAEA,WAAW,cAAc"}

package/dist/number-field/index.d.mts

@@ -0,0 +1,26 @@
+import "../internal/platform-attributes.mjs";
+import { NumberFieldRoot, NumberFieldRootProps, NumberFieldState, NumberFieldValueChangeDetails } from "./number-field-root.mjs";
+import { NumberFieldButtonState, NumberFieldDecrementProps, NumberFieldIncrement, NumberFieldIncrementProps } from "./number-field-increment.mjs";
+import { NumberFieldDecrement } from "./number-field-decrement.mjs";
+import { NumberFieldInput, NumberFieldInputProps } from "./number-field-input.mjs";
+import { NumberFieldLabel, NumberFieldLabelProps } from "./number-field-label.mjs";
+//#region src/number-field/index.d.ts
+/**
+ * NumberField: a text field that holds a number. `Root` (`div[role=group]`, owns the state),
+ * `Label`, `Input` (the visible `input[type=text]` plus a visually hidden native
+ * `input[type=number]` that carries `name`, the constraints and the posted value), and the
+ * `Increment` / `Decrement` buttons (press-and-hold). The user types in their locale's notation
+ * (committed on blur or Enter) or steps with the keys and buttons. Two actions:
+ * `valueChangeAction` on every step (a transition; keep it cheap) and `valueCommitAction` once
+ * per gesture (the save; uncontrolled state is committed when it resolves).
+ */
+export declare const NumberField: {
+  readonly Root: typeof NumberFieldRoot;
+  readonly Label: typeof NumberFieldLabel;
+  readonly Input: typeof NumberFieldInput;
+  readonly Increment: typeof NumberFieldIncrement;
+  readonly Decrement: typeof NumberFieldDecrement;
+};
+//#endregion
+export type { NumberFieldButtonState, NumberFieldDecrementProps, NumberFieldIncrementProps, NumberFieldInputProps, NumberFieldLabelProps, NumberFieldRootProps, NumberFieldState, NumberFieldValueChangeDetails };
+//# sourceMappingURL=index.d.mts.map

package/dist/number-field/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/number-field/index.ts"],"mappings":";;;;;;;;;;;;;;;;qBAkBa;WACX,aAAI;WACJ,cAAK;WACL,cAAK;WACL,kBAAS;WACT,kBAAS"}

package/dist/number-field/index.mjs

@@ -0,0 +1,26 @@
+import { NumberFieldIncrement } from "./number-field-increment.mjs";
+import { NumberFieldDecrement } from "./number-field-decrement.mjs";
+import { NumberFieldRoot } from "./number-field-root.mjs";
+import { NumberFieldInput } from "./number-field-input.mjs";
+import { NumberFieldLabel } from "./number-field-label.mjs";
+//#region src/number-field/index.ts
+/**
+* NumberField: a text field that holds a number. `Root` (`div[role=group]`, owns the state),
+* `Label`, `Input` (the visible `input[type=text]` plus a visually hidden native
+* `input[type=number]` that carries `name`, the constraints and the posted value), and the
+* `Increment` / `Decrement` buttons (press-and-hold). The user types in their locale's notation
+* (committed on blur or Enter) or steps with the keys and buttons. Two actions:
+* `valueChangeAction` on every step (a transition; keep it cheap) and `valueCommitAction` once
+* per gesture (the save; uncontrolled state is committed when it resolves).
+*/
+const NumberField = {
+	Root: NumberFieldRoot,
+	Label: NumberFieldLabel,
+	Input: NumberFieldInput,
+	Increment: NumberFieldIncrement,
+	Decrement: NumberFieldDecrement
+};
+//#endregion
+export { NumberField };
+
+//# sourceMappingURL=index.mjs.map

package/dist/number-field/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/number-field/index.ts"],"sourcesContent":["// Ships the platform attribute typings with this subpath (conventions 7.4). Type-only: the\n// built JS has no import of it.\nimport \"../internal/platform-attributes.js\";\nimport { NumberFieldDecrement } from \"./number-field-decrement.js\";\nimport { NumberFieldIncrement } from \"./number-field-increment.js\";\nimport { NumberFieldInput } from \"./number-field-input.js\";\nimport { NumberFieldLabel } from \"./number-field-label.js\";\nimport { NumberFieldRoot } from \"./number-field-root.js\";\n\n/**\n * NumberField: a text field that holds a number. `Root` (`div[role=group]`, owns the state),\n * `Label`, `Input` (the visible `input[type=text]` plus a visually hidden native\n * `input[type=number]` that carries `name`, the constraints and the posted value), and the\n * `Increment` / `Decrement` buttons (press-and-hold). The user types in their locale's notation\n * (committed on blur or Enter) or steps with the keys and buttons. Two actions:\n * `valueChangeAction` on every step (a transition; keep it cheap) and `valueCommitAction` once\n * per gesture (the save; uncontrolled state is committed when it resolves).\n */\nexport const NumberField = {\n  Root: NumberFieldRoot,\n  Label: NumberFieldLabel,\n  Input: NumberFieldInput,\n  Increment: NumberFieldIncrement,\n  Decrement: NumberFieldDecrement,\n} as const;\n\nexport type {\n  NumberFieldRootProps,\n  NumberFieldState,\n  NumberFieldValueChangeDetails,\n} from \"./number-field-root.js\";\nexport type { NumberFieldLabelProps } from \"./number-field-label.js\";\nexport type { NumberFieldInputProps } from \"./number-field-input.js\";\nexport type {\n  NumberFieldButtonState,\n  NumberFieldIncrementProps,\n  NumberFieldDecrementProps,\n} from \"./number-field-increment.js\";\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,MAAa,cAAc;CACzB,MAAM;CACN,OAAO;CACP,OAAO;CACP,WAAW;CACX,WAAW;AACb"}

package/dist/number-field/number-field-arithmetic.mjs

@@ -0,0 +1,78 @@
+import { decimalsOf, roundTo } from "../internal/decimal.mjs";
+//#region src/number-field/number-field-arithmetic.ts
+/** Tolerance for grid computations on binary floating point. */
+const EPSILON = 1e-9;
+function decimalsFor(bounds) {
+	return Math.max(decimalsOf(bounds.step), decimalsOf(bounds.min ?? 0));
+}
+/** The largest grid point `≤ max` (an unreachable `max` stays unreachable: `0..5` by `2` is `4`). */
+function gridMax(max, base, step) {
+	return base + Math.floor((max - base) / step + EPSILON) * step;
+}
+function clampAndGuard(result, current, direction, bounds) {
+	const { min, max, step } = bounds;
+	const base = min ?? 0;
+	let next = result;
+	if (max !== void 0 && next > max + EPSILON) next = gridMax(max, base, step);
+	if (min !== void 0 && next < min - EPSILON) next = min;
+	next = roundTo(next, decimalsFor(bounds));
+	if (current !== null) {
+		if (direction > 0 && next < current) return current;
+		if (direction < 0 && next > current) return current;
+	}
+	return next;
+}
+/**
+* `current` stepped `n` times (`n > 0` up, `n < 0` down): empty counts as `0`; the step base is
+* `min` (else `0`); an off-grid value snaps to the nearest grid point in the stepping direction,
+* which counts as one step; the result is clamped to `[min, max]` on the grid and rounded to the
+* decimals of `step` and `min`. When the clamp would move the value against the direction, the
+* value is returned unchanged.
+*/
+function stepValue(current, n, bounds) {
+	const { min, step } = bounds;
+	const value = current ?? 0;
+	const base = min ?? 0;
+	const index = (value - base) / step;
+	const nearest = Math.round(index);
+	let target;
+	if (Math.abs(index - nearest) <= EPSILON * Math.max(1, Math.abs(index))) target = nearest + n;
+	else if (n > 0) target = Math.ceil(index) + (n - 1);
+	else target = Math.floor(index) + (n + 1);
+	return clampAndGuard(base + target * step, current, n, bounds);
+}
+/**
+* `current` moved by `delta` (PageUp / PageDown, Shift+Arrow: `± largeStep`). A whole number of
+* steps is `stepValue(current, delta / step)`; otherwise the value moves by `delta` and snaps to
+* the grid toward the start (never past `delta`), at least one step.
+*/
+function stepBy(current, delta, bounds) {
+	const { min, step } = bounds;
+	const ratio = delta / step;
+	if (Math.abs(ratio - Math.round(ratio)) <= EPSILON * Math.max(1, Math.abs(ratio))) return stepValue(current, Math.round(ratio), bounds);
+	const value = current ?? 0;
+	const base = min ?? 0;
+	const index = (value + delta - base) / step;
+	let target = delta > 0 ? Math.floor(index + EPSILON) : Math.ceil(index - EPSILON);
+	const start = (value - base) / step;
+	if (delta > 0 && target <= start + EPSILON) target = Math.floor(start + EPSILON) + 1;
+	if (delta < 0 && target >= start - EPSILON) target = Math.ceil(start - EPSILON) - 1;
+	return clampAndGuard(base + target * step, current, delta, bounds);
+}
+/** The bound a Home / End key moves to: `min`, or the largest grid point `≤ max`. */
+function boundValue(which, bounds) {
+	const { min, max, step } = bounds;
+	if (which === "min") return min;
+	if (max === void 0) return void 0;
+	if (min !== void 0 && max < min) return min;
+	return roundTo(gridMax(max, min ?? 0, step), decimalsFor(bounds));
+}
+/** The next step in `direction` would change nothing (a button at its bound). Empty never is. */
+function isAtBound(value, direction, bounds) {
+	if (value === null) return false;
+	return stepValue(value, direction, bounds) === value;
+}
+//#endregion
+export { boundValue, isAtBound, stepBy, stepValue };
+
+//# sourceMappingURL=number-field-arithmetic.mjs.map

package/dist/number-field/number-field-arithmetic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-field-arithmetic.mjs","names":[],"sources":["../../src/number-field/number-field-arithmetic.ts"],"sourcesContent":["// Stepping arithmetic of NumberField (design/components/number-field.md 5.5). No directive: no\n// React, no client-only API. The spec's `stepUp(n)` / `stepDown(n)` (snap off-grid values in the\n// stepping direction, clamp into `[min, max]` on the grid), not the native UI stepping.\nimport { decimalsOf, roundTo } from \"../internal/decimal.js\";\n\nexport interface StepBounds {\n  readonly min: number | undefined;\n  readonly max: number | undefined;\n  /** Positive. */\n  readonly step: number;\n}\n\n/** Tolerance for grid computations on binary floating point. */\nconst EPSILON = 1e-9;\n\nfunction decimalsFor(bounds: StepBounds): number {\n  return Math.max(decimalsOf(bounds.step), decimalsOf(bounds.min ?? 0));\n}\n\n/** The largest grid point `≤ max` (an unreachable `max` stays unreachable: `0..5` by `2` is `4`). */\nfunction gridMax(max: number, base: number, step: number): number {\n  return base + Math.floor((max - base) / step + EPSILON) * step;\n}\n\nfunction clampAndGuard(\n  result: number,\n  current: number | null,\n  direction: number,\n  bounds: StepBounds,\n): number {\n  const { min, max, step } = bounds;\n  const base = min ?? 0;\n  let next = result;\n  if (max !== undefined && next > max + EPSILON) next = gridMax(max, base, step);\n  if (min !== undefined && next < min - EPSILON) next = min;\n  next = roundTo(next, decimalsFor(bounds));\n  // 4. A step that would move against its direction changes nothing (an empty value has no\n  // direction to keep: empty + ArrowDown with `min 3` is `3`, design 5.5).\n  if (current !== null) {\n    if (direction > 0 && next < current) return current;\n    if (direction < 0 && next > current) return current;\n  }\n  return next;\n}\n\n/**\n * `current` stepped `n` times (`n > 0` up, `n < 0` down): empty counts as `0`; the step base is\n * `min` (else `0`); an off-grid value snaps to the nearest grid point in the stepping direction,\n * which counts as one step; the result is clamped to `[min, max]` on the grid and rounded to the\n * decimals of `step` and `min`. When the clamp would move the value against the direction, the\n * value is returned unchanged.\n */\nexport function stepValue(current: number | null, n: number, bounds: StepBounds): number {\n  const { min, step } = bounds;\n  const value = current ?? 0;\n  const base = min ?? 0;\n  const index = (value - base) / step;\n  const nearest = Math.round(index);\n  let target: number;\n  if (Math.abs(index - nearest) <= EPSILON * Math.max(1, Math.abs(index))) {\n    target = nearest + n;\n  } else if (n > 0) {\n    target = Math.ceil(index) + (n - 1);\n  } else {\n    target = Math.floor(index) + (n + 1);\n  }\n  return clampAndGuard(base + target * step, current, n, bounds);\n}\n\n/**\n * `current` moved by `delta` (PageUp / PageDown, Shift+Arrow: `± largeStep`). A whole number of\n * steps is `stepValue(current, delta / step)`; otherwise the value moves by `delta` and snaps to\n * the grid toward the start (never past `delta`), at least one step.\n */\nexport function stepBy(current: number | null, delta: number, bounds: StepBounds): number {\n  const { min, step } = bounds;\n  const ratio = delta / step;\n  if (Math.abs(ratio - Math.round(ratio)) <= EPSILON * Math.max(1, Math.abs(ratio))) {\n    return stepValue(current, Math.round(ratio), bounds);\n  }\n  const value = current ?? 0;\n  const base = min ?? 0;\n  const index = (value + delta - base) / step;\n  let target = delta > 0 ? Math.floor(index + EPSILON) : Math.ceil(index - EPSILON);\n  const start = (value - base) / step;\n  if (delta > 0 && target <= start + EPSILON) target = Math.floor(start + EPSILON) + 1;\n  if (delta < 0 && target >= start - EPSILON) target = Math.ceil(start - EPSILON) - 1;\n  return clampAndGuard(base + target * step, current, delta, bounds);\n}\n\n/** The bound a Home / End key moves to: `min`, or the largest grid point `≤ max`. */\nexport function boundValue(which: \"min\" | \"max\", bounds: StepBounds): number | undefined {\n  const { min, max, step } = bounds;\n  if (which === \"min\") return min;\n  if (max === undefined) return undefined;\n  if (min !== undefined && max < min) return min;\n  return roundTo(gridMax(max, min ?? 0, step), decimalsFor(bounds));\n}\n\n/** The next step in `direction` would change nothing (a button at its bound). Empty never is. */\nexport function isAtBound(value: number | null, direction: 1 | -1, bounds: StepBounds): boolean {\n  if (value === null) return false;\n  return stepValue(value, direction, bounds) === value;\n}\n"],"mappings":";;;AAaA,MAAM,UAAU;AAEhB,SAAS,YAAY,QAA4B;CAC/C,OAAO,KAAK,IAAI,WAAW,OAAO,IAAI,GAAG,WAAW,OAAO,OAAO,CAAC,CAAC;AACtE;;AAGA,SAAS,QAAQ,KAAa,MAAc,MAAsB;CAChE,OAAO,OAAO,KAAK,OAAO,MAAM,QAAQ,OAAO,OAAO,IAAI;AAC5D;AAEA,SAAS,cACP,QACA,SACA,WACA,QACQ;CACR,MAAM,EAAE,KAAK,KAAK,SAAS;CAC3B,MAAM,OAAO,OAAO;CACpB,IAAI,OAAO;CACX,IAAI,QAAQ,KAAA,KAAa,OAAO,MAAM,SAAS,OAAO,QAAQ,KAAK,MAAM,IAAI;CAC7E,IAAI,QAAQ,KAAA,KAAa,OAAO,MAAM,SAAS,OAAO;CACtD,OAAO,QAAQ,MAAM,YAAY,MAAM,CAAC;CAGxC,IAAI,YAAY,MAAM;EACpB,IAAI,YAAY,KAAK,OAAO,SAAS,OAAO;EAC5C,IAAI,YAAY,KAAK,OAAO,SAAS,OAAO;CAC9C;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,UAAU,SAAwB,GAAW,QAA4B;CACvF,MAAM,EAAE,KAAK,SAAS;CACtB,MAAM,QAAQ,WAAW;CACzB,MAAM,OAAO,OAAO;CACpB,MAAM,SAAS,QAAQ,QAAQ;CAC/B,MAAM,UAAU,KAAK,MAAM,KAAK;CAChC,IAAI;CACJ,IAAI,KAAK,IAAI,QAAQ,OAAO,KAAK,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,CAAC,GACpE,SAAS,UAAU;MACd,IAAI,IAAI,GACb,SAAS,KAAK,KAAK,KAAK,KAAK,IAAI;MAEjC,SAAS,KAAK,MAAM,KAAK,KAAK,IAAI;CAEpC,OAAO,cAAc,OAAO,SAAS,MAAM,SAAS,GAAG,MAAM;AAC/D;;;;;;AAOA,SAAgB,OAAO,SAAwB,OAAe,QAA4B;CACxF,MAAM,EAAE,KAAK,SAAS;CACtB,MAAM,QAAQ,QAAQ;CACtB,IAAI,KAAK,IAAI,QAAQ,KAAK,MAAM,KAAK,CAAC,KAAK,UAAU,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,CAAC,GAC9E,OAAO,UAAU,SAAS,KAAK,MAAM,KAAK,GAAG,MAAM;CAErD,MAAM,QAAQ,WAAW;CACzB,MAAM,OAAO,OAAO;CACpB,MAAM,SAAS,QAAQ,QAAQ,QAAQ;CACvC,IAAI,SAAS,QAAQ,IAAI,KAAK,MAAM,QAAQ,OAAO,IAAI,KAAK,KAAK,QAAQ,OAAO;CAChF,MAAM,SAAS,QAAQ,QAAQ;CAC/B,IAAI,QAAQ,KAAK,UAAU,QAAQ,SAAS,SAAS,KAAK,MAAM,QAAQ,OAAO,IAAI;CACnF,IAAI,QAAQ,KAAK,UAAU,QAAQ,SAAS,SAAS,KAAK,KAAK,QAAQ,OAAO,IAAI;CAClF,OAAO,cAAc,OAAO,SAAS,MAAM,SAAS,OAAO,MAAM;AACnE;;AAGA,SAAgB,WAAW,OAAsB,QAAwC;CACvF,MAAM,EAAE,KAAK,KAAK,SAAS;CAC3B,IAAI,UAAU,OAAO,OAAO;CAC5B,IAAI,QAAQ,KAAA,GAAW,OAAO,KAAA;CAC9B,IAAI,QAAQ,KAAA,KAAa,MAAM,KAAK,OAAO;CAC3C,OAAO,QAAQ,QAAQ,KAAK,OAAO,GAAG,IAAI,GAAG,YAAY,MAAM,CAAC;AAClE;;AAGA,SAAgB,UAAU,OAAsB,WAAmB,QAA6B;CAC9F,IAAI,UAAU,MAAM,OAAO;CAC3B,OAAO,UAAU,OAAO,WAAW,MAAM,MAAM;AACjD"}

package/dist/number-field/number-field-context.d.mts

@@ -0,0 +1,2 @@
+import "./number-field-root.mjs";
+import { RefObject } from "react";

package/dist/number-field/number-field-context.mjs

@@ -0,0 +1,13 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/number-field/number-field-context.ts
+const NumberFieldContext = createContext(null);
+function useNumberFieldContext(part) {
+	const context = use(NumberFieldContext);
+	if (context === null) throw new Error(`${part} must be rendered inside a NumberField.Root.`);
+	return context;
+}
+//#endregion
+export { NumberFieldContext, useNumberFieldContext };
+
+//# sourceMappingURL=number-field-context.mjs.map

package/dist/number-field/number-field-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-field-context.mjs","names":[],"sources":["../../src/number-field/number-field-context.ts"],"sourcesContent":["\"use client\";\nimport { createContext, use } from \"react\";\nimport type { RefObject } from \"react\";\nimport type { StepBounds } from \"./number-field-arithmetic.js\";\nimport type { NumberFieldState } from \"./number-field-root.js\";\n\n/** A step button's direction. */\nexport type StepDirection = \"increment\" | \"decrement\";\n\n/** What produced a step or a commit (`details.source`). */\nexport type NumberFieldSource = \"input\" | \"increment\" | \"decrement\" | \"keyboard\" | \"wheel\" | null;\n\nexport interface NumberFieldContextValue {\n  /** The state every part's function props receive. */\n  readonly state: NumberFieldState;\n  readonly bounds: StepBounds;\n  /** What a button steps from: the parsed draft while one is open, else the shown value. */\n  readonly stepBase: number | null;\n  /** The Root is pending and the latest step or commit came from this source. */\n  readonly pendingSource: NumberFieldSource;\n  /** Ids: the visible input (the Root's, or a Field's control id) and the Label. */\n  readonly inputId: string;\n  readonly labelId: string;\n  readonly name: string | undefined;\n  readonly form: string | undefined;\n  /** `inputmode=\"decimal\"` rather than `\"numeric\"` (8.5). */\n  readonly allowsFractions: boolean;\n  readonly stepOnWheel: boolean;\n  /** The hidden input's `defaultValue`: the reset target as `String(number)` or `\"\"`. */\n  readonly resetTargetText: string;\n  /** Inside a `Field.Root`: `data-invalid` on the Root and the Input. */\n  readonly fieldInvalid: boolean | undefined;\n  readonly visibleRef: RefObject<HTMLInputElement | null>;\n  readonly hiddenRef: RefObject<HTMLInputElement | null>;\n\n  /** `input` on the visible input: the urgent draft. */\n  readonly typed: (text: string) => void;\n  /** `focusout` on the visible input: commit the draft (4.1). */\n  readonly commitDraft: (event: Event) => void;\n  /** `keydown` on the visible input (4.2). */\n  readonly keyDown: (event: KeyboardEvent) => void;\n  /** The native `wheel` listener on the visible input (4.4). */\n  readonly wheel: (event: WheelEvent) => void;\n  /** `pointerdown` on a button: the first step; `false` when no hold is open afterwards. */\n  readonly beginHold: (direction: StepDirection, event: Event) => boolean;\n  /** One tick of the hold; `false` when the hold ended (the bound was reached). */\n  readonly tickHold: (direction: StepDirection, event: Event | undefined) => boolean;\n  /** The hold's release (or cancel): one commit. */\n  readonly endHold: (direction: StepDirection, event: Event) => void;\n  /** A click with no pointer gesture (assistive technology): step + commit. */\n  readonly activate: (direction: StepDirection, event: Event) => void;\n  /** Mirrors the hidden input's `validationMessage` onto the visible input (6.2). */\n  readonly mirror: () => void;\n  /** Called by the Label from a layout effect; returns the unregistration. */\n  readonly registerLabel: () => () => void;\n  /** Called by the Input from its mount layout effect (late mount reconciliation). */\n  readonly onInputMounted: () => void;\n}\n\nexport const NumberFieldContext = createContext<NumberFieldContextValue | null>(null);\n\nexport function useNumberFieldContext(part: string): NumberFieldContextValue {\n  const context = use(NumberFieldContext);\n  if (context === null) {\n    throw new Error(`${part} must be rendered inside a NumberField.Root.`);\n  }\n  return context;\n}\n"],"mappings":";;;AA2DA,MAAa,qBAAqB,cAA8C,IAAI;AAEpF,SAAgB,sBAAsB,MAAuC;CAC3E,MAAM,UAAU,IAAI,kBAAkB;CACtC,IAAI,YAAY,MACd,MAAM,IAAI,MAAM,GAAG,KAAK,6CAA6C;CAEvE,OAAO;AACT"}

package/dist/number-field/number-field-decrement.d.mts

@@ -0,0 +1,16 @@
+import { NumberFieldDecrementProps } from "./number-field-increment.mjs";
+//#region src/number-field/number-field-decrement.d.ts
+/**
+ * Steps the value down: `button[type=button][tabindex=-1]` with `aria-controls` → the input and
+ * the default `aria-label` `"Decrease"`; one step at the press, then repeated while held, one
+ * commit at the release. Natively `disabled` when the next step would change nothing.
+ *
+ * Owned keys: `type`, `tabIndex`, `aria-controls`, `disabled`, `onPointerDown`, `onClick`,
+ * `onContextMenu`, `data-pending`, `data-disabled`.
+ */
+export declare function NumberFieldDecrement(props: NumberFieldDecrementProps): import("react").ReactNode;
+export declare namespace NumberFieldDecrement {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=number-field-decrement.d.mts.map

package/dist/number-field/number-field-decrement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-field-decrement.d.mts","names":[],"sources":["../../src/number-field/number-field-decrement.tsx"],"mappings":";;;;;;;;;;wBAcgB,qBAAqB,OAAO,4CAAyB;yBAArD"}

package/dist/number-field/number-field-decrement.mjs

@@ -0,0 +1,19 @@
+"use client";
+import { useStepButtonElement } from "./number-field-increment.mjs";
+//#region src/number-field/number-field-decrement.tsx
+/**
+* Steps the value down: `button[type=button][tabindex=-1]` with `aria-controls` → the input and
+* the default `aria-label` `"Decrease"`; one step at the press, then repeated while held, one
+* commit at the release. Natively `disabled` when the next step would change nothing.
+*
+* Owned keys: `type`, `tabIndex`, `aria-controls`, `disabled`, `onPointerDown`, `onClick`,
+* `onContextMenu`, `data-pending`, `data-disabled`.
+*/
+function NumberFieldDecrement(props) {
+	return useStepButtonElement("decrement", "NumberField.Decrement", props);
+}
+NumberFieldDecrement.displayName = "NumberFieldDecrement";
+//#endregion
+export { NumberFieldDecrement };
+
+//# sourceMappingURL=number-field-decrement.mjs.map

package/dist/number-field/number-field-decrement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-field-decrement.mjs","names":[],"sources":["../../src/number-field/number-field-decrement.tsx"],"sourcesContent":["\"use client\";\nimport { useStepButtonElement } from \"./number-field-increment.js\";\nimport type { NumberFieldDecrementProps } from \"./number-field-increment.js\";\n\nexport type { NumberFieldDecrementProps } from \"./number-field-increment.js\";\n\n/**\n * Steps the value down: `button[type=button][tabindex=-1]` with `aria-controls` → the input and\n * the default `aria-label` `\"Decrease\"`; one step at the press, then repeated while held, one\n * commit at the release. Natively `disabled` when the next step would change nothing.\n *\n * Owned keys: `type`, `tabIndex`, `aria-controls`, `disabled`, `onPointerDown`, `onClick`,\n * `onContextMenu`, `data-pending`, `data-disabled`.\n */\nexport function NumberFieldDecrement(props: NumberFieldDecrementProps) {\n  return useStepButtonElement(\"decrement\", \"NumberField.Decrement\", props);\n}\n\nNumberFieldDecrement.displayName = \"NumberFieldDecrement\";\n"],"mappings":";;;;;;;;;;;AAcA,SAAgB,qBAAqB,OAAkC;CACrE,OAAO,qBAAqB,aAAa,yBAAyB,KAAK;AACzE;AAEA,qBAAqB,cAAc"}

package/dist/number-field/number-field-format.mjs

@@ -0,0 +1,279 @@
+import { roundTo } from "../internal/decimal.mjs";
+//#region src/number-field/number-field-format.ts
+const BIDI = /[؜‎‏‪-‮⁦-⁩]/g;
+function normalize(text) {
+	return text.normalize("NFKC").replace(BIDI, "").replace(/\s/g, " ").toLowerCase();
+}
+/** Every string `format` may emit, with the plural samples that change a unit or currency name. */
+const SAMPLES = [
+	-1234567.891,
+	0,
+	1,
+	2,
+	3,
+	5,
+	11,
+	21,
+	.5,
+	1.5,
+	100
+];
+function collect(locale, options, type, into) {
+	let formatter;
+	try {
+		formatter = new Intl.NumberFormat(locale, options);
+	} catch {
+		return;
+	}
+	for (const sample of SAMPLES) for (const part of formatter.formatToParts(sample)) {
+		if (part.type !== type) continue;
+		const value = normalize(part.value).trim();
+		if (value !== "") into.add(value);
+	}
+}
+function deriveSymbols(locale, options, numberingSystem) {
+	const loc = locale;
+	const probeOptions = {
+		...options,
+		notation: "standard",
+		useGrouping: true,
+		minimumFractionDigits: 1,
+		maximumFractionDigits: 3,
+		minimumSignificantDigits: void 0,
+		maximumSignificantDigits: void 0,
+		signDisplay: "auto",
+		numberingSystem
+	};
+	let probe;
+	try {
+		probe = new Intl.NumberFormat(loc, probeOptions);
+	} catch {
+		probe = new Intl.NumberFormat(loc, {
+			useGrouping: true,
+			minimumFractionDigits: 1,
+			numberingSystem
+		});
+	}
+	const parts = probe.formatToParts(-1234567890.5);
+	let decimal = ".";
+	let group = ",";
+	const minus = /* @__PURE__ */ new Set(["-", "−"]);
+	const plus = /* @__PURE__ */ new Set(["+"]);
+	const integers = [];
+	for (const part of parts) {
+		const value = normalize(part.value);
+		if (part.type === "decimal") decimal = value;
+		else if (part.type === "group") group = value;
+		else if (part.type === "minusSign" && value.trim() !== "") minus.add(value.trim());
+		else if (part.type === "integer") integers.push(part.value);
+	}
+	try {
+		for (const part of new Intl.NumberFormat(loc, {
+			...probeOptions,
+			signDisplay: "always"
+		}).formatToParts(1)) if (part.type === "plusSign") plus.add(normalize(part.value).trim());
+	} catch {}
+	const primaryGroup = integers.at(-1)?.length ?? 3;
+	const secondaryGroup = integers.length > 2 ? integers.at(-2)?.length ?? 3 : primaryGroup;
+	const groups = [group.trim() === "" ? " " : group];
+	if ([
+		"'",
+		"’",
+		"ʼ"
+	].includes(group)) groups.push("'", "’", "ʼ");
+	const affixes = /* @__PURE__ */ new Set();
+	const style = options.style ?? "decimal";
+	if (style === "percent") {
+		collect(loc, options, "percentSign", affixes);
+		affixes.add("%");
+	} else if (style === "currency") {
+		for (const currencyDisplay of [
+			"symbol",
+			"narrowSymbol",
+			"code",
+			"name"
+		]) collect(loc, {
+			...options,
+			currencyDisplay
+		}, "currency", affixes);
+		if (options.currency !== void 0) affixes.add(options.currency.toLowerCase());
+	} else if (style === "unit") for (const unitDisplay of [
+		"short",
+		"long",
+		"narrow"
+	]) collect(loc, {
+		...options,
+		unitDisplay
+	}, "unit", affixes);
+	const literals = /* @__PURE__ */ new Set();
+	collect(loc, options, "literal", literals);
+	for (const ch of ["(", ")"]) literals.delete(ch);
+	const literalList = [...literals].filter((l) => l !== "").sort((a, b) => b.length - a.length);
+	const digitFormat = new Intl.NumberFormat(loc, {
+		useGrouping: false,
+		numberingSystem
+	});
+	const digits = Array.from({ length: 10 }, (_, d) => normalize(digitFormat.format(d)));
+	return {
+		decimal,
+		groups,
+		minus: [...minus],
+		plus: [...plus],
+		affixes: [...affixes].sort((a, b) => b.length - a.length),
+		literals: literalList,
+		edges: [...affixes, ...literalList].sort((a, b) => b.length - a.length),
+		digits,
+		primaryGroup,
+		secondaryGroup
+	};
+}
+function stripEdges(text, tokens) {
+	let s = text.trim();
+	let changed = true;
+	while (changed && s !== "") {
+		changed = false;
+		for (const token of tokens) {
+			if (s.startsWith(token)) {
+				s = s.slice(token.length).trim();
+				changed = true;
+			}
+			if (s.endsWith(token)) {
+				s = s.slice(0, s.length - token.length).trim();
+				changed = true;
+			}
+		}
+	}
+	return s;
+}
+function startsWithAny(s, tokens) {
+	for (const token of tokens) if (s.startsWith(token)) return token;
+	return null;
+}
+function endsWithAny(s, tokens) {
+	for (const token of tokens) if (s.endsWith(token)) return token;
+	return null;
+}
+/** Strict grouping (5.3 step 5): the integer part, with group separators replaced by nothing. */
+function ungroup(integer, symbols) {
+	const separators = symbols.groups;
+	const chunks = [];
+	let current = "";
+	for (const ch of integer) if (separators.includes(ch)) {
+		chunks.push(current);
+		current = "";
+	} else current += ch;
+	chunks.push(current);
+	if (chunks.length === 1) return integer;
+	const { primaryGroup, secondaryGroup } = symbols;
+	const last = chunks.length - 1;
+	for (let i = 0; i <= last; i += 1) {
+		const length = chunks[i].length;
+		if (i === last) {
+			if (length !== primaryGroup) return void 0;
+		} else if (i === 0) {
+			if (length < 1 || length > secondaryGroup) return void 0;
+		} else if (length !== secondaryGroup) return;
+	}
+	return chunks.join("");
+}
+function parseWith(text, symbols, percent, round) {
+	let s = normalize(text).trim();
+	if (s === "") return null;
+	const edges = symbols.edges;
+	s = stripEdges(s, edges);
+	if (s === "") return void 0;
+	let negative = false;
+	if (s.startsWith("(") && s.endsWith(")")) {
+		negative = true;
+		s = stripEdges(s.slice(1, -1), edges);
+	} else {
+		const leadMinus = startsWithAny(s, symbols.minus);
+		const leadPlus = leadMinus === null ? startsWithAny(s, symbols.plus) : null;
+		if (leadMinus !== null || leadPlus !== null) {
+			negative = leadMinus !== null;
+			s = s.slice((leadMinus ?? leadPlus).length);
+		} else {
+			const trailMinus = endsWithAny(s, symbols.minus);
+			const trailPlus = trailMinus === null ? endsWithAny(s, symbols.plus) : null;
+			if (trailMinus !== null || trailPlus !== null) {
+				negative = trailMinus !== null;
+				s = s.slice(0, s.length - (trailMinus ?? trailPlus).length);
+			}
+		}
+		s = stripEdges(s, edges);
+	}
+	if (s === "") return void 0;
+	const decimalAliases = [symbols.decimal];
+	if (symbols.decimal === "٫" && !symbols.groups.includes(".")) decimalAliases.push(".");
+	let integer = "";
+	let fraction = null;
+	for (const ch of s) {
+		const localDigit = symbols.digits.indexOf(ch);
+		const digit = localDigit !== -1 ? String(localDigit) : /[0-9]/.test(ch) ? ch : null;
+		if (digit !== null) {
+			if (fraction === null) integer += digit;
+			else fraction += digit;
+		} else if (decimalAliases.includes(ch)) {
+			if (fraction !== null) return void 0;
+			fraction = "";
+		} else if (symbols.groups.includes(ch)) {
+			if (fraction !== null) return void 0;
+			integer += ch;
+		} else return;
+	}
+	const digitsOnly = ungroup(integer, symbols);
+	if (digitsOnly === void 0) return void 0;
+	if (digitsOnly === "" && (fraction === null || fraction === "")) return void 0;
+	let value = Number(`${digitsOnly === "" ? "0" : digitsOnly}.${fraction ?? ""}`.replace(/\.$/, ""));
+	if (!Number.isFinite(value)) return void 0;
+	if (negative) value = -value;
+	const result = round(percent ? value / 100 : value);
+	return result === 0 ? 0 : result;
+}
+const cache = /* @__PURE__ */ new Map();
+function cacheKey(locale, format) {
+	const entries = Object.entries(format).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return JSON.stringify([locale ?? null, entries]);
+}
+/** A stable serialisation of `format`, for memoising on its content rather than its identity. */
+function formatKey(format) {
+	return cacheKey(void 0, format ?? {});
+}
+/**
+* The formatter and parser for `(locale, format)`, cached per pair at module level (construction
+* is expensive). `locale` `undefined` is the runtime's locale.
+*/
+function createNumberFormatter(locale, format = {}) {
+	const key = cacheKey(locale, format);
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	const intl = new Intl.NumberFormat(locale, format);
+	const resolved = intl.resolvedOptions();
+	const percent = resolved.style === "percent";
+	const significant = format.maximumSignificantDigits !== void 0 || format.minimumSignificantDigits !== void 0;
+	const fractionDigits = significant ? void 0 : resolved.maximumFractionDigits;
+	const notation = format.notation ?? "standard";
+	const warning = notation !== "standard" ? `\`notation: "${notation}"\` cannot be parsed back; typed text in this format reverts.` : significant ? "`maximumSignificantDigits` makes the value's rounding impossible to state; the value may differ from the text." : null;
+	const round = (value) => {
+		if (fractionDigits === void 0) return value;
+		if (percent) return roundTo(roundTo(value * 100, fractionDigits) / 100, fractionDigits + 2);
+		return roundTo(value, fractionDigits);
+	};
+	const symbols = deriveSymbols(locale, format, resolved.numberingSystem);
+	const formatter = {
+		locale: resolved.locale,
+		format: (value) => value === null ? "" : intl.format(value),
+		parse: (text) => parseWith(text, symbols, percent, round),
+		round,
+		fractionDigits,
+		allowsFractions: percent || fractionDigits === void 0 || fractionDigits > 0,
+		percent,
+		warning
+	};
+	cache.set(key, formatter);
+	return formatter;
+}
+//#endregion
+export { createNumberFormatter, formatKey };
+
+//# sourceMappingURL=number-field-format.mjs.map

package/dist/number-field/number-field-format.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-field-format.mjs","names":[],"sources":["../../src/number-field/number-field-format.ts"],"sourcesContent":["// Locale-aware formatting and parsing of NumberField (design/components/number-field.md 5). No\n// directive: no React, no client-only API; usable on the server.\n//\n// ECMA-402 has no parser, so the locale's symbols are derived from `formatToParts` once per\n// `(locale, format)` and the parser accepts exactly the shapes the formatter produces (plus\n// full-width digits, ASCII signs and the other spellings of the currency or unit), with **strict\n// grouping**: `1,5` under `en` is unparsable, never `15`.\nimport { roundTo } from \"../internal/decimal.js\";\n\nexport interface NumberFormatter {\n  /** The resolved locale (`resolvedOptions().locale`). */\n  readonly locale: string;\n  /** The text for `value`; `\"\"` for `null`. */\n  readonly format: (value: number | null) => string;\n  /**\n   * The value `text` stands for, rounded (5.4): `null` for an empty text, `undefined` for an\n   * unparsable one.\n   */\n  readonly parse: (text: string) => number | null | undefined;\n  /** `value` rounded to what the text can show (5.4); unchanged with significant digits. */\n  readonly round: (value: number) => number;\n  /** The resolved `maximumFractionDigits`, or `undefined` when significant digits rule. */\n  readonly fractionDigits: number | undefined;\n  /** The format can show a fraction (`inputmode=\"decimal\"`, 8.5). */\n  readonly allowsFractions: boolean;\n  /** `style: \"percent\"`: the text shows the value × 100. */\n  readonly percent: boolean;\n  /** Development: why this format cannot round-trip (`compact` notation, significant digits). */\n  readonly warning: string | null;\n}\n\n// Bidirectional controls that some locales put around numbers and signs (`ar`: U+061C).\nconst BIDI = /[؜‎‏‪-‮⁦-⁩]/g;\n\nfunction normalize(text: string): string {\n  return text.normalize(\"NFKC\").replace(BIDI, \"\").replace(/\\s/g, \" \").toLowerCase();\n}\n\n/** Every string `format` may emit, with the plural samples that change a unit or currency name. */\nconst SAMPLES = [-1234567.891, 0, 1, 2, 3, 5, 11, 21, 0.5, 1.5, 100];\n\nfunction collect(\n  locale: string | readonly string[] | undefined,\n  options: Intl.NumberFormatOptions,\n  type: Intl.NumberFormatPartTypes,\n  into: Set<string>,\n): void {\n  let formatter: Intl.NumberFormat;\n  try {\n    formatter = new Intl.NumberFormat(locale as string | string[] | undefined, options);\n  } catch {\n    return;\n  }\n  for (const sample of SAMPLES) {\n    for (const part of formatter.formatToParts(sample)) {\n      if (part.type !== type) continue;\n      const value = normalize(part.value).trim();\n      if (value !== \"\") into.add(value);\n    }\n  }\n}\n\ninterface Symbols {\n  readonly decimal: string;\n  /** Group separators accepted (normalised). `\" \"` stands for any whitespace. */\n  readonly groups: readonly string[];\n  readonly minus: readonly string[];\n  readonly plus: readonly string[];\n  /** Currency, unit and percent strings, longest first. */\n  readonly affixes: readonly string[];\n  /** Literal strings the formatter puts around the number (never parentheses). */\n  readonly literals: readonly string[];\n  /** Affixes and literals, longest first: what may be stripped from the edges. */\n  readonly edges: readonly string[];\n  /** The numbering system's ten digits, normalised. */\n  readonly digits: readonly string[];\n  readonly primaryGroup: number;\n  readonly secondaryGroup: number;\n}\n\nfunction deriveSymbols(\n  locale: string | readonly string[] | undefined,\n  options: Intl.NumberFormatOptions,\n  numberingSystem: string,\n): Symbols {\n  const loc = locale as string | string[] | undefined;\n  // A probe that always shows a fraction and groups, without rounding by significant digits.\n  const probeOptions: Intl.NumberFormatOptions = {\n    ...options,\n    notation: \"standard\",\n    useGrouping: true,\n    minimumFractionDigits: 1,\n    maximumFractionDigits: 3,\n    minimumSignificantDigits: undefined,\n    maximumSignificantDigits: undefined,\n    signDisplay: \"auto\",\n    numberingSystem,\n  };\n  let probe: Intl.NumberFormat;\n  try {\n    probe = new Intl.NumberFormat(loc, probeOptions);\n  } catch {\n    probe = new Intl.NumberFormat(loc, {\n      useGrouping: true,\n      minimumFractionDigits: 1,\n      numberingSystem,\n    });\n  }\n  const parts = probe.formatToParts(-1234567890.5);\n  let decimal = \".\";\n  let group = \",\";\n  const minus = new Set([\"-\", \"−\"]);\n  const plus = new Set([\"+\"]);\n  const integers: string[] = [];\n  for (const part of parts) {\n    const value = normalize(part.value);\n    if (part.type === \"decimal\") decimal = value;\n    else if (part.type === \"group\") group = value;\n    else if (part.type === \"minusSign\" && value.trim() !== \"\") minus.add(value.trim());\n    else if (part.type === \"integer\") integers.push(part.value);\n  }\n  try {\n    for (const part of new Intl.NumberFormat(loc, {\n      ...probeOptions,\n      signDisplay: \"always\",\n    }).formatToParts(1)) {\n      if (part.type === \"plusSign\") plus.add(normalize(part.value).trim());\n    }\n  } catch {\n    // The plus sign stays ASCII.\n  }\n  const primaryGroup = integers.at(-1)?.length ?? 3;\n  const secondaryGroup = integers.length > 2 ? (integers.at(-2)?.length ?? 3) : primaryGroup;\n\n  const groups = [group.trim() === \"\" ? \" \" : group];\n  // An apostrophe group (`de-CH`) is typed with whichever apostrophe the keyboard has.\n  if ([\"'\", \"’\", \"ʼ\"].includes(group)) groups.push(\"'\", \"’\", \"ʼ\");\n\n  const affixes = new Set<string>();\n  const style = options.style ?? \"decimal\";\n  if (style === \"percent\") {\n    collect(loc, options, \"percentSign\", affixes);\n    affixes.add(\"%\");\n  } else if (style === \"currency\") {\n    for (const currencyDisplay of [\"symbol\", \"narrowSymbol\", \"code\", \"name\"] as const) {\n      collect(loc, { ...options, currencyDisplay }, \"currency\", affixes);\n    }\n    if (options.currency !== undefined) affixes.add(options.currency.toLowerCase());\n  } else if (style === \"unit\") {\n    for (const unitDisplay of [\"short\", \"long\", \"narrow\"] as const) {\n      collect(loc, { ...options, unitDisplay }, \"unit\", affixes);\n    }\n  }\n  const literals = new Set<string>();\n  collect(loc, options, \"literal\", literals);\n  for (const ch of [\"(\", \")\"]) literals.delete(ch);\n\n  const literalList = [...literals].filter((l) => l !== \"\").sort((a, b) => b.length - a.length);\n\n  const digitFormat = new Intl.NumberFormat(loc, { useGrouping: false, numberingSystem });\n  const digits = Array.from({ length: 10 }, (_, d) => normalize(digitFormat.format(d)));\n\n  return {\n    decimal,\n    groups,\n    minus: [...minus],\n    plus: [...plus],\n    affixes: [...affixes].sort((a, b) => b.length - a.length),\n    literals: literalList,\n    edges: [...affixes, ...literalList].sort((a, b) => b.length - a.length),\n    digits,\n    primaryGroup,\n    secondaryGroup,\n  };\n}\n\nfunction stripEdges(text: string, tokens: readonly string[]): string {\n  let s = text.trim();\n  let changed = true;\n  while (changed && s !== \"\") {\n    changed = false;\n    for (const token of tokens) {\n      if (s.startsWith(token)) {\n        s = s.slice(token.length).trim();\n        changed = true;\n      }\n      if (s.endsWith(token)) {\n        s = s.slice(0, s.length - token.length).trim();\n        changed = true;\n      }\n    }\n  }\n  return s;\n}\n\nfunction startsWithAny(s: string, tokens: readonly string[]): string | null {\n  for (const token of tokens) if (s.startsWith(token)) return token;\n  return null;\n}\n\nfunction endsWithAny(s: string, tokens: readonly string[]): string | null {\n  for (const token of tokens) if (s.endsWith(token)) return token;\n  return null;\n}\n\n/** Strict grouping (5.3 step 5): the integer part, with group separators replaced by nothing. */\nfunction ungroup(integer: string, symbols: Symbols): string | undefined {\n  const separators = symbols.groups;\n  const chunks: string[] = [];\n  let current = \"\";\n  for (const ch of integer) {\n    if (separators.includes(ch)) {\n      chunks.push(current);\n      current = \"\";\n    } else {\n      current += ch;\n    }\n  }\n  chunks.push(current);\n  if (chunks.length === 1) return integer;\n  const { primaryGroup, secondaryGroup } = symbols;\n  const last = chunks.length - 1;\n  for (let i = 0; i <= last; i += 1) {\n    const length = chunks[i]!.length;\n    if (i === last) {\n      if (length !== primaryGroup) return undefined;\n    } else if (i === 0) {\n      if (length < 1 || length > secondaryGroup) return undefined;\n    } else if (length !== secondaryGroup) {\n      return undefined;\n    }\n  }\n  return chunks.join(\"\");\n}\n\nfunction parseWith(\n  text: string,\n  symbols: Symbols,\n  percent: boolean,\n  round: (value: number) => number,\n): number | null | undefined {\n  let s = normalize(text).trim();\n  if (s === \"\") return null;\n\n  // 2. Currency, unit and percent strings and literals, at the edges only (and again inside the\n  // sign below): in the middle of the number they are garbage, never a group separator.\n  const edges = symbols.edges;\n  s = stripEdges(s, edges);\n  if (s === \"\") return undefined;\n\n  // 3. One sign: parentheses (accounting), a leading or trailing minus or plus.\n  let negative = false;\n  if (s.startsWith(\"(\") && s.endsWith(\")\")) {\n    negative = true;\n    s = stripEdges(s.slice(1, -1), edges);\n  } else {\n    const leadMinus = startsWithAny(s, symbols.minus);\n    const leadPlus = leadMinus === null ? startsWithAny(s, symbols.plus) : null;\n    if (leadMinus !== null || leadPlus !== null) {\n      negative = leadMinus !== null;\n      s = s.slice((leadMinus ?? leadPlus)!.length);\n    } else {\n      const trailMinus = endsWithAny(s, symbols.minus);\n      const trailPlus = trailMinus === null ? endsWithAny(s, symbols.plus) : null;\n      if (trailMinus !== null || trailPlus !== null) {\n        negative = trailMinus !== null;\n        s = s.slice(0, s.length - (trailMinus ?? trailPlus)!.length);\n      }\n    }\n    s = stripEdges(s, edges);\n  }\n  if (s === \"\") return undefined;\n\n  // 4. Digits to ASCII; anything but a digit, the decimal or a group separator is garbage.\n  const decimalAliases = [symbols.decimal];\n  // An Arabic decimal separator is often typed as the ASCII period.\n  if (symbols.decimal === \"٫\" && !symbols.groups.includes(\".\")) decimalAliases.push(\".\");\n  let integer = \"\";\n  let fraction: string | null = null;\n  for (const ch of s) {\n    const localDigit = symbols.digits.indexOf(ch);\n    const digit = localDigit !== -1 ? String(localDigit) : /[0-9]/.test(ch) ? ch : null;\n    if (digit !== null) {\n      if (fraction === null) integer += digit;\n      else fraction += digit;\n    } else if (decimalAliases.includes(ch)) {\n      if (fraction !== null) return undefined;\n      fraction = \"\";\n    } else if (symbols.groups.includes(ch)) {\n      // 5. Group separators only before the decimal separator.\n      if (fraction !== null) return undefined;\n      integer += ch;\n    } else {\n      return undefined;\n    }\n  }\n  const digitsOnly = ungroup(integer, symbols);\n  if (digitsOnly === undefined) return undefined;\n  if (digitsOnly === \"\" && (fraction === null || fraction === \"\")) return undefined;\n\n  // 6. The number; percent divides by 100.\n  let value = Number(\n    `${digitsOnly === \"\" ? \"0\" : digitsOnly}.${fraction ?? \"\"}`.replace(/\\.$/, \"\"),\n  );\n  if (!Number.isFinite(value)) return undefined;\n  if (negative) value = -value;\n  // 7. Rounded to what the text shows.\n  const result = round(percent ? value / 100 : value);\n  return result === 0 ? 0 : result;\n}\n\nconst cache = new Map<string, NumberFormatter>();\n\nfunction cacheKey(locale: string | readonly string[] | undefined, format: object): string {\n  const entries = Object.entries(format)\n    .filter(([, v]) => v !== undefined)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n  return JSON.stringify([locale ?? null, entries]);\n}\n\n/** A stable serialisation of `format`, for memoising on its content rather than its identity. */\nexport function formatKey(format: Intl.NumberFormatOptions | undefined): string {\n  return cacheKey(undefined, format ?? {});\n}\n\n/**\n * The formatter and parser for `(locale, format)`, cached per pair at module level (construction\n * is expensive). `locale` `undefined` is the runtime's locale.\n */\nexport function createNumberFormatter(\n  locale: string | readonly string[] | undefined,\n  format: Intl.NumberFormatOptions = {},\n): NumberFormatter {\n  const key = cacheKey(locale, format);\n  const cached = cache.get(key);\n  if (cached !== undefined) return cached;\n\n  const intl = new Intl.NumberFormat(locale as string | string[] | undefined, format);\n  const resolved = intl.resolvedOptions() as Intl.ResolvedNumberFormatOptions & {\n    roundingPriority?: string;\n  };\n  const percent = resolved.style === \"percent\";\n  const significant =\n    format.maximumSignificantDigits !== undefined || format.minimumSignificantDigits !== undefined;\n  const fractionDigits = significant ? undefined : resolved.maximumFractionDigits;\n  const notation = format.notation ?? \"standard\";\n  const warning =\n    notation !== \"standard\"\n      ? `\\`notation: \"${notation}\"\\` cannot be parsed back; typed text in this format reverts.`\n      : significant\n        ? \"`maximumSignificantDigits` makes the value's rounding impossible to state; the value \" +\n          \"may differ from the text.\"\n        : null;\n\n  const round = (value: number): number => {\n    if (fractionDigits === undefined) return value;\n    if (percent) return roundTo(roundTo(value * 100, fractionDigits) / 100, fractionDigits + 2);\n    return roundTo(value, fractionDigits);\n  };\n\n  const symbols = deriveSymbols(locale, format, resolved.numberingSystem);\n  const formatter: NumberFormatter = {\n    locale: resolved.locale,\n    format: (value) => (value === null ? \"\" : intl.format(value)),\n    parse: (text) => parseWith(text, symbols, percent, round),\n    round,\n    fractionDigits,\n    allowsFractions: percent || fractionDigits === undefined || fractionDigits > 0,\n    percent,\n    warning,\n  };\n  cache.set(key, formatter);\n  return formatter;\n}\n"],"mappings":"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"}

package/dist/number-field/number-field-increment.d.mts

@@ -0,0 +1,32 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import "./number-field-context.mjs";
+import { CSSProperties, ComponentPropsWithRef, ReactNode } from "react";
+//#region src/number-field/number-field-increment.d.ts
+export interface NumberFieldButtonState {
+  /** The Root is pending and the latest step or commit came from this button. */
+  readonly pending: boolean;
+  /** The prop, the Root's `disabled` or `readOnly`, or the next step would change nothing. */
+  readonly disabled: boolean;
+}
+export interface NumberFieldIncrementProps extends Omit<ComponentPropsWithRef<"button">, "type" | "tabIndex" | "disabled" | "onPointerDown" | "onClick" | "onContextMenu" | "aria-controls" | "className" | "style" | "children"> {
+  disabled?: boolean;
+  className?: StateValue<string | undefined, NumberFieldButtonState>;
+  style?: StateValue<CSSProperties | undefined, NumberFieldButtonState>;
+  children?: StateValue<ReactNode, NumberFieldButtonState>;
+  render?: RenderProp<ComponentPropsWithRef<"button">, NumberFieldButtonState>;
+}
+export type NumberFieldDecrementProps = NumberFieldIncrementProps;
+/**
+ * Steps the value up: `button[type=button][tabindex=-1]` with `aria-controls` → the input and the
+ * default `aria-label` `"Increase"`; one step at the press, then repeated while held, one commit
+ * at the release. Natively `disabled` when the next step would change nothing.
+ *
+ * Owned keys: `type`, `tabIndex`, `aria-controls`, `disabled`, `onPointerDown`, `onClick`,
+ * `onContextMenu`, `data-pending`, `data-disabled`.
+ */
+export declare function NumberFieldIncrement(props: NumberFieldIncrementProps): ReactNode;
+export declare namespace NumberFieldIncrement {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=number-field-increment.d.mts.map

package/dist/number-field/number-field-increment.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-field-increment.d.mts","names":[],"sources":["../../src/number-field/number-field-increment.tsx"],"mappings":";;;;iBAYiB;;WAEN;;WAEA;;iBAGM,kCAAkC,KACjD;EAYA;EACA,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;EAC9C,WAAW,WAAW,WAAW;EACjC,SAAS,WAAW,iCAAiC;;YAG3C,4BAA4B;;;;;;;;;wBA6DxB,qBAAqB,OAAO,4BAAyB;yBAArD"}