@midscene/visualizer 0.30.10 → 1.0.0

package/dist/lib/component/universal-playground/providers/storage-provider.js

@@ -24,17 +24,43 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    IndexedDBStorageProvider: ()=>external_indexeddb_storage_provider_js_namespaceObject.IndexedDBStorageProvider,
-    StorageType: ()=>storage_provider_StorageType,
-    detectBestStorageType: ()=>detectBestStorageType,
+    NoOpStorageProvider: ()=>NoOpStorageProvider,
+    LocalStorageProvider: ()=>LocalStorageProvider,
     IndexedDBMemoryStorageProvider: ()=>external_indexeddb_storage_provider_js_namespaceObject.MemoryStorageProvider,
+    IndexedDBStorageProvider: ()=>external_indexeddb_storage_provider_js_namespaceObject.IndexedDBStorageProvider,
     IndexedDBNoOpStorageProvider: ()=>external_indexeddb_storage_provider_js_namespaceObject.NoOpStorageProvider,
-    LocalStorageProvider: ()=>LocalStorageProvider,
-    NoOpStorageProvider: ()=>NoOpStorageProvider,
+    MemoryStorageProvider: ()=>MemoryStorageProvider,
+    StorageType: ()=>storage_provider_StorageType,
     createStorageProvider: ()=>createStorageProvider,
-    MemoryStorageProvider: ()=>MemoryStorageProvider
+    detectBestStorageType: ()=>detectBestStorageType
 });
 const external_indexeddb_storage_provider_js_namespaceObject = require("./indexeddb-storage-provider.js");
+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,
@@ -45,6 +71,38 @@ function _define_property(obj, key, value) {
     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 {
@@ -57,114 +115,119 @@ class LocalStorageProvider {
             return false;
         }
     }
-    async saveMessages(messages) {
-        try {
-            if (!this.checkStorageSpace()) {
-                console.warn('Low storage space detected, clearing old data...');
-                await this.handleQuotaExceeded();
-            }
-            const messagesToSave = messages.slice(-this.maxStorageItems);
-            const lightMessages = messagesToSave.map((msg)=>({
-                    ...msg,
-                    result: void 0
-                }));
-            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...');
-                await this.handleQuotaExceeded();
-                try {
-                    const recentMessages = messages.slice(-10);
-                    const lightRecentMessages = recentMessages.map((msg)=>({
-                            ...msg,
-                            result: void 0
-                        }));
-                    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);
-                    await this.clearMessages();
+    saveMessages(messages) {
+        return _async_to_generator(function*() {
+            try {
+                if (!this.checkStorageSpace()) {
+                    console.warn('Low storage space detected, clearing old data...');
+                    yield this.handleQuotaExceeded();
                 }
-            } else console.error('Failed to save messages to localStorage:', error);
-        }
-    }
-    async loadMessages() {
-        try {
-            const stored = localStorage.getItem(this.messagesKey);
-            if (!stored) return [];
-            const messages = JSON.parse(stored);
-            const restoredMessages = await Promise.all(messages.map(async (msg)=>{
-                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 {
-                            ...msg,
-                            ...resultItem
-                        };
-                    } catch (e) {
-                        console.warn('Failed to parse stored result:', e);
+                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();
                     }
-                }
-                return msg;
-            }));
-            return restoredMessages;
-        } catch (error) {
-            console.error('Failed to load messages from localStorage:', error);
-            return [];
-        }
+                } else console.error('Failed to save messages to localStorage:', error);
+            }
+        }).call(this);
     }
-    async clearMessages() {
-        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);
-        }
+    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);
     }
-    async saveResult(id, result) {
-        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...');
-                await 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);
-        }
+    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);
     }
-    async handleQuotaExceeded() {
-        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);
+    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 ${additionalKeysToRemove.length} additional playground-related entries`);
+                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);
             }
-        } catch (error) {
-            console.error('Failed to handle quota exceeded:', error);
-        }
+        }).call(this);
     }
     constructor(namespace = 'playground'){
         _define_property(this, "messagesKey", void 0);
@@ -175,22 +238,30 @@ class LocalStorageProvider {
     }
 }
 class MemoryStorageProvider {
-    async saveMessages(messages) {
-        this.messages = [
-            ...messages
-        ];
+    saveMessages(messages) {
+        return _async_to_generator(function*() {
+            this.messages = [
+                ...messages
+            ];
+        }).call(this);
     }
-    async loadMessages() {
-        return [
-            ...this.messages
-        ];
+    loadMessages() {
+        return _async_to_generator(function*() {
+            return [
+                ...this.messages
+            ];
+        }).call(this);
     }
-    async clearMessages() {
-        this.messages = [];
-        this.results.clear();
+    clearMessages() {
+        return _async_to_generator(function*() {
+            this.messages = [];
+            this.results.clear();
+        }).call(this);
     }
-    async saveResult(id, result) {
-        this.results.set(id, result);
+    saveResult(id, result) {
+        return _async_to_generator(function*() {
+            this.results.set(id, result);
+        }).call(this);
     }
     constructor(){
         _define_property(this, "messages", []);
@@ -198,12 +269,20 @@ class MemoryStorageProvider {
     }
 }
 class NoOpStorageProvider {
-    async saveMessages(_messages) {}
-    async loadMessages() {
-        return [];
+    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*() {})();
     }
-    async clearMessages() {}
-    async saveResult(_id, _result) {}
 }
 var storage_provider_StorageType = /*#__PURE__*/ function(StorageType) {
     StorageType["INDEXEDDB"] = "indexeddb";
@@ -212,8 +291,7 @@ var storage_provider_StorageType = /*#__PURE__*/ function(StorageType) {
     StorageType["NONE"] = "none";
     return StorageType;
 }({});
-function createStorageProvider() {
-    let type = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : "indexeddb", namespace = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 'playground';
+function createStorageProvider(type = "indexeddb", namespace = 'playground') {
     switch(type){
         case "indexeddb":
             if ('undefined' != typeof indexedDB) return new external_indexeddb_storage_provider_js_namespaceObject.IndexedDBStorageProvider(namespace);
@@ -252,7 +330,7 @@ exports.NoOpStorageProvider = __webpack_exports__.NoOpStorageProvider;
 exports.StorageType = __webpack_exports__.StorageType;
 exports.createStorageProvider = __webpack_exports__.createStorageProvider;
 exports.detectBestStorageType = __webpack_exports__.detectBestStorageType;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "IndexedDBMemoryStorageProvider",
     "IndexedDBNoOpStorageProvider",
     "IndexedDBStorageProvider",
@@ -262,7 +340,7 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "StorageType",
     "createStorageProvider",
     "detectBestStorageType"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });