wu-framework 1.1.6 → 1.1.8

package/scripts/rollup-plugin-hex.js

@@ -1,143 +0,0 @@
-/**
- * 🔐 ROLLUP PLUGIN: HEX ENCODER
- *
- * Convierte el código JavaScript a formato hexadecimal
- * para máxima ofuscación y protección del código fuente.
- *
- * El código resultante se decodifica y ejecuta en runtime.
- */
-
-/**
- * Convierte string a hexadecimal
- * @param {string} str - String a convertir
- * @returns {string} String en hexadecimal
- */
-function stringToHex(str) {
-  let hex = '';
-  for (let i = 0; i < str.length; i++) {
-    const charCode = str.charCodeAt(i);
-    hex += charCode.toString(16).padStart(2, '0');
-  }
-  return hex;
-}
-
-/**
- * Genera el loader que decodifica y ejecuta el código hex
- * @param {string} hexCode - Código en hexadecimal
- * @param {boolean} isModule - Si es módulo ES
- * @returns {string} Código JavaScript con loader
- */
-function generateLoader(hexCode, isModule = true) {
-  // Loader minificado que decodifica hex y ejecuta
-  const loader = `
-(function(){
-  var h="${hexCode}";
-  var d=function(x){
-    for(var s="",i=0;i<x.length;i+=2)
-      s+=String.fromCharCode(parseInt(x.substr(i,2),16));
-    return s;
-  };
-  var c=d(h);
-  ${isModule ?
-    'var b=new Blob([c],{type:"text/javascript"});var u=URL.createObjectURL(b);import(u).then(function(m){URL.revokeObjectURL(u);Object.assign(window.__wu_exports__=window.__wu_exports__||{},m);});' :
-    'var s=document.createElement("script");s.text=c;document.head.appendChild(s);'
-  }
-})();
-`.trim().replace(/\s+/g, ' ');
-
-  return loader;
-}
-
-/**
- * Genera loader asíncrono para módulos ES
- * @param {string} hexCode - Código hexadecimal
- * @returns {string} Código con loader async
- */
-function generateAsyncLoader(hexCode) {
-  return `/*!
- * Wu Framework - Hex Encoded Build
- * Decode and execute at runtime
- */
-const __wu_hex__="${hexCode}";
-const __wu_decode__=(h)=>{let s="";for(let i=0;i<h.length;i+=2)s+=String.fromCharCode(parseInt(h.substr(i,2),16));return s;};
-const __wu_code__=__wu_decode__(__wu_hex__);
-const __wu_blob__=new Blob([__wu_code__],{type:"text/javascript"});
-const __wu_url__=URL.createObjectURL(__wu_blob__);
-const __wu_module__=await import(__wu_url__);
-URL.revokeObjectURL(__wu_url__);
-export const WuCore=__wu_module__.WuCore;
-export const WuLoader=__wu_module__.WuLoader;
-export const WuSandbox=__wu_module__.WuSandbox;
-export const WuManifest=__wu_module__.WuManifest;
-export const WuEventBus=__wu_module__.WuEventBus;
-export const WuStore=__wu_module__.WuStore;
-export const WuCache=__wu_module__.WuCache;
-export const WuPlugin=__wu_module__.WuPlugin;
-export const WuHooks=__wu_module__.WuHooks;
-export const WuPerformance=__wu_module__.WuPerformance;
-export const adapters=__wu_module__.adapters;
-export default __wu_module__.default||__wu_module__.WuCore;
-`;
-}
-
-/**
- * Plugin de Rollup para codificación hexadecimal
- * @param {Object} options - Opciones del plugin
- * @returns {Object} Plugin de Rollup
- */
-export default function hexEncoder(options = {}) {
-  const {
-    encodeStrings = true,
-    encodeIdentifiers = true,
-    addLoader = true,
-    asyncLoader = true,
-    chunkSize = 0 // 0 = sin chunks, >0 = dividir en chunks
-  } = options;
-
-  return {
-    name: 'hex-encoder',
-
-    renderChunk(code, chunk, outputOptions) {
-      console.log(`[HexEncoder] Processing chunk: ${chunk.fileName}`);
-
-      // Convertir código a hexadecimal
-      const hexCode = stringToHex(code);
-
-      console.log(`[HexEncoder] Original size: ${code.length} bytes`);
-      console.log(`[HexEncoder] Hex size: ${hexCode.length} bytes`);
-
-      if (!addLoader) {
-        // Solo devolver el hex sin loader
-        return {
-          code: `// Wu Framework - Hex Encoded\n// Decode with: hexToString("${hexCode}")\nexport default "${hexCode}";`,
-          map: null
-        };
-      }
-
-      // Generar código con loader
-      let finalCode;
-
-      if (asyncLoader) {
-        finalCode = generateAsyncLoader(hexCode);
-      } else {
-        finalCode = generateLoader(hexCode, outputOptions.format === 'es');
-      }
-
-      console.log(`[HexEncoder] Final size: ${finalCode.length} bytes`);
-
-      return {
-        code: finalCode,
-        map: null
-      };
-    },
-
-    generateBundle(outputOptions, bundle) {
-      console.log(`[HexEncoder] Build complete!`);
-      console.log(`[HexEncoder] Output format: ${outputOptions.format}`);
-      console.log(`[HexEncoder] Files generated: ${Object.keys(bundle).join(', ')}`);
-    }
-  };
-}
-
-// Exportar utilidades para uso standalone
-export { stringToHex, generateLoader, generateAsyncLoader };

package/src/core/wu-registry.js

@@ -1,60 +0,0 @@
-/**
- * 🔔 WU-REGISTRY: APP REGISTRATION TRACKER
- * Simplificado - solo trackea apps registradas
- */
-
-export class WuRegistry {
-  constructor() {
-    this.registeredApps = new Set();
-    this._setupNotifyReady();
-  }
-
-  /**
-   * 🔔 Setup notifyReady API en window.wu
-   */
-  _setupNotifyReady() {
-    const setupFn = () => {
-      if (window.wu && !window.wu.notifyReady) {
-        window.wu.notifyReady = (appName) => {
-          const event = new CustomEvent('wu:app:ready', {
-            detail: { appName, timestamp: Date.now() }
-          });
-          window.dispatchEvent(event);
-        };
-      }
-    };
-
-    setupFn();
-    if (!window.wu) {
-      queueMicrotask(setupFn);
-    }
-  }
-
-  /**
-   * ✅ MARK AS REGISTERED
-   */
-  markAsRegistered(appName) {
-    this.registeredApps.add(appName);
-  }
-
-  /**
-   * ❓ IS REGISTERED
-   */
-  isRegistered(appName) {
-    return this.registeredApps.has(appName);
-  }
-
-  /**
-   * ❌ UNREGISTER APP
-   */
-  unregister(appName) {
-    this.registeredApps.delete(appName);
-  }
-
-  /**
-   * 🧹 CLEANUP
-   */
-  cleanup() {
-    this.registeredApps.clear();
-  }
-}

package/src/core/wu-sandbox-pool.js

@@ -1,390 +0,0 @@
-/**
- * 🏊 WU-SANDBOX-POOL: VIRTUAL SANDBOX POOL
- *
- * Object Pool pattern para reutilizar sandboxes:
- * - Reduce memory usage
- * - Reduce GC pressure
- * - Mejora performance de mount/unmount
- * - Auto-cleanup de sandboxes inactivos
- */
-
-export class WuSandboxPool {
-  constructor(core) {
-    this.core = core;
-
-    // Pool configuration
-    this.config = {
-      minSize: 2,           // Mínimo de sandboxes en pool
-      maxSize: 10,          // Máximo de sandboxes en pool
-      idleTimeout: 30000,   // Tiempo antes de limpiar sandbox (30s)
-      warmupOnInit: true    // Crear sandboxes al inicializar
-    };
-
-    // Pool state
-    this.available = [];   // Sandboxes disponibles
-    this.inUse = new Map(); // Sandboxes en uso: appName -> sandbox
-    this.totalCreated = 0;
-    this.totalReused = 0;
-
-    // Cleanup timer
-    this.cleanupTimer = null;
-
-    console.log('[WuSandboxPool] 🏊 Sandbox pool initialized');
-  }
-
-  /**
-   * 🚀 INIT: Inicializar pool
-   */
-  async init() {
-    if (this.config.warmupOnInit) {
-      await this.warmup();
-    }
-
-    // Iniciar cleanup periódico
-    this.startCleanupTimer();
-
-    console.log('[WuSandboxPool] Pool ready');
-  }
-
-  /**
-   * 🔥 WARMUP: Pre-crear sandboxes
-   */
-  async warmup() {
-    console.log(`[WuSandboxPool] Warming up pool with ${this.config.minSize} sandboxes`);
-
-    for (let i = 0; i < this.config.minSize; i++) {
-      const sandbox = this.createSandbox();
-      this.available.push(sandbox);
-    }
-
-    console.log(`[WuSandboxPool] ✅ Pool warmed up with ${this.available.length} sandboxes`);
-  }
-
-  /**
-   * 🎯 CREATE SANDBOX: Crear nuevo sandbox
-   * @returns {Object} Sandbox instance
-   */
-  createSandbox() {
-    // Crear container temporal
-    const container = document.createElement('div');
-    container.className = 'wu-sandbox-container';
-    container.style.display = 'none';
-
-    // Crear shadow root
-    const shadowRoot = container.attachShadow({ mode: 'open' });
-
-    // Crear mount point dentro del shadow
-    const mountPoint = document.createElement('div');
-    mountPoint.className = 'wu-mount-point';
-    shadowRoot.appendChild(mountPoint);
-
-    const sandbox = {
-      id: `sandbox_${this.totalCreated++}`,
-      container,
-      shadowRoot,
-      mountPoint,
-      createdAt: Date.now(),
-      lastUsed: Date.now(),
-      timesUsed: 0,
-      currentApp: null
-    };
-
-    console.log(`[WuSandboxPool] Created sandbox: ${sandbox.id}`);
-
-    return sandbox;
-  }
-
-  /**
-   * 🔓 ACQUIRE: Obtener sandbox del pool
-   * @param {string} appName - Nombre de la app
-   * @returns {Object} Sandbox instance
-   */
-  acquire(appName) {
-    // Verificar si ya tiene un sandbox
-    if (this.inUse.has(appName)) {
-      console.warn(`[WuSandboxPool] App "${appName}" already has a sandbox`);
-      return this.inUse.get(appName);
-    }
-
-    let sandbox;
-
-    // Intentar reutilizar sandbox disponible
-    if (this.available.length > 0) {
-      sandbox = this.available.pop();
-      this.totalReused++;
-
-      console.log(`[WuSandboxPool] ♻️ Reusing sandbox ${sandbox.id} for ${appName}`);
-    }
-    // Si no hay disponibles y no excedemos máximo, crear nuevo
-    else if (this.inUse.size < this.config.maxSize) {
-      sandbox = this.createSandbox();
-
-      console.log(`[WuSandboxPool] 🆕 Creating new sandbox ${sandbox.id} for ${appName}`);
-    }
-    // Si excedemos máximo, crear temporal (no pooleable)
-    else {
-      sandbox = this.createSandbox();
-      sandbox.temporary = true;
-
-      console.warn(`[WuSandboxPool] ⚠️ Pool exhausted, creating temporary sandbox for ${appName}`);
-    }
-
-    // Preparar sandbox para uso
-    this.prepareSandbox(sandbox, appName);
-
-    // Marcar como en uso
-    sandbox.currentApp = appName;
-    sandbox.lastUsed = Date.now();
-    sandbox.timesUsed++;
-
-    this.inUse.set(appName, sandbox);
-
-    return sandbox;
-  }
-
-  /**
-   * 🔒 RELEASE: Liberar sandbox al pool
-   * @param {string} appName - Nombre de la app
-   */
-  release(appName) {
-    const sandbox = this.inUse.get(appName);
-
-    if (!sandbox) {
-      console.warn(`[WuSandboxPool] App "${appName}" has no sandbox to release`);
-      return;
-    }
-
-    // Limpiar sandbox
-    this.cleanSandbox(sandbox);
-
-    // Remover de uso
-    this.inUse.delete(appName);
-    sandbox.currentApp = null;
-    sandbox.lastUsed = Date.now();
-
-    // Si es temporal, destruir
-    if (sandbox.temporary) {
-      this.destroySandbox(sandbox);
-      console.log(`[WuSandboxPool] 🗑️ Destroyed temporary sandbox ${sandbox.id}`);
-      return;
-    }
-
-    // Si pool no está lleno, devolver al pool
-    if (this.available.length < this.config.maxSize) {
-      this.available.push(sandbox);
-      console.log(`[WuSandboxPool] ✅ Released sandbox ${sandbox.id} back to pool`);
-    }
-    // Si pool está lleno, destruir
-    else {
-      this.destroySandbox(sandbox);
-      console.log(`[WuSandboxPool] 🗑️ Pool full, destroyed sandbox ${sandbox.id}`);
-    }
-  }
-
-  /**
-   * 🔧 PREPARE SANDBOX: Preparar sandbox para uso
-   * @param {Object} sandbox - Sandbox instance
-   * @param {string} appName - Nombre de la app
-   */
-  prepareSandbox(sandbox, appName) {
-    // Mostrar container
-    sandbox.container.style.display = 'block';
-
-    // Agregar identificador de app
-    sandbox.container.setAttribute('data-wu-app', appName);
-
-    console.log(`[WuSandboxPool] Prepared sandbox ${sandbox.id} for ${appName}`);
-  }
-
-  /**
-   * 🧹 CLEAN SANDBOX: Limpiar sandbox para reutilización
-   * @param {Object} sandbox - Sandbox instance
-   */
-  cleanSandbox(sandbox) {
-    // Limpiar contenido del mount point
-    if (sandbox.mountPoint) {
-      sandbox.mountPoint.innerHTML = '';
-    }
-
-    // Limpiar estilos del shadow root
-    if (sandbox.shadowRoot) {
-      const styles = sandbox.shadowRoot.querySelectorAll('style');
-      styles.forEach(style => style.remove());
-    }
-
-    // Ocultar container
-    sandbox.container.style.display = 'none';
-
-    // Remover identificador de app
-    sandbox.container.removeAttribute('data-wu-app');
-
-    console.log(`[WuSandboxPool] Cleaned sandbox ${sandbox.id}`);
-  }
-
-  /**
-   * 💥 DESTROY SANDBOX: Destruir sandbox completamente
-   * @param {Object} sandbox - Sandbox instance
-   */
-  destroySandbox(sandbox) {
-    // Limpiar contenido
-    this.cleanSandbox(sandbox);
-
-    // Remover del DOM si está adjuntado
-    if (sandbox.container.parentNode) {
-      sandbox.container.parentNode.removeChild(sandbox.container);
-    }
-
-    // Limpiar referencias
-    sandbox.shadowRoot = null;
-    sandbox.mountPoint = null;
-    sandbox.container = null;
-
-    console.log(`[WuSandboxPool] Destroyed sandbox ${sandbox.id}`);
-  }
-
-  /**
-   * ⏰ START CLEANUP TIMER: Iniciar limpieza periódica
-   */
-  startCleanupTimer() {
-    // Limpiar timer anterior si existe
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-    }
-
-    // Limpiar cada minuto
-    this.cleanupTimer = setInterval(() => {
-      this.cleanupIdleSandboxes();
-    }, 60000);
-  }
-
-  /**
-   * 🧹 CLEANUP IDLE SANDBOXES: Limpiar sandboxes inactivos
-   */
-  cleanupIdleSandboxes() {
-    const now = Date.now();
-    const threshold = now - this.config.idleTimeout;
-
-    // Filtrar sandboxes que no han sido usados recientemente
-    const toKeep = [];
-    const toDestroy = [];
-
-    this.available.forEach(sandbox => {
-      if (sandbox.lastUsed < threshold && this.available.length > this.config.minSize) {
-        toDestroy.push(sandbox);
-      } else {
-        toKeep.push(sandbox);
-      }
-    });
-
-    // Destruir sandboxes idle
-    toDestroy.forEach(sandbox => {
-      this.destroySandbox(sandbox);
-    });
-
-    this.available = toKeep;
-
-    if (toDestroy.length > 0) {
-      console.log(`[WuSandboxPool] 🧹 Cleaned up ${toDestroy.length} idle sandboxes`);
-    }
-
-    // Si quedamos por debajo del mínimo, crear nuevos
-    if (this.available.length < this.config.minSize) {
-      const needed = this.config.minSize - this.available.length;
-      console.log(`[WuSandboxPool] Creating ${needed} sandboxes to maintain minimum`);
-
-      for (let i = 0; i < needed; i++) {
-        this.available.push(this.createSandbox());
-      }
-    }
-  }
-
-  /**
-   * ⚙️ CONFIGURE: Configurar pool
-   * @param {Object} config - Nueva configuración
-   */
-  configure(config) {
-    const oldMinSize = this.config.minSize;
-
-    this.config = {
-      ...this.config,
-      ...config
-    };
-
-    // Si aumentó el minSize, crear más sandboxes
-    if (this.config.minSize > oldMinSize) {
-      const needed = this.config.minSize - this.available.length;
-      if (needed > 0) {
-        console.log(`[WuSandboxPool] Creating ${needed} sandboxes for new minSize`);
-        for (let i = 0; i < needed; i++) {
-          this.available.push(this.createSandbox());
-        }
-      }
-    }
-
-    // Si disminuyó el minSize o maxSize, limpiar exceso
-    if (this.available.length > this.config.maxSize) {
-      const excess = this.available.length - this.config.maxSize;
-      const toDestroy = this.available.splice(this.config.maxSize, excess);
-      toDestroy.forEach(sandbox => this.destroySandbox(sandbox));
-
-      console.log(`[WuSandboxPool] Destroyed ${excess} excess sandboxes`);
-    }
-
-    console.log('[WuSandboxPool] Configuration updated:', this.config);
-  }
-
-  /**
-   * 📊 GET STATS: Estadísticas del pool
-   * @returns {Object}
-   */
-  getStats() {
-    const totalSandboxes = this.available.length + this.inUse.size;
-    const utilization = totalSandboxes > 0
-      ? ((this.inUse.size / totalSandboxes) * 100).toFixed(1)
-      : 0;
-
-    const avgTimesUsed = totalSandboxes > 0
-      ? [...this.available, ...this.inUse.values()]
-          .reduce((sum, s) => sum + s.timesUsed, 0) / totalSandboxes
-      : 0;
-
-    return {
-      available: this.available.length,
-      inUse: this.inUse.size,
-      totalSandboxes,
-      utilization: `${utilization}%`,
-      totalCreated: this.totalCreated,
-      totalReused: this.totalReused,
-      reuseRate: this.totalCreated > 0
-        ? `${((this.totalReused / this.totalCreated) * 100).toFixed(1)}%`
-        : '0%',
-      avgTimesUsed: avgTimesUsed.toFixed(1),
-      config: this.config,
-      appsInUse: Array.from(this.inUse.keys())
-    };
-  }
-
-  /**
-   * 🧹 CLEANUP: Limpiar todo el pool
-   */
-  cleanup() {
-    // Detener cleanup timer
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-
-    // Destruir todos los sandboxes disponibles
-    this.available.forEach(sandbox => this.destroySandbox(sandbox));
-    this.available = [];
-
-    // Destruir sandboxes en uso (forzado)
-    this.inUse.forEach((sandbox, appName) => {
-      console.warn(`[WuSandboxPool] Force destroying sandbox for active app: ${appName}`);
-      this.destroySandbox(sandbox);
-    });
-    this.inUse.clear();
-
-    console.log('[WuSandboxPool] 🧹 Pool cleaned up');
-  }
-}