npm package: @jamx-framework/adapter-tauri
Description: JAMX Framework â€” Tauri desktop adapter
Author: Stiven-21
Latest version: 2.0.0

# @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
```typescript
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
```typescript
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
```typescript
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
```typescript
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.