bitboss-ui 3.0.0-beta.48 → 3.0.0-beta.49

package/dist/components/BbNumberInput/numberDisplay.js

@@ -0,0 +1,499 @@
+//#region src/components/BbNumberInput/numberDisplay.ts
+var e = {
+	tag: "en",
+	decimal: ".",
+	group: "",
+	primary: 3,
+	secondary: 3,
+	groupInt: null,
+	minusPrefix: "-"
+}, t = /[\u200e\u200f\u061c]/g, n = " \xA0   ", r = "'’ʼ", i = "٫", a = "-−﹣－", o = /* @__PURE__ */ new Map(), s = (e, n) => {
+	let r = n ? `${e}|${n}` : e, i = o.get(r);
+	if (i) return i;
+	let a, c = null;
+	try {
+		a = new Intl.NumberFormat(e, {
+			maximumFractionDigits: 0,
+			numberingSystem: "latn",
+			useGrouping: "auto"
+		}), n && (c = new Intl.NumberFormat(e, {
+			style: "currency",
+			currency: n,
+			maximumFractionDigits: 0,
+			numberingSystem: "latn",
+			useGrouping: "auto"
+		}));
+	} catch {
+		return s(n ? e : "en");
+	}
+	let l = new Intl.NumberFormat(e, {
+		...n ? {
+			style: "currency",
+			currency: n
+		} : {},
+		numberingSystem: "latn",
+		useGrouping: "always"
+	}).formatToParts(1234567890.5), u = l.find((e) => e.type === "decimal")?.value ?? (n ? s(e).decimal : "."), d = l.find((e) => e.type === "group")?.value ?? "", f = l.filter((e) => e.type === "integer").map((e) => e.value), p = f.length > 1 ? f[f.length - 1].length : 3, m = f.length > 2 ? f[f.length - 2].length : p, h = "";
+	for (let e of a.formatToParts(-1)) {
+		if (e.type === "integer") break;
+		e.type === "minusSign" ? h += "-" : e.type === "literal" && (h += e.value.replace(/[^\u200e\u200f\u061c]/g, ""));
+	}
+	h.includes("-") || (h = "-");
+	let g = {
+		tag: e,
+		decimal: u.replace(t, ""),
+		group: d.replace(t, ""),
+		primary: p,
+		secondary: m,
+		groupInt: c ? (e) => c.formatToParts(e).filter((e) => e.type === "integer" || e.type === "group").map((e) => e.value).join("").replace(t, "") : (e) => a.format(e).replace(t, "").replace(/^[-\u2212]/, ""),
+		minusPrefix: h
+	};
+	return o.set(r, g), g;
+}, c = /* @__PURE__ */ new Map(), l = (e, t) => {
+	let n = `${t}|${e}`;
+	if (c.has(n)) return c.get(n);
+	let r = null;
+	try {
+		let { minimumFractionDigits: n, maximumFractionDigits: i } = new Intl.NumberFormat(t, {
+			style: "currency",
+			currency: e
+		}).resolvedOptions();
+		r = {
+			min: n ?? 0,
+			max: i ?? 0
+		};
+	} catch {
+		r = null;
+	}
+	return c.set(n, r), r;
+}, u = (e) => {
+	let t = e;
+	for (; t > 0 && /\p{Nd}/u.test(String.fromCodePoint(t - 1));) t--;
+	return t;
+}, d = (e) => {
+	let t = e.normalize("NFKC");
+	if (t.length !== 1 && [...t].length !== 1) return t;
+	let n = t.codePointAt(0);
+	return n >= 48 && n <= 57 ? t : a.includes(t) ? "-" : /\p{Nd}/u.test(t) ? String((n - u(n)) % 10) : t;
+}, f = (e) => [...e.replace(t, "")].map(d).join(""), p = (e) => e >= "0" && e <= "9", m = (e, t, n) => {
+	let r = e.startsWith("-"), i = r ? e.slice(1) : e, a = i.indexOf("."), o = a === -1 ? i : i.slice(0, a), s = a === -1 ? "" : i.slice(a + 1), c = o.length > 1 && o.startsWith("0"), l = o && t.groupInt && !c ? t.groupInt(o) : o, u = [], d = "";
+	r && (u.push(t.minusPrefix.indexOf("-")), d = t.minusPrefix);
+	for (let e of l) p(e) && u.push(d.length), d += e;
+	let f = Math.max(0, n.minPrecision - s.length);
+	if (a !== -1) {
+		u.push(d.length), d += t.decimal;
+		for (let e of s) u.push(d.length), d += e;
+		d += "0".repeat(f);
+	} else o && n.minPrecision > 0 && (d += t.decimal + "0".repeat(f));
+	return {
+		text: d,
+		positions: u
+	};
+}, h = (e, t) => {
+	let { hole: n, positions: r } = e;
+	if (n) {
+		let e = r.length && r[0] < n[0] ? 1 : 0;
+		if (t <= e) return t === 0 && e ? r[0] : n[0];
+	}
+	return t <= 0 ? 0 : r[Math.min(t, r.length) - 1] + 1;
+}, g = (e, t) => {
+	let n = 0;
+	for (; n < e.positions.length && e.positions[n] < t;) n++;
+	return n;
+}, _ = (e, t) => {
+	let { hole: n, positions: r } = e;
+	if (!n) return t;
+	let i = h(e, r.length && r[0] < n[0] ? 1 : 0);
+	return Math.min(Math.max(t, i), n[1]);
+}, v = (e, t, n) => {
+	let { hole: r } = e;
+	return !r || t === n || g(e, t) !== g(e, n) ? !1 : n <= r[0] || t >= r[1];
+}, y = /* @__PURE__ */ new Map(), b = (e, t, n) => {
+	let r = `${e.tag}|${e.kind}|${e.code}|${t}|${n}`;
+	if (y.has(r)) return y.get(r);
+	let i = null;
+	try {
+		i = new Intl.NumberFormat(e.tag, {
+			style: e.kind,
+			...e.kind === "currency" ? {
+				currency: e.code,
+				currencyDisplay: n ?? "symbol"
+			} : {
+				unit: e.code,
+				unitDisplay: n ? "long" : "short"
+			},
+			...t === null ? {} : {
+				minimumFractionDigits: t,
+				maximumFractionDigits: t
+			},
+			numberingSystem: "latn",
+			useGrouping: "auto"
+		});
+	} catch {
+		i = null;
+	}
+	return y.set(r, i), i;
+}, x = (e, t, n) => {
+	let r = t ? {
+		tag: e,
+		kind: "currency",
+		code: t
+	} : n ? {
+		tag: e,
+		kind: "unit",
+		code: n
+	} : null;
+	return r && b(r, null) ? r : null;
+}, S = /* @__PURE__ */ new Set([
+	"integer",
+	"group",
+	"decimal",
+	"fraction"
+]), C = (e) => {
+	let t = e.findIndex((e) => S.has(e.type));
+	if (t === -1) return null;
+	let n = t;
+	for (; n + 1 < e.length && S.has(e[n + 1].type);) n++;
+	let r = "", i = -1;
+	for (let n of e.slice(0, t)) n.type === "minusSign" ? (i = r.length, r += "-") : r += n.value;
+	let a = e.slice(n + 1).filter((e) => e.type !== "minusSign").map((e) => e.value).join("");
+	return {
+		before: r,
+		after: a,
+		minusAt: i
+	};
+}, w = (e, t) => {
+	let n = e.startsWith("-"), r = n ? e.slice(1) : e, i = r.indexOf("."), a = (i === -1 ? r : r.slice(0, i)).replace(/^0+/, "") || "0", o = (i === -1 ? "" : r.slice(i + 1)).padEnd(t, "0"), s = Math.min(100, o.length);
+	return {
+		text: `${n ? "-" : ""}${a}${s ? `.${o.slice(0, s)}` : ""}`,
+		digits: s,
+		negative: n
+	};
+}, T = (e, t, n) => {
+	let r = w(t, n), i = b(e, r.digits), a = (e) => i ? i.formatToParts(e) : [];
+	return C(a(r.text)) ?? C(a(r.negative ? "-5" : "5")) ?? {
+		before: "",
+		after: "",
+		minusAt: -1
+	};
+}, E = /* @__PURE__ */ new Set([
+	"Arab",
+	"Hebr",
+	"Thaa",
+	"Syrc",
+	"Nkoo",
+	"Adlm"
+]), D = /* @__PURE__ */ new Map(), O = (e) => {
+	let t = D.get(e);
+	if (t === void 0) {
+		try {
+			t = E.has(new Intl.Locale(e).maximize().script ?? "");
+		} catch {
+			t = !1;
+		}
+		D.set(e, t);
+	}
+	return t;
+}, k = (e, t, n, r) => {
+	let i = m(e, t, n);
+	if (!r || !/\d/.test(e)) return i;
+	let a = e.startsWith("-"), o = T(r, e, n.minPrecision), { before: s, minusAt: c } = o, l = i.text, u = i.positions;
+	if (a) {
+		let e = t.minusPrefix.length;
+		l = l.slice(e), u = u.slice(1).map((t) => t - e), c === -1 && (c = s.length, s += "-");
+	}
+	let { after: d } = o;
+	O(r.tag) && /[\p{Script=Latin}\p{Sc}#%°‰]$/u.test(d) && (d += "‎");
+	let f = s.length;
+	return {
+		text: s + l + d,
+		positions: [...a ? [c] : [], ...u.map((e) => e + f)],
+		hole: [f, f + l.length],
+		shell: `${s}\u0000${d}`
+	};
+}, A = ["¥", "￥"], j = [
+	"0",
+	"1",
+	"2",
+	"5",
+	"1.5",
+	"1234.5"
+], M = /* @__PURE__ */ new Map(), N = (e) => {
+	let n = `${e.tag}|${e.kind}|${e.code}`, r = M.get(n);
+	if (r) return r;
+	let i = /* @__PURE__ */ new Set(), a = b(e, null);
+	for (let e of j) for (let n of [e, `-${e}`]) for (let e of a?.formatToParts(n) ?? []) (e.type === "currency" || e.type === "unit") && i.add(e.value.replace(t, "").trim());
+	return e.kind === "currency" && i.add(e.code.toUpperCase()), [...i].some((e) => A.includes(e)) && A.forEach((e) => i.add(e)), i.delete(""), r = [...i].sort((e, t) => t.length - e.length), M.set(n, r), r;
+}, P = /^([-−﹣－(+]?\s*)\p{L}[\p{L}\p{M}.]*\s*(?=[-−﹣－(\p{Sc}\p{Nd}])/u, F = (e, n) => {
+	if (!n) return e;
+	let r = e.replace(t, "");
+	for (let e of N(n)) {
+		let t = /\p{L}$/u.test(e) ? `${e}.` : null;
+		t && (r = r.split(t).join("")), r = r.split(e).join("");
+	}
+	return r.trim().replace(P, "$1");
+}, ee = (e, t, n) => {
+	let r = w(e, t), i = b(n, r.digits, "name");
+	return i ? i.format(r.text) : e;
+}, I = /* @__PURE__ */ new Map(), L = (e, t) => {
+	if (!Number.isFinite(e)) return "";
+	let n = Math.max(0, Math.min(100, t)), r = I.get(n);
+	r || (r = new Intl.NumberFormat("en", {
+		maximumFractionDigits: n,
+		numberingSystem: "latn",
+		useGrouping: !1
+	}), I.set(n, r));
+	let i = r.format(e);
+	return i === "-0" ? "0" : i;
+}, R = (e) => {
+	if (e === "") return null;
+	if (!/\d/.test(e)) return;
+	let t = Number(e.endsWith(".") ? e.slice(0, -1) : e);
+	if (Number.isFinite(t)) return t === 0 ? 0 : t;
+}, z = (e) => {
+	let { group: t } = e;
+	return t ? n.includes(t) ? n : r.includes(t) ? r : t : "";
+}, B = (e) => e.replace(/[\\\]^-]/g, "\\$&"), V = /* @__PURE__ */ new Map(), H = (e) => {
+	let t = `${e.tag}|${e.decimal}|${e.group}`, n = V.get(t);
+	if (n) return n;
+	let r = z(e), i = e.primary, a = e.secondary, o = r ? `\\d{1,${a}}(?:[${B(r)}]\\d{${a}})*[${B(r)}]\\d{${i}}` : "(?!)", s = e.decimal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return n = RegExp(`^(-?)(\\d*|${o})(?:${s}(\\d*))?$`), V.set(t, n), n;
+}, U = (e, t) => {
+	let n = f(e.trim()), r = H(t).exec(n);
+	if (!r) return null;
+	let [, i, a, o] = r, s = a.replace(/\D/g, "");
+	return !s && o === void 0 ? i ? "-" : "" : `${i}${s}${o === void 0 ? "" : `.${o}`}`;
+}, W = (e) => {
+	let t = "";
+	for (let n of f(e)) n === i ? t += "." : (p(n) || n === "." || n === "," || n === "-") && (t += n);
+	let n = /^[^\d]*-/.test(t);
+	t = t.replace(/-/g, "");
+	let r = t.lastIndexOf(","), a = t.lastIndexOf("."), o;
+	if (r !== -1 && a !== -1) {
+		let e = Math.max(r, a);
+		o = [...t].map((t, n) => t === "," || t === "." ? n === e ? "." : "" : t).join("");
+	} else {
+		let e = r === -1 ? "." : ",";
+		o = t.split(e).length - 1 > 1 ? t.replaceAll(e, "") : t.replace(",", ".");
+	}
+	return `${n ? "-" : ""}${o}`;
+}, G = /\p{Nd}/u, K = (e) => {
+	let t = e?.normalize("NFKC");
+	return t === "." || t === "," || t === i;
+}, q = /^(\d+(?:[.,]\d+)?)[eE]([+-]?\d+)$/, J = `.,\u066b\u066c${n}${r}`, Y = (e) => {
+	let t = [...e], n = t.findIndex((e) => G.test(e));
+	if (n === -1) return null;
+	let r = (e) => e < t.length && G.test(t[e]), i = n, o = !1;
+	for (; i < t.length;) {
+		let e = t[i];
+		if (G.test(e)) i++;
+		else if (J.includes(e.normalize("NFKC")) && r(i + 1)) i++;
+		else if (!o && (e === "e" || e === "E")) {
+			let e = a.includes(t[i + 1]) || t[i + 1] === "+";
+			if (!r(i + (e ? 2 : 1))) break;
+			o = !0, i += e ? 2 : 1;
+		} else break;
+	}
+	let s = n;
+	K(t[s - 1]) && s--, K(t[i]) && i++;
+	let c = f(t.slice(0, s).join("")), l = t.slice(i).join(""), u = c.includes("-") || c.includes("(") && l.includes(")"), d = f(t.slice(s, i).join("")), p = q.exec(d);
+	if (p) {
+		let e = L(Number(`${p[1].replace(",", ".")}e${p[2]}`), 20);
+		return e && u ? `-${e}` : e;
+	}
+	return `${u ? "-" : ""}${d}`;
+}, X = (e, t) => {
+	let n = Y(e) ?? e;
+	return U(n, t) ?? W(n);
+}, Z = 20, Q = (e, t, n, r) => {
+	let a = d(n), { raw: o } = e;
+	if (p(a)) {
+		let n = t === 0 && o.startsWith("-") ? 1 : t;
+		return {
+			state: {
+				...e,
+				raw: o.slice(0, n) + a + o.slice(n)
+			},
+			caret: n + 1
+		};
+	}
+	if (a === "-") return o.startsWith("-") ? {
+		state: {
+			...e,
+			raw: o.slice(1)
+		},
+		caret: Math.max(0, t - 1)
+	} : {
+		state: {
+			...e,
+			raw: `-${o}`
+		},
+		caret: t + 1
+	};
+	let s = a === i ? "." : a;
+	if (s !== "," && s !== "." || s === e.groupChar) return null;
+	let c = o.indexOf(".");
+	if (c === -1) return t === 0 && o.startsWith("-") ? null : {
+		state: {
+			...e,
+			raw: o.slice(0, t) + "." + o.slice(t),
+			decChar: s
+		},
+		caret: t + 1
+	};
+	if (t === c && Math.min(r.minPrecision, r.maxPrecision) > 0) return {
+		state: {
+			...e,
+			decChar: e.decChar || s
+		},
+		caret: t + 1
+	};
+	if (r.maxPrecision < 3 || t <= c) return null;
+	let l = e.decChar || r.localeKey, u = o.slice(0, c) + o.slice(c + 1);
+	if (s !== l) {
+		let e = t - 1;
+		return {
+			state: {
+				raw: u.slice(0, e) + "." + u.slice(e),
+				decChar: s,
+				groupChar: l
+			},
+			caret: e + 1
+		};
+	}
+	return {
+		state: {
+			raw: u,
+			decChar: "",
+			groupChar: s
+		},
+		caret: t - 1
+	};
+}, te = (e, t, n) => {
+	let r = e, i = t, a = +!!r.startsWith("-");
+	r[a] === "." && (r = `${r.slice(0, a)}0${r.slice(a)}`, i > a && i++);
+	let o = r.indexOf(".");
+	if (o !== -1) {
+		let e = Math.max(0, n.maxPrecision);
+		r.length - o - 1 > e && (r = r.slice(0, o + 1 + e));
+	}
+	let s = r.length > Z;
+	return s && (r = r.slice(0, Z)), {
+		raw: r,
+		caret: Math.min(i, r.length),
+		cut: s
+	};
+}, ne = (e, t, n) => {
+	let r = Math.min(n.minPrecision, n.maxPrecision), { raw: i } = e, a = Math.max(0, Math.min(t.start, i.length)), o = Math.max(a, Math.min(t.end, i.length)), s = {
+		...e,
+		caret: a,
+		rejected: !0
+	}, c = a === o, l = i.indexOf("."), u = (e) => r > 0 && l !== -1 && e > l && e - l <= r, d = e, f = a;
+	switch (t.type) {
+		case "insert": {
+			d = {
+				...e,
+				raw: i.slice(0, a) + i.slice(o)
+			}, a <= l && o > l && (d = {
+				...d,
+				decChar: ""
+			});
+			let r = !c;
+			for (let e of t.text) {
+				let t = Q(d, f, e, n);
+				t && (d = t.state, f = t.caret, r = !0);
+			}
+			if (!r) return {
+				...s,
+				caret: o
+			};
+			break;
+		}
+		case "paste": {
+			let e = i.slice(0, a) + i.slice(o), r = t.raw;
+			if (r.startsWith("-") && (a !== 0 || e.startsWith("-")) && (r = r.slice(1)), r.replace(/^-/, "").length > Z || (n.maxPrecision <= 0 && (r = r.replace(/\.\d*$/, "")), r.includes(".") && e.includes("."))) return {
+				...s,
+				caret: o
+			};
+			d = {
+				raw: i.slice(0, a) + r + i.slice(o),
+				decChar: "",
+				groupChar: ""
+			}, f = a + r.length;
+			break;
+		}
+		case "deleteBackward":
+		case "deleteForward": {
+			if (!c) {
+				d = {
+					...e,
+					raw: i.slice(0, a) + i.slice(o)
+				};
+				break;
+			}
+			let n = t.type === "deleteBackward" ? a - 1 : a;
+			if (n < 0 || n >= i.length) return s;
+			if (r > 0 && n === l) return {
+				...e,
+				caret: t.type === "deleteBackward" ? l : l + 1,
+				rejected: !0
+			};
+			if (u(n) && n < i.length - 1) {
+				d = {
+					...e,
+					raw: i.slice(0, n) + "0" + i.slice(n + 1)
+				}, f = t.type === "deleteBackward" ? n : n + 1;
+				break;
+			}
+			d = {
+				...e,
+				raw: i.slice(0, n) + i.slice(n + 1)
+			}, f = n;
+			break;
+		}
+		case "deleteToStart":
+		case "deleteToEnd": {
+			let [n, r] = c ? t.type === "deleteToStart" ? [0, a] : [a, i.length] : [a, o];
+			if (n === r) return s;
+			d = {
+				...e,
+				raw: i.slice(0, n) + i.slice(r)
+			}, f = n;
+			break;
+		}
+	}
+	t.type !== "insert" && t.type !== "paste" && !/\d/.test(d.raw) && (d = {
+		...d,
+		raw: d.raw.replace(".", "")
+	}), d.raw.includes(".") || (d = {
+		...d,
+		decChar: ""
+	});
+	let p = te(d.raw, f, n);
+	if ((t.type === "insert" || t.type === "paste") && p.cut) return {
+		...s,
+		caret: o
+	};
+	let m = {
+		...d,
+		raw: p.raw,
+		caret: p.caret,
+		rejected: !1
+	}, h = R(m.raw);
+	if (typeof h == "number" && h > n.max) {
+		let e = L(n.max, n.maxPrecision);
+		m = {
+			raw: e,
+			decChar: "",
+			groupChar: "",
+			caret: e.length,
+			rejected: !1
+		};
+	}
+	return {
+		...m,
+		raw: $(m.raw, r)
+	};
+}, $ = (e, t) => t > 0 && /\d/.test(e) && !e.includes(".") ? `${e}.` : e, re = (e, t) => typeof e == "number" ? L(e, t) : "", ie = { span: "minimal" };
+//#endregion
+export { e as PLAIN_SYMBOLS, x as affixOf, ne as applyEdit, l as currencyDigitsOf, h as displayIndexOf, k as formatAffixed, m as formatRaw, v as isShellOnly, d as normalizeChar, s as numberSymbolsOf, U as parseLocaleText, W as parseLooseText, re as rawAtRest, g as rawIndexOf, L as rawOfNumber, X as readText, _ as snapOffset, ee as spokenAffixed, F as stripAffix, R as valueOfRaw, $ as withPaddedMark, ie as writeStrategy };

package/dist/components/BbNumberInput/types.d.ts

@@ -21,6 +21,19 @@ export declare const BB_NUMBER_INPUT_PT: {
     readonly parts: readonly ["root", "label", "description", "message", "hint", "box", "input", "icon", "spinner", "prefix", "suffix", "clear"];
     readonly states: readonly ["hasValue", "readonly", "disabled", "warnings", "errors", "loading"];
 };
+/**
+ * The 45 simple units `Intl.NumberFormat` sanctions (ECMA-402;
+ * `Intl.supportedValuesOf('unit')`).
+ */
+export type BbNumberSimpleUnit = 'acre' | 'bit' | 'byte' | 'celsius' | 'centimeter' | 'day' | 'degree' | 'fahrenheit' | 'fluid-ounce' | 'foot' | 'gallon' | 'gigabit' | 'gigabyte' | 'gram' | 'hectare' | 'hour' | 'inch' | 'kilobit' | 'kilobyte' | 'kilogram' | 'kilometer' | 'liter' | 'megabit' | 'megabyte' | 'meter' | 'microsecond' | 'mile' | 'mile-scandinavian' | 'milliliter' | 'millimeter' | 'millisecond' | 'minute' | 'month' | 'nanosecond' | 'ounce' | 'percent' | 'petabyte' | 'pound' | 'second' | 'stone' | 'terabit' | 'terabyte' | 'week' | 'yard' | 'year';
+/**
+ * A unit for `BbNumberInput`'s `unit`: a sanctioned simple unit, or two joined
+ * by `-per-` (`kilometer-per-hour`; the halves are not checked, so the
+ * manifest stays small). `square-meter` and `kilowatt` are not
+ * `Intl` units, so they are type errors. `percent` holds the number you see:
+ * 15 shows `15%`.
+ */
+export type BbNumberUnit = BbNumberSimpleUnit | `${string}-per-${string}`;
 export type BbNumberInputProps = {
     [K in `pt:${BbNumberInputPtPart}` | `pt:${BbNumberInputPtPart}:${BbNumberInputPtState}`]?: PtValue;
 } & {
@@ -55,6 +68,15 @@ export type BbNumberInputProps = {
      * `--bb-input-py-compact`) instead.
      */
     compact?: boolean;
+    /**
+     * An ISO 4217 code (`'EUR'`, `'USD'`, `'JPY'`): the field shows the amount
+     * the locale's way, symbol included (`1.234,56 €` in Italian, `$1,234.56`
+     * in English), inside the text, so `#prefix` / `#suffix` stay free. The
+     * model is the number (`1234.56`). The decimals default to the currency's
+     * own; `minPrecision` / `maxPrecision` win when set. One or the other with
+     * `unit`.
+     */
+    currency?: string;
     /**
      * Visual variant of the field box — the same names and tokens as the
      * `BbButton` variants. Colours only: height, padding and border width are
@@ -163,11 +185,34 @@ export type BbNumberInputProps = {
      */
     max?: number;
     /**
-     * Maximum precision of the number.
+     * Maximum precision of the number: fraction digits past it are refused as
+     * typed (never rounded). With `currency`, the currency's own digits (`2`
+     * for EUR, `0` for JPY, `3` for KWD), or `minPrecision` when that is larger.
      *
      * @defaultValue `8`
      */
     maxPrecision?: number;
+    /**
+     * Fraction digits always shown (`2`: `1` shows `1,00`, `1,5` shows `1,50`),
+     * also while typing, where the padding zeros are placeholders the user types
+     * over. The model stays the number (`1.5`). A `minPrecision` above
+     * `maxPrecision` gives way to it. Applies with `disableFormatting` too
+     * (the padding only, period decimal). With `currency`, the currency's own
+     * digits (`2` for EUR, `0` for JPY).
+     *
+     * @defaultValue `0`
+     */
+    minPrecision?: number;
+    /**
+     * Shows the number as typed, with a period decimal and no grouping — the
+     * field before Q60.25: no locale display, `name` on the visible input.
+     * Without it the field shows the number the locale's way while the user
+     * types (`10.005,6` in Italian), groups it for them, and posts the raw value
+     * (`10005.6`) through a hidden input carrying `name`.
+     *
+     * @defaultValue `false`
+     */
+    disableFormatting?: boolean;
     /**
      * Minimum value cap. Applied on blur and on Enter (before a surrounding
      * form submits), not while typing, so a value above a `min` greater than 1
@@ -217,6 +262,14 @@ export type BbNumberInputProps = {
      * @defaultValue `1`
      */
     step?: number;
+    /**
+     * A unit `Intl.NumberFormat` knows (`'kilogram'`, `'kilometer-per-hour'`,
+     * `'celsius'`, `'percent'`; a typo is a type error): the field shows it
+     * the locale's way inside the text (`20 kg`, `15 %`). The model is the number you see: `unit="percent"`
+     * showing `15 %` holds `15`, not `0.15`. One or the other with `currency`
+     * (set both and `currency` wins).
+     */
+    unit?: BbNumberUnit;
 } & FormFieldProps<number | string | null>;
 export type BbNumberInputEvents = {
     /**

package/dist/components/BbNumberInput/warroom/corpus.d.ts

@@ -0,0 +1,58 @@
+import { Affix, PastePath } from './oracle';
+export type CorpusCase = {
+    id: string;
+    field: string;
+    source: 'spreadsheet' | 'pdf' | 'web' | 'typed-elsewhere';
+    clipboard: string;
+    expected: number | null;
+    path: PastePath;
+    note: string;
+    /** The spec is silent or ambiguous here: see WAR-ROOM.md § Open questions. */
+    open?: string;
+};
+export declare const CORPUS: CorpusCase[];
+/**
+ * A paste into an EMPTY currency / unit field (GROK-CURRENCY § 2 Paste, § 5
+ * Read-back; oracle `pasteIntoAffixed`). `shell`: the field's own shell was
+ * stripped (else the round-5 sign strip and the plain rule ran). `expected`
+ * is the model after the field's fraction cap (`maxPrecision`, the currency's
+ * own digits by default: oracle `capFraction`). Fields are built-in locale
+ * keys, so every row runs in the browser too.
+ */
+export type AffixCase = Omit<CorpusCase, 'path'> & {
+    affix: Affix;
+    path: PastePath;
+    shell: boolean;
+    props?: {
+        maxPrecision?: number;
+        minPrecision?: number;
+    };
+};
+export declare const AFFIX_CORPUS: AffixCase[];
+/**
+ * Shell STRUCTURE per locale (GROK-CURRENCY § 3), asserted by part type and
+ * order, never by a `format()` snapshot: which side the symbol sits on, and
+ * whether the minus of the negative shell comes before or after it. `symbol`
+ * pins the currency / unit part's text only where it is the trap itself.
+ * Tags no dictionary ships (`lt`, `ar-EG`, `hi-IN`) are engine-level rows.
+ */
+export type ShellCase = {
+    id: string;
+    field: string;
+    affix: Affix;
+    side: 'prefix' | 'suffix';
+    minus: 'before-symbol' | 'after-symbol';
+    symbol?: string;
+    /** Two values whose shells must differ (plural-dependent units). */
+    plural?: [number, number];
+    engineOnly?: boolean;
+    note: string;
+};
+export declare const SHELL_CASES: ShellCase[];
+/** Currency fraction digits from `resolvedOptions()`; `icu`: differs between ICU builds, assert in one pinned engine only. */
+export declare const DIGIT_CASES: Array<{
+    code: string;
+    min: number;
+    max: number;
+    icu?: boolean;
+}>;

package/dist/components/BbNumberInput/warroom/currency-verify.rows.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Rows shared by `currency-verify.node.test.ts` and `currency-verify.test.ts`
+ * (lane 10 verifier). Tags outside the built-in locale table (`en-PK`,
+ * `es-PY`, `es-CL`, `vi`, `is`) are engine-only: the component cannot be
+ * mounted in them, so the browser file skips them (as `SHELL_CASES`
+ * `engineOnly`).
+ */
+export declare const ENGINE_ONLY_TAGS: Set<string>;
+export declare const OWN_DOTTED_ROWS: readonly [readonly ["en-PK", {
+    readonly currency: "PKR";
+}, "Rs.1,234", 1234], readonly ["en-PK", {
+    readonly currency: "PKR";
+}, "-Rs.1,234", -1234], readonly ["en-PK", {
+    readonly currency: "PKR";
+}, "Rs.12", 12], readonly ["sv", {
+    readonly currency: "SEK";
+}, "kr.12", 12], readonly ["nb", {
+    readonly currency: "NOK";
+}, "kr.12", 12], readonly ["sv", {
+    readonly currency: "SEK";
+}, "1 234,50kr.", 1234.5], readonly ["nb", {
+    readonly currency: "NOK";
+}, "1 234,50kr.", 1234.5], readonly ["en", {
+    readonly unit: "kilogram";
+}, "kg.12", 12], readonly ["en", {
+    readonly currency: "USD";
+}, "+Rs.1,234", 1234]];
+export declare const ZERO_DIGIT_OWN_ROWS: readonly [readonly ["es-PY", "PYG", 1234], readonly ["es-PY", "PYG", 12345], readonly ["es-CL", "CLP", 1234], readonly ["vi", "VND", 1234], readonly ["is", "ISK", 1234], readonly ["de", "JPY", 1234], readonly ["de", "KRW", 12345], readonly ["it", "JPY", 12345], readonly ["es", "CLP", 12345], readonly ["nl", "JPY", 1234], readonly ["da", "ISK", 1234], readonly ["pt-BR", "JPY", 12345], readonly ["tr", "JPY", 1234]];

package/dist/components/BbNumberInput/warroom/currency.rows.d.ts

@@ -0,0 +1,2 @@
+import { Affix } from './oracle';
+export declare const FOREIGN_DOT_ROWS: Array<readonly [locale: string, affix: Affix, text: string, expected: number]>;