@godscene/web 1.7.11

package/dist/lib/playwright/ai-fixture.js

@@ -0,0 +1,401 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PlaywrightAiFixture: ()=>PlaywrightAiFixture,
+    midsceneDumpAnnotationId: ()=>midsceneDumpAnnotationId
+});
+const external_index_js_namespaceObject = require("./index.js");
+const utils_namespaceObject = require("@godscene/core/utils");
+const constants_namespaceObject = require("@godscene/shared/constants");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const shared_utils_namespaceObject = require("@godscene/shared/utils");
+const test_namespaceObject = require("@playwright/test");
+const debugPage = (0, logger_namespaceObject.getDebug)('web:playwright:ai-fixture');
+const groupAndCaseForTest = (testInfo)=>{
+    let taskFile;
+    let taskTitle;
+    const titlePath = [
+        ...testInfo.titlePath
+    ];
+    if (titlePath.length > 1) {
+        taskFile = titlePath.shift() || 'unnamed';
+        taskTitle = titlePath.join('__');
+    } else if (1 === titlePath.length) {
+        taskTitle = titlePath[0];
+        taskFile = `${taskTitle}`;
+    } else {
+        taskTitle = 'unnamed';
+        taskFile = 'unnamed';
+    }
+    const taskTitleWithRetry = `${taskTitle}${testInfo.retry ? `(retry #${testInfo.retry})` : ''}`;
+    return {
+        file: taskFile,
+        id: (0, shared_utils_namespaceObject.replaceIllegalPathCharsAndSpace)(`${taskFile}(${taskTitle})`),
+        title: (0, shared_utils_namespaceObject.replaceIllegalPathCharsAndSpace)(taskTitleWithRetry)
+    };
+};
+const midsceneAgentKeyId = '_midsceneAgentId';
+const midsceneDumpAnnotationId = 'MIDSCENE_DUMP_ANNOTATION';
+const PlaywrightAiFixture = (options)=>{
+    const { forceSameTabNavigation = true, waitForNetworkIdleTimeout = constants_namespaceObject.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT, waitForNavigationTimeout = constants_namespaceObject.DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT, cache, ...sharedAgentOptions } = options ?? {};
+    const processTestCacheConfig = (testInfo)=>{
+        const { id } = groupAndCaseForTest(testInfo);
+        return (0, utils_namespaceObject.processCacheConfig)(cache, id);
+    };
+    const pageAgentMap = {};
+    const testAgentRecords = new Map();
+    const getAgentRecordsForTest = (testInfo)=>{
+        let records = testAgentRecords.get(testInfo.testId);
+        if (!records) {
+            records = new Map();
+            testAgentRecords.set(testInfo.testId, records);
+        }
+        return records;
+    };
+    const setReportAnnotation = (testInfo, reportPaths)=>{
+        testInfo.annotations = testInfo.annotations.filter((item)=>item.type !== midsceneDumpAnnotationId);
+        for (const reportPath of reportPaths)testInfo.annotations.push({
+            type: midsceneDumpAnnotationId,
+            description: reportPath
+        });
+    };
+    const finalizeAgentRecord = async (record)=>{
+        if (!record.finalizePromise) record.finalizePromise = (async ()=>{
+            await record.agent.destroy();
+            const reportPath = record.agent.reportFile || void 0;
+            record.finalReportPath = reportPath;
+            return reportPath;
+        })();
+        return await record.finalizePromise;
+    };
+    const createOrReuseAgentForPage = (page, testInfo, opts)=>{
+        let idForPage = page[midsceneAgentKeyId];
+        if (!idForPage) {
+            idForPage = (0, shared_utils_namespaceObject.uuid)();
+            page[midsceneAgentKeyId] = idForPage;
+            const { file, title } = groupAndCaseForTest(testInfo);
+            const cacheConfig = processTestCacheConfig(testInfo);
+            const reportTag = `playwright-${title.replace(/[\\/]/g, '-')}-${idForPage}`;
+            const agent = new external_index_js_namespaceObject.PlaywrightAgent(page, {
+                testId: reportTag,
+                reportFileName: reportTag,
+                forceSameTabNavigation,
+                cache: cacheConfig,
+                groupName: title,
+                groupDescription: file,
+                generateReport: true,
+                ...sharedAgentOptions,
+                ...opts
+            });
+            pageAgentMap[idForPage] = agent;
+            const records = getAgentRecordsForTest(testInfo);
+            const record = {
+                agent
+            };
+            records.set(idForPage, record);
+            page.on('close', async ()=>{
+                debugPage('page closed');
+                try {
+                    await finalizeAgentRecord(record);
+                } finally{
+                    delete pageAgentMap[idForPage];
+                }
+            });
+        }
+        return pageAgentMap[idForPage];
+    };
+    async function generateAiFunction(options) {
+        const { page, testInfo, use, aiActionType } = options;
+        const agent = createOrReuseAgentForPage(page, testInfo, {
+            waitForNavigationTimeout,
+            waitForNetworkIdleTimeout
+        });
+        await use(async (taskPrompt, ...args)=>new Promise((resolve, reject)=>{
+                test_namespaceObject.test.step(`ai-${aiActionType} - ${JSON.stringify(taskPrompt)}`, async ()=>{
+                    try {
+                        const result = await agent[aiActionType].bind(agent)(taskPrompt, ...args);
+                        resolve(result);
+                    } catch (error) {
+                        reject(error);
+                    }
+                });
+            }));
+    }
+    return {
+        _midsceneFinalizeReports: [
+            async ({}, use, testInfo)=>{
+                await use();
+                const records = testAgentRecords.get(testInfo.testId);
+                if (!records || 0 === records.size) return;
+                const reportPaths = (await Promise.all(Array.from(records.values()).map((record)=>finalizeAgentRecord(record)))).filter((reportPath)=>Boolean(reportPath));
+                if (reportPaths.length > 0) setReportAnnotation(testInfo, reportPaths);
+                testAgentRecords.delete(testInfo.testId);
+            },
+            {
+                auto: true
+            }
+        ],
+        agentForPage: async ({ page }, use, testInfo)=>{
+            await use(async (propsPage, opts)=>{
+                const cacheConfig = processTestCacheConfig(testInfo);
+                let finalCacheConfig = cacheConfig;
+                if (opts?.cache !== void 0) {
+                    const userCache = opts.cache;
+                    if (false === userCache) finalCacheConfig = false;
+                    else if (true === userCache) {
+                        const { id } = groupAndCaseForTest(testInfo);
+                        finalCacheConfig = {
+                            id
+                        };
+                    } else if ('object' == typeof userCache) if (userCache.id) finalCacheConfig = userCache;
+                    else {
+                        const { id } = groupAndCaseForTest(testInfo);
+                        finalCacheConfig = {
+                            ...userCache,
+                            id
+                        };
+                    }
+                }
+                const agent = createOrReuseAgentForPage(propsPage || page, testInfo, {
+                    waitForNavigationTimeout,
+                    waitForNetworkIdleTimeout,
+                    cache: finalCacheConfig,
+                    ...opts
+                });
+                return agent;
+            });
+        },
+        ai: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'ai'
+            });
+        },
+        aiAct: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAct'
+            });
+        },
+        aiAction: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAction'
+            });
+        },
+        aiTap: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiTap'
+            });
+        },
+        aiRightClick: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiRightClick'
+            });
+        },
+        aiDoubleClick: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiDoubleClick'
+            });
+        },
+        aiHover: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiHover'
+            });
+        },
+        aiInput: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiInput'
+            });
+        },
+        aiKeyboardPress: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiKeyboardPress'
+            });
+        },
+        aiScroll: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiScroll'
+            });
+        },
+        aiQuery: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiQuery'
+            });
+        },
+        aiAssert: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAssert'
+            });
+        },
+        aiWaitFor: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiWaitFor'
+            });
+        },
+        aiLocate: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiLocate'
+            });
+        },
+        aiNumber: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiNumber'
+            });
+        },
+        aiString: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiString'
+            });
+        },
+        aiBoolean: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiBoolean'
+            });
+        },
+        aiAsk: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAsk'
+            });
+        },
+        runYaml: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'runYaml'
+            });
+        },
+        setAIActionContext: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'setAIActionContext'
+            });
+        },
+        evaluateJavaScript: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'evaluateJavaScript'
+            });
+        },
+        recordToReport: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'recordToReport'
+            });
+        },
+        logScreenshot: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'logScreenshot'
+            });
+        },
+        freezePageContext: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'freezePageContext'
+            });
+        },
+        unfreezePageContext: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'unfreezePageContext'
+            });
+        }
+    };
+};
+exports.PlaywrightAiFixture = __webpack_exports__.PlaywrightAiFixture;
+exports.midsceneDumpAnnotationId = __webpack_exports__.midsceneDumpAnnotationId;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PlaywrightAiFixture",
+    "midsceneDumpAnnotationId"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/playwright/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PlaywrightAiFixture: ()=>external_ai_fixture_js_namespaceObject.PlaywrightAiFixture,
+    PlaywrightWebPage: ()=>external_page_js_namespaceObject.WebPage,
+    overrideAIConfig: ()=>env_namespaceObject.overrideAIConfig,
+    PlaywrightAgent: ()=>PlaywrightAgent
+});
+const agent_namespaceObject = require("@godscene/core/agent");
+const external_page_js_namespaceObject = require("./page.js");
+const external_ai_fixture_js_namespaceObject = require("./ai-fixture.js");
+const env_namespaceObject = require("@godscene/shared/env");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const external_semver_namespaceObject = require("semver");
+var external_semver_default = /*#__PURE__*/ __webpack_require__.n(external_semver_namespaceObject);
+const base_page_js_namespaceObject = require("../puppeteer/base-page.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const debug = (0, logger_namespaceObject.getDebug)('playwright:agent');
+function getPlaywrightVersion() {
+    try {
+        const playwrightPkg = (0, external_utils_js_namespaceObject.getWebpackRequire)()('playwright/package.json');
+        return playwrightPkg.version || null;
+    } catch (error) {
+        console.error('[midscene:error] Failed to get Playwright version', error);
+        return null;
+    }
+}
+class PlaywrightAgent extends agent_namespaceObject.Agent {
+    isRetryableContextError(error) {
+        return error instanceof Error && base_page_js_namespaceObject.BROWSER_NAVIGATION_ERROR_PATTERN.test(error.message);
+    }
+    constructor(page, opts){
+        if (!page) throw new Error('[midscene] PlaywrightAgent requires a valid Playwright page instance. Please make sure to pass a valid page object.');
+        const webPage = new external_page_js_namespaceObject.WebPage(page, opts);
+        super(webPage, opts);
+        const { forceSameTabNavigation = true, forceChromeSelectRendering } = opts ?? {};
+        if (forceSameTabNavigation) (0, base_page_js_namespaceObject.forceClosePopup)(page, debug);
+        if (forceChromeSelectRendering) {
+            const playwrightVersion = getPlaywrightVersion();
+            if (playwrightVersion && !external_semver_default().gte(playwrightVersion, '1.52.0')) console.warn(`[midscene:error] forceChromeSelectRendering requires Playwright >= 1.52.0, but current version is ${playwrightVersion}. This feature may not work correctly.`);
+            (0, base_page_js_namespaceObject.forceChromeSelectRendering)(page);
+        }
+    }
+}
+exports.PlaywrightAgent = __webpack_exports__.PlaywrightAgent;
+exports.PlaywrightAiFixture = __webpack_exports__.PlaywrightAiFixture;
+exports.PlaywrightWebPage = __webpack_exports__.PlaywrightWebPage;
+exports.overrideAIConfig = __webpack_exports__.overrideAIConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PlaywrightAgent",
+    "PlaywrightAiFixture",
+    "PlaywrightWebPage",
+    "overrideAIConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/playwright/page.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    WebPage: ()=>WebPage
+});
+const base_page_js_namespaceObject = require("../puppeteer/base-page.js");
+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 WebPage extends base_page_js_namespaceObject.Page {
+    async registerFileChooserListener(handler) {
+        const page = this.underlyingPage;
+        let capturedError;
+        this.playwrightFileChooserHandler = async (chooser)=>{
+            try {
+                await handler({
+                    accept: async (files)=>{
+                        await chooser.setFiles(files);
+                    }
+                });
+            } catch (error) {
+                capturedError = error;
+            }
+        };
+        page.on('filechooser', this.playwrightFileChooserHandler);
+        return {
+            dispose: ()=>{
+                if (this.playwrightFileChooserHandler) {
+                    page.off('filechooser', this.playwrightFileChooserHandler);
+                    this.playwrightFileChooserHandler = void 0;
+                }
+            },
+            getError: ()=>capturedError
+        };
+    }
+    constructor(page, opts){
+        super(page, 'playwright', opts), _define_property(this, "playwrightFileChooserHandler", void 0);
+    }
+}
+exports.WebPage = __webpack_exports__.WebPage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WebPage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});