);
}
function NbTarjeta({ titulo, icono, derecha, children, dataNb, id }) {
return (
{icono === 'candado' ? : }
{titulo}
{derecha ?
{derecha}
: null}
{children}
);
}
function NbFila({ etiqueta, children }) {
return (
{etiqueta}{children}
);
}
function NbNota({ children }) {
return
{children}
;
}
// Paso numerado: hecho · activo · pendiente
function NbPaso({ n, titulo, estado, resumen, children }) {
const hecho = estado === 'hecho', activo = estado === 'activo';
return (
No aparece «{NB_CARPETA}»: {NB_PRINCIPAL} todavía no te la comparte.
) : null}
);
}
function NbPermisoMac() {
const n = useNube();
const nube = AxNube.info(n.elegida) || NB_NUBES.gdrive;
return (
AxNube.responderPermiso(false)}>No permitir AxNube.responderPermiso(true)}>Permitir}>
Puedes cambiarlo después en Configuración del Sistema › Privacidad y seguridad › Archivos y carpetas.
);
}
// ─────────────────────────────────────────────────────────────
// SINCRONIZAR POR TU NUBE — piezas compartidas
// ─────────────────────────────────────────────────────────────
function NbEspacio({ compacto }) {
const n = useNube();
const nube = AxNube.info();
if (!nube) return null;
const e = AxNube.espacioDatos();
const tono = n.espacio === 'lleno' ? 'bad' : n.espacio === 'casi' ? 'warm' : 'ok';
return (
Espacio de {nube.nombre}{nbGB(e.usado)} GB de {e.total} GB · Piixi ocupa {nbGB(e.piixi)} GB
{!compacto && n.espacio !== 'normal' ? (
AxNube._toast({ kind: 'info', message: 'En la app real se abre ' + nube.sitio + ' para liberar espacio.' })}>Liberar espacio en {nube.nombre}
}>
{n.espacio === 'lleno'
? 'Ya no cabe nada nuevo: los cambios del equipo esperan aquí y viajan directo cuando las computadoras se alcancen. '
: 'Quedan ' + nbGB(e.libre) + ' GB. Cuando se llene, lo que viaja por tu nube se queda esperando. '}
{nube.llena} Piixi ya borra solo lo que no se usa: lo que queda es de la cartera vigente.
) : null}
);
}
function NbPendientes() {
const n = useNube();
if (!n.pendientes.length) return null;
const nube = AxNube.info();
return (
{n.pendientes.length === 1 ? '1 archivo todavía no llega' : n.pendientes.length + ' archivos todavía no llegan'}No se perdió
El aviso llegó antes que el archivo. Piixi lo vuelve a buscar solo, cada vez con más calma, y lo aplica en cuanto {nube.nombre} termine de bajarlo. Sólo si en 24 horas no aparece se avisa como falla.
);
}
function NbDesconectada() {
const n = useNube();
const nube = AxNube.info();
if (!nube || n.conexion === 'ok') return null;
return (
AxNube.reconectar()}>{n.reconectando ? 'Buscando…' : 'Reintentar'} AxNube._toast({ kind: 'info', message: 'En la app real se abre ' + nube.app + '.' })}>Abrir {nube.nombre} (AxNube.esMiembro() ? AxNube.set({ dialogo: 'miembro' }) : AxNube.reconectar())}>Elegir la carpeta otra vez
}>
La app de {nube.nombre} está cerrada, cerró sesión o la carpeta «{NB_CARPETA}» se movió. Nada se pierde: lo que cambies se guarda aquí, sigue viajando directo cuando las computadoras se alcancen, y por la nube en cuanto vuelva.
);
}
// ─────────────────────────────────────────────────────────────
// SINCRONIZAR POR TU NUBE — principal
// ─────────────────────────────────────────────────────────────
function NbElegirNube() {
const n = useNube();
const ids = ['gdrive', 'onedrive', 'icloud'];
const sel = n.elegida;
return (
{ids.map((id) => {
const x = NB_NUBES[id];
const bloqueada = id === 'icloud' && n.mixto && n.qIcloud === 'B';
const avisar = id === 'icloud' && n.mixto && n.qIcloud === 'A';
const on = sel === id;
return (
);
})}
Una nube por despacho: la tuya. Tus miembros entran a esa misma carpeta; si usan otra nube, abren una cuenta gratuita en la tuya y lo compartido no gasta su espacio.
AxNube.continuarCon(sel)}>{sel ? 'Continuar con ' + NB_NUBES[sel].nombre : 'Elige una nube'}
);
}
function NbPasoCarpeta() {
const n = useNube();
const nube = AxNube.info(n.elegida);
const win = n.soP === 'win';
const encontrada = n.detecta && (!win || nube.detectaWin);
const ruta = AxNube.ruta(nube.id, n.soP);
return (
<>
{n.permiso === 'negado' ? (
AxNube.set({ permiso: 'pidiendo' })}>Volver a pedir el permiso}>
macOS pregunta una sola vez. Si contestaste «No permitir», ábrelo en Configuración del Sistema › Privacidad y seguridad › Archivos y carpetas › Piixi.
) : null}
{n.avisoNoNube ? (
Elegiste una carpeta de esta computadora que no sincroniza {nube.nombre}: los miembros no la verían. Elige una dentro de {nube.nombre}.
) : null}
{encontrada ? (
<>
{ruta}Piixi crea ahí la carpeta «{NB_CARPETA}» con un archivo marcador sellado, para que cada miembro compruebe que eligió la buena. Lo que viaja por ella va sellado: ni Piixi ni {nube.nombre} pueden leerlo.
{!win && n.permisoMac && n.permiso !== 'concedido' ? La primera vez, macOS te va a preguntar si Piixi puede usar archivos de {nube.nombre}: contesta «Permitir». : null}
AxNube.crearCarpeta(ruta)}>Crear la carpeta aquí AxNube.set({ dialogo: 'principal' })}>Elegir otra ubicación…
) : (
<>
{win && nube.id === 'gdrive'
? 'En Windows, Google Drive aparece como una unidad aparte (casi siempre G:) y no hay forma segura de detectarla. Elígela tú: busca «Mi unidad».'
: '¿Ya instalaste ' + nube.app + ' e iniciaste sesión? Si sí, elige su carpeta tú.'}
AxNube.set({ dialogo: 'principal' })}>Elegir la carpeta de {nube.nombre}… AxNube._toast({ kind: 'info', message: 'En la app real se abre la página de descarga de ' + nube.app + '.' })}>No tengo la app: descargarla
)}
AxNube.set({ paso: 'elegir', permiso: null, avisoNoNube: false })}>Elegir otra nube
);
}
function NbMiembroFila({ m, conAccion }) {
const pill = m.estado === 'unida' ? Ya entró
: m.estado === 'compartida' ? Compartida · falta que la elija
: Falta compartírsela;
return (
{m.persona}
{m.compu} · {m.so}
{pill}
{conAccion && m.estado === 'invitada' ? AxNube.marcarCompartida(m.id)}>Ya se la compartí : null}
);
}
function NbPasoCompartir() {
const n = useNube();
const nube = AxNube.info();
const [copiado, setCopiado] = useState(false);
const copiar = () => {
const t = 'Para unirte a la nube de ' + NB_DESPACHO + ' en Piixi:\n1. Si no tienes cuenta de ' + nube.nombre + ', abre una gratuita.\n2. Instala ' + nube.app + '.\n3. ' + nube.miembroExtra + '\n4. En Piixi: Ajustes › Equipo › Nube del despacho › Elegir la carpeta.';
if (window.pregCopiar) pregCopiar(t);
setCopiado(true); setTimeout(() => setCopiado(false), 3000);
};
return (
<>
{n.carpeta}
Compártela con tu equipo, desde {nube.nombre}:
{nube.compartir.map((p, i) =>
{p}
)}
Piixi no la puede compartir por ti: {nube.id === 'icloud' ? 'iCloud no lo permite a otras apps.' : 'se hace desde tu cuenta de ' + nube.nombre + ', con tu permiso.'}
{n.miembros.map((m) => )}
{copiado ? 'Copiado' : 'Copiar los pasos para tus miembros'} AxNube.terminar()}>Listo
);
}
function NbPrincipalLista() {
const n = useNube();
const nube = AxNube.info();
const unidos = n.miembros.filter((m) => m.estado === 'unida').length;
return (
<>
Conectada : No responde}>
{n.carpeta}{nube.cuenta}Cuando las computadoras no se alcanzan directo (la principal apagada, o una red que no deja). Directo sigue siendo lo preferido.
{n.miembros.map((m) => )}
Para sacar a alguien del equipo son dos pasos: dejar de compartirle la carpeta en {nube.nombre} y rotar la llave del despacho en Ajustes › Equipo.
AxNube.reiniciarPrincipal()}>Cambiar de nube
);
}
function NbPrincipal() {
const n = useNube();
const pasoN = { elegir: 1, carpeta: 2, creando: 2, compartir: 3, lista: 4 }[n.paso];
if (n.paso === 'lista') return ;
const est = (k) => (pasoN > k ? 'hecho' : pasoN === k ? 'activo' : 'pendiente');
const nube = AxNube.info(n.elegida);
return (
Paso {Math.min(3, pasoN)} de 3}>
Cuando las computadoras del equipo no se alcanzan directo, los cambios y los PDF viajan por una carpeta en tu nube, sellados en tu computadora. Ningún dato del despacho pasa por los servidores de Piixi.
{n.paso === 'creando' ? (
Creando la carpeta y su marcador sellado… {Math.round(n.creandoPct * 100)} %
) : }
);
}
// ─────────────────────────────────────────────────────────────
// SINCRONIZAR POR TU NUBE — miembro (Sofía, Windows)
// ─────────────────────────────────────────────────────────────
function NbMiembro() {
const n = useNube();
const nube = AxNube.info();
if (!AxNube.configurada()) {
return (
Cuando {NB_PRINCIPAL} la configure, aquí verás los pasos para entrar. Mientras, todo viaja directo cuando las computadoras se alcanzan.
);
}
const compartida = n.miembros.find((m) => m.id === 'sofia').estado !== 'invitada';
const orden = { cuenta: 1, app: 2, carpeta: 3, verificando: 3, unida: 4 };
const k = orden[n.mPaso];
const est = (i) => (k > i ? 'hecho' : k === i ? 'activo' : 'pendiente');
const cabecera = (
Es la nube de la computadora principal: una por despacho. Lo que te comparte no gasta tu espacio.
);
if (n.mPaso === 'unida') {
return (
<>
Esta computadora ya entró : No responde}>
{cabecera}
{n.mCarpeta}Cuando no te alcanzas directo con la computadora principal. Tus cambios suben a tu subcarpeta y la principal los aplica al leerlos.
{n.qEspacio === 'B' && n.espacio !== 'normal' ? (
{NB_PRINCIPAL} ya tiene el aviso; no tienes que hacer nada. Si se llena, tus cambios esperan aquí y viajan directo cuando se alcancen.
) : null}
);
}
return (
Paso {Math.min(3, k)} de 3}>
{cabecera}
{n.mCuenta === 'no' ? (
<>
Abre una cuenta gratuita de {nube.nombre} en {nube.sitio}. No necesitas pagar nada: lo que {NB_PRINCIPAL} comparte no gasta tu espacio.
AxNube._toast({ kind: 'info', message: 'En la app real se abre ' + nube.sitio + '.' })}>Abrir {nube.sitio} AxNube.set({ mPaso: 'app' })}>Ya la abrí
) : (
AxNube.set({ mCuenta: 'si', mPaso: 'app' })}>Sí, ya tengo AxNube.set({ mCuenta: 'no' })}>No, todavía no
)}
Instálala e inicia sesión con tu cuenta. Es la que baja la carpeta del despacho a esta computadora.
{nube.id === 'gdrive' || nube.id === 'onedrive' ? (
{nube.miembroExtra}
) : {nube.miembroExtra}}
AxNube.set({ mPaso: 'carpeta', mAcceso: true })}>{nube.id === 'icloud' ? 'Ya la instalé y acepté la carpeta' : 'Ya la instalé y agregué el acceso directo'}
{n.mPaso === 'verificando' ? (
Comprobando el marcador de la carpeta…
) : (
<>
{n.mRechazo ? (
{n.mRechazo === 'ajena'
? 'Tiene el marcador de otra instalación de Piixi, no el de ' + NB_DESPACHO + '. '
: 'No tiene el marcador de ' + NB_DESPACHO + '. '}
Busca «{NB_CARPETA}»{nube.id === 'gdrive' ? ' en Mi unidad (es el acceso directo que agregaste)' : ''} y elígela. Si no aparece, pídele a {NB_PRINCIPAL} que te la comparta otra vez.
) : null}
{!compartida ? Ojo: {NB_PRINCIPAL} todavía no marca que te la compartió. Si no la ves, pídesela. : null}
AxNube.set({ dialogo: 'miembro' })}>Elegir la carpeta…
navigate('/equipo-sincronizacion')}>Ver la sincronización del equipo}/>
{miembro ? : }
);
}
// ─────────────────────────────────────────────────────────────
// RESPALDO AUTOMÁTICO · /ajustes/respaldo
// ─────────────────────────────────────────────────────────────
function RpContrasenaForm({ titulo, boton, onListo, nota, cancelar }) {
const [a, setA] = useState('');
const [b, setB] = useState('');
const [apunte, setApunte] = useState(false);
const err = a && b && a !== b ? 'Las contraseñas no coinciden.' : a && a.length < 8 ? 'Usa al menos 8 caracteres.' : null;
const listo = a && b && !err && apunte;
return (
{titulo ?
{titulo}
: null}
setA(e.target.value)} placeholder="Al menos 8 caracteres"/> setB(e.target.value)}/>
{nota}
onListo()}>{boton}
{cancelar ? Cancelar : null}
);
}
const RP_NOTA_LLAVERO = 'Piixi la guarda en el llavero de esta computadora para respaldar cada noche sin pedírtela. Si esta computadora se descompone, el llavero se va con ella: para recuperar tu cartera en otra vas a necesitar esta contraseña. Piixi no la puede recuperar por ti.';
function RpConfigurar() {
const r = useResp();
useNube();
const sug = AxResp.sugerida();
const [eligiendo, setEligiendo] = useState(false);
const est = (k) => ({ carpeta: 1, contrasena: 2 }[r.paso] > k ? 'hecho' : { carpeta: 1, contrasena: 2 }[r.paso] === k ? 'activo' : 'pendiente');
return (
{sug ? (
{sug.ruta}
Así la copia sobrevive si esta computadora se descompone. Es una carpeta tuya, aparte de la del equipo: no se comparte con nadie.
) : (
Puedes elegir cualquier carpeta, pero si es de esta misma computadora, la copia se pierde con ella. Mejor instala la app de tu nube y elige su carpeta.
)}
{eligiendo ? (
Diálogo del sistema (simulado) · elige una carpeta
{['gdrive', 'onedrive', 'icloud'].map((id) => (
{ setEligiendo(false); AxResp.usarCarpeta(id, AxNube.ruta(id, AxNube.get().soP) + '/' + NB_RESP_CARPETA); }}>
{NB_NUBES[id].nombre} › {NB_RESP_CARPETA}
))}
{ setEligiendo(false); AxResp.usarCarpeta(null, '~/Documents/' + NB_RESP_CARPETA); }}>Documentos › {NB_RESP_CARPETA} (en esta computadora)
) : null}
{sug ? AxResp.usarCarpeta(sug.nube, sug.ruta)}>Usar esta carpeta : null}
setEligiendo(!eligiendo)}>Elegir otra carpeta…
{r.nubeCarpeta === null && r.carpeta ? (
Si se descompone, la copia se pierde con ella. Puedes seguir, pero te lo vamos a recordar en Ajustes.
) : null}
AxResp.encender()}
cancelar={() => AxResp.set({ paso: 'carpeta' })}/>
Puedes seguir trabajando: la copia se toma sin detener Piixi.
) : fallo ? (
AxResp.elegirCarpetaOtraVez()}>Elegir la carpeta otra vez AxResp.correr('ahora')}>Reintentar
: <>
AxNube._toast({ kind: 'info', message: 'En la app real se abre ' + (nube ? nube.sitio : 'tu nube') + ' para liberar espacio.' })}>Liberar espacio en {nube ? nube.nombre : 'tu nube'} setCambiando(true)}>Elegir otra carpeta
}>
{fallo.motivo === 'carpeta'
? 'No encontramos «' + NB_RESP_CARPETA + '» en ' + (nube ? 'tu ' + nube.nombre : 'la ruta de siempre') + ': ¿la moviste, le cambiaste el nombre o la borraste? Elígela de nuevo o elige otra. '
: 'Faltan unos ' + (ult ? ult.mb : 48) + ' MB en tu ' + (nube ? nube.nombre : 'carpeta') + '. ' + (nube ? nube.llena + ' ' : '')}
{ult ? 'Tu copia más reciente sigue siendo la de ' + rpFecha(ult.dia, r.hoy).toLowerCase() + ', ' + ult.hora : ''}
) : ult ? (
{ult.mb} MB · {ult.archivo}
) : (
Si quieres comprobarlo ya, haz uno ahora.
)}
{caida && !r.corriendo ? (
AxNube.reconectar()}>Reintentar}>
{ult && !ult.subida ? 'La copia de ' + rpFecha(ult.dia, r.hoy).toLowerCase() + ' quedó en la carpeta, pero todavía no sube a la nube: mientras, sólo existe en esta computadora. ' : 'Las copias se siguen escribiendo en la carpeta, pero no suben a la nube hasta que ' + nube.nombre + ' vuelva. '}
Abre {nube.app} o vuelve a iniciar sesión.
) : null}
{esp === 'casi' && !fallo && nube ? (
El próximo respaldo ({ult ? ult.mb : 48} MB) todavía cabe. {nube.llena}
) : null}
Cada noche, sólo en esta computadora (la principal). Si estuvo apagada, corre en cuanto vuelvas a abrir Piixi.
{nube ? : null}
{r.carpeta}Se guardan las últimas 7; la más vieja se borra sola. {r.copias.length ? 'Hoy hay ' + r.copias.length + '.' : ''}Guardada en el llavero de esta computadora
Piixi deja de respaldar cada noche y borra la contraseña del llavero de esta computadora. Las copias que ya están en tu carpeta se quedan ahí y siguen abriendo con su contraseña.
);
}
function RpComprobar() {
const r = useResp();
const [t, setT] = useState('');
const [olvido, setOlvido] = useState(false);
if (!r.comprobar || r.estado !== 'encendido') return null;
return (
Pasaron 30 días. Si esta computadora se descompone, esa contraseña es lo único que te deja recuperar tu cartera en otra. Escríbela para comprobarlo.
{olvido ? (
{ setOlvido(false); AxResp.set({ comprobar: false }); AxNube._toast({ kind: 'success', title: 'Contraseña cambiada', message: 'El respaldo de esta noche ya se sella con la nueva.' }); }}
cancelar={() => setOlvido(false)}/>
) : (
setT(e.target.value)} placeholder="Contraseña del respaldo"/>
{ AxResp.set({ comprobar: false }); setT(''); AxNube._toast({ kind: 'success', title: 'Es correcta', message: 'Te volvemos a preguntar en 30 días.' }); }}>Comprobar setOlvido(true)}>La olvidé: elegir otra
)}
);
}
function RpRestaurar() {
const r = useResp();
const [sel, setSel] = useState(null);
const [modal, setModal] = useState(null); // null | confirmar | llavero | aplicando | listo
const [pct, setPct] = useState(0);
const [clave, setClave] = useState('');
const [error, setError] = useState(null);
const [archivo, setArchivo] = useState(null);
const copias = r.copias.slice().reverse();
const copia = copias.find((c) => c.dia === sel) || copias[0] || null;
const aplicar = () => {
setModal('aplicando'); setPct(0);
let v = 0;
const id = setInterval(() => { v = Math.min(1, v + 0.1); setPct(v); if (v >= 1) { clearInterval(id); setModal('listo'); } }, 160);
};
const conClave = () => { if (!r.abre) { setError('La contraseña no abre este respaldo.'); return; } setError(null); aplicar(); };
const cerrar = () => { setModal(null); setClave(''); setError(null); };
const otra = r.donde === 'otra';
const usaLlavero = !otra && r.qRestaurar === 'A' && r.estado === 'encendido';
return (
{otra ? 'En otra computadora' : 'En esta computadora'}}>
{otra ? (
<>
En una computadora nueva no está tu llavero. Instala Piixi, elige el archivo del respaldo desde tu nube y escribe la contraseña que elegiste al encender el respaldo automático.
) : (
Todavía no hay copias en la carpeta. Cuando corra el primer respaldo, aquí las verás.
)}
{} : cerrar} width={480}
title={modal === 'listo' ? 'Cartera restaurada' : 'Restaurar la copia de ' + (copia ? rpFecha(copia.dia, r.hoy).toLowerCase() + ', ' + copia.hora : '')}
footer={modal === 'confirmar' ? <>
Cancelar
{usaLlavero
? setModal('llavero')}>Restaurar
: Restaurar}
: modal === 'listo' ? Listo : null}>
{modal === 'confirmar' ? (
Restaurar reemplaza la cartera de esta computadora por la de esa copia. La cartera de hoy se guarda aparte por si necesitas regresar.
{usaLlavero ? (
Piixi usa la contraseña guardada en el llavero de esta computadora: no tienes que escribirla. El sistema te va a pedir permiso.
) : (
{ setClave(e.target.value); setError(null); }}/>
)}
) : modal === 'aplicando' ? (
Restaurando… Piixi se va a reiniciar. {Math.round(pct * 100)} %
) : modal === 'listo' ? (
Piixi se reinició con la cartera de esa copia. La de antes quedó guardada aparte.
Para permitirlo, escribe la contraseña de esta computadora o usa Touch ID. (En Windows: «Confirma que eres tú» con tu PIN.)
••••••••
);
}
function RpManual() {
const { pushToast } = useAxStore();
const r = useResp();
const [a, setA] = useState('');
const [b, setB] = useState('');
const err = a && b && a !== b ? 'Las contraseñas no coinciden.' : null;
return (
Un solo archivo .piixi, protegido con una contraseña que eliges ahora. Piixi no guarda esta contraseña ni la puede recuperar.
{miembro ? (
Lo hace la principal}>
Es la que tiene la cartera completa del despacho. Desde aquí puedes guardar un respaldo a mano cuando quieras.
) : (
{r.estado === 'apagado' ? (
<>
Cada noche, Piixi guarda una copia sellada de tu cartera en una carpeta de tu nube (Google Drive, OneDrive o iCloud). Así, si esta computadora se descompone o la cambias, tu trabajo no se pierde.
);
}
// ─────────────────────────────────────────────────────────────
// SUPERFICIES EN OTRAS PANTALLAS (estado vivo)
// ─────────────────────────────────────────────────────────────
// Ajustes › Equipo: la fila de la nube (principal) o de la nube del despacho (miembro)
function NubeFilaAjustes(miembro) {
const n = AxNube.get();
const nube = AxNube.info();
if (miembro) {
if (!AxNube.configurada()) return { label: 'Nube del despacho', value: 'La principal todavía no la elige', pill: { tone: 'ghost', label: 'sin nube' }, linkTo: '/ajustes/nube' };
if (n.mPaso !== 'unida') return { label: 'Nube del despacho', value: nube.nombre + ' de ' + NB_PRINCIPAL + ' · falta que esta computadora entre', pill: { tone: 'warm', label: 'falta entrar' }, linkTo: '/ajustes/nube' };
if (n.conexion !== 'ok') return { label: 'Nube del despacho', value: nube.nombre + ' no responde en esta computadora', pill: { tone: 'danger', label: 'revisar' }, linkTo: '/ajustes/nube' };
return { label: 'Nube del despacho', value: nube.nombre + ' de ' + NB_PRINCIPAL + ' · esta computadora ya entró', pill: { tone: 'accent', label: 'on' }, linkTo: '/ajustes/nube' };
}
if (!AxNube.configurada()) {
return { label: 'Sincronizar por tu nube', value: n.nube ? 'A medias: falta ' + (n.paso === 'compartir' ? 'compartir la carpeta' : 'terminar') : 'Sin configurar · tu Google Drive, OneDrive o iCloud cuando no se alcanzan directo', pill: { tone: n.nube ? 'warm' : 'ghost', label: n.nube ? 'a medias' : 'off' }, linkTo: '/ajustes/nube' };
}
const unidos = n.miembros.filter((m) => m.estado === 'unida').length;
const base = nube.nombre + ' · ' + unidos + ' de ' + n.miembros.length + ' miembros ya entraron';
if (n.conexion !== 'ok') return { label: 'Sincronizar por tu nube', value: nube.nombre + ' no responde en esta computadora', pill: { tone: 'danger', label: 'revisar' }, linkTo: '/ajustes/nube' };
if (n.espacio !== 'normal') return { label: 'Sincronizar por tu nube', value: base + ' · ' + (n.espacio === 'lleno' ? 'lleno' : 'casi lleno'), pill: { tone: n.espacio === 'lleno' ? 'danger' : 'warm', label: 'espacio' }, linkTo: '/ajustes/nube' };
return { label: 'Sincronizar por tu nube', value: base, pill: { tone: 'accent', label: 'on' }, linkTo: '/ajustes/nube' };
}
// Ajustes: tarjeta «Respaldo de tu cartera»
function RespaldoTarjeta() {
const r = useResp();
useNube();
const eq = useEquipo();
const { navigate } = useHashRoute();
const ult = AxResp.ultimo();
const fallo = AxResp.fallo();
const nube = AxResp.nube();
let fila;
if (eq.ver === 'miembro') fila = { label: 'Respaldo automático', value: 'Lo hace la computadora principal (' + NB_PRINCIPAL + ')', pill: { tone: 'ghost', label: 'principal' }, linkTo: '/ajustes/respaldo' };
else if (r.estado !== 'encendido') fila = { label: 'Respaldo automático', value: r.estado === 'configurando' ? 'A medias: falta la contraseña' : 'Apagado · hoy, si esta computadora se descompone, la cartera se pierde', pill: { tone: 'warm', label: 'off' }, linkTo: '/ajustes/respaldo' };
else if (fallo) fila = { label: 'Respaldo automático', value: 'El de anoche no se hizo: ' + (fallo.motivo === 'carpeta' ? 'la carpeta ya no existe' : 'no cabe en tu ' + (nube ? nube.nombre : 'nube')), pill: { tone: 'danger', label: 'falló' }, linkTo: '/ajustes/respaldo' };
else if (r.comprobar) fila = { label: 'Respaldo automático', value: 'Encendido · comprueba que recuerdas la contraseña', pill: { tone: 'info', label: 'comprobar' }, linkTo: '/ajustes/respaldo' };
else fila = { label: 'Respaldo automático', value: ult ? 'Último: ' + rpFecha(ult.dia, r.hoy).toLowerCase() + ', ' + ult.hora + (nube ? ' · en tu ' + nube.nombre : '') : 'Encendido · el primero corre esta noche', pill: { tone: 'accent', label: 'on' }, linkTo: '/ajustes/respaldo' };
const g = { id: 'respaldo', label: 'Respaldo de tu cartera', icon: 'shield', items: [
fila,
{ label: 'Restaurar', value: 'Desde una copia de tu carpeta, o desde un archivo en otra computadora', linkTo: '/ajustes/respaldo?ir=restaurar' },
{ label: 'Guardar a mano', value: 'Un archivo .piixi con la contraseña que elijas', linkTo: '/ajustes/respaldo?ir=manual' },
] };
return window.SettingsGroupCard ? : null;
}
// Tu cuenta › Dónde viven tus datos: el aviso de respaldo deja de ser «aún no disponible»
function RespaldoEnCuenta() {
const r = useResp();
useNube();
const { navigate } = useHashRoute();
const ult = AxResp.ultimo();
const fallo = AxResp.fallo();
const nube = AxResp.nube();
const on = r.estado === 'encendido';
const tono = on && !fallo ? { b: 'var(--ax-accent-line)', bg: 'var(--ax-accent-soft)', c: 'var(--ax-accent)', i: 'check' }
: fallo ? { b: 'var(--ax-danger)', bg: 'var(--ax-danger-soft)', c: 'var(--ax-danger)', i: 'alert' }
: { b: 'var(--ax-warm-line)', bg: 'var(--ax-warm-soft)', c: 'var(--ax-warm)', i: 'alert' };
return (
{on && !fallo ? (
<>Respaldo automático encendido. {ult ? 'Último: ' + rpFecha(ult.dia, r.hoy).toLowerCase() + ', ' + ult.hora + (nube ? ', en tu ' + nube.nombre + '.' : '') : 'El primero corre esta noche.'} Si esta computadora se descompone, recuperas tu cartera con el archivo y tu contraseña.
) : fallo ? (
<>El respaldo de anoche no se hizo. {fallo.motivo === 'carpeta' ? 'La carpeta ya no existe.' : 'No cupo en tu ' + (nube ? nube.nombre : 'nube') + '.'}
) : (
<>Lo que eso cuesta: hoy no hay respaldo. Si esta computadora se descompone, la cartera se pierde. Respaldar y restaurar es la contraparte honesta de guardar todo aquí.
)}
navigate('/ajustes/respaldo')}>{on ? 'Ver el respaldo' : 'Configurar respaldo'}
);
}
// Equipo › sincronización: la línea de la nube del despacho, arriba
function NbTarjetaEquipo() {
const n = useNube();
const eq = useEquipo();
const { navigate } = useHashRoute();
const nube = AxNube.info();
const miembro = eq.ver === 'miembro';
let texto, pill;
if (!AxNube.configurada()) {
texto = miembro ? 'El despacho todavía no tiene nube: si no se alcanzan directo, los cambios esperan.' : 'Sin nube del despacho: si las computadoras no se alcanzan directo, los cambios esperan. Configúrala para que viajen por tu Google Drive, OneDrive o iCloud.';
pill = Sin nube;
} else if (n.conexion !== 'ok') {
texto = nube.nombre + ' no responde en esta computadora. Mientras, sólo directo.'; pill = No responde;
} else if (miembro && n.mPaso !== 'unida') {
texto = 'El despacho usa el ' + nube.nombre + ' de ' + NB_PRINCIPAL + ', pero esta computadora todavía no entra a la carpeta.'; pill = Falta entrar;
} else {
const espTxt = (!miembro || n.qEspacio === 'B') && n.espacio !== 'normal' ? ' · ' + (n.espacio === 'lleno' ? 'lleno' : 'casi lleno') : '';
texto = (miembro ? 'Si no te alcanzas directo con la principal, todo viaja por el ' + nube.nombre + ' del despacho, sellado.' : 'Si no se alcanzan directo, todo viaja por tu ' + nube.nombre + ', sellado. Ningún dato pasa por Piixi.') + espTxt;
pill = espTxt ? {n.espacio === 'lleno' ? 'Lleno' : 'Casi lleno'} : {nube.nombre};
}
return (
{nube ? : }
{miembro ? 'Nube del despacho' : 'Sincronizar por tu nube'}
);
}
// Equipo › sincronización › miembro: el aviso cuando la red no deja la directa
function NbAvisoMiembro() {
const n = useNube();
const { navigate } = useHashRoute();
const nube = AxNube.info();
const ir =
navigate('/ajustes/nube')}>{AxNube.configurada() ? 'Entrar a la nube del despacho' : 'Ver «Nube del despacho»'}
;
if (!AxNube.configurada()) {
return Esta red no permite la conexión directa con la principal, y el despacho todavía no tiene nube. Tus cambios esperan aquí y viajan cuando se alcancen.{ir};
}
if (n.conexion !== 'ok') return Esta red no permite la conexión directa, y {nube.nombre} no responde en esta computadora. Tus cambios esperan aquí.;
if (n.mPaso !== 'unida') return Esta red no permite la conexión directa con la principal. Para que tus cambios viajen por el {nube.nombre} del despacho, falta que esta computadora entre a la carpeta.{ir};
return (
Esta red no permite la conexión directa con la principal; sincronizando por {AxNube.nombreVia(true)}…
{n.pendientes.length ?
1 archivo todavía no llega ({n.pendientes[0].nombre}); se reintenta solo. No se perdió.
: null}
);
}
// Barra de arriba: avisos que no pueden esperar a que abras Ajustes
function NbAvisosBarra() {
const n = useNube();
const r = useResp();
const eq = useEquipo();
const { navigate } = useHashRoute();
const nube = AxNube.info();
const miembro = eq.ver === 'miembro';
const avisos = [];
if (nube && AxNube.configurada() && n.conexion !== 'ok') avisos.push({ k: 'nube', t: nube.nombre + ' no responde', tono: 'danger', to: '/ajustes/nube' });
else if (nube && AxNube.configurada() && n.espacio !== 'normal' && (!miembro || n.qEspacio === 'B')) avisos.push({ k: 'espacio', t: (miembro ? 'Nube del despacho ' : nube.nombre + ' ') + (n.espacio === 'lleno' ? 'lleno' : 'casi lleno'), tono: n.espacio === 'lleno' ? 'danger' : 'warm', to: '/ajustes/nube' });
if (!miembro && r.estado === 'encendido' && AxResp.fallo()) avisos.push({ k: 'respaldo', t: 'El respaldo de anoche falló', tono: 'danger', to: '/ajustes/respaldo' });
if (!avisos.length) return null;
return (
{avisos.map((a) => (
))}
);
}
// ─────────────────────────────────────────────────────────────
// PANEL «SIMULAR» · Nube del agente (#1432 #1439)
// ─────────────────────────────────────────────────────────────
function NbTwkBtn({ onClick, children, fuerte }) {
return (
);
}
const nbNotaTwk = { fontSize: 10.5, color: 'rgba(41,38,27,0.62)', lineHeight: 1.45 };
function NubeTweaks({ navigate }) {
const n = useNube();
const r = useResp();
const eq = useEquipo();
const { pushToast } = useAxStore();
window.__nbToast = pushToast;
const [copiado, setCopiado] = useState(false);
const comoPrincipal = () => AxEquipo.setVer('principal');
const comoMiembro = () => AxEquipo.setVer('miembro');
const configurada = () => { if (!AxNube.configurada()) AxNube.configurarYa('gdrive'); };
const limpio = () => { AxNube.limpiar(); AxResp.set({ carpetaExiste: true, comprobar: false }); };
const sofiaUnida = () => { configurada(); AxNube.marcarCompartida('sofia'); AxNube.unirYa(); };
const recorridos = [
{ t: '1 · Laura (principal) conecta su Google Drive, crea la carpeta y la comparte', f: () => { limpio(); comoPrincipal(); AxNube.reiniciarPrincipal(); navigate('/ajustes'); } , nota: 'Empieza en Ajustes › Equipo › «Sincronizar por tu nube».' },
{ t: '2 · Sofía (miembro, Windows) entra a la carpeta del despacho', f: () => { limpio(); configurada(); AxNube.marcarCompartida('sofia'); AxNube.reiniciarMiembro(); comoMiembro(); navigate('/equipo-sincronizacion'); }, nota: 'Empieza en Equipo › sincronización, como miembro.' },
{ t: '3 · Sofía elige una carpeta equivocada', f: () => { limpio(); configurada(); AxNube.marcarCompartida('sofia'); AxNube.set({ mPaso: 'carpeta', mCuenta: 'si', mAcceso: true, mRechazo: null }); comoMiembro(); navigate('/ajustes/nube'); } },
{ t: '4 · La red no deja la directa: Sofía sincroniza por la nube de Laura', f: () => { limpio(); sofiaUnida(); comoMiembro(); AxEquipo.setPrincipal('nube'); navigate('/equipo-sincronizacion'); }, nota: 'Mira también el indicador de la barra de arriba.' },
{ t: '5 · Un PDF todavía no llega (reintento, no perdido)', f: () => { limpio(); sofiaUnida(); comoMiembro(); AxEquipo.setPrincipal('nube'); AxNube.simularPendiente(); navigate('/ajustes/nube'); } },
{ t: '6 · El Google Drive de Laura está casi lleno', f: () => { limpio(); configurada(); comoPrincipal(); AxNube.set({ espacio: 'casi' }); navigate('/ajustes/nube'); } },
{ t: '7 · Google Drive se desconectó en la computadora de Laura', f: () => { limpio(); configurada(); comoPrincipal(); AxNube.set({ conexion: 'desconectada' }); navigate('/inicio'); }, nota: 'Aparece arriba en todas las pantallas; el aviso lleva a la nube.' },
{ t: '8 · Laura enciende el respaldo automático', f: () => { limpio(); comoPrincipal(); AxResp.apagar(); navigate('/cuenta'); }, nota: 'Empieza en Tu cuenta › «Dónde viven tus datos» › Configurar respaldo.' },
{ t: '9 · Pasó la noche: último respaldo y restaurar con el llavero', f: () => { limpio(); comoPrincipal(); AxResp.encendidoYa(); AxResp.set({ donde: 'esta' }); navigate('/ajustes/respaldo'); } },
{ t: '10 · El respaldo de anoche falló: la carpeta ya no existe', f: () => { limpio(); comoPrincipal(); AxResp.encendidoYa(); AxResp.set({ carpetaExiste: false }); AxResp.pasaNoche(); navigate('/inicio'); }, nota: 'El aviso sale arriba; Ajustes y Tu cuenta también lo dicen.' },
{ t: '11 · Restaurar en una computadora nueva (sin llavero)', f: () => { limpio(); comoPrincipal(); AxResp.encendidoYa(); AxResp.set({ donde: 'otra' }); navigate('/ajustes/respaldo?ir=restaurar'); } },
];
const preguntas = [
{ texto: 'En un despacho que mezcla Mac y Windows, ¿Piixi deja elegir iCloud?', valor: n.qIcloud,
a: 'Sí, con un aviso: «ahí iCloud se traba; te sugerimos Google Drive u OneDrive»', b: 'No: iCloud sale apagado si hay alguna computadora Windows en el equipo',
elegir: (v) => AxNube.set({ qIcloud: v }), donde: 'Sincronizar por tu nube › paso 1',
ir: () => { comoPrincipal(); AxNube.reiniciarPrincipal(); AxNube.set({ mixto: true, elegida: 'icloud' }); navigate('/ajustes/nube'); } },
{ texto: 'Cuando la directa no se puede, ¿qué dice el indicador de la barra de arriba del miembro?', valor: n.qNombre,
a: '«Por Google Drive» (el nombre de la nube)', b: '«Por la nube del despacho»',
elegir: (v) => AxNube.set({ qNombre: v }), donde: 'la barra de arriba, como miembro',
ir: () => { sofiaUnida(); comoMiembro(); AxEquipo.setPrincipal('nube'); navigate('/inicio'); } },
{ texto: 'Cuando la nube del despacho está casi llena, ¿quién ve el aviso?', valor: n.qEspacio,
a: 'Sólo la principal (es su nube y la que puede liberar espacio)', b: 'La principal y también los miembros, en la barra de arriba',
elegir: (v) => AxNube.set({ qEspacio: v }), donde: 'la barra de arriba y Nube del despacho, como miembro',
ir: () => { sofiaUnida(); AxNube.set({ espacio: 'casi' }); comoMiembro(); navigate('/ajustes/nube'); } },
{ texto: 'Al restaurar en ESTA misma computadora, ¿hay que escribir la contraseña del respaldo?', valor: r.qRestaurar,
a: 'No: Piixi usa la del llavero; sólo confirmas con la contraseña de la computadora o Touch ID', b: 'Sí, siempre se escribe (aunque esté en el llavero)',
elegir: (v) => AxResp.set({ qRestaurar: v }), donde: 'Respaldo de tu cartera › Restaurar',
ir: () => { comoPrincipal(); if (AxResp.get().estado !== 'encendido') AxResp.encendidoYa(); AxResp.set({ donde: 'esta' }); navigate('/ajustes/respaldo?ir=restaurar'); } },
{ texto: 'Como la contraseña vive en el llavero, el agente puede olvidarla. ¿Piixi se la vuelve a pedir para comprobar que la recuerda?', valor: r.qRecordar,
a: 'Sí: cada 30 días la pide una vez (y si la olvidó, la cambia ahí mismo)', b: 'No: sólo se escribe al encender el respaldo',
elegir: (v) => AxResp.set({ qRecordar: v, comprobar: v === 'A' ? AxResp.get().comprobar : false }), donde: 'Respaldo de tu cartera, tras «pasan 30 días»',
ir: () => { comoPrincipal(); if (AxResp.get().estado !== 'encendido') AxResp.encendidoYa(); AxResp.pasan30(); navigate('/ajustes/respaldo'); } },
];
const resumen = 'Nube del agente (#1432 #1439):\n' + preguntas.map((q, i) => (i + 1) + '. ' + q.texto + '\n → ' + q.valor + ': ' + (q.valor === 'B' ? q.b : q.a)).join('\n');
const copiar = () => { if (window.pregCopiar) pregCopiar(resumen); setCopiado(true); setTimeout(() => setCopiado(false), 4000); };
return (
<>
Dos pantallas nuevas: «Sincronizar por tu nube» (Ajustes › Equipo) y «Respaldo de tu cartera» (Ajustes, y desde Tu cuenta). Una nube por despacho, la de la principal; la contraseña del respaldo se guarda en el llavero. Elige una situación y navégala a clics.
{recorridos.map((x, i) => (
→ {x.t}
{x.nota ?
{x.nota}
: null}
))}
Cinco dudas abiertas. Toca A o B y la app cambia en ese momento; «Llévame ahí» te deja donde se siente la diferencia.
AxEquipo.setVer(v)}/>
{ if (v === 'ninguna') AxNube.reiniciarPrincipal(); else AxNube.configurarYa(v); }}/>
AxNube.set({ soP: v })}/>
AxNube.set({ mixto: v === 'mixto' })}/>
AxNube.set({ detecta: v === 'si' })}/>
AxNube.set({ permisoMac: v === 'si', permiso: null })}/>
AxNube.set({ espacio: v })}/>
AxNube.set({ conexion: v })}/>
AxNube.simularPendiente()}>→ Un archivo todavía no llega AxNube.llego()}>→ Tu nube ya lo bajó (llega y se aplica) { AxNube.marcarCompartida('sofia'); AxNube.unirYa(); }}>→ Sofía ya entró a la carpeta AxNube.reiniciarMiembro()}>→ Sofía vuelve a empezar
{ if (v === 'on') AxResp.encendidoYa(); else AxResp.apagar(); }}/>
AxResp.set({ carpetaExiste: v === 'existe' })}/>
AxResp.set({ detectada: v })}/>
AxResp.set({ donde: v })}/>
AxResp.set({ abre: v === 'abre' })}/>
AxResp.pasaNoche()}>→ Pasa la noche (corre el respaldo) { AxResp.pasan30(); if (AxResp.get().qRecordar === 'B') pushToast({ kind: 'info', message: 'Con la respuesta B no pasa nada: Piixi no vuelve a pedir la contraseña.' }); }}>→ Pasan 30 días