wu-framework 1.0.0

package/src/core/wu-manifest.js

@@ -0,0 +1,366 @@
+/**
+ * 📋 WU-MANIFEST: SISTEMA DE MANIFIESTOS SIMPLIFICADO
+ * Maneja wu.json sin complicaciones innecesarias
+ */
+
+export class WuManifest {
+  constructor() {
+    this.cache = new Map();
+    this.schemas = new Map();
+
+    // Definir schema básico
+    this.defineSchema();
+
+    console.log('[WuManifest] 📋 Manifest system initialized');
+  }
+
+  /**
+   * Definir schema de validación para wu.json
+   */
+  defineSchema() {
+    this.schemas.set('wu.json', {
+      required: ['name', 'entry'],
+      optional: ['wu'],
+      wu: {
+        optional: ['exports', 'imports', 'routes', 'permissions'],
+        exports: 'object',
+        imports: 'array',
+        routes: 'array',
+        permissions: 'array'
+      }
+    });
+  }
+
+  /**
+   * Cargar manifest desde URL
+   * @param {string} appUrl - URL base de la aplicación
+   * @returns {Object} Manifest parseado y validado
+   */
+  async load(appUrl) {
+    const manifestUrl = `${appUrl}/wu.json`;
+
+    console.log(`[WuManifest] 📥 Loading manifest: ${manifestUrl}`);
+
+    try {
+      // Verificar cache
+      if (this.cache.has(manifestUrl)) {
+        console.log(`[WuManifest] ⚡ Cache hit: ${manifestUrl}`);
+        return this.cache.get(manifestUrl);
+      }
+
+      // Cargar manifest
+      const response = await fetch(manifestUrl, {
+        cache: 'no-cache',
+        headers: {
+          'Accept': 'application/json'
+        }
+      });
+
+      if (!response.ok) {
+        // Si no hay manifest, crear uno básico
+        if (response.status === 404) {
+          console.log(`[WuManifest] 📄 No manifest found, creating default for: ${appUrl}`);
+          return this.createDefaultManifest(appUrl);
+        }
+
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const manifestText = await response.text();
+      const manifest = JSON.parse(manifestText);
+
+      // Validar manifest
+      const validatedManifest = this.validate(manifest);
+
+      // Cachear resultado
+      this.cache.set(manifestUrl, validatedManifest);
+
+      console.log(`[WuManifest] ✅ Manifest loaded: ${manifest.name}`);
+      return validatedManifest;
+
+    } catch (error) {
+      console.error(`[WuManifest] ❌ Failed to load manifest: ${manifestUrl}`, error);
+
+      // En caso de error, intentar crear manifest por defecto
+      try {
+        return this.createDefaultManifest(appUrl);
+      } catch (defaultError) {
+        throw new Error(`Failed to load manifest from ${manifestUrl}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Crear manifest por defecto cuando no existe wu.json
+   * @param {string} appUrl - URL de la aplicación
+   * @returns {Object} Manifest por defecto
+   */
+  createDefaultManifest(appUrl) {
+    // Extraer nombre de la app de la URL
+    const appName = this.extractAppNameFromUrl(appUrl);
+
+    const defaultManifest = {
+      name: appName,
+      entry: 'index.js',
+      wu: {
+        exports: {},
+        imports: [],
+        routes: [],
+        permissions: []
+      }
+    };
+
+    console.log(`[WuManifest] 🔧 Created default manifest for: ${appName}`);
+    return defaultManifest;
+  }
+
+  /**
+   * Extraer nombre de app desde URL
+   * @param {string} url - URL de la aplicación
+   * @returns {string} Nombre de la aplicación
+   */
+  extractAppNameFromUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      const pathSegments = urlObj.pathname.split('/').filter(Boolean);
+
+      // Usar el último segmento como nombre de la app
+      return pathSegments[pathSegments.length - 1] || 'unknown-app';
+    } catch {
+      // Si no es una URL válida, usar como está
+      return url.replace(/[^a-zA-Z0-9-]/g, '') || 'unknown-app';
+    }
+  }
+
+  /**
+   * Validar manifest contra schema
+   * @param {Object} manifest - Manifest a validar
+   * @returns {Object} Manifest validado
+   */
+  validate(manifest) {
+    const schema = this.schemas.get('wu.json');
+
+    // Verificar campos requeridos
+    for (const field of schema.required) {
+      if (!manifest[field]) {
+        throw new Error(`Required field missing: ${field}`);
+      }
+    }
+
+    // Verificar tipos en sección wu
+    if (manifest.wu) {
+      const wu = manifest.wu;
+      const wuSchema = schema.wu;
+
+      if (wu.exports && typeof wu.exports !== 'object') {
+        throw new Error('wu.exports must be an object');
+      }
+
+      if (wu.imports && !Array.isArray(wu.imports)) {
+        throw new Error('wu.imports must be an array');
+      }
+
+      if (wu.routes && !Array.isArray(wu.routes)) {
+        throw new Error('wu.routes must be an array');
+      }
+
+      if (wu.permissions && !Array.isArray(wu.permissions)) {
+        throw new Error('wu.permissions must be an array');
+      }
+    }
+
+    // Normalizar y limpiar manifest
+    return this.normalize(manifest);
+  }
+
+  /**
+   * Normalizar manifest
+   * @param {Object} manifest - Manifest a normalizar
+   * @returns {Object} Manifest normalizado
+   */
+  normalize(manifest) {
+    const normalized = {
+      name: manifest.name.trim(),
+      entry: this.normalizeEntry(manifest.entry),
+      wu: {
+        exports: manifest.wu?.exports || {},
+        imports: manifest.wu?.imports || [],
+        routes: manifest.wu?.routes || [],
+        permissions: manifest.wu?.permissions || []
+      }
+    };
+
+    // Normalizar exports
+    if (normalized.wu.exports) {
+      const normalizedExports = {};
+      for (const [key, path] of Object.entries(normalized.wu.exports)) {
+        normalizedExports[key] = this.normalizeComponentPath(path);
+      }
+      normalized.wu.exports = normalizedExports;
+    }
+
+    // Validar imports
+    normalized.wu.imports = normalized.wu.imports.filter(imp => {
+      if (typeof imp !== 'string' || !imp.includes('.')) {
+        console.warn(`[WuManifest] Invalid import format: ${imp}`);
+        return false;
+      }
+      return true;
+    });
+
+    return normalized;
+  }
+
+  /**
+   * Normalizar entry path
+   * @param {string} entry - Entry path
+   * @returns {string} Entry normalizado
+   */
+  normalizeEntry(entry) {
+    if (!entry) return 'index.js';
+
+    let normalized = entry.trim();
+
+    // Remover ./ inicial si está presente
+    if (normalized.startsWith('./')) {
+      normalized = normalized.substring(2);
+    }
+
+    // Agregar extensión si no la tiene
+    if (!normalized.includes('.')) {
+      normalized += '.js';
+    }
+
+    return normalized;
+  }
+
+  /**
+   * Normalizar path de componente
+   * @param {string} path - Path del componente
+   * @returns {string} Path normalizado
+   */
+  normalizeComponentPath(path) {
+    if (!path) return '';
+
+    let normalized = path.trim();
+
+    // Remover ./ inicial si está presente
+    if (normalized.startsWith('./')) {
+      normalized = normalized.substring(2);
+    }
+
+    // Agregar extensión si no la tiene
+    if (!normalized.includes('.')) {
+      normalized += '.js';
+    }
+
+    return normalized;
+  }
+
+  /**
+   * Validar dependencias de imports
+   * @param {Array} imports - Lista de imports
+   * @param {Map} availableApps - Apps disponibles
+   * @returns {Object} Resultado de validación
+   */
+  validateDependencies(imports, availableApps) {
+    const result = {
+      valid: [],
+      invalid: [],
+      missing: []
+    };
+
+    for (const importPath of imports) {
+      const [appName, componentName] = importPath.split('.');
+
+      if (!appName || !componentName) {
+        result.invalid.push({
+          import: importPath,
+          reason: 'Invalid format. Use "app.component"'
+        });
+        continue;
+      }
+
+      const app = availableApps.get(appName);
+      if (!app) {
+        result.missing.push({
+          import: importPath,
+          app: appName,
+          reason: 'App not registered'
+        });
+        continue;
+      }
+
+      const manifest = app.manifest;
+      const exportExists = manifest?.wu?.exports?.[componentName];
+
+      if (!exportExists) {
+        result.invalid.push({
+          import: importPath,
+          reason: `Component ${componentName} not exported by ${appName}`
+        });
+        continue;
+      }
+
+      result.valid.push({
+        import: importPath,
+        app: appName,
+        component: componentName,
+        path: exportExists
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Crear manifest programáticamente
+   * @param {string} name - Nombre de la app
+   * @param {Object} config - Configuración
+   * @returns {Object} Manifest creado
+   */
+  create(name, config = {}) {
+    const manifest = {
+      name: name,
+      entry: config.entry || 'index.js',
+      wu: {
+        exports: config.exports || {},
+        imports: config.imports || [],
+        routes: config.routes || [],
+        permissions: config.permissions || []
+      }
+    };
+
+    return this.normalize(manifest);
+  }
+
+  /**
+   * Limpiar cache de manifests
+   * @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(`[WuManifest] 🗑️ Cleared cache for: ${url}`);
+        }
+      }
+    } else {
+      this.cache.clear();
+      console.log(`[WuManifest] 🗑️ Manifest cache cleared completely`);
+    }
+  }
+
+  /**
+   * Obtener estadísticas del sistema de manifests
+   */
+  getStats() {
+    return {
+      cached: this.cache.size,
+      schemas: this.schemas.size,
+      cacheKeys: Array.from(this.cache.keys())
+    };
+  }
+}

package/src/core/wu-performance.js

@@ -0,0 +1,226 @@
+/**
+ * ⚡ WU-PERFORMANCE: MICROFRONTEND LIFECYCLE MONITORING
+ *
+ * Monitoreo de performance específico para operaciones del framework:
+ * - Tiempos de mount/unmount
+ * - Tiempos de carga de módulos
+ * - Estadísticas por app
+ */
+
+export class WuPerformance {
+  constructor() {
+    this.metrics = new Map(); // appName -> metrics
+    this.measurements = [];
+    this.marks = new Map();
+
+    this.config = {
+      enabled: true,
+      maxMeasurements: 1000
+    };
+
+    this.thresholds = {
+      mount: 3000, // ms
+      unmount: 1000, // ms
+      load: 5000 // ms
+    };
+
+    console.log('[WuPerformance] ⚡ Framework performance monitoring initialized');
+  }
+
+  /**
+   * 📊 START MEASURE: Iniciar medición
+   * @param {string} name - Nombre de la medición
+   * @param {string} appName - Nombre de la app (opcional)
+   */
+  startMeasure(name, appName = 'global') {
+    const markName = `${appName}:${name}:start`;
+    this.marks.set(markName, performance.now());
+
+    console.log(`[WuPerformance] 📊 Measure started: ${markName}`);
+  }
+
+  /**
+   * ⏹️ END MEASURE: Finalizar medición
+   * @param {string} name - Nombre de la medición
+   * @param {string} appName - Nombre de la app (opcional)
+   * @returns {number} Duración en ms
+   */
+  endMeasure(name, appName = 'global') {
+    const markName = `${appName}:${name}:start`;
+    const startTime = this.marks.get(markName);
+
+    if (!startTime) {
+      console.warn(`[WuPerformance] ⚠️ No start mark found for: ${markName}`);
+      return 0;
+    }
+
+    const duration = performance.now() - startTime;
+    this.marks.delete(markName);
+
+    // Registrar medición
+    this.recordMeasurement({
+      name,
+      appName,
+      duration,
+      timestamp: Date.now(),
+      type: 'duration'
+    });
+
+    // Verificar threshold
+    if (this.checkThreshold(name, duration)) {
+      console.warn(`[WuPerformance] ⚠️ Threshold exceeded for ${name}: ${duration.toFixed(2)}ms`);
+    }
+
+    console.log(`[WuPerformance] ⏹️ Measure ended: ${markName} (${duration.toFixed(2)}ms)`);
+    return duration;
+  }
+
+  /**
+   * 📝 RECORD MEASUREMENT: Registrar medición
+   * @param {Object} measurement - Medición
+   */
+  recordMeasurement(measurement) {
+    this.measurements.push(measurement);
+
+    // Mantener tamaño máximo
+    if (this.measurements.length > this.config.maxMeasurements) {
+      this.measurements.shift();
+    }
+
+    // Actualizar métricas de la app
+    if (!this.metrics.has(measurement.appName)) {
+      this.metrics.set(measurement.appName, {
+        appName: measurement.appName,
+        measurements: [],
+        stats: {}
+      });
+    }
+
+    const appMetrics = this.metrics.get(measurement.appName);
+    appMetrics.measurements.push(measurement);
+
+    // Calcular estadísticas
+    this.calculateStats(measurement.appName);
+  }
+
+  /**
+   * 📊 CALCULATE STATS: Calcular estadísticas
+   * @param {string} appName - Nombre de la app
+   */
+  calculateStats(appName) {
+    const appMetrics = this.metrics.get(appName);
+    if (!appMetrics) return;
+
+    const measurements = appMetrics.measurements;
+    if (measurements.length === 0) return;
+
+    // Agrupar por tipo de medición
+    const byType = {};
+    measurements.forEach(m => {
+      if (!byType[m.name]) byType[m.name] = [];
+      byType[m.name].push(m.duration);
+    });
+
+    // Calcular estadísticas para cada tipo
+    appMetrics.stats = {};
+    Object.entries(byType).forEach(([name, durations]) => {
+      appMetrics.stats[name] = {
+        count: durations.length,
+        avg: durations.reduce((a, b) => a + b, 0) / durations.length,
+        min: Math.min(...durations),
+        max: Math.max(...durations),
+        last: durations[durations.length - 1]
+      };
+    });
+  }
+
+  /**
+   * 🎯 CHECK THRESHOLD: Verificar si se excedió threshold
+   * @param {string} name - Nombre de la medición
+   * @param {number} value - Valor
+   * @returns {boolean}
+   */
+  checkThreshold(name, value) {
+    const threshold = this.thresholds[name];
+    return threshold && value > threshold;
+  }
+
+  /**
+   * 📊 GENERATE REPORT: Generar reporte de performance del framework
+   * @returns {Object}
+   */
+  generateReport() {
+    const report = {
+      timestamp: Date.now(),
+      totalMeasurements: this.measurements.length,
+      apps: {}
+    };
+
+    // Agregar métricas por app
+    for (const [appName, metrics] of this.metrics) {
+      report.apps[appName] = {
+        measurementCount: metrics.measurements.length,
+        stats: metrics.stats
+      };
+    }
+
+    return report;
+  }
+
+  /**
+   * 📋 GET METRICS: Obtener métricas de una app
+   * @param {string} appName - Nombre de la app
+   * @returns {Object}
+   */
+  getMetrics(appName) {
+    return this.metrics.get(appName) || null;
+  }
+
+  /**
+   * 📊 GET ALL METRICS: Obtener todas las métricas
+   * @returns {Object}
+   */
+  getAllMetrics() {
+    const allMetrics = {};
+
+    for (const [appName, metrics] of this.metrics) {
+      allMetrics[appName] = metrics;
+    }
+
+    return allMetrics;
+  }
+
+  /**
+   * 🧹 CLEAR METRICS: Limpiar métricas
+   * @param {string} appName - Nombre de la app (opcional)
+   */
+  clearMetrics(appName) {
+    if (appName) {
+      this.metrics.delete(appName);
+      this.measurements = this.measurements.filter(m => m.appName !== appName);
+    } else {
+      this.metrics.clear();
+      this.measurements = [];
+    }
+
+    console.log(`[WuPerformance] 🧹 Metrics cleared${appName ? ` for ${appName}` : ''}`);
+  }
+
+  /**
+   * ⚙️ CONFIGURE: Configurar performance monitor
+   * @param {Object} config - Nueva configuración
+   */
+  configure(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+
+    if (config.thresholds) {
+      this.thresholds = {
+        ...this.thresholds,
+        ...config.thresholds
+      };
+    }
+  }
+}