wu-framework 1.0.0

package/src/core/wu-loader.js

@@ -0,0 +1,271 @@
+/**
+ * 🚀 WU-LOADER: SISTEMA DE CARGA DINÁMICA UNIVERSAL
+ * Carga aplicaciones y componentes sin depender del framework
+ */
+
+export class WuLoader {
+  constructor() {
+    this.cache = new Map();
+    this.loadingPromises = new Map();
+
+    console.log('[WuLoader] 📦 Dynamic loader initialized');
+  }
+
+  /**
+   * Cargar aplicación completa
+   * @param {string} appUrl - URL base de la aplicación
+   * @param {Object} manifest - Manifest de la aplicación
+   * @returns {string} Código JavaScript de la aplicación
+   */
+  async loadApp(appUrl, manifest) {
+    const entryFile = manifest?.entry || 'index.js';
+    const fullUrl = `${appUrl}/${entryFile}`;
+
+    console.log(`[WuLoader] 📥 Loading app from: ${fullUrl}`);
+
+    try {
+      // Verificar cache
+      if (this.cache.has(fullUrl)) {
+        console.log(`[WuLoader] ⚡ Cache hit for: ${fullUrl}`);
+        return this.cache.get(fullUrl);
+      }
+
+      // Verificar si ya está cargando
+      if (this.loadingPromises.has(fullUrl)) {
+        console.log(`[WuLoader] ⏳ Loading in progress for: ${fullUrl}`);
+        return await this.loadingPromises.get(fullUrl);
+      }
+
+      // Crear promesa de carga
+      const loadingPromise = this.fetchCode(fullUrl);
+      this.loadingPromises.set(fullUrl, loadingPromise);
+
+      const code = await loadingPromise;
+
+      // Limpiar promesa de carga y cachear resultado
+      this.loadingPromises.delete(fullUrl);
+      this.cache.set(fullUrl, code);
+
+      console.log(`[WuLoader] ✅ App loaded successfully: ${fullUrl}`);
+      return code;
+
+    } catch (error) {
+      this.loadingPromises.delete(fullUrl);
+      console.error(`[WuLoader] ❌ Failed to load app: ${fullUrl}`, error);
+      throw new Error(`Failed to load app from ${fullUrl}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Cargar componente específico
+   * @param {string} appUrl - URL base de la aplicación
+   * @param {string} componentPath - Ruta del componente
+   * @returns {Function} Función del componente
+   */
+  async loadComponent(appUrl, componentPath) {
+    // Normalizar ruta del componente
+    let normalizedPath = componentPath;
+    if (normalizedPath.startsWith('./')) {
+      normalizedPath = normalizedPath.substring(2);
+    }
+    if (!normalizedPath.endsWith('.js') && !normalizedPath.endsWith('.jsx')) {
+      normalizedPath += '.js';
+    }
+
+    const fullUrl = `${appUrl}/${normalizedPath}`;
+
+    console.log(`[WuLoader] 🧩 Loading component from: ${fullUrl}`);
+
+    try {
+      // Cargar código del componente
+      const code = await this.loadCode(fullUrl);
+
+      // Crear función que retorna el componente
+      const componentFunction = new Function('require', 'module', 'exports', `
+        ${code}
+        return typeof module.exports === 'function' ? module.exports :
+               typeof module.exports === 'object' && module.exports.default ? module.exports.default :
+               exports.default || exports;
+      `);
+
+      // Ejecutar y obtener el componente
+      const fakeModule = { exports: {} };
+      const fakeRequire = (name) => {
+        console.warn(`[WuLoader] Component ${componentPath} requires ${name} - not supported yet`);
+        return {};
+      };
+
+      const component = componentFunction(fakeRequire, fakeModule, fakeModule.exports);
+
+      console.log(`[WuLoader] ✅ Component loaded: ${componentPath}`);
+      return component;
+
+    } catch (error) {
+      console.error(`[WuLoader] ❌ Failed to load component: ${componentPath}`, error);
+      throw new Error(`Failed to load component ${componentPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Cargar código con cache
+   * @param {string} url - URL del archivo
+   * @returns {string} Código JavaScript
+   */
+  async loadCode(url) {
+    // Verificar cache
+    if (this.cache.has(url)) {
+      return this.cache.get(url);
+    }
+
+    // Verificar si ya está cargando
+    if (this.loadingPromises.has(url)) {
+      return await this.loadingPromises.get(url);
+    }
+
+    // Crear promesa de carga
+    const loadingPromise = this.fetchCode(url);
+    this.loadingPromises.set(url, loadingPromise);
+
+    try {
+      const code = await loadingPromise;
+      this.loadingPromises.delete(url);
+      this.cache.set(url, code);
+      return code;
+    } catch (error) {
+      this.loadingPromises.delete(url);
+      throw error;
+    }
+  }
+
+  /**
+   * Realizar fetch del código
+   * @param {string} url - URL del archivo
+   * @returns {string} Código JavaScript
+   */
+  async fetchCode(url) {
+    const response = await fetch(url, {
+      cache: 'no-cache',
+      headers: {
+        'Accept': 'application/javascript, text/javascript, */*'
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const code = await response.text();
+
+    if (!code.trim()) {
+      throw new Error('Empty response');
+    }
+
+    return code;
+  }
+
+  /**
+   * Precargar aplicaciones
+   * @param {Array} appConfigs - Configuraciones de aplicaciones
+   */
+  async preload(appConfigs) {
+    console.log(`[WuLoader] 🚀 Preloading ${appConfigs.length} apps...`);
+
+    const preloadPromises = appConfigs.map(async (config) => {
+      try {
+        await this.loadApp(config.url, config.manifest);
+        console.log(`[WuLoader] ✅ Preloaded: ${config.name}`);
+      } catch (error) {
+        console.warn(`[WuLoader] ⚠️ Failed to preload ${config.name}:`, error.message);
+      }
+    });
+
+    await Promise.allSettled(preloadPromises);
+    console.log(`[WuLoader] 🎉 Preload completed`);
+  }
+
+  /**
+   * Verificar si una URL está disponible
+   * @param {string} url - URL a verificar
+   * @returns {boolean} True si está disponible
+   */
+  async isAvailable(url) {
+    try {
+      const response = await fetch(url, { method: 'HEAD' });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Resolver dependencias de imports
+   * @param {Array} imports - Lista de imports del manifest
+   * @param {Map} availableApps - Apps disponibles
+   */
+  async resolveDependencies(imports, availableApps) {
+    const resolved = new Map();
+
+    for (const importPath of imports || []) {
+      const [appName, componentName] = importPath.split('.');
+
+      if (!appName || !componentName) {
+        console.warn(`[WuLoader] Invalid import format: ${importPath}`);
+        continue;
+      }
+
+      const app = availableApps.get(appName);
+      if (!app) {
+        console.warn(`[WuLoader] Import app not found: ${appName}`);
+        continue;
+      }
+
+      const manifest = app.manifest;
+      const exportPath = manifest?.wu?.exports?.[componentName];
+
+      if (!exportPath) {
+        console.warn(`[WuLoader] Export not found: ${importPath}`);
+        continue;
+      }
+
+      try {
+        const component = await this.loadComponent(app.url, exportPath);
+        resolved.set(importPath, component);
+        console.log(`[WuLoader] ✅ Resolved dependency: ${importPath}`);
+      } catch (error) {
+        console.error(`[WuLoader] ❌ Failed to resolve: ${importPath}`, error);
+      }
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Limpiar cache
+   * @param {string} pattern - Patrón opcional para limpiar URLs específicas
+   */
+  clearCache(pattern) {
+    if (pattern) {
+      const regex = new RegExp(pattern);
+      for (const [url] of this.cache) {
+        if (regex.test(url)) {
+          this.cache.delete(url);
+          console.log(`[WuLoader] 🗑️ Cleared cache for: ${url}`);
+        }
+      }
+    } else {
+      this.cache.clear();
+      console.log(`[WuLoader] 🗑️ Cache cleared completely`);
+    }
+  }
+
+  /**
+   * Obtener estadísticas del loader
+   */
+  getStats() {
+    return {
+      cached: this.cache.size,
+      loading: this.loadingPromises.size,
+      cacheKeys: Array.from(this.cache.keys())
+    };
+  }
+}

package/src/core/wu-logger.js

@@ -0,0 +1,119 @@
+/**
+ * 📝 WU-LOGGER: Sistema de logging inteligente para entornos
+ * Controla los logs automáticamente según el entorno
+ */
+
+export class WuLogger {
+  constructor() {
+    // Detectar entorno automáticamente
+    this.isDevelopment = this.detectEnvironment();
+    this.logLevel = this.isDevelopment ? 'debug' : 'error';
+
+    this.levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+  }
+
+  /**
+   * Detectar si estamos en desarrollo
+   */
+  detectEnvironment() {
+    // Múltiples formas de detectar desarrollo
+    return (
+      // Vite development
+      window.location.hostname === 'localhost' ||
+      window.location.hostname === '127.0.0.1' ||
+      window.location.port !== '' ||
+      // NODE_ENV si está disponible
+      (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') ||
+      // URL params para forzar debug
+      new URLSearchParams(window.location.search).has('wu-debug') ||
+      // Manual override
+      window.WU_DEBUG === true
+    );
+  }
+
+  /**
+   * Configurar nivel de logging
+   */
+  setLevel(level) {
+    this.logLevel = level;
+    return this;
+  }
+
+  /**
+   * Habilitar/deshabilitar development mode
+   */
+  setDevelopment(isDev) {
+    this.isDevelopment = isDev;
+    this.logLevel = isDev ? 'debug' : 'error';
+    return this;
+  }
+
+  /**
+   * Verificar si debemos mostrar el log
+   */
+  shouldLog(level) {
+    return this.levels[level] >= this.levels[this.logLevel];
+  }
+
+  /**
+   * Logging methods
+   */
+  debug(...args) {
+    if (this.shouldLog('debug')) {
+      console.log(...args);
+    }
+  }
+
+  info(...args) {
+    if (this.shouldLog('info')) {
+      console.info(...args);
+    }
+  }
+
+  warn(...args) {
+    if (this.shouldLog('warn')) {
+      console.warn(...args);
+    }
+  }
+
+  error(...args) {
+    if (this.shouldLog('error')) {
+      console.error(...args);
+    }
+  }
+
+  /**
+   * Logging con contexto Wu
+   */
+  wu(level, ...args) {
+    if (this.shouldLog(level)) {
+      const method = level === 'debug' ? 'log' : level;
+      console[method]('[Wu]', ...args);
+    }
+  }
+
+  /**
+   * Helper methods específicos para Wu
+   */
+  wuDebug(...args) { this.wu('debug', ...args); }
+  wuInfo(...args) { this.wu('info', ...args); }
+  wuWarn(...args) { this.wu('warn', ...args); }
+  wuError(...args) { this.wu('error', ...args); }
+}
+
+// Singleton instance
+export const logger = new WuLogger();
+
+// Helper para compatibilidad con logs existentes
+export const wuLog = {
+  debug: (...args) => logger.wuDebug(...args),
+  info: (...args) => logger.wuInfo(...args),
+  warn: (...args) => logger.wuWarn(...args),
+  error: (...args) => logger.wuError(...args)
+};