@softdin/portal-admin 0.0.0-stage → 0.2.0

package/dist-lib/chunks/chat.service-C7ZQf4w3.js

@@ -0,0 +1,241 @@
+import { t as api } from "./api-M7D1c3IT.js";
+//#region src/services/chat.service.ts
+/** Minutos hábiles → «45 min», «3 h 20 min». */
+function duracion(min) {
+	if (min === null) return "—";
+	if (min < 60) return `${min} min`;
+	const h = Math.floor(min / 60);
+	const m = min % 60;
+	return m ? `${h} h ${m} min` : `${h} h`;
+}
+var chatService = {
+	async resumen() {
+		const { data } = await api.get("/chat/resumen");
+		return data.data;
+	},
+	async conversaciones(vista, temaId, clienteInternoId = null) {
+		const { data } = await api.get("/chat/conversaciones", { params: {
+			vista,
+			tema_id: temaId ?? void 0,
+			cliente_interno_id: clienteInternoId ?? void 0
+		} });
+		return data.data;
+	},
+	async conversacion(id) {
+		const { data } = await api.get(`/chat/conversaciones/${id}`);
+		return data.data;
+	},
+	async responder(id, cuerpo, interno) {
+		const { data } = await api.post(`/chat/conversaciones/${id}/mensajes`, {
+			cuerpo,
+			interno
+		});
+		return data.data;
+	},
+	async tomar(id) {
+		const { data } = await api.post(`/chat/conversaciones/${id}/tomar`);
+		return data.data;
+	},
+	async asignar(id, usuarioId) {
+		const { data } = await api.post(`/chat/conversaciones/${id}/asignar`, { usuario_id: usuarioId });
+		return data.data;
+	},
+	/** Devuelve null si, tras pasarla a otro tema, el usuario ya no la ve. */
+	async reasignar(id, cambio) {
+		const { data } = await api.post(`/chat/conversaciones/${id}/reasignar`, cambio);
+		return data.data;
+	},
+	async esperando(id) {
+		const { data } = await api.post(`/chat/conversaciones/${id}/esperando`);
+		return data.data;
+	},
+	async resolver(id, comentario) {
+		const { data } = await api.post(`/chat/conversaciones/${id}/resolver`, { comentario });
+		return data.data;
+	},
+	async configuracion() {
+		const { data } = await api.get("/chat/configuracion");
+		return data.data;
+	},
+	async guardarConfiguracion(c) {
+		const { clientes_internos: _, ...cuerpo } = c;
+		const { data } = await api.put("/chat/configuracion", cuerpo);
+		return data.data;
+	},
+	/** Ajuste propio de un cliente interno (solo admin). Responde la configuración completa. */
+	async ajustarClienteInterno(clienteInternoId, ajuste) {
+		const { data } = await api.put(`/chat/configuracion/clientes-internos/${clienteInternoId}`, {
+			activo: ajuste.activo,
+			horario: ajuste.horario,
+			mensaje_fuera_horario: ajuste.mensaje_fuera_horario
+		});
+		return data.data;
+	},
+	/** Quita el ajuste: el cliente interno vuelve a lo general. */
+	async heredarClienteInterno(clienteInternoId) {
+		const { data } = await api.delete(`/chat/configuracion/clientes-internos/${clienteInternoId}`);
+		return data.data;
+	},
+	async temas() {
+		const { data } = await api.get("/chat/temas");
+		return data.data;
+	},
+	async crearTema(t) {
+		const { data } = await api.post("/chat/temas", t);
+		return data.data;
+	},
+	async actualizarTema(id, t) {
+		const { data } = await api.patch(`/chat/temas/${id}`, t);
+		return data.data;
+	},
+	async personas() {
+		const { data } = await api.get("/chat/personas");
+		return data.data;
+	},
+	async actualizarPersona(id, p) {
+		const { data } = await api.put(`/chat/personas/${id}`, p);
+		return data.data;
+	},
+	/** El propio usuario: disponible o no para la asignación automática. */
+	async marcarDisponible(disponible) {
+		await api.put("/chat/disponible", { disponible });
+	},
+	async respuestas() {
+		const { data } = await api.get("/chat/respuestas");
+		return data.data;
+	},
+	async guardarRespuesta(r) {
+		const cuerpo = {
+			titulo: r.titulo,
+			cuerpo: r.cuerpo,
+			tema_id: r.tema_id ?? null
+		};
+		const { data } = r.id ? await api.patch(`/chat/respuestas/${r.id}`, cuerpo) : await api.post("/chat/respuestas", cuerpo);
+		return data.data;
+	},
+	async borrarRespuesta(id) {
+		await api.delete(`/chat/respuestas/${id}`);
+	},
+	/** Con `clienteInternoId`, solo las conversaciones de los empleados de ese cliente interno. */
+	async informe(desde, hasta, clienteInternoId = null) {
+		const { data } = await api.get("/chat/informe", { params: {
+			desde,
+			hasta,
+			cliente_interno_id: clienteInternoId ?? void 0
+		} });
+		return data.data;
+	},
+	/** Con `clienteInternoId`, los generales más los de ese cliente; sin él, todos. */
+	async conocimiento(clienteInternoId = null) {
+		const { data } = await api.get("/chat/conocimiento", { params: { cliente_interno_id: clienteInternoId ?? void 0 } });
+		return data.data;
+	},
+	async guardarArticulo(a) {
+		const cuerpo = {
+			titulo: a.titulo,
+			contenido: a.contenido,
+			tema_id: a.tema_id ?? null,
+			cliente_interno_id: a.cliente_interno_id ?? null,
+			visible_en_faq: a.visible_en_faq,
+			activo: a.activo
+		};
+		const { data } = a.id ? await api.patch(`/chat/conocimiento/${a.id}`, cuerpo) : await api.post("/chat/conocimiento", cuerpo);
+		return data.data;
+	},
+	async borrarArticulo(id) {
+		await api.delete(`/chat/conocimiento/${id}`);
+	}
+};
+var ESTADOS_CONVERSACION = {
+	ia: {
+		texto: "Con el asistente",
+		clase: "estado-info"
+	},
+	resuelta_ia: {
+		texto: "Resuelta por el asistente",
+		clase: "estado-ok"
+	},
+	sin_asignar: {
+		texto: "Sin asignar",
+		clase: "estado-alerta"
+	},
+	asignada: {
+		texto: "Asignada",
+		clase: "estado-info"
+	},
+	esperando_empleado: {
+		texto: "Esperando al empleado",
+		clase: "estado-neutro"
+	},
+	resuelta: {
+		texto: "Resuelta",
+		clase: "estado-ok"
+	},
+	cerrada: {
+		texto: "Cerrada",
+		clase: "estado-neutro"
+	}
+};
+var MOTIVOS_ESCALAMIENTO = {
+	empleado_pidio: "El empleado pidió hablar con una persona",
+	ia_no_sabe: "El asistente no tenía la respuesta",
+	insatisfaccion: "El empleado no quedó satisfecho con el asistente",
+	tema_sensible: "Tema sensible: el asistente no leyó el mensaje",
+	decision: "Pide algo que una persona debe decidir",
+	ia_no_disponible: "Consulta directa a RRHH"
+};
+/** Días del horario de atención: 1 = lunes … 7 = domingo. */
+var DIAS_SEMANA = [
+	{
+		n: 1,
+		texto: "Lun"
+	},
+	{
+		n: 2,
+		texto: "Mar"
+	},
+	{
+		n: 3,
+		texto: "Mié"
+	},
+	{
+		n: 4,
+		texto: "Jue"
+	},
+	{
+		n: 5,
+		texto: "Vie"
+	},
+	{
+		n: 6,
+		texto: "Sáb"
+	},
+	{
+		n: 7,
+		texto: "Dom"
+	}
+];
+/** «Lun, Mar, Mié · 08:00–17:00». */
+function textoHorario(h) {
+	return `${DIAS_SEMANA.filter((d) => h.dias.includes(d.n)).map((d) => d.texto).join(", ") || "Ningún día"} · ${h.desde}–${h.hasta}`;
+}
+/** Fecha y hora cortas en la zona del navegador. */
+function fechaHora(iso) {
+	if (!iso) return "—";
+	return new Date(iso).toLocaleString("es-CO", {
+		day: "numeric",
+		month: "short",
+		hour: "numeric",
+		minute: "2-digit"
+	});
+}
+/** «en 2 h», «hace 35 min»: para el plazo de respuesta. */
+function relativo(iso, ahora = Date.now()) {
+	if (!iso) return "—";
+	const min = Math.round((new Date(iso).getTime() - ahora) / 6e4);
+	const abs = Math.abs(min);
+	const texto = abs < 60 ? `${abs} min` : abs < 2880 ? `${Math.round(abs / 60)} h` : `${Math.round(abs / 1440)} días`;
+	return min >= 0 ? `en ${texto}` : `hace ${texto}`;
+}
+//#endregion
+export { duracion as a, textoHorario as c, chatService as i, ESTADOS_CONVERSACION as n, fechaHora as o, MOTIVOS_ESCALAMIENTO as r, relativo as s, DIAS_SEMANA as t };

package/dist-lib/chunks/cliente-interno.store-De39VsEE.js

@@ -0,0 +1,203 @@
+import { t as api } from "./api-M7D1c3IT.js";
+import { t as useAuthStore } from "./auth.store-BrGKZg-7.js";
+import { defineStore } from "pinia";
+import { computed, ref, watch } from "vue";
+//#region src/services/portal-empleado.service.ts
+var portalSolicitudesService = {
+	/** Con `clienteInterno`, solo las de los empleados de ese cliente interno; sin él, todo el tenant. */
+	async listar(estado, clienteInterno = null) {
+		const params = {};
+		if (estado) params.estado = estado;
+		if (clienteInterno !== null) params.cliente_interno_id = clienteInterno;
+		const { data } = await api.get("/solicitudes", { params });
+		return data.data;
+	},
+	/**
+	* Viaja firmado a SoftDIN, donde vive la novedad: al aprobar se activa; al no
+	* aprobar queda inactiva y el comentario le llega al empleado.
+	*/
+	async vistoBueno(id, aprueba, comentario) {
+		await api.post(`/solicitudes/${id}/visto-bueno`, {
+			aprueba,
+			comentario
+		});
+	}
+};
+/**
+* `id` es siempre el del tipo del tenant. Con `clienteInterno`, se ve y se cambia lo de los
+* empleados de ese cliente interno: cambiarlo le crea su propia configuración, que prevalece.
+*/
+var portalTiposService = {
+	async listar(clienteInterno = null) {
+		const params = clienteInterno === null ? {} : { cliente_interno_id: clienteInterno };
+		const { data } = await api.get("/tipos-solicitud", { params });
+		return data.data;
+	},
+	async actualizar(id, cambios, clienteInterno = null) {
+		const cuerpo = clienteInterno === null ? cambios : {
+			...cambios,
+			cliente_interno_id: clienteInterno
+		};
+		const { data } = await api.patch(`/tipos-solicitud/${id}`, cuerpo);
+		return data.data;
+	},
+	/** El cliente interno vuelve a usar lo de todo el tenant para este tipo. */
+	async heredar(id, clienteInterno) {
+		const { data } = await api.delete(`/tipos-solicitud/${id}/cliente-interno/${clienteInterno}`);
+		return data.data;
+	}
+};
+var portalEmpleadosService = {
+	/** Empleados que SoftDIN publicó al portal; busca por nombre o documento (máximo 100). */
+	async buscar(buscar, clienteInterno = null) {
+		const params = {};
+		if (buscar.trim()) params.buscar = buscar.trim();
+		if (clienteInterno !== null) params.cliente_interno = clienteInterno;
+		const { data } = await api.get("/empleados", { params });
+		return data.data;
+	},
+	/** Catálogo de clientes internos del tenant que envió SoftDIN (también los que aún no tienen empleados). */
+	async clientesInternos() {
+		const { data } = await api.get("/clientes-internos");
+		return data.data;
+	},
+	async invitar(empleoId, canal) {
+		const { data } = await api.post(`/empleados/${empleoId}/invitacion`, { canal });
+		return data.data;
+	}
+};
+//#endregion
+//#region src/stores/cliente-interno.store.ts
+/**
+* Cliente interno elegido en la barra superior: un solo selector para todas las pestañas.
+* `null` = «Todo el tenant». La lista es el catálogo de clientes internos que SoftDIN envió
+* al tenant (también los que aún no tienen empleados). La elección se recuerda por tenant en
+* este navegador; si el cliente guardado ya no está en la lista, se vuelve a todo el tenant.
+*
+* Con alcance por cliente (SSO desde softdin-tenant, `auth.clientesInternos` con lista) el
+* selector ofrece solo los permitidos y no «Todo el tenant»: la elección es siempre uno de
+* ellos. `lista` sigue siendo el catálogo completo, para poner nombre a lo que se consulta.
+*/
+var PREFIJO = "softdin_portal_tenant_cliente_interno_";
+function leerGuardado(tenant) {
+	try {
+		const crudo = localStorage.getItem(PREFIJO + tenant);
+		const id = crudo === null ? NaN : Number(crudo);
+		return Number.isInteger(id) && id > 0 ? id : null;
+	} catch {
+		return null;
+	}
+}
+function guardar(tenant, id) {
+	try {
+		if (id === null) localStorage.removeItem(PREFIJO + tenant);
+		else localStorage.setItem(PREFIJO + tenant, String(id));
+	} catch {}
+}
+var useClienteInternoStore = defineStore("portal-cliente-interno", () => {
+	const auth = useAuthStore();
+	const lista = ref([]);
+	const cargada = ref(false);
+	/** Ids permitidos, o `null` sin restricción. */
+	const permitidos = computed(() => auth.clientesInternos ?? null);
+	/** Si el usuario solo puede trabajar en algunos clientes internos. */
+	const restringido = computed(() => permitidos.value !== null);
+	/**
+	* Restringido a ninguno (`clientes_internos: []`): puede consultar todo el tenant, pero no
+	* escribir en ningún cliente interno. El selector ofrece solo «Todo el tenant».
+	*/
+	const ninguno = computed(() => permitidos.value !== null && permitidos.value.length === 0);
+	/**
+	* Lo que ofrece el selector de la barra (sin «Todo el tenant», que lo pone la vista): los de
+	* `clientes_internos` y, además, ninguno que `GET rrhh/clientes-internos` marque `permitido: false`.
+	*/
+	const opciones = computed(() => {
+		const ids = permitidos.value;
+		return lista.value.filter((c) => c.permitido !== false && (ids === null || ids.includes(c.id)));
+	});
+	/**
+	* La elección válida más parecida a `id`: sin restricción, `id` si está en la lista (o
+	* mientras la lista no llega) y si no `null`; con restricción, `id` si es de los permitidos
+	* y si no el primero de ellos.
+	*/
+	function validar(id) {
+		const ids = permitidos.value;
+		if (ids === null) {
+			if (id === null) return null;
+			return !cargada.value || opciones.value.some((c) => c.id === id) ? id : null;
+		}
+		const candidatos = cargada.value ? opciones.value.map((c) => c.id) : ids;
+		return id !== null && candidatos.includes(id) ? id : candidatos[0] ?? null;
+	}
+	const seleccionado = ref(validar(auth.cliente ? leerGuardado(auth.cliente.id) : null));
+	/** Tenant de la lista cargada (o en camino). */
+	let tenantCargado = null;
+	let enCurso = null;
+	/** Carga la lista del tenant de la sesión; una sola vez por tenant salvo `forzar`. */
+	function cargar(forzar = false) {
+		const tenant = auth.cliente?.id ?? null;
+		if (tenant === null) {
+			reiniciar();
+			return Promise.resolve();
+		}
+		if (!forzar && tenantCargado === tenant) return enCurso ?? Promise.resolve();
+		tenantCargado = tenant;
+		const promesa = (async () => {
+			let nueva = [];
+			try {
+				nueva = await portalEmpleadosService.clientesInternos();
+			} catch {}
+			if (auth.cliente?.id !== tenant) return;
+			lista.value = nueva;
+			cargada.value = true;
+			seleccionado.value = validar(leerGuardado(tenant));
+		})();
+		enCurso = promesa;
+		promesa.finally(() => {
+			if (enCurso === promesa) enCurso = null;
+		});
+		return promesa;
+	}
+	/** Cambia la elección (null = todo el tenant) y la recuerda para este tenant. */
+	function elegir(id) {
+		const valido = validar(id !== null && lista.value.some((c) => c.id === id) ? id : null);
+		seleccionado.value = valido;
+		if (auth.cliente) guardar(auth.cliente.id, valido);
+	}
+	function nombre(id) {
+		if (id == null) return "Todo el tenant";
+		return lista.value.find((c) => c.id === id)?.nombre ?? `Cliente ${id}`;
+	}
+	function reiniciar() {
+		lista.value = [];
+		seleccionado.value = null;
+		cargada.value = false;
+		tenantCargado = null;
+		enCurso = null;
+	}
+	watch(() => auth.cliente?.id ?? null, (tenant, antes) => {
+		if (tenant === antes) return;
+		reiniciar();
+		if (tenant !== null) {
+			seleccionado.value = validar(leerGuardado(tenant));
+			cargar();
+		}
+	});
+	watch(() => permitidos.value === null ? null : permitidos.value.join(","), () => {
+		if (auth.cliente) seleccionado.value = validar(seleccionado.value);
+	});
+	return {
+		lista,
+		opciones,
+		restringido,
+		ninguno,
+		seleccionado,
+		cargada,
+		cargar,
+		elegir,
+		nombre,
+		reiniciar
+	};
+});
+//#endregion
+export { portalTiposService as i, portalEmpleadosService as n, portalSolicitudesService as r, useClienteInternoStore as t };

package/dist-lib/chunks/homologacion-CoeHD7cB.js

@@ -0,0 +1,131 @@
+//#region src/lib/homologacion.ts
+/** Grupos de la pantalla «Homologación», en el orden en que se muestran. */
+var GRUPOS_HOMOLOGACION = [
+	{
+		grupo: "incapacidad",
+		titulo: "Incapacidad"
+	},
+	{
+		grupo: "licencia",
+		titulo: "Licencias"
+	},
+	{
+		grupo: "vacaciones",
+		titulo: "Vacaciones"
+	},
+	{
+		grupo: "permiso",
+		titulo: "Permisos"
+	},
+	{
+		grupo: "tipo",
+		titulo: "Tipos de solicitud nuevos"
+	}
+];
+/** Siglas de las variables que exige la PILA para lo del portal (softdin/servicio, `EnumVariablesSistema`). */
+var SIGLAS_VARIABLE = {
+	45: "IGE",
+	46: "IRP",
+	47: "LMA",
+	48: "SLN",
+	106: "LRM",
+	134: "LPA"
+};
+/** `IGE (45)`; si no es una de las conocidas, el nombre que mande SoftDIN con algún concepto de esa variable. */
+function nombreVariable(variable, conceptos = []) {
+	if (variable === null || variable === void 0) return "—";
+	const sigla = SIGLAS_VARIABLE[variable] ?? conceptos.find((c) => c.variable === variable)?.variable_nombre;
+	return sigla ? `${sigla} (${variable})` : `Variable ${variable}`;
+}
+/** Texto del concepto en el combo: código – nombre – variable. */
+function textoConcepto(c, conceptos = []) {
+	const variable = c.variable_nombre ?? (c.variable !== null ? nombreVariable(c.variable, conceptos) : null);
+	return [
+		c.codigo,
+		c.nombre,
+		variable
+	].filter((x) => x !== null && x !== "").join(" – ");
+}
+/**
+* Aviso (no bloquea) cuando el concepto elegido no liquida con la variable que exige la PILA para la fila, p. ej. una
+* incapacidad laboral (IRP) homologada con un concepto IGE. SoftDIN guarda la misma advertencia al guardar.
+*/
+function avisoVariable(fila, concepto, conceptos = []) {
+	if (!concepto || fila.variable_esperada === null || fila.variable_esperada === void 0) return null;
+	if (concepto.variable !== null && Number(concepto.variable) === Number(fila.variable_esperada)) return null;
+	const tiene = concepto.variable === null ? "no tiene variable de la PILA" : `liquida como ${nombreVariable(concepto.variable, conceptos)}`;
+	return `«${concepto.codigo} – ${concepto.nombre}» ${tiene}, pero la PILA espera ${nombreVariable(fila.variable_esperada, conceptos)} para «${fila.nombre}». Se puede guardar: queda la advertencia en SoftDIN.`;
+}
+/** Los tipos de solicitud que crea el administrador del portal llevan el prefijo `t_`. */
+function esTipoNuevo(tipo) {
+	return tipo.startsWith("t_");
+}
+function tipoDeClave(clave) {
+	return clave.startsWith("tipo:") ? clave.slice(5) : null;
+}
+/** Cuándo pide soporte un tipo de solicitud nuevo, para las tablas. */
+function soporteDeTipoNuevo(t) {
+	if (!t.requiere_soporte) return "Sin soporte";
+	if (t.plazo_soporte_dias === null || t.plazo_soporte_dias === void 0) return "Soporte obligatorio al radicar";
+	return `Soporte: al radicar o dentro de los ${t.plazo_soporte_dias} días siguientes`;
+}
+var UNIDADES_PERMISO = [
+	{
+		valor: "horas",
+		texto: "Horas"
+	},
+	{
+		valor: "dias_habiles",
+		texto: "Días hábiles"
+	},
+	{
+		valor: "dias_calendario",
+		texto: "Días calendario"
+	}
+];
+var PERIODOS_TOPE = [
+	{
+		valor: "evento",
+		texto: "Por cada permiso"
+	},
+	{
+		valor: "dia",
+		texto: "Por día"
+	},
+	{
+		valor: "semestre",
+		texto: "Por semestre"
+	},
+	{
+		valor: "anio",
+		texto: "Por año"
+	}
+];
+/** Líneas de parentesco (Código Civil, arts. 35 a 50) y el grado máximo que se puede pedir en cada una. */
+var LINEAS_PARENTESCO = [
+	{
+		linea: "consanguinidad",
+		texto: "Consanguinidad",
+		maximo: 4
+	},
+	{
+		linea: "afinidad",
+		texto: "Afinidad",
+		maximo: 2
+	},
+	{
+		linea: "civil",
+		texto: "Civil (adopción, crianza)",
+		maximo: 2
+	}
+];
+/**
+* El permiso sale de la plantilla de la ley (tal cual o ajustado): se mejora, no se empeora, y solo se ajustan
+* nombre, tope, soporte y si está activo. Los propios (del cliente o creados en el portal) se cambian completos.
+*/
+function esPermisoDeLey(p) {
+	if (p.origen) return p.origen !== "propio";
+	return p.legal === true;
+}
+//#endregion
+export { avisoVariable as a, nombreVariable as c, tipoDeClave as d, UNIDADES_PERMISO as i, soporteDeTipoNuevo as l, LINEAS_PARENTESCO as n, esPermisoDeLey as o, PERIODOS_TOPE as r, esTipoNuevo as s, GRUPOS_HOMOLOGACION as t, textoConcepto as u };

package/dist-lib/chunks/portal-empleado-6KQrnsQJ.js

@@ -0,0 +1,120 @@
+//#region src/lib/portal-empleado.ts
+/** Estado de una solicitud del portal, como lo ve nómina. */
+var ESTADOS_SOLICITUD_PORTAL = {
+	recibida: {
+		texto: "Recibida",
+		clase: "estado-neutro"
+	},
+	en_aprobacion: {
+		texto: "En aprobación",
+		clase: "estado-espera"
+	},
+	pendiente_visto_bueno: {
+		texto: "Pendiente de visto bueno",
+		clase: "estado-espera"
+	},
+	aprobada: {
+		texto: "Aprobada",
+		clase: "estado-ok"
+	},
+	rechazada: {
+		texto: "Rechazada",
+		clase: "estado-error"
+	},
+	rechazada_nomina: {
+		texto: "Sin visto bueno de nómina",
+		clase: "estado-error"
+	},
+	cancelada: {
+		texto: "Cancelada por el empleado",
+		clase: "estado-neutro"
+	}
+};
+/** `2026-11-10` o `2026-11-10 00:00:00` → `10/11/2026`. */
+function fechaCorta(valor) {
+	if (!valor) return "—";
+	const [a, m, d] = valor.slice(0, 10).split("-");
+	return a && m && d ? `${d}/${m}/${a}` : valor;
+}
+/**
+* Novedad que SoftDIN crea al aprobar, por tipo. Es informativo: el empleado
+* elige el concepto entre los que SoftDIN tiene configurados para su grupo de
+* nómina, y la configuración vive allá.
+*/
+function conceptoDeTipo(tipo) {
+	switch (tipo) {
+		case "permiso": return "La del concepto que elige el empleado: licencia remunerada (LRM) o no remunerada (SLN) de su grupo de nómina";
+		case "licencia": return "Licencia no remunerada (SLN)";
+		case "vacaciones": return "Ninguna: se liquida en su propio formulario, con el concepto que eligió el empleado";
+		case "certificado": return "Ninguna: Recursos Humanos la atiende en Certificados adjuntando el PDF";
+		case "incapacidad": return "Incapacidad de origen común (IGE) o laboral (IRP), según indique el empleado; se crea al radicar, inactiva hasta el visto bueno";
+		case "licencia_maternidad": return "Licencia de maternidad (LMA); se crea al radicar, inactiva hasta el visto bueno";
+		case "licencia_paternidad": return "Licencia de paternidad (LPA); se crea al radicar, inactiva hasta el visto bueno";
+		default: return "—";
+	}
+}
+/** Nombre legible del tipo (el que trae el portal en minúsculas y con guion bajo). */
+var NOMBRES_TIPO_SOLICITUD = {
+	vacaciones: "Vacaciones",
+	permiso: "Permiso",
+	licencia: "Licencia",
+	certificado: "Certificado",
+	incapacidad: "Incapacidad",
+	licencia_maternidad: "Licencia de maternidad",
+	licencia_paternidad: "Licencia de paternidad"
+};
+function nombreTipoSolicitud(tipo) {
+	return NOMBRES_TIPO_SOLICITUD[tipo] ?? tipo.charAt(0).toUpperCase() + tipo.slice(1).replace(/_/g, " ");
+}
+/** Incapacidad y licencias: llevan soporte (certificado médico, registro civil) que nómina revisa en SoftDIN. */
+var TIPOS_CON_SOPORTE = [
+	"incapacidad",
+	"licencia_maternidad",
+	"licencia_paternidad"
+];
+function esTipoConSoporte(tipo) {
+	return TIPOS_CON_SOPORTE.includes(tipo);
+}
+/** Cuándo pide soporte el tipo, para la tabla de tipos (la regla vive en SoftDIN). */
+function soporteDeTipo(tipo) {
+	if (tipo === "incapacidad") return "Certificado de incapacidad obligatorio al radicar";
+	if (tipo === "licencia_maternidad") return "Soporte obligatorio al radicar";
+	if (tipo === "licencia_paternidad") return "Registro civil: al radicar o dentro de los 30 días siguientes";
+	return null;
+}
+/**
+* Estado del soporte de una solicitud. El documento (dato de salud) está solo en SoftDIN, reservado en el
+* expediente del empleado: aquí no se muestra ni se descarga.
+*/
+function estadoSoporte(s) {
+	if (!esTipoConSoporte(s.tipo)) return null;
+	if (s.tiene_soporte) return {
+		texto: "Soporte adjunto — ábralo en el expediente de SoftDIN",
+		pendiente: false
+	};
+	if (s.soporte_en_envio) return {
+		texto: "Enviando el soporte… llegará al expediente de SoftDIN",
+		pendiente: false
+	};
+	const dias = s.soporte_pendiente?.dias_restantes;
+	if (dias === null || dias === void 0) return {
+		texto: "Soporte pendiente",
+		pendiente: true
+	};
+	if (dias < 0) return {
+		texto: `Soporte pendiente (plazo vencido hace ${-dias} ${-dias === 1 ? "día" : "días"})`,
+		pendiente: true
+	};
+	return {
+		texto: `Soporte pendiente (${dias} ${dias === 1 ? "día" : "días"})`,
+		pendiente: true
+	};
+}
+/** Datos no clínicos de la incapacidad o licencia, en una línea. */
+function datosNoClinicos(s) {
+	if (s.origen) return [s.origen === "laboral" ? "Origen laboral" : "Origen común", s.es_prorroga ? "Prórroga" : null].filter(Boolean).join(" · ");
+	if (s.fecha_parto) return `Parto: ${fechaCorta(s.fecha_parto)}`;
+	return null;
+}
+//#endregion
+export { estadoSoporte as a, soporteDeTipo as c, esTipoConSoporte as i, conceptoDeTipo as n, fechaCorta as o, datosNoClinicos as r, nombreTipoSolicitud as s, ESTADOS_SOLICITUD_PORTAL as t };