@kapiuara/ui 0.0.0-stage → 0.1.0

package/dist/components/overlays/KapiPopover.js

@@ -0,0 +1,68 @@
+"use client";
+import { resolveKapiRoot as e } from "../../hooks/kapiRoot.js";
+import { isOutsidePopover as t } from "./popoverLogic.js";
+import { usePlacement as n } from "../../hooks/usePlacement.js";
+import { KapiOverlayPortal as r } from "./overlayPortal.js";
+import { useExitPresence as i } from "./useExitPresence.js";
+/* empty css                */
+import { jsx as a } from "react/jsx-runtime";
+import { useEffect as o, useLayoutEffect as s, useRef as c, useState as l } from "react";
+//#region src/components/overlays/KapiPopover.tsx
+function u({ open: u, anchorRef: d, onClose: f, side: p = "bottom", align: m = "start", offset: h = 6, margin: g = 8, matchAnchorWidth: _ = !1, role: v = "dialog", "aria-label": y, id: b, className: x = "", style: S, closeOnEscape: C = !0, closeOnOutside: w = !0, restoreFocus: T = !0, children: E }) {
+	let D = c(null), [O, k] = l(null), A = c(f);
+	o(() => {
+		A.current = f;
+	});
+	let { present: j, closing: M } = i(u, D);
+	s(() => {
+		k(j ? e(d.current) : null);
+	}, [j, d]);
+	let { placement: N, style: P } = n({
+		open: j,
+		enabled: !!O,
+		anchor: d,
+		floatingRef: D,
+		side: p,
+		align: m,
+		offset: h,
+		margin: g,
+		width: _ ? "min-anchor" : "content"
+	});
+	return o(() => {
+		if (!u) return;
+		let e = (e) => {
+			C && e.key === "Escape" && !e.defaultPrevented && (e.preventDefault(), A.current?.(), T && d.current?.focus());
+		}, n = (e) => {
+			w && t(e.target, [D.current, d.current]) && A.current?.();
+		};
+		return document.addEventListener("keydown", e), document.addEventListener("pointerdown", n, !0), () => {
+			document.removeEventListener("keydown", e), document.removeEventListener("pointerdown", n, !0);
+		};
+	}, [
+		u,
+		C,
+		w,
+		T,
+		d
+	]), j ? /* @__PURE__ */ a(r, {
+		root: O,
+		children: /* @__PURE__ */ a("div", {
+			ref: D,
+			id: b,
+			role: v,
+			"aria-label": y,
+			tabIndex: -1,
+			className: `kapi-popover${x ? ` ${x}` : ""}`,
+			"data-side": N?.side ?? p,
+			"data-align": m,
+			"data-closing": M || void 0,
+			style: {
+				...S,
+				...P
+			},
+			children: E
+		})
+	}) : null;
+}
+//#endregion
+export { u as KapiPopover };

package/dist/components/overlays/KapiShapeSheet.d.ts

@@ -0,0 +1,34 @@
+import { type ReactNode } from "react";
+import "./overlays.css";
+import { type KapiRootProps } from "../rootProps";
+import type { KapiLabelsOverride } from "../labelsLogic";
+/** `className`/`style`/`id` van al contenedor que se transforma; abierto, `width`/`height` ganan sobre `style`. */
+export type KapiShapeSheetProps = KapiRootProps & {
+    /** Título del panel abierto. */
+    title: string;
+    /** Contenido del panel. */
+    children: ReactNode;
+    /** Ancho del panel abierto (px). */
+    width?: number;
+    /** Alto del panel abierto (px). */
+    height?: number;
+    /** aria-label del FAB. Gana sobre `labels.open` ("Abrir"). */
+    label?: string;
+    /** Textos fijos (botón cerrar). */
+    labels?: KapiLabelsOverride<KapiShapeSheetLabels> | undefined;
+};
+/** ¿La tecla cierra el panel? */
+export declare const isDismissKey: (key: string) => boolean;
+/** ¿El target del evento cae fuera de `root`? (sin root o sin target no hay nada que cerrar). */
+export declare const isOutsideTarget: (root: Node | null, target: EventTarget | null) => boolean;
+/**
+ * "Container transform": el FAB circular se TRANSFORMA en panel (tamaño + radio + color).
+ * Cierra con el botón, con click fuera y con Escape. El panel es un diálogo no modal: al abrir el foco
+ * va al primer enfocable del contenido (o al panel) y al cerrar con el botón o Escape vuelve al FAB.
+ */
+export type KapiShapeSheetLabels = {
+    close: string;
+    open: string;
+};
+export declare const DEFAULT_SHAPE_SHEET_LABELS: KapiShapeSheetLabels;
+export declare const KapiShapeSheet: ({ title, children, width, height, label, labels, className, style, id }: KapiShapeSheetProps) => import("react").JSX.Element;

package/dist/components/overlays/KapiShapeSheet.js

@@ -0,0 +1,82 @@
+"use client";
+import { useLabels as e } from "../locale/KapiLocaleProvider.js";
+import { joinClasses as t } from "../rootProps.js";
+/* empty css             */
+import { focusableWithin as n } from "../../hooks/focusLogic.js";
+import { jsx as r, jsxs as i } from "react/jsx-runtime";
+import { useEffect as a, useId as o, useRef as s, useState as c } from "react";
+import { Minus as l, Plus as u } from "lucide-react";
+//#region src/components/overlays/KapiShapeSheet.tsx
+var d = (e) => e === "Escape", f = (e, t) => e !== null && t instanceof Node && !e.contains(t), p = {
+	close: "Cerrar",
+	open: "Abrir"
+}, m = ({ title: m, children: h, width: g = 300, height: _ = 250, label: v, labels: y, className: b, style: x, id: S }) => {
+	let C = e("shapeSheet", p, y), w = s(null), T = s(null), E = s(null), D = s(null), O = o(), [k, A] = c(!1), j = s(!1), M = () => {
+		j.current = !0, A(!1);
+	};
+	return a(() => {
+		k ? (n(D.current)[0] ?? E.current)?.focus() : j.current && (j.current = !1, T.current?.focus());
+	}, [k]), a(() => {
+		if (!k) return;
+		let e = (e) => {
+			f(w.current, e.target) && A(!1);
+		}, t = (e) => {
+			d(e.key) && (j.current = !0, A(!1));
+		};
+		return document.addEventListener("pointerdown", e), document.addEventListener("keydown", t), () => {
+			document.removeEventListener("pointerdown", e), document.removeEventListener("keydown", t);
+		};
+	}, [k]), /* @__PURE__ */ i("div", {
+		ref: w,
+		id: S,
+		className: t("kapi-shape", k && "kapi-shape--open", b),
+		style: k ? {
+			...x,
+			width: g,
+			height: _
+		} : x,
+		children: [/* @__PURE__ */ r("button", {
+			ref: T,
+			type: "button",
+			className: "kapi-shape__fab",
+			inert: k,
+			onClick: () => A(!0),
+			"aria-expanded": k,
+			"aria-label": v ?? C.open,
+			children: /* @__PURE__ */ r(u, {
+				size: 22,
+				strokeWidth: 2.4
+			})
+		}), /* @__PURE__ */ i("div", {
+			ref: E,
+			className: "kapi-shape__sheet",
+			inert: !k,
+			role: "dialog",
+			"aria-labelledby": O,
+			tabIndex: -1,
+			children: [/* @__PURE__ */ i("div", {
+				className: "kapi-shape__head",
+				children: [/* @__PURE__ */ r("span", {
+					className: "kapi-shape__title",
+					id: O,
+					children: m
+				}), /* @__PURE__ */ r("button", {
+					type: "button",
+					className: "kapi-shape__close",
+					onClick: M,
+					"aria-label": C.close,
+					children: /* @__PURE__ */ r(l, {
+						size: 16,
+						strokeWidth: 2.4
+					})
+				})]
+			}), /* @__PURE__ */ r("div", {
+				className: "kapi-shape__body",
+				ref: D,
+				children: h
+			})]
+		})]
+	});
+};
+//#endregion
+export { p as DEFAULT_SHAPE_SHEET_LABELS, m as KapiShapeSheet, d as isDismissKey, f as isOutsideTarget };

package/dist/components/overlays/KapiSplitModal.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from "react";
+import type { KapiModalProps } from "./KapiModal";
+import { type KapiSplitModalSide } from "./splitModalLayout";
+import "./KapiModal.css";
+import "./KapiSplitModal.css";
+import type { KapiLabelsOverride } from "../labelsLogic";
+export type KapiSplitModalAside = {
+    /** Controlled visibility of the aside. */
+    open: boolean;
+    children: ReactNode;
+    title?: ReactNode;
+    footer?: ReactNode;
+    /** Which side of the main card the aside docks to. Default "left". */
+    side?: KapiSplitModalSide;
+    /** Aside width (number → px, string → any CSS length). Default 380. */
+    width?: number | string;
+    /** X on the aside header: closes just the aside (the parent flips `open`). */
+    onClose?: () => void;
+    closeLabel?: string;
+};
+/** `close` es la X de la tarjeta principal; `closePanel`, la del panel lateral sin `closeLabel`. */
+export type KapiSplitModalLabels = {
+    close: string;
+    closePanel: string;
+};
+export declare const DEFAULT_SPLIT_MODAL_LABELS: KapiSplitModalLabels;
+export type KapiSplitModalProps = Omit<KapiModalProps, "labels"> & {
+    /** Panel lateral acoplado a la tarjeta principal (visibilidad, contenido, lado y ancho). */
+    aside?: KapiSplitModalAside;
+    /** Textos fijos (clave `splitModal`): la X principal (sin `closeLabel`) y la del panel lateral. */
+    labels?: KapiLabelsOverride<KapiSplitModalLabels> | undefined;
+};
+/**
+ * Modal con un panel lateral opcional ("Desglose"). Con `aside` ausente o
+ * `aside.open === false` es idéntico a KapiModal; con `aside.open` muestra ambas
+ * tarjetas juntas, centradas, cada una con su propio scroll. El botón que abre el
+ * aside lo pone el consumidor (p. ej. en `footer`). En pantallas angostas (<900px)
+ * las tarjetas se apilan en columna.
+ * `className`/`style`/`id` van a la tarjeta principal (como en `KapiModal`).
+ */
+export declare const KapiSplitModal: ({ open, ...props }: KapiSplitModalProps) => import("react").JSX.Element | null;

package/dist/components/overlays/KapiSplitModal.js

@@ -0,0 +1,125 @@
+"use client";
+import { useLabels as e } from "../locale/KapiLocaleProvider.js";
+import { dialogNameProps as t, modalClasses as n } from "./dialogUtils.js";
+import { useExitPresence as r } from "./useExitPresence.js";
+import { getPortalRoot as i, useBackdropClose as a, useNativeDialog as o } from "./useNativeDialog.js";
+/* empty css              */
+import { resolveAsideWidth as s, resolvePanelOrder as c, splitModalClasses as l } from "./splitModalLayout.js";
+/* empty css                   */
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+import { useId as f, useRef as p } from "react";
+import { X as m } from "lucide-react";
+import { createPortal as h } from "react-dom";
+//#region src/components/overlays/KapiSplitModal.tsx
+var g = {
+	close: "Cerrar",
+	closePanel: "Cerrar panel"
+}, _ = ({ open: e, ...t }) => {
+	let n = p(null), { present: i, closing: a } = r(e, n);
+	return i ? /* @__PURE__ */ u(y, {
+		...t,
+		dialogRef: n,
+		closing: a
+	}) : null;
+}, v = () => {}, y = ({ title: r, subtitle: p, onClose: _, children: y, footer: b, size: x = "md", hideHeader: S = !1, className: C = "", style: w, id: T, closeOnBackdrop: E = !0, closeOnEscape: D = !0, closeLabel: O, labels: k, "aria-label": A, "aria-labelledby": j, aside: M, dialogRef: N, closing: P }) => {
+	let F = P ? v : _, I = f(), L = f(), { ref: R, dialogProps: z } = o({ onRequestClose: D ? F : void 0 }), B = a(E ? F : void 0), V = e("splitModal", g, k), H = O ?? V.close, U = i();
+	if (!U) return null;
+	let W = M?.open === !0, G = M?.side ?? "left", K = /* @__PURE__ */ d("div", {
+		id: T,
+		className: n(x, C),
+		style: w,
+		children: [
+			S ? /* @__PURE__ */ u("button", {
+				type: "button",
+				className: "kapi-modal__x kapi-modal__x--float",
+				onClick: F,
+				"aria-label": H,
+				children: /* @__PURE__ */ u(m, {
+					size: 17,
+					strokeWidth: 2.2
+				})
+			}) : /* @__PURE__ */ d("div", {
+				className: "kapi-modal__head",
+				children: [/* @__PURE__ */ d("div", { children: [/* @__PURE__ */ u("div", {
+					id: I,
+					className: "kapi-modal__title",
+					children: r
+				}), p && /* @__PURE__ */ u("div", {
+					className: "kapi-modal__sub",
+					children: p
+				})] }), /* @__PURE__ */ u("button", {
+					type: "button",
+					className: "kapi-modal__x",
+					onClick: F,
+					"aria-label": H,
+					children: /* @__PURE__ */ u(m, {
+						size: 17,
+						strokeWidth: 2.2
+					})
+				})]
+			}),
+			/* @__PURE__ */ u("div", {
+				className: "kapi-modal__body",
+				children: y
+			}),
+			b && /* @__PURE__ */ u("div", {
+				className: "kapi-modal__foot",
+				children: b
+			})
+		]
+	}, "main"), q = M && W ? /* @__PURE__ */ d("aside", {
+		className: "kapi-splitmodal__aside",
+		style: { "--kapi-split-aside-w": s(M.width) },
+		"aria-labelledby": M.title ? L : void 0,
+		children: [
+			(M.title || M.onClose) && /* @__PURE__ */ d("div", {
+				className: "kapi-modal__head",
+				children: [/* @__PURE__ */ u("div", {
+					id: L,
+					className: "kapi-modal__title",
+					children: M.title
+				}), M.onClose && /* @__PURE__ */ u("button", {
+					type: "button",
+					className: "kapi-modal__x",
+					onClick: M.onClose,
+					"aria-label": M.closeLabel ?? V.closePanel,
+					children: /* @__PURE__ */ u(m, {
+						size: 17,
+						strokeWidth: 2.2
+					})
+				})]
+			}),
+			/* @__PURE__ */ u("div", {
+				className: "kapi-modal__body",
+				children: M.children
+			}),
+			M.footer && /* @__PURE__ */ u("div", {
+				className: "kapi-modal__foot",
+				children: M.footer
+			})
+		]
+	}, "aside") : null, J = c(G).map((e) => e === "main" ? K : q).filter((e) => e !== null);
+	return h(/* @__PURE__ */ u("dialog", {
+		ref: (e) => {
+			R.current = e, N.current = e;
+		},
+		className: "kapi-modal-overlay kapi-modal-dialog",
+		"data-closing": P || void 0,
+		"aria-modal": "true",
+		...t({
+			titleId: I,
+			title: r,
+			hideHeader: S,
+			"aria-label": A,
+			"aria-labelledby": j
+		}),
+		...z,
+		...B,
+		children: /* @__PURE__ */ u("div", {
+			className: W ? l(G) : "kapi-splitmodal kapi-splitmodal--single",
+			children: J
+		})
+	}), U);
+};
+//#endregion
+export { g as DEFAULT_SPLIT_MODAL_LABELS, _ as KapiSplitModal };

package/dist/components/overlays/KapiTooltip.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from "react";
+import "./overlays.css";
+import { type KapiRootProps } from "../rootProps";
+export type KapiTooltipSide = "right" | "left" | "top" | "bottom";
+/** `className`/`style`/`id` van al envoltorio `<span class="kapi-tip">` del disparador. */
+export type KapiTooltipProps = KapiRootProps & {
+    /** Texto del tooltip. */
+    label: string;
+    /** Disparador: el elemento que muestra el tooltip al pasar el mouse o enfocarlo. */
+    children: ReactNode;
+    /** Lado preferido: se respeta si entra; si no, va al opuesto. */
+    prefer?: KapiTooltipSide;
+};
+/** Ancho estimado de la burbuja (sin medirla), con tope. */
+export declare const estimateTooltipWidth: (label: string) => number;
+/**
+ * Lado final del tooltip (auto-flip) con el motor `placePopover`: se respeta el lado pedido salvo que
+ * la burbuja (tamaño estimado) no entre; entonces va al opuesto. Pura: recibe el rect del disparador y
+ * el viewport (sin `bottom`/`left` se toman `top`/`right`; sin alto de viewport, abajo siempre entra).
+ */
+export declare const resolveTooltipSide: (prefer: KapiTooltipSide, rect: Pick<DOMRect, "top" | "right"> & Partial<Pick<DOMRect, "bottom" | "left">>, label: string, viewportWidth: number, viewportHeight?: number) => KapiTooltipSide;
+/**
+ * Punto de la burbuja en coordenadas de viewport según el lado (la burbuja es `position: fixed`, así no la
+ * recorta un contenedor con overflow, como el panel plegado o la zona que scrollea del rail). El CSS la
+ * corre desde ese punto (centrada en el eje que corresponda).
+ */
+export declare const tooltipAnchor: (side: KapiTooltipSide, rect: Pick<DOMRect, "top" | "bottom" | "left" | "right">) => {
+    x: number;
+    y: number;
+};
+/** `aria-describedby` del disparador: suma el id del tooltip al que ya traía (sin pisarlo ni repetir). */
+export declare const tooltipDescribedBy: (existing: unknown, tipId: string) => string | undefined;
+/**
+ * Tooltip para íconos sueltos. Se muestra con hover y con foco de teclado (`:focus-visible`), se
+ * descarta con Escape (WCAG 1.4.13) y el disparador lo referencia por `aria-describedby`. Al abrir mide
+ * el disparador y abre del lado con espacio.
+ */
+export declare const KapiTooltip: ({ label, children, prefer, className, style, id }: KapiTooltipProps) => import("react").JSX.Element;

package/dist/components/overlays/KapiTooltip.js

@@ -0,0 +1,105 @@
+"use client";
+import { joinIds as e } from "../inputs/fieldLogic.js";
+import { placePopover as t } from "./popoverLogic.js";
+import { onViewportChange as n } from "../../hooks/rafThrottle.js";
+import { joinClasses as r } from "../rootProps.js";
+/* empty css             */
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+import { cloneElement as o, isValidElement as s, useEffect as c, useId as l, useLayoutEffect as u, useRef as d, useState as f } from "react";
+//#region src/components/overlays/KapiTooltip.tsx
+var p = 280, m = 7, h = 28, g = 12, _ = 44, v = (e) => Math.min(p, String(e).length * m + h), y = (e, n, r, i, a = Infinity) => {
+	let o = n.bottom ?? n.top, s = n.left ?? n.right, c = {
+		top: n.top,
+		bottom: o,
+		left: s,
+		right: n.right,
+		width: n.right - s,
+		height: o - n.top
+	}, l = e === "top" || e === "bottom";
+	return t(c, {
+		width: v(r),
+		height: _
+	}, {
+		width: i,
+		height: a
+	}, {
+		side: e,
+		offset: l ? 0 : g,
+		flip: "if-overflow",
+		shift: !1
+	}).side;
+}, b = 10, x = 8, S = (e, t) => {
+	let n = (t.left + t.right) / 2, r = (t.top + t.bottom) / 2;
+	return e === "left" ? {
+		x: t.left - b,
+		y: r
+	} : e === "top" ? {
+		x: n,
+		y: t.top - x
+	} : e === "bottom" ? {
+		x: n,
+		y: t.bottom + x
+	} : {
+		x: t.right + b,
+		y: r
+	};
+}, C = (e, t) => {
+	try {
+		return e.matches(t);
+	} catch {
+		return null;
+	}
+}, w = (t, n) => e(typeof t == "string" ? t : void 0, n), T = ({ label: e, children: t, prefer: p = "right", className: m, style: h, id: g }) => {
+	let _ = l(), v = d(null), [b, x] = f(p), [T, E] = f(!1), [D, O] = f(!1), k = d({
+		hover: !1,
+		focus: !1
+	}), A = () => {
+		let t = v.current;
+		if (!t) return;
+		let n = t.getBoundingClientRect(), r = y(p, n, e, window.innerWidth, window.innerHeight), { x: i, y: a } = S(r, n);
+		t.style.setProperty("--kapi-tip-x", `${Math.round(i)}px`), t.style.setProperty("--kapi-tip-y", `${Math.round(a)}px`), x(r);
+	}, j = d(A);
+	u(() => {
+		j.current = A;
+	});
+	let M = d(null), N = d(!1), P = (e) => {
+		let t = M.current;
+		if (!t || typeof t.showPopover != "function") return;
+		let n = C(t, ":popover-open") ?? N.current;
+		e && !n && t.showPopover(), !e && n && t.hidePopover(), N.current = e;
+	}, F = (e) => {
+		k.current[e] = !0, E(!1), O(!0), A(), P(!0);
+	}, I = (e) => {
+		k.current[e] = !1, !(k.current.hover || k.current.focus) && (E(!1), O(!1), P(!1));
+	};
+	c(() => D ? n(() => j.current()) : void 0, [D]);
+	let L = (e) => {
+		e.key === "Escape" && !T && E(!0);
+	}, R = s(t) ? t : null, z = R ? o(R, { "aria-describedby": w(R.props["aria-describedby"], _) }) : t;
+	return /* @__PURE__ */ a("span", {
+		id: g,
+		className: r("kapi-tip", m),
+		style: h,
+		ref: v,
+		"data-side": b,
+		"data-dismissed": T || void 0,
+		"aria-describedby": R ? void 0 : _,
+		onMouseEnter: () => F("hover"),
+		onFocus: (e) => {
+			(C(e.target, ":focus-visible") ?? !0) && F("focus");
+		},
+		onMouseLeave: () => I("hover"),
+		onBlur: () => I("focus"),
+		onKeyDown: L,
+		children: [z, /* @__PURE__ */ i("span", {
+			ref: M,
+			className: "kapi-tip__bubble",
+			role: "tooltip",
+			id: _,
+			popover: "manual",
+			children: e
+		})]
+	});
+};
+//#endregion
+export { T as KapiTooltip, v as estimateTooltipWidth, y as resolveTooltipSide, S as tooltipAnchor, w as tooltipDescribedBy };

package/dist/components/overlays/canvasFormLogic.d.ts

@@ -0,0 +1,18 @@
+/** Anything with a `then` is treated as an async result. */
+export declare const isThenable: (value: unknown) => value is PromiseLike<unknown>;
+export type RunSubmitHooks = {
+    /** Called right before an async submit starts (never for a sync handler). */
+    onStart: () => void;
+    /** Called when an async submit settles, whether it resolved or rejected. */
+    onEnd: () => void;
+    /** Receives a rejection. When omitted the rejection is re-thrown to the caller. */
+    onError?: ((error: unknown) => void) | undefined;
+};
+/**
+ * Runs a submit handler and reports the async lifecycle.
+ * - Sync handler: neither `onStart` nor `onEnd` fire (no flicker of the busy state).
+ * - Async handler: `onStart` fires first, `onEnd` always fires once it settles.
+ * - Rejection: goes to `onError` if given, otherwise it is re-thrown after `onEnd`.
+ * A synchronous throw is handled like a rejection.
+ */
+export declare const runSubmit: (handler: () => unknown, hooks: RunSubmitHooks) => Promise<void>;

package/dist/components/overlays/canvasFormLogic.js

@@ -0,0 +1,16 @@
+//#region src/components/overlays/canvasFormLogic.ts
+var e = (e) => typeof e == "object" && !!e && typeof e.then == "function", t = async (t, n) => {
+	let r = !1;
+	try {
+		let i = t();
+		if (!e(i)) return;
+		r = !0, n.onStart(), await i;
+	} catch (e) {
+		if (!n.onError) throw e;
+		n.onError(e);
+	} finally {
+		r && n.onEnd();
+	}
+};
+//#endregion
+export { e as isThenable, t as runSubmit };

package/dist/components/overlays/commandPaletteLogic.d.ts

@@ -0,0 +1,29 @@
+/** Pure logic for KapiCommandPalette: matching, filtering, flattening and active-index handling. */
+/** Lowercase + strip diacritics so "bandeja" matches "Bandejás" and "inicio" matches "Início". */
+export declare const normalizeText: (text: string) => string;
+/** Minimal shape the logic needs from a command (the component's `KapiCommand` satisfies it). */
+export type CommandLike = {
+    id: string;
+    /** Plain-text label used for matching (the component derives it from `label`). */
+    text: string;
+    keywords?: readonly string[];
+    disabled?: boolean;
+};
+export type GroupLike<C extends CommandLike> = {
+    id: string;
+    commands: readonly C[];
+};
+/** Text of a ReactNode-ish label: strings and numbers only; anything else yields "". */
+export declare const nodeText: (node: unknown) => string;
+/** True when every whitespace-separated term of the query appears in the label or any keyword. */
+export declare const matchesCommand: (command: CommandLike, query: string) => boolean;
+/** Keep only matching commands; drop groups left without matches (so their label is hidden). */
+export declare const filterGroups: <C extends CommandLike, G extends GroupLike<C>>(groups: readonly G[], query: string) => Array<G & {
+    commands: C[];
+}>;
+/** Flat navigation list across groups, in display order, skipping disabled commands. */
+export declare const flattenNavigable: <C extends CommandLike>(groups: readonly GroupLike<C>[]) => C[];
+/** Next/previous index with wrap. From "none" (-1): down -> first, up -> last. */
+export declare const moveActiveIndex: (current: number, count: number, direction: 1 | -1) => number;
+/** Keep the active index valid when the list changes: -1 when empty, otherwise clamped into range. */
+export declare const clampActiveIndex: (index: number, count: number) => number;

package/dist/components/overlays/commandPaletteLogic.js

@@ -0,0 +1,19 @@
+//#region src/components/overlays/commandPaletteLogic.ts
+var e = (e) => e.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase(), t = (e) => typeof e == "string" ? e : typeof e == "number" ? String(e) : Array.isArray(e) ? e.map(t).join("") : e && typeof e == "object" && "props" in e ? t(e.props?.children) : "", n = (t, n) => {
+	let r = e(n.trim());
+	if (!r) return !0;
+	let i = [t.text, ...t.keywords ?? []].map(e).join("\n");
+	return r.split(/\s+/).every((e) => i.includes(e));
+}, r = (e, t) => {
+	let r = [];
+	for (let i of e) {
+		let e = i.commands.filter((e) => n(e, t));
+		e.length > 0 && r.push({
+			...i,
+			commands: e
+		});
+	}
+	return r;
+}, i = (e) => e.flatMap((e) => e.commands.filter((e) => !e.disabled)), a = (e, t, n) => t <= 0 ? -1 : e < 0 || e >= t ? n === 1 ? 0 : t - 1 : (e + n + t) % t, o = (e, t) => t <= 0 ? -1 : e < 0 ? 0 : Math.min(e, t - 1);
+//#endregion
+export { o as clampActiveIndex, r as filterGroups, i as flattenNavigable, n as matchesCommand, a as moveActiveIndex, t as nodeText, e as normalizeText };