@widgetic/editor 3.11.4 → 4.0.2

package/dist/utils/VectorManager.js

@@ -0,0 +1,754 @@
+import { vectorUtils, vectorCategories } from "./vectorUtils";
+class VectorManager {
+    // Debug configuration
+    static DEBUG_MODE = false;
+    static WAIT_TIME = VectorManager.DEBUG_MODE ? 2500 : 250;
+    // Singleton instance
+    static instance = null;
+    // Track loaded and pending vectors to prevent duplicates
+    loadedVectors = new Set();
+    // Map of intersection observers keyed by container ID
+    observers = new Map();
+    // Debounce timer for scroll events
+    scrollTimeout = null;
+    // Cache promise to prevent multiple simultaneous API calls
+    vectorListPromise = null;
+    initialVectorsLoaded = false;
+    allVectorsLoaded = false;
+    cachedVectorList = [];
+    // Cache configuration
+    static CACHE_KEY = 'svg_vectors_cache';
+    // Controls how long we keep the vector list in browser's localStorage
+    static CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
+    static LOADED_VECTORS_KEY = 'loaded_vectors_cache';
+    // Controls how long browsers should cache the actual vector files
+    static CACHE_CONTROL = 'public, max-age=31536000'; // 1 year
+    // Add new property to store visible vectors
+    visibleVectors = new Set();
+    static initialPreloadComplete = false;
+    static preloadPromise = null;
+    completeVectorList = [];
+    // Add new property to track initialization
+    static isInitialized = false;
+    static initialVectorNumber = 8; // 8 - how many vectors to load initially
+    // Add a static property to track initialization state
+    static initializationPromise = null;
+    // Add this property
+    remainingTime = 0;
+    // Add a Map to store pre-initialized observers
+    preInitializedObservers = new Map();
+    // Add batch size constant
+    static BATCH_SIZE = 100;
+    currentBatchIndex = VectorManager.initialVectorNumber; // Start after initial vectors
+    // Add a map to track batch indices per controller
+    batchIndices = new Map();
+    // Add a map to store preloaded vectors per category
+    categoryVectors = new Map();
+    // Add to existing properties
+    customVectors = new Map();
+    /**
+     * Private constructor to enforce singleton pattern
+     */
+    constructor() {
+        // console.log('🏗️ [VectorManager] Creating VectorManager instance...');
+    }
+    /**
+     * Gets or creates the singleton instance and initializes it
+     */
+    static async getInstance() {
+        if (!VectorManager.instance) {
+            VectorManager.instance = new VectorManager();
+            // Initialize only once
+            if (!VectorManager.initializationPromise) {
+                VectorManager.initializationPromise = VectorManager.instance.initialize();
+            }
+            // Wait for initialization to complete
+            await VectorManager.initializationPromise;
+        }
+        return VectorManager.instance;
+    }
+    /**
+     * Initializes the VectorManager with initial vectors and setup
+     */
+    async initialize() {
+        if (VectorManager.isInitialized) {
+            // console.log('✅ [VectorManager] Already initialized');
+            return;
+        }
+        try {
+            // console.log('🚀 [VectorManager] Starting initialization...');
+            // Load custom vectors first, before any other operations
+            const customVectors = await this.loadCustomVectors();
+            // console.log('✅ [VectorManager] Loaded custom vectors:', customVectors.length);
+            // First check browser's cached vectors
+            const cachedVectors = await this.getBrowserCachedVectors();
+            // console.log('📦 [VectorManager] Browser cached vectors:', {
+            //   total: cachedVectors.length,
+            //   vectors: cachedVectors
+            // });
+            // Add cached vectors to loadedVectors set
+            cachedVectors.forEach(vector => this.loadedVectors.add(vector));
+            // Save to localStorage for persistence
+            this.saveLoadedVectors();
+            // Get recent vectors first
+            const recentVectors = vectorUtils.getRecentVectors()
+                .map(vector => ({
+                name: vector.name,
+                category: vectorCategories.normalize(vector.category),
+                url: vector.url
+            }));
+            // Get initial vector list and cache it
+            const initialVectorList = await this.getInitialVectorList();
+            // console.log('📋 [VectorManager] Initial vector list loaded:', initialVectorList.length);
+            // Cache the complete vector list immediately
+            try {
+                // Load vectors from svgs.json instead of API
+                const response = await fetch('/svgs.json');
+                if (!response.ok)
+                    throw new Error('Failed to fetch vectors');
+                const data = await response.json();
+                // Convert to VectorData format and cache
+                this.cachedVectorList = data.svgGroups.flatMap((group) => group.items.map((item) => ({
+                    name: item.name,
+                    category: vectorCategories.normalize(group.category),
+                    url: item.url
+                })));
+                // Preload initial vectors for each category
+                const categories = ['Icons', 'Emojis', 'Clipart', 'Mine'];
+                // Preload vectors for each category
+                await Promise.all(categories.map(async (category) => {
+                    const categoryVectors = this.cachedVectorList
+                        .filter(vector => vectorCategories.normalize(vector.category) === category)
+                        .slice(0, VectorManager.initialVectorNumber);
+                    this.categoryVectors.set(category, categoryVectors);
+                    // Preload the vectors
+                    await Promise.all(categoryVectors.map(async (vector) => {
+                        try {
+                            await this.loadVector(vector.name);
+                        }
+                        catch (error) {
+                            console.warn(`⚠️ [VectorManager] Failed to preload vector: ${vector.name}`, error);
+                        }
+                    }));
+                    // console.log(`📚 [VectorManager] Preloaded vectors for ${category}:`, {
+                    //   total: categoryVectors.length,
+                    //   sample: categoryVectors.slice(0, 3).map(v => v.name)
+                    // });
+                }));
+                // Save filtered list to localStorage cache
+                this.saveVectorListToCache(this.cachedVectorList);
+                this.allVectorsLoaded = true;
+                // console.log('📚 [VectorManager] Complete vector list cached:', {
+                //   total: this.cachedVectorList.length,
+                //   categoriesPreloaded: Array.from(this.categoryVectors.keys())
+                // });
+            }
+            catch (error) {
+                console.error('❌ [VectorManager] Error caching complete vector list:', error);
+            }
+            // Only set initialized after everything is complete
+            VectorManager.isInitialized = true;
+            this.initialVectorsLoaded = true;
+            // console.log('✅ [VectorManager] Initialization complete. Vector status:', {
+            //   totalLoaded: this.loadedVectors.size,
+            //   loadedVectors: Array.from(this.loadedVectors),
+            //   cachedVectors: this.cachedVectorList.length
+            // });
+            // Pre-initialize observers for vector controllers
+            this.preInitializeObservers();
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Pre-initializes observers during VectorManager initialization
+     */
+    preInitializeObservers() {
+        // Create a default observer configuration
+        const observerConfig = {
+            root: null,
+            rootMargin: '50px',
+            threshold: 0
+        };
+        // Create and store the observer
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach(entry => {
+                const vectorName = entry.target.getAttribute('data-vector');
+                if (vectorName) {
+                    if (entry.isIntersecting) {
+                        this.addVisibleVector(vectorName);
+                        if (!this.isScrolling()) {
+                            this.loadInitialVisibleVectors();
+                        }
+                    }
+                    else {
+                        this.removeVisibleVector(vectorName);
+                    }
+                }
+            });
+        }, observerConfig);
+        // Store it with a default key
+        this.preInitializedObservers.set('default', observer);
+    }
+    /**
+     * Loads custom vectors from custom-svgs.json
+     */
+    async loadCustomVectors() {
+        try {
+            const response = await fetch('/custom-svgs.json');
+            if (!response.ok) {
+                console.error('❌ [VectorManager] Failed to load custom-svgs.json');
+                return [];
+            }
+            const vectorsData = await response.json();
+            const customVectors = [];
+            // Process each SVG group
+            for (const group of vectorsData.svgGroups) {
+                if (group.category === 'Mine') {
+                    for (const item of group.items) {
+                        const vectorData = {
+                            name: item.name,
+                            category: 'Mine',
+                            url: item.url,
+                            isCustom: true
+                        };
+                        this.customVectors.set(item.name, vectorData);
+                        customVectors.push(vectorData);
+                        this.loadedVectors.add(item.name);
+                    }
+                }
+            }
+            return customVectors;
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error loading custom vectors:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets list of vectors cached in browser
+     */
+    async getBrowserCachedVectors() {
+        try {
+            const cachedVectorsList = localStorage.getItem(VectorManager.LOADED_VECTORS_KEY);
+            const cachedVectors = cachedVectorsList ? JSON.parse(cachedVectorsList) : [];
+            // console.log('📦 [VectorManager] Vectors in localStorage:', cachedVectors);
+            // Verify each vector exists in the DOM/cache
+            const verifiedVectors = await Promise.all(cachedVectors.map(async (name) => {
+                const status = await this.verifyVectorCache(name);
+                return { name, status };
+            }));
+            // Filter to only include vectors that are properly cached
+            const validCachedVectors = verifiedVectors
+                .filter(({ status }) => status.cached)
+                .map(({ name }) => name);
+            // console.log('✅ [VectorManager] Valid cached vectors:', {
+            //   total: validCachedVectors.length,
+            //   vectors: validCachedVectors
+            // });
+            return validCachedVectors;
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error getting browser cached vectors:', error);
+            return [];
+        }
+    }
+    /**
+     * Saves the current state of loaded vectors to localStorage
+     */
+    saveLoadedVectors() {
+        try {
+            const vectorsToCache = Array.from(this.loadedVectors);
+            localStorage.setItem(VectorManager.LOADED_VECTORS_KEY, JSON.stringify(vectorsToCache));
+            // Verify the save operation
+            const savedData = localStorage.getItem(VectorManager.LOADED_VECTORS_KEY);
+            // console.log('💾 [VectorManager] Vector cache status:', {
+            //   savedVectors: vectorsToCache,
+            //   verifiedCache: savedData ? JSON.parse(savedData) : null,
+            //   cacheSize: savedData?.length || 0
+            // });
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error saving loaded vectors:', error);
+        }
+    }
+    /**
+     * Gets initial vector list (initial number of vectors + recent vectors)
+     */
+    async getInitialVectorList() {
+        try {
+            if (this.initialVectorsLoaded) {
+                return this.cachedVectorList;
+            }
+            // Load recent vectors first
+            const recentVectors = vectorUtils.getRecentVectors()
+                .map(vector => ({
+                name: vector.name,
+                category: vectorCategories.normalize(vector.category),
+                url: vector.url,
+                isCustom: vector.isCustom
+            }));
+            // Add custom vectors from custom-svgs.json
+            const customVectors = await this.loadCustomVectors();
+            // Load vectors from svgs.json
+            const response = await fetch('/svgs.json');
+            if (!response.ok)
+                throw new Error('Failed to fetch vectors');
+            const data = await response.json();
+            // Process and combine vectors
+            const standardVectors = data.svgGroups.flatMap((group) => group.items.map((item) => ({
+                name: item.name,
+                category: vectorCategories.normalize(group.category),
+                url: item.url,
+                isCustom: false
+            })));
+            // Combine all vectors
+            this.cachedVectorList = [
+                ...recentVectors,
+                ...customVectors,
+                ...standardVectors.filter((vector) => !recentVectors.some((recent) => recent.name === vector.name) &&
+                    !customVectors.some((custom) => custom.name === vector.name))
+            ];
+            this.initialVectorsLoaded = true;
+            return this.cachedVectorList;
+        }
+        catch (error) {
+            console.error('Error getting initial vectors:', error);
+            return [];
+        }
+    }
+    /**
+     * Saves vector list to localStorage cache
+     */
+    saveVectorListToCache(vectors) {
+        try {
+            const cacheData = {
+                timestamp: Date.now(),
+                vectors: vectors
+            };
+            localStorage.setItem(VectorManager.CACHE_KEY, JSON.stringify(cacheData));
+            // console.log('💾 [VectorManager] Vector list cached:', {
+            //   vectors: vectors.length,
+            //   expires: new Date(cacheData.timestamp + VectorManager.CACHE_DURATION)
+            // });
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error caching vector list:', error);
+        }
+    }
+    /**
+     * Verifies if a vector is actually cached in the browser
+     */
+    async verifyVectorCache(name) {
+        const status = {
+            name,
+            cached: false,
+            url: '',
+            headers: {}
+        };
+        try {
+            // Check if vector is in localStorage
+            const cachedVectors = localStorage.getItem(VectorManager.LOADED_VECTORS_KEY);
+            const loadedVectors = cachedVectors ? JSON.parse(cachedVectors) : [];
+            const isCached = loadedVectors.includes(name);
+            // Find vector URL
+            const vector = this.cachedVectorList.find(v => v.name === name);
+            if (vector) {
+                status.url = vector.url;
+            }
+            status.cached = isCached && !!status.url;
+            return status;
+        }
+        catch (error) {
+            console.warn('⚠️ [VectorManager] Error verifying vector cache:', name, error);
+            return status;
+        }
+    }
+    /**
+     * Loads a vector by name
+     * Simpler than font loading since we just need to verify the URL exists
+     */
+    async loadVector(name) {
+        if (this.loadedVectors.has(name)) {
+            return;
+        }
+        try {
+            // Find vector in cache
+            const vector = this.cachedVectorList.find(v => v.name === name);
+            if (!vector) {
+                throw new Error(`Vector ${name} not found in cache`);
+            }
+            // Verify URL exists
+            const response = await fetch(vector.url, { method: 'HEAD' });
+            if (!response.ok) {
+                throw new Error(`Failed to verify vector URL: ${vector.url}`);
+            }
+            // Mark as loaded
+            this.loadedVectors.add(name);
+            this.saveLoadedVectors();
+            // console.log('✅ [VectorManager] Vector loaded successfully:', name);
+        }
+        catch (error) {
+            console.warn(`⚠️ [VectorManager] Error loading vector ${name}:`, error);
+            // Still mark as loaded to prevent retries
+            this.loadedVectors.add(name);
+            this.saveLoadedVectors();
+        }
+    }
+    /**
+     * Loads initial visible vectors
+     */
+    async loadInitialVisibleVectors() {
+        const visibleVectors = Array.from(this.visibleVectors);
+        // Get initial vectors list
+        const initialVectors = this.cachedVectorList.slice(0, VectorManager.initialVectorNumber);
+        const initialVectorNames = new Set(initialVectors.map(vector => vector.name));
+        // Filter visible vectors to only include those in the initial batch
+        const vectorsToLoad = visibleVectors.filter(name => initialVectorNames.has(name));
+        if (vectorsToLoad.length > 0) {
+            // console.log('🔄 [VectorManager] Loading initial visible vectors:', {
+            //   visible: visibleVectors.length,
+            //   toLoad: vectorsToLoad.length,
+            //   initialBatchSize: initialVectors.length
+            // });
+            const loadPromises = vectorsToLoad.map(async (name) => {
+                try {
+                    await this.loadVector(name);
+                }
+                catch (error) {
+                    console.warn(`⚠️ [VectorManager] Failed to load vector: ${name}`, error);
+                }
+            });
+            await Promise.all(loadPromises);
+        }
+    }
+    /**
+     * Handles scroll optimization for vector loading
+     * Implements debouncing to prevent excessive loading
+     * @param callback - Optional callback after vectors are loaded
+     */
+    handleScroll(callback) {
+        if (this.scrollTimeout) {
+            window.clearTimeout(this.scrollTimeout);
+            this.scrollTimeout = null;
+        }
+        this.remainingTime = VectorManager.WAIT_TIME;
+        this.scrollTimeout = window.setTimeout(async () => {
+            const visibleVectors = Array.from(this.visibleVectors);
+            // console.log('🔄 [VectorManager] Loading visible vectors:', {
+            //   total: visibleVectors.length,
+            //   vectors: visibleVectors
+            // });
+            try {
+                // Load all visible vectors in parallel
+                const loadPromises = visibleVectors.map(async (name) => {
+                    if (this.loadedVectors.has(name)) {
+                        const status = await this.verifyVectorCache(name);
+                        if (!status.cached) {
+                            // console.log('⚠️ [VectorManager] Reloading uncached vector:', name);
+                            return this.loadVector(name);
+                        }
+                        return Promise.resolve();
+                    }
+                    // console.log('📥 [VectorManager] Loading new vector:', name);
+                    return this.loadVector(name);
+                });
+                await Promise.all(loadPromises);
+                // Log final cache status
+                const finalStatus = await Promise.all(visibleVectors.map(async (name) => ({
+                    name,
+                    status: await this.verifyVectorCache(name)
+                })));
+                // console.log('✅ [VectorManager] Vector loading complete:', {
+                //   total: finalStatus.length,
+                //   vectors: finalStatus.map(({ name, status }) => ({
+                //     name,
+                //     cached: status.cached,
+                //     url: status.url
+                //   }))
+                // });
+            }
+            catch (error) {
+                console.error('❌ [VectorManager] Error loading vectors:', error);
+            }
+            this.visibleVectors.clear();
+            this.scrollTimeout = null;
+            if (callback)
+                callback();
+        }, VectorManager.WAIT_TIME);
+    }
+    /**
+     * Checks if scrolling is currently active
+     */
+    isScrolling() {
+        return this.scrollTimeout !== null;
+    }
+    /**
+     * Adds a vector to the visible set
+     */
+    addVisibleVector(name) {
+        if (!this.visibleVectors.has(name)) {
+            this.visibleVectors.add(name);
+        }
+    }
+    /**
+     * Removes a vector from the visible set
+     */
+    removeVisibleVector(name) {
+        if (this.visibleVectors.has(name)) {
+            this.visibleVectors.delete(name);
+        }
+    }
+    /**
+     * Gets the cached vector list without making an API call
+     */
+    getCachedVectorList() {
+        return this.cachedVectorList;
+    }
+    /**
+     * Gets the next batch of vectors
+     */
+    getNextBatch(controllerId, category) {
+        // Get or initialize batch index for this controller
+        let currentIndex = this.batchIndices.get(controllerId) || VectorManager.initialVectorNumber;
+        // Filter vectors by category first
+        const categoryVectors = category === 'All'
+            ? this.cachedVectorList
+            : category === 'Mine'
+                ? Array.from(this.customVectors.values())
+                : this.cachedVectorList.filter(vector => vectorCategories.normalize(vector.category) === category);
+        const start = currentIndex;
+        const end = start + VectorManager.BATCH_SIZE;
+        // Get next batch from category-filtered list
+        const batch = categoryVectors.slice(start, end);
+        // Only update index if we actually got more vectors
+        if (batch.length > 0) {
+            this.batchIndices.set(controllerId, end);
+        }
+        // console.log('📦 [VectorManager] Loading next batch:', {
+        //   controllerId,
+        //   category,
+        //   start,
+        //   end,
+        //   batchSize: batch.length,
+        //   totalInCategory: categoryVectors.length,
+        //   remainingVectors: categoryVectors.length - end
+        // });
+        return batch;
+    }
+    /**
+     * Checks if there are more vectors to load
+     */
+    hasMoreVectors(controllerId, category) {
+        const currentIndex = this.batchIndices.get(controllerId) || VectorManager.initialVectorNumber;
+        // Filter vectors by category first
+        const categoryVectors = category === 'All'
+            ? this.cachedVectorList
+            : category === 'Mine'
+                ? Array.from(this.customVectors.values())
+                : this.cachedVectorList.filter(vector => vectorCategories.normalize(vector.category) === category);
+        const remainingItems = categoryVectors.length - currentIndex;
+        // console.log('🔍 [VectorManager] Checking remaining vectors:', {
+        //   category,
+        //   currentIndex,
+        //   totalInCategory: categoryVectors.length,
+        //   remainingItems
+        // });
+        // Only return true if we have more items in this category
+        return remainingItems > 0;
+    }
+    /**
+     * Resets the batch index to initial number
+     * This allows each vector input controller to start from the beginning
+     */
+    resetBatchIndex(controllerId) {
+        this.batchIndices.set(controllerId, VectorManager.initialVectorNumber);
+        // console.log('🔄 [VectorManager] Reset batch index for:', controllerId);
+    }
+    /**
+     * Gets preloaded vectors for a category
+     */
+    getPreloadedVectors(category) {
+        if (category === 'Mine') {
+            return Array.from(this.customVectors.values());
+        }
+        const preloadedVectors = this.categoryVectors.get(category) || [];
+        // Ensure vectors are loaded
+        preloadedVectors.forEach(vector => {
+            if (!this.loadedVectors.has(vector.name)) {
+                this.loadVector(vector.name)
+                    .catch(error => console.warn(`⚠️ [VectorManager] Failed to load vector: ${vector.name}`, error));
+            }
+        });
+        return preloadedVectors;
+    }
+    /**
+     * Gets the complete list of vectors
+     */
+    async getCompleteVectorList(force = false) {
+        try {
+            if (this.allVectorsLoaded && !force) {
+                return this.cachedVectorList;
+            }
+            if (!force) {
+                const cachedVectors = this.getVectorListFromCache();
+                if (cachedVectors) {
+                    this.cachedVectorList = cachedVectors;
+                    this.allVectorsLoaded = true;
+                    return cachedVectors;
+                }
+            }
+            this.vectorListPromise = (async () => {
+                const response = await fetch('/svgs.json');
+                if (!response.ok)
+                    throw new Error('Failed to fetch vectors');
+                const data = await response.json();
+                const allVectors = data.svgGroups.flatMap((group) => group.items.map((item) => ({
+                    name: item.name,
+                    category: vectorCategories.normalize(group.category),
+                    url: item.url,
+                    isCustom: false
+                })));
+                this.cachedVectorList = allVectors;
+                this.allVectorsLoaded = true;
+                this.saveVectorListToCache(allVectors);
+                // console.log('✅ [VectorManager] Complete vector list loaded:', {
+                //   total: allVectors.length,
+                //   format: 'SVG'
+                // });
+                return allVectors;
+            })();
+            return this.vectorListPromise;
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error getting complete vector list:', error);
+            return this.cachedVectorList;
+        }
+    }
+    /**
+     * Checks if a vector is a custom vector
+     */
+    isCustomVector(name) {
+        return this.customVectors.has(name);
+    }
+    /**
+     * Gets custom vector data if available
+     */
+    getCustomVector(name) {
+        return this.customVectors.get(name);
+    }
+    /**
+     * Removes a custom vector
+     */
+    async removeCustomVector(name) {
+        try {
+            if (this.customVectors.has(name)) {
+                this.customVectors.delete(name);
+                this.loadedVectors.delete(name);
+                // Update cached vector list
+                this.cachedVectorList = this.cachedVectorList.filter(vector => vector.name !== name || vector.category !== 'Mine');
+                // console.log('✅ [VectorManager] Custom vector removed:', name);
+            }
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error removing custom vector:', error);
+        }
+    }
+    /**
+     * Gets observer for a container
+     */
+    getObserver(container) {
+        if (!container) {
+            console.warn('❌ [VectorManager] No container provided for observer');
+            return null;
+        }
+        // Generate or retrieve unique ID for container
+        const key = container.dataset.observerId || `vector-observer-${Math.random().toString(36).slice(2)}`;
+        container.dataset.observerId = key;
+        // Return existing observer if one exists
+        if (this.observers.has(key)) {
+            return this.observers.get(key) || null;
+        }
+        // Create new observer
+        console.log('🔧 [VectorManager] Creating new observer for container:', key);
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach(entry => {
+                const vectorName = entry.target.getAttribute('data-vector');
+                if (vectorName) {
+                    if (entry.isIntersecting) {
+                        this.addVisibleVector(vectorName);
+                        if (!this.isScrolling()) {
+                            this.loadInitialVisibleVectors();
+                        }
+                    }
+                    else {
+                        this.removeVisibleVector(vectorName);
+                    }
+                }
+            });
+        }, {
+            root: container,
+            rootMargin: '50px' // Pre-load vectors slightly before they come into view
+        });
+        this.observers.set(key, observer);
+        return observer;
+    }
+    /**
+     * Gets a pre-initialized observer
+     */
+    getPreInitializedObserver() {
+        return this.preInitializedObservers.get('default') || null;
+    }
+    /**
+     * Gets stats about loaded vectors
+     */
+    getLoadedVectorsStats() {
+        return {
+            total: this.loadedVectors.size,
+            vectors: Array.from(this.loadedVectors)
+        };
+    }
+    /**
+     * Cleans up resources when a vector container is removed
+     * Prevents memory leaks from orphaned observers
+     */
+    cleanup(containerId) {
+        const observer = this.observers.get(containerId);
+        if (observer) {
+            observer.disconnect();
+            this.observers.delete(containerId);
+        }
+    }
+    /**
+     * Checks if a vector is already loaded
+     */
+    isVectorLoaded(name) {
+        return this.loadedVectors.has(name);
+    }
+    /**
+     * Gets the vector list from cache without making an API call
+     * Returns null if cache is invalid or expired
+     */
+    getVectorListFromCache() {
+        try {
+            const cached = localStorage.getItem(VectorManager.CACHE_KEY);
+            if (!cached)
+                return null;
+            const cache = JSON.parse(cached);
+            const now = Date.now();
+            // Check if cache has expired
+            if (now - cache.timestamp > VectorManager.CACHE_DURATION) {
+                console.log('📅 [VectorManager] Cache expired, will refresh');
+                return null;
+            }
+            return cache.vectors;
+        }
+        catch (error) {
+            console.error('❌ [VectorManager] Error reading vector cache:', error);
+            return null;
+        }
+    }
+}
+export default VectorManager;