@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.9 → 0.2.11

package/dist/utils/lazy-loading.js

@@ -2,70 +2,74 @@ import React from 'react';
 
 // Lazy loading utilities for code splitting and dynamic imports
 export interface LazyLoadConfig {
-  enabled;
-  preloadThreshold;
-  cacheSize;
-  retryAttempts;
-  retryDelay;
-  loadingTimeout;
+  enabled: boolean;
+  preloadThreshold: number;
+  cacheSize: number;
+  retryAttempts: number;
+  retryDelay: number;
+  loadingTimeout: number;
 }
 
 export interface LazyLoadResult<T> {
-  data;
-  loading;
-  error;
-  retry) => Promise<LazyLoadResult<T>>;
+  data: T | null;
+  loading: boolean;
+  error: Error | null;
+  retry: () => Promise<LazyLoadResult<T>>;
 }
 
 export interface LazyLoadStats {
-  totalRequests;
-  successfulLoads;
-  failedLoads;
-  cacheHits;
-  averageLoadTime;
-  totalLoadTime;
+  totalRequests: number;
+  successfulLoads: number;
+  failedLoads: number;
+  cacheHits: number;
+  averageLoadTime: number;
+  totalLoadTime: number;
 }
 
 export class LazyLoader {
-  private config;
-  private cache, { data; timestamp; ttl}>;
-  private loadingStates, boolean>;
-  private errorStates, Error>;
-  private stats;
-  private preloadQueue;
-  private retryCounts, number>;
-
-  constructor(config= {
-    enabled,
-    preloadThreshold,
-    cacheSize,
-    retryAttempts,
-    retryDelay,
-    loadingTimeout}) {
+  private config: LazyLoadConfig;
+  private cache: Map<string, { data: any; timestamp: number; ttl: number }>;
+  private loadingStates: Map<string, boolean>;
+  private errorStates: Map<string, Error>;
+  private stats: LazyLoadStats;
+  private preloadQueue: Set<string>;
+  private retryCounts: Map<string, number>;
+
+  constructor(config: LazyLoadConfig = {
+    enabled: true,
+    preloadThreshold: 0.8,
+    cacheSize: 100,
+    retryAttempts: 3,
+    retryDelay: 1000,
+    loadingTimeout: 10000
+  }) {
     this.config = config;
     this.cache = new Map();
     this.loadingStates = new Map();
     this.errorStates = new Map();
     this.stats = {
-      totalRequests,
-      successfulLoads,
-      failedLoads,
-      cacheHits,
-      averageLoadTime,
-      totalLoadTime};
+      totalRequests: 0,
+      successfulLoads: 0,
+      failedLoads: 0,
+      cacheHits: 0,
+      averageLoadTime: 0,
+      totalLoadTime: 0
+    };
     this.preloadQueue = new Set();
     this.retryCounts = new Map();
   }
 
   // Lazy load a module with dynamic import
   async lazyLoad<T>(
-    modulePath,
-    importFn) => Promise<T>,
-    options;
-      ttl?;
-      preload?;
+    modulePath: string,
+    importFn: () => Promise<T>,
+    options: {
+      cacheKey?: string;
+      ttl?: number;
+      preload?: boolean;
     } = {}
-  )= options.cacheKey || modulePath;
+  ): Promise<LazyLoadResult<T>> {
+    const cacheKey = options.cacheKey || modulePath;
     const ttl = options.ttl || 300000; // 5 minutes default
 
     // Check cache first
@@ -75,10 +79,10 @@ export class LazyLoader {
         this.stats.cacheHits++;
         this.stats.totalRequests++; // Count cache hits as requests too
         return {
-          data,
-          loading,
-          error,
-          retry) => {
+          data: cached.data,
+          loading: false,
+          error: null,
+          retry: () => {
             // Clear error state before retrying
             this.errorStates.delete(cacheKey);
             this.retryCounts.delete(cacheKey);
@@ -94,10 +98,10 @@ export class LazyLoader {
     // Check if already loading
     if (this.loadingStates.get(cacheKey)) {
       return {
-        data,
-        loading,
-        error,
-        retry) => this.lazyLoad(modulePath, importFn, options)
+        data: null,
+        loading: true,
+        error: null,
+        retry: () => this.lazyLoad(modulePath, importFn, options)
       };
     }
 
@@ -105,10 +109,10 @@ export class LazyLoader {
     const previousError = this.errorStates.get(cacheKey);
     if (previousError) {
       return {
-        data,
-        loading,
-        error,
-        retry) => this.lazyLoad(modulePath, importFn, options)
+        data: null,
+        loading: false,
+        error: previousError,
+        retry: () => this.lazyLoad(modulePath, importFn, options)
       };
     }
 
@@ -145,9 +149,9 @@ export class LazyLoader {
 
       return {
         data,
-        loading,
-        error,
-        retry) => this.lazyLoad(modulePath, importFn, options)
+        loading: false,
+        error: null,
+        retry: () => this.lazyLoad(modulePath, importFn, options)
       };
 
     } catch (error) {
@@ -168,14 +172,14 @@ export class LazyLoader {
         }, this.config.retryDelay);
       }
 
-      const errorObj = error instanceof Error ? error ));
+      const errorObj = error instanceof Error ? error : new Error(String(error));
       this.errorStates.set(cacheKey, errorObj);
 
       return {
-        data,
-        loading,
-        error,
-        retry) => {
+        data: null,
+        loading: false,
+        error: errorObj,
+        retry: () => {
           // Clear error state before retrying
           this.errorStates.delete(cacheKey);
           this.retryCounts.delete(cacheKey);
@@ -186,7 +190,8 @@ export class LazyLoader {
   }
 
   // Preload a module without waiting for the result
-  preload<T>(modulePath, importFn) => Promise<T>)) return;
+  preload<T>(modulePath: string, importFn: () => Promise<T>): void {
+    if (!this.config.enabled) return;
 
     // Limit preload queue size
     if (this.preloadQueue.size >= 10) {
@@ -211,17 +216,20 @@ export class LazyLoader {
   }
 
   // Execute preload
-  private async executePreload<T>(modulePath, importFn) => Promise<T>), importFn, { cacheKey, ttl}); // 10 minutes for preloaded modules
+  private async executePreload<T>(modulePath: string, importFn: () => Promise<T>): Promise<void> {
+    try {
+      await this.lazyLoad(modulePath, importFn, { cacheKey: modulePath, ttl: 600000 }); // 10 minutes for preloaded modules
     } catch (error) {
       // Silently fail preloads
-      console.debug(`Preload failed for ${modulePath}, error);
+      console.debug(`Preload failed for ${modulePath}:`, error);
     } finally {
       this.preloadQueue.delete(modulePath);
     }
   }
 
   // Queue preload for later execution
-  private queuePreload(modulePath)) { // Limit preload queue
+  private queuePreload(modulePath: string): void {
+    if (this.preloadQueue.size < 10) { // Limit preload queue
       this.preloadQueue.add(modulePath);
     }
   }
@@ -229,7 +237,9 @@ export class LazyLoader {
 
 
   // Cache a result
-  private cacheResult(key, data, ttl)= this.config.cacheSize) {
+  private cacheResult(key: string, data: any, ttl: number): void {
+    // Implement LRU cache eviction
+    if (this.cache.size >= this.config.cacheSize) {
       const oldestKey = this.cache.keys().next().value;
       if (oldestKey) {
         this.cache.delete(oldestKey);
@@ -238,83 +248,95 @@ export class LazyLoader {
 
     this.cache.set(key, {
       data,
-      timestamp),
+      timestamp: Date.now(),
       ttl
     });
   }
 
   // Create a timeout promise
-  private createTimeout(ms), reject) => {
+  private createTimeout(ms: number): Promise<never> {
+    return new Promise((_, reject) => {
       setTimeout(() => reject(new Error(`Loading timeout after ${ms}ms`)), ms);
     });
   }
 
   // Update load time statistics
-  private updateLoadTimeStats(loadTime)= loadTime;
+  private updateLoadTimeStats(loadTime: number): void {
+    this.stats.totalLoadTime += loadTime;
     this.stats.averageLoadTime = this.stats.totalLoadTime / this.stats.totalRequests;
   }
 
   // Get loading state for a module
-  isLoading(modulePath));
+  isLoading(modulePath: string): boolean {
+    return this.loadingStates.has(modulePath);
   }
 
   // Get error state for a module
-  getError(modulePath)) || null;
+  getError(modulePath: string): Error | null {
+    return this.errorStates.get(modulePath) || null;
   }
 
   // Clear cache for a specific module
-  clearCache(modulePath));
+  clearCache(modulePath: string): void {
+    this.cache.delete(modulePath);
     this.errorStates.delete(modulePath);
     this.retryCounts.delete(modulePath);
   }
 
   // Clear all cache
-  clearAllCache());
+  clearAllCache(): void {
+    this.cache.clear();
     this.errorStates.clear();
     this.retryCounts.clear();
   }
 
   // Get cache statistics
-  getCacheStats();
-    maxSize;
-    hitRate;
+  getCacheStats(): {
+    size: number;
+    maxSize: number;
+    hitRate: number;
   } {
     const hitRate = this.stats.totalRequests > 0 
       ? (this.stats.cacheHits / this.stats.totalRequests) * 100 
-      ;
+      : 0;
 
     return {
-      size,
-      maxSize,
+      size: this.cache.size,
+      maxSize: this.config.cacheSize,
       hitRate
     };
   }
 
   // Get performance statistics
-  getStats()};
+  getStats(): LazyLoadStats {
+    return { ...this.stats };
   }
 
   // Reset all statistics
-  resetStats()= {
-      totalRequests,
-      successfulLoads,
-      failedLoads,
-      cacheHits,
-      averageLoadTime,
-      totalLoadTime};
+  resetStats(): void {
+    this.stats = {
+      totalRequests: 0,
+      successfulLoads: 0,
+      failedLoads: 0,
+      cacheHits: 0,
+      averageLoadTime: 0,
+      totalLoadTime: 0
+    };
   }
 
   // Check if preload is in progress
-  isPreloading(modulePath));
+  isPreloading(modulePath: string): boolean {
+    return this.preloadQueue.has(modulePath);
   }
 
   // Get preload queue status
-  getPreloadQueue()] {
+  getPreloadQueue(): string[] {
     return Array.from(this.preloadQueue);
   }
 
   // Update configuration
-  updateConfig(newConfig)= { ...this.config, ...newConfig };
+  updateConfig(newConfig: Partial<LazyLoadConfig>): void {
+    this.config = { ...this.config, ...newConfig };
     
     // Adjust cache size if needed
     if (newConfig.cacheSize && newConfig.cacheSize < this.cache.size) {
@@ -328,16 +350,17 @@ export class LazyLoader {
   }
 
   // Export lazy loading analysis
-  exportAnalysis()= this.getCacheStats();
+  exportAnalysis(): string {
+    const cacheStats = this.getCacheStats();
     const stats = this.getStats();
     const preloadQueue = this.getPreloadQueue();
 
     return JSON.stringify({
-      config,
+      config: this.config,
       cacheStats,
-      performanceStats,
+      performanceStats: stats,
       preloadQueue,
-      timestamp).toISOString()
+      timestamp: new Date().toISOString()
     }, null, 2);
   }
 }
@@ -347,15 +370,18 @@ export const lazyLoader = new LazyLoader();
 
 // Utility function for React lazy loading
 export function createLazyComponent<T>(
-  importFn) => Promise<{ default}>
-));
+  importFn: () => Promise<{ default: React.ComponentType<T> }>
+): React.LazyExoticComponent<React.ComponentType<T>> {
+  return React.lazy(importFn);
 }
 
 // Utility function for conditional lazy loading
 export function conditionalLazyLoad<T>(
-  condition,
-  importFn) => Promise<T>,
-  fallback)) {
+  condition: boolean,
+  importFn: () => Promise<T>,
+  fallback: T
+): Promise<T> {
+  if (condition) {
     return importFn();
   }
   return Promise.resolve(fallback);
@@ -363,9 +389,9 @@ export function conditionalLazyLoad<T>(
 
 // Utility function for batch lazy loading
 export function batchLazyLoad<T>(
-  modules; importFn) => Promise<T> }>,
-  options; maxConcurrent?} = {}
-)]> {
+  modules: Array<{ path: string; importFn: () => Promise<T> }>,
+  options: { parallel?: boolean; maxConcurrent?: number } = {}
+): Promise<T[]> {
   const { parallel = true, maxConcurrent = 3 } = options;
 
   if (!parallel) {
@@ -378,9 +404,9 @@ export function batchLazyLoad<T>(
   }
 
   // Parallel loading with concurrency limit
-  const results] = [];
+  const results: T[] = [];
   const queue = [...modules];
-  const active] = [];
+  const active: Promise<void>[] = [];
 
   return new Promise((resolve, reject) => {
     function processQueue() {