@godscene/visualizer 1.7.11

package/dist/es/component/universal-playground/providers/indexeddb-storage-provider.mjs

@@ -0,0 +1,280 @@
+import { IndexedDBManager, createCleanupFunction, withErrorHandling } from "@godscene/shared/baseDB";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function indexeddb_storage_provider_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else indexeddb_storage_provider_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+const DB_NAME = 'midscene_playground';
+const DB_VERSION = 1;
+const MESSAGES_STORE = 'playground_messages';
+const RESULTS_STORE = 'playground_results';
+const MAX_STORED_MESSAGES = 100;
+const MAX_STORED_RESULTS = 50;
+class IndexedDBStorageProvider {
+    saveMessages(messages) {
+        return _async_to_generator(function*() {
+            yield withErrorHandling(()=>_async_to_generator(function*() {
+                    yield this.dbManager.clear(MESSAGES_STORE);
+                    const messagesToSave = messages.slice(-MAX_STORED_MESSAGES);
+                    yield Promise.all(messagesToSave.map((msg, index)=>{
+                        const lightMessage = _object_spread_props(_object_spread({}, msg), {
+                            result: 'result' === msg.type ? void 0 : msg.result
+                        });
+                        const data = {
+                            id: msg.id || `msg-${index}`,
+                            data: lightMessage,
+                            timestamp: msg.timestamp ? msg.timestamp.getTime() : Date.now() + index
+                        };
+                        return this.dbManager.put(MESSAGES_STORE, data);
+                    }));
+                }).call(this), 'Failed to save messages to IndexedDB', void 0, this.messagesCleanup);
+        }).call(this);
+    }
+    loadMessages() {
+        return _async_to_generator(function*() {
+            const result = yield withErrorHandling(()=>_async_to_generator(function*() {
+                    const messages = yield this.dbManager.getAll(MESSAGES_STORE, true);
+                    if (0 === messages.length) return [];
+                    return Promise.all(messages.map((msg)=>_async_to_generator(function*() {
+                            const item = msg.data;
+                            const restoredItem = _object_spread_props(_object_spread({}, item), {
+                                timestamp: new Date(item.timestamp)
+                            });
+                            if ('result' === item.type && item.id) {
+                                const fullResult = yield this.loadResult(item.id);
+                                if (fullResult) {
+                                    restoredItem.result = fullResult.result;
+                                    restoredItem.replayScriptsInfo = fullResult.replayScriptsInfo;
+                                    restoredItem.replayCounter = fullResult.replayCounter;
+                                    restoredItem.verticalMode = fullResult.verticalMode;
+                                }
+                            }
+                            return restoredItem;
+                        }).call(this)));
+                }).call(this), 'Failed to load messages from IndexedDB', [], this.messagesCleanup);
+            return result || [];
+        }).call(this);
+    }
+    clearMessages() {
+        return _async_to_generator(function*() {
+            yield withErrorHandling(()=>_async_to_generator(function*() {
+                    yield Promise.all([
+                        this.dbManager.clear(MESSAGES_STORE),
+                        this.dbManager.clear(RESULTS_STORE)
+                    ]);
+                }).call(this), 'Failed to clear messages from IndexedDB');
+        }).call(this);
+    }
+    saveResult(id, result) {
+        return _async_to_generator(function*() {
+            yield withErrorHandling(()=>_async_to_generator(function*() {
+                    const compressedResult = this.compressResultForStorage(result);
+                    const data = {
+                        id,
+                        data: compressedResult,
+                        timestamp: Date.now(),
+                        size: JSON.stringify(compressedResult).length
+                    };
+                    yield this.dbManager.put(RESULTS_STORE, data);
+                }).call(this), 'Failed to save result to IndexedDB', void 0, this.resultsCleanup);
+        }).call(this);
+    }
+    loadResult(id) {
+        return _async_to_generator(function*() {
+            const result = yield withErrorHandling(()=>_async_to_generator(function*() {
+                    const data = yield this.dbManager.get(RESULTS_STORE, id);
+                    return (null == data ? void 0 : data.data) || null;
+                }).call(this), 'Failed to load result from IndexedDB', null);
+            return result || null;
+        }).call(this);
+    }
+    compressResultForStorage(result) {
+        var _result_result_dump, _result_result;
+        if (!(null == (_result_result = result.result) ? void 0 : null == (_result_result_dump = _result_result.dump) ? void 0 : _result_result_dump.tasks)) return result;
+        const compressedTasks = result.result.dump.tasks.map((task)=>{
+            var _task_recorder;
+            return _object_spread_props(_object_spread({}, task), {
+                uiContext: task.uiContext ? _object_spread_props(_object_spread({}, task.uiContext), {
+                    screenshot: task.uiContext.screenshot
+                }) : task.uiContext,
+                recorder: null == (_task_recorder = task.recorder) ? void 0 : _task_recorder.map((record)=>_object_spread_props(_object_spread({}, record), {
+                        screenshot: record.screenshot
+                    }))
+            });
+        });
+        return _object_spread_props(_object_spread({}, result), {
+            result: _object_spread_props(_object_spread({}, result.result), {
+                dump: _object_spread_props(_object_spread({}, result.result.dump), {
+                    tasks: compressedTasks
+                })
+            })
+        });
+    }
+    compressScreenshotIfNeeded(screenshot) {
+        if (!screenshot) return screenshot;
+        if (screenshot.length > 1048576) {
+            const sizeKB = Math.round(screenshot.length / 1024);
+            return `[COMPRESSED: ${sizeKB}KB screenshot removed for storage]`;
+        }
+        return screenshot;
+    }
+    getStorageStats() {
+        return _async_to_generator(function*() {
+            const result = yield withErrorHandling(()=>_async_to_generator(function*() {
+                    const [messageCount, resultCount] = yield Promise.all([
+                        this.dbManager.count(MESSAGES_STORE),
+                        this.dbManager.count(RESULTS_STORE)
+                    ]);
+                    return {
+                        messageCount,
+                        resultCount
+                    };
+                }).call(this), 'Failed to get storage statistics', {
+                messageCount: 0,
+                resultCount: 0
+            });
+            return result || {
+                messageCount: 0,
+                resultCount: 0
+            };
+        }).call(this);
+    }
+    cleanup() {
+        return _async_to_generator(function*() {
+            yield Promise.all([
+                this.messagesCleanup(),
+                this.resultsCleanup()
+            ]);
+        }).call(this);
+    }
+    constructor(namespace = 'playground'){
+        _define_property(this, "dbManager", void 0);
+        _define_property(this, "namespace", void 0);
+        _define_property(this, "messagesCleanup", void 0);
+        _define_property(this, "resultsCleanup", void 0);
+        this.namespace = namespace;
+        this.dbManager = new IndexedDBManager(`${DB_NAME}_${namespace}`, DB_VERSION, [
+            {
+                name: MESSAGES_STORE,
+                keyPath: 'id'
+            },
+            {
+                name: RESULTS_STORE,
+                keyPath: 'id'
+            }
+        ]);
+        this.messagesCleanup = createCleanupFunction(this.dbManager, MESSAGES_STORE, MAX_STORED_MESSAGES);
+        this.resultsCleanup = createCleanupFunction(this.dbManager, RESULTS_STORE, MAX_STORED_RESULTS);
+    }
+}
+class MemoryStorageProvider {
+    saveMessages(messages) {
+        return _async_to_generator(function*() {
+            this.messages = [
+                ...messages
+            ];
+        }).call(this);
+    }
+    loadMessages() {
+        return _async_to_generator(function*() {
+            return [
+                ...this.messages
+            ];
+        }).call(this);
+    }
+    clearMessages() {
+        return _async_to_generator(function*() {
+            this.messages = [];
+            this.results.clear();
+        }).call(this);
+    }
+    saveResult(id, result) {
+        return _async_to_generator(function*() {
+            this.results.set(id, result);
+        }).call(this);
+    }
+    constructor(){
+        _define_property(this, "messages", []);
+        _define_property(this, "results", new Map());
+    }
+}
+class NoOpStorageProvider {
+    saveMessages(_messages) {
+        return _async_to_generator(function*() {})();
+    }
+    loadMessages() {
+        return _async_to_generator(function*() {
+            return [];
+        })();
+    }
+    clearMessages() {
+        return _async_to_generator(function*() {})();
+    }
+    saveResult(_id, _result) {
+        return _async_to_generator(function*() {})();
+    }
+}
+export { IndexedDBStorageProvider, MemoryStorageProvider, NoOpStorageProvider };

package/dist/es/component/universal-playground/providers/storage-provider.mjs

@@ -0,0 +1,279 @@
+import { IndexedDBStorageProvider, MemoryStorageProvider, NoOpStorageProvider } from "./indexeddb-storage-provider.mjs";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function storage_provider_ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = null != source ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else storage_provider_ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+    return target;
+}
+class LocalStorageProvider {
+    checkStorageSpace() {
+        try {
+            const testKey = 'storage-test';
+            const testData = 'x'.repeat(102400);
+            localStorage.setItem(testKey, testData);
+            localStorage.removeItem(testKey);
+            return true;
+        } catch (unused) {
+            return false;
+        }
+    }
+    saveMessages(messages) {
+        return _async_to_generator(function*() {
+            try {
+                if (!this.checkStorageSpace()) {
+                    console.warn('Low storage space detected, clearing old data...');
+                    yield this.handleQuotaExceeded();
+                }
+                const messagesToSave = messages.slice(-this.maxStorageItems);
+                const lightMessages = messagesToSave.map((msg)=>_object_spread_props(_object_spread({}, msg), {
+                        result: 'result' === msg.type ? void 0 : msg.result
+                    }));
+                const messageData = JSON.stringify(lightMessages);
+                localStorage.setItem(this.messagesKey, messageData);
+            } catch (error) {
+                if (error instanceof DOMException && 'QuotaExceededError' === error.name) {
+                    console.warn('LocalStorage quota exceeded, attempting to clear old data and retry...');
+                    yield this.handleQuotaExceeded();
+                    try {
+                        const recentMessages = messages.slice(-10);
+                        const lightRecentMessages = recentMessages.map((msg)=>_object_spread_props(_object_spread({}, msg), {
+                                result: 'result' === msg.type ? void 0 : msg.result
+                            }));
+                        const messageData = JSON.stringify(lightRecentMessages);
+                        localStorage.setItem(this.messagesKey, messageData);
+                        console.info('Successfully saved recent messages after clearing storage');
+                    } catch (retryError) {
+                        console.error('Failed to save even after clearing storage:', retryError);
+                        yield this.clearMessages();
+                    }
+                } else console.error('Failed to save messages to localStorage:', error);
+            }
+        }).call(this);
+    }
+    loadMessages() {
+        return _async_to_generator(function*() {
+            try {
+                const stored = localStorage.getItem(this.messagesKey);
+                if (!stored) return [];
+                const messages = JSON.parse(stored);
+                const restoredMessages = yield Promise.all(messages.map((msg)=>_async_to_generator(function*() {
+                        if ('result' === msg.type && msg.id) {
+                            const resultKey = `${this.resultsKey}-${msg.id}`;
+                            const storedResult = localStorage.getItem(resultKey);
+                            if (storedResult) try {
+                                const resultItem = JSON.parse(storedResult);
+                                return _object_spread({}, msg, resultItem);
+                            } catch (e) {
+                                console.warn('Failed to parse stored result:', e);
+                            }
+                        }
+                        return msg;
+                    }).call(this)));
+                return restoredMessages;
+            } catch (error) {
+                console.error('Failed to load messages from localStorage:', error);
+                return [];
+            }
+        }).call(this);
+    }
+    clearMessages() {
+        return _async_to_generator(function*() {
+            try {
+                localStorage.removeItem(this.messagesKey);
+                const keys = Object.keys(localStorage);
+                keys.forEach((key)=>{
+                    if (key.startsWith(this.resultsKey)) localStorage.removeItem(key);
+                });
+            } catch (error) {
+                console.error('Failed to clear messages from localStorage:', error);
+            }
+        }).call(this);
+    }
+    saveResult(id, result) {
+        return _async_to_generator(function*() {
+            try {
+                const resultKey = `${this.resultsKey}-${id}`;
+                localStorage.setItem(resultKey, JSON.stringify(result));
+            } catch (error) {
+                if (error instanceof DOMException && 'QuotaExceededError' === error.name) {
+                    console.warn('LocalStorage quota exceeded when saving result, clearing old results...');
+                    yield this.handleQuotaExceeded();
+                    try {
+                        const resultKey = `${this.resultsKey}-${id}`;
+                        localStorage.setItem(resultKey, JSON.stringify(result));
+                    } catch (retryError) {
+                        console.error('Failed to save result even after clearing storage:', retryError);
+                    }
+                } else console.error('Failed to save result to localStorage:', error);
+            }
+        }).call(this);
+    }
+    handleQuotaExceeded() {
+        return _async_to_generator(function*() {
+            try {
+                const keys = Object.keys(localStorage);
+                const resultKeys = keys.filter((key)=>key.startsWith(this.resultsKey));
+                const keysToRemove = resultKeys.slice(0, Math.max(1, Math.floor(resultKeys.length / 2)));
+                keysToRemove.forEach((key)=>{
+                    localStorage.removeItem(key);
+                });
+                console.info(`Cleared ${keysToRemove.length} old result entries to free up storage space`);
+                const playgroundKeys = keys.filter((key)=>key.includes('playground') || key.includes('agent') || key.startsWith('midscene'));
+                if (playgroundKeys.length > 10) {
+                    const additionalKeysToRemove = playgroundKeys.slice(0, Math.floor(playgroundKeys.length / 3));
+                    additionalKeysToRemove.forEach((key)=>{
+                        if (key !== this.messagesKey) localStorage.removeItem(key);
+                    });
+                    console.info(`Cleared ${additionalKeysToRemove.length} additional playground-related entries`);
+                }
+            } catch (error) {
+                console.error('Failed to handle quota exceeded:', error);
+            }
+        }).call(this);
+    }
+    constructor(namespace = 'playground'){
+        _define_property(this, "messagesKey", void 0);
+        _define_property(this, "resultsKey", void 0);
+        _define_property(this, "maxStorageItems", 50);
+        this.messagesKey = `${namespace}-messages`;
+        this.resultsKey = `${namespace}-results`;
+    }
+}
+class storage_provider_MemoryStorageProvider {
+    saveMessages(messages) {
+        return _async_to_generator(function*() {
+            this.messages = [
+                ...messages
+            ];
+        }).call(this);
+    }
+    loadMessages() {
+        return _async_to_generator(function*() {
+            return [
+                ...this.messages
+            ];
+        }).call(this);
+    }
+    clearMessages() {
+        return _async_to_generator(function*() {
+            this.messages = [];
+            this.results.clear();
+        }).call(this);
+    }
+    saveResult(id, result) {
+        return _async_to_generator(function*() {
+            this.results.set(id, result);
+        }).call(this);
+    }
+    constructor(){
+        _define_property(this, "messages", []);
+        _define_property(this, "results", new Map());
+    }
+}
+class storage_provider_NoOpStorageProvider {
+    saveMessages(_messages) {
+        return _async_to_generator(function*() {})();
+    }
+    loadMessages() {
+        return _async_to_generator(function*() {
+            return [];
+        })();
+    }
+    clearMessages() {
+        return _async_to_generator(function*() {})();
+    }
+    saveResult(_id, _result) {
+        return _async_to_generator(function*() {})();
+    }
+}
+var storage_provider_StorageType = /*#__PURE__*/ function(StorageType) {
+    StorageType["INDEXEDDB"] = "indexeddb";
+    StorageType["LOCALSTORAGE"] = "localStorage";
+    StorageType["MEMORY"] = "memory";
+    StorageType["NONE"] = "none";
+    return StorageType;
+}({});
+function createStorageProvider(type = "indexeddb", namespace = 'playground') {
+    switch(type){
+        case "indexeddb":
+            if ("u" > typeof indexedDB) return new IndexedDBStorageProvider(namespace);
+            console.warn('IndexedDB not available, falling back to localStorage');
+            return createStorageProvider("localStorage", namespace);
+        case "localStorage":
+            if ("u" > typeof localStorage) return new LocalStorageProvider(namespace);
+            console.warn('localStorage not available, falling back to memory storage');
+            return createStorageProvider("memory", namespace);
+        case "memory":
+            return new storage_provider_MemoryStorageProvider();
+        case "none":
+            return new storage_provider_NoOpStorageProvider();
+        default:
+            throw new Error(`Unknown storage type: ${type}`);
+    }
+}
+function detectBestStorageType() {
+    return "memory";
+}
+export { MemoryStorageProvider as IndexedDBMemoryStorageProvider, NoOpStorageProvider as IndexedDBNoOpStorageProvider, IndexedDBStorageProvider, LocalStorageProvider, storage_provider_MemoryStorageProvider as MemoryStorageProvider, storage_provider_NoOpStorageProvider as NoOpStorageProvider, storage_provider_StorageType as StorageType, createStorageProvider, detectBestStorageType };