@kapiuara/ui 0.0.0-stage → 0.1.1

package/dist/components/inputs/KapiTagInput.js

@@ -0,0 +1,115 @@
+"use client";
+import { assignRef as e, fieldControlProps as t, focusLeaves as n, joinIds as r } from "./fieldLogic.js";
+import { useKapiField as ee } from "./KapiField.js";
+import { useLabels as i } from "../locale/KapiLocaleProvider.js";
+import { joinClasses as a } from "../rootProps.js";
+/* empty css                 */
+import { addTags as o, hasSeparator as s, removeTagAt as c, spliceText as te, splitDraft as l, splitTags as u } from "./tagInputLogic.js";
+import { KapiTag as d } from "../display/KapiTag.js";
+import { jsx as f, jsxs as p } from "react/jsx-runtime";
+import { useCallback as m, useId as ne, useRef as h, useState as g } from "react";
+//#region src/components/inputs/KapiTagInput.tsx
+var _ = {
+	remove: "Quitar",
+	duplicate: "Ya está en la lista:",
+	max: "Llegaste al máximo de"
+}, v = ({ size: e = "md", invalid: t, disabled: n, className: r }) => a("kapi-taginput", e !== "md" && `kapi-taginput--${e}`, t && "kapi-taginput--err", n && "kapi-taginput--disabled", r);
+function y({ value: a, defaultValue: y = [], onChange: b, validate: x, maxTags: S, allowDuplicates: C, caseSensitive: w, placeholder: T, disabled: E = !1, size: D = "md", name: O, id: re, invalid: ie, required: k, "aria-label": A, "aria-labelledby": j, "aria-describedby": M, onBlur: N, ref: P, labels: F, className: I, onClick: L, ...R }) {
+	let z = i("tagInput", _, F), B = ee(), V = ne(), [H, U] = g(y), [W, G] = g(""), [K, q] = g(null), J = h(null), Y = h(null), X = a ?? H, ae = m((t) => {
+		Y.current = t, e(P, t);
+	}, [P]), Z = (e) => {
+		a === void 0 && U(e), b?.(e);
+	}, oe = (e) => e.reason === "invalid" ? e.message : e.reason === "duplicate" ? `${z.duplicate} ${e.tag}` : `${z.max} ${S}`, Q = (e, t = "") => {
+		let { values: n, rejected: r } = o(X, e, {
+			validate: x,
+			maxTags: S,
+			allowDuplicates: C,
+			caseSensitive: w
+		});
+		n.length !== X.length && Z(n), q(r[0] ? oe(r[0]) : null), G([...r.map((e) => e.tag), t].filter(Boolean).join(", "));
+	}, se = (e) => {
+		let t = e.target.value;
+		if (q(null), !s(t)) {
+			G(t);
+			return;
+		}
+		let { complete: n, tail: r } = l(t);
+		Q(n, r);
+	}, ce = (e) => {
+		E || (e.key === "Enter" && W.trim() ? (e.preventDefault(), Q(u(W))) : e.key === "Backspace" && W === "" && X.length > 0 && (e.preventDefault(), q(null), Z(c(X, X.length - 1))));
+	}, le = (e) => {
+		let t = e.clipboardData.getData("text");
+		if (!s(t)) return;
+		e.preventDefault();
+		let n = e.currentTarget, r = te(W, n.selectionStart ?? W.length, n.selectionEnd ?? W.length, t);
+		Q(u(r));
+	}, ue = (e) => {
+		n(e.relatedTarget, J.current) && (W.trim() && Q(u(W)), N?.(e));
+	}, de = (e) => {
+		L?.(e), !(e.defaultPrevented || E) && (e.target.closest("button, input") || Y.current?.focus());
+	}, fe = (e) => {
+		q(null), Z(c(X, e)), Y.current?.focus();
+	}, $ = K !== null || (ie ?? B?.invalid ?? !1);
+	return /* @__PURE__ */ p("div", {
+		...R,
+		ref: J,
+		className: v({
+			size: D,
+			invalid: $,
+			disabled: E,
+			className: I
+		}),
+		onClick: de,
+		onBlur: ue,
+		children: [
+			/* @__PURE__ */ p("div", {
+				className: "kapi-taginput__box",
+				children: [X.length > 0 && /* @__PURE__ */ f("ul", {
+					className: "kapi-taginput__tags",
+					children: X.map((e, t) => /* @__PURE__ */ f("li", {
+						className: "kapi-taginput__item",
+						children: /* @__PURE__ */ f(d, {
+							tone: "primary",
+							size: D === "sm" ? "sm" : "md",
+							onRemove: E ? void 0 : () => fe(t),
+							removeLabel: `${z.remove} ${e}`,
+							children: e
+						})
+					}, `${t}-${e}`))
+				}), /* @__PURE__ */ f("input", {
+					ref: ae,
+					type: "text",
+					className: "kapi-taginput__input",
+					...t(B, {
+						id: re,
+						describedBy: r(K !== null && V, M),
+						invalid: $,
+						required: k
+					}),
+					"aria-label": A,
+					"aria-labelledby": j,
+					placeholder: X.length ? void 0 : T,
+					value: W,
+					disabled: E,
+					enterKeyHint: "enter",
+					onChange: se,
+					onKeyDown: ce,
+					onPaste: le
+				})]
+			}),
+			K !== null && /* @__PURE__ */ f("span", {
+				id: V,
+				className: "kapi-taginput__error",
+				role: "alert",
+				children: K
+			}),
+			O && X.map((e, t) => /* @__PURE__ */ f("input", {
+				type: "hidden",
+				name: O,
+				value: e
+			}, `${t}-${e}`))
+		]
+	});
+}
+//#endregion
+export { _ as DEFAULT_TAG_INPUT_LABELS, y as KapiTagInput, v as tagInputClasses };

package/dist/components/inputs/KapiTextarea.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode, type Ref, type TextareaHTMLAttributes } from "react";
+import "./inputsExtra.css";
+import { type KapiFieldStatus } from "./KapiField";
+export type KapiTextareaFieldProps = TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    /** Validation: green (`ok`) or red (`err`) border. */
+    status?: KapiFieldStatus;
+    /** Label. With `label` or `help` the control is wrapped in a `KapiField`. */
+    label?: ReactNode;
+    /** Adds the required asterisk to the label. */
+    required?: boolean;
+    /** Help / error message below the control (takes the color of `status`). */
+    help?: ReactNode;
+    /** Class of the wrapping `KapiField` (if any). `className` goes to the control. */
+    fieldClassName?: string;
+    /** Grow with the content instead of showing a scrollbar. */
+    autosize?: boolean;
+    /** With `autosize`: max visible rows before it scrolls (default: unlimited). */
+    maxRows?: number;
+    /** Ref to the `<textarea>`. */
+    ref?: Ref<HTMLTextAreaElement>;
+};
+/** Control classes. Pure and exported: this is what gets tested (not the markup). */
+export declare const textareaClasses: ({ status, autosize, className }?: {
+    status?: KapiFieldStatus | undefined;
+    autosize?: boolean | undefined;
+    className?: string | undefined;
+}) => string;
+/**
+ * Multiline text field of the design system (`.kapi-input` + `.kapi-textarea`). Works controlled or not.
+ * With `autosize` it grows with its content, optionally up to `maxRows`.
+ */
+export declare const KapiTextarea: ({ status, label, required, help, fieldClassName, autosize, maxRows, className, id, rows, onInput, ref, ...rest }: KapiTextareaFieldProps) => import("react").JSX.Element;

package/dist/components/inputs/KapiTextarea.js

@@ -0,0 +1,67 @@
+"use client";
+import { fieldControlProps as e, joinIds as t } from "./fieldLogic.js";
+import { KapiField as n, useKapiField as r } from "./KapiField.js";
+/* empty css                */
+import { inputClasses as i } from "./KapiInput.js";
+import { autosizeHeight as a, rowsToHeight as o } from "./textareaLogic.js";
+import { jsx as s } from "react/jsx-runtime";
+import { useCallback as c, useId as l, useLayoutEffect as u, useRef as d } from "react";
+//#region src/components/inputs/KapiTextarea.tsx
+var f = ({ status: e, autosize: t = !1, className: n = "" } = {}) => i({
+	status: e,
+	className: [
+		"kapi-textarea",
+		t && "kapi-textarea--auto",
+		n
+	].filter(Boolean).join(" ")
+}), p = ({ status: i, label: p, required: m, help: h, fieldClassName: g, autosize: _, maxRows: v, className: y, id: b, rows: x = 3, onInput: S, ref: C, ...w }) => {
+	let T = r(), E = p != null || !!h, D = l(), O = b ?? (E ? D : T?.controlId), k = h ? `${O}-help` : void 0, A = d(null), j = c((e) => {
+		A.current = e, typeof C == "function" ? C(e) : C && (C.current = e);
+	}, [C]), M = c(() => {
+		let e = A.current;
+		if (!e || !_) return;
+		let t = getComputedStyle(e), n = (e) => parseFloat(e) || 0, r = n(t.lineHeight) || n(t.fontSize) * 1.5, i = n(t.borderTopWidth) + n(t.borderBottomWidth), s = n(t.paddingTop) + n(t.paddingBottom) + i;
+		e.style.height = "auto";
+		let { height: c, overflowing: l } = a(e.scrollHeight + i, {
+			minHeight: o(x, r, s),
+			maxHeight: v ? o(v, r, s) : void 0
+		});
+		e.style.height = `${c}px`, e.style.overflowY = l ? "auto" : "hidden";
+	}, [
+		_,
+		v,
+		x
+	]);
+	u(M);
+	let N = (e) => {
+		M(), S?.(e);
+	}, P = /* @__PURE__ */ s("textarea", {
+		...w,
+		ref: j,
+		...e(E ? null : T, {
+			id: O,
+			describedBy: t(k, w["aria-describedby"]),
+			invalid: i ? i === "err" : void 0
+		}),
+		rows: x,
+		required: m,
+		className: f({
+			status: i,
+			autosize: _,
+			className: y
+		}),
+		onInput: N
+	});
+	return E ? /* @__PURE__ */ s(n, {
+		label: p,
+		htmlFor: O,
+		required: m,
+		help: h,
+		helpId: k,
+		status: i,
+		className: g,
+		children: P
+	}) : P;
+};
+//#endregion
+export { p as KapiTextarea, f as textareaClasses };

package/dist/components/inputs/asyncSelectLogic.d.ts

@@ -0,0 +1,42 @@
+import { type KapiSelectEntry, type KapiSelectOption, type KapiSelectValue } from "./selectLogic";
+/** Opciones conocidas por valor: así los seleccionados conservan su label aunque salgan de la lista. */
+export type KapiKnownOptions<T = unknown> = ReadonlyMap<string, KapiSelectOption<T>>;
+/**
+ * Suma las opciones de `entries` (aplanando grupos) a la caché; la versión nueva de un valor reemplaza a la
+ * anterior. Sin cambios devuelve el mismo `Map` (un `setState` con él no re-renderiza).
+ */
+export declare const mergeKnownOptions: <T>(known: KapiKnownOptions<T>, entries: readonly KapiSelectEntry<T>[]) => KapiKnownOptions<T>;
+/** Opciones seleccionadas resueltas desde la caché, en el orden del valor (los valores desconocidos se omiten). */
+export declare const selectedFromKnown: <T>(known: KapiKnownOptions<T>, value: KapiSelectValue | undefined) => KapiSelectOption<T>[];
+/**
+ * Ofrecer "Crear …": la búsqueda (sin espacios de borde) no está vacía y ninguna opción visible tiene
+ * exactamente ese label (sin distinguir mayúsculas ni acentos).
+ */
+export declare const showCreateOption: <T>(entries: readonly KapiSelectEntry<T>[], query: string) => boolean;
+/** Valor tras crear una opción: simple → la creada; múltiple → se agrega (nunca se quita si ya estaba). */
+export declare const withCreated: (value: KapiSelectValue | undefined, createdValue: string, multiple: boolean) => KapiSelectValue;
+export type KapiLoadRequest = {
+    /** Señal para cancelar el pedido (se aborta al empezar otro, al cerrar o al desmontar). */
+    signal: AbortSignal;
+    /** Si el pedido sigue siendo el último y no se abortó: solo entonces puede escribir resultados. */
+    isCurrent: () => boolean;
+};
+export type KapiLoadSequencer = {
+    /** Empieza un pedido: aborta el anterior y lo vuelve viejo. */
+    start: () => KapiLoadRequest;
+    /** Aborta el pedido en curso sin empezar otro. */
+    cancel: () => void;
+};
+/** Secuencia de cargas: un `AbortController` por pedido más el guardia de respuestas fuera de orden. */
+export declare const createLoadSequencer: () => KapiLoadSequencer;
+/** Valor interno de la fila "Crear …" (nunca se emite: elegirla llama a `onCreate`). */
+export declare const CREATE_VALUE = "\0kapisel-create";
+/** Si la opción es la fila "Crear …" agregada por `menuItems`. */
+export declare const isCreateRow: (option: {
+    value: string;
+}) => boolean;
+/**
+ * Lista navegable del menú: las opciones aplanadas y, si `canCreate` y `showCreateOption` lo permiten, la fila
+ * "Crear …" al final (con índice propio para teclado y `aria-activedescendant`). Única fuente de la regla.
+ */
+export declare const menuItems: <T>(entries: readonly KapiSelectEntry<T>[], query: string, canCreate: boolean, createLabel: string) => KapiSelectOption<T>[];

package/dist/components/inputs/asyncSelectLogic.js

@@ -0,0 +1,46 @@
+import { flattenOptions as e, normalizeText as t, normalizeValue as n, toggleValue as r } from "./selectLogic.js";
+import { createRequestTracker as i } from "./autocompleteLogic.js";
+//#region src/components/inputs/asyncSelectLogic.ts
+var a = (e, t) => e === t || e.label === t.label && e.disabled === t.disabled && e.data === t.data, o = (t, n) => {
+	let r = null;
+	for (let i of e(n)) {
+		let e = (r ?? t).get(i.value);
+		e && a(e, i) || (r ??= new Map(t), r.set(i.value, i));
+	}
+	return r ?? t;
+}, s = (e, t) => {
+	let r = [];
+	for (let i of n(t, !0)) {
+		let t = e.get(i);
+		t && r.push(t);
+	}
+	return r;
+}, c = (n, r) => {
+	let i = t(r.trim());
+	return i ? !e(n).some((e) => t(e.label.trim()) === i) : !1;
+}, l = (e, t, i) => i && n(e, !0).includes(t) ? n(e, !0) : r(e, t, i), u = () => {
+	let e = i(), t = null;
+	return {
+		start: () => {
+			t?.abort();
+			let n = new AbortController();
+			t = n;
+			let r = e.next();
+			return {
+				signal: n.signal,
+				isCurrent: () => e.isCurrent(r) && !n.signal.aborted
+			};
+		},
+		cancel: () => {
+			t?.abort(), t = null, e.cancel();
+		}
+	};
+}, d = "\0kapisel-create", f = (e) => e.value === d, p = (t, n, r, i) => {
+	let a = e(t);
+	return r && c(t, n) ? [...a, {
+		value: d,
+		label: i
+	}] : a;
+};
+//#endregion
+export { d as CREATE_VALUE, u as createLoadSequencer, f as isCreateRow, p as menuItems, o as mergeKnownOptions, s as selectedFromKnown, c as showCreateOption, l as withCreated };

package/dist/components/inputs/autocompleteLogic.d.ts

@@ -0,0 +1,73 @@
+/** Lowercase + strip diacritics so "ingenieria" matches "Ingeniería". */
+export declare const normalizeText: (text: string) => string;
+/**
+ * Sync filter: options whose label contains the query (case/diacritic-insensitive).
+ * Prefix matches rank before inner matches; ties keep the original order. `limit <= 0` or
+ * `Infinity` means no cap.
+ */
+export declare const filterOptions: <T>(options: readonly T[], query: string, getLabel: (option: T) => string, limit?: number) => T[];
+/** Next/previous active 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;
+/** The dropdown opens only while the input is focused, not dismissed, and the query is long enough. */
+export declare const shouldOpen: ({ focused, dismissed, query, minChars }: {
+    focused: boolean;
+    dismissed: boolean;
+    query: string;
+    minChars?: number;
+}) => boolean;
+export type HighlightPart = {
+    text: string;
+    match: boolean;
+};
+/** Split a label around the first occurrence of the query (diacritic-insensitive), keeping original text. */
+export declare const highlightParts: (label: string, query: string) => HighlightPart[];
+/** True when a response belongs to the most recent request (older ones must be dropped). */
+export declare const isLatestRequest: (requestId: number, latestId: number) => boolean;
+export type RequestTracker = {
+    /** Start a new request; every earlier id becomes stale. */
+    next: () => number;
+    /** Invalidate all in-flight requests without starting one (unmount, query cleared). */
+    cancel: () => void;
+    /** Whether `id` is still the latest request. */
+    isCurrent: (id: number) => boolean;
+};
+/** Monotonic request-id tracker: guards against out-of-order async responses. */
+export declare const createRequestTracker: () => RequestTracker;
+export type MenuPosition = {
+    top: number;
+    left: number;
+    width: number;
+};
+/**
+ * Viewport-space (`position: fixed`) box for a portaled menu anchored under an input.
+ * `gap` is the vertical space between the input's bottom edge and the menu. Width never goes negative.
+ */
+export declare const menuPositionFrom: (rect: {
+    left: number;
+    bottom: number;
+    width: number;
+}, gap?: number) => MenuPosition;
+/** Engine options for the autocomplete menu: below the input, input width, flips up, no clamping. */
+export declare const AUTOCOMPLETE_MENU_PLACEMENT: {
+    readonly side: "bottom";
+    readonly align: "start";
+    readonly flip: "auto";
+    readonly shift: false;
+    readonly width: "anchor";
+};
+/**
+ * Menu box under the input that flips above when it does not fit below and there is more room above
+ * (unmeasured height 0 never flips). Same engine options the component uses through `usePlacement`.
+ */
+export declare const placeAutocompleteMenu: (rect: {
+    top: number;
+    bottom: number;
+    left: number;
+    width: number;
+}, menuHeight: number, viewportHeight: number, gap?: number) => MenuPosition & {
+    side: "top" | "bottom";
+};
+/** Text shown as the default label for string-ish options. */
+export declare const defaultGetLabel: (option: unknown) => string;

package/dist/components/inputs/autocompleteLogic.js

@@ -0,0 +1,67 @@
+//#region src/components/inputs/autocompleteLogic.ts
+var e = (e) => e.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase(), t = (t, n, r, i = Infinity) => {
+	let a = e(n.trim()), o = i > 0 ? i : Infinity;
+	if (!a) return t.slice(0, o);
+	let s = [], c = [];
+	for (let n of t) {
+		let t = e(r(n)).indexOf(a);
+		t === 0 ? s.push(n) : t > 0 && c.push(n);
+	}
+	return [...s, ...c].slice(0, o);
+}, n = (e, t, n) => t <= 0 ? -1 : e < 0 || e >= t ? n === 1 ? 0 : t - 1 : (e + n + t) % t, r = (e, t) => t <= 0 || e < 0 ? -1 : Math.min(e, t - 1), i = ({ focused: e, dismissed: t, query: n, minChars: r = 0 }) => e && !t && n.trim().length >= r, a = (t, n) => {
+	let r = e(n.trim());
+	if (!r || !t) return [{
+		text: t,
+		match: !1
+	}];
+	let i = "", a = [];
+	for (let n = 0; n < t.length; n++) {
+		let r = e(t.charAt(n));
+		for (let e = 0; e < r.length; e++) a.push(n);
+		i += r;
+	}
+	let o = i.indexOf(r);
+	if (o < 0) return [{
+		text: t,
+		match: !1
+	}];
+	let s = a[o] ?? 0, c = (a[o + r.length - 1] ?? t.length - 1) + 1;
+	return [
+		{
+			text: t.slice(0, s),
+			match: !1
+		},
+		{
+			text: t.slice(s, c),
+			match: !0
+		},
+		{
+			text: t.slice(c),
+			match: !1
+		}
+	].filter((e) => e.text !== "");
+}, o = (e, t) => e === t, s = () => {
+	let e = 0;
+	return {
+		next: () => ++e,
+		cancel: () => {
+			e++;
+		},
+		isCurrent: (t) => o(t, e)
+	};
+}, c = {
+	side: "bottom",
+	align: "start",
+	flip: "auto",
+	shift: !1,
+	width: "anchor"
+}, l = (e) => {
+	if (typeof e == "string") return e;
+	if (e && typeof e == "object" && "label" in e) {
+		let t = e.label;
+		if (typeof t == "string") return t;
+	}
+	return String(e);
+};
+//#endregion
+export { c as AUTOCOMPLETE_MENU_PLACEMENT, r as clampActiveIndex, s as createRequestTracker, l as defaultGetLabel, t as filterOptions, a as highlightParts, o as isLatestRequest, n as moveActiveIndex, e as normalizeText, i as shouldOpen };

package/dist/components/inputs/checkControl.d.ts

@@ -0,0 +1,20 @@
+import type { InputHTMLAttributes, ReactNode, Ref } from "react";
+export type KapiCheckControlProps = Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "children"> & {
+    /** Texto al lado del control. Sin `label`, pasa `aria-label`. */
+    label?: ReactNode;
+    /** Marca el control como inválido (`aria-invalid`). Sin la prop, lo toma del `KapiField` (`status="err"`). */
+    invalid?: boolean;
+    /** Ref al `<input>`. */
+    ref?: Ref<HTMLInputElement>;
+};
+/** Clases del `<label>` `.kapi-check`. Pura y exportada para testear. */
+export declare const checkClasses: (className?: string) => string;
+/**
+ * Base interna de KapiCheckbox y KapiRadio: `<label class="kapi-check"><input/>texto</label>`. `className` va a la etiqueta.
+ * Dentro de un `KapiField` toma ayuda (`aria-describedby`), `aria-invalid` y `aria-required`; el checkbox también el id
+ * (lo nombra el label del campo). El radio no: los de un grupo comparten el campo y se nombran con su `label`.
+ */
+export declare const createCheckControl: (type: "checkbox" | "radio", displayName: string) => {
+    ({ label, className, ref, invalid, id, required, "aria-describedby": describedBy, "aria-invalid": ariaInvalid, "aria-required": ariaRequired, ...rest }: KapiCheckControlProps): import("react").JSX.Element;
+    displayName: string;
+};

package/dist/components/inputs/checkControl.js

@@ -0,0 +1,31 @@
+"use client";
+import { nativeFieldProps as e } from "./fieldLogic.js";
+import { useKapiField as t } from "./KapiField.js";
+import { jsx as n, jsxs as r } from "react/jsx-runtime";
+//#region src/components/inputs/checkControl.tsx
+var i = (e = "") => ["kapi-check", e].filter(Boolean).join(" "), a = (a, o) => {
+	let s = ({ label: o, className: s, ref: c, invalid: l, id: u, required: d, "aria-describedby": f, "aria-invalid": p, "aria-required": m, ...h }) => {
+		let g = e(t(), {
+			id: u,
+			describedBy: f,
+			invalid: l,
+			required: d,
+			ariaInvalid: p,
+			ariaRequired: m,
+			takeId: a !== "radio"
+		});
+		return /* @__PURE__ */ r("label", {
+			className: i(s),
+			children: [/* @__PURE__ */ n("input", {
+				ref: c,
+				type: a,
+				...h,
+				...g,
+				required: d
+			}), o]
+		});
+	};
+	return s.displayName = o, s;
+};
+//#endregion
+export { i as checkClasses, a as createCheckControl };

package/dist/components/inputs/datePickerLogic.d.ts

@@ -0,0 +1,92 @@
+export type KapiDatePickerMode = "date" | "time" | "datetime";
+export type CalendarCell = {
+    day: number;
+    /** `true` si pertenece al mes anterior/siguiente (relleno de la grilla). */
+    out: boolean;
+    date: Date;
+};
+export declare const MESES: readonly ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"];
+/** Encabezado de la semana: arranca en lunes. */
+export declare const WEEKDAYS: readonly ["L", "M", "X", "J", "V", "S", "D"];
+/** Nombres completos de los días (lunes primero): nombre accesible de encabezados y días. */
+export declare const WEEKDAY_NAMES: readonly ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"];
+/** Textos de los calendarios (`KapiDatePicker`, `KapiDateRangePicker`); se pisan con `labels`. */
+export type KapiCalendarLabels = {
+    /** Botón que abre el calendario. */
+    openPicker: string;
+    prevMonth: string;
+    nextMonth: string;
+    /** Vaciar el valor. */
+    clear: string;
+    today: string;
+    /** 12 nombres, enero primero. */
+    months: ReadonlyArray<string>;
+    /** 7 iniciales, lunes primero. */
+    weekdays: ReadonlyArray<string>;
+    /** 7 nombres completos, lunes primero (nombre accesible de encabezados y días). */
+    weekdayNames: ReadonlyArray<string>;
+};
+export declare const DEFAULT_CALENDAR_LABELS: KapiCalendarLabels;
+/** Nombres del calendario que dependen del locale. */
+export type KapiCalendarNames = Pick<KapiCalendarLabels, "months" | "weekdays" | "weekdayNames">;
+/**
+ * Meses (largo) y días (inicial y largo, lunes primero) de `Intl.DateTimeFormat` para `locale`.
+ * Sin locale, o con uno inválido, devuelve los nombres en castellano (`MESES`, `WEEKDAYS`,
+ * `WEEKDAY_NAMES`, que coinciden con `Intl` en `es`). Cacheado por locale: seguro en render.
+ */
+export declare const calendarNames: (locale?: string) => KapiCalendarNames;
+/**
+ * `DEFAULT_CALENDAR_LABELS` con los nombres de `calendarNames(locale)`; sin locale, los defaults
+ * tal cual. Devuelve el mismo objeto por locale (sirve como `defaults` estable de `useLabels`).
+ */
+export declare const localizedCalendarLabels: (locale?: string) => KapiCalendarLabels;
+/** Título del mes visible: "octubre 2026". */
+export declare const monthTitle: (view: Date, months?: ReadonlyArray<string>) => string;
+export declare const pad: (n: number) => string;
+/**
+ * Minutos de la columna de hora, de a `step` (entero entre 1 y 59; otro valor vuelve a 1). Si el minuto
+ * elegido no cae en la grilla (p. ej. tipeado), se suma en orden para que siga marcado.
+ */
+export declare const minuteOptions: (step?: number, selected?: number | null) => number[];
+export declare const hasCalendar: (mode: KapiDatePickerMode) => boolean;
+export declare const hasTime: (mode: KapiDatePickerMode) => boolean;
+export declare const sameDay: (a: Date | null | undefined, b: Date | null | undefined) => boolean;
+export declare const sameMonth: (a: Date, b: Date) => boolean;
+/**
+ * Nombre accesible de un día de la grilla: "lunes 19 de octubre de 2026". Sale de los `labels`
+ * (meses y días) para que un override de idioma alcance también al lector de pantalla. Con un
+ * `locale` no castellano usa `Intl.DateTimeFormat` ("Monday, October 19, 2026") e ignora `labels`.
+ */
+export declare const calendarDayLabel: (date: Date, labels?: Pick<KapiCalendarLabels, "months" | "weekdayNames">, locale?: string) => string;
+/** Parte la grilla (42 celdas) en semanas de 7, para las filas del `role="grid"`. */
+export declare const calendarRows: <T>(cells: readonly T[]) => T[][];
+/**
+ * Día a enfocar en la grilla tras una tecla (patrón WAI-ARIA date picker dialog):
+ * flechas ±1/±7 días, Home/End inicio (lunes) y fin (domingo) de la semana, PageUp/PageDown ±1 mes
+ * y con Shift ±1 año. Devuelve `undefined` si la tecla no navega. El caller cambia de mes si el
+ * resultado cae fuera del visible.
+ */
+export declare const moveCalendarFocus: (from: Date, e: {
+    key: string;
+    shiftKey?: boolean;
+}) => Date | undefined;
+/** Grilla de 6 semanas (42 celdas) del mes, con semana que arranca en lunes. */
+export declare const buildDays: (year: number, month: number) => CalendarCell[];
+/** `dd/mm/aaaa`, `hh:mm` o `dd/mm/aaaa hh:mm` según el modo. Vacío si no hay fecha. */
+export declare const formatValue: (d: Date | null | undefined, mode: KapiDatePickerMode) => string;
+/**
+ * Valor para formularios nativos, como lo serializan los inputs nativos: `yyyy-mm-dd` (date),
+ * `hh:mm` (time) o `yyyy-mm-ddThh:mm` (datetime-local), en hora local. Vacío si no hay fecha.
+ */
+export declare const formDateValue: (d: Date | null | undefined, mode: KapiDatePickerMode) => string;
+/** Máscara de teclado: se queda con los dígitos y los reparte en `dd/mm/aaaa hh:mm`. */
+export declare const maskInput: (raw: string, mode: KapiDatePickerMode) => string;
+/**
+ * Parsea el texto tipeado.
+ * - `null`: texto vacío (borrar).
+ * - `undefined`: texto inválido (el caller restaura el último valor válido).
+ * - `Date`: valor válido. En "time" parte de `current` (o `now`) y pisa sólo la hora.
+ * Años de 2 dígitos se interpretan como 20xx. Rechaza fechas que desbordan
+ * (31/02) y horas fuera de rango (25:00) en vez de normalizarlas en silencio.
+ */
+export declare const parseText: (str: string, mode: KapiDatePickerMode, current?: Date | null, now?: Date) => Date | null | undefined;