@kapiuara/ui 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,76 @@
+export type StackEntryState = "open" | "closing";
+export type StackEntry = Readonly<{
+    id: string;
+    state: StackEntryState;
+}>;
+export type StackState = readonly StackEntry[];
+export type StackAction = {
+    type: "add";
+    id: string;
+} | {
+    type: "mark";
+    id: string;
+    state: StackEntryState;
+} | {
+    type: "remove";
+    id: string;
+};
+export declare const EMPTY_STACK: StackState;
+/** Idempotente: devuelve la MISMA referencia si la acción no cambia nada. */
+export declare const stackReducer: (state: StackState, action: StackAction) => StackState;
+/** Cantidad de paneles ABIERTOS (no cerrándose) apilados por encima de `id`. */
+export declare const depthOf: (state: StackState, id: string) => number;
+/** Posición en la pila (0 = base). -1 si no está registrado. */
+export declare const levelOf: (state: StackState, id: string) => number;
+export declare const DEFAULT_PUSH_RATIO = 0.04;
+export declare const DEFAULT_PUSH_OFFSET = 16;
+export declare const MIN_PUSH_SCALE = 0.8;
+export declare const MAX_PUSH_RATIO = 0.2;
+export type PushTransform = {
+    scale: number;
+    translateX: number;
+};
+/**
+ * Cuánto se empuja un panel que tiene `depth` hijos abiertos encima:
+ * escala `1 - depth * ratio` (con piso) y corrimiento a la izquierda de
+ * `depth * offset` px (asoma como "carta" detrás del hijo).
+ */
+export declare const pushTransform: (depth: number, ratio?: number, offset?: number) => PushTransform;
+/** Store mínimo (compatible con useSyncExternalStore) sobre `stackReducer`. */
+export declare const createStackStore: () => {
+    getSnapshot: () => StackState;
+    getServerSnapshot: () => StackState;
+    subscribe: (listener: () => void) => () => void;
+    dispatch: (action: StackAction) => void;
+};
+/** Singleton compartido por todos los `KapiOffcanvas` de la página. */
+export declare const offcanvasStackStore: {
+    getSnapshot: () => StackState;
+    getServerSnapshot: () => StackState;
+    subscribe: (listener: () => void) => () => void;
+    dispatch: (action: StackAction) => void;
+};
+export type OffcanvasPhase = "unmounted" | "enter" | "open" | "exit";
+export type OffcanvasPhaseEvent = "open" | "entered" | "close" | "exited";
+export declare const phaseReducer: (phase: OffcanvasPhase, event: OffcanvasPhaseEvent) => OffcanvasPhase;
+export type PanelEntry<T> = Readonly<{
+    id: string;
+    open: boolean;
+    config: T;
+}>;
+export type PanelsAction<T> = {
+    type: "push";
+    id: string;
+    config: T;
+} | {
+    type: "close";
+    id: string;
+} | {
+    type: "closeAll";
+} | {
+    type: "remove";
+    id: string;
+};
+export declare const panelsReducer: <T>(state: readonly PanelEntry<T>[], action: PanelsAction<T>) => readonly PanelEntry<T>[];
+/** Id del panel abierto más alto de la pila (el que cierra Escape / `pop`). */
+export declare const topOpenId: <T>(state: readonly PanelEntry<T>[]) => string | undefined;

package/dist/components/overlays/offcanvasStack.js

@@ -0,0 +1,72 @@
+import { clamp as e } from "./dialogUtils.js";
+//#region src/components/overlays/offcanvasStack.ts
+var t = [], n = (e, t) => {
+	let n = e.findIndex((e) => e.id === t.id);
+	switch (t.type) {
+		case "add": return n >= 0 ? e : [...e, {
+			id: t.id,
+			state: "open"
+		}];
+		case "mark": return n < 0 || e[n]?.state === t.state ? e : e.map((e, r) => r === n ? {
+			...e,
+			state: t.state
+		} : e);
+		case "remove": return n < 0 ? e : e.filter((e) => e.id !== t.id);
+	}
+}, r = (e, t) => {
+	let n = e.findIndex((e) => e.id === t);
+	return n < 0 ? 0 : e.slice(n + 1).filter((e) => e.state === "open").length;
+}, i = (e, t) => e.findIndex((e) => e.id === t), a = .04, o = .8, s = .2, c = (t, n = a, r = 16) => {
+	let i = Math.max(0, Math.floor(t));
+	if (i === 0) return {
+		scale: 1,
+		translateX: 0
+	};
+	let c = e(Number.isFinite(n) ? n : a, 0, s), l = Math.max(0, Number.isFinite(r) ? r : 16);
+	return {
+		scale: Math.round(e(1 - i * c, o, 1) * 1e4) / 1e4,
+		translateX: l === 0 ? 0 : -i * l
+	};
+}, l = () => {
+	let e = t, r = /* @__PURE__ */ new Set();
+	return {
+		getSnapshot: () => e,
+		getServerSnapshot: () => t,
+		subscribe: (e) => (r.add(e), () => {
+			r.delete(e);
+		}),
+		dispatch: (t) => {
+			let i = n(e, t);
+			i !== e && (e = i, r.forEach((e) => e()));
+		}
+	};
+}, u = l(), d = (e, t) => {
+	switch (t) {
+		case "open": return e === "unmounted" ? "enter" : e === "exit" ? "open" : e;
+		case "entered": return e === "enter" ? "open" : e;
+		case "close": return e === "enter" ? "unmounted" : e === "open" ? "exit" : e;
+		case "exited": return e === "exit" ? "unmounted" : e;
+	}
+}, f = (e, t) => {
+	switch (t.type) {
+		case "push": return e.some((e) => e.id === t.id) ? e : [...e, {
+			id: t.id,
+			open: !0,
+			config: t.config
+		}];
+		case "close": {
+			let n = e.findIndex((e) => e.id === t.id);
+			return n < 0 || e.slice(n).every((e) => !e.open) ? e : e.map((e, t) => t >= n && e.open ? {
+				...e,
+				open: !1
+			} : e);
+		}
+		case "closeAll": return e.every((e) => !e.open) ? e : e.map((e) => e.open ? {
+			...e,
+			open: !1
+		} : e);
+		case "remove": return e.some((e) => e.id === t.id) ? e.filter((e) => e.id !== t.id) : e;
+	}
+}, p = (e) => [...e].reverse().find((e) => e.open)?.id;
+//#endregion
+export { a as DEFAULT_PUSH_RATIO, t as EMPTY_STACK, s as MAX_PUSH_RATIO, o as MIN_PUSH_SCALE, l as createStackStore, r as depthOf, i as levelOf, u as offcanvasStackStore, f as panelsReducer, d as phaseReducer, c as pushTransform, n as stackReducer, p as topOpenId };

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

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+export type KapiOverlayPortalProps = {
+    /** Destino del portal (ver `resolveKapiRoot` en hooks/kapiRoot). Si es `null`, no renderiza. */
+    root: HTMLElement | null;
+    /** Contenido que se portalea a `root`. */
+    children: ReactNode;
+};
+/** Portal fino hacia el nodo `.kapi`. */
+export declare const KapiOverlayPortal: ({ root, children }: KapiOverlayPortalProps) => import("react").ReactPortal | null;

package/dist/components/overlays/overlayPortal.js

@@ -0,0 +1,6 @@
+"use client";
+import { createPortal as e } from "react-dom";
+//#region src/components/overlays/overlayPortal.tsx
+var t = ({ root: t, children: n }) => t ? e(n, t) : null;
+//#endregion
+export { t as KapiOverlayPortal };

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

@@ -0,0 +1,94 @@
+/** Lado del ancla donde se abre el popover. */
+export type KapiPopoverSide = "top" | "bottom" | "left" | "right";
+/** Alineación en el eje cruzado: inicio, centro o fin del ancla. */
+export type KapiPopoverAlign = "start" | "center" | "end";
+export type KapiPopoverRect = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    width: number;
+    height: number;
+};
+export type KapiPopoverSize = {
+    width: number;
+    height: number;
+};
+/** Ancla puntual (p. ej. la posición del click derecho). */
+export type KapiPopoverPoint = {
+    x: number;
+    y: number;
+};
+/** Rect, punto o `null` (sin ancla: se usa `fallback`). */
+export type KapiPopoverAnchor = KapiPopoverRect | KapiPopoverPoint | null;
+/**
+ * Cuándo da vuelta al lado opuesto en el eje principal:
+ * - `"auto"`: si está medido, no entra y del otro lado hay más lugar (default).
+ * - `"if-overflow"`: siempre que no entre, sin mirar el otro lado ni si está medido.
+ * - `false`: nunca.
+ */
+export type KapiPopoverFlip = "auto" | "if-overflow" | false;
+/**
+ * Ancho del popover:
+ * - `"content"`: el propio (medido o estimado), sin tocar (default).
+ * - `"anchor"`: exactamente el del ancla (salida `width`).
+ * - `"min-anchor"`: al menos el del ancla (salida `minWidth`).
+ * - `{ max }`: fijo, `max` acotado al viewport menos los márgenes (salida `width`).
+ */
+export type KapiPopoverWidth = "content" | "anchor" | "min-anchor" | {
+    max: number;
+};
+export type KapiPlacePopoverOptions = {
+    /** Lado preferido. Default `"bottom"`. */
+    side?: KapiPopoverSide;
+    /** Default `"start"`. `"auto"` elige inicio o fin del ancla según el lugar (menús de acciones). */
+    align?: KapiPopoverAlign | "auto";
+    /** Separación (px) entre ancla y popover. Default `6`. */
+    offset?: number;
+    /** Margen mínimo (px) al borde del viewport en el eje cruzado. Default `8`. */
+    margin?: number;
+    /** Default `"auto"`. */
+    flip?: KapiPopoverFlip;
+    /**
+     * Acotar al viewport con `margin`: `true` sólo el eje cruzado (default), `"both"` también el
+     * principal, `false` nada.
+     */
+    shift?: boolean | "both";
+    /** Piso (px) de la posición hacia arriba/izquierda en el eje principal. Default `0`. */
+    mainMin?: number;
+    /** Default `"content"`. */
+    width?: KapiPopoverWidth;
+    /** Dirección del texto: en `"rtl"` el inicio/fin horizontal se espeja. Default `"ltr"`. */
+    dir?: "ltr" | "rtl";
+    /** Esquina donde va el popover sin ancla (`null`). Default `{ x: margin, y: margin }`. */
+    fallback?: KapiPopoverPoint;
+};
+export type KapiPopoverPlacement = {
+    top: number;
+    left: number;
+    side: KapiPopoverSide;
+    align: KapiPopoverAlign;
+    /** Centro horizontal del popover (para CSS que centra con `translateX(-50%)`). */
+    centerX: number;
+    /** Con `width: "anchor"` o `{ max }`. */
+    width?: number;
+    /** Con `width: "min-anchor"`. */
+    minWidth?: number;
+};
+/** Acota `value` a `[margin, viewport - size - margin]`; si no entra, queda en `margin`. */
+export declare const shiftIntoView: (value: number, size: number, viewport: number, margin?: number) => number;
+/**
+ * Motor único de posicionamiento (coordenadas de viewport, `position: fixed`) de un elemento
+ * flotante anclado a un rect, un punto o nada. En el eje principal da vuelta según `flip`; hacia
+ * arriba/izquierda nunca queda por debajo de `mainMin`. En el eje cruzado se acota al viewport con
+ * `margin` (`shift`). Puro: el tamaño puede venir medido o estimado.
+ */
+export declare function placePopover(anchor: KapiPopoverAnchor, popover: KapiPopoverSize, viewport: KapiPopoverSize, { side, align, offset, margin, flip, shift, mainMin, width: widthMode, dir, fallback }?: KapiPlacePopoverOptions): KapiPopoverPlacement;
+/** ¿Dos ubicaciones son iguales? (guarda de igualdad para no re-renderizar en loop). */
+export declare const samePlacement: (a: KapiPopoverPlacement | null, b: KapiPopoverPlacement | null) => boolean;
+type Containing = {
+    contains: (node: never) => boolean;
+} | null | undefined;
+/** ¿El evento cayó fuera del popover y de su ancla? (target nulo: no se considera afuera). */
+export declare const isOutsidePopover: (target: unknown, nodes: ReadonlyArray<Containing>) => boolean;
+export {};

package/dist/components/overlays/popoverLogic.js

@@ -0,0 +1,47 @@
+//#region src/components/overlays/popoverLogic.ts
+var e = {
+	top: "bottom",
+	bottom: "top",
+	left: "right",
+	right: "left"
+}, t = (e, t, n) => Math.max(t, Math.min(e, n)), n = (e, n, r, i = 8) => t(e, i, Math.max(r - n - i, i)), r = (e) => "top" in e ? e : {
+	top: e.y,
+	bottom: e.y,
+	left: e.x,
+	right: e.x,
+	width: 0,
+	height: 0
+}, i = (e) => Number.isFinite(e) && e > 0 ? e : 0, a = (e, t, n) => e === "bottom" ? n.height - t.bottom : e === "top" ? t.top : e === "right" ? n.width - t.right : t.left, o = (e, t, n, r, i) => e === "auto" ? t > 0 && t + n > r && i > r : e === "if-overflow" && t + n > r, s = (e, t, n, r, i) => {
+	let a = n > 0 && e + n > r - i, o = e + t / 2 > r / 2, s = n > 0 && e + t - n < i;
+	return (a || o) && !s ? "end" : "start";
+}, c = (e) => e === "start" ? "end" : e === "end" ? "start" : e;
+function l(t, l, u, { side: d = "bottom", align: f = "start", offset: p = 6, margin: m = 8, flip: h = "auto", shift: g = !0, mainMin: _ = 0, width: v = "content", dir: y = "ltr", fallback: b = {
+	x: m,
+	y: m
+} } = {}) {
+	let x = t ? r(t) : null, S = d === "top" || d === "bottom", C = l.width, w, T;
+	v === "anchor" ? (w = i(x?.width ?? 0), C = w) : v === "min-anchor" ? (T = x?.width ?? 0, C = Math.max(l.width, T)) : typeof v == "object" && (w = Math.max(0, Math.min(v.max, u.width - m * 2)), C = w);
+	let E = {
+		width: C,
+		height: l.height
+	}, D = d, O, k, A;
+	if (!x) O = S ? b.y : b.x, k = S ? b.x : b.y, A = f === "auto" ? "start" : f;
+	else {
+		o(h, S ? E.height : E.width, p, a(d, x, u), a(e[d], x, u)) && (D = e[d]), O = D === "bottom" ? x.bottom + p : D === "right" ? x.right + p : D === "top" ? Math.max(_, x.top - p - E.height) : Math.max(_, x.left - p - E.width);
+		let t = S ? x.left : x.top, n = S ? x.width : x.height, r = S ? E.width : E.height, i = S ? u.width : u.height, l = y === "rtl" && S, g = f === "auto" ? s(t, n, r, i, m) : l ? c(f) : f;
+		A = l ? c(g) : g, k = g === "start" ? t : g === "end" ? t + n - r : t + (n - r) / 2;
+	}
+	let j = S ? E.width : E.height, M = S ? E.height : E.width, N = g ? n(k, j, S ? u.width : u.height, m) : k;
+	g === "both" && (O = n(O, M, S ? u.height : u.width, m));
+	let P = S ? O : N, F = S ? N : O, I = {
+		top: P,
+		left: F,
+		side: D,
+		align: A,
+		centerX: F + E.width / 2
+	};
+	return w !== void 0 && (I.width = w), T !== void 0 && (I.minWidth = T), I;
+}
+var u = (e, t) => e === t || !!e && !!t && e.top === t.top && e.left === t.left && e.side === t.side && e.align === t.align && e.width === t.width && e.minWidth === t.minWidth && e.centerX === t.centerX, d = (e, t) => e != null && !t.some((t) => t?.contains(e));
+//#endregion
+export { d as isOutsidePopover, l as placePopover, u as samePlacement, n as shiftIntoView };

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

@@ -0,0 +1,8 @@
+export type KapiSplitModalSide = "left" | "right";
+export declare const DEFAULT_ASIDE_WIDTH = "380px";
+/** DOM order of the two panels: `left` = [aside | main], `right` = [main | aside]. */
+export declare const resolvePanelOrder: (side?: KapiSplitModalSide) => ["aside", "main"] | ["main", "aside"];
+/** Aside width as a CSS length (number → px, numeric string → px, other strings untouched). */
+export declare const resolveAsideWidth: (width: number | string | undefined) => string;
+/** Class list of the split row (side modifier included). */
+export declare const splitModalClasses: (side?: KapiSplitModalSide) => string;

package/dist/components/overlays/splitModalLayout.js

@@ -0,0 +1,5 @@
+import { toCssSize as e } from "./dialogUtils.js";
+//#region src/components/overlays/splitModalLayout.ts
+var t = "380px", n = (e = "left") => e === "right" ? ["main", "aside"] : ["aside", "main"], r = (n) => e(n, t), i = (e = "left") => `kapi-splitmodal kapi-splitmodal--${e === "right" ? "right" : "left"}`;
+//#endregion
+export { t as DEFAULT_ASIDE_WIDTH, r as resolveAsideWidth, n as resolvePanelOrder, i as splitModalClasses };

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

@@ -0,0 +1,14 @@
+import { type RefObject } from "react";
+/**
+ * Mantiene montado un overlay mientras anima su salida. Con `open` en false el componente sigue
+ * renderizando (`closing` en true: que ponga `data-closing` y el CSS dispare la animación de salida)
+ * hasta que `el` termina su animación/transición; recién ahí `present` pasa a false.
+ *
+ * La espera se deriva del CSS computado de `el` (nunca un número fijo). Sin movimiento (reduced-motion
+ * del SO o `data-motion="reduced"`, o sin animación que esperar) cierra en el mismo commit, así que un
+ * overlay sin animación se desmonta igual de rápido que antes. `ref` debe apuntar al elemento que anima.
+ */
+export declare const useExitPresence: (open: boolean, ref: RefObject<HTMLElement | null>) => {
+    present: boolean;
+    closing: boolean;
+};

package/dist/components/overlays/useExitPresence.js

@@ -0,0 +1,34 @@
+"use client";
+import { prefersReducedMotion as e } from "../../hooks/reducedMotion.js";
+import { exitWaitMs as t, nextExitPhase as n } from "./exitPresenceLogic.js";
+import { useLayoutEffect as r, useState as i } from "react";
+//#region src/components/overlays/useExitPresence.ts
+var a = (a, o) => {
+	let [s, c] = i(a ? "open" : "closed"), l = n(s, a);
+	return l !== s && c(l), r(() => {
+		if (s !== "closing") return;
+		let n = o.current;
+		if (!n || e(n)) {
+			c("closed");
+			return;
+		}
+		let r = t(getComputedStyle(n));
+		if (r <= 0) {
+			c("closed");
+			return;
+		}
+		let i = () => c("closed"), a = (e) => {
+			e.target === n && i();
+		};
+		n.addEventListener("animationend", a), n.addEventListener("transitionend", a);
+		let l = setTimeout(i, r + 100);
+		return () => {
+			n.removeEventListener("animationend", a), n.removeEventListener("transitionend", a), clearTimeout(l);
+		};
+	}, [s, o]), {
+		present: l !== "closed",
+		closing: l === "closing"
+	};
+};
+//#endregion
+export { a as useExitPresence };

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

@@ -0,0 +1,30 @@
+import { type MouseEvent, type SyntheticEvent } from "react";
+/** Nodo donde se montan los diálogos: la raíz `.kapi` (hereda tokens). `null` en SSR. */
+export declare const getPortalRoot: () => HTMLElement | null;
+export type UseNativeDialogOptions = {
+    /**
+     * Se llama cuando el usuario pide cerrar (Escape o cierre nativo). Si es
+     * `undefined`, el diálogo es bloqueante: Escape se ignora y, si el navegador
+     * lo cierra igual, se vuelve a abrir.
+     */
+    onRequestClose?: (() => void) | undefined;
+    /** Bloquea el scroll del `body` mientras está montado. Default true. */
+    lockScroll?: boolean;
+};
+/**
+ * Ciclo de vida de un `<dialog>` modal nativo: `showModal()` al montar (focus
+ * trap, `inert` del fondo, Escape y `::backdrop` los da el navegador), bloqueo de
+ * scroll, foco inicial en `[data-autofocus]` y restauración de foco al desmontar.
+ */
+export declare const useNativeDialog: ({ onRequestClose, lockScroll }?: UseNativeDialogOptions) => {
+    ref: import("react").RefObject<HTMLDialogElement | null>;
+    dialogProps: {
+        onCancel: (e: SyntheticEvent<HTMLDialogElement>) => void;
+        onClose: () => void;
+    };
+};
+/** Cierra al hacer click en el fondo (el propio `<dialog>`), no al soltar un drag desde adentro. */
+export declare const useBackdropClose: (onClose: (() => void) | undefined) => {
+    onMouseDown: (e: MouseEvent<HTMLDialogElement>) => void;
+    onClick: (e: MouseEvent<HTMLDialogElement>) => void;
+};

package/dist/components/overlays/useNativeDialog.js

@@ -0,0 +1,56 @@
+"use client";
+import { resolveKapiRoot as e } from "../../hooks/kapiRoot.js";
+import { createScrollLock as t } from "./dialogUtils.js";
+import { useCallback as n, useLayoutEffect as r, useRef as i } from "react";
+//#region src/components/overlays/useNativeDialog.ts
+var a = () => e(), o = t({
+	getTarget: () => typeof document > "u" ? null : document.body,
+	measure: () => ({
+		scrollbar: Math.max(0, window.innerWidth - document.documentElement.clientWidth),
+		padding: parseFloat(getComputedStyle(document.body).paddingRight) || 0
+	})
+}), s = (e) => {
+	e.open || (typeof e.showModal == "function" ? e.showModal() : e.setAttribute("open", ""));
+}, c = (e) => {
+	typeof e.close == "function" ? e.open && e.close() : e.removeAttribute("open");
+}, l = ({ onRequestClose: e, lockScroll: t = !0 } = {}) => {
+	let a = i(null), l = i(e);
+	return r(() => {
+		l.current = e;
+	}), r(() => {
+		let e = a.current;
+		if (!e) return;
+		let n = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+		s(e);
+		let r = t ? o.acquire() : void 0;
+		return e.querySelector("[data-autofocus]")?.focus(), () => {
+			r?.(), c(e), n?.isConnected && n.focus();
+		};
+	}, [t]), {
+		ref: a,
+		dialogProps: {
+			onCancel: n((e) => {
+				e.nativeEvent.cancelable && (e.preventDefault(), l.current?.());
+			}, []),
+			onClose: n(() => {
+				let e = a.current;
+				e && (e.open || (l.current?.(), setTimeout(() => {
+					e.isConnected && !e.open && s(e);
+				}, 0)));
+			}, [])
+		}
+	};
+}, u = (e) => {
+	let t = i(!1);
+	return {
+		onMouseDown: (e) => {
+			t.current = e.target === e.currentTarget;
+		},
+		onClick: (n) => {
+			let r = t.current && n.target === n.currentTarget;
+			t.current = !1, r && e?.();
+		}
+	};
+};
+//#endregion
+export { a as getPortalRoot, u as useBackdropClose, l as useNativeDialog };

package/dist/components/rootProps.d.ts

@@ -0,0 +1,17 @@
+import type { CSSProperties } from "react";
+/**
+ * Atributos nativos mínimos que acepta todo componente cuyo elemento visible no es un elemento
+ * plano propio (portaleado, compuesto o con varias raíces). Cada componente documenta en qué
+ * elemento caen. Los componentes con un elemento raíz plano aceptan además el resto de los
+ * atributos nativos (`data-*`, `aria-*`, handlers).
+ */
+export type KapiRootProps = {
+    /** Clase extra de la superficie visible (se une a las clases propias). */
+    className?: string | undefined;
+    /** Estilos en línea de la superficie visible. */
+    style?: CSSProperties | undefined;
+    /** `id` de la superficie visible. */
+    id?: string | undefined;
+};
+/** Une clases ignorando las vacías. Pura. */
+export declare const joinClasses: (...parts: Array<string | false | null | undefined>) => string;

package/dist/components/rootProps.js

@@ -0,0 +1,4 @@
+//#region src/components/rootProps.ts
+var e = (...e) => e.filter(Boolean).join(" ");
+//#endregion
+export { e as joinClasses };

package/dist/hooks/breakpointOpenLogic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Estado abierto/cerrado de un panel que en desktop es lateral y en móvil es drawer, al cruzar
+ * el breakpoint (lógica pura). Devuelve el nuevo estado, o `null` si no hubo cruce.
+ *  - desktop → móvil: se cierra (un drawer abierto taparía todo con su backdrop).
+ *  - móvil → desktop: vuelve al último estado que tenía en desktop.
+ */
+export declare const openOnBreakpointCross: (wasMobile: boolean, isMobile: boolean, lastDesktopOpen: boolean) => boolean | null;

package/dist/hooks/breakpointOpenLogic.js

@@ -0,0 +1,4 @@
+//#region src/hooks/breakpointOpenLogic.ts
+var e = (e, t, n) => e === t ? null : !t && n;
+//#endregion
+export { e as openOnBreakpointCross };

package/dist/hooks/dateFormat.d.ts

@@ -0,0 +1,12 @@
+export declare const isoDateTime: (date: Date | string) => string | null;
+/**
+ * Fecha relativa a `now` con `Intl.RelativeTimeFormat` ("ahora", "hace 5 minutos", "ayer",
+ * "hace 2 semanas", "dentro de 10 minutos"…). Acepta `Date` o string parseable; una fecha inválida
+ * devuelve "". Trunca en vez de redondear: 59,5 minutos es "hace 59 minutos", nunca "hace 60 minutos".
+ */
+export declare const formatRelativeTime: (date: Date | string, now?: Date, locale?: string) => string;
+/**
+ * Fecha absoluta con `Intl.DateTimeFormat` (default `{ dateStyle: "medium" }`: "12 mar 2026").
+ * Acepta `Date` o string parseable; una fecha inválida devuelve "".
+ */
+export declare const formatDate: (date: Date | string, locale?: string, options?: Intl.DateTimeFormatOptions) => string;

package/dist/hooks/dateFormat.js

@@ -0,0 +1,15 @@
+//#region src/hooks/dateFormat.ts
+var e = 6e4, t = 60 * e, n = 24 * t, r = 7 * n, i = 30 * n, a = 365 * n, o = /* @__PURE__ */ new Map(), s = (e) => {
+	let t = o.get(e);
+	return t || (t = new Intl.RelativeTimeFormat(e, { numeric: "auto" }), o.set(e, t)), t;
+}, c = (e) => (typeof e == "string" ? new Date(e) : e).getTime(), l = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/, u = (e) => Number.isFinite(c(e)) ? typeof e == "string" && l.test(e) ? e : (typeof e == "string" ? new Date(e) : e).toISOString() : null, d = (o, l = /* @__PURE__ */ new Date(), u = "es") => {
+	let d = c(o);
+	if (!Number.isFinite(d)) return "";
+	let f = d - l.getTime(), p = Math.abs(f), m = s(u);
+	return p < e ? m.format(0, "second") : p < t ? m.format(Math.trunc(f / e), "minute") : p < n ? m.format(Math.trunc(f / t), "hour") : p < r ? m.format(Math.trunc(f / n), "day") : p < i ? m.format(Math.trunc(f / r), "week") : p < a ? m.format(Math.trunc(f / i), "month") : m.format(Math.trunc(f / a), "year");
+}, f = (e, t = "es", n = { dateStyle: "medium" }) => {
+	let r = c(e);
+	return Number.isFinite(r) ? new Intl.DateTimeFormat(t, n).format(r) : "";
+};
+//#endregion
+export { f as formatDate, d as formatRelativeTime, u as isoDateTime };

package/dist/hooks/downloadLogic.d.ts

@@ -0,0 +1,31 @@
+/** Cómo se puede mostrar un archivo en el navegador. */
+export type KapiFileKind = "pdf" | "image" | "text" | "other";
+/**
+ * Nombre de archivo de un header `Content-Disposition` (RFC 6266): `filename*` (UTF-8, codificado)
+ * gana sobre `filename`. Se descartan las rutas. `null` si no trae nombre.
+ */
+export declare const fileNameFromContentDisposition: (header: string | null | undefined) => string | null;
+/** Nombre de archivo del último segmento de una URL (sin query ni hash). `null` para `blob:`/`data:`. */
+export declare const fileNameFromUrl: (url: string) => string | null;
+/**
+ * Tipo de visualización a partir de un MIME (`application/pdf`) o de un nombre/URL (`acta.pdf`).
+ * `text` es solo texto plano y JSON: CSV, HTML y el resto van a `other` (se descargan).
+ */
+export declare const fileKind: (mimeOrName: string | null | undefined) => KapiFileKind;
+/**
+ * Tamaño legible en base 1024: "0 B", "512 B", "1,5 KB", "23 MB", "1,2 GB" (bytes sin decimales; el
+ * resto con un decimal como máximo, según `locale`). Si el redondeo llega a 1024 sube de unidad
+ * ("1 MB", nunca "1024 KB"). Negativo, `NaN` o infinito → "".
+ */
+export declare const formatFileSize: (bytes: number, locale?: string) => string;
+/**
+ * URL que se puede poner en un `href`/`data`/`src` del visor: relativa, `http(s):`, `blob:` o un
+ * `data:` de imagen o PDF. Rechaza `javascript:` y el resto de los esquemas.
+ */
+export declare const isSafeFileUrl: (url: string) => boolean;
+/**
+ * Descarga un Blob con un nombre: crea una URL temporal, hace click en un `<a download>` y lo quita.
+ * La URL se revoca en el próximo tick (para que el click llegue a iniciar la descarga). Fuera del
+ * navegador no hace nada.
+ */
+export declare const downloadBlob: (blob: Blob, fileName: string) => void;

package/dist/hooks/downloadLogic.js

@@ -0,0 +1,85 @@
+//#region src/hooks/downloadLogic.ts
+var e = (e) => e.split(/[\\/]/).pop() ?? "", t = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of `;${e}`.matchAll(/;\s*([^\s=;]+)\s*=\s*("(?:[^"\\]|\\.)*"|[^;]*)/g)) {
+		let e = (n[1] ?? "").toLowerCase(), r = (n[2] ?? "").trim();
+		r.startsWith("\"") && (r = r.slice(1, -1).replace(/\\(["\\])/g, "$1")), t.has(e) || t.set(e, r);
+	}
+	return t;
+}, n = (e) => {
+	let t = /^([^']*)'[^']*'(.*)$/.exec(e);
+	if (!t) return null;
+	let n = (t[1] ?? "").toLowerCase();
+	if (n !== "utf-8" && n !== "") return null;
+	try {
+		return decodeURIComponent(t[2] ?? "");
+	} catch {
+		return null;
+	}
+}, r = (r) => {
+	if (!r) return null;
+	let i = t(r), a = i.get("filename*");
+	return e((a === void 0 ? null : n(a)) ?? i.get("filename") ?? "") || null;
+}, i = (t) => {
+	if (!t || /^(blob|data):/i.test(t)) return null;
+	let n = e((t.split(/[?#]/)[0] ?? "").replace(/^[a-z][a-z0-9+.-]*:\/\/[^/\\]*/i, ""));
+	if (!n) return null;
+	try {
+		return decodeURIComponent(n);
+	} catch {
+		return n;
+	}
+}, a = /* @__PURE__ */ new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"avif",
+	"bmp",
+	"svg",
+	"ico"
+]), o = /* @__PURE__ */ new Set([
+	"txt",
+	"log",
+	"json",
+	"md"
+]), s = /* @__PURE__ */ new Set(["text/plain", "application/json"]), c = /^(application|audio|font|image|message|model|multipart|text|video)\/[a-z0-9.+-]+$/, l = (t) => {
+	let n = (t ?? "").trim().toLowerCase();
+	if (!n) return "other";
+	let r = e(n.split(/[?#]/)[0] ?? ""), i = r.lastIndexOf("."), l = i < 0 ? "" : r.slice(i + 1);
+	if (l === "pdf") return "pdf";
+	if (a.has(l)) return "image";
+	if (o.has(l)) return "text";
+	let u = (n.split(";")[0] ?? "").trim();
+	return c.test(u) ? u === "application/pdf" ? "pdf" : u.startsWith("image/") ? "image" : s.has(u) ? "text" : "other" : "other";
+}, u = [
+	"B",
+	"KB",
+	"MB",
+	"GB",
+	"TB"
+], d = /* @__PURE__ */ new Map(), f = (e, t) => {
+	let n = `${e}|${t}`, r = d.get(n);
+	return r || (r = new Intl.NumberFormat(e, { maximumFractionDigits: t }), d.set(n, r)), r;
+}, p = (e, t = "es") => {
+	if (!Number.isFinite(e) || e < 0) return "";
+	let n = 0, r = e;
+	for (; n < u.length - 1 && r >= 1024;) r /= 1024, n++;
+	let i = 10 ** (n === 0 ? 0 : 1);
+	return Math.round(r * i) / i >= 1024 && n < u.length - 1 && (r /= 1024, n++), `${f(t, n === 0 ? 0 : 1).format(r)} ${u[n]}`;
+}, m = (e) => {
+	let t = 0, n = e.length;
+	for (; t < n && e.charCodeAt(t) <= 32;) t++;
+	for (; n > t && e.charCodeAt(n - 1) <= 32;) n--;
+	return e.slice(t, n);
+}, h = (e) => {
+	let t = m(e.replace(/[\t\n\r]/g, "")).toLowerCase(), n = /^([a-z][a-z0-9+.-]*):/.exec(t)?.[1];
+	return n === void 0 ? !0 : n === "data" ? /^data:(image\/|application\/pdf[;,])/.test(t) : n === "http" || n === "https" || n === "blob";
+}, g = (e, t) => {
+	if (typeof document > "u" || typeof URL.createObjectURL != "function") return;
+	let n = URL.createObjectURL(e), r = document.createElement("a");
+	r.href = n, r.download = t, r.style.display = "none", document.body.appendChild(r), r.click(), r.remove(), setTimeout(() => URL.revokeObjectURL(n), 0);
+};
+//#endregion
+export { g as downloadBlob, l as fileKind, r as fileNameFromContentDisposition, i as fileNameFromUrl, p as formatFileSize, h as isSafeFileUrl };