@olenbetong/appframe-ds 1.5.0 → 1.6.0

package/src/input/NumberInput.tsx

@@ -0,0 +1,268 @@
+import "./NumberInput.css";
+
+import { Button, Field, Label, ValidationMessage } from "@digdir/designsystemet-react";
+import { MinusIcon, PlusIcon } from "@navikt/aksel-icons";
+import clsx from "clsx";
+import { type ReactNode, type Ref, useCallback, useEffect, useId, useRef, useState } from "react";
+
+import { InputAdornments, type InputAdornmentsProps } from "./InputAdornments.js";
+import { clamp, formatNumber, parseNumber, roundTo } from "./numberFormat.js";
+import { getLocalizedString } from "../i18n.js";
+
+export type NumberInputProps = Omit<
+	InputAdornmentsProps,
+	"value" | "defaultValue" | "onChange" | "type" | "children" | "min" | "max" | "step" | "inputMode" | "ref"
+> & {
+	/**
+	 * The number being edited. `null` renders an empty input.
+	 */
+	value: number | null | undefined;
+	/**
+	 * Called with the parsed number whenever the text in the input is a valid number, and with
+	 * `null` when the input is cleared. Not called while the text is incomplete (a lone `-`).
+	 */
+	onChange: (value: number | null) => void;
+	/**
+	 * Fraction digits shown and rounded to when stepping. Defaults to 2.
+	 */
+	decimalDigits?: number;
+	/**
+	 * BCP 47 culture the value is formatted in (`nb-NO` shows `8,00`, `en-GB` shows `8.00`).
+	 * Defaults to the Appframe session's culture, and to `nb-NO` when there is no session.
+	 * Typed text is parsed the same way whatever the culture: both `,` and `.` are decimal separators.
+	 */
+	culture?: string;
+	/**
+	 * Amount added or subtracted by the stepper buttons and the arrow keys. Defaults to 1.
+	 */
+	step?: number;
+	/**
+	 * Smallest allowed value. Typed and stepped values are clamped to it.
+	 */
+	min?: number;
+	/**
+	 * Largest allowed value. Typed and stepped values are clamped to it.
+	 */
+	max?: number;
+	label?: ReactNode;
+	description?: ReactNode;
+	/**
+	 * Error message shown below the input. Also marks the input invalid.
+	 */
+	error?: ReactNode;
+	/**
+	 * Hide the increment and decrement buttons. The arrow keys still step. The buttons are also
+	 * hidden when the input is disabled or read only.
+	 */
+	hideSteppers?: boolean;
+	/**
+	 * Ref to the input element.
+	 */
+	ref?: Ref<HTMLInputElement>;
+};
+
+/**
+ * A text input for editing a number, with stepper buttons and arrow key support. The number is
+ * shown formatted in the user's culture (`8,00`) and edited as text, so both `,` and `.` are
+ * accepted as the decimal separator. The whole value is selected when the input gets focus, so
+ * typing replaces it.
+ *
+ * `className` and `style` go on the `Field` wrapper, like Designsystemet's `Textfield`; the rest
+ * of the props go to the input.
+ *
+ * @example
+ * ```jsx
+ * <NumberInput label="Hours" value={hours} onChange={setHours} step={0.25} min={0} max={24} />
+ * ```
+ */
+export function NumberInput({
+	value,
+	onChange,
+	decimalDigits = 2,
+	culture,
+	step = 1,
+	min,
+	max,
+	label,
+	description,
+	error,
+	hideSteppers = false,
+	className,
+	style,
+	disabled,
+	readOnly,
+	onFocus,
+	onBlur,
+	onKeyDown,
+	ref,
+	"data-size": size,
+	"data-color": color,
+	id: idProp,
+	...props
+}: NumberInputProps) {
+	let generatedId = useId();
+	let id = idProp ?? generatedId;
+	let inputRef = useRef<HTMLInputElement | null>(null);
+	let [hasFocus, setHasFocus] = useState(false);
+	let [text, setText] = useState("");
+	/** The last value this input reported, so an outside change can be told from our own. */
+	let lastEmitted = useRef<number | null>(value ?? null);
+
+	let setRefs = useCallback(
+		(element: HTMLInputElement | null) => {
+			inputRef.current = element;
+			if (typeof ref === "function") {
+				ref(element);
+			} else if (ref) {
+				ref.current = element;
+			}
+		},
+		[ref],
+	);
+
+	function emit(next: number | null) {
+		lastEmitted.current = next;
+		onChange(next);
+	}
+
+	function editText(nextValue: number | null) {
+		setText(formatNumber(nextValue, { decimalDigits, culture }) ?? "");
+	}
+
+	function handleTextChange(raw: string) {
+		setText(raw);
+
+		let parsed = parseNumber(raw);
+		if (parsed === null) {
+			emit(null);
+			return;
+		}
+		if (Number.isNaN(parsed)) {
+			return;
+		}
+
+		let clamped = clamp(parsed, min, max);
+		if (clamped !== parsed) {
+			editText(clamped);
+		}
+		emit(clamped);
+	}
+
+	function addStep(delta: number) {
+		let current = hasFocus ? parseNumber(text) : (value ?? null);
+		if (current === null || Number.isNaN(current)) {
+			current = 0;
+		}
+
+		let next = roundTo(clamp(current + delta, min, max), decimalDigits);
+		editText(next);
+		emit(next);
+
+		let input = inputRef.current;
+		if (input && document.activeElement === input) {
+			setTimeout(() => input.select(), 0);
+		}
+	}
+
+	function handleFocus(event: React.FocusEvent<HTMLInputElement>) {
+		lastEmitted.current = value ?? null;
+		editText(value ?? null);
+		setHasFocus(true);
+		onFocus?.(event);
+	}
+
+	function handleBlur(event: React.FocusEvent<HTMLInputElement>) {
+		setHasFocus(false);
+		onBlur?.(event);
+	}
+
+	function handleKeyDown(event: React.KeyboardEvent<HTMLInputElement>) {
+		if (!readOnly && !disabled) {
+			if (event.key === "ArrowUp") {
+				event.preventDefault();
+				addStep(step);
+			} else if (event.key === "ArrowDown") {
+				event.preventDefault();
+				addStep(-step);
+			}
+		}
+		onKeyDown?.(event);
+	}
+
+	// Select the whole value when the input gets focus, so typing replaces it
+	useEffect(() => {
+		if (hasFocus) {
+			inputRef.current?.select();
+		}
+	}, [hasFocus]);
+
+	// The value changed from the outside while editing (cancel edit, a reset): show the new value
+	useEffect(() => {
+		if (hasFocus && (value ?? null) !== lastEmitted.current) {
+			lastEmitted.current = value ?? null;
+			setText(formatNumber(value, { decimalDigits, culture }) ?? "");
+		}
+	}, [value, hasFocus, decimalDigits, culture]);
+
+	let showSteppers = !hideSteppers && !disabled && !readOnly;
+	let current = value ?? null;
+	let atMin = current !== null && min !== undefined && current <= min;
+	let atMax = current !== null && max !== undefined && current >= max;
+
+	return (
+		<Field className={clsx("ObNumberInput-root", className)} style={style} data-size={size} data-color={color}>
+			{!!label && <Label htmlFor={id}>{label}</Label>}
+			{!!description && <Field.Description>{description}</Field.Description>}
+			<InputAdornments
+				{...props}
+				data-size={size}
+				data-color={color}
+				id={id}
+				ref={setRefs}
+				type="text"
+				inputMode="decimal"
+				autoComplete="off"
+				disabled={disabled}
+				readOnly={readOnly}
+				aria-invalid={error ? true : undefined}
+				value={hasFocus ? text : (formatNumber(value, { decimalDigits, culture, grouping: true }) ?? "")}
+				onChange={(event) => handleTextChange(event.target.value)}
+				onFocus={handleFocus}
+				onBlur={handleBlur}
+				onKeyDown={handleKeyDown}
+			>
+				{showSteppers && (
+					<>
+						<Button
+							icon
+							type="button"
+							variant="tertiary"
+							data-size="sm"
+							className="ObNumberInput-stepper"
+							tabIndex={-1}
+							disabled={atMin}
+							aria-label={getLocalizedString("Decrease value")}
+							onClick={() => addStep(-step)}
+						>
+							<MinusIcon aria-hidden />
+						</Button>
+						<Button
+							icon
+							type="button"
+							variant="tertiary"
+							data-size="sm"
+							className="ObNumberInput-stepper"
+							tabIndex={-1}
+							disabled={atMax}
+							aria-label={getLocalizedString("Increase value")}
+							onClick={() => addStep(step)}
+						>
+							<PlusIcon aria-hidden />
+						</Button>
+					</>
+				)}
+			</InputAdornments>
+			{!!error && <ValidationMessage>{error}</ValidationMessage>}
+		</Field>
+	);
+}

package/src/input/index.ts

@@ -1 +1,3 @@
 export * from "./InputAdornments.js";
+export * from "./NumberInput.js";
+export { formatNumber, getDefaultCulture, parseNumber, type FormatNumberOptions } from "./numberFormat.js";

package/src/input/numberFormat.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+
+import { clamp, formatNumber, getDefaultCulture, parseNumber, roundTo } from "./numberFormat.js";
+
+describe("formatNumber", () => {
+	it("returns null for nothing", () => {
+		expect(formatNumber(null)).toBeNull();
+		expect(formatNumber(undefined)).toBeNull();
+		expect(formatNumber(Number.NaN)).toBeNull();
+	});
+
+	it("falls back to nb-NO when there is no Appframe session", () => {
+		expect(getDefaultCulture()).toBe("nb-NO");
+		expect(formatNumber(8)).toBe("8,00");
+	});
+
+	it("follows the culture given", () => {
+		expect(formatNumber(8, { culture: "en-GB" })).toBe("8.00");
+		expect(formatNumber(8, { culture: "de-DE" })).toBe("8,00");
+	});
+
+	it("pads and rounds to the fraction digits", () => {
+		expect(formatNumber(1.005, { decimalDigits: 0 })).toBe("1");
+		expect(formatNumber(1.5, { decimalDigits: 3 })).toBe("1,500");
+	});
+
+	it("leaves out thousands separators unless asked for them", () => {
+		expect(formatNumber(1234.5)).toBe("1234,50");
+		expect(formatNumber(1234.5, { culture: "en-GB" })).toBe("1234.50");
+		expect(formatNumber(1234.5, { culture: "en-GB", grouping: true })).toBe("1,234.50");
+		// nb-NO groups with a (narrow no-break) space
+		expect(formatNumber(1234.5, { grouping: true })).toMatch(/^1\s234,50$/);
+	});
+
+	it("round trips through parseNumber in any culture", () => {
+		expect(parseNumber(formatNumber(1234.5))).toBe(1234.5);
+		expect(parseNumber(formatNumber(1234.5, { culture: "en-GB" }))).toBe(1234.5);
+	});
+});
+
+describe("parseNumber", () => {
+	it("returns null for empty text", () => {
+		expect(parseNumber("")).toBeNull();
+		expect(parseNumber("   ")).toBeNull();
+		expect(parseNumber(null)).toBeNull();
+		expect(parseNumber(undefined)).toBeNull();
+	});
+
+	it("reads both comma and period as the decimal separator", () => {
+		expect(parseNumber("1,5")).toBe(1.5);
+		expect(parseNumber("1.5")).toBe(1.5);
+		expect(parseNumber("1,")).toBe(1);
+		expect(parseNumber(".5")).toBe(0.5);
+	});
+
+	it("accepts the typographic minus and ignores whitespace", () => {
+		expect(parseNumber("−2")).toBe(-2);
+		expect(parseNumber(" 1 234 ")).toBe(1234);
+	});
+
+	it("returns NaN for text that is not a number yet", () => {
+		expect(parseNumber("-")).toBeNaN();
+		expect(parseNumber("abc")).toBeNaN();
+	});
+});
+
+describe("roundTo and clamp", () => {
+	it("rounds away floating point noise", () => {
+		expect(roundTo(0.1 + 0.2, 2)).toBe(0.3);
+		expect(roundTo(2.675, 0)).toBe(3);
+	});
+
+	it("clamps only against the bounds given", () => {
+		expect(clamp(5)).toBe(5);
+		expect(clamp(5, 0, 3)).toBe(3);
+		expect(clamp(-1, 0)).toBe(0);
+		expect(clamp(2, undefined, 1)).toBe(1);
+	});
+});

package/src/input/numberFormat.ts

@@ -0,0 +1,94 @@
+/*
+ * Culture-aware number formatting and parsing for inputs that edit a number as
+ * text. Formatting follows the user's culture, read from the Appframe session
+ * when the function runs so a page that sets it after this module loads still
+ * formats correctly. Parsing is deliberately culture-agnostic: a Norwegian user
+ * typing `1.5` means the same as `1,5`.
+ */
+
+export const DEFAULT_CULTURE = "nb-NO";
+
+export type FormatNumberOptions = {
+	/**
+	 * Number of fraction digits, used as both minimum and maximum so `8` is
+	 * shown as `8,00`. Defaults to 2.
+	 */
+	decimalDigits?: number;
+	/**
+	 * Whether to use thousands separators. Off by default, since the result
+	 * is often fed back into `parseNumber`, which does not understand them.
+	 */
+	grouping?: boolean;
+	/**
+	 * BCP 47 culture to format in. Defaults to the Appframe session's culture,
+	 * and to `nb-NO` when there is no session (tests, Storybook).
+	 */
+	culture?: string;
+};
+
+const formatters = new Map<string, Intl.NumberFormat>();
+
+/**
+ * The culture numbers are formatted in when none is given: the Appframe
+ * session's, or `nb-NO` outside a session.
+ */
+export function getDefaultCulture(): string {
+	return globalThis.af?.userSession?.culture ?? DEFAULT_CULTURE;
+}
+
+/**
+ * Formats a number with a fixed number of fraction digits in the user's culture.
+ * Returns `null` for `null`/`undefined` so the result can be fed straight into an input value.
+ */
+export function formatNumber(value: number | null | undefined, options: FormatNumberOptions = {}): string | null {
+	if (value == null || Number.isNaN(value)) return null;
+
+	let decimalDigits = options.decimalDigits ?? 2;
+	let grouping = options.grouping ?? false;
+	let culture = options.culture ?? getDefaultCulture();
+	let key = `${culture}|${decimalDigits}|${grouping}`;
+	let formatter = formatters.get(key);
+
+	if (!formatter) {
+		formatter = new Intl.NumberFormat(culture, {
+			minimumFractionDigits: decimalDigits,
+			maximumFractionDigits: decimalDigits,
+			useGrouping: grouping,
+		});
+		formatters.set(key, formatter);
+	}
+
+	return formatter.format(value);
+}
+
+/**
+ * Parses text typed by a user into a number, whatever their culture. Both `,`
+ * and `.` are always read as the decimal separator (never as thousands
+ * separators), whitespace is the only thousands separator understood
+ * (`1 234,5`, including the no-break spaces `Intl` groups with), and the
+ * typographic minus is accepted.
+ *
+ * Returns `null` for an empty string, and `NaN` for text that is not (yet) a
+ * number, such as a lone `-`.
+ */
+export function parseNumber(text: string | null | undefined): number | null {
+	if (text == null) return null;
+
+	let normalized = text.replace(/\s/g, "").replace("−", "-").replace(",", ".");
+	if (normalized === "") return null;
+
+	return Number(normalized);
+}
+
+/**
+ * Rounds to a number of fraction digits, avoiding the floating point noise of
+ * repeated additions (`0.1 + 0.2`).
+ */
+export function roundTo(value: number, decimalDigits: number): number {
+	let factor = 10 ** decimalDigits;
+	return Math.round(value * factor) / factor;
+}
+
+export function clamp(value: number, min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY): number {
+	return Math.min(Math.max(value, min), max);
+}

package/src/progress/LinearProgress.css

@@ -42,15 +42,33 @@
 }
 
 /*
- * The indeterminate bar is full width and animated with `transform`, where the
- * start and end of the bar move at different speeds (the bar stretches and
- * shrinks as it travels).
+ * The indeterminate animation is Material Design's: two bars chase each other
+ * across the track in a 2.1s cycle. The first grows from 35% to 90% of the
+ * track as it crosses; the second starts 1.15s later with a sharper easing and
+ * shrinks to a sliver. Both reach the far side at 60% of the cycle and hold
+ * there, which is what gives the motion its rhythm.
+ *
+ * MUI animates `left` and `right`. Each bar here is the full track width and is
+ * moved and scaled with `transform` instead, which stays on the compositor;
+ * since both edges interpolate linearly with the same easing either way, the
+ * result is the same: translateX is MUI's `left`, scaleX is 1 - left - right.
  */
 .ObLinearProgress-indeterminate .ObLinearProgress-bar {
 	transform-origin: left center;
 	will-change: transform;
-	animation: ObLinearProgress-indeterminate var(--obLinearProgress-duration) cubic-bezier(0.65, 0.815, 0.735, 0.395)
-		infinite;
+	animation-duration: var(--obLinearProgress-duration);
+	animation-iteration-count: infinite;
+}
+
+.ObLinearProgress-indeterminate .ObLinearProgress-bar1 {
+	animation-name: ObLinearProgress-indeterminate1;
+	animation-timing-function: cubic-bezier(0.65, 0.815, 0.735, 0.395);
+}
+
+.ObLinearProgress-indeterminate .ObLinearProgress-bar2 {
+	animation-name: ObLinearProgress-indeterminate2;
+	animation-timing-function: cubic-bezier(0.165, 0.84, 0.44, 1);
+	animation-delay: calc(var(--obLinearProgress-duration) * 0.5476); /* 1.15s of 2.1s */
 }
 
 /* Zero-height wrapper so the overlay bar never affects the layout */
@@ -66,23 +84,33 @@
 	inset-inline: 0;
 }
 
-@keyframes ObLinearProgress-indeterminate {
+/* MUI: left -35% / right 100% -> left 100% / right -90%, held from 60% */
+@keyframes ObLinearProgress-indeterminate1 {
 	0% {
 		transform: translateX(-35%) scaleX(0.35);
 	}
 
-	60% {
-		transform: translateX(60%) scaleX(0.7);
+	60%,
+	100% {
+		transform: translateX(100%) scaleX(0.9);
+	}
+}
+
+/* MUI: left -200% / right 100% -> left 107% / right -8%, held from 60% */
+@keyframes ObLinearProgress-indeterminate2 {
+	0% {
+		transform: translateX(-200%) scaleX(2);
 	}
 
+	60%,
 	100% {
-		transform: translateX(100%) scaleX(0.2);
+		transform: translateX(107%) scaleX(0.01);
 	}
 }
 
 @media (prefers-reduced-motion: reduce) {
-	.ObLinearProgress-indeterminate .ObLinearProgress-bar {
-		animation-duration: 4s;
+	.ObLinearProgress-indeterminate {
+		--obLinearProgress-duration: 4s;
 	}
 }
 

package/src/progress/LinearProgress.tsx

@@ -90,9 +90,11 @@ export function LinearProgress({
 			{...props}
 		>
 			<div
-				className="ObLinearProgress-bar"
+				className="ObLinearProgress-bar ObLinearProgress-bar1"
 				style={percentage === undefined ? undefined : { inlineSize: `${percentage}%` }}
 			/>
+			{/* The indeterminate animation is two bars chasing each other, as in Material Design */}
+			{!isDeterminate && <div className="ObLinearProgress-bar ObLinearProgress-bar2" />}
 		</div>
 	);
 

package/src/test/setup.ts

@@ -4,9 +4,24 @@ fixHappyDomDocumentClass();
 
 import "@testing-library/jest-dom/vitest";
 
+import type { TestingLibraryMatchers } from "@testing-library/jest-dom/matchers";
+
 import { cleanup } from "@testing-library/react";
 import { afterEach } from "vitest";
 
 afterEach(() => {
 	cleanup();
 });
+
+/*
+ * jest-dom 7.0.1 types its matchers onto the one-parameter `Assertion<T>` of Vitest 4, which
+ * Vitest 5 replaced with `Assertion<R, T>`; custom matchers now go on `Matchers<R, T>`. Until
+ * jest-dom ships Vitest 5 types, register them there. Remove this when its `vitest` entry
+ * types `Matchers` itself.
+ */
+declare module "vitest" {
+	interface Matchers<R extends void | Promise<void> = void | Promise<void>, T = unknown> extends TestingLibraryMatchers<
+		T,
+		R
+	> {}
+}