@kapiuara/ui 0.0.0-stage → 0.1.0

package/dist/components/inputs/datePickerLogic.js

@@ -0,0 +1,174 @@
+//#region src/components/inputs/datePickerLogic.ts
+var e = [
+	"enero",
+	"febrero",
+	"marzo",
+	"abril",
+	"mayo",
+	"junio",
+	"julio",
+	"agosto",
+	"septiembre",
+	"octubre",
+	"noviembre",
+	"diciembre"
+], t = [
+	"L",
+	"M",
+	"X",
+	"J",
+	"V",
+	"S",
+	"D"
+], n = [
+	"lunes",
+	"martes",
+	"miércoles",
+	"jueves",
+	"viernes",
+	"sábado",
+	"domingo"
+], r = {
+	openPicker: "Abrir selector",
+	prevMonth: "Mes anterior",
+	nextMonth: "Mes siguiente",
+	clear: "Borrar",
+	today: "Hoy",
+	months: e,
+	weekdays: t,
+	weekdayNames: n
+}, i = {
+	months: e,
+	weekdays: t,
+	weekdayNames: n
+}, a = {
+	calendar: "gregory",
+	numberingSystem: "latn"
+}, o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = (e) => {
+	let t = (t) => new Intl.DateTimeFormat(e, {
+		...t,
+		...a,
+		timeZone: "UTC"
+	}), n = t({ month: "long" }), r = t({ weekday: "narrow" }), i = t({ weekday: "long" }), o = new Intl.Locale(e).language === "es", s = Array.from({ length: 12 }, (t, r) => {
+		let i = n.format(Date.UTC(2024, r, 1));
+		return o ? i.toLocaleLowerCase(e) : i;
+	}), c = Array.from({ length: 7 }, (e, t) => Date.UTC(2024, 0, 1 + t));
+	return {
+		months: s,
+		weekdays: c.map((e) => r.format(e)),
+		weekdayNames: c.map((e) => i.format(e))
+	};
+}, l = (e) => {
+	if (!e) return i;
+	let t = o.get(e);
+	if (!t) {
+		try {
+			t = c(e);
+		} catch {
+			t = i;
+		}
+		o.set(e, t);
+	}
+	return t;
+}, u = (e) => {
+	if (!e) return r;
+	let t = s.get(e);
+	return t || (t = {
+		...r,
+		...l(e)
+	}, s.set(e, t)), t;
+}, d = (t, n = e) => `${n[t.getMonth()] ?? ""} ${t.getFullYear()}`, f = (e) => String(e).padStart(2, "0"), p = (e = 1, t) => {
+	let n = Number.isInteger(e) && e >= 1 && e <= 59 ? e : 1, r = Array.from({ length: Math.ceil(60 / n) }, (e, t) => t * n);
+	return t != null && !r.includes(t) && r.push(t), r.sort((e, t) => e - t);
+}, m = (e) => e === "date" || e === "datetime", h = (e) => e === "time" || e === "datetime", g = (e, t) => !!e && !!t && e.getFullYear() === t.getFullYear() && e.getMonth() === t.getMonth() && e.getDate() === t.getDate(), _ = (e, t) => e.getFullYear() === t.getFullYear() && e.getMonth() === t.getMonth(), v = (e) => (e.getDay() + 6) % 7, y = /* @__PURE__ */ new Map(), b = (e) => {
+	if (y.has(e)) return y.get(e) ?? null;
+	let t = null;
+	try {
+		new Intl.Locale(e).language !== "es" && (t = new Intl.DateTimeFormat(e, {
+			...a,
+			weekday: "long",
+			day: "numeric",
+			month: "long",
+			year: "numeric"
+		}));
+	} catch {
+		t = null;
+	}
+	return y.set(e, t), t;
+}, x = (e, t = r, n) => {
+	let i = n ? b(n) : null;
+	return i ? i.format(e) : `${t.weekdayNames[v(e)] ?? ""} ${e.getDate()} de ${t.months[e.getMonth()] ?? ""} de ${e.getFullYear()}`;
+}, S = (e) => {
+	let t = [];
+	for (let n = 0; n < e.length; n += 7) t.push(e.slice(n, n + 7));
+	return t;
+}, C = (e, t) => {
+	let n = new Date(e.getFullYear(), e.getMonth() + t, 1), r = new Date(n.getFullYear(), n.getMonth() + 1, 0).getDate();
+	return new Date(n.getFullYear(), n.getMonth(), Math.min(e.getDate(), r));
+}, w = (e, t) => new Date(e.getFullYear(), e.getMonth(), e.getDate() + t), T = (e, t) => {
+	switch (t.key) {
+		case "ArrowRight": return w(e, 1);
+		case "ArrowLeft": return w(e, -1);
+		case "ArrowDown": return w(e, 7);
+		case "ArrowUp": return w(e, -7);
+		case "Home": return w(e, -v(e));
+		case "End": return w(e, 6 - v(e));
+		case "PageUp": return C(e, t.shiftKey ? -12 : -1);
+		case "PageDown": return C(e, t.shiftKey ? 12 : 1);
+		default: return;
+	}
+}, E = (e, t) => {
+	let n = (new Date(e, t, 1).getDay() + 6) % 7, r = new Date(e, t + 1, 0).getDate(), i = new Date(e, t, 0).getDate(), a = [];
+	for (let r = n - 1; r >= 0; --r) a.push({
+		day: i - r,
+		out: !0,
+		date: new Date(e, t - 1, i - r)
+	});
+	for (let n = 1; n <= r; n += 1) a.push({
+		day: n,
+		out: !1,
+		date: new Date(e, t, n)
+	});
+	for (let n = 1; a.length < 42; n += 1) a.push({
+		day: n,
+		out: !0,
+		date: new Date(e, t + 1, n)
+	});
+	return a;
+}, D = (e, t) => e ? [m(t) ? `${f(e.getDate())}/${f(e.getMonth() + 1)}/${e.getFullYear()}` : "", h(t) ? `${f(e.getHours())}:${f(e.getMinutes())}` : ""].filter(Boolean).join(" ") : "", O = (e, t) => {
+	if (!e) return "";
+	let n = `${String(e.getFullYear()).padStart(4, "0")}-${f(e.getMonth() + 1)}-${f(e.getDate())}`, r = `${f(e.getHours())}:${f(e.getMinutes())}`;
+	return t === "time" ? r : t === "datetime" ? `${n}T${r}` : n;
+}, k = (e, t) => {
+	let n = (e || "").replace(/\D/g, ""), r;
+	if (m(t)) {
+		let e = n.slice(0, 8);
+		if (r = e.slice(0, 2), e.length > 2 && (r += `/${e.slice(2, 4)}`), e.length > 4 && (r += `/${e.slice(4, 8)}`), h(t)) {
+			let e = n.slice(8, 12);
+			e.length && (r += ` ${e.slice(0, 2)}`), e.length > 2 && (r += `:${e.slice(2, 4)}`);
+		}
+	} else {
+		let e = n.slice(0, 4);
+		r = e.slice(0, 2), e.length > 2 && (r += `:${e.slice(2, 4)}`);
+	}
+	return r;
+}, A = (e, t, n = null, r = /* @__PURE__ */ new Date()) => {
+	let i = (e || "").trim();
+	if (!i) return null;
+	let a = m(t), o = h(t), s = i.match(/(\d{1,2})\/(\d{1,2})\/(\d{2,4})/), c = i.match(/(\d{1,2}):(\d{2})/), l;
+	if (a) {
+		if (!s) return;
+		let e = Number(s[3].length === 2 ? `20${s[3]}` : s[3]), t = Number(s[2]) - 1, n = Number(s[1]);
+		if (l = new Date(e, t, n), Number.isNaN(l.getTime()) || l.getMonth() !== t || l.getDate() !== n) return;
+	} else l = new Date(n ?? r);
+	if (o) {
+		if (c) {
+			let e = Number(c[1]), t = Number(c[2]);
+			if (e > 23 || t > 59) return;
+			l.setHours(e, t);
+		} else if (!a) return;
+	}
+	return l;
+};
+//#endregion
+export { r as DEFAULT_CALENDAR_LABELS, e as MESES, t as WEEKDAYS, n as WEEKDAY_NAMES, E as buildDays, x as calendarDayLabel, l as calendarNames, S as calendarRows, O as formDateValue, D as formatValue, m as hasCalendar, h as hasTime, u as localizedCalendarLabels, k as maskInput, p as minuteOptions, d as monthTitle, T as moveCalendarFocus, f as pad, A as parseText, g as sameDay, _ as sameMonth };

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

@@ -0,0 +1,31 @@
+export type KapiDateRange = {
+    from: Date | null;
+    to: Date | null;
+};
+export declare const EMPTY_RANGE: KapiDateRange;
+/** Separador visible entre las dos fechas. */
+export declare const RANGE_SEPARATOR = " \u2013 ";
+/** Rango con las dos puntas. */
+export declare const isCompleteRange: (range: KapiDateRange) => boolean;
+/** Mismo rango, comparando por día. */
+export declare const sameRange: (a: KapiDateRange, b: KapiDateRange) => boolean;
+/**
+ * Click en un día del calendario: el primero arranca el rango, el segundo lo cierra (ordenando las
+ * puntas). Con un rango ya completo, el click empieza uno nuevo.
+ */
+export declare const pickRangeDay: (range: KapiDateRange, day: Date) => KapiDateRange;
+export type RangeDayState = "start" | "end" | "in" | "single" | null;
+/**
+ * Cómo se pinta un día: extremo inicial/final, intermedio, rango de un día o nada. Con sólo el inicio
+ * elegido, `hover` previsualiza el rango hacia el día bajo el puntero (en cualquier dirección).
+ */
+export declare const rangeDayState: (day: Date, range: KapiDateRange, hover?: Date | null) => RangeDayState;
+/** `dd/mm/aaaa – dd/mm/aaaa`; con sólo el inicio, la primera fecha; vacío sin nada. */
+export declare const formatRange: (range: KapiDateRange) => string;
+/** Máscara de teclado: 16 dígitos repartidos en `dd/mm/aaaa – dd/mm/aaaa`. */
+export declare const maskRangeInput: (raw: string) => string;
+/**
+ * Parsea el texto tipeado. `null`: vacío (borrar). `undefined`: incompleto o inválido (el caller
+ * restaura el último rango válido). Si las fechas vienen invertidas, las ordena.
+ */
+export declare const parseRangeText: (text: string) => KapiDateRange | null | undefined;

package/dist/components/inputs/dateRangeLogic.js

@@ -0,0 +1,44 @@
+import { formatValue as e, maskInput as t, parseText as n, sameDay as r } from "./datePickerLogic.js";
+//#region src/components/inputs/dateRangeLogic.ts
+var i = {
+	from: null,
+	to: null
+}, a = " – ", o = (e) => new Date(e.getFullYear(), e.getMonth(), e.getDate()), s = (e, t) => o(e) <= o(t) ? [e, t] : [t, e], c = (e) => !!e.from && !!e.to, l = (e, t) => (e.from ? r(e.from, t.from) : !t.from) && (e.to ? r(e.to, t.to) : !t.to), u = (e, t) => {
+	let n = o(t);
+	if (!e.from || e.to) return {
+		from: n,
+		to: null
+	};
+	let [r, i] = s(e.from, n);
+	return {
+		from: o(r),
+		to: o(i)
+	};
+}, d = (e, t, n) => {
+	if (!t.from) return null;
+	let i = t.to ?? n ?? null;
+	if (!i) return r(e, t.from) ? "single" : null;
+	let [a, c] = s(t.from, i);
+	if (r(a, c)) return r(e, a) ? "single" : null;
+	if (r(e, a)) return "start";
+	if (r(e, c)) return "end";
+	let l = o(e).getTime();
+	return l > o(a).getTime() && l < o(c).getTime() ? "in" : null;
+}, f = (t) => [e(t.from, "date"), e(t.to, "date")].filter(Boolean).join(a), p = (e) => {
+	let n = (e || "").replace(/\D/g, "").slice(0, 16), r = t(n.slice(0, 8), "date"), i = t(n.slice(8), "date");
+	return i ? `${r}${a}${i}` : r;
+}, m = (e) => {
+	let t = (e || "").trim();
+	if (!t) return null;
+	let r = t.split(/\s*[–-]\s*/);
+	if (r.length !== 2) return;
+	let i = n(r[0], "date"), a = n(r[1], "date");
+	if (!i || !a) return;
+	let [o, c] = s(i, a);
+	return {
+		from: o,
+		to: c
+	};
+};
+//#endregion
+export { i as EMPTY_RANGE, a as RANGE_SEPARATOR, f as formatRange, c as isCompleteRange, p as maskRangeInput, m as parseRangeText, u as pickRangeDay, d as rangeDayState, l as sameRange };

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

@@ -0,0 +1,69 @@
+/**
+ * `list` abre sus opciones; `date` pide una fecha; `dateRange` pide un rango (desde/hasta) en un solo
+ * calendario; `flag` se aplica directo.
+ */
+export type KapiFacetKind = "list" | "date" | "dateRange" | "flag";
+export type KapiFacetOption = {
+    value: string;
+    label: string;
+    /** Cuántos resultados tiene la opción; se muestra a la derecha y se lee ("Pendiente, 4"). */
+    count?: number | undefined;
+};
+export type KapiFacet = {
+    key: string;
+    label: string;
+    kind: KapiFacetKind;
+    /** Opciones de una faceta `list`. */
+    options?: ReadonlyArray<KapiFacetOption> | undefined;
+    /**
+     * Recibe el valor elegido: el `value` de la opción, la fecha como `yyyy-mm-dd`, el rango como
+     * `yyyy-mm-dd/yyyy-mm-dd` (ver `parseDateRangeValue`) o `"true"` (flag).
+     */
+    apply: (value: string) => void;
+};
+/** Filtro activo que la barra muestra como chip removible. */
+export type KapiFacetChip = {
+    key: string;
+    label: string;
+    onRemove: () => void;
+};
+export type KapiFacetMenuItem = {
+    type: "text";
+    text: string;
+} | {
+    type: "facet";
+    facet: KapiFacet;
+} | {
+    type: "option";
+    option: KapiFacetOption;
+};
+/**
+ * Ítems del desplegable. Sin faceta pendiente: "buscar el texto" (si hay) y las facetas que coinciden.
+ * Con una faceta `list` pendiente: sus opciones que coinciden. Con una `date` o `dateRange`: nada (decide
+ * el calendario).
+ */
+export declare function facetMenuItems(facets: ReadonlyArray<KapiFacet>, pending: KapiFacet | null, input: string): KapiFacetMenuItem[];
+/** Mueve el ítem activo con vuelta; desde `-1` entra por el extremo según la dirección. */
+export declare const moveActive: (index: number, count: number, delta: 1 | -1) => number;
+export type KapiFacetKeyAction = "next" | "prev" | "select" | "text" | "cancel" | "close" | "dropPending" | "removeLast";
+/** Qué hace una tecla en el input de la barra. `null` = dejar que el input la maneje. */
+export declare function facetKeyAction(key: string, s: {
+    input: string;
+    pending: boolean;
+    active: number;
+    open: boolean;
+    chips: number;
+}): KapiFacetKeyAction | null;
+/** Fecha local como `yyyy-mm-dd` (el valor que recibe el `apply` de una faceta `date`). */
+export declare const toDateValue: (d: Date) => string;
+/** Rango local como `yyyy-mm-dd/yyyy-mm-dd` (intervalo ISO 8601: el valor que recibe una faceta `dateRange`). */
+export declare const toDateRangeValue: (from: Date, to: Date) => string;
+/** Separa el valor de una faceta `dateRange` en `{ from, to }` (`yyyy-mm-dd`); `null` si no tiene esa forma. */
+export declare const parseDateRangeValue: (value: string) => {
+    from: string;
+    to: string;
+} | null;
+/** Nombre accesible de una opción: con `count`, "Pendiente, 4". */
+export declare const facetOptionName: (option: KapiFacetOption) => string;
+/** ¿El valor de la faceta se elige en un calendario (fecha o rango) en vez del desplegable? */
+export declare const isDateFacet: (facet: KapiFacet | null) => boolean;

package/dist/components/inputs/facetedSearchLogic.js

@@ -0,0 +1,39 @@
+import { normalizeFilterText as e } from "../data/tableLogic.js";
+//#region src/components/inputs/facetedSearchLogic.ts
+var t = (t, n) => !n || e(t).includes(n);
+function n(n, r, i) {
+	let a = e(i);
+	if (r) return r.kind === "list" ? (r.options ?? []).filter((e) => t(e.label, a)).map((e) => ({
+		type: "option",
+		option: e
+	})) : [];
+	let o = i.trim(), s = o ? [{
+		type: "text",
+		text: o
+	}] : [];
+	for (let e of n) t(e.label, a) && s.push({
+		type: "facet",
+		facet: e
+	});
+	return s;
+}
+var r = (e, t, n) => t === 0 ? -1 : e < 0 ? n > 0 ? 0 : t - 1 : (e + n + t) % t;
+function i(e, t) {
+	switch (e) {
+		case "ArrowDown": return "next";
+		case "ArrowUp": return "prev";
+		case "Enter": return t.open && t.active >= 0 ? "select" : !t.pending && t.input.trim() ? "text" : null;
+		case "Escape": return t.pending ? "cancel" : t.open ? "close" : null;
+		case "Backspace": return t.input === "" ? t.pending ? "dropPending" : t.chips > 0 ? "removeLast" : null : null;
+		default: return null;
+	}
+}
+var a = (e) => `${e.getFullYear()}-${String(e.getMonth() + 1).padStart(2, "0")}-${String(e.getDate()).padStart(2, "0")}`, o = (e, t) => `${a(e)}/${a(t)}`, s = (e) => {
+	let t = /^(\d{4}-\d{2}-\d{2})\/(\d{4}-\d{2}-\d{2})$/.exec(e);
+	return t ? {
+		from: t[1],
+		to: t[2]
+	} : null;
+}, c = (e) => e.count === void 0 ? e.label : `${e.label}, ${e.count}`, l = (e) => e?.kind === "date" || e?.kind === "dateRange";
+//#endregion
+export { i as facetKeyAction, n as facetMenuItems, c as facetOptionName, l as isDateFacet, r as moveActive, s as parseDateRangeValue, o as toDateRangeValue, a as toDateValue };

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

@@ -0,0 +1,67 @@
+import type { AriaAttributes, Ref } from "react";
+/** Lo que un `KapiField` le pasa al control que tiene adentro. */
+export type KapiFieldContextValue = {
+    controlId: string;
+    labelId?: string | undefined;
+    helpId?: string | undefined;
+    required: boolean;
+    invalid: boolean;
+};
+/** Suma ids para `aria-describedby`/`aria-labelledby`: sin vacíos ni repetidos; `undefined` si no queda ninguno. */
+export declare const joinIds: (...ids: (string | undefined | null | false)[]) => string | undefined;
+/** Ids del campo: el del control (`htmlFor` o automático), el del label y el de la ayuda. */
+export declare const fieldIds: ({ htmlFor, autoId, helpId, hasHelp }: {
+    htmlFor?: string | undefined;
+    autoId: string;
+    helpId?: string | undefined;
+    hasHelp: boolean;
+}) => {
+    controlId: string;
+    labelId: string;
+    helpId?: string;
+};
+/**
+ * Atributos de accesibilidad del control: lo propio gana; la descripción del campo se suma a la propia.
+ * Un control que no es un elemento etiquetable (`labelable: false`, p. ej. un `div` combobox) se nombra
+ * con `aria-labelledby`, porque el `for` del label no le llega; salvo que ya tenga `aria-label`.
+ */
+export declare const fieldControlProps: (ctx: KapiFieldContextValue | null, own: {
+    id?: string | undefined;
+    describedBy?: string | undefined;
+    invalid?: boolean | undefined;
+    required?: boolean | undefined;
+    labelable?: boolean | undefined;
+    ariaLabel?: string | undefined;
+}) => {
+    id: string | undefined;
+    "aria-describedby": string | undefined;
+    "aria-invalid": true | undefined;
+    "aria-required": true | undefined;
+    "aria-labelledby": string | undefined;
+};
+/**
+ * Atributos de campo de un control nativo (checkbox, switch, radio, range): los `aria-*` propios ganan,
+ * después `invalid`/`required` y por último el `KapiField`. Con `takeId: false` no toma el id del campo:
+ * los radios de un grupo comparten el campo y no pueden repetir id (se nombran con su propio texto).
+ */
+export declare const nativeFieldProps: (ctx: KapiFieldContextValue | null, own: {
+    id?: string | undefined;
+    describedBy?: string | undefined;
+    invalid?: boolean | undefined;
+    required?: boolean | undefined;
+    ariaInvalid?: AriaAttributes["aria-invalid"] | undefined;
+    ariaRequired?: AriaAttributes["aria-required"] | undefined;
+    takeId?: boolean | undefined;
+}) => {
+    id: string | undefined;
+    "aria-describedby": string | undefined;
+    "aria-invalid": boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+    "aria-required": (boolean | "true" | "false") | undefined;
+};
+/**
+ * ¿El foco sale del control? `next` es el `relatedTarget` del blur; `containers` son las partes del
+ * control (raíz, menú portaleado…). Sin destino (foco al `body`) cuenta como salida.
+ */
+export declare const focusLeaves: (next: EventTarget | null, ...containers: (Node | null | undefined)[]) => boolean;
+/** Asigna un nodo a una ref (función u objeto); sirve para combinar la ref propia con la del usuario. */
+export declare const assignRef: <T>(ref: Ref<T> | undefined, node: T | null) => void;

package/dist/components/inputs/fieldLogic.js

@@ -0,0 +1,35 @@
+//#region src/components/inputs/fieldLogic.ts
+var e = (...e) => {
+	let t = [...new Set(e.flatMap((e) => e ? e.split(/\s+/).filter(Boolean) : []))];
+	return t.length ? t.join(" ") : void 0;
+}, t = ({ htmlFor: e, autoId: t, helpId: n, hasHelp: r }) => {
+	let i = e ?? t;
+	return {
+		controlId: i,
+		labelId: `${i}-label`,
+		...r ? { helpId: n ?? `${i}-help` } : {}
+	};
+}, n = (t, n) => ({
+	id: n.id ?? t?.controlId,
+	"aria-describedby": e(t?.helpId, n.describedBy),
+	"aria-invalid": n.invalid ?? t?.invalid ? !0 : void 0,
+	"aria-required": n.required ?? t?.required ? !0 : void 0,
+	"aria-labelledby": n.labelable === !1 && !n.ariaLabel ? t?.labelId : void 0
+}), r = (e, t) => {
+	let r = n(e, {
+		id: t.id,
+		describedBy: t.describedBy,
+		invalid: t.invalid,
+		required: t.required
+	});
+	return {
+		id: t.takeId === !1 ? t.id : r.id,
+		"aria-describedby": r["aria-describedby"],
+		"aria-invalid": t.ariaInvalid ?? r["aria-invalid"],
+		"aria-required": t.ariaRequired ?? r["aria-required"]
+	};
+}, i = (e, ...t) => !(e instanceof Node && t.some((t) => t?.contains(e))), a = (e, t) => {
+	typeof e == "function" ? e(t) : e && (e.current = t);
+};
+//#endregion
+export { a as assignRef, n as fieldControlProps, t as fieldIds, i as focusLeaves, e as joinIds, r as nativeFieldProps };

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

@@ -0,0 +1,13 @@
+/** Tamaño legible en KB (como el original: sin decimales). */
+export declare const formatFileSize: (bytes: number) => string;
+/** ¿El archivo cumple el atributo `accept` (`.pdf,image/*,text/plain`)? Sin `accept` todo pasa. */
+export declare const matchesAccept: (file: {
+    name: string;
+    type: string;
+}, accept?: string) => boolean;
+/** Arma la nueva lista: en `multiple` agrega al final; si no, queda sólo el primero. */
+export declare const mergeFiles: (current: File[], incoming: File[], multiple: boolean) => File[];
+/** Quita el archivo en la posición `index` (sin mutar). */
+export declare const removeFileAt: (files: File[], index: number) => File[];
+/** Teclas que activan la dropzone (rol button): Enter y Espacio. */
+export declare const isActivationKey: (key: string) => boolean;

package/dist/components/inputs/fileUploadLogic.js

@@ -0,0 +1,9 @@
+//#region src/components/inputs/fileUploadLogic.ts
+var e = (e) => `${e > 0 ? Math.max(1, Math.round(e / 1024)) : 0} KB`, t = (e, t) => {
+	let n = (t ?? "").split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+	if (n.length === 0) return !0;
+	let r = e.name.toLowerCase(), i = e.type.toLowerCase();
+	return n.some((e) => e.startsWith(".") ? r.endsWith(e) : e.endsWith("/*") ? i.startsWith(e.slice(0, -1)) : i === e);
+}, n = (e, t, n) => n ? [...e, ...t] : t.slice(0, 1), r = (e, t) => e.filter((e, n) => n !== t), i = (e) => e === "Enter" || e === " " || e === "Spacebar";
+//#endregion
+export { e as formatFileSize, i as isActivationKey, t as matchesAccept, n as mergeFiles, r as removeFileAt };

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

@@ -0,0 +1,55 @@
+export { KapiButton, buttonClasses } from "./KapiButton";
+export type { KapiButtonProps, KapiButtonSize, KapiButtonVariant } from "./KapiButton";
+export { KapiIconButton, iconButtonClasses } from "./KapiIconButton";
+export type { KapiIconButtonProps } from "./KapiIconButton";
+export { KapiInput, inputClasses, DEFAULT_INPUT_LABELS } from "./KapiInput";
+export type { KapiInputLabels, KapiInputProps, KapiInputSize, KapiTextareaProps } from "./KapiInput";
+export { hasAdornments, inputBoxClasses } from "./inputLogic";
+export { KapiInputGroup, useKapiInputGroup } from "./KapiInputGroup";
+export type { KapiInputGroupProps, KapiInputGroupAddonProps, KapiInputGroupSize } from "./KapiInputGroup";
+export { inputGroupClasses, inputGroupAddonClasses } from "./inputGroupLogic";
+export { KapiField, fieldClasses, helpClasses, useKapiField } from "./KapiField";
+export type { KapiFieldContextValue, KapiFieldProps, KapiFieldStatus } from "./KapiField";
+export { fieldControlProps } from "./fieldLogic";
+export { KapiCheckbox } from "./KapiCheckbox";
+export type { KapiCheckboxProps } from "./KapiCheckbox";
+export { KapiRadio } from "./KapiRadio";
+export type { KapiRadioProps } from "./KapiRadio";
+export { KapiSwitch } from "./KapiSwitch";
+export type { KapiSwitchProps } from "./KapiSwitch";
+export { KapiCheckCard, checkCardClasses } from "./KapiCheckCard";
+export type { KapiCheckCardProps } from "./KapiCheckCard";
+export { KapiSelect, selectClasses, DEFAULT_SELECT_LABELS } from "./KapiSelect";
+export type { KapiSelectLabels } from "./KapiSelect";
+export type { KapiSelectProps, KapiSelectBaseProps, KapiSelectSingleProps, KapiSelectMultiProps, KapiSelectSize, KapiSelectOption, KapiSelectGroup, KapiSelectEntry } from "./KapiSelect";
+export { KapiCalendar } from "./KapiCalendar";
+export { KapiDatePicker } from "./KapiDatePicker";
+export { DEFAULT_CALENDAR_LABELS, calendarNames, localizedCalendarLabels, monthTitle } from "./datePickerLogic";
+export type { KapiCalendarLabels, KapiCalendarNames } from "./datePickerLogic";
+export type { KapiCalendarProps } from "./KapiCalendar";
+export type { KapiDatePickerProps, KapiDatePickerMode } from "./KapiDatePicker";
+export { KapiDateRangePicker, DEFAULT_DATE_RANGE_LABELS } from "./KapiDateRangePicker";
+export type { KapiDateRange, KapiDateRangePickerProps, KapiDateRangePickerLabels } from "./KapiDateRangePicker";
+export { KapiDniInput, KapiCuitInput, KapiCurrencyInput, DEFAULT_CUIT_INPUT_LABELS } from "./KapiMaskedInput";
+export type { KapiDniInputProps, KapiCuitInputLabels, KapiCuitInputProps, KapiCurrencyInputProps } from "./KapiMaskedInput";
+export { cuitCheckDigit, formatCuit, formatCurrency, formatDni, isValidCuit, parseCurrency } from "./maskLogic";
+export { KapiFileUpload, DEFAULT_FILE_UPLOAD_LABELS } from "./KapiFileUpload";
+export type { KapiFileUploadProps, KapiFileUploadLabels } from "./KapiFileUpload";
+export { KapiSegmented } from "./KapiSegmented";
+export type { KapiSegmentedColor, KapiSegmentedItem, KapiSegmentedProps, KapiSegmentedVariant } from "./KapiSegmented";
+export { KapiTextarea, textareaClasses } from "./KapiTextarea";
+export type { KapiTextareaFieldProps } from "./KapiTextarea";
+export { KapiSlider, sliderClasses } from "./KapiSlider";
+export type { KapiSliderProps, KapiSliderTone } from "./KapiSlider";
+export { KapiNumberStepper, stepperClasses, DEFAULT_NUMBER_STEPPER_LABELS } from "./KapiNumberStepper";
+export type { KapiNumberStepperProps, KapiNumberStepperLabels } from "./KapiNumberStepper";
+export { KapiTagInput, tagInputClasses, DEFAULT_TAG_INPUT_LABELS } from "./KapiTagInput";
+export type { KapiTagInputProps, KapiTagInputLabels, KapiTagInputSize } from "./KapiTagInput";
+export { KapiRating, DEFAULT_RATING_LABELS, ratingClasses } from "./KapiRating";
+export type { KapiRatingLabels, KapiRatingProps, KapiRatingSize } from "./KapiRating";
+export { KapiAutocomplete, DEFAULT_AUTOCOMPLETE_LABELS } from "./KapiAutocomplete";
+export type { KapiAutocompleteLabels, KapiAutocompleteProps, KapiAutocompleteRenderContext } from "./KapiAutocomplete";
+export { KapiFacetedSearch, DEFAULT_FACETED_SEARCH_LABELS } from "./KapiFacetedSearch";
+export type { KapiFacetedSearchLabels, KapiFacetedSearchProps } from "./KapiFacetedSearch";
+export { facetKeyAction, facetMenuItems, parseDateRangeValue, toDateRangeValue, toDateValue } from "./facetedSearchLogic";
+export type { KapiFacet, KapiFacetChip, KapiFacetKind, KapiFacetOption, KapiFacetKeyAction, KapiFacetMenuItem } from "./facetedSearchLogic";

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

@@ -0,0 +1,22 @@
+import type { KapiFieldStatus } from "./KapiField";
+export type KapiInputGroupSize = "sm" | "md" | "lg";
+/** Clases del grupo: el borde, el radio y el anillo de foco son suyos; los segmentos van sin borde. */
+export declare const inputGroupClasses: ({ size, status, className }?: {
+    size?: KapiInputGroupSize | undefined;
+    status?: KapiFieldStatus | undefined;
+    className?: string | undefined;
+}) => string;
+/** Clases del segmento estático (texto o ícono: "https://", "$", una lupa). */
+export declare const inputGroupAddonClasses: (className?: string) => string;
+/** Tamaño de un control dentro de un grupo: el propio gana; si no, el del grupo; fuera de un grupo, nada. */
+export declare const resolveGroupSize: <S extends string>(own: S | undefined, group: S | undefined) => S | undefined;
+/**
+ * Id del `KapiSelect`. Dentro de un grupo envuelto en un `KapiField` la etiqueta apunta al input
+ * de texto, así que el select no reclama el id del field (evita ids duplicados) y usa el suyo.
+ */
+export declare const selectControlId: ({ id, fieldControlId, autoId, inGroup }: {
+    id?: string | undefined;
+    fieldControlId?: string | undefined;
+    autoId: string;
+    inGroup: boolean;
+}) => string;

package/dist/components/inputs/inputGroupLogic.js

@@ -0,0 +1,9 @@
+//#region src/components/inputs/inputGroupLogic.ts
+var e = ({ size: e = "md", status: t, className: n = "" } = {}) => [
+	"kapi-inputgroup",
+	e !== "md" && `kapi-inputgroup--${e}`,
+	t && `kapi-inputgroup--${t}`,
+	n
+].filter(Boolean).join(" "), t = (e = "") => ["kapi-inputgroup__addon", e].filter(Boolean).join(" "), n = (e, t) => e ?? t, r = ({ id: e, fieldControlId: t, autoId: n, inGroup: r }) => e ?? (r ? void 0 : t) ?? n;
+//#endregion
+export { t as inputGroupAddonClasses, e as inputGroupClasses, n as resolveGroupSize, r as selectControlId };

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

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+import type { KapiFieldStatus } from "./KapiField";
+export type KapiInputBoxSize = "sm" | "md" | "lg";
+/** Adornos que obligan a envolver el input en una caja (`.kapi-inputbox`). */
+export type KapiInputAdornments = {
+    startIcon?: ReactNode | undefined;
+    endIcon?: ReactNode | undefined;
+    prefix?: ReactNode | undefined;
+    suffix?: ReactNode | undefined;
+    clearable?: boolean | undefined;
+    shortcut?: string | undefined;
+};
+/** ¿El adorno se dibuja? `null`, `undefined`, booleanos y `""` no (React no los pinta). */
+export declare const present: (node: ReactNode) => boolean;
+/** ¿Hay algún adorno? Sin adornos el input se renderiza igual que siempre (sin envoltorio). */
+export declare const hasAdornments: ({ startIcon, endIcon, prefix, suffix, clearable, shortcut }: KapiInputAdornments) => boolean;
+/** ¿El valor tiene algo? Decide si se muestra el botón de limpiar. */
+export declare const hasValue: (value: unknown) => boolean;
+/** Clases de la caja que envuelve input + adornos: es la que lleva borde, fondo y anillo de foco. */
+export declare const inputBoxClasses: ({ size, status, disabled, className }?: {
+    size?: KapiInputBoxSize | undefined;
+    status?: KapiFieldStatus | undefined;
+    disabled?: boolean | undefined;
+    className?: string | undefined;
+}) => string;

package/dist/components/inputs/inputLogic.js

@@ -0,0 +1,10 @@
+//#region src/components/inputs/inputLogic.ts
+var e = (e) => e != null && typeof e != "boolean" && e !== "", t = ({ startIcon: t, endIcon: n, prefix: r, suffix: i, clearable: a, shortcut: o }) => e(t) || e(n) || e(r) || e(i) || !!a || !!o, n = (e) => e == null ? !1 : Array.isArray(e) ? e.length > 0 : String(e) !== "", r = ({ size: e = "md", status: t, disabled: n = !1, className: r = "" } = {}) => [
+	"kapi-inputbox",
+	e !== "md" && `kapi-inputbox--${e}`,
+	t && `kapi-inputbox--${t}`,
+	n && "is-disabled",
+	r
+].filter(Boolean).join(" ");
+//#endregion
+export { t as hasAdornments, n as hasValue, r as inputBoxClasses, e as present };

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

@@ -0,0 +1,34 @@
+export declare const DNI_MAX_DIGITS = 8;
+export declare const CUIT_DIGITS = 11;
+/** Tope de dígitos enteros en moneda (dentro de `Number.MAX_SAFE_INTEGER` con centavos). */
+export declare const CURRENCY_MAX_INT_DIGITS = 13;
+export declare const CURRENCY_PREFIX = "$ ";
+/** Sólo los dígitos, cortados en `max`. */
+export declare const onlyDigits: (raw: string, max?: number) => string;
+/** DNI: `12.345.678` (7 dígitos: `1.234.567`). Agrupa mientras se tipea. */
+export declare const formatDni: (raw: string) => string;
+/** CUIT/CUIL: `20-12345678-9`. Agrega los guiones mientras se tipea. */
+export declare const formatCuit: (raw: string) => string;
+/**
+ * Dígito verificador de CUIT/CUIL (módulo 11) para los 10 primeros dígitos.
+ * `null` si no hay 10 dígitos o si el resto da 10 (no existe dígito válido).
+ */
+export declare const cuitCheckDigit: (first10: string) => number | null;
+/** CUIT/CUIL completo (11 dígitos, con o sin guiones) y con el dígito verificador correcto. */
+export declare const isValidCuit: (raw: string) => boolean;
+/**
+ * Máscara de moneda mientras se tipea: `$ 1.234,5`. Coma decimal (como mucho 2 decimales), puntos de
+ * miles automáticos, sin ceros a la izquierda. Sin dígitos ni coma → vacío.
+ */
+export declare const maskCurrencyInput: (raw: string) => string;
+/** Lee un importe es-AR (`$ 1.234,56`). Sin dígitos → `null`. */
+export declare const parseCurrency: (text: string) => number | null;
+/** Importe es-AR con dos decimales: `$ 1.234,56`. Redondea a centavos. Sin valor → vacío. */
+export declare const formatCurrency: (value: number | null | undefined) => string;
+/** Cuántos caracteres significativos (dígitos y coma) hay antes del cursor. */
+export declare const countSignificant: (text: string, caret: number) => number;
+/**
+ * Posición del cursor en el texto formateado: justo después del n-ésimo significativo. Con `n = 0`,
+ * antes del primero (después del prefijo); si no alcanzan, al final.
+ */
+export declare const caretForSignificant: (formatted: string, n: number) => number;