@decido/shell-vscode-core 4.0.1 → 4.0.3

package/src/core/NotificationService.ts

@@ -1,53 +0,0 @@
-// /src/core/NotificationService.ts (REDISENADO)
-
-import { html } from "../utils.js";
-
-export type NotificationType = 'info' | 'success' | 'warning' | 'error' | 'achievement';
-
-export class NotificationService {
-    public container: HTMLElement;
-
-    constructor() {
-        this.container = document.createElement('div');
-        this.container.id = 'notification-container';
-        this.container.className = 'fixed top-5 right-5 z-10000 w-96 space-y-3';
-        document.body.appendChild(this.container);
-    }
-
-    public show(type: NotificationType, title: string, message: string, duration: number = 4000) {
-        const id = `notif_${Date.now()}`;
-        const notificationEl = document.createElement('div');
-        notificationEl.id = id;
-        
-        const typeStyles = {
-            info: { icon: 'fas fa-info-circle', color: 'border-secondary' },
-            success: { icon: 'fas fa-check-circle', color: 'border-success' },
-            warning: { icon: 'fas fa-exclamation-triangle', color: 'border-accent' },
-            error: { icon: 'fas fa-times-circle', color: 'border-danger' },
-            achievement: { icon: 'fas fa-trophy', color: 'border-accent' },
-        };
-        const styles = typeStyles[type];
-
-        // Usamos la estética glass-card con un borde de color distintivo
-        notificationEl.innerHTML = html`
-            <div class="notification-item glass-card animate-slide-in-right border-l-4 ${styles.color}">
-                <i class="notification-icon ${styles.icon}"></i>
-                <div class="flex-grow">
-                    <h4 class="notification-title">${title}</h4>
-                    <p class="notification-message">${message}</p>
-                </div>
-                <button class="notification-close-btn" data-close-id="${id}">&times;</button>
-            </div>
-        `;
-
-        notificationEl.querySelector('.notification-close-btn')?.addEventListener('click', () => {
-            notificationEl.remove();
-        });
-
-        this.container.appendChild(notificationEl);
-
-        setTimeout(() => {
-            document.getElementById(id)?.remove();
-        }, duration);
-    }
-}

package/src/core/RouterService.ts

@@ -1,68 +0,0 @@
-// src/core/RouterService.ts
-import { authService } from './AuthService.js';
-import { IPlatformAPI } from './api.js';
-import { RouteDefinition } from '../types';
-
-export class RouterService {
-    private routes: RouteDefinition[] = [];
-    private api!: IPlatformAPI;
-
-    public init(api: IPlatformAPI) {
-        this.api = api;
-        window.addEventListener('hashchange', this.handleRouteChange);
-        // window.addEventListener('load', this.handleRouteChange);
-    }
-
-    public registerRoute(route: RouteDefinition) {
-        this.routes.push(route);
-    }
-
-    public navigate(path: string) {
-        window.location.hash = path;
-    }
-
-    // Centraliza la lectura del hash en un solo lugar.
-    private _getCurrentHash(): string {
-        return window.location.hash.slice(1) || '/';
-    }
-
-    public handleRouteChange = () => {
-        const path = this._getCurrentHash();
-        const route = this.routes.find(r => r.path === path);
-        const session = authService.session[0](); // Obtenemos el estado actual de la sesión
-
-        if (!route) {
-            // Ruta no encontrada, podríamos redirigir a una página 404
-            console.error(`Ruta no encontrada: ${path}`);
-            this.api.layout.renderComponent('not-found-view');
-            return;
-        }
-
-        // --- LÓGICA DE GUARDIÁN DE NAVEGACIÓN ---
-        const isAuthenticated = session.status === 'authenticated';
-
-        // 1. Si la ruta es protegida y el usuario no está autenticado...
-        if (route.auth === 'protected' && !isAuthenticated) {
-            this.navigate('/login'); // ...redirige al login.
-            return;
-        }
-
-        // 2. Si la ruta es solo para invitados (como login) y el usuario ya está autenticado...
-        if (route.auth === 'guestOnly' && isAuthenticated) {
-            this.navigate('/dashboard'); // ...redirige al dashboard.
-            return;
-        }
-
-        // 3. (Futuro) Si la ruta requiere roles específicos...
-        // if (route.roles && !route.roles.some(role => session.user?.roles.includes(role))) {
-        //     this.navigate('/forbidden'); // ...redirige a "Acceso Denegado".
-        //     return;
-        // }
-
-        // Si todas las comprobaciones pasan, renderizamos el componente.
-        if (route.title) document.title = `Decido - ${route.title}`;
-        this.api.layout.renderComponent(route.componentTag, { isFullscreen: route.isFullscreen });
-    }
-}
-
-export const routerService = new RouterService();

package/src/core/ServiceContainer.ts

@@ -1,31 +0,0 @@
-import { ServiceKey, ServiceRegistry } from "../platform/ServiceRegistry.js";
-
-/**
- * Un contenedor de inyección de dependencias tipado y genérico.
- */
-export class ServiceContainer {
-    private services = new Map<ServiceKey, any>();
-
-    /**
-     * Registra una instancia de un servicio.
-     * El tipo es validado contra el `ServiceRegistry`.
-     */
-    public register<K extends ServiceKey>(key: K, instance: ServiceRegistry[K]): void {
-        if (this.services.has(key)) {
-            console.warn(`[ServiceContainer] El servicio '${key}' ya está registrado. Se sobrescribirá.`);
-        }
-        this.services.set(key, instance);
-    }
-
-    /**
-     * Obtiene la instancia de un servicio registrado.
-     * El tipo de retorno es inferido automáticamente a partir de la clave.
-     */
-    public get<K extends ServiceKey>(key: K): ServiceRegistry[K] {
-        const service = this.services.get(key);
-        if (!service) {
-            throw new Error(`[ServiceContainer] No se encontró servicio registrado con la clave: ${key}`);
-        }
-        return service;
-    }
-}

package/src/core/ShortcutService.ts

@@ -1,49 +0,0 @@
-// /src/core/ShortcutService.ts
-
-import { IPlatformAPI } from "./api.js";
-
-interface Shortcut {
-    id: string;
-    keys: string; // Ej: "Control+K", "Shift+N"
-    commandId: string;
-    commandArg?: any;
-    description?: string;
-}
-
-export class ShortcutService {
-    private api!: IPlatformAPI;
-    private shortcuts: Map<string, Shortcut> = new Map();
-
-    public init(api: IPlatformAPI) {
-        this.api = api;
-        window.addEventListener('keydown', this.handleKeyDown.bind(this));
-    }
-
-    public register(shortcut: Shortcut) {
-        // La clave será una combinación normalizada, ej: "control_k"
-        const key = shortcut.keys.toLowerCase().split('+').sort().join('_');
-        this.shortcuts.set(key, shortcut);
-    }
-
-    private handleKeyDown(e: KeyboardEvent) {
-        const keyParts: string[] = [];
-        if (e.ctrlKey) keyParts.push('control');
-        if (e.metaKey) keyParts.push('meta'); // Cmd en Mac
-        if (e.shiftKey) keyParts.push('shift');
-        if (e.altKey) keyParts.push('alt');
-
-        // Evitamos que modificadores solos disparen algo
-        if (!['Control', 'Meta', 'Shift', 'Alt'].includes(e.key)) {
-            keyParts.push(e.key.toLowerCase());
-        }
-
-        if (keyParts.length > 1) {
-            const key = keyParts.sort().join('_');
-            const shortcut = this.shortcuts.get(key);
-            if (shortcut) {
-                e.preventDefault();
-                this.api.commands.execute(shortcut.commandId, shortcut.commandArg);
-            }
-        }
-    }
-}

package/src/core/StorageService.ts

@@ -1,123 +0,0 @@
-// src/core/StorageService.ts
-import { DailySnapshot, db, ModuleData, LocalProject } from "../lib/local-db.js";
-
-
-
-
-export class StorageService {
-    // --- Métodos para Colecciones de Entidades (Tareas, Metas, etc.) ---
-
-    async getCollection<T>(entityType: string): Promise<T[]> {
-        const results = await db.moduleData.where({ entityType }).toArray();
-        return results.map((item: { data: T; }) => item.data as T);
-    }
-
-    async saveEntity<T extends { id: string | number }>(entityType: string, entity: T): Promise<void> {
-        const record: ModuleData = {
-            id: `${entityType}-${entity.id}`,
-            entityId: entity.id,
-            moduleId: entityType + 's',
-            entityType: entityType,
-            data: entity
-        };
-        await db.moduleData.put(record);
-    }
-
-    async deleteEntity(entityType: string, entityId: string | number): Promise<void> {
-        await db.moduleData.delete(`${entityType}-${entityId}`);
-    }
-
-    // --- Métodos para Objetos de Estado Únicos (Journal, Settings, etc.) ---
-
-    async getValue<T>(key: string): Promise<T | undefined> {
-        const result = await db.moduleData.get(`value-${key}`);
-        return result ? result.data as T : undefined;
-    }
-
-    async saveValue<T>(key: string, value: T): Promise<void> {
-        const record: ModuleData = {
-            id: `value-${key}`,
-            entityId: key,
-            moduleId: 'values',
-            entityType: 'value',
-            data: value
-        };
-        await db.moduleData.put(record);
-    }
-
-    /**
-    * Guarda un snapshot completo del estado de la aplicación para una fecha específica.
-    * La fecha se guarda en formato 'YYYY-MM-DD'.
-    * @param date La fecha del snapshot.
-    * @param state El objeto de estado completo a guardar.
-    */
-    async saveDailySnapshot(date: Date, state: any): Promise<void> {
-        const dateKey = date.toISOString().split('T')[0]; // 'YYYY-MM-DD'
-        const snapshotRecord: DailySnapshot = {
-            date: dateKey,
-            data: state,
-            timestamp: new Date()
-        };
-        // `put` sobreescribirá si ya existe un snapshot para ese día.
-        await db.dailySnapshots.put(snapshotRecord);
-        console.log(`📸 Snapshot guardado para la fecha: ${dateKey}`);
-    }
-
-    /**
-     * Recupera el snapshot de un día específico.
-     * @param date La fecha del snapshot a recuperar.
-     * @returns El estado guardado para esa fecha, o undefined si no existe.
-     */
-    async getDailySnapshot(date: Date): Promise<any | undefined> {
-        const dateKey = date.toISOString().split('T')[0];
-        const result = await db.dailySnapshots.get(dateKey);
-        return result ? result.data : undefined;
-    }
-
-    /**
-     * Obtiene una lista de todas las fechas para las que existe un snapshot.
-     * @returns Un array de strings con las fechas en formato 'YYYY-MM-DD'.
-     */
-    async getAvailableSnapshotDates(): Promise<string[]> {
-        return await db.dailySnapshots.toCollection().keys() as string[];
-    }
-
-    // --- PROYECTOS (Manejo de datos pesados) ---
-
-    async saveProject(id: string, name: string, flowData: any) {
-        // IndexedDB es asíncrono, no bloquea la UI
-        await db.projects.put({
-            id,
-            name,
-            data: flowData, // Aquí puedes guardar MBs de nodos sin problema
-            updatedAt: Date.now()
-        });
-        console.log(`💾 Proyecto ${id} guardado en IndexedDB`);
-    }
-
-    async getProject(id: string): Promise<LocalProject | undefined> {
-        return await db.projects.get(id);
-    }
-
-    async getAllProjectsMetadata() {
-        // Solo traemos ID y Nombre para la lista del sidebar (rápido)
-        return await db.projects.toArray();
-    }
-
-    async deleteProject(id: string) {
-        await db.projects.delete(id);
-    }
-
-    // --- CONFIGURACIÓN (Settings ligeros) ---
-
-    async setSetting(key: string, value: any) {
-        await db.settings.put({ key, value });
-    }
-
-    async getSetting(key: string) {
-        const item = await db.settings.get(key);
-        return item?.value;
-    }
-}
-
-export const storageService = new StorageService();

package/src/core/ThemeService.ts

@@ -1,71 +0,0 @@
-// src/core/ThemeService.ts
-import { createSignal } from './signals.js';
-
-export type Theme = 'dark' | 'light';
-
-// Valores por defecto para los temas
-const themes = {
-    dark: {
-        '--bg-main': '#070720',
-        '--bg-content': '#0F0F23',
-        '--bg-surface': 'rgba(255, 255, 255, 0.03)',
-        '--text-primary': '#FFFFFF',
-        '--text-secondary': '#9CA3AF',
-    },
-    light: {
-        '--bg-main': '#f8f9fa',
-        '--bg-content': '#FFFFFF',
-        '--bg-surface': 'rgba(0, 0, 0, 0.03)',
-        '--text-primary': '#212529',
-        '--text-secondary': '#495057',
-    }
-};
-
-export class ThemeService {
-    public activeTheme: ReturnType<typeof createSignal<Theme>>;
-
-    constructor() {
-        const savedTheme = localStorage.getItem('decido-theme') as Theme || 'dark';
-        this.activeTheme = createSignal(savedTheme);
-        this.applyTheme(savedTheme);
-    }
-
-    public setTheme(themeName: Theme): void {
-        this.activeTheme[1](themeName); // Actualiza la señal
-        this.applyTheme(themeName);
-        localStorage.setItem('decido-theme', themeName);
-    }
-
-    private applyTheme(themeName: Theme) {
-        const theme = themes[themeName];
-        for (const [key, value] of Object.entries(theme)) {
-            document.documentElement.style.setProperty(key, value);
-        }
-    }
-
-    // Permite actualizar un token individual en tiempo real para el panel
-    public updateToken(tokenName: string, value: string) {
-        document.documentElement.style.setProperty(tokenName, value);
-    }
-
-    public applyPalette(palette: Record<string, string>) {
-        const tokenMap = {
-            primary: '--color-primary',
-            secondary: '--color-secondary',
-            accent: '--color-accent',
-            bgMain: '--bg-main',
-            bgContent: '--bg-content',
-            textPrimary: '--text-primary',
-            textSecondary: '--text-secondary',
-        };
-
-        for (const [key, value] of Object.entries(palette)) {
-            const tokenName = tokenMap[key as keyof typeof tokenMap];
-            if (tokenName) {
-                this.updateToken(tokenName, value);
-            }
-        }
-    }
-}
-
-export const themeService = new ThemeService();

package/src/core/WebSocketService.ts

@@ -1,32 +0,0 @@
-// File: packages/core/src/core/WebSocketService.ts
-
-import { IPlatformAPI } from './api';
-
-// Define los estados posibles de la conexión para un control claro.
-type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
-
-/**
- * Servicio Mock de WebSocket. Desactivado para la transición a Micro-IDE.
- */
-export class WebSocketService {
-    private api!: IPlatformAPI;
-    private status: ConnectionStatus = 'disconnected';
-
-    /**
-     * @param api La instancia de la API de la plataforma.
-     */
-    public init(api: IPlatformAPI): void {
-        this.api = api;
-        console.log("🔌 WebSocketService (Mock) inicializado en modo Offline.");
-    }
-
-    public connect(): void {
-        console.log("[WebSocket] Ignorado: Conectando local (Micro-IDE).");
-    }
-
-    public disconnect(): void { }
-
-    public emit(eventName: string, payload: any): void {
-        console.log(`[WebSocket Mock] Envío evadido: ${eventName}`, payload);
-    }
-}

package/src/core/api.ts

@@ -1,78 +0,0 @@
-// src/platform/api.ts
-import { CommandService } from "./CommandService.js";
-import { EventBus } from "./EventBus.js";
-import { ILayoutService } from "../platform"
-import { ModalService } from "./ModalService.js";
-import { NotificationService } from "./NotificationService.js";
-import * as state from '../appState.js';
-import { GamificationService } from "./GamificationService.js";
-import { CalendarService } from "./CalendarService.js";
-import { ShortcutService } from "./ShortcutService.js";
-import { ModuleManager } from "./app/ModuleManager.js";
-import { ThemeService } from "./ThemeService.js";
-import { AuthService } from './AuthService.js';
-import { RouterService } from "./RouterService.js";
-import { StorageService } from "./StorageService.js";
-import { SyncService } from "../lib/sync-service.js";
-import { ServiceKey, ServiceRegistry } from '../platform/ServiceRegistry.js';
-import { ServiceContainer } from "./ServiceContainer.js";
-import { HookService } from "./index.js";
-import { DebugService } from "./DebugService.js";
-import { WebSocketService } from "./WebSocketService.js";
-
-
-/**
- * La API de la Plataforma que se expone a cada módulo.
- * Actúa como un contrato bien definido entre el núcleo de la app y sus extensiones.
- */
-export interface IPlatformAPI {
-    debug?: DebugService;
-    events: EventBus;
-    commands: CommandService;
-    layout: ILayoutService;
-    modals: ModalService;
-    notifications: NotificationService;
-    gamification: GamificationService;
-    calendar: CalendarService;
-    shortcuts: ShortcutService; 
-    state: typeof state;
-    theme: ThemeService;
-    storage: StorageService;
-    sync: SyncService;
-    router?: RouterService;
-
-    moduleManager: ModuleManager | null;
-    container: ServiceContainer;
-    readonly hooks: HookService;
-    websocket: WebSocketService;
-
-    // --- Acceso a la API del Backend ---
-    readonly modules: {
-        rateModule(id: any, rating: number, review: string): unknown;
-        getModuleById(moduleId: string): unknown;
-        getCategories(): any[] | PromiseLike<any[]>;
-        getModules: () => Promise<any[]>;
-        getInstalledModules: () => Promise<any[]>;
-        uploadModule: (formData: FormData) => Promise<any>;
-        installModule: (moduleId: string) => Promise<any>;
-        getProfile: () => Promise<any>;
-        updateProfile: (profileData: any) => Promise<any>;
-    };
-    readonly timetravel: {
-        revertToDate: (date: String) => Promise<any>;
-        getSnapshotDates(): Promise<any>;
-        getPreviousActivityDate: (date: String) => Promise<any>;
-        getNextActivityDate: (date: String) => Promise<any>;
-    };
-    readonly auth: AuthService;
-    readonly ai: {
-        generateTheme: (prompt: string) => Promise<any>;
-        // ... otros métodos de IA
-    };
-
-    // El API de servicios ahora es una fachada para el contenedor
-    readonly services: {
-        register<K extends keyof ServiceRegistry>(key: K, instance: ServiceRegistry[K]): void;
-        get<K extends keyof ServiceRegistry>(key: K): Promise<ServiceRegistry[K]>;
-    };
-}