@nxgt/material 3.75.0 → 3.76.0

package/dist/programmer-variant-eKJNKENL.js

@@ -0,0 +1,501 @@
+import { t as e } from "./use-material-translation-CD6QoVal.js";
+import { t } from "./toggle-FeCCJqbg.js";
+import { n } from "./calculator-context-BugcKuVG.js";
+import { i as r, n as i, s as a } from "./key-layout-cR79xfGE.js";
+import { t as o } from "./programmer-word-CNCF7DJF.js";
+import { t as s } from "./calculator-segment-BlJE1LaS.js";
+import { useId as c, useState as l } from "react";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+import { calculate as f, formatExpression as p, sessionOptions as m, toCanonical as h, tokenize as g } from "@nxgt/material-core/calculator";
+import { BASES as _, WORD_SIZES as v, bits as y, changeWord as b, parseBase as ee, programmerOptions as x, toBase as S, toggleBit as C, wrap as w } from "@nxgt/material-core/calculator/programmer";
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-state.ts
+var T = (e) => ({
+	size: e.size,
+	signed: e.signed
+}), E = (e) => x(e), D = /(?:\s*(?:mod|and|or|xor|nand|nor|shl|shr|rol|ror|[-+*/^&|])\s*)+$/, O = (e) => e.replace(D, "").trim(), k = (e) => {
+	try {
+		return BigInt(e);
+	} catch {
+		return;
+	}
+};
+function A(e, t) {
+	if (e.justEvaluated && e.result) return k(e.result);
+	let n = O(e.expression);
+	if (n === "") return;
+	let r = f(n, m(e, E(t)));
+	return r.ok ? k(h(r.value)) : void 0;
+}
+var j = (e, t, n) => S(e, t, n), M = (e, t, n) => S(e, t, n, {
+	group: !0,
+	upper: !0
+});
+function N(e, t, n) {
+	let r = T(n);
+	return {
+		...e,
+		expression: j(w(t, r), n.base, r),
+		result: "",
+		error: "",
+		justEvaluated: !1
+	};
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-announce.ts
+function te(e, t, n) {
+	if (!e || !n || t.error || !t.justEvaluated || !t.result) return e;
+	let r = k(t.result);
+	if (r === void 0) return e;
+	let i = M(r, n.base, T(n));
+	return {
+		...e,
+		values: {
+			...e.values,
+			value: i
+		}
+	};
+}
+var P = {
+	16: ["material.calculator.programmer.hex", "Hexadecimal"],
+	10: ["material.calculator.programmer.dec", "Decimal"],
+	8: ["material.calculator.programmer.oct", "Octal"],
+	2: ["material.calculator.programmer.bin", "Binary"]
+};
+function F(e, t) {
+	let [n, r] = P[e];
+	return {
+		key: "material.calculator.programmer.unavailable",
+		fallback: "Not available in {base}",
+		values: { base: t(n, r) }
+	};
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-display.ts
+var I = /[0-9a-f]+$/i;
+function L(e, t) {
+	let { session: n } = e, r = t.programmer ?? o, i = T(r), a = p(n.expression, { locale: t.locale });
+	if (n.error) return {
+		expression: a,
+		result: "",
+		kind: "error",
+		value: "",
+		error: n.error
+	};
+	let s = A(n, r);
+	if (s !== void 0) return {
+		expression: a,
+		result: M(s, r.base, i),
+		kind: n.justEvaluated ? "result" : "preview",
+		value: String(s),
+		error: ""
+	};
+	let c = O(n.expression);
+	if (c === "") return {
+		expression: a,
+		result: "0",
+		kind: "empty",
+		value: "",
+		error: ""
+	};
+	let l = I.exec(c)?.[0] ?? "", u = l ? ee(l, r.base, i) : void 0;
+	return {
+		expression: a,
+		result: u?.ok ? M(u.value, r.base, i) : "0",
+		kind: "preview",
+		value: "",
+		error: ""
+	};
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-layout.ts
+var R = (e, t, n, i, a) => r(e, t, n, "function", i, a, 2), z = (e) => ({ ...r(`h${e}`, e, e.toUpperCase(), "digit", `hex-${e}`, `Digit ${e.toUpperCase()}`, 2) }), B = [
+	[
+		z("a"),
+		z("b"),
+		z("c"),
+		z("d"),
+		z("e"),
+		z("f")
+	],
+	[
+		R("and", "and", "AND", "and", "And"),
+		R("or", "or", "OR", "or", "Or"),
+		R("xor", "xor", "XOR", "xor", "Exclusive or"),
+		R("not", "not", "NOT", "not", "Not"),
+		R("nand", "nand", "NAND", "nand", "Not and"),
+		R("nor", "nor", "NOR", "nor", "Not or")
+	],
+	[
+		R("shl", "shl", "<<", "shift-left", "Shift left"),
+		R("shr", "shr", ">>", "shift-right", "Shift right (arithmetic)"),
+		R("rol", "rol", "ROL", "rotate-left", "Rotate left"),
+		R("ror", "ror", "ROR", "rotate-right", "Rotate right"),
+		r("open", "(", "(", "bracket", "open-paren", "Open parenthesis", 2),
+		r("close", ")", ")", "bracket", "close-paren", "Close parenthesis", 2)
+	]
+], V = {
+	columns: 12,
+	split: B.length,
+	rows: [
+		...B,
+		a([
+			r("clear", "C", "C", "utility", "clear", "Clear all"),
+			r("sign", "±", "±", "utility", "sign", "Change sign"),
+			r("mod", "mod", "mod", "operator", "modulo", "Modulo"),
+			r("divide", "/", "÷", "operator", "divide", "Divided by")
+		]),
+		a([
+			i(7),
+			i(8),
+			i(9),
+			r("multiply", "*", "×", "operator", "multiply", "Times")
+		]),
+		a([
+			i(4),
+			i(5),
+			i(6),
+			r("subtract", "-", "−", "operator", "subtract", "Minus")
+		]),
+		a([
+			i(1),
+			i(2),
+			i(3),
+			r("add", "+", "+", "operator", "add", "Plus")
+		]),
+		a([
+			i(0, 2),
+			r("backspace", "backspace", "⌫", "utility", "backspace", "Delete last character"),
+			r("equals", "=", "=", "equals", "equals", "Equals")
+		])
+	]
+}, H = [
+	"CE",
+	"ans",
+	"^"
+], U = {
+	16: {
+		key: "material.calculator.programmer.set-hex",
+		fallback: "Hexadecimal digits"
+	},
+	10: {
+		key: "material.calculator.programmer.set-dec",
+		fallback: "Decimal digits"
+	},
+	8: {
+		key: "material.calculator.programmer.set-oct",
+		fallback: "Octal digits"
+	},
+	2: {
+		key: "material.calculator.programmer.set-bin",
+		fallback: "Binary digits"
+	}
+};
+function W(e, t) {
+	try {
+		return g(e, E(t).dialect, {
+			wordSize: t.size,
+			signed: t.signed
+		}).filter((e) => e.k !== "end");
+	} catch {
+		return;
+	}
+}
+function G(e, t, n) {
+	let r = W(e, t);
+	if (!r) return;
+	let i = e;
+	for (let e of [...r].reverse()) {
+		if (e.k !== "num" || !e.v) continue;
+		let t = k(h(e.v));
+		if (t === void 0) return;
+		i = i.slice(0, e.s.start) + j(t, n.base, T(n)) + i.slice(e.s.end);
+	}
+	return i;
+}
+function K(e, t, n, r) {
+	let i = {
+		...t,
+		base: n
+	}, a = O(e.expression) !== e.expression.trim();
+	if (r !== void 0 && !a) {
+		let a = e.justEvaluated ? [] : W(e.expression, t), o = ((a?.[0]?.text === "-" ? a.slice(1) : a)?.length ?? 0) > 1;
+		return {
+			programmer: i,
+			session: N(e, r, i),
+			announcement: o ? {
+				key: "material.calculator.programmer.converted",
+				fallback: "Converted to {value}",
+				values: { value: M(r, n, T(i)) }
+			} : U[n]
+		};
+	}
+	if (e.expression.trim() === "") return {
+		programmer: i,
+		session: e,
+		announcement: U[n]
+	};
+	let o = G(e.expression, t, i);
+	return o === void 0 ? {
+		programmer: t,
+		session: e,
+		announcement: {
+			key: "material.calculator.programmer.base-kept",
+			fallback: "Base not changed: the expression is not valid"
+		}
+	} : {
+		programmer: i,
+		session: {
+			...e,
+			expression: o
+		},
+		announcement: U[n]
+	};
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-reduce.ts
+var q = (e, t) => e ? {
+	key: "material.calculator.programmer.bit-on",
+	fallback: "Bit {bit} is 1",
+	values: { bit: t }
+} : {
+	key: "material.calculator.programmer.bit-off",
+	fallback: "Bit {bit} is 0",
+	values: { bit: t }
+};
+function J(e, t, n) {
+	let r = A(e, t);
+	if (n.type === "base") return K(e, t, n.base, r);
+	if (n.type === "bit") {
+		let i = r ?? (O(e.expression) === "" ? 0n : void 0);
+		if (i === void 0) return {
+			programmer: t,
+			session: e,
+			announcement: null
+		};
+		let a = T(t), o = BigInt(n.index), s = C(i, o, a), c = (y(s, a) >> o & 1n) == 1n;
+		return {
+			programmer: t,
+			session: N(e, s, t),
+			announcement: q(c, n.index)
+		};
+	}
+	let i = n.type === "size" ? {
+		...t,
+		size: n.size
+	} : {
+		...t,
+		signed: n.signed
+	}, a = b(r ?? 0n, T(i)), o = Y(e.ans, i);
+	return {
+		programmer: i,
+		session: r === void 0 ? {
+			...e,
+			ans: o
+		} : {
+			...N(e, a.value, i),
+			ans: o
+		},
+		announcement: a.announce
+	};
+}
+function Y(e, t) {
+	let n = k(e);
+	return n === void 0 ? e : String(w(n, T(t)));
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-bitpad.tsx
+function X({ value: t, programmer: n, onToggle: r }) {
+	let { t: i } = e(), [a, o] = l(!1), s = c(), f = t === void 0, p = y(t ?? 0n, T(n)), m = Array.from({ length: n.size / 4 }, (e, t) => t).reverse().map((e) => [
+		3,
+		2,
+		1,
+		0
+	].map((t) => e * 4 + t));
+	return /* @__PURE__ */ d("div", {
+		"data-slot": "calculator-bitpad",
+		className: "nxgt-prog-bitpad",
+		children: [/* @__PURE__ */ u("button", {
+			type: "button",
+			className: "nxgt-prog-bits-toggle",
+			"aria-expanded": a,
+			"aria-controls": s,
+			onClick: () => o(!a),
+			children: i("material.calculator.programmer.bits", "Bit pad")
+		}), /* @__PURE__ */ u("div", {
+			id: s,
+			role: "group",
+			"aria-label": i("material.calculator.programmer.bits", "Bit pad"),
+			dir: "ltr",
+			hidden: !a,
+			"data-size": n.size,
+			className: "nxgt-prog-bits",
+			children: m.map((e) => /* @__PURE__ */ u("div", {
+				className: "nxgt-prog-nibble",
+				children: e.map((e) => {
+					let t = (p >> BigInt(e) & 1n) == 1n;
+					return /* @__PURE__ */ d("button", {
+						type: "button",
+						"aria-pressed": t,
+						"aria-disabled": f || void 0,
+						"aria-label": i("material.calculator.programmer.bit", "Bit {n}", { n: e }),
+						"data-pw": `calculator-bit-${e}`,
+						className: "nxgt-prog-bit",
+						onClick: () => {
+							f || r(e);
+						},
+						children: [/* @__PURE__ */ u("span", {
+							"aria-hidden": "true",
+							children: +!!t
+						}), /* @__PURE__ */ u("small", {
+							"aria-hidden": "true",
+							children: e
+						})]
+					}, e);
+				})
+			}, e[0]))
+		})]
+	});
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-readouts.tsx
+var Z = {
+	16: "HEX",
+	10: "DEC",
+	8: "OCT",
+	2: "BIN"
+}, Q = {
+	16: ["material.calculator.programmer.hex", "Hexadecimal"],
+	10: ["material.calculator.programmer.dec", "Decimal"],
+	8: ["material.calculator.programmer.oct", "Octal"],
+	2: ["material.calculator.programmer.bin", "Binary"]
+};
+function ne({ value: t, programmer: n, onBase: r }) {
+	let { t: i } = e(), a = c(), o = T(n);
+	return /* @__PURE__ */ d("fieldset", {
+		dir: "ltr",
+		"data-slot": "calculator-bases",
+		className: "nxgt-prog-bases",
+		children: [/* @__PURE__ */ u("legend", {
+			className: "sr-only",
+			children: i("material.calculator.programmer.base", "Number base")
+		}), [..._].reverse().map((e) => {
+			let s = `${a}-${e}`;
+			return /* @__PURE__ */ d("label", {
+				className: "nxgt-prog-base",
+				"data-pw": `calculator-base-${e}`,
+				children: [
+					/* @__PURE__ */ u("input", {
+						type: "radio",
+						name: a,
+						className: "sr-only",
+						checked: n.base === e,
+						"aria-label": i(Q[e][0], Q[e][1]),
+						"aria-describedby": s,
+						onChange: () => r(e)
+					}),
+					/* @__PURE__ */ u("span", {
+						"aria-hidden": "true",
+						className: "nxgt-prog-base-name",
+						children: Z[e]
+					}),
+					/* @__PURE__ */ u("output", {
+						id: s,
+						className: "nxgt-prog-base-value",
+						children: M(t, e, o)
+					})
+				]
+			}, e);
+		})]
+	});
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-toolbar.tsx
+var re = v.map((e) => ({
+	id: `${e}`,
+	glyph: `${e}`,
+	name: `${e} bits`
+})), $ = (e) => {
+	try {
+		return e === "" ? 0n : BigInt(e);
+	} catch {
+		return 0n;
+	}
+}, ie = (e) => e.value === "" ? e.kind === "empty" ? 0n : void 0 : $(e.value);
+function ae() {
+	let { t: r } = e(), { state: i, display: a, setProgrammer: o } = n(), c = i.programmer;
+	return /* @__PURE__ */ d("div", {
+		"data-slot": "calculator-toolbar",
+		className: "nxgt-prog-toolbar",
+		children: [
+			/* @__PURE__ */ u(ne, {
+				value: $(a.value),
+				programmer: c,
+				onBase: (e) => o({
+					type: "base",
+					base: e
+				})
+			}),
+			/* @__PURE__ */ d("div", {
+				className: "nxgt-calc-toolbar",
+				children: [/* @__PURE__ */ u(s, {
+					label: r("material.calculator.programmer.size", "Word size"),
+					choices: re,
+					value: `${c.size}`,
+					nameKey: (e) => `material.calculator.programmer.size-${e}`,
+					onChange: (e) => {
+						let t = v.find((t) => `${t}` === e);
+						t && o({
+							type: "size",
+							size: t
+						});
+					}
+				}), /* @__PURE__ */ u(t, {
+					size: "sm",
+					pressed: c.signed,
+					onPressedChange: (e) => o({
+						type: "signed",
+						signed: e
+					}),
+					"aria-label": r("material.calculator.programmer.signed", "Signed"),
+					className: "nxgt-calc-second",
+					"data-pw": "calculator-signed",
+					children: r("material.calculator.programmer.signed", "Signed")
+				})]
+			}),
+			/* @__PURE__ */ u(X, {
+				value: ie(a),
+				programmer: c,
+				onToggle: (e) => o({
+					type: "bit",
+					index: e
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-variant.ts
+var oe = {
+	part: {
+		layout: V,
+		extraKeys: H,
+		programmer: !0,
+		toolbar: ae
+	},
+	logic: {
+		options: (e, t) => t.programmer ? {
+			...e,
+			...E(t.programmer)
+		} : e,
+		display: L,
+		said: te,
+		refused: F,
+		reduce: J,
+		copy: (e, t) => {
+			let n = k(e);
+			return n === void 0 ? void 0 : S(n, t.base, T(t), { upper: !0 });
+		}
+	}
+};
+//#endregion
+export { oe as variant };

package/dist/programmer-word-CNCF7DJF.js

@@ -0,0 +1,15 @@
+//#region lib/components/ui/widgets/calculator/variants/programmer/programmer-word.ts
+var e = {
+	base: 10,
+	size: 64,
+	signed: !0
+}, t = (t) => ({
+	...e,
+	size: t.defaultWordSize ?? e.size,
+	signed: t.defaultSigned ?? e.signed
+});
+function n(e, t) {
+	return /^[0-9a-f]$/.test(e) && Number.parseInt(e, 16) >= t;
+}
+//#endregion
+export { n, t as r, e as t };