);
}
// Barra superior de la computadora del miembro
function EqsBarraSuperior({ texto, sub, icono, spinner, progreso, indet, quieta }) {
return (
Buscar póliza, cliente…
{spinner && }
{icono && }
{texto}
{sub &&
{sub}
}
{(progreso != null || indet) ? : }
);
}
function EqsTarjeta({ titulo, cuerpo, acciones, children }) {
return (
Ajustes › Equipo
{titulo}
{cuerpo &&
{cuerpo}
}
{acciones}
{children &&
{children}
}
);
}
function EqsNota({ children }) {
return
{children}
;
}
const EQS_DIRECTO = 'Tus datos viajan directo desde la computadora principal; no pasan por la nube de Piixi.';
const EQS_CIFRADA = 'Cifrada en tu computadora: ni Piixi ni el proveedor de la nube pueden leerla.';
const EQS_AMBAS = 'Llega directo desde la computadora principal. Si no se alcanzan, por la nube, cifrada en tu computadora: ni Piixi ni el proveedor de la nube pueden leerla.';
const eqsNota = (via) => (via === 'nube' ? EQS_CIFRADA : via === 'ambas' ? EQS_AMBAS : EQS_DIRECTO);
// ── 1. Primera copia ────────────────────────────────────────────────────────
function EqsPrimera({ via }) {
const nube = via === 'nube';
const [pausa, setPausa] = useState(false);
const t = eqsUseAvance({ pausa, paso: 0.012, ms: 400, ciclo: true });
const pol = 0.434 + 0.566 * t;
const pdf = 0.144 + 0.856 * t;
const gen = (pol + pdf) / 2;
const pct = Math.round(gen * 100);
const min = Math.max(1, Math.ceil((1 - t) * 8));
const boton = (
setPausa(!pausa)}>
{pausa ? 'Simular que vuelven a coincidir' : 'Simular interrupción'}
);
return (
<>
Avance general{pct} %
{pausa ? 'Nada se pierde: lo que ya llegó se queda en esta computadora.' : 'Tiempo restante estimado: unos ' + min + ' min. Puedes seguir trabajando.'} {eqsNota(via)}
);
}
// ── 2. Sincronizado ─────────────────────────────────────────────────────────
function EqsSincronizado({ via }) {
const nube = via === 'nube';
const amb = via === 'ambas';
const [recibiendo, setRecibiendo] = useState(true);
const t = eqsUseAvance({ pausa: !recibiendo, paso: 0.05, ms: 500, ciclo: false, alTerminar: () => setRecibiendo(false) });
const pct = Math.round(t * 100);
return (
<>
setRecibiendo(true)}>Simular llegada de PDFs nuevos}>
{recibiendo ? : Todo al día. Tus cambios también viajan solos hacia la computadora principal.}
{eqsNota(via)}
);
}
// ── 3. Computadora principal fuera de línea ─────────────────────────────────
const EQS_CAMBIOS = [
{ t: 'Nota nueva en la póliza de Ana Torres Ruiz', h: '9:52 a.m.' },
{ t: 'Teléfono corregido en la ficha de Luis Herrera Paz', h: '10:15 a.m.' },
{ t: 'Recibo marcado como pagado · póliza de Marta Solís', h: '10:31 a.m.' },
];
function EqsFuera({ via }) {
const amb = via === 'ambas';
const nube = via === 'nube' || amb;
const [fase, setFase] = useState('fuera'); // fuera | bajando | enviando | listo
const tb = eqsUseAvance({ pausa: fase !== 'bajando', paso: 0.05, ms: 400, ciclo: false, alTerminar: () => setFase('fuera') });
const pb = Math.round(tb * 100);
const t = eqsUseAvance({ pausa: fase !== 'enviando', paso: 0.04, ms: 300, ciclo: false, alTerminar: () => setFase('listo') });
const n = Math.min(3, Math.floor(t * 3) + 1);
const hechos = fase === 'listo' ? 3 : fase === 'enviando' ? n - 1 : 0;
const texto = fase === 'bajando' ? 'DESCARGANDO DESDE LA NUBE · ' + pb + ' %' : fase === 'fuera' ? (amb ? 'LLEGÓ POR LA NUBE, CIFRADA · AL CORTE DE LAS 9:40 A.M.' : nube ? 'AL CORTE DE LAS 9:40 A.M. · LA PRINCIPAL NO HA SUBIDO NADA NUEVO' : 'LA COMPUTADORA PRINCIPAL NO ESTÁ EN LÍNEA') : fase === 'enviando' ? 'ENVIANDO TUS CAMBIOS · ' + n + ' DE 3' : 'SINCRONIZADO · HACE UN MOMENTO';
return (
<>
setFase(fase === 'fuera' ? 'enviando' : 'fuera')} disabled={fase === 'enviando' || fase === 'bajando'}>{fase === 'fuera' ? 'Simular que vuelve la principal' : 'Volver a simular'}
{nube && setFase('bajando')} disabled={fase !== 'fuera'}>Simular descarga de lo último subido}
}>
{fase === 'bajando' && }
{fase === 'enviando' && }
{nube && {EQS_CIFRADA}}
)}
{!busca && intentos > 0 && Sigue sin conexión directa (intento {intentos}). Prueba de nuevo desde el Wi-Fi de la oficina.}
Los datos del despacho no se mandan por la nube de Piixi, así que sin conexión directa no se sincroniza a distancia. Mientras tanto puedes seguir trabajando: tus cambios se guardan y viajan después.
);
}
function EqsSinDirectaAmbas() {
const [busca, setBusca] = useState(false);
const [intentos, setIntentos] = useState(0);
const [bajando, setBajando] = useState(true);
const tb = eqsUseAvance({ pausa: !bajando, paso: 0.05, ms: 400, ciclo: false, alTerminar: () => setBajando(false) });
const tm = useRef(null);
useEffect(() => () => clearTimeout(tm.current), []);
const reintentar = () => {
setBusca(true);
tm.current = setTimeout(() => { setBusca(false); setIntentos((x) => x + 1); }, 5000);
};
const pb = Math.round(tb * 100);
return (
<>
{busca ? 'Reintentando…' : 'Reintentar directo'}}>
{bajando && }
{busca && (
Buscando a la computadora principal…
)}
{!busca && intentos > 0 && Sigue sin conexión directa (intento {intentos}); se sigue usando la nube.}
Sus cambios igual esperan a que la computadora principal los aplique. {EQS_CIFRADA}
);
}
// ── 5. Conflicto ────────────────────────────────────────────────────────────
function EqsConflicto() {
const [visto, setVisto] = useState(false);
return (
<>
setVisto(true)}>Entendido}>
Teléfono en la ficha de Luis Herrera Paz
Tu cambio · 10:15 a.m. · no se aplicó
55 5555 0142
Quedó · computadora principal · 10:02 a.m.
55 5555 0188
Si crees que tu versión es la correcta, vuelve a escribirla desde la ficha; viajará de nuevo a la computadora principal.
);
}
// ── 6. Dado de baja ─────────────────────────────────────────────────────────
function EqsBaja() {
const [fin, setFin] = useState(false);
const t = eqsUseAvance({ pausa: fin, paso: 0.02, ms: 400, ciclo: false, alTerminar: () => setFin(true) });
const pct = Math.round(t * 100);
return (
<>
{!fin && }
{fin && La computadora principal conserva todo; aquí no queda nada del despacho.}
);
}
// ── Computadora principal: lista de miembros ────────────────────────────────
const EQS_MIEMBROS = [
{ k: 'sync', persona: 'Sofía', nombre: 'Escritorio de Sofía', tipo: 'Windows', l: 'Sincronizado', seg: 12 },
{ k: 'copiando', persona: 'Marco', nombre: 'Laptop de Marco', tipo: 'Mac', l: 'Primera copia', seg: 38 },
{ k: 'recibiendo', persona: 'Valeria', nombre: 'Mesa de Valeria', tipo: 'Windows', l: 'Recibiendo sus cambios', seg: 24 },
{ k: 'fuera', persona: 'Diego', nombre: 'Laptop de Diego', tipo: 'Mac', l: 'Sin conexión' },
{ k: 'sindirecta', persona: 'Paula', nombre: 'Escritorio de Paula', tipo: 'Windows', l: 'Sin conexión directa' },
{ k: 'aplicados', persona: 'Iván', nombre: 'Laptop de Iván', tipo: 'Mac', l: 'Cambios aplicados' },
];
function EqsFilaBase({ m, pill, children, k }) {
return (
{m.nombre}
Computadora {m.tipo}
{pill}
{children &&
{children}
}
);
}
function EqsFilaPrincipal({ m, via }) {
const nube = via === 'nube';
const amb = via === 'ambas';
const tCopia = eqsUseAvance({ pausa: m.k !== 'copiando', paso: 0.012, ms: 400, ciclo: true });
const tCambios = eqsUseAvance({ pausa: m.k !== 'recibiendo', paso: 0.04, ms: 300, ciclo: true });
// Vía que entregó la última tanda (escenario «las dos encendidas»)
const porNube = m.k === 'fuera' || m.k === 'sindirecta';
const viaTxt = porNube ? 'por la nube, cifrada' : 'directo';
let pill, barra = null, vivo = false;
if (m.k === 'sync') pill = Sincronizado hace 2 min;
if (m.k === 'copiando') {
const v = 0.29 + 0.71 * tCopia;
pill = {nube ? 'Descargando desde la nube' : 'Copiando la primera copia'} · {Math.round(v * 100)} %;
barra = ; vivo = true;
}
if (m.k === 'recibiendo') {
const n = Math.min(5, Math.floor(tCambios * 5) + 1);
pill = Recibiendo sus cambios · {n} de 5;
barra = ; vivo = true;
}
if (m.k === 'fuera') pill = Sin conexión desde ayer 6:10 p.m.;
if (m.k === 'sindirecta') pill = En línea, pero sin conexión directa;
if (m.k === 'aplicados') pill = 3 cambios suyos aplicados hoy;
if (amb) {
const v = m.k === 'copiando' ? 0.29 + 0.71 * tCopia : m.k === 'recibiendo' ? tCambios : 1;
barra = (
);
}
// Subida de la principal a la nube (vía nube y comparación)
function EqsSubida({ respaldo }) {
const [listo, setListo] = useState(false);
const t = eqsUseAvance({ pausa: listo, paso: 0.05, ms: 500, ciclo: false, alTerminar: () => setListo(true) });
const pct = Math.round(t * 100);
return (
{listo ? 'Lista en la nube · hace 2 min' : 'Subiendo cifrada a la nube · ' + pct + ' %'}
{respaldo ? 'Respaldo en la nube · ' : ''}Espacio en la nube: 640 MB
setListo(false)}>Simular nueva subida
{!listo &&
}
{EQS_CIFRADA}
);
}
function EqsPrincipal({ filtro, via }) {
const nube = via === 'nube';
const amb = via === 'ambas';
let lista = EQS_MIEMBROS.filter((m) => filtro === 'todos' || m.k === filtro);
if (nube) lista = lista.filter((m) => m.k !== 'sindirecta');
const comparables = EQS_MIEMBROS.filter((m) => ['sync', 'copiando', 'recibiendo', 'sindirecta'].includes(m.k));
const intro = nube
? 'La computadora principal sube la cartera cifrada a la nube y los miembros la bajan de ahí, aunque la principal esté apagada. Sus cambios esperan a que la principal los aplique.'
: amb
? 'Las computadoras se sincronizan solas. Directo entre ellas es lo preferido; si no se alcanzan (principal apagada o una red que no deja conectar), se usa la nube, cifrada. Abajo ves por dónde llegó la última tanda de cada miembro.'
: 'Cuando las dos computadoras están abiertas y se alcanzan, se sincronizan solas en segundos, en los dos sentidos. Los datos viajan directo entre ellas; la nube de Piixi sólo sirve para que se reconozcan.';
return (
Ajustes › Equipo · miembros
{intro}
{(nube || amb) && }
{lista.map((m) => )}
{amb && (
Medición (sólo durante las pruebas)
La misma tanda viaja por las dos vías a la vez para medir cuál llega primero. Los tiempos de la maqueta son simulados.
{comparables.map((m) => )}
)}
);
}
// ── Pantalla ────────────────────────────────────────────────────────────────
const EQS_ESTADOS_M = [
{ k: 'primera', l: '1 · Primera copia', C: EqsPrimera },
{ k: 'sincronizado', l: '2 · Sincronizado', C: EqsSincronizado },
{ k: 'fuera', l: '3 · Principal fuera de línea', C: EqsFuera },
{ k: 'sindirecta', l: '4 · Sin conexión directa', C: EqsSinDirecta, soloDirecto: true },
{ k: 'conflicto', l: '5 · Conflicto', C: EqsConflicto },
{ k: 'baja', l: '6 · Dado de baja', C: EqsBaja },
];
const EQS_VIAS = [
{ k: 'ambas', l: 'Las dos encendidas (lo que se va a probar)' },
{ k: 'directo', l: 'Si al final sólo queda la directa' },
{ k: 'nube', l: 'Si al final sólo queda la nube' },
];
function EqsSel({ opciones, valor, onChange }) {
return (
{opciones.map((o) => (
onChange(o.k)}>{o.l}
))}
);
}
function EquipoSyncScreen() {
const [vista, setVista] = useState('miembro');
const [estadoM, setEstadoM] = useState('primera');
const [filtroP, setFiltroP] = useState('todos');
const [corrida, setCorrida] = useState(0);
const [via, setViaState] = useState(window.__eqsVia || 'ambas');
const setVia = (v) => {
window.__eqsVia = v;
setViaState(v);
if (v === 'nube' && estadoM === 'sindirecta') setEstadoM('primera');
if (v === 'nube' && filtroP === 'sindirecta') setFiltroP('todos');
setCorrida((c) => c + 1);
};
useEffect(() => {
const h = (e) => setVia(e.detail);
window.addEventListener('eqs-via', h);
return () => window.removeEventListener('eqs-via', h);
});
const nube = via === 'nube';
const estados = EQS_ESTADOS_M.filter((e) => !(nube && e.soloDirecto));
const Actual = EQS_ESTADOS_M.find((e) => e.k === estadoM).C;
const miembros = nube ? EQS_MIEMBROS.filter((m) => m.k !== 'sindirecta') : EQS_MIEMBROS;
const sub = via === 'ambas' ? 'Qué ve cada computadora mientras se sincronizan: directo entre ellas, y por la nube, cifrada, si no se alcanzan.' : via === 'directo' ? 'Qué ve cada computadora mientras se sincronizan directo, sin pasar por la nube de Piixi.'
: nube ? 'Qué ve cada computadora mientras la cartera viaja por la nube, cifrada en la computadora principal.'
: '';
return (
Maqueta · simular estado de sincronización
Escenario:
Ver como:
{vista === 'miembro' ? (
Estado: { setEstadoM(k); setCorrida((c) => c + 1); }} opciones={estados} />
setCorrida((c) => c + 1)}>Reiniciar
{nube && «Sin conexión directa» no existe por la nube: no hace falta que las dos se alcancen.}
{false && Comparando: aquí se ve la vía directa de este estado. Elige «Por la nube, cifrada» para ver la otra; la comparación por miembro está en «Computadora principal».}