@jamx-framework/adapter-tauri

Descripción

Adaptador de JAMX Framework para aplicaciones de escritorio basadas en Tauri. Permite crear aplicaciones de escritorio con una API consistente que combina la potencia de Rust y la simplicidad de TypeScript, ofreciendo acceso a funcionalidades del sistema operativo, gestión de ventanas, notificaciones, almacenamiento y más a través de una interfaz moderna y tipada.

Cómo funciona

El adaptador proporciona servicios y managers que encapsulan las APIs nativas de Tauri, simulando su comportamiento en entornos de prueba y proporcionando tipado completo. Todos los servicios están diseñados para ser utilizados mediante inyección de dependencias o mediante instancias directas, y se integran con la arquitectura de JAMX mediante tipos e interfaces compartidas.

Componentes principales

• src/dialog.ts: Servicio de diálogos nativos (open, save, confirm, message)
• src/fs.ts: Sistema de archivos con operaciones de lectura, escritura y manipulación de directorios
• src/notifications.ts: Gestor de notificaciones de escritorio con permisos y envío
• src/store.ts: Almacenamiento persistente compatible con tauri-plugin-store
• src/system.ts: Información del sistema operativo y recursos del hardware
• src/window.ts: Gestor de ventanas con creación, configuración y control
• src/tray.ts: Sistema de bandeja de notificación con menús y eventos
• src/index.ts: Punto de exportación que reúne todos los servicios
• src/types.ts: Definiciones de tipos compartidos (WindowConfig, SystemInfo, etc.)

Uso básico

import {
  WindowManager,
  TauriFs,
  DialogService,
  DesktopNotifications,
  TauriStore,
  SystemService,
} from '@jamx-framework/adapter-tauri';

// Inicializar servicios
const windowManager = new WindowManager();
const fs = new TauriFs();
const dialog = new DialogService();
const notifications = new DesktopNotifications();
const store = new TauriStore('app-data');
const system = new SystemService();

// Crear ventana
const windowState = await windowManager.create({
  label: 'main',
  title: 'Mi Aplicación JAMX',
  width: 1024,
  height: 720,
});

// Mostrar diálogo de selección de archivo
const result = await dialog.open({
  title: 'Selecciona un archivo',
  filters: [DialogService.filter('Archivos de texto', '.txt', '.md')],
});
console.log('Archivo seleccionado:', result);

// Leer y escribir archivo
await fs.writeTextFile('/tmp/prueba.txt', 'Hola desde JAMX');
const content = await fs.readTextFile('/tmp/prueba.txt');
console.log('Contenido:', content);

// Enviar notificación
await notifications.requestPermission();
await notifications.send({
  title: '¡Bienvenido!',
  body: 'Tu aplicación JAMX está lista para usar.',
});

// Acceder a información del sistema
console.log('Sistema operativo:', system.os);
console.log('Memoria total (GB):', (system.totalMemory / (1024 ** 3)).toFixed(2));

// Usar almacenamiento persistente
await store.set('user-settings', { theme: 'dark', language: 'es' });
const settings = await store.get<{ theme: string; language: string }>('user-settings');
console.log('Configuración:', settings);

Ejemplos

Gestión avanzada de ventanas

import { WindowManager } from '@jamx-framework/adapter-tauri';

const manager = new WindowManager();

// Crear ventana secundaria
const splashWindow = await manager.create({
  label: 'splash',
  title: 'Pantalla de Bienvenida',
  width: 400,
  height: 300,
  fullscreen: false,
});

// Configurar propiedades
await manager.resize('splash', 500, 400);
await manager.setTitle('splash', 'Bienvenido a JAMX');
await manager.focus('splash');

// Escucha de eventos (simulado para tests)
const windows = manager.getAll();
console.log('Ventanas abiertas:', windows.length);

Uso con inyección de dependencias

import { Container } from '@jamx-framework/core';
import {
  WindowManager,
  SystemService,
  DesktopNotifications,
} from '@jamx-framework/adapter-tauri';

// Registrar servicios
Container.registerSingleton('windowManager', () => new WindowManager());
Container.registerSingleton('system', () => new SystemService());
Container.registerSingleton('notifications', () => new DesktopNotifications());

// Resolver e usar
const windowManager = Container.resolve('windowManager');
const system = Container.resolve('system');

const window = await windowManager.create({
  label: 'app',
  title: 'Aplicación JAMX',
  width: 800,
  height: 600,
});

console.log('Sistema operativo:', system.os);
console.log('Arquitectura:', system.arch);

Simulación en tests

import { DialogService } from '@jamx-framework/adapter-tauri';

const dialog = new DialogService();
dialog.setNextOpenResult('/tmp/test.txt'); // Simular resultado de open dialog
dialog.setNextConfirmResult(false); // Simular cancelación en confirm

const result = await dialog.open();
console.log('Resultado simulado:', result);

Flujo interno

1. Servicios: Cada funcionalidad (ventanas, archivos, notificaciones, etc.) está encapsulada en su propio servicio
2. Tipado: Todos los métodos y propiedades están tipados con interfaces definidas en types.ts
3. Simulación: En entornos de prueba, los servicios usan implementaciones mock para evitar dependencias nativas
4. Integración: Los servicios pueden ser registrados en el contenedor de dependencias de JAMX para inyección automática
5. Eventos: Sistemas como NetworkMonitor (si está presente) emiten eventos de cambio de estado que pueden ser suscritos
6. Persistencia: TauriStore y otros servicios mantienen estado interno pero están diseñados para ser stateless cuando es posible

Este adaptador permite a los desarrolladores de JAMX construir aplicaciones de escritorio completas con acceso a funcionalidades del sistema de forma consistente entre Windows, macOS y Linux, manteniendo una arquitectura modular, testeable y con tipado completo.