@kapiuara/ui 0.0.0-stage → 0.1.0

package/dist/components/feedback/KapiProgress.js

@@ -0,0 +1,94 @@
+"use client";
+/* empty css             */
+import { circleDash as e, clampPercent as t, formatPercent as n, progressClasses as r } from "./progressLogic.js";
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+//#region src/components/feedback/KapiProgress.tsx
+var o = {
+	sm: 36,
+	md: 56,
+	lg: 84
+}, s = {
+	sm: 4,
+	md: 6,
+	lg: 8
+};
+function c({ value: c, variant: l = "bar", tone: u = "primary", size: d = "md", label: f, showValue: p = !1, "aria-label": m, className: h, ...g }) {
+	let _ = t(c), v = r({
+		tone: u,
+		size: d,
+		variant: l,
+		className: h
+	}), y = {
+		role: "progressbar",
+		"aria-valuemin": 0,
+		"aria-valuemax": 100,
+		"aria-valuenow": Math.round(_),
+		"aria-label": typeof f == "string" ? f : m
+	};
+	if (l === "circle") {
+		let t = o[d], r = s[d], c = (t - r) / 2, { circumference: l, offset: u } = e(_, c);
+		return /* @__PURE__ */ a("div", {
+			...g,
+			className: v,
+			children: [/* @__PURE__ */ a("div", {
+				className: "kapi-progress__ring",
+				style: {
+					width: t,
+					height: t
+				},
+				...y,
+				children: [/* @__PURE__ */ a("svg", {
+					width: t,
+					height: t,
+					viewBox: `0 0 ${t} ${t}`,
+					"aria-hidden": !0,
+					children: [/* @__PURE__ */ i("circle", {
+						className: "kapi-progress__track",
+						cx: t / 2,
+						cy: t / 2,
+						r: c,
+						strokeWidth: r
+					}), /* @__PURE__ */ i("circle", {
+						className: "kapi-progress__arc",
+						cx: t / 2,
+						cy: t / 2,
+						r: c,
+						strokeWidth: r,
+						strokeDasharray: l,
+						strokeDashoffset: u,
+						transform: `rotate(-90 ${t / 2} ${t / 2})`
+					})]
+				}), p && /* @__PURE__ */ i("span", {
+					className: "kapi-progress__center",
+					children: n(_)
+				})]
+			}), f && /* @__PURE__ */ i("span", {
+				className: "kapi-progress__label",
+				children: f
+			})]
+		});
+	}
+	return /* @__PURE__ */ a("div", {
+		...g,
+		className: v,
+		children: [(f || p) && /* @__PURE__ */ a("div", {
+			className: "kapi-progress__head",
+			children: [f && /* @__PURE__ */ i("span", {
+				className: "kapi-progress__label",
+				children: f
+			}), p && /* @__PURE__ */ i("span", {
+				className: "kapi-progress__value",
+				children: n(_)
+			})]
+		}), /* @__PURE__ */ i("div", {
+			className: "kapi-progress__bar",
+			...y,
+			children: /* @__PURE__ */ i("div", {
+				className: "kapi-progress__fill",
+				style: { width: `${_}%` }
+			})
+		})]
+	});
+}
+//#endregion
+export { c as KapiProgress };

package/dist/components/feedback/KapiSkeleton.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes } from "react";
+/** Atributos nativos (`id`, `data-*`…) van al `<span>`; `style` se combina con las medidas (gana `style`). */
+export type KapiSkeletonProps = Omit<HTMLAttributes<HTMLSpanElement>, "children"> & {
+    /** Ancho: número en px o cualquier medida CSS (`"60%"`). */
+    width?: number | string;
+    /** Alto: número en px o cualquier medida CSS. */
+    height?: number | string;
+    /** Radio del borde: número en px o cualquier medida CSS. */
+    radius?: number | string;
+};
+/** Placeholder con shimmer: `{cargando ? <KapiSkeleton width="60%" height={16} /> : <Contenido />}`. */
+export declare const KapiSkeleton: ({ width, height, radius, className, style, ...rest }: KapiSkeletonProps) => import("react").JSX.Element;

package/dist/components/feedback/KapiSkeleton.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx as e } from "react/jsx-runtime";
+//#region src/components/feedback/KapiSkeleton.tsx
+var t = ({ width: t = "100%", height: n = 14, radius: r = 8, className: i, style: a, ...o }) => /* @__PURE__ */ e("span", {
+	...o,
+	className: `kapi-sk${i ? ` ${i}` : ""}`,
+	style: {
+		width: t,
+		height: n,
+		borderRadius: r,
+		...a
+	},
+	"aria-hidden": "true"
+});
+//#endregion
+export { t as KapiSkeleton };

package/dist/components/feedback/KapiToastContainer.d.ts

@@ -0,0 +1,16 @@
+import "./feedback.css";
+import { type KapiRootProps } from "../rootProps";
+import type { KapiLabelsOverride } from "../labelsLogic";
+export type KapiToastLabels = {
+    close: string;
+};
+export declare const DEFAULT_TOAST_LABELS: KapiToastLabels;
+/** `className`/`style`/`id` van a la pila de toasts (portaleada a `.kapi`). */
+export type KapiToastContainerProps = KapiRootProps & {
+    /** Etiqueta accesible del botón de cierre. Gana sobre `labels.close` ("Cerrar"). */
+    closeLabel?: string;
+    /** Textos fijos (clave `toast`). */
+    labels?: KapiLabelsOverride<KapiToastLabels> | undefined;
+};
+/** Montalo una vez en la app: apila los toasts (nunca se encilman) en `.kapi`. */
+export declare const KapiToastContainer: ({ closeLabel: closeLabelProp, labels, className, style, id }: KapiToastContainerProps) => import("react").ReactPortal | null;

package/dist/components/feedback/KapiToastContainer.js

@@ -0,0 +1,81 @@
+"use client";
+import { useLabels as e } from "../locale/KapiLocaleProvider.js";
+import { useKapiRoot as t } from "../../hooks/kapiRoot.js";
+import { joinClasses as n } from "../rootProps.js";
+/* empty css             */
+import { toastStore as r } from "./toastStore.js";
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+import { useSyncExternalStore as o } from "react";
+import { AlertTriangle as s, CheckCircle2 as c, Info as l, XCircle as u } from "lucide-react";
+import { createPortal as d } from "react-dom";
+//#region src/components/feedback/KapiToastContainer.tsx
+var f = { close: "Cerrar" }, p = {
+	success: {
+		Icon: c,
+		color: "var(--kapi-success)"
+	},
+	error: {
+		Icon: u,
+		color: "var(--kapi-danger)"
+	},
+	info: {
+		Icon: l,
+		color: "var(--kapi-info)"
+	},
+	warning: {
+		Icon: s,
+		color: "var(--kapi-warning)"
+	}
+}, m = ({ closeLabel: s, labels: c, className: l, style: u, id: m }) => {
+	let h = e("toast", f, c), g = s ?? h.close, _ = o(r.subscribe, r.getSnapshot, r.getSnapshot), v = t();
+	return v ? d(/* @__PURE__ */ i("div", {
+		id: m,
+		className: n("kapi-toasts", l),
+		style: u,
+		"aria-live": "polite",
+		children: _.map((e) => {
+			let { Icon: t, color: n } = p[e.variant];
+			return /* @__PURE__ */ a("div", {
+				className: `kapi-toast ${e.leaving ? "kapi-toast--out" : "kapi-toast--in"}`,
+				onAnimationEnd: (t) => {
+					e.leaving && t.animationName === "kapi-toast-out" && r.remove(e.id);
+				},
+				children: [
+					/* @__PURE__ */ i("span", {
+						className: `kapi-toast__icon kapi-toast__icon--${e.variant}`,
+						children: /* @__PURE__ */ i(t, {
+							size: 18,
+							strokeWidth: 2.2,
+							color: n
+						})
+					}),
+					/* @__PURE__ */ i("span", {
+						className: "kapi-toast__msg",
+						children: e.message
+					}),
+					e.action && /* @__PURE__ */ i("button", {
+						type: "button",
+						className: "kapi-toast__action",
+						onClick: () => {
+							try {
+								e.action?.onClick();
+							} finally {
+								r.dismiss(e.id);
+							}
+						},
+						children: e.action.label
+					}),
+					/* @__PURE__ */ i("button", {
+						type: "button",
+						className: "kapi-toast__x",
+						"aria-label": g,
+						onClick: () => r.dismiss(e.id),
+						children: "×"
+					})
+				]
+			}, e.id);
+		})
+	}), v) : null;
+};
+//#endregion
+export { f as DEFAULT_TOAST_LABELS, m as KapiToastContainer };

package/dist/components/feedback/KapiTour.d.ts

@@ -0,0 +1,40 @@
+import "./feedback.css";
+import { type TourStep } from "./tourLogic";
+import { type KapiRootProps } from "../rootProps";
+import type { KapiLabelsOverride } from "../labelsLogic";
+export type KapiTourLabels = {
+    next: string;
+    back: string;
+    done: string;
+    close: string;
+    of: string;
+};
+/** `className`/`style`/`id` van al popover del paso (el diálogo); la posición calculada gana sobre `style`. */
+export type KapiTourProps = KapiRootProps & {
+    /** Pasos del tour (se saltean los cuyo selector no existe). */
+    steps: readonly TourStep[];
+    /** Controlado: el tour se muestra mientras sea true. */
+    open: boolean;
+    /** Se llama al cerrar (X, Escape o "Listo") y cuando no hay pasos disponibles. */
+    onClose: () => void;
+    /**
+     * Si se pasa, al cerrar se marca como visto en localStorage con esta clave (`true` = `kapi:tour-seen`).
+     * Para aislar dos apps del mismo origen usa una clave con namespace, p. ej. `"tramites:tour-seen"`
+     * (las claves `*:tour-seen` heredan el `v2_tour_seen` viejo en la primera lectura).
+     */
+    markSeen?: boolean | string;
+    /** Textos fijos (clave `tour`). */
+    labels?: KapiLabelsOverride<KapiTourLabels> | undefined;
+};
+/**
+ * Tour guiado genérico: spotlight + popover, recalcula en resize/scroll, Escape cierra.
+ * Accesible: el popover es un diálogo modal que recibe el foco en cada paso, atrapa Tab, y al cerrar
+ * el foco vuelve a donde estaba antes de abrir.
+ */
+export declare const KapiTour: ({ steps, open, onClose, markSeen, labels, className, style, id }: KapiTourProps) => import("react").ReactPortal | null;
+/** Estado mínimo para controlar un tour: `const t = useKapiTour(); <KapiTour open={t.open} onClose={t.close} .../>`. */
+export declare const useKapiTour: (initialOpen?: boolean) => {
+    open: boolean;
+    start: () => void;
+    close: () => void;
+};

package/dist/components/feedback/KapiTour.js

@@ -0,0 +1,157 @@
+"use client";
+import { useLabels as e } from "../locale/KapiLocaleProvider.js";
+import { useKapiRoot as t } from "../../hooks/kapiRoot.js";
+import { onViewportChange as n } from "../../hooks/rafThrottle.js";
+import { usePlacement as r } from "../../hooks/usePlacement.js";
+import { joinClasses as i } from "../rootProps.js";
+import { trapTabKey as a } from "../../hooks/focusLogic.js";
+/* empty css             */
+import { TOUR_PLACEMENT as o, filterAvailableSteps as s, highlightBox as c, markTourSeen as l } from "./tourLogic.js";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+import { useCallback as f, useEffect as p, useId as m, useLayoutEffect as h, useRef as g, useState as _ } from "react";
+import { createPortal as v } from "react-dom";
+//#region src/components/feedback/KapiTour.tsx
+var y = {
+	next: "Siguiente",
+	back: "Atrás",
+	done: "Listo",
+	close: "Cerrar",
+	of: "de"
+}, b = ({ steps: b, open: x, onClose: S, markSeen: C, labels: w, className: T, style: E, id: D }) => {
+	let O = e("tour", y, w), k = t(), [A, j] = _([]), [M, N] = _(0), [P, F] = _(null), I = g(null), L = m(), R = f(() => {
+		C && l(typeof C == "string" ? C : void 0), S();
+	}, [C, S]), z = b.map((e) => e.element).join("|"), B = g(b);
+	B.current = b, p(() => {
+		if (!x) {
+			j([]);
+			return;
+		}
+		let e = s(B.current, (e) => document.querySelector(e) !== null);
+		e.length ? (j(e), N(0)) : R();
+	}, [x, z]);
+	let V = x ? A[M] : void 0;
+	h(() => {
+		if (!x) return;
+		let e = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+		return () => {
+			e?.isConnected && e.focus();
+		};
+	}, [x]), p(() => {
+		V && k && I.current?.focus();
+	}, [V, k]), h(() => {
+		if (!V) return;
+		let e = document.querySelector(V.element);
+		if (!e) {
+			F(null);
+			return;
+		}
+		e.scrollIntoView({
+			block: "nearest",
+			inline: "nearest"
+		});
+		let t = () => F(c(e.getBoundingClientRect()));
+		return t(), n(t);
+	}, [V]);
+	let { style: H, update: U } = r({
+		open: !!V && !!k,
+		anchor: () => {
+			let e = V ? document.querySelector(V.element) : null;
+			return e ? e.getBoundingClientRect() : null;
+		},
+		floatingRef: I,
+		measure: !1,
+		estimate: {
+			width: 300,
+			height: 180
+		},
+		...o,
+		width: { max: 300 },
+		hideUntilPlaced: !1
+	});
+	if (h(() => {
+		V && U();
+	}, [V, U]), p(() => {
+		if (!V) return;
+		let e = (e) => {
+			e.key === "Escape" && (e.preventDefault(), R());
+		};
+		return document.addEventListener("keydown", e), () => document.removeEventListener("keydown", e);
+	}, [V, R]), !k || !V) return null;
+	let W = M === A.length - 1;
+	return v(/* @__PURE__ */ d("div", {
+		className: "kapi-tour",
+		children: [P && /* @__PURE__ */ u("div", {
+			className: "kapi-tour__hl",
+			style: P
+		}), /* @__PURE__ */ d("div", {
+			ref: I,
+			id: D,
+			className: i("kapi-tour__pop", T),
+			style: {
+				...E,
+				...H
+			},
+			role: "dialog",
+			"aria-modal": "true",
+			"aria-label": V.title,
+			"aria-describedby": L,
+			tabIndex: -1,
+			onKeyDown: (e) => {
+				e.key === "Escape" ? (e.preventDefault(), e.stopPropagation(), R()) : a(e, I.current);
+			},
+			children: [
+				/* @__PURE__ */ u("button", {
+					type: "button",
+					className: "kapi-tour__x",
+					onClick: R,
+					"aria-label": O.close,
+					children: "×"
+				}),
+				/* @__PURE__ */ u("div", {
+					className: "kapi-tour__title",
+					children: V.title
+				}),
+				/* @__PURE__ */ u("div", {
+					className: "kapi-tour__desc",
+					id: L,
+					children: V.description
+				}),
+				/* @__PURE__ */ d("div", {
+					className: "kapi-tour__foot",
+					children: [/* @__PURE__ */ d("span", {
+						className: "kapi-tour__prog",
+						children: [
+							M + 1,
+							" ",
+							O.of,
+							" ",
+							A.length
+						]
+					}), /* @__PURE__ */ d("div", {
+						className: "kapi-tour__foot-actions",
+						children: [M > 0 && /* @__PURE__ */ u("button", {
+							type: "button",
+							className: "kapi-btn",
+							onClick: () => N(M - 1),
+							children: O.back
+						}), /* @__PURE__ */ u("button", {
+							type: "button",
+							className: "kapi-btn kapi-btn--primary",
+							onClick: () => W ? R() : N(M + 1),
+							children: W ? O.done : O.next
+						})]
+					})]
+				})
+			]
+		})]
+	}), k);
+}, x = (e = !1) => {
+	let [t, n] = _(e);
+	return {
+		open: t,
+		start: f(() => n(!0), []),
+		close: f(() => n(!1), [])
+	};
+};
+//#endregion
+export { b as KapiTour, x as useKapiTour };

package/dist/components/feedback/KapiUnsavedBar.d.ts

@@ -0,0 +1,35 @@
+import type { HTMLAttributes } from "react";
+import "./KapiUnsavedBar.css";
+import type { KapiLabelsOverride } from "../labelsLogic";
+/** Atributos nativos (`id`, `style`, `data-*`…) van a la región; `role` y `aria-label` son propios. */
+export type KapiUnsavedBarProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "role" | "aria-label"> & {
+    /** Cantidad de cambios; sin valor muestra "Cambios sin guardar". */
+    count?: number;
+    /** Click en "Descartar". */
+    onDiscard: () => void;
+    /** Click en "Guardar". */
+    onSave: () => void;
+    /** Guardando: deshabilita ambos botones y marca Guardar como ocupado. */
+    saving?: boolean;
+    /** Gana sobre `labels.discard` ("Descartar"). */
+    discardLabel?: string;
+    /** Gana sobre `labels.save` ("Guardar"). */
+    saveLabel?: string;
+    /** Texto del conteo. Default `unsavedCountLabel` ("Cambios sin guardar" / "N cambios sin guardar"). */
+    countLabel?: (count?: number) => string;
+    /** Textos fijos (nombre de la región, botones y "Guardando…"). */
+    labels?: KapiLabelsOverride<KapiUnsavedBarLabels> | undefined;
+};
+export type KapiUnsavedBarLabels = {
+    region: string;
+    saving: string;
+    discard: string;
+    save: string;
+};
+export declare const DEFAULT_UNSAVED_BAR_LABELS: KapiUnsavedBarLabels;
+/**
+ * Barra sticky de "cambios sin guardar": a la izquierda el conteo, a la derecha
+ * Descartar (ghost) y Guardar (primary). Renderizala sólo mientras haya cambios.
+ * Combinala con `useUnsavedGuard` para proteger la navegación.
+ */
+export declare const KapiUnsavedBar: ({ count, onDiscard, onSave, saving, discardLabel, saveLabel, className, countLabel, labels, ...rest }: KapiUnsavedBarProps) => import("react").JSX.Element;

package/dist/components/feedback/KapiUnsavedBar.js

@@ -0,0 +1,47 @@
+"use client";
+import { KapiButton as e } from "../inputs/KapiButton.js";
+import { useLabels as t } from "../locale/KapiLocaleProvider.js";
+import { unsavedCountLabel as n } from "./unsavedBarLogic.js";
+/* empty css                   */
+import { jsx as r, jsxs as i } from "react/jsx-runtime";
+//#region src/components/feedback/KapiUnsavedBar.tsx
+var a = {
+	region: "Cambios sin guardar",
+	saving: "Guardando…",
+	discard: "Descartar",
+	save: "Guardar"
+}, o = ({ count: o, onDiscard: s, onSave: c, saving: l = !1, discardLabel: u, saveLabel: d, className: f, countLabel: p = n, labels: m, ...h }) => {
+	let g = t("unsavedBar", a, m);
+	return /* @__PURE__ */ i("div", {
+		...h,
+		className: `kapi-unsaved-bar${f ? ` ${f}` : ""}`,
+		role: "region",
+		"aria-label": g.region,
+		children: [/* @__PURE__ */ i("span", {
+			className: "kapi-unsaved-bar__label",
+			role: "status",
+			children: [/* @__PURE__ */ r("span", {
+				className: "kapi-unsaved-bar__dot",
+				"aria-hidden": "true"
+			}), p(o)]
+		}), /* @__PURE__ */ i("div", {
+			className: "kapi-unsaved-bar__actions",
+			children: [/* @__PURE__ */ r(e, {
+				size: "sm",
+				variant: "ghost",
+				onClick: s,
+				disabled: l,
+				children: u ?? g.discard
+			}), /* @__PURE__ */ r(e, {
+				size: "sm",
+				variant: "primary",
+				onClick: c,
+				disabled: l,
+				"aria-busy": l || void 0,
+				children: l ? g.saving : d ?? g.save
+			})]
+		})]
+	});
+};
+//#endregion
+export { a as DEFAULT_UNSAVED_BAR_LABELS, o as KapiUnsavedBar };

package/dist/components/feedback/bulkBarLogic.d.ts

@@ -0,0 +1,2 @@
+/** Etiqueta del conteo de filas seleccionadas ("filas" es femenino). */
+export declare const selectedCountLabel: (n: number) => string;

package/dist/components/feedback/bulkBarLogic.js

@@ -0,0 +1,7 @@
+//#region src/components/feedback/bulkBarLogic.ts
+var e = (e) => {
+	let t = Number.isFinite(e) ? Math.max(0, Math.trunc(e)) : 0;
+	return t === 1 ? "1 seleccionada" : `${t} seleccionadas`;
+};
+//#endregion
+export { e as selectedCountLabel };

package/dist/components/feedback/countdownLogic.d.ts

@@ -0,0 +1,74 @@
+/** Pure time math for KapiCountdown. No DOM, no clock access: `now` is always injected. */
+export type KapiCountdownTarget = Date | string | number;
+/** Coarse state of a deadline, derived from the remaining milliseconds. */
+export type KapiCountdownBucket = "far" | "near" | "overdue";
+/** Badge color roles a bucket can map to (mirrors KapiBadge variants). */
+export type KapiCountdownTone = "neutral" | "primary" | "success" | "info" | "warning" | "danger";
+export type KapiCountdownToneMap = Record<KapiCountdownBucket, KapiCountdownTone>;
+export type CountdownBreakdown = {
+    /** True when the target is now or in the past (remaining <= 0). */
+    overdue: boolean;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+};
+export declare const SECOND_MS = 1000;
+export declare const MINUTE_MS: number;
+export declare const HOUR_MS: number;
+export declare const DAY_MS: number;
+/** A deadline within this window is "near" unless overridden. */
+export declare const DEFAULT_NEAR_MS: number;
+export declare const DEFAULT_TONES: KapiCountdownToneMap;
+/** Target to epoch milliseconds. Returns `NaN` for anything unparseable. */
+export declare const parseTarget: (to: KapiCountdownTarget) => number;
+/** Milliseconds left until `target` (negative once passed). `NaN` for an invalid target. */
+export declare const remainingMs: (target: KapiCountdownTarget, now: number) => number;
+/**
+ * Splits a duration into d/h/m/s. Uses the absolute value (the sign only sets `overdue`)
+ * and floors, so partial seconds never round a deadline up.
+ */
+export declare const breakdown: (ms: number) => CountdownBreakdown;
+/** Which bucket a remaining time falls in. `nearMs` itself is still "near"; <= 0 is overdue. */
+export declare const bucketFor: (ms: number, nearMs?: number) => KapiCountdownBucket;
+/** Merges a partial tone override over the defaults. */
+export declare const resolveTones: (tones?: Partial<KapiCountdownToneMap>) => KapiCountdownToneMap;
+/** Ticking clock label: `HH:MM:SS`, prefixed by `Nd ` when a day or more remains. Zero when overdue. */
+export declare const formatClock: (ms: number) => string;
+/** Forms of one unit keyed by `Intl.PluralRules` category; `other` is the fallback. */
+export type KapiCountdownUnitForms = {
+    one: string;
+    other: string;
+} & Partial<Record<Intl.LDMLPluralRule, string>>;
+/** Locale used for plural rules when none is given (matches the Spanish default copy). */
+export declare const DEFAULT_COUNTDOWN_LOCALE = "es";
+/**
+ * Human duration using the two most significant units: "3 días y 4 horas",
+ * "5 minutos y 2 segundos", "7 segundos". Zero gives "0 segundos". Unit words and the
+ * conjunction come from `labels` (missing keys use the Spanish defaults); the plural form is picked
+ * with `Intl.PluralRules(locale)`, or `es` for the default Spanish unit words.
+ */
+export declare const formatDuration: (ms: number, labels?: KapiCountdownLabels, locale?: string) => string;
+export type KapiCountdownLabels = {
+    /** Chip text once the deadline passed (shown alone when exactly zero). */
+    overdue: string;
+    /** Prefix of the overdue elapsed time, e.g. "Venció hace". */
+    overduePrefix: string;
+    /** Prefix of the tooltip while running, e.g. "Faltan". */
+    remainingPrefix: string;
+    day?: KapiCountdownUnitForms;
+    hour?: KapiCountdownUnitForms;
+    minute?: KapiCountdownUnitForms;
+    second?: KapiCountdownUnitForms;
+    /** Joins the two units, e.g. "y" in "3 días y 4 horas". */
+    conjunction?: string;
+    /** Remaining time under one second, e.g. "menos de 1 segundo". */
+    lessThanSecond?: string;
+};
+export declare const DEFAULT_COUNTDOWN_LABELS: Required<KapiCountdownLabels>;
+/** Alias kept for existing imports. */
+export declare const DEFAULT_LABELS: Required<KapiCountdownLabels>;
+/** Short chip text: the ticking clock while running, "Vencido" once the deadline passed. */
+export declare const chipText: (ms: number, labels?: KapiCountdownLabels) => string;
+/** Full sentence for the tooltip / accessible name. */
+export declare const describe: (ms: number, labels?: KapiCountdownLabels, locale?: string) => string;

package/dist/components/feedback/countdownLogic.js

@@ -0,0 +1,70 @@
+import { withLabels as e } from "../labelsLogic.js";
+//#region src/components/feedback/countdownLogic.ts
+var t = 1e3, n = 60 * t, r = 60 * n, i = 24 * r, a = i, o = {
+	far: "info",
+	near: "warning",
+	overdue: "danger"
+}, s = (e) => e instanceof Date ? e.getTime() : typeof e == "number" ? Number.isFinite(e) ? e : NaN : typeof e == "string" && e.trim() !== "" ? new Date(e).getTime() : NaN, c = (e, t) => s(e) - t, l = (e) => {
+	let a = Number.isFinite(e) ? e : 0, o = Math.floor(Math.abs(a) / t) * t;
+	return {
+		overdue: a <= 0,
+		days: Math.floor(o / i),
+		hours: Math.floor(o % i / r),
+		minutes: Math.floor(o % r / n),
+		seconds: Math.floor(o % n / t)
+	};
+}, u = (e, t = a) => !Number.isFinite(e) || e <= 0 ? "overdue" : e <= t ? "near" : "far", d = (e) => ({
+	...o,
+	...e
+}), f = (e) => String(e).padStart(2, "0"), p = (e) => {
+	let t = l(e);
+	if (t.overdue) return "00:00:00";
+	let n = `${f(t.hours)}:${f(t.minutes)}:${f(t.seconds)}`;
+	return t.days > 0 ? `${t.days}d ${n}` : n;
+}, m = "es", h = /* @__PURE__ */ new Map(), g = (e) => {
+	let t = h.get(e);
+	if (!t) {
+		try {
+			t = new Intl.PluralRules(e);
+		} catch {
+			t = new Intl.PluralRules("es");
+		}
+		h.set(e, t);
+	}
+	return t;
+}, _ = (t) => t === b ? b : e(b, t), v = (e, t, n, r) => {
+	let i = n[t];
+	return `${e} ${i[g(i === b[t] ? "es" : r).select(e)] ?? i.other}`;
+}, y = (e, t = x, n = "es") => {
+	let r = l(e), i = _(t), a = (e, t) => v(e, t, i, n), o = [];
+	return r.days > 0 ? (o.push(a(r.days, "day")), r.hours > 0 && o.push(a(r.hours, "hour"))) : r.hours > 0 ? (o.push(a(r.hours, "hour")), r.minutes > 0 && o.push(a(r.minutes, "minute"))) : r.minutes > 0 ? (o.push(a(r.minutes, "minute")), r.seconds > 0 && o.push(a(r.seconds, "second"))) : o.push(a(r.seconds, "second")), o.join(` ${i.conjunction} `);
+}, b = {
+	overdue: "Vencido",
+	overduePrefix: "Venció hace",
+	remainingPrefix: "Faltan",
+	day: {
+		one: "día",
+		other: "días"
+	},
+	hour: {
+		one: "hora",
+		other: "horas"
+	},
+	minute: {
+		one: "minuto",
+		other: "minutos"
+	},
+	second: {
+		one: "segundo",
+		other: "segundos"
+	},
+	conjunction: "y",
+	lessThanSecond: "menos de 1 segundo"
+}, x = b, S = (e, t = x) => u(e) === "overdue" ? t.overdue : p(e), C = (e, t = x, n = "es") => {
+	if (!Number.isFinite(e)) return "";
+	if (e <= 0) return Math.floor(Math.abs(e) / 1e3) === 0 ? t.overdue : `${t.overduePrefix} ${y(e, t, n)}`;
+	let r = e < 1e3 ? t.lessThanSecond ?? b.lessThanSecond : y(e, t, n);
+	return `${t.remainingPrefix} ${r}`;
+};
+//#endregion
+export { i as DAY_MS, b as DEFAULT_COUNTDOWN_LABELS, m as DEFAULT_COUNTDOWN_LOCALE, x as DEFAULT_LABELS, a as DEFAULT_NEAR_MS, o as DEFAULT_TONES, r as HOUR_MS, n as MINUTE_MS, t as SECOND_MS, l as breakdown, u as bucketFor, S as chipText, C as describe, p as formatClock, y as formatDuration, s as parseTarget, c as remainingMs, d as resolveTones };