@rpascene/visualizer 0.30.11

package/dist/es/component/universal-playground/index.mjs

@@ -0,0 +1,403 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import icons, { ArrowDownOutlined, ClearOutlined, LoadingOutlined } from "@ant-design/icons";
+import { Button, Form, List, Tooltip, Typography, message } from "antd";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { usePlaygroundExecution } from "../../hooks/usePlaygroundExecution.mjs";
+import { usePlaygroundState } from "../../hooks/usePlaygroundState.mjs";
+import { useEnvConfig } from "../../store/store.mjs";
+import { ContextPreview } from "../context-preview/index.mjs";
+import { PlaygroundResultView } from "../playground-result/index.mjs";
+import avatar from "../../icons/avatar.mjs";
+import { PromptInput } from "../prompt-input/index.mjs";
+import { createStorageProvider, detectBestStorageType } from "./providers/storage-provider.mjs";
+import { overrideAIConfig } from "@rpascene/shared/env";
+import { commandMap } from "@rpascene/shared/constants";
+import "./index.css";
+const { Text } = Typography;
+function getSDKId(sdk) {
+    if (sdk.id && 'string' == typeof sdk.id) return `agent-${sdk.id}`;
+    return 'playground-default';
+}
+function ErrorMessage(param) {
+    let { error } = param;
+    if (!error) return null;
+    return /*#__PURE__*/ jsxs(Tooltip, {
+        title: /*#__PURE__*/ jsx("span", {
+            style: {
+                whiteSpace: 'pre-wrap',
+                wordBreak: 'break-all'
+            },
+            children: error
+        }),
+        overlayStyle: {
+            maxWidth: '100vw'
+        },
+        children: [
+            "Error: ",
+            error.split('\n')[0]
+        ]
+    });
+}
+function UniversalPlayground(param) {
+    let { playgroundSDK, storage, contextProvider, config: componentConfig = {}, branding = {}, className = '', dryMode = false, showContextPreview = true, showPromptInput = true, onHumanUse = ()=>{}, showHumanUse = false } = param;
+    const [form] = Form.useForm();
+    const { config } = useEnvConfig();
+    const [sdkReady, setSdkReady] = useState(false);
+    const ref = useRef(null);
+    useEffect(()=>{
+        const initializeSDK = async ()=>{
+            if (playgroundSDK && 'function' == typeof playgroundSDK.checkStatus) try {
+                await playgroundSDK.checkStatus();
+                setSdkReady(true);
+            } catch (error) {
+                console.warn('Failed to initialize SDK, using default namespace:', error);
+                setSdkReady(true);
+            }
+            else setSdkReady(true);
+        };
+        initializeSDK();
+    }, [
+        playgroundSDK
+    ]);
+    const effectiveStorage = useMemo(()=>{
+        if (storage) return storage;
+        if (!sdkReady) return null;
+        const namespace = componentConfig.storageNamespace || getSDKId(playgroundSDK);
+        const bestStorageType = detectBestStorageType();
+        console.log(`Using ${bestStorageType} storage for namespace: ${namespace}`);
+        return createStorageProvider(bestStorageType, namespace);
+    }, [
+        storage,
+        sdkReady,
+        componentConfig.storageNamespace,
+        playgroundSDK
+    ]);
+    const { loading, setLoading, infoList, setInfoList, actionSpace, actionSpaceLoading, uiContextPreview, setUiContextPreview, showScrollToBottomButton, verticalMode, replayCounter, setReplayCounter, infoListRef, currentRunningIdRef, interruptedFlagRef, clearInfoList, handleScrollToBottom } = usePlaygroundState(playgroundSDK, effectiveStorage, contextProvider);
+    const { handleRun: executeAction, handleStop, canStop } = usePlaygroundExecution(playgroundSDK, effectiveStorage, actionSpace, loading, setLoading, infoList, setInfoList, replayCounter, setReplayCounter, verticalMode, currentRunningIdRef, interruptedFlagRef, showHumanUse);
+    useEffect(()=>{
+        if ((null == playgroundSDK ? void 0 : playgroundSDK.overrideConfig) && config) playgroundSDK.overrideConfig(config).catch((error)=>{
+            console.error('Failed to override SDK config:', error);
+        });
+    }, [
+        playgroundSDK,
+        config
+    ]);
+    useEffect(()=>{
+        form.setFieldValue('type', 'aiTap');
+    }, [
+        form
+    ]);
+    const handleFormRun = useCallback(async ()=>{
+        try {
+            const value = form.getFieldsValue();
+            console.log(value, "\u8868\u5355\u7684\u503C");
+            await executeAction(value);
+        } catch (error) {
+            message.error((null == error ? void 0 : error.message) || 'Execution failed');
+        }
+    }, [
+        form,
+        executeAction,
+        ref
+    ]);
+    const configAlreadySet = Object.keys(config || {}).length >= 1;
+    const runButtonEnabled = componentConfig.serverMode || !dryMode && !actionSpaceLoading && configAlreadySet;
+    const selectedType = Form.useWatch('type', form);
+    const finalShowContextPreview = showContextPreview && false !== componentConfig.showContextPreview;
+    const layout = componentConfig.layout || 'vertical';
+    const showVersionInfo = false !== componentConfig.showVersionInfo;
+    useEffect(()=>{
+        try {
+            const handleMessage = (request, sender, sendResponse)=>{
+                if ('zhiyou_rpa_aitap' === request.action) (async ()=>{
+                    if (canStop) await handleStop();
+                    clearInfoList();
+                    overrideAIConfig(request.data.aiConfig);
+                    try {
+                        const result = await executeAction({
+                            type: 'aiTap',
+                            prompt: request.data.prompt,
+                            params: {
+                                locate: request.data.prompt
+                            }
+                        });
+                        sendResponse(result);
+                    } catch (error) {
+                        sendResponse({
+                            error
+                        });
+                    }
+                })();
+                return true;
+            };
+            chrome.runtime.onMessage.addListener(handleMessage);
+            return ()=>{
+                chrome.runtime.onMessage.removeListener(handleMessage);
+            };
+        } catch (error) {}
+    }, [
+        executeAction,
+        clearInfoList,
+        canStop,
+        handleStop
+    ]);
+    return /*#__PURE__*/ jsx("div", {
+        className: `playground-container ${layout}-mode ${className}`.trim(),
+        ref: ref,
+        children: /*#__PURE__*/ jsxs(Form, {
+            form: form,
+            onFinish: handleFormRun,
+            className: "command-form",
+            initialValues: {
+                type: 'aiTap'
+            },
+            children: [
+                finalShowContextPreview && /*#__PURE__*/ jsx("div", {
+                    className: "context-preview-section",
+                    children: /*#__PURE__*/ jsx(ContextPreview, {
+                        uiContextPreview: uiContextPreview,
+                        setUiContextPreview: setUiContextPreview,
+                        showContextPreview: finalShowContextPreview
+                    })
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: "middle-dialog-area",
+                    children: [
+                        infoList.length > 1 && /*#__PURE__*/ jsx("div", {
+                            className: "clear-button-container",
+                            children: /*#__PURE__*/ jsx(Button, {
+                                size: "small",
+                                icon: /*#__PURE__*/ jsx(ClearOutlined, {}),
+                                onClick: clearInfoList,
+                                type: "text",
+                                className: "clear-button"
+                            })
+                        }),
+                        /*#__PURE__*/ jsx("div", {
+                            ref: infoListRef,
+                            className: "info-list-container",
+                            children: /*#__PURE__*/ jsx(List, {
+                                itemLayout: "vertical",
+                                dataSource: infoList,
+                                renderItem: (item)=>{
+                                    var _item_result;
+                                    return /*#__PURE__*/ jsx(List.Item, {
+                                        className: "list-item",
+                                        children: 'user' === item.type ? /*#__PURE__*/ jsx("div", {
+                                            className: "user-message-container",
+                                            children: /*#__PURE__*/ jsx("div", {
+                                                className: "user-message-bubble",
+                                                children: item.content
+                                            })
+                                        }) : 'progress' === item.type ? /*#__PURE__*/ jsx("div", {
+                                            children: (()=>{
+                                                var _parts_, _item_result, _item_result1, _item_result2;
+                                                const parts = item.content.split(' - ');
+                                                const action = null == (_parts_ = parts[0]) ? void 0 : _parts_.trim();
+                                                const description = parts.slice(1).join(' - ').trim();
+                                                const currentIndex = infoList.findIndex((listItem)=>listItem.id === item.id);
+                                                const laterProgressExists = infoList.slice(currentIndex + 1).some((listItem)=>'progress' === listItem.type);
+                                                const isLatestProgress = !laterProgressExists;
+                                                const shouldShowLoading = loading && isLatestProgress;
+                                                return /*#__PURE__*/ jsxs(Fragment, {
+                                                    children: [
+                                                        action && /*#__PURE__*/ jsxs("span", {
+                                                            className: "progress-action-item",
+                                                            children: [
+                                                                action,
+                                                                /*#__PURE__*/ jsx("span", {
+                                                                    className: `progress-status-icon ${shouldShowLoading ? 'loading' : (null == (_item_result = item.result) ? void 0 : _item_result.error) ? 'error' : 'completed'}`,
+                                                                    children: shouldShowLoading ? /*#__PURE__*/ jsx(LoadingOutlined, {
+                                                                        spin: true
+                                                                    }) : (null == (_item_result1 = item.result) ? void 0 : _item_result1.error) ? "\u2717" : "\u2713"
+                                                                })
+                                                            ]
+                                                        }),
+                                                        description && /*#__PURE__*/ jsx("div", {
+                                                            children: /*#__PURE__*/ jsx("span", {
+                                                                className: "progress-description",
+                                                                children: description
+                                                            })
+                                                        }),
+                                                        (null == (_item_result2 = item.result) ? void 0 : _item_result2.error) && /*#__PURE__*/ jsx(ErrorMessage, {
+                                                            error: item.result.error
+                                                        })
+                                                    ]
+                                                });
+                                            })()
+                                        }) : 'separator' === item.type ? /*#__PURE__*/ jsxs("div", {
+                                            className: "new-conversation-separator",
+                                            children: [
+                                                /*#__PURE__*/ jsx("div", {
+                                                    className: "separator-line"
+                                                }),
+                                                /*#__PURE__*/ jsx("div", {
+                                                    className: "separator-text-container",
+                                                    children: /*#__PURE__*/ jsx(Text, {
+                                                        type: "secondary",
+                                                        className: "separator-text",
+                                                        children: item.content
+                                                    })
+                                                })
+                                            ]
+                                        }) : /*#__PURE__*/ jsxs("div", {
+                                            className: "system-message-container",
+                                            children: [
+                                                /*#__PURE__*/ jsxs("div", {
+                                                    className: "system-message-header",
+                                                    children: [
+                                                        /*#__PURE__*/ jsx(icons, {
+                                                            component: branding.icon || avatar,
+                                                            style: {
+                                                                fontSize: 20
+                                                            }
+                                                        }),
+                                                        /*#__PURE__*/ jsx("span", {
+                                                            className: "system-message-title",
+                                                            children: branding.title || "RPA\u667A\u80FD\u52A9\u624B"
+                                                        })
+                                                    ]
+                                                }),
+                                                (item.content || item.result) && /*#__PURE__*/ jsxs("div", {
+                                                    className: "system-message-content",
+                                                    children: [
+                                                        'result' === item.type && (null == (_item_result = item.result) ? void 0 : _item_result.error) && /*#__PURE__*/ jsxs("div", {
+                                                            className: "error-message",
+                                                            children: [
+                                                                /*#__PURE__*/ jsx("div", {
+                                                                    className: "divider"
+                                                                }),
+                                                                /*#__PURE__*/ jsx(ErrorMessage, {
+                                                                    error: item.result.error
+                                                                })
+                                                            ]
+                                                        }),
+                                                        'result' === item.type ? /*#__PURE__*/ jsx(PlaygroundResultView, {
+                                                            result: item.result || null,
+                                                            loading: item.loading || false,
+                                                            serverValid: true,
+                                                            serviceMode: 'Server',
+                                                            replayScriptsInfo: item.replayScriptsInfo || null,
+                                                            replayCounter: item.replayCounter || 0,
+                                                            loadingProgressText: item.loadingProgressText || '',
+                                                            verticalMode: item.verticalMode || false,
+                                                            fitMode: "width"
+                                                        }) : /*#__PURE__*/ jsxs(Fragment, {
+                                                            children: [
+                                                                /*#__PURE__*/ jsx("div", {
+                                                                    className: "system-message-text",
+                                                                    children: item.content
+                                                                }),
+                                                                item.loading && item.loadingProgressText && /*#__PURE__*/ jsx("div", {
+                                                                    className: "loading-progress-text",
+                                                                    children: /*#__PURE__*/ jsx("span", {
+                                                                        children: item.loadingProgressText
+                                                                    })
+                                                                })
+                                                            ]
+                                                        })
+                                                    ]
+                                                }),
+                                                showHumanUse && (null == item ? void 0 : item.actionTasks) && (null == item ? void 0 : item.actionTasks.length) > 0 && /*#__PURE__*/ jsx("div", {
+                                                    className: "system-message-content",
+                                                    children: /*#__PURE__*/ jsxs(Fragment, {
+                                                        children: [
+                                                            /*#__PURE__*/ jsxs("div", {
+                                                                className: "system-message-text",
+                                                                children: [
+                                                                    /*#__PURE__*/ jsx("div", {
+                                                                        className: "action-result-title",
+                                                                        children: "\u6B64\u6B21\u751F\u6210\u5982\u4E0B\u547D\u4EE4\uFF0C\u70B9\u51FB\u91C7\u7528\u53EF\u63D2\u5165\u5230\u8BBE\u8BA1\u5668"
+                                                                    }),
+                                                                    /*#__PURE__*/ jsx("ul", {
+                                                                        className: "action-result-list",
+                                                                        children: item.actionTasks.map((data, index)=>{
+                                                                            var _commandMap_data_subType, _data_param, _data_param1;
+                                                                            return /*#__PURE__*/ jsxs("li", {
+                                                                                title: data.locate,
+                                                                                children: [
+                                                                                    /*#__PURE__*/ jsxs("div", {
+                                                                                        className: "action-result-command",
+                                                                                        children: [
+                                                                                            "\u547D\u4EE4\uFF1A",
+                                                                                            (null == (_commandMap_data_subType = commandMap[data.subType]) ? void 0 : _commandMap_data_subType.DisplayName) || data.subType
+                                                                                        ]
+                                                                                    }),
+                                                                                    (null == data ? void 0 : null == (_data_param = data.param) ? void 0 : _data_param.value) && /*#__PURE__*/ jsxs("div", {
+                                                                                        className: "action-result-command",
+                                                                                        children: [
+                                                                                            "\u503C\uFF1A",
+                                                                                            (null == data ? void 0 : null == (_data_param1 = data.param) ? void 0 : _data_param1.value) || (null == data ? void 0 : data.param.keyName)
+                                                                                        ]
+                                                                                    }),
+                                                                                    /*#__PURE__*/ jsxs("div", {
+                                                                                        className: "action-result-locate",
+                                                                                        children: [
+                                                                                            "\u5143\u7D20\uFF1A",
+                                                                                            data.locate
+                                                                                        ]
+                                                                                    })
+                                                                                ]
+                                                                            }, index);
+                                                                        })
+                                                                    })
+                                                                ]
+                                                            }),
+                                                            /*#__PURE__*/ jsx("div", {
+                                                                className: "action-result-btns",
+                                                                children: /*#__PURE__*/ jsx(Button, {
+                                                                    type: "primary",
+                                                                    onClick: ()=>onHumanUse(item.actionTasks),
+                                                                    children: "\u91C7\u7528"
+                                                                })
+                                                            })
+                                                        ]
+                                                    })
+                                                })
+                                            ]
+                                        })
+                                    }, item.id);
+                                }
+                            })
+                        }),
+                        showScrollToBottomButton && false !== componentConfig.enableScrollToBottom && /*#__PURE__*/ jsx(Button, {
+                            className: "scroll-to-bottom-button",
+                            type: "primary",
+                            shape: "circle",
+                            icon: /*#__PURE__*/ jsx(ArrowDownOutlined, {}),
+                            onClick: handleScrollToBottom,
+                            size: "large"
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx("div", {
+                    className: "bottom-input-section aaa",
+                    children: showPromptInput && /*#__PURE__*/ jsx(PromptInput, {
+                        runButtonEnabled: runButtonEnabled,
+                        form: form,
+                        serviceMode: 'Server',
+                        selectedType: selectedType,
+                        dryMode: dryMode,
+                        stoppable: canStop,
+                        loading: loading,
+                        onRun: handleFormRun,
+                        onStop: handleStop,
+                        actionSpace: actionSpace
+                    })
+                }),
+                showVersionInfo && branding.version && /*#__PURE__*/ jsx("div", {
+                    className: "version-info-section",
+                    children: /*#__PURE__*/ jsxs("span", {
+                        className: "version-text",
+                        children: [
+                            "RPA\u667A\u80FD\u52A9\u624B version: ",
+                            branding.version
+                        ]
+                    })
+                })
+            ]
+        })
+    });
+}
+const universal_playground = UniversalPlayground;
+export { UniversalPlayground, universal_playground as default };

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

@@ -0,0 +1,52 @@
+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;
+}
+class BaseContextProvider {
+    async refreshContext() {
+        this.cachedContext = void 0;
+        return await this.getUIContext();
+    }
+    constructor(){
+        _define_property(this, "cachedContext", void 0);
+    }
+}
+class AgentContextProvider extends BaseContextProvider {
+    async getUIContext() {
+        if (this.cachedContext) return this.cachedContext;
+        const agent = this.getAgent();
+        if (!(null == agent ? void 0 : agent.getUIContext)) throw new Error('Agent does not support getUIContext');
+        const context = await agent.getUIContext();
+        this.cachedContext = context;
+        return context;
+    }
+    constructor(getAgent, options){
+        super(), _define_property(this, "getAgent", void 0), _define_property(this, "options", void 0), this.getAgent = getAgent, this.options = options;
+    }
+}
+class StaticContextProvider extends BaseContextProvider {
+    async getUIContext() {
+        return this.context;
+    }
+    async refreshContext() {
+        return this.context;
+    }
+    constructor(context){
+        super(), _define_property(this, "context", void 0), this.context = context;
+    }
+}
+class NoOpContextProvider {
+    async getUIContext() {
+        throw new Error('Context preview is disabled');
+    }
+    async refreshContext() {
+        throw new Error('Context preview is disabled');
+    }
+}
+export { AgentContextProvider, BaseContextProvider, NoOpContextProvider, StaticContextProvider };

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

@@ -0,0 +1,207 @@
+import { IndexedDBManager, createCleanupFunction, withErrorHandling } from "@rpascene/shared/baseDB";
+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;
+}
+const DB_NAME = 'rpascene_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 {
+    async saveMessages(messages) {
+        await withErrorHandling(async ()=>{
+            await this.dbManager.clear(MESSAGES_STORE);
+            const messagesToSave = messages.slice(-MAX_STORED_MESSAGES);
+            await Promise.all(messagesToSave.map((msg, index)=>{
+                const lightMessage = {
+                    ...msg,
+                    result: void 0
+                };
+                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);
+            }));
+        }, 'Failed to save messages to IndexedDB', void 0, this.messagesCleanup);
+    }
+    async loadMessages() {
+        const result = await withErrorHandling(async ()=>{
+            const messages = await this.dbManager.getAll(MESSAGES_STORE, true);
+            if (0 === messages.length) return [];
+            return Promise.all(messages.map(async (msg)=>{
+                const item = msg.data;
+                const restoredItem = {
+                    ...item,
+                    timestamp: new Date(item.timestamp)
+                };
+                if ('result' === item.type && item.id) {
+                    const fullResult = await this.loadResult(item.id);
+                    if (fullResult) {
+                        restoredItem.result = fullResult.result;
+                        restoredItem.replayScriptsInfo = fullResult.replayScriptsInfo;
+                        restoredItem.replayCounter = fullResult.replayCounter;
+                        restoredItem.verticalMode = fullResult.verticalMode;
+                    }
+                }
+                return restoredItem;
+            }));
+        }, 'Failed to load messages from IndexedDB', [], this.messagesCleanup);
+        return result || [];
+    }
+    async clearMessages() {
+        await withErrorHandling(async ()=>{
+            await Promise.all([
+                this.dbManager.clear(MESSAGES_STORE),
+                this.dbManager.clear(RESULTS_STORE)
+            ]);
+        }, 'Failed to clear messages from IndexedDB');
+    }
+    async saveResult(id, result) {
+        await withErrorHandling(async ()=>{
+            const compressedResult = this.compressResultForStorage(result);
+            const data = {
+                id,
+                data: compressedResult,
+                timestamp: Date.now(),
+                size: JSON.stringify(compressedResult).length
+            };
+            await this.dbManager.put(RESULTS_STORE, data);
+        }, 'Failed to save result to IndexedDB', void 0, this.resultsCleanup);
+    }
+    async loadResult(id) {
+        const result = await withErrorHandling(async ()=>{
+            const data = await this.dbManager.get(RESULTS_STORE, id);
+            return (null == data ? void 0 : data.data) || null;
+        }, 'Failed to load result from IndexedDB', null);
+        return result || null;
+    }
+    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.executions)) return result;
+        const compressedExecutions = result.result.dump.executions.map((execution)=>{
+            var _execution_tasks;
+            return {
+                ...execution,
+                tasks: (null == (_execution_tasks = execution.tasks) ? void 0 : _execution_tasks.map((task)=>{
+                    var _task_recorder;
+                    var _this_compressScreenshotIfNeeded;
+                    return {
+                        ...task,
+                        uiContext: task.uiContext ? {
+                            ...task.uiContext,
+                            screenshotBase64: null != (_this_compressScreenshotIfNeeded = this.compressScreenshotIfNeeded(task.uiContext.screenshotBase64)) ? _this_compressScreenshotIfNeeded : task.uiContext.screenshotBase64
+                        } : task.uiContext,
+                        recorder: null == (_task_recorder = task.recorder) ? void 0 : _task_recorder.map((record)=>({
+                                ...record,
+                                screenshot: this.compressScreenshotIfNeeded(record.screenshot)
+                            }))
+                    };
+                })) || []
+            };
+        });
+        return {
+            ...result,
+            result: {
+                ...result.result,
+                dump: {
+                    ...result.result.dump,
+                    executions: compressedExecutions
+                }
+            }
+        };
+    }
+    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;
+    }
+    async getStorageStats() {
+        const result = await withErrorHandling(async ()=>{
+            const [messageCount, resultCount] = await Promise.all([
+                this.dbManager.count(MESSAGES_STORE),
+                this.dbManager.count(RESULTS_STORE)
+            ]);
+            return {
+                messageCount,
+                resultCount
+            };
+        }, 'Failed to get storage statistics', {
+            messageCount: 0,
+            resultCount: 0
+        });
+        return result || {
+            messageCount: 0,
+            resultCount: 0
+        };
+    }
+    async cleanup() {
+        await Promise.all([
+            this.messagesCleanup(),
+            this.resultsCleanup()
+        ]);
+    }
+    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 {
+    async saveMessages(messages) {
+        this.messages = [
+            ...messages
+        ];
+    }
+    async loadMessages() {
+        return [
+            ...this.messages
+        ];
+    }
+    async clearMessages() {
+        this.messages = [];
+        this.results.clear();
+    }
+    async saveResult(id, result) {
+        this.results.set(id, result);
+    }
+    constructor(){
+        _define_property(this, "messages", []);
+        _define_property(this, "results", new Map());
+    }
+}
+class NoOpStorageProvider {
+    async saveMessages(_messages) {}
+    async loadMessages() {
+        return [];
+    }
+    async clearMessages() {}
+    async saveResult(_id, _result) {}
+}
+export { IndexedDBStorageProvider, MemoryStorageProvider, NoOpStorageProvider };