WebAPICache
├── Method Cache (FunctionTemplate)
│   ├── API::MethodName → WebAPICacheEntry
│   └── Persistent V8 objects
└── Property Cache (ObjectTemplate)
    ├── API::PropertyName → WebAPICacheEntry
    └── Persistent V8 objects

#include <APHTML/Script/API/APUIBinder.h>

// Create binder and enable caching
APUIBinder binder;
binder.SetWebAPICachingEnabled(true);
binder.SetWebAPICacheSize(10 * 1024 * 1024); // 10MB cache

// Define Web API configuration
WebAPIBindingConfig config;
config.apiName = "MyWebAPI";
config.version = "1.0";
config.enableCaching = true;
config.persistentCache = true;
config.methods = {"getData", "setData", "process"};
config.properties = {"status", "count", "enabled"};

// Bind with caching
auto result = binder.BindWebAPI(config, [](::v8::Isolate* isolate, ::v8::Local<::v8::Context> context) {
    // Your binding logic here
    // This will be cached for future use
});

if (result.success) {
    std::cout << "Binding completed in " << result.bindingTimeMs << "ms" << std::endl;
    std::cout << "From cache: " << (result.fromCache ? "Yes" : "No") << std::endl;
}

// Cache individual methods
auto methodResult = binder.BindWebAPIMethod("MyAPI", "getData", 
    []() { return "data"; }, 
    true); // Enable caching

// Cache individual properties
auto propertyResult = binder.BindWebAPIProperty("MyAPI", "status",
    []() { return true; },
    [](bool value) { /* setter */ },
    true); // Enable caching

// Preload commonly used APIs for faster startup
std::vector<std::string> criticalAPIs = {
    "WebAudio", "WebStorage", "WebNetwork", "WebGL"
};

size_t preloaded = binder.PreloadWebAPIs(criticalAPIs);
std::cout << "Preloaded " << preloaded << " APIs" << std::endl;

// Get cache statistics
auto stats = binder.GetWebAPICacheStats();
std::cout << "Cache hit rate: " << (stats.hitRate * 100) << "%" << std::endl;
std::cout << "Memory usage: " << stats.totalMemoryUsage << " bytes" << std::endl;

// Clear specific API cache
binder.ClearWebAPICache("WebStorage");

// Clear all caches
binder.ClearWebAPICache();

// Optimize cache (removes old entries)
binder.OptimizeWebAPICache(false); // Non-aggressive
binder.OptimizeWebAPICache(true);  // Aggressive

// For high-performance applications
binder.SetWebAPICacheSize(50 * 1024 * 1024); // 50MB cache
binder.SetWebAPICachingEnabled(true);

// For memory-constrained environments
binder.SetWebAPICacheSize(1 * 1024 * 1024);  // 1MB cache
binder.OptimizeWebAPICache(true); // Aggressive cleanup

// Use persistent cache for stable APIs
config.persistentCache = true; // For WebAudio, WebGL, etc.

// Use temporary cache for dynamic APIs
config.persistentCache = false; // For WebStorage, WebNetwork, etc.

// Monitor cache usage
auto stats = binder.GetWebAPICacheStats();
if (stats.totalMemoryUsage > stats.maxCacheSize * 0.8) {
    binder.OptimizeWebAPICache(true);
}

// Preload critical APIs during initialization
std::vector<std::string> startupAPIs = {
    "WebAudio", "WebStorage", "WebNetwork"
};
binder.PreloadWebAPIs(startupAPIs);

auto result = binder.BindWebAPI(config, bindingFunction);
if (!result.success) {
    std::cerr << "Binding failed: " << result.errorMessage << std::endl;
    // Fallback to non-cached binding
    config.enableCaching = false;
    binder.BindWebAPI(config, bindingFunction);
}

// Register custom templates for reuse
binder.RegisterWebAPITemplate("CustomAPI", "1.0", 
    [](::v8::Isolate* isolate) -> ::v8::Local<::v8::FunctionTemplate> {
        return ::v8::FunctionTemplate::New(isolate, customCallback);
    });

// Get cached entry details
const auto* cached = binder.GetCachedWebAPI("MyAPI", "1.0");
if (cached) {
    std::cout << "Cache hit count: " << cached->hitCount << std::endl;
    std::cout << "Last used: " << cached->lastUsed.time_since_epoch().count() << std::endl;
}

// Before (standard binding)
binder.bindFunction("getData", &getDataFunction);

// After (with caching)
binder.BindWebAPIMethod("MyAPI", "getData", &getDataFunction, true);

// Before (standard class binding)
binder.bindClass<MyClass>("MyClass", [](auto& classBinder) {
    classBinder.addMethod("getData", &MyClass::getData);
});

// After (with caching)
WebAPIBindingConfig config;
config.apiName = "MyClass";
config.enableCaching = true;
binder.BindWebAPI(config, [](::v8::Isolate* isolate, ::v8::Local<::v8::Context> context) {
    binder.BindWebAPIMethod("MyClass", "getData", &MyClass::getData);
});

// Enable detailed logging
auto stats = binder.GetWebAPICacheStats();
std::cout << "Cache Debug Info:" << std::endl;
std::cout << "  Entries: " << stats.totalEntries << std::endl;
std::cout << "  Hits: " << stats.totalHits << std::endl;
std::cout << "  Misses: " << stats.totalMisses << std::endl;
std::cout << "  Hit Rate: " << (stats.hitRate * 100) << "%" << std::endl;
std::cout << "  Memory: " << stats.totalMemoryUsage << "/" << stats.maxCacheSize << std::endl;