@widergy/energy-ui 3.98.0 → 3.98.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [3.98.2](https://github.com/widergy/energy-ui/compare/v3.98.1...v3.98.2) (2025-08-12)
+
+
+### Bug Fixes
+
+* [SFPE-483] UTDataCategory empty data ([#664](https://github.com/widergy/energy-ui/issues/664)) ([be73350](https://github.com/widergy/energy-ui/commit/be7335017612682e9b44a7950c6d9e0999427867))
+
+## [3.98.1](https://github.com/widergy/energy-ui/compare/v3.98.0...v3.98.1) (2025-08-12)
+
+
+### Bug Fixes
+
+* [PDI-149] fix on utils ([#663](https://github.com/widergy/energy-ui/issues/663)) ([a642070](https://github.com/widergy/energy-ui/commit/a642070e196b634ea54113c2140cf306b0cf8011))
+
 # [3.98.0](https://github.com/widergy/energy-ui/compare/v3.97.0...v3.98.0) (2025-08-12)
 
 

package/dist/components/UTDataCategory/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WITHOUT_DATA_TEXT = void 0;
+const WITHOUT_DATA_TEXT = exports.WITHOUT_DATA_TEXT = 'Sin datos';

package/dist/components/UTDataCategory/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _propTypes = require("prop-types");
 var _react = _interopRequireWildcard(require("react"));
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
 var _WithTheme = _interopRequireDefault(require("../WithTheme"));
 var _UTDataElement = _interopRequireDefault(require("../UTDataElement"));
 var _UTLabel = _interopRequireDefault(require("../UTLabel"));
@@ -14,6 +15,7 @@ var _classesUtils = require("../../utils/classesUtils");
 var _testIds = require("../../constants/testIds");
 var _stylesModule = _interopRequireDefault(require("./styles.module.scss"));
 var _theme = require("./theme");
+var _constants = require("./constants");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
@@ -65,7 +67,10 @@ const UTDataCategory = _ref => {
   }, /*#__PURE__*/_react.default.createElement("div", {
     ref: childrenRef,
     className: _stylesModule.default.childrenContent
-  }, elements.map((element, index) => {
+  }, (0, _isEmpty.default)(elements) ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+    align: "center",
+    colorTheme: "gray"
+  }, _constants.WITHOUT_DATA_TEXT) : elements.map((element, index) => {
     const {
       key,
       ...dataElementProps

package/dist/index.js

@@ -480,7 +480,7 @@ Object.defineProperty(exports, "keyboardUtils", {
 Object.defineProperty(exports, "stylesDeduplicationUtils", {
   enumerable: true,
   get: function () {
-    return _styleDeduplication.default;
+    return _stylesDeduplicationUtils.default;
   }
 });
 var _AlertHandler = _interopRequireDefault(require("./components/UTAlert/AlertHandler"));
@@ -562,5 +562,5 @@ var _UTVirtualKeyboard = _interopRequireDefault(require("./components/UTVirtualK
 var _UTWorkflowContainer = _interopRequireDefault(require("./components/UTWorkflowContainer"));
 var _WithLoading = _interopRequireDefault(require("./components/WithLoading"));
 var _WithTouch = _interopRequireDefault(require("./components/WithTouch"));
-var _styleDeduplication = _interopRequireDefault(require("./utils/styleDeduplication"));
+var _stylesDeduplicationUtils = _interopRequireDefault(require("./utils/stylesDeduplicationUtils"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/dist/utils/stylesDeduplicationUtils.js

@@ -0,0 +1,453 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+/**
+ * Sistema de deduplicación de estilos para Energy UI
+ * Evita que los estilos se carguen múltiples veces cuando la librería se importa desde diferentes proyectos
+ */
+
+// Cache global para estilos ya cargados
+const loadedStyles = new Set(); // Set de hashes de contenido CSS ya procesados
+const styleElementsByHash = new Map(); // Map de hash -> elemento DOM para estilos ya cargados
+
+// Cache global para URLs de hojas de estilos externas ya cargadas
+const loadedStylesheets = new Set(); // Set de URLs normalizadas de hojas externas ya cargadas
+
+// Referencias globales para cleanup
+let globalObserver = null;
+let isConfigured = false;
+
+/**
+ * Normaliza el contenido CSS para comparaciones consistentes
+ */
+const normalizeCSSContent = content => {
+  if (!content || typeof content !== 'string') {
+    return '';
+  }
+  return content
+  // Remover comentarios CSS (pero preservar source maps)
+  .replace(/\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g, match => {
+    // Preservar source maps que pueden contener información importante
+    if (match.includes('sourceMappingURL')) {
+      return match;
+    }
+    return '';
+  })
+  // Remover espacios en blanco extra
+  .replace(/\s+/g, ' ')
+  // Remover espacios al inicio y final
+  .trim()
+  // Normalizar saltos de línea
+  .replace(/\r\n/g, '\n').replace(/\r/g, '\n')
+  // Remover espacios alrededor de caracteres especiales
+  .replace(/\s*([{}:;,])\s*/g, '$1')
+  // Normalizar valores de colores
+  .replace(/#([0-9a-fA-F]{3})\b/g, (match, hex) => // Expandir colores de 3 dígitos a 6 dígitos
+  "#".concat(hex.split('').map(char => char + char).join('')))
+  // Normalizar valores de unidades
+  .replace(/(\d+)px/g, '$1px').replace(/(\d+)em/g, '$1em').replace(/(\d+)rem/g, '$1rem')
+  // Remover espacios extra entre reglas
+  .replace(/}\s*{/g, '}{')
+  // Normalizar selectores
+  .replace(/\s*,\s*/g, ',').replace(/\s*>\s*/g, '>').replace(/\s*\+\s*/g, '+').replace(/\s*~\s*/g, '~');
+};
+
+/**
+ * Normaliza URLs para comparaciones consistentes
+ */
+const normalizeURL = url => {
+  if (!url || typeof url !== 'string') {
+    return '';
+  }
+  try {
+    const urlObj = new URL(url, window.location.href);
+
+    // Remover parámetros de query que no afectan el contenido
+    const paramsToRemove = ['v', 'version', 't', 'timestamp', 'cache', 'cb'];
+    paramsToRemove.forEach(param => {
+      urlObj.searchParams.delete(param);
+    });
+
+    // Normalizar el path
+    let path = urlObj.pathname;
+
+    // Remover extensiones de archivo para comparación
+    path = path.replace(/\.(css|scss|sass|less)$/i, '');
+
+    // Remover hashes de build (ej: main.abc123.css -> main)
+    path = path.replace(/\.([a-f0-9]{8,})\./i, '.');
+
+    // Construir URL normalizada
+    const normalizedURL = "".concat(urlObj.origin).concat(path);
+    return normalizedURL.toLowerCase();
+  } catch (e) {
+    // Si no es una URL válida, normalizar como string
+    return url.toLowerCase().replace(/[?#].*$/, '') // Remover query params y hash
+    .replace(/\.(css|scss|sass|less)$/i, '') // Remover extensiones
+    .replace(/\.([a-f0-9]{8,})\./i, '.') // Remover hashes de build
+    .trim();
+  }
+};
+
+/**
+ * Genera un hash único para un conjunto de estilos normalizado
+ */
+const generateStyleHash = content => {
+  const normalizedContent = normalizeCSSContent(content);
+
+  // Usar un algoritmo de hash más robusto
+  let hash = 0;
+  const prime = 31;
+  for (let i = 0; i < normalizedContent.length; i++) {
+    const char = normalizedContent.charCodeAt(i);
+    hash = hash * prime + char >>> 0; // Mantener como entero de 32 bits sin signo
+  }
+  return hash.toString(36);
+};
+
+/**
+ * Verifica si el contenido es un estilo de Energy UI
+ */
+const isEnergyUIStyle = content => {
+  if (!content || typeof content !== 'string') {
+    return false;
+  }
+  const normalizedContent = normalizeCSSContent(content);
+
+  // Patrones específicos de Energy UI - MÁS SEGUROS
+  const energyUIPatterns = [
+  // Clases de componentes UT (muy específicas)
+  /\.[a-z]*UT[A-Z][a-zA-Z]*/g,
+  // Clases CSS Modules con hash de UT (muy específicas)
+  /\.UT[A-Z][a-zA-Z]*__[a-zA-Z0-9_-]+/g,
+  // Variables CSS de Energy UI (muy específicas)
+  /--energy-ui-/g, /--ut-/g,
+  // Selectores específicos de Energy UI (muy específicos)
+  /\[data-energy-ui\]/g, /\[data-ut-/g,
+  // Comentarios específicos de Energy UI (muy específicos)
+  /\/\*.*energy.*ui.*\*\//gi, /\/\*.*ut.*\*\//gi,
+  // CSS Modules internos de Energy UI (patrón específico .styles_[name]_[hash])
+  /\.styles_[a-zA-Z0-9_-]+_[a-zA-Z0-9_-]+/g,
+  // Source maps específicos de Energy UI
+  /sourceMappingURL.*energy/i, /sourceMappingURL.*ut/i];
+
+  // Verificación adicional de seguridad: debe contener al menos 2 patrones específicos
+  const matches = energyUIPatterns.filter(pattern => pattern.test(normalizedContent));
+
+  // Solo considerar Energy UI si hay al menos 2 coincidencias (más seguro)
+  if (matches.length >= 2) {
+    return true;
+  }
+
+  // Caso especial: si contiene el patrón .styles_[name]_[hash] Y algún otro patrón específico
+  const stylesPattern = /\.styles_[a-zA-Z0-9_-]+_[a-zA-Z0-9_-]+/g;
+  const hasStylesPattern = stylesPattern.test(normalizedContent);
+  const hasOtherPattern = energyUIPatterns.some(pattern => pattern !== stylesPattern && pattern.test(normalizedContent));
+  const isEnergyUI = hasStylesPattern && hasOtherPattern;
+  return isEnergyUI;
+};
+
+/**
+ * Verifica si una URL es de Energy UI
+ */
+const isEnergyUIURL = url => {
+  if (!url || typeof url !== 'string') {
+    return false;
+  }
+  const normalizedURL = normalizeURL(url);
+
+  // Patrones de URL de Energy UI - MÁS SEGUROS
+  const energyUIPatterns = [
+  // URLs específicas de Energy UI
+  /energy-ui/i, /energyui/i, /ut-components/i, /energy.*ui/i,
+  // URLs locales específicas de Energy UI (más restrictivas)
+  /localhost.*\/energy/i, /localhost.*\/ut/i, /localhost.*energy-ui/i, /localhost.*ut-components/i];
+  return energyUIPatterns.some(pattern => pattern.test(normalizedURL));
+};
+
+/**
+ * Verifica si un estilo ya está cargado
+ */
+const isStyleAlreadyLoaded = content => {
+  const hash = generateStyleHash(content);
+  return loadedStyles.has(hash);
+};
+
+/**
+ * Marca un estilo como cargado
+ */
+const markStyleAsLoaded = (content, element) => {
+  const hash = generateStyleHash(content);
+  loadedStyles.add(hash);
+  styleElementsByHash.set(hash, element);
+};
+
+/**
+ * Verifica si una hoja de estilos externa ya está cargada
+ */
+const isStylesheetAlreadyLoaded = href => {
+  const normalizedHref = normalizeURL(href);
+  return loadedStylesheets.has(normalizedHref);
+};
+
+/**
+ * Marca una hoja de estilos externa como cargada
+ */
+const markStylesheetAsLoaded = href => {
+  const normalizedHref = normalizeURL(href);
+  loadedStylesheets.add(normalizedHref);
+};
+
+/**
+ * Verifica si estamos en un entorno compatible
+ */
+const isCompatibleEnvironment = () => typeof window !== 'undefined' && typeof document !== 'undefined' && typeof document.head !== 'undefined';
+
+/**
+ * Intercepta la creación de elementos <style> para evitar duplicados
+ */
+const interceptStyleCreation = () => {
+  // Verificar si estamos en un entorno con DOM disponible
+  if (!isCompatibleEnvironment()) {
+    return;
+  }
+  if (isConfigured) {
+    return;
+  }
+
+  // Usar el punto de inserción existente (meta tag)
+  const insertionPoint = document.getElementById('energyui-insertion-point');
+  if (!insertionPoint) {
+    console.warn('Energy UI: No se encontró el punto de inserción <meta id="energyui-insertion-point"/>');
+    return;
+  }
+
+  // Observer específico que solo procesa elementos después del meta tag
+
+  // Observer que solo observa los cambios DESPUÉS del meta tag (más seguro)
+  const observeAfterMetaTag = () => {
+    // Observar solo los nodos que se insertan después del meta tag
+    const observer = new MutationObserver(mutations => {
+      mutations.forEach(mutation => {
+        if (mutation.type === 'childList') {
+          mutation.addedNodes.forEach(node => {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+              // Solo procesar elementos que están después del meta tag
+              if (insertionPoint.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_FOLLOWING) {
+                // Procesar elementos <style>
+                if (node.tagName === 'STYLE') {
+                  const content = node.textContent || '';
+
+                  // Usar detección mejorada de Energy UI
+                  if (content && isEnergyUIStyle(content)) {
+                    if (isStyleAlreadyLoaded(content)) {
+                      node.remove();
+                    } else {
+                      markStyleAsLoaded(content, node);
+                    }
+                  }
+                }
+
+                // Procesar elementos <link> con hojas de estilos
+                if (node.tagName === 'LINK' && node.rel === 'stylesheet') {
+                  const href = node.href || '';
+
+                  // Usar detección mejorada de URLs de Energy UI
+                  if (href && isEnergyUIURL(href)) {
+                    // Detección silenciosa de hojas de estilos externas
+                  }
+                }
+              }
+            }
+          });
+        }
+      });
+    });
+
+    // Observar solo el head, pero filtrar por posición relativa al meta tag
+    observer.observe(document.head, {
+      childList: true,
+      subtree: false // No observar subtree, solo nodos directos
+    });
+    return observer;
+  };
+
+  // Usar el observer específico
+  globalObserver = observeAfterMetaTag();
+
+  // Marcar como configurado
+  isConfigured = true;
+};
+
+/**
+ * Función para limpiar estilos duplicados existentes
+ */
+const cleanupDuplicateStyles = () => {
+  // Limpiar elementos <style> duplicados
+  const existingStyleElements = document.querySelectorAll('style');
+  const seenContents = new Set();
+  existingStyleElements.forEach(style => {
+    const content = style.textContent || '';
+
+    // Usar detección mejorada de Energy UI
+    if (content && isEnergyUIStyle(content)) {
+      const hash = generateStyleHash(content);
+      if (seenContents.has(hash)) {
+        style.remove();
+      } else {
+        seenContents.add(hash);
+        markStyleAsLoaded(content, style);
+      }
+    }
+  });
+
+  // Limpiar hojas de estilos externas duplicadas
+  const linkElements = document.querySelectorAll('link[rel="stylesheet"]');
+  linkElements.forEach(link => {
+    const href = link.href || '';
+
+    // Usar detección mejorada de URLs de Energy UI
+    if (href && isEnergyUIURL(href)) {
+      if (isStylesheetAlreadyLoaded(href)) {
+        link.remove();
+      } else {
+        markStylesheetAsLoaded(href);
+      }
+    }
+  });
+};
+
+/**
+ * Función para limpiar recursos y desconectar observers
+ */
+const cleanupStyleDeduplication = () => {
+  if (globalObserver) {
+    globalObserver.disconnect();
+    globalObserver = null;
+  }
+
+  // Limpiar caches
+  loadedStyles.clear();
+  styleElementsByHash.clear();
+  loadedStylesheets.clear();
+
+  // Resetear estado
+  isConfigured = false;
+};
+
+/**
+ * Hook para React
+ */
+const useStyleDeduplication = function () {
+  let enableStyleDeduplication = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  (0, _react.useEffect)(() => {
+    if (enableStyleDeduplication) {
+      interceptStyleCreation();
+      cleanupDuplicateStyles();
+    }
+
+    // Cleanup automático cuando el componente se desmonta
+    return () => {
+      if (enableStyleDeduplication) {
+        cleanupStyleDeduplication();
+      }
+    };
+  }, [enableStyleDeduplication]);
+};
+
+/**
+ * Función para configuración manual
+ */
+const setupStyleDeduplication = () => {
+  interceptStyleCreation();
+  cleanupDuplicateStyles();
+};
+
+/**
+ * Función para verificar si está configurado
+ */
+const isStyleDeduplicationConfigured = () => isConfigured && globalObserver !== null;
+
+/**
+ * Función para obtener estadísticas de deduplicación
+ */
+const getDeduplicationStats = () => ({
+  loadedStylesCount: loadedStyles.size,
+  styleElementsByHashCount: styleElementsByHash.size,
+  loadedStylesheetsCount: loadedStylesheets.size,
+  isConfigured: isStyleDeduplicationConfigured()
+});
+
+/**
+ * Función para testing: verificar si un contenido sería detectado como Energy UI
+ */
+const testEnergyUIDetection = content => ({
+  isEnergyUI: isEnergyUIStyle(content),
+  normalizedContent: normalizeCSSContent(content),
+  hash: generateStyleHash(content)
+});
+
+/**
+ * Función para testing: verificar si una URL sería detectada como Energy UI
+ */
+const testEnergyUIURLDetection = url => ({
+  isEnergyUI: isEnergyUIURL(url),
+  normalizedURL: normalizeURL(url)
+});
+
+/**
+ * Función para debugging: obtener información detallada de estilos cargados
+ */
+const getDetailedStats = () => {
+  const currentStyleElements = document.querySelectorAll('style');
+  const currentLinkElements = document.querySelectorAll('link[rel="stylesheet"]');
+  const energyUIStyles = [];
+  const energyUILinks = [];
+  currentStyleElements.forEach((style, index) => {
+    const content = style.textContent || '';
+    if (isEnergyUIStyle(content)) {
+      energyUIStyles.push({
+        index,
+        hash: generateStyleHash(content),
+        isDuplicate: isStyleAlreadyLoaded(content),
+        normalizedContent: "".concat(normalizeCSSContent(content).substring(0, 100), "...")
+      });
+    }
+  });
+  currentLinkElements.forEach((link, index) => {
+    const href = link.href || '';
+    if (isEnergyUIURL(href)) {
+      energyUILinks.push({
+        index,
+        href,
+        normalizedURL: normalizeURL(href),
+        isDuplicate: isStylesheetAlreadyLoaded(href)
+      });
+    }
+  });
+  return {
+    totalStyles: currentStyleElements.length,
+    totalLinks: currentLinkElements.length,
+    energyUIStyles,
+    energyUILinks,
+    loadedStylesCount: loadedStyles.size,
+    styleElementsByHashCount: styleElementsByHash.size,
+    isConfigured: isStyleDeduplicationConfigured()
+  };
+};
+var _default = exports.default = {
+  getDeduplicationStats,
+  isStyleDeduplicationConfigured,
+  setupStyleDeduplication,
+  cleanupStyleDeduplication,
+  useStyleDeduplication,
+  isCompatibleEnvironment,
+  isStylesheetAlreadyLoaded,
+  testEnergyUIDetection,
+  testEnergyUIURLDetection,
+  getDetailedStats
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@widergy/energy-ui",
-  "version": "3.98.0",
+  "version": "3.98.2",
   "description": "Widergy Web Components",
   "author": "widergy",
   "license": "MIT",

package/dist/utils/styleDeduplication.js

@@ -1,183 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useStyleDeduplication = exports.setupStyleDeduplication = exports.isStyleDeduplicationConfigured = exports.getDeduplicationStats = exports.default = void 0;
-var _react = require("react");
-/**
- * Sistema de deduplicación de estilos para Energy UI
- * Evita que los estilos se carguen múltiples veces cuando la librería se importa desde diferentes proyectos
- */
-
-// Cache global para estilos ya cargados
-const loadedStyles = new Set();
-const styleElements = new Map();
-
-/**
- * Genera un hash único para un conjunto de estilos
- */
-const generateStyleHash = content => {
-  let hash = 0;
-  for (let i = 0; i < content.length; i++) {
-    const char = content.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash; // Convertir a entero de 32 bits
-  }
-  return hash.toString(36);
-};
-
-/**
- * Verifica si un estilo ya está cargado
- */
-const isStyleAlreadyLoaded = content => {
-  const hash = generateStyleHash(content);
-  return loadedStyles.has(hash);
-};
-
-/**
- * Marca un estilo como cargado
- */
-const markStyleAsLoaded = (content, element) => {
-  const hash = generateStyleHash(content);
-  loadedStyles.add(hash);
-  styleElements.set(hash, element);
-};
-
-/**
- * Intercepta la creación de elementos <style> para evitar duplicados
- */
-const interceptStyleCreation = () => {
-  if (window.__energyUI_styleDeduplicationConfigured) {
-    return;
-  }
-
-  // Crear el punto de inserción si no existe
-  let insertionPoint = document.getElementById('energyui-insertion-point');
-  if (!insertionPoint) {
-    insertionPoint = document.createElement('div');
-    insertionPoint.id = 'energyui-insertion-point';
-    insertionPoint.setAttribute('data-energy-ui', 'deduplication-insertion-point');
-    document.head.appendChild(insertionPoint);
-  }
-
-  // Usar un enfoque más simple: solo observar el DOM
-  const observer = new MutationObserver(mutations => {
-    mutations.forEach(mutation => {
-      mutation.addedNodes.forEach(node => {
-        if (node.nodeType === Node.ELEMENT_NODE && node.tagName === 'STYLE') {
-          const content = node.textContent || '';
-          if (content && (content.includes('UT') || content.includes('energy-ui') || content.includes('energyui') || content.includes('__'))) {
-            if (isStyleAlreadyLoaded(content)) {
-              console.log('Energy UI: Estilo duplicado detectado en DOM, removiendo...');
-              node.remove();
-            } else {
-              markStyleAsLoaded(content, node);
-            }
-          }
-        }
-      });
-    });
-  });
-  observer.observe(document.head, {
-    childList: true,
-    subtree: true
-  });
-
-  // Interceptar la inserción de reglas CSS para JSS
-  const originalInsertRule = CSSStyleSheet.prototype.insertRule;
-  CSSStyleSheet.prototype.insertRule = function (rule, index) {
-    // Verificar si la regla ya existe en otra hoja de estilos
-    if (rule && typeof rule === 'string') {
-      const existingSheets = Array.from(document.styleSheets);
-      for (const sheet of existingSheets) {
-        try {
-          const rules = Array.from(sheet.cssRules || []);
-          for (const existingRule of rules) {
-            if (existingRule.cssText === rule) {
-              console.log('Energy UI: Regla CSS duplicada detectada y evitada');
-              return 0; // Retornar índice 0 para evitar errores
-            }
-          }
-        } catch (e) {
-          // Ignorar errores de CORS
-        }
-      }
-    }
-    return originalInsertRule.call(this, rule, index);
-  };
-
-  // Marcar como configurado
-  window.__energyUI_styleDeduplicationConfigured = true;
-  console.log('Energy UI: Sistema de deduplicación de estilos configurado');
-};
-
-/**
- * Función para limpiar estilos duplicados existentes
- */
-const cleanupDuplicateStyles = () => {
-  const styleElements = document.querySelectorAll('style');
-  const seenContents = new Set();
-  styleElements.forEach(style => {
-    const content = style.textContent || '';
-    if (content && (content.includes('UT') || content.includes('energy-ui') || content.includes('energyui') || content.includes('__'))) {
-      const hash = generateStyleHash(content);
-      if (seenContents.has(hash)) {
-        console.log('Energy UI: Removiendo estilo duplicado existente');
-        style.remove();
-      } else {
-        seenContents.add(hash);
-        markStyleAsLoaded(content, style);
-      }
-    }
-  });
-};
-
-/**
- * Hook para React
- */
-const useStyleDeduplication = function () {
-  let enableStyleDeduplication = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-  (0, _react.useEffect)(() => {
-    if (enableStyleDeduplication) {
-      interceptStyleCreation();
-      cleanupDuplicateStyles();
-    }
-  }, [enableStyleDeduplication]);
-};
-
-/**
- * Función para configuración manual
- */
-exports.useStyleDeduplication = useStyleDeduplication;
-const setupStyleDeduplication = () => {
-  interceptStyleCreation();
-  cleanupDuplicateStyles();
-};
-
-/**
- * Función para verificar si está configurado
- */
-exports.setupStyleDeduplication = setupStyleDeduplication;
-const isStyleDeduplicationConfigured = () => {
-  return window.__energyUI_styleDeduplicationConfigured === true;
-};
-
-/**
- * Función para obtener estadísticas de deduplicación
- */
-exports.isStyleDeduplicationConfigured = isStyleDeduplicationConfigured;
-const getDeduplicationStats = () => {
-  return {
-    loadedStylesCount: loadedStyles.size,
-    styleElementsCount: styleElements.size,
-    isConfigured: isStyleDeduplicationConfigured()
-  };
-};
-exports.getDeduplicationStats = getDeduplicationStats;
-var _default = exports.default = {
-  getDeduplicationStats,
-  isStyleDeduplicationConfigured,
-  setupStyleDeduplication,
-  useStyleDeduplication
-};