@coherent.js/devtools 1.0.0-beta.8 → 1.0.0-rc.2

package/dist/performance/index.js

@@ -0,0 +1,1443 @@
+// src/performance/code-splitting.js
+var CodeSplitter = class {
+  constructor(options = {}) {
+    this.options = {
+      preload: [],
+      prefetch: [],
+      timeout: 1e4,
+      retries: 3,
+      ...options
+    };
+    this.modules = /* @__PURE__ */ new Map();
+    this.loading = /* @__PURE__ */ new Map();
+    this.failed = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Dynamically import a module
+   * 
+   * @param {string} path - Module path
+   * @param {Object} [options] - Import options
+   * @returns {Promise} Module exports
+   */
+  async import(path, options = {}) {
+    if (this.modules.has(path)) {
+      return this.modules.get(path);
+    }
+    if (this.loading.has(path)) {
+      return this.loading.get(path);
+    }
+    const importPromise = this.loadModule(path, options);
+    this.loading.set(path, importPromise);
+    try {
+      const module = await importPromise;
+      this.modules.set(path, module);
+      this.loading.delete(path);
+      return module;
+    } catch (error) {
+      this.loading.delete(path);
+      this.failed.add(path);
+      throw error;
+    }
+  }
+  /**
+   * Load module with retries
+   */
+  async loadModule(path, options = {}) {
+    const maxRetries = options.retries ?? this.options.retries;
+    const timeout = options.timeout ?? this.options.timeout;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const importPath = attempt > 0 ? `${path}?retry=${attempt}&t=${Date.now()}` : path;
+        const module = await Promise.race([
+          import(importPath),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Import timeout")), timeout)
+          )
+        ]);
+        return module;
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxRetries) {
+          await new Promise(
+            (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3)
+          );
+        }
+      }
+    }
+    throw new Error(`Failed to load module ${path}: ${lastError.message}`);
+  }
+  /**
+   * Preload modules
+   */
+  async preload(paths) {
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    return Promise.all(
+      pathArray.map((path) => this.import(path).catch((err) => {
+        console.warn(`Failed to preload ${path}:`, err);
+        return null;
+      }))
+    );
+  }
+  /**
+   * Prefetch modules (low priority)
+   */
+  prefetch(paths) {
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (typeof requestIdleCallback !== "undefined") {
+      requestIdleCallback(() => {
+        pathArray.forEach((path) => {
+          this.import(path).catch(() => {
+          });
+        });
+      });
+    } else {
+      setTimeout(() => {
+        pathArray.forEach((path) => {
+          this.import(path).catch(() => {
+          });
+        });
+      }, 0);
+    }
+  }
+  /**
+   * Check if module is loaded
+   */
+  isLoaded(path) {
+    return this.modules.has(path);
+  }
+  /**
+   * Check if module is loading
+   */
+  isLoading(path) {
+    return this.loading.has(path);
+  }
+  /**
+   * Check if module failed to load
+   */
+  hasFailed(path) {
+    return this.failed.has(path);
+  }
+  /**
+   * Clear cache
+   */
+  clearCache(path = null) {
+    if (path) {
+      this.modules.delete(path);
+      this.failed.delete(path);
+    } else {
+      this.modules.clear();
+      this.failed.clear();
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      loaded: this.modules.size,
+      loading: this.loading.size,
+      failed: this.failed.size,
+      modules: Array.from(this.modules.keys())
+    };
+  }
+};
+function createCodeSplitter(options = {}) {
+  return new CodeSplitter(options);
+}
+function lazy(loader, options = {}) {
+  let modulePromise = null;
+  let module = null;
+  let error = null;
+  return function LazyComponent(props = {}) {
+    if (module) {
+      const Component = module.default || module;
+      return Component(props);
+    }
+    if (error) {
+      if (options.errorComponent) {
+        return options.errorComponent({ error, retry: () => {
+          error = null;
+          modulePromise = null;
+          return LazyComponent(props);
+        } });
+      }
+      return {
+        div: {
+          className: "lazy-error",
+          text: `Error loading component: ${error.message}`
+        }
+      };
+    }
+    if (!modulePromise) {
+      modulePromise = loader().then((mod) => {
+        module = mod;
+        return mod;
+      }).catch((err) => {
+        error = err;
+        throw err;
+      });
+    }
+    if (options.loadingComponent) {
+      return options.loadingComponent(props);
+    }
+    return {
+      div: {
+        className: "lazy-loading",
+        text: options.loadingText || "Loading..."
+      }
+    };
+  };
+}
+function splitComponent(componentPath, options = {}) {
+  const splitter = new CodeSplitter(options);
+  return lazy(
+    () => splitter.import(componentPath),
+    options
+  );
+}
+function createRouteSplitter(routes) {
+  const splitter = new CodeSplitter();
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const [path, config] of Object.entries(routes)) {
+    if (typeof config === "string") {
+      routeMap.set(path, {
+        loader: () => splitter.import(config)
+      });
+    } else {
+      routeMap.set(path, {
+        loader: () => splitter.import(config.component),
+        preload: config.preload || [],
+        ...config
+      });
+    }
+  }
+  return {
+    /**
+     * Load route component
+     */
+    async loadRoute(path) {
+      const route = routeMap.get(path);
+      if (!route) {
+        throw new Error(`Route not found: ${path}`);
+      }
+      if (route.preload && route.preload.length > 0) {
+        splitter.prefetch(route.preload);
+      }
+      return await route.loader();
+    },
+    /**
+     * Preload route
+     */
+    preloadRoute(path) {
+      const route = routeMap.get(path);
+      if (route) {
+        return route.loader();
+      }
+    },
+    /**
+     * Get all routes
+     */
+    getRoutes() {
+      return Array.from(routeMap.keys());
+    },
+    /**
+     * Get splitter instance
+     */
+    getSplitter() {
+      return splitter;
+    }
+  };
+}
+var BundleAnalyzer = class {
+  constructor() {
+    this.chunks = /* @__PURE__ */ new Map();
+    this.loadTimes = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Track chunk load
+   */
+  trackLoad(chunkName, size, loadTime) {
+    this.chunks.set(chunkName, { size, loadTime });
+    this.loadTimes.set(chunkName, loadTime);
+  }
+  /**
+   * Get bundle statistics
+   */
+  getStats() {
+    const chunks = Array.from(this.chunks.entries());
+    const totalSize = chunks.reduce((sum, [, chunk]) => sum + chunk.size, 0);
+    const avgLoadTime = chunks.reduce((sum, [, chunk]) => sum + chunk.loadTime, 0) / chunks.length;
+    return {
+      totalChunks: chunks.length,
+      totalSize,
+      averageLoadTime: avgLoadTime,
+      chunks: chunks.map(([name, data]) => ({
+        name,
+        size: data.size,
+        loadTime: data.loadTime,
+        percentage: (data.size / totalSize * 100).toFixed(2)
+      }))
+    };
+  }
+  /**
+   * Find largest chunks
+   */
+  getLargestChunks(limit = 10) {
+    return Array.from(this.chunks.entries()).sort((a, b) => b[1].size - a[1].size).slice(0, limit).map(([name, data]) => ({ name, ...data }));
+  }
+  /**
+   * Find slowest chunks
+   */
+  getSlowestChunks(limit = 10) {
+    return Array.from(this.chunks.entries()).sort((a, b) => b[1].loadTime - a[1].loadTime).slice(0, limit).map(([name, data]) => ({ name, ...data }));
+  }
+};
+
+// src/performance/cache.js
+var LRUCache = class {
+  constructor(options = {}) {
+    this.maxSize = options.maxSize || 100;
+    this.ttl = options.ttl || null;
+    this.cache = /* @__PURE__ */ new Map();
+    this.accessOrder = [];
+  }
+  /**
+   * Get value from cache
+   */
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const entry = this.cache.get(key);
+    if (this.ttl && Date.now() - entry.timestamp > this.ttl) {
+      this.delete(key);
+      return void 0;
+    }
+    this.updateAccessOrder(key);
+    return entry.value;
+  }
+  /**
+   * Set value in cache
+   */
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.delete(key);
+    }
+    if (this.cache.size >= this.maxSize) {
+      this.evict();
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now()
+    });
+    this.accessOrder.push(key);
+    return this;
+  }
+  /**
+   * Check if key exists
+   */
+  has(key) {
+    if (!this.cache.has(key)) {
+      return false;
+    }
+    const entry = this.cache.get(key);
+    if (this.ttl && Date.now() - entry.timestamp > this.ttl) {
+      this.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete key
+   */
+  delete(key) {
+    this.cache.delete(key);
+    const index = this.accessOrder.indexOf(key);
+    if (index > -1) {
+      this.accessOrder.splice(index, 1);
+    }
+    return this;
+  }
+  /**
+   * Clear cache
+   */
+  clear() {
+    this.cache.clear();
+    this.accessOrder = [];
+    return this;
+  }
+  /**
+   * Get cache size
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * Update access order
+   */
+  updateAccessOrder(key) {
+    const index = this.accessOrder.indexOf(key);
+    if (index > -1) {
+      this.accessOrder.splice(index, 1);
+    }
+    this.accessOrder.push(key);
+  }
+  /**
+   * Evict least recently used
+   */
+  evict() {
+    if (this.accessOrder.length > 0) {
+      const oldest = this.accessOrder.shift();
+      this.cache.delete(oldest);
+    }
+  }
+  /**
+   * Get all keys
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Get all values
+   */
+  values() {
+    return Array.from(this.cache.values()).map((entry) => entry.value);
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      utilizationPercent: (this.cache.size / this.maxSize * 100).toFixed(2),
+      oldestKey: this.accessOrder[0],
+      newestKey: this.accessOrder[this.accessOrder.length - 1]
+    };
+  }
+};
+var MemoryCache = class {
+  constructor(options = {}) {
+    this.options = {
+      strategy: "lru",
+      // lru, lfu, fifo
+      maxSize: 100,
+      ttl: null,
+      ...options
+    };
+    this.cache = /* @__PURE__ */ new Map();
+    this.metadata = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * Get from cache
+   */
+  get(key) {
+    if (!this.cache.has(key)) {
+      this.misses++;
+      return void 0;
+    }
+    const entry = this.cache.get(key);
+    if (entry.ttl && Date.now() > entry.expiresAt) {
+      this.delete(key);
+      this.misses++;
+      return void 0;
+    }
+    this.updateMetadata(key);
+    this.hits++;
+    return entry.value;
+  }
+  /**
+   * Set in cache
+   */
+  set(key, value, options = {}) {
+    if (this.cache.size >= this.options.maxSize && !this.cache.has(key)) {
+      this.evict();
+    }
+    const ttl = options.ttl || this.options.ttl;
+    this.cache.set(key, {
+      value,
+      ttl,
+      expiresAt: ttl ? Date.now() + ttl : null,
+      createdAt: Date.now()
+    });
+    this.metadata.set(key, {
+      accessCount: 0,
+      lastAccess: Date.now()
+    });
+    return this;
+  }
+  /**
+   * Update metadata based on strategy
+   */
+  updateMetadata(key) {
+    const meta = this.metadata.get(key);
+    if (meta) {
+      meta.accessCount++;
+      meta.lastAccess = Date.now();
+    }
+  }
+  /**
+   * Evict based on strategy
+   */
+  evict() {
+    let keyToEvict;
+    switch (this.options.strategy) {
+      case "lru":
+        keyToEvict = this.findLRU();
+        break;
+      case "lfu":
+        keyToEvict = this.findLFU();
+        break;
+      case "fifo":
+        keyToEvict = this.findFIFO();
+        break;
+      default:
+        keyToEvict = this.cache.keys().next().value;
+    }
+    if (keyToEvict) {
+      this.delete(keyToEvict);
+    }
+  }
+  /**
+   * Find least recently used key
+   */
+  findLRU() {
+    let oldest = null;
+    let oldestTime = Infinity;
+    for (const [key, meta] of this.metadata.entries()) {
+      if (meta.lastAccess < oldestTime) {
+        oldestTime = meta.lastAccess;
+        oldest = key;
+      }
+    }
+    return oldest;
+  }
+  /**
+   * Find least frequently used key
+   */
+  findLFU() {
+    let leastUsed = null;
+    let minCount = Infinity;
+    for (const [key, meta] of this.metadata.entries()) {
+      if (meta.accessCount < minCount) {
+        minCount = meta.accessCount;
+        leastUsed = key;
+      }
+    }
+    return leastUsed;
+  }
+  /**
+   * Find first in (oldest)
+   */
+  findFIFO() {
+    let oldest = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.createdAt < oldestTime) {
+        oldestTime = entry.createdAt;
+        oldest = key;
+      }
+    }
+    return oldest;
+  }
+  /**
+   * Check if key exists
+   */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * Delete key
+   */
+  delete(key) {
+    this.cache.delete(key);
+    this.metadata.delete(key);
+    return this;
+  }
+  /**
+   * Clear cache
+   */
+  clear() {
+    this.cache.clear();
+    this.metadata.clear();
+    this.hits = 0;
+    this.misses = 0;
+    return this;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    const hitRate = total > 0 ? (this.hits / total * 100).toFixed(2) : 0;
+    return {
+      size: this.cache.size,
+      maxSize: this.options.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: `${hitRate}%`,
+      strategy: this.options.strategy
+    };
+  }
+};
+var MemoCache = class {
+  constructor(options = {}) {
+    this.cache = new LRUCache(options);
+    this.keyGenerator = options.keyGenerator || this.defaultKeyGenerator;
+  }
+  /**
+   * Default key generator
+   */
+  defaultKeyGenerator(...args) {
+    return JSON.stringify(args);
+  }
+  /**
+   * Memoize a function
+   */
+  memoize(fn) {
+    return (...args) => {
+      const key = this.keyGenerator(...args);
+      if (this.cache.has(key)) {
+        return this.cache.get(key);
+      }
+      const result = fn(...args);
+      this.cache.set(key, result);
+      return result;
+    };
+  }
+  /**
+   * Clear memoization cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return this.cache.getStats();
+  }
+};
+var RenderCache = class {
+  constructor(options = {}) {
+    this.cache = new MemoryCache({
+      maxSize: options.maxSize || 50,
+      ttl: options.ttl || 6e4,
+      // 1 minute default
+      strategy: "lru"
+    });
+  }
+  /**
+   * Generate cache key for component
+   */
+  generateKey(component, props) {
+    const componentName = component.name || "anonymous";
+    const propsKey = this.hashProps(props);
+    return `${componentName}:${propsKey}`;
+  }
+  /**
+   * Hash props for cache key
+   */
+  hashProps(props) {
+    try {
+      return JSON.stringify(props, Object.keys(props).sort());
+    } catch {
+      return String(Date.now());
+    }
+  }
+  /**
+   * Get cached render
+   */
+  get(component, props) {
+    const key = this.generateKey(component, props);
+    return this.cache.get(key);
+  }
+  /**
+   * Cache render result
+   */
+  set(component, props, result, options = {}) {
+    const key = this.generateKey(component, props);
+    this.cache.set(key, result, options);
+  }
+  /**
+   * Clear cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return this.cache.getStats();
+  }
+};
+function createCache(type = "lru", options = {}) {
+  switch (type) {
+    case "lru":
+      return new LRUCache(options);
+    case "memory":
+      return new MemoryCache(options);
+    case "memo":
+      return new MemoCache(options);
+    case "render":
+      return new RenderCache(options);
+    default:
+      return new LRUCache(options);
+  }
+}
+function memoize(fn, options = {}) {
+  const cache = new MemoCache(options);
+  return cache.memoize(fn);
+}
+
+// src/performance/lazy-loading.js
+var LazyLoader = class {
+  constructor(options = {}) {
+    this.options = {
+      rootMargin: "50px",
+      threshold: 0.01,
+      ...options
+    };
+    this.observer = null;
+    this.observed = /* @__PURE__ */ new Set();
+    this.loaded = /* @__PURE__ */ new Set();
+    this.initObserver();
+  }
+  /**
+   * Initialize Intersection Observer
+   */
+  initObserver() {
+    if (typeof IntersectionObserver === "undefined") {
+      return;
+    }
+    this.observer = new IntersectionObserver(
+      (entries) => this.handleIntersection(entries),
+      {
+        rootMargin: this.options.rootMargin,
+        threshold: this.options.threshold
+      }
+    );
+  }
+  /**
+   * Handle intersection
+   */
+  handleIntersection(entries) {
+    entries.forEach((entry) => {
+      if (entry.isIntersecting) {
+        this.loadElement(entry.target);
+      }
+    });
+  }
+  /**
+   * Observe an element
+   */
+  observe(element) {
+    if (!this.observer || this.observed.has(element)) {
+      return;
+    }
+    this.observer.observe(element);
+    this.observed.add(element);
+  }
+  /**
+   * Unobserve an element
+   */
+  unobserve(element) {
+    if (!this.observer) {
+      return;
+    }
+    this.observer.unobserve(element);
+    this.observed.delete(element);
+  }
+  /**
+   * Load an element
+   */
+  loadElement(element) {
+    if (this.loaded.has(element)) {
+      return;
+    }
+    if (element.tagName === "IMG") {
+      this.loadImage(element);
+    } else if (element.tagName === "SCRIPT") {
+      this.loadScript(element);
+    } else if (element.tagName === "IFRAME") {
+      this.loadIframe(element);
+    }
+    this.loaded.add(element);
+    this.unobserve(element);
+  }
+  /**
+   * Load image
+   */
+  loadImage(img) {
+    const src = img.dataset.src;
+    const srcset = img.dataset.srcset;
+    if (src) {
+      img.src = src;
+    }
+    if (srcset) {
+      img.srcset = srcset;
+    }
+    img.classList.add("loaded");
+  }
+  /**
+   * Load script
+   */
+  loadScript(script) {
+    const src = script.dataset.src;
+    if (src) {
+      script.src = src;
+    }
+  }
+  /**
+   * Load iframe
+   */
+  loadIframe(iframe) {
+    const src = iframe.dataset.src;
+    if (src) {
+      iframe.src = src;
+    }
+  }
+  /**
+   * Disconnect observer
+   */
+  disconnect() {
+    if (this.observer) {
+      this.observer.disconnect();
+    }
+    this.observed.clear();
+  }
+};
+var ImageLazyLoader = class {
+  constructor(options = {}) {
+    this.options = {
+      placeholder: 'data:image/svg+xml,%3Csvg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"%3E%3C/svg%3E',
+      loadingClass: "lazy-loading",
+      loadedClass: "lazy-loaded",
+      errorClass: "lazy-error",
+      ...options
+    };
+    this.loader = new LazyLoader(options);
+  }
+  /**
+   * Create lazy image component
+   */
+  createImage(src, options = {}) {
+    return {
+      img: {
+        src: this.options.placeholder,
+        "data-src": src,
+        "data-srcset": options.srcset,
+        alt: options.alt || "",
+        className: this.options.loadingClass,
+        loading: "lazy",
+        onload: `this.classList.add("${this.options.loadedClass}")`,
+        onerror: `this.classList.add("${this.options.errorClass}")`
+      }
+    };
+  }
+  /**
+   * Observe images
+   */
+  observe(selector = "img[data-src]") {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const images = document.querySelectorAll(selector);
+    images.forEach((img) => this.loader.observe(img));
+  }
+  /**
+   * Load all images immediately
+   */
+  loadAll() {
+    this.observed.forEach((element) => {
+      this.loader.loadElement(element);
+    });
+  }
+};
+var ResourcePreloader = class {
+  constructor() {
+    this.preloaded = /* @__PURE__ */ new Set();
+    this.preloading = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Preload an image
+   */
+  async preloadImage(src) {
+    if (this.preloaded.has(src)) {
+      return;
+    }
+    if (this.preloading.has(src)) {
+      return this.preloading.get(src);
+    }
+    const promise = new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => {
+        this.preloaded.add(src);
+        this.preloading.delete(src);
+        resolve(img);
+      };
+      img.onerror = () => {
+        this.preloading.delete(src);
+        reject(new Error(`Failed to preload image: ${src}`));
+      };
+      img.src = src;
+    });
+    this.preloading.set(src, promise);
+    return promise;
+  }
+  /**
+   * Preload multiple images
+   */
+  async preloadImages(sources) {
+    return Promise.all(sources.map((src) => this.preloadImage(src)));
+  }
+  /**
+   * Preload a script
+   */
+  async preloadScript(src) {
+    if (this.preloaded.has(src)) {
+      return;
+    }
+    if (this.preloading.has(src)) {
+      return this.preloading.get(src);
+    }
+    const promise = new Promise((resolve, reject) => {
+      const link = document.createElement("link");
+      link.rel = "preload";
+      link.as = "script";
+      link.href = src;
+      link.onload = () => {
+        this.preloaded.add(src);
+        this.preloading.delete(src);
+        resolve();
+      };
+      link.onerror = () => {
+        this.preloading.delete(src);
+        reject(new Error(`Failed to preload script: ${src}`));
+      };
+      document.head.appendChild(link);
+    });
+    this.preloading.set(src, promise);
+    return promise;
+  }
+  /**
+   * Prefetch a resource
+   */
+  prefetch(href, options = {}) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const link = document.createElement("link");
+    link.rel = "prefetch";
+    link.href = href;
+    if (options.as) {
+      link.as = options.as;
+    }
+    document.head.appendChild(link);
+  }
+  /**
+   * Check if resource is preloaded
+   */
+  isPreloaded(src) {
+    return this.preloaded.has(src);
+  }
+  /**
+   * Clear preload cache
+   */
+  clear() {
+    this.preloaded.clear();
+    this.preloading.clear();
+  }
+};
+var ProgressiveImageLoader = class {
+  /**
+   * Create progressive image component
+   */
+  createImage(lowResSrc, highResSrc, options = {}) {
+    return {
+      div: {
+        className: "progressive-image",
+        style: options.style || {},
+        children: [
+          {
+            img: {
+              src: lowResSrc,
+              className: "progressive-image-low",
+              alt: options.alt || "",
+              style: "filter: blur(10px); transition: opacity 0.3s;"
+            }
+          },
+          {
+            img: {
+              "data-src": highResSrc,
+              className: "progressive-image-high",
+              alt: options.alt || "",
+              style: "opacity: 0; transition: opacity 0.3s;",
+              onload: "this.style.opacity = 1; this.previousElementSibling.style.opacity = 0;"
+            }
+          }
+        ]
+      }
+    };
+  }
+};
+function createLazyLoader(options = {}) {
+  return new LazyLoader(options);
+}
+function createImageLazyLoader(options = {}) {
+  return new ImageLazyLoader(options);
+}
+function createPreloader() {
+  return new ResourcePreloader();
+}
+function lazyImage(src, options = {}) {
+  const loader = new ImageLazyLoader();
+  return loader.createImage(src, options);
+}
+function progressiveImage(lowRes, highRes, options = {}) {
+  const loader = new ProgressiveImageLoader();
+  return loader.createImage(lowRes, highRes, options);
+}
+
+// src/performance-dashboard.js
+var PerformanceDashboard = class {
+  constructor(options = {}) {
+    this.options = {
+      updateInterval: options.updateInterval || 5e3,
+      maxHistoryPoints: options.maxHistoryPoints || 100,
+      enableAlerts: options.enableAlerts !== false,
+      enableRecommendations: options.enableRecommendations !== false,
+      colorOutput: options.colorOutput !== false,
+      ...options
+    };
+    this.metrics = {
+      api: {
+        requests: 0,
+        averageTime: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+        staticRoutes: 0,
+        dynamicRoutes: 0,
+        history: []
+      },
+      components: {
+        renders: 0,
+        averageTime: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+        staticComponents: 0,
+        dynamicComponents: 0,
+        memoryUsage: 0,
+        history: []
+      },
+      fullstack: {
+        totalRequests: 0,
+        averageTime: 0,
+        errors: 0,
+        bottlenecks: [],
+        history: []
+      }
+    };
+    this.alerts = [];
+    this.recommendations = [];
+    this.startTime = Date.now();
+    this.updateTimer = null;
+  }
+  /**
+   * Start monitoring performance
+   */
+  startMonitoring() {
+    if (this.updateTimer) return;
+    this.updateTimer = setInterval(() => {
+      this.updateMetrics();
+      this.generateAlerts();
+      this.generateRecommendations();
+    }, this.options.updateInterval);
+  }
+  /**
+   * Stop monitoring
+   */
+  stopMonitoring() {
+    if (this.updateTimer) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = null;
+    }
+  }
+  /**
+   * Record API request metrics
+   */
+  recordAPIRequest(duration, routeType, cacheHit = false) {
+    this.metrics.api.requests++;
+    this.metrics.api.averageTime = this.updateAverage(
+      this.metrics.api.averageTime,
+      duration,
+      this.metrics.api.requests
+    );
+    if (cacheHit) {
+      this.metrics.api.cacheHits++;
+    } else {
+      this.metrics.api.cacheMisses++;
+    }
+    if (routeType === "static") {
+      this.metrics.api.staticRoutes++;
+    } else {
+      this.metrics.api.dynamicRoutes++;
+    }
+    this.addToHistory("api", {
+      timestamp: Date.now(),
+      duration,
+      routeType,
+      cacheHit
+    });
+  }
+  /**
+   * Record component render metrics
+   */
+  recordComponentRender(duration, componentType, cacheHit = false, memoryDelta = 0) {
+    this.metrics.components.renders++;
+    this.metrics.components.averageTime = this.updateAverage(
+      this.metrics.components.averageTime,
+      duration,
+      this.metrics.components.renders
+    );
+    if (cacheHit) {
+      this.metrics.components.cacheHits++;
+    } else {
+      this.metrics.components.cacheMisses++;
+    }
+    if (componentType === "static") {
+      this.metrics.components.staticComponents++;
+    } else {
+      this.metrics.components.dynamicComponents++;
+    }
+    this.metrics.components.memoryUsage += memoryDelta;
+    this.addToHistory("components", {
+      timestamp: Date.now(),
+      duration,
+      componentType,
+      cacheHit,
+      memoryDelta
+    });
+  }
+  /**
+   * Record full-stack request metrics
+   */
+  recordFullStackRequest(duration, error = null, bottlenecks = []) {
+    this.metrics.fullstack.totalRequests++;
+    this.metrics.fullstack.averageTime = this.updateAverage(
+      this.metrics.fullstack.averageTime,
+      duration,
+      this.metrics.fullstack.totalRequests
+    );
+    if (error) {
+      this.metrics.fullstack.errors++;
+    }
+    this.metrics.fullstack.bottlenecks = bottlenecks;
+    this.addToHistory("fullstack", {
+      timestamp: Date.now(),
+      duration,
+      error,
+      bottlenecks
+    });
+  }
+  /**
+   * Update metrics from external sources
+   */
+  updateMetrics() {
+    const now = Date.now();
+    const uptime = now - this.startTime;
+    const apiRate = this.metrics.api.requests / (uptime / 1e3);
+    const componentRate = this.metrics.components.renders / (uptime / 1e3);
+    const fullStackRate = this.metrics.fullstack.totalRequests / (uptime / 1e3);
+    return {
+      apiRate,
+      componentRate,
+      fullStackRate,
+      uptime
+    };
+  }
+  /**
+   * Generate performance alerts
+   */
+  generateAlerts() {
+    this.alerts = [];
+    if (this.metrics.api.averageTime > 50) {
+      this.alerts.push({
+        type: "warning",
+        category: "api",
+        message: `API response time is high: ${this.metrics.api.averageTime.toFixed(2)}ms`,
+        threshold: 50,
+        current: this.metrics.api.averageTime
+      });
+    }
+    const apiCacheHitRate = this.getCacheHitRate("api");
+    if (apiCacheHitRate < 80) {
+      this.alerts.push({
+        type: "warning",
+        category: "api",
+        message: `API cache hit rate is low: ${apiCacheHitRate.toFixed(1)}%`,
+        threshold: 80,
+        current: apiCacheHitRate
+      });
+    }
+    if (this.metrics.components.averageTime > 20) {
+      this.alerts.push({
+        type: "warning",
+        category: "components",
+        message: `Component render time is high: ${this.metrics.components.averageTime.toFixed(2)}ms`,
+        threshold: 20,
+        current: this.metrics.components.averageTime
+      });
+    }
+    const componentCacheHitRate = this.getCacheHitRate("components");
+    if (componentCacheHitRate < 90) {
+      this.alerts.push({
+        type: "warning",
+        category: "components",
+        message: `Component cache hit rate is low: ${componentCacheHitRate.toFixed(1)}%`,
+        threshold: 90,
+        current: componentCacheHitRate
+      });
+    }
+    if (this.metrics.fullstack.errors > 0) {
+      this.alerts.push({
+        type: "error",
+        category: "fullstack",
+        message: `${this.metrics.fullstack.errors} errors detected`,
+        threshold: 0,
+        current: this.metrics.fullstack.errors
+      });
+    }
+  }
+  /**
+   * Generate performance recommendations
+   */
+  generateRecommendations() {
+    this.recommendations = [];
+    const staticRouteRatio = this.metrics.api.staticRoutes / Math.max(this.metrics.api.requests, 1);
+    if (staticRouteRatio < 0.7) {
+      this.recommendations.push({
+        type: "optimization",
+        category: "api",
+        message: "Consider adding more static routes to improve smart routing efficiency",
+        impact: "high",
+        effort: "low"
+      });
+    }
+    const apiCacheHitRate = this.getCacheHitRate("api");
+    if (apiCacheHitRate < 90) {
+      this.recommendations.push({
+        type: "optimization",
+        category: "api",
+        message: "Increase API cache size or TTL to improve cache hit rate",
+        impact: "medium",
+        effort: "low"
+      });
+    }
+    const staticComponentRatio = this.metrics.components.staticComponents / Math.max(this.metrics.components.renders, 1);
+    if (staticComponentRatio < 0.8) {
+      this.recommendations.push({
+        type: "optimization",
+        category: "components",
+        message: "More components could be optimized as static for better caching",
+        impact: "high",
+        effort: "medium"
+      });
+    }
+    if (this.metrics.components.memoryUsage > 100 * 1024 * 1024) {
+      this.recommendations.push({
+        type: "optimization",
+        category: "memory",
+        message: "Memory usage is high. Consider reducing cache size or implementing memory cleanup",
+        impact: "medium",
+        effort: "medium"
+      });
+    }
+  }
+  /**
+   * Get cache hit rate for category
+   */
+  getCacheHitRate(category) {
+    const metrics = this.metrics[category];
+    if (!metrics || !metrics.cacheHits) return 0;
+    const total = metrics.cacheHits + metrics.cacheMisses;
+    return total > 0 ? metrics.cacheHits / total * 100 : 0;
+  }
+  /**
+   * Update running average
+   */
+  updateAverage(current, newValue, count) {
+    return (current * (count - 1) + newValue) / count;
+  }
+  /**
+   * Add data point to history
+   */
+  addToHistory(category, data) {
+    if (!this.metrics[category].history) {
+      this.metrics[category].history = [];
+    }
+    this.metrics[category].history.push(data);
+    if (this.metrics[category].history.length > this.options.maxHistoryPoints) {
+      this.metrics[category].history = this.metrics[category].history.slice(-this.options.maxHistoryPoints);
+    }
+  }
+  /**
+   * Generate dashboard visualization
+   */
+  generateDashboard() {
+    const lines = [];
+    if (this.options.colorOutput) {
+      lines.push(this.colorize("\u{1F4CA} Coherent.js Performance Dashboard", "cyan"));
+      lines.push(this.colorize("\u2550".repeat(50), "cyan"));
+    } else {
+      lines.push("\u{1F4CA} Coherent.js Performance Dashboard");
+      lines.push("\u2550".repeat(50));
+    }
+    const uptime = (Date.now() - this.startTime) / 1e3;
+    lines.push(`\u23F1\uFE0F  Uptime: ${uptime.toFixed(1)}s`);
+    lines.push("");
+    lines.push("\u{1F680} API Performance");
+    lines.push("\u2500".repeat(20));
+    const apiCacheHitRate = this.getCacheHitRate("api");
+    lines.push(`   Requests: ${this.metrics.api.requests} (${(this.metrics.api.requests / uptime).toFixed(1)} req/s)`);
+    lines.push(`   Avg Time: ${this.metrics.api.averageTime.toFixed(2)}ms`);
+    lines.push(`   Cache Hit Rate: ${apiCacheHitRate.toFixed(1)}%`);
+    lines.push(`   Static Routes: ${this.metrics.api.staticRoutes}/${this.metrics.api.requests} (${(this.metrics.api.staticRoutes / Math.max(this.metrics.api.requests, 1) * 100).toFixed(1)}%)`);
+    lines.push("");
+    lines.push("\u{1F3D7}\uFE0F  Component Performance");
+    lines.push("\u2500".repeat(25));
+    const componentCacheHitRate = this.getCacheHitRate("components");
+    lines.push(`   Renders: ${this.metrics.components.renders} (${(this.metrics.components.renders / uptime).toFixed(1)} renders/s)`);
+    lines.push(`   Avg Time: ${this.metrics.components.averageTime.toFixed(2)}ms`);
+    lines.push(`   Cache Hit Rate: ${componentCacheHitRate.toFixed(1)}%`);
+    lines.push(`   Static Components: ${this.metrics.components.staticComponents}/${this.metrics.components.renders} (${(this.metrics.components.staticComponents / Math.max(this.metrics.components.renders, 1) * 100).toFixed(1)}%)`);
+    lines.push(`   Memory Usage: ${(this.metrics.components.memoryUsage / 1024 / 1024).toFixed(1)}MB`);
+    lines.push("");
+    lines.push("\u{1F310} Full-Stack Performance");
+    lines.push("\u2500".repeat(26));
+    lines.push(`   Total Requests: ${this.metrics.fullstack.totalRequests} (${(this.metrics.fullstack.totalRequests / uptime).toFixed(1)} req/s)`);
+    lines.push(`   Avg Time: ${this.metrics.fullstack.averageTime.toFixed(2)}ms`);
+    lines.push(`   Errors: ${this.metrics.fullstack.errors}`);
+    lines.push("");
+    if (this.alerts.length > 0) {
+      lines.push("\u26A0\uFE0F  Performance Alerts");
+      lines.push("\u2500".repeat(22));
+      this.alerts.forEach((alert) => {
+        const icon = alert.type === "error" ? "\u274C" : "\u26A0\uFE0F";
+        lines.push(`   ${icon} ${alert.message}`);
+      });
+      lines.push("");
+    }
+    if (this.recommendations.length > 0) {
+      lines.push("\u{1F4A1} Optimization Recommendations");
+      lines.push("\u2500".repeat(30));
+      this.recommendations.forEach((rec) => {
+        const impact = rec.impact === "high" ? "\u{1F525}" : rec.impact === "medium" ? "\u26A1" : "\u{1F4A4}";
+        lines.push(`   ${impact} ${rec.message} (${rec.effort} effort)`);
+      });
+      lines.push("");
+    }
+    const score = this.calculatePerformanceScore();
+    const scoreColor = score >= 90 ? "green" : score >= 70 ? "yellow" : "red";
+    lines.push(`Performance Score: ${this.colorize(`${score.toFixed(1)}/100`, scoreColor)}`);
+    return lines.join("\n");
+  }
+  /**
+   * Calculate overall performance score
+   */
+  calculatePerformanceScore() {
+    let score = 100;
+    if (this.metrics.api.averageTime > 50) score -= 10;
+    if (this.metrics.api.averageTime > 100) score -= 10;
+    if (this.getCacheHitRate("api") < 90) score -= 10;
+    if (this.metrics.components.averageTime > 20) score -= 10;
+    if (this.metrics.components.averageTime > 50) score -= 10;
+    if (this.getCacheHitRate("components") < 95) score -= 10;
+    if (this.metrics.fullstack.errors > 0) score -= Math.min(20, this.metrics.fullstack.errors * 5);
+    return Math.max(0, score);
+  }
+  /**
+   * Add color to text
+   */
+  colorize(text, color) {
+    if (!this.options.colorOutput) return text;
+    const colors = {
+      black: "\x1B[30m",
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      magenta: "\x1B[35m",
+      cyan: "\x1B[36m",
+      white: "\x1B[37m",
+      gray: "\x1B[90m"
+    };
+    const reset = "\x1B[0m";
+    return `${colors[color] || ""}${text}${reset}`;
+  }
+  /**
+   * Export metrics as JSON
+   */
+  exportMetrics() {
+    return {
+      timestamp: Date.now(),
+      uptime: Date.now() - this.startTime,
+      metrics: { ...this.metrics },
+      alerts: [...this.alerts],
+      recommendations: [...this.recommendations],
+      performanceScore: this.calculatePerformanceScore()
+    };
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.metrics = {
+      api: { requests: 0, averageTime: 0, cacheHits: 0, cacheMisses: 0, staticRoutes: 0, dynamicRoutes: 0, history: [] },
+      components: { renders: 0, averageTime: 0, cacheHits: 0, cacheMisses: 0, staticComponents: 0, dynamicComponents: 0, memoryUsage: 0, history: [] },
+      fullstack: { totalRequests: 0, averageTime: 0, errors: 0, bottlenecks: [], history: [] }
+    };
+    this.alerts = [];
+    this.recommendations = [];
+    this.startTime = Date.now();
+  }
+};
+function createPerformanceDashboard(options = {}) {
+  return new PerformanceDashboard(options);
+}
+function showPerformanceDashboard(dashboard) {
+  const output = dashboard.generateDashboard();
+  console.log(output);
+  return dashboard;
+}
+export {
+  BundleAnalyzer,
+  CodeSplitter,
+  ImageLazyLoader,
+  LRUCache,
+  LazyLoader,
+  MemoCache,
+  MemoryCache,
+  PerformanceDashboard,
+  ProgressiveImageLoader,
+  RenderCache,
+  ResourcePreloader,
+  createCache,
+  createCodeSplitter,
+  createImageLazyLoader,
+  createLazyLoader,
+  createPerformanceDashboard,
+  createPreloader,
+  createRouteSplitter,
+  lazy,
+  lazyImage,
+  memoize,
+  progressiveImage,
+  showPerformanceDashboard,
+  splitComponent
+};
+//# sourceMappingURL=index.js.map