@kapiuara/ui 0.0.0-stage → 0.1.0

package/dist/components/inputs/maskLogic.js

@@ -0,0 +1,57 @@
+var e = [
+	5,
+	4,
+	3,
+	2,
+	7,
+	6,
+	5,
+	4,
+	3,
+	2
+], t = (e, t = Infinity) => (e || "").replace(/\D/g, "").slice(0, t), n = (e) => e.replace(/\B(?=(\d{3})+(?!\d))/g, "."), r = (e) => n(t(e, 8)), i = (e) => {
+	let n = t(e, 11);
+	return [
+		n.slice(0, 2),
+		n.slice(2, 10),
+		n.slice(10)
+	].filter(Boolean).join("-");
+}, a = (n) => {
+	let r = t(n);
+	if (r.length !== 10) return null;
+	let i = 11 - e.reduce((e, t, n) => e + t * Number(r[n]), 0) % 11;
+	return i === 11 ? 0 : i === 10 ? null : i;
+}, o = (e) => {
+	let n = t(e);
+	if (n.length !== 11) return !1;
+	let r = a(n.slice(0, 10));
+	return r !== null && r === Number(n[10]);
+}, s = (e) => {
+	let t = "", n = "", r = !1;
+	for (let i of e || "") i === "," ? r = !0 : i >= "0" && i <= "9" && (r ? n += i : t += i);
+	return {
+		int: t,
+		dec: n,
+		comma: r
+	};
+}, c = (e) => {
+	let { int: t, dec: r, comma: i } = s(e);
+	return !t && !i ? "" : `\$ ${n((t.replace(/^0+(?=\d)/, "") || "0").slice(0, 13))}${i ? `,${r.slice(0, 2)}` : ""}`;
+}, l = (e) => {
+	let { int: t, dec: n } = s(e);
+	return !t && !n ? null : Number(`${t.slice(0, 13) || "0"}.${n.slice(0, 2) || "0"}`);
+}, u = (e) => {
+	if (e == null || !Number.isFinite(e)) return "";
+	let t = Math.abs(e), r = Number(`${t}e2`), i = Math.round(Number.isFinite(r) ? r : t * 100), a = String(Math.floor(i / 100)), o = String(i % 100).padStart(2, "0");
+	return `${e < 0 && i > 0 ? "-" : ""}\$ ${n(a)},${o}`;
+}, d = (e) => e === "," || e >= "0" && e <= "9", f = (e, t) => [...e.slice(0, Math.max(0, t))].filter(d).length, p = (e, t) => {
+	if (t <= 0) {
+		let t = [...e].findIndex(d);
+		return t === -1 ? e.length : t;
+	}
+	let n = 0;
+	for (let r = 0; r < e.length; r += 1) if (d(e[r]) && (n += 1, n === t)) return r + 1;
+	return e.length;
+};
+//#endregion
+export { p as caretForSignificant, f as countSignificant, a as cuitCheckDigit, i as formatCuit, u as formatCurrency, r as formatDni, o as isValidCuit, c as maskCurrencyInput, t as onlyDigits, l as parseCurrency };

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

@@ -0,0 +1,14 @@
+export type StepBounds = {
+    min?: number | undefined;
+    max?: number | undefined;
+    step?: number | undefined;
+};
+/** Clamp to optional bounds. */
+export declare const clampNumber: (value: number, { min, max }?: StepBounds) => number;
+/**
+ * Move `value` by `delta` steps (-1 / +1, or any multiple) and clamp to bounds.
+ * Rounds to the step's precision so 0.1 + 0.2 style noise never reaches the UI.
+ */
+export declare const stepValue: (value: number, delta: number, { min, max, step }?: StepBounds) => number;
+export declare const canDecrement: (value: number, { min }?: StepBounds) => boolean;
+export declare const canIncrement: (value: number, { max }?: StepBounds) => boolean;

package/dist/components/inputs/numberStepLogic.js

@@ -0,0 +1,21 @@
+//#region src/components/inputs/numberStepLogic.ts
+var e = (e) => {
+	let t = String(e), n = /e-(\d+)$/i.exec(t);
+	if (n) {
+		let e = t.slice(0, n.index), r = e.indexOf(".");
+		return (r === -1 ? 0 : e.length - r - 1) + Number(n[1]);
+	}
+	let r = t.indexOf(".");
+	return r === -1 ? 0 : t.length - r - 1;
+}, t = (e, { min: t, max: n } = {}) => {
+	let r = e;
+	return t !== void 0 && r < t && (r = t), n !== void 0 && r > n && (r = n), r;
+}, n = (n, r, { min: i, max: a, step: o = 1 } = {}) => {
+	let s = Number.isFinite(n) ? n : i ?? 0, c = s + r * o, l = Math.max(e(o), e(s));
+	return t(Number(c.toFixed(l)), {
+		min: i,
+		max: a
+	});
+}, r = (e, { min: t } = {}) => t === void 0 || e > t, i = (e, { max: t } = {}) => t === void 0 || e < t;
+//#endregion
+export { r as canDecrement, i as canIncrement, t as clampNumber, n as stepValue };

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

@@ -0,0 +1,9 @@
+export type StarFill = "full" | "half" | "empty";
+/** Snap a rating to 1 (or 0.5 with `allowHalf`) and clamp to 0..max. */
+export declare const normalizeRating: (value: number, max: number, allowHalf?: boolean) => number;
+/** Fill state of each of the `max` stars for a given value. */
+export declare const starFills: (value: number, max: number, allowHalf?: boolean) => StarFill[];
+/** Rating for a pointer at `ratio` (0..1) across star `index`; left half = half star when allowed. */
+export declare const ratingFromPointer: (index: number, ratio: number, allowHalf?: boolean) => number;
+/** Keyboard handling: returns the next value, or null when the key is not handled. */
+export declare const ratingFromKey: (key: string, value: number, max: number, allowHalf?: boolean) => number | null;

package/dist/components/inputs/ratingLogic.js

@@ -0,0 +1,22 @@
+//#region src/components/inputs/ratingLogic.ts
+var e = (e, t, n = !1) => {
+	if (!Number.isFinite(e)) return 0;
+	let r = n ? .5 : 1, i = Math.round(e / r) * r;
+	return Math.min(t, Math.max(0, i));
+}, t = (t, n, r = !1) => {
+	let i = e(t, n, r);
+	return Array.from({ length: n }, (e, t) => i >= t + 1 ? "full" : r && i >= t + .5 ? "half" : "empty");
+}, n = (e, t, n = !1) => n && t < .5 ? e + .5 : e + 1, r = (t, n, r, i = !1) => {
+	let a = i ? .5 : 1;
+	switch (t) {
+		case "ArrowRight":
+		case "ArrowUp": return e(n + a, r, i);
+		case "ArrowLeft":
+		case "ArrowDown": return e(n - a, r, i);
+		case "Home": return 0;
+		case "End": return r;
+		default: return null;
+	}
+};
+//#endregion
+export { e as normalizeRating, r as ratingFromKey, n as ratingFromPointer, t as starFills };

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

@@ -0,0 +1,6 @@
+/**
+ * Índice del radio a marcar/enfocar tras una tecla (patrón WAI-ARIA radio group, con vuelta).
+ * Derecha/Abajo avanzan, Izquierda/Arriba retroceden, Home/End van a los extremos.
+ * `current` puede ser -1 (ninguno marcado). Devuelve `undefined` si la tecla no navega.
+ */
+export declare const nextRadioIndex: (count: number, current: number, key: string) => number | undefined;

package/dist/components/inputs/segmentedLogic.js

@@ -0,0 +1,14 @@
+//#region src/components/inputs/segmentedLogic.ts
+var e = (e, t, n) => {
+	if (e !== 0) switch (n) {
+		case "ArrowRight":
+		case "ArrowDown": return (t + 1) % e;
+		case "ArrowLeft":
+		case "ArrowUp": return (t <= 0 ? e : t) - 1;
+		case "Home": return 0;
+		case "End": return e - 1;
+		default: return;
+	}
+};
+//#endregion
+export { e as nextRadioIndex };

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

@@ -0,0 +1,89 @@
+export type KapiSelectOption<T = unknown> = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    data?: T;
+};
+export type KapiSelectGroup<T = unknown> = {
+    label: string;
+    options: KapiSelectOption<T>[];
+};
+export type KapiSelectEntry<T = unknown> = KapiSelectOption<T> | KapiSelectGroup<T>;
+/** Valor público del select: `string` (simple), `string[]` (múltiple) o `null` (vacío). */
+export type KapiSelectValue = string | string[] | null;
+export declare const isGroup: <T>(entry: KapiSelectEntry<T>) => entry is KapiSelectGroup<T>;
+/** Minúsculas + sin diacríticos: "jose" matchea "José". */
+export declare const normalizeText: (text: string) => string;
+/** Aplana grupos en una lista de opciones (orden visual = orden de navegación por teclado). */
+export declare const flattenOptions: <T>(entries: readonly KapiSelectEntry<T>[]) => KapiSelectOption<T>[];
+/**
+ * Filtra por label (sin distinguir mayúsculas ni acentos). Los grupos conservan solo las opciones que
+ * matchean y se descartan si quedan vacíos. Query vacía = sin filtro.
+ */
+export declare const filterOptions: <T>(entries: readonly KapiSelectEntry<T>[], query: string) => KapiSelectEntry<T>[];
+export type ActiveDirection = "next" | "prev" | "first" | "last";
+type Navigable = {
+    disabled?: boolean;
+};
+/**
+ * Próximo índice activo saltando deshabilitadas, con wrap. `first`/`last` = Home/End.
+ * Devuelve -1 si no hay ninguna opción habilitada.
+ */
+export declare const nextActiveIndex: (current: number, dir: ActiveDirection, items: readonly Navigable[]) => number;
+/** Normaliza el valor al modo del select: múltiple → `string[]`, simple → `string | null`. */
+export declare const normalizeValue: (value: KapiSelectValue | undefined, multiple: boolean) => KapiSelectValue;
+/** Valor resultante de elegir una opción: simple → la opción; múltiple → la agrega o la quita. */
+export declare const toggleValue: (value: KapiSelectValue | undefined, optionValue: string, multiple: boolean) => KapiSelectValue;
+/** Opciones seleccionadas, en el orden del valor (así los chips respetan el orden de selección). */
+export declare const selectedOptions: <T>(entries: readonly KapiSelectEntry<T>[], value: KapiSelectValue | undefined) => KapiSelectOption<T>[];
+/** Texto del valor para lectores de pantalla / vista simple: labels unidos o el placeholder. */
+export declare const displayLabel: (selected: readonly {
+    label: string;
+}[], placeholder: string) => string;
+/** Índice activo al abrir el menú: la primera seleccionada habilitada, o el borde pedido. */
+export declare const initialActiveIndex: (items: readonly KapiSelectOption<unknown>[], selectedValues: readonly string[], edge?: "selected" | "first" | "last") => number;
+/**
+ * Typeahead (select sin búsqueda): índice de la próxima opción cuyo label empieza con el buffer.
+ * Con un solo carácter cicla desde la siguiente a `from`; con más, extiende el prefijo desde la actual.
+ */
+export declare const findTypeaheadIndex: (items: readonly KapiSelectOption<unknown>[], buffer: string, from: number) => number;
+export type IndexedOption<T> = {
+    option: KapiSelectOption<T>;
+    index: number;
+};
+export type IndexedRow<T> = {
+    kind: "option";
+    key: string;
+    item: IndexedOption<T>;
+} | {
+    kind: "group";
+    key: string;
+    label: string;
+    items: IndexedOption<T>[];
+};
+/** Asigna a cada opción su índice en la lista aplanada, conservando la estructura de grupos para renderizar. */
+export declare const indexEntries: <T>(entries: readonly KapiSelectEntry<T>[]) => IndexedRow<T>[];
+export type MenuPlacement = {
+    top: number;
+    left: number;
+    width: number;
+    placement: "bottom" | "top";
+};
+/** Opciones del motor para el menú del select: abajo, ancho del control, sin acotar en horizontal. */
+export declare const SELECT_MENU_PLACEMENT: {
+    readonly side: "bottom";
+    readonly align: "start";
+    readonly shift: false;
+    readonly width: "anchor";
+};
+/**
+ * Posición del menú (coordenadas de viewport): debajo del control; si no entra y arriba hay más lugar,
+ * se abre hacia arriba. Wrapper de `placePopover`.
+ */
+export declare const placeMenu: (rect: {
+    top: number;
+    bottom: number;
+    left: number;
+    width: number;
+}, menuHeight: number, viewportHeight: number, gap?: number) => MenuPlacement;
+export {};

package/dist/components/inputs/selectLogic.js

@@ -0,0 +1,82 @@
+//#region src/components/inputs/selectLogic.ts
+var e = (e) => "options" in e && Array.isArray(e.options), t = (e) => e.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase(), n = (t) => t.flatMap((t) => e(t) ? t.options : [t]), r = (n, r) => {
+	let i = t(r.trim());
+	if (!i) return [...n];
+	let a = (e) => t(e.label).includes(i), o = [];
+	for (let t of n) if (e(t)) {
+		let e = t.options.filter(a);
+		e.length > 0 && o.push({
+			...t,
+			options: e
+		});
+	} else a(t) && o.push(t);
+	return o;
+}, i = (e, t, n) => {
+	let r = n.length;
+	if (!n.some((e) => !e.disabled)) return -1;
+	if (t === "first") return n.findIndex((e) => !e.disabled);
+	if (t === "last") {
+		for (let e = r - 1; e >= 0; e--) if (!n[e]?.disabled) return e;
+		return -1;
+	}
+	let i = t === "next" ? 1 : -1, a = e < 0 || e >= r ? i === 1 ? -1 : r : e;
+	for (let e = 0; e < r; e++) if (a = (a + i + r) % r, !n[a]?.disabled) return a;
+	return -1;
+}, a = (e, t) => t ? Array.isArray(e) ? e : e == null ? [] : [e] : Array.isArray(e) ? e[0] ?? null : e ?? null, o = (e, t, n) => {
+	if (!n) return t;
+	let r = a(e, !0);
+	return r.includes(t) ? r.filter((e) => e !== t) : [...r, t];
+}, s = (e, t) => {
+	let r = a(t, !0), i = n(e), o = [];
+	for (let e of r) {
+		let t = i.find((t) => t.value === e);
+		t && o.push(t);
+	}
+	return o;
+}, c = (e, t) => e.length > 0 ? e.map((e) => e.label).join(", ") : t, l = (e, t, n = "selected") => {
+	if (n === "selected") {
+		let n = e.findIndex((e) => !e.disabled && t.includes(e.value));
+		if (n >= 0) return n;
+	}
+	return i(-1, n === "last" ? "last" : "first", e);
+}, u = (e, n, r) => {
+	let i = t(n), a = e.length;
+	if (!i || a === 0) return -1;
+	let o = i.length === 1 ? r + 1 : Math.max(r, 0);
+	for (let n = 0; n < a; n++) {
+		let r = ((o + n) % a + a) % a, s = e[r];
+		if (s && !s.disabled && t(s.label).startsWith(i)) return r;
+	}
+	return -1;
+}, d = (t) => {
+	let n = 0;
+	return t.map((t, r) => {
+		if (e(t)) {
+			let e = t.options.map((e) => ({
+				option: e,
+				index: n++
+			}));
+			return {
+				kind: "group",
+				key: `g${r}-${t.label}`,
+				label: t.label,
+				items: e
+			};
+		}
+		return {
+			kind: "option",
+			key: `o${r}-${t.value}`,
+			item: {
+				option: t,
+				index: n++
+			}
+		};
+	});
+}, f = {
+	side: "bottom",
+	align: "start",
+	shift: !1,
+	width: "anchor"
+};
+//#endregion
+export { f as SELECT_MENU_PLACEMENT, c as displayLabel, r as filterOptions, u as findTypeaheadIndex, n as flattenOptions, d as indexEntries, l as initialActiveIndex, e as isGroup, i as nextActiveIndex, t as normalizeText, a as normalizeValue, s as selectedOptions, o as toggleValue };

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

@@ -0,0 +1,9 @@
+export type SliderRange = {
+    min: number;
+    max: number;
+    step: number;
+};
+/** Snap `value` to the nearest step from `min`, clamped to [min, max]. */
+export declare const clampToStep: (value: number, { min, max, step }: SliderRange) => number;
+/** Position of `value` within [min, max] as a 0..100 percentage (drives the track fill). */
+export declare const percentOf: (value: number, min: number, max: number) => number;

package/dist/components/inputs/sliderLogic.js

@@ -0,0 +1,17 @@
+//#region src/components/inputs/sliderLogic.ts
+var e = (e) => {
+	let t = String(e), n = t.indexOf(".");
+	return n === -1 ? 0 : t.length - n - 1;
+}, t = (t, { min: n, max: r, step: i }) => {
+	if (Number.isNaN(t)) return n;
+	let a = Math.min(Math.max(t, n), r);
+	if (i <= 0) return a;
+	let o = n + Math.round((a - n) / i) * i, s = Math.max(e(i), e(n)), c = Number(o.toFixed(s));
+	return Math.min(c, r);
+}, n = (e, t, n) => {
+	if (n <= t) return 0;
+	let r = (e - t) / (n - t) * 100;
+	return Math.min(100, Math.max(0, r));
+};
+//#endregion
+export { t as clampToStep, n as percentOf };

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

@@ -0,0 +1,40 @@
+export type TagRejection = {
+    tag: string;
+    reason: "invalid";
+    message: string;
+} | {
+    tag: string;
+    reason: "duplicate" | "max";
+};
+export type AddTagsOptions = {
+    /** Mensaje de error si el texto no es válido; `null` (o `""`) si lo es: sólo un mensaje no vacío rechaza. */
+    validate?: ((tag: string) => string | null) | undefined;
+    /** Tope de etiquetas. */
+    maxTags?: number | undefined;
+    /** Deja repetir etiquetas. Default `false`. */
+    allowDuplicates?: boolean | undefined;
+    /** Al comparar duplicados, distingue mayúsculas. Default `false`. */
+    caseSensitive?: boolean | undefined;
+};
+/** ¿El texto tiene una coma o un salto de línea? */
+export declare const hasSeparator: (text: string) => boolean;
+/** Parte un texto en etiquetas: corta en comas y saltos de línea, recorta y descarta las vacías. */
+export declare const splitTags: (text: string) => string[];
+/** Lo escrito hasta el último separador son etiquetas terminadas; lo que sigue queda como borrador. */
+export declare const splitDraft: (text: string) => {
+    complete: string[];
+    tail: string;
+};
+/** Reemplaza el rango `[start, end)` de `text` por `insert` (lo que hace un pegado sobre una selección). */
+export declare const spliceText: (text: string, start: number, end: number, insert: string) => string;
+/**
+ * Suma candidatos a la lista sin mutarla. Cada uno se recorta; los vacíos se ignoran y los demás se
+ * rechazan por duplicado (sin distinguir mayúsculas salvo `caseSensitive`), inválido (`validate`) o tope
+ * (`maxTags`), en ese orden de chequeo: tope, duplicado, validación.
+ */
+export declare const addTags: (values: ReadonlyArray<string>, candidates: ReadonlyArray<string>, { validate, maxTags, allowDuplicates, caseSensitive }?: AddTagsOptions) => {
+    values: string[];
+    rejected: TagRejection[];
+};
+/** Quita la etiqueta en `index` sin mutar (fuera de rango devuelve una copia igual). */
+export declare const removeTagAt: (values: ReadonlyArray<string>, index: number) => string[];

package/dist/components/inputs/tagInputLogic.js

@@ -0,0 +1,40 @@
+//#region src/components/inputs/tagInputLogic.ts
+var e = /[,\r\n]/, t = /[,\r\n]+/, n = (t) => e.test(t), r = (e) => e.split(t).map((e) => e.trim()).filter(Boolean), i = (t) => {
+	let n = t.split(e), r = (n.pop() ?? "").trimStart();
+	return {
+		complete: n.map((e) => e.trim()).filter(Boolean),
+		tail: r
+	};
+}, a = (e, t, n, r) => e.slice(0, t) + r + e.slice(n), o = (e, t, { validate: n, maxTags: r, allowDuplicates: i = !1, caseSensitive: a = !1 } = {}) => {
+	let o = (e) => a ? e : e.toLocaleLowerCase(), s = [...e], c = new Set(s.map(o)), l = [];
+	for (let e of t) {
+		let t = e.trim();
+		if (!t) continue;
+		if (r !== void 0 && s.length >= r) {
+			l.push({
+				tag: t,
+				reason: "max"
+			});
+			continue;
+		}
+		if (!i && c.has(o(t))) {
+			l.push({
+				tag: t,
+				reason: "duplicate"
+			});
+			continue;
+		}
+		let a = n?.(t) || null;
+		a === null ? (s.push(t), c.add(o(t))) : l.push({
+			tag: t,
+			reason: "invalid",
+			message: a
+		});
+	}
+	return {
+		values: s,
+		rejected: l
+	};
+}, s = (e, t) => e.filter((e, n) => n !== t);
+//#endregion
+export { o as addTags, n as hasSeparator, s as removeTagAt, a as spliceText, i as splitDraft, r as splitTags };

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

@@ -0,0 +1,17 @@
+export type AutosizeBounds = {
+    /** Minimum height in px (usually `rows` worth of text). */
+    minHeight: number;
+    /** Optional maximum height in px; beyond it the textarea scrolls. */
+    maxHeight?: number | undefined;
+};
+/**
+ * Height a textarea should take for its content. Pure: callers pass the measured
+ * `scrollHeight` (content + padding) and get back the clamped height plus whether
+ * the content overflows the maximum (so the caller can enable scrolling).
+ */
+export declare const autosizeHeight: (scrollHeight: number, { minHeight, maxHeight }: AutosizeBounds) => {
+    height: number;
+    overflowing: boolean;
+};
+/** Min/max heights in px from row counts, given line height and vertical padding + borders. */
+export declare const rowsToHeight: (rows: number, lineHeight: number, chrome: number) => number;

package/dist/components/inputs/textareaLogic.js

@@ -0,0 +1,13 @@
+//#region src/components/inputs/textareaLogic.ts
+var e = (e, { minHeight: t, maxHeight: n }) => {
+	let r = Math.max(e, t);
+	return n !== void 0 && r > n ? {
+		height: Math.max(n, t),
+		overflowing: !0
+	} : {
+		height: r,
+		overflowing: !1
+	};
+}, t = (e, t, n) => Math.round(e * t + n);
+//#endregion
+export { e as autosizeHeight, t as rowsToHeight };

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

@@ -0,0 +1,13 @@
+/**
+ * Foco de los date pickers (patrón WAI-ARIA date picker dialog):
+ * - abrir por foco/click en el campo deja el foco ahí (se puede tipear);
+ * - abrir con el botón o con Flecha abajo pide enfocar la grilla (`focusRequest` crece);
+ * - `returnFocus` cierra y devuelve el foco al campo sin que su `onFocus` vuelva a abrir.
+ */
+export declare const useCalendarFocus: (setOpen: (open: boolean) => void) => {
+    inputRef: import("react").RefObject<HTMLInputElement | null>;
+    focusRequest: number;
+    openFromKeyboard: () => void;
+    openFromFocus: () => void;
+    returnFocus: () => void;
+};

package/dist/components/inputs/useCalendarFocus.js

@@ -0,0 +1,25 @@
+"use client";
+import { useRef as e, useState as t } from "react";
+//#region src/components/inputs/useCalendarFocus.ts
+var n = (n) => {
+	let r = e(null), i = e(!1), [a, o] = t(0);
+	return {
+		inputRef: r,
+		focusRequest: a,
+		openFromKeyboard: () => {
+			o((e) => e + 1), n(!0);
+		},
+		openFromFocus: () => {
+			i.current ? i.current = !1 : (o(0), n(!0));
+		},
+		returnFocus: () => {
+			n(!1);
+			let e = r.current;
+			e && (i.current = !0, e.focus(), document.activeElement !== e && (i.current = !1), queueMicrotask(() => {
+				i.current = !1;
+			}));
+		}
+	};
+};
+//#endregion
+export { n as useCalendarFocus };

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

@@ -0,0 +1,15 @@
+import type { RefObject } from "react";
+/** Opciones del motor para el popover (inline) de los date pickers: abajo; arriba si no entra. */
+export declare const DATE_POP_PLACEMENT: {
+    readonly side: "bottom";
+    readonly align: "start";
+    readonly offset: 6;
+    readonly flip: "auto";
+    readonly shift: false;
+};
+/**
+ * Lado del popover inline de KapiDatePicker / KapiDateRangePicker según el motor único: mide el campo
+ * y el popover, se reubica con scroll/resize/tamaño. Sólo decide el lado (el CSS posiciona con
+ * `kapi-dp__pop--up`); no lo oculta mientras mide porque el foco entra al calendario al abrir.
+ */
+export declare const useDatePopSide: (open: boolean, fieldRef: RefObject<HTMLElement | null>, popRef: RefObject<HTMLElement | null>) => "top" | "bottom";

package/dist/components/inputs/useDatePopSide.js

@@ -0,0 +1,20 @@
+import { usePlacement as e } from "../../hooks/usePlacement.js";
+//#region src/components/inputs/useDatePopSide.ts
+var t = {
+	side: "bottom",
+	align: "start",
+	offset: 6,
+	flip: "auto",
+	shift: !1
+}, n = (n, r, i) => {
+	let { placement: a } = e({
+		open: n,
+		anchor: r,
+		floatingRef: i,
+		...t,
+		hideUntilPlaced: !1
+	});
+	return a?.side === "top" ? "top" : "bottom";
+};
+//#endregion
+export { t as DATE_POP_PLACEMENT, n as useDatePopSide };

package/dist/components/labelsLogic.d.ts

@@ -0,0 +1,6 @@
+/** Overrides de textos por clave (prop `labels`): cada clave puede faltar o venir en `undefined`. */
+export type KapiLabelsOverride<L> = {
+    [K in keyof L]?: L[K] | undefined;
+};
+/** Defaults + overrides por clave. Una clave en `undefined` no borra el default. No muta. */
+export declare const withLabels: <L extends object>(defaults: L, overrides?: KapiLabelsOverride<L>) => L;

package/dist/components/labelsLogic.js

@@ -0,0 +1,11 @@
+//#region src/components/labelsLogic.ts
+var e = (e, t) => {
+	let n = { ...e };
+	if (t) for (let e of Object.keys(t)) {
+		let r = t[e];
+		r !== void 0 && (n[e] = r);
+	}
+	return n;
+};
+//#endregion
+export { e as withLabels };

package/dist/components/layout/KapiAccessCard.d.ts

@@ -0,0 +1,40 @@
+import type { ReactNode } from "react";
+import { type KapiAccessCardTone } from "./accessCardLogic";
+import "./KapiAccessCard.css";
+import type { KapiRootProps } from "../rootProps";
+import { type KapiLinkLabels } from "../locale/linkLabels";
+import type { KapiLabelsOverride } from "../labelsLogic";
+/** `className`/`style`/`id` van al enlace o al botón de la card. */
+type CommonProps = KapiRootProps & {
+    /** Ícono (lucide-react) dentro del recuadro de color. */
+    icon: ReactNode;
+    /** Rol semántico que define el color del recuadro del ícono. */
+    tone?: KapiAccessCardTone;
+    /** Título de la card (nombre del sistema o sección). */
+    title: ReactNode;
+    /** Texto secundario bajo el título. */
+    description?: ReactNode;
+    /** Abre otro sistema / otra pestaña: cambia el chevron por el ícono de enlace externo. */
+    external?: boolean;
+    /** Textos fijos (aviso de pestaña nueva; clave compartida `link`). */
+    labels?: KapiLabelsOverride<KapiLinkLabels> | undefined;
+};
+export type KapiAccessCardProps = CommonProps & ({
+    /** Destino como enlace real (`<a>`). */
+    href: string;
+    /** Abrir en pestaña nueva. */
+    newTab?: boolean;
+    onClick?: never;
+} | {
+    href?: never;
+    newTab?: never;
+    /** Destino con lógica previa: se dibuja como `role="button"`. */
+    onClick: () => void;
+});
+/**
+ * Card de acceso directo: ícono + título + bajada y, a la derecha, un indicador de destino
+ * (chevron = navega dentro de la app, flecha ↗ = abre otro sistema). Con `href` es un enlace
+ * real; con `onClick`, un botón accesible por teclado (Enter / Espacio).
+ */
+export declare const KapiAccessCard: ({ icon, tone, title, description, external, href, newTab, onClick, className, style, id, labels }: KapiAccessCardProps) => import("react").JSX.Element;
+export {};