@rpascene/web 0.30.8

package/dist/types/playwright/ai-fixture.d.ts

@@ -0,0 +1,117 @@
+import { type PlaywrightWebPage } from './index';
+import type { Agent as PageAgent } from '@rpascene/core/agent';
+import { type TestInfo, type TestType } from '@playwright/test';
+import type { Page as OriginPlaywrightPage } from 'playwright';
+export type APITestType = Pick<TestType<any, any>, 'step'>;
+export declare const rpasceneDumpAnnotationId = "RPASCENE_DUMP_ANNOTATION";
+type PlaywrightCacheConfig = {
+    strategy?: 'read-only' | 'read-write' | 'write-only';
+    id?: string;
+};
+type PlaywrightCache = false | true | PlaywrightCacheConfig;
+export declare const PlaywrightAiFixture: (options?: {
+    forceSameTabNavigation?: boolean;
+    waitForNetworkIdleTimeout?: number;
+    waitForNavigationTimeout?: number;
+    cache?: PlaywrightCache;
+}) => {
+    agentForPage: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    ai: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiAction: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiTap: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiRightClick: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiDoubleClick: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiHover: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiInput: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiKeyboardPress: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiScroll: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiQuery: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiAssert: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiWaitFor: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiLocate: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiNumber: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiString: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiBoolean: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiAsk: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    runYaml: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    setAIActionContext: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    evaluateJavaScript: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    logScreenshot: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    freezePageContext: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    unfreezePageContext: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+};
+export type PlayWrightAiFixtureType = {
+    agentForPage: (page?: any, opts?: any) => Promise<PageAgent<PlaywrightWebPage>>;
+    ai: <T = any>(prompt: string) => Promise<T>;
+    aiAction: (taskPrompt: string) => ReturnType<PageAgent['aiAction']>;
+    aiTap: (...args: Parameters<PageAgent['aiTap']>) => ReturnType<PageAgent['aiTap']>;
+    aiRightClick: (...args: Parameters<PageAgent['aiRightClick']>) => ReturnType<PageAgent['aiRightClick']>;
+    aiDoubleClick: (...args: Parameters<PageAgent['aiDoubleClick']>) => ReturnType<PageAgent['aiDoubleClick']>;
+    aiHover: (...args: Parameters<PageAgent['aiHover']>) => ReturnType<PageAgent['aiHover']>;
+    aiInput: (...args: Parameters<PageAgent['aiInput']>) => ReturnType<PageAgent['aiInput']>;
+    aiKeyboardPress: (...args: Parameters<PageAgent['aiKeyboardPress']>) => ReturnType<PageAgent['aiKeyboardPress']>;
+    aiScroll: (...args: Parameters<PageAgent['aiScroll']>) => ReturnType<PageAgent['aiScroll']>;
+    aiQuery: <T = any>(...args: Parameters<PageAgent['aiQuery']>) => Promise<T>;
+    aiAssert: (...args: Parameters<PageAgent['aiAssert']>) => ReturnType<PageAgent['aiAssert']>;
+    aiWaitFor: (...args: Parameters<PageAgent['aiWaitFor']>) => Promise<void>;
+    aiLocate: (...args: Parameters<PageAgent['aiLocate']>) => ReturnType<PageAgent['aiLocate']>;
+    aiNumber: (...args: Parameters<PageAgent['aiNumber']>) => ReturnType<PageAgent['aiNumber']>;
+    aiString: (...args: Parameters<PageAgent['aiString']>) => ReturnType<PageAgent['aiString']>;
+    aiBoolean: (...args: Parameters<PageAgent['aiBoolean']>) => ReturnType<PageAgent['aiBoolean']>;
+    aiAsk: (...args: Parameters<PageAgent['aiAsk']>) => ReturnType<PageAgent['aiAsk']>;
+    runYaml: (...args: Parameters<PageAgent['runYaml']>) => ReturnType<PageAgent['runYaml']>;
+    setAIActionContext: (...args: Parameters<PageAgent['setAIActionContext']>) => ReturnType<PageAgent['setAIActionContext']>;
+    evaluateJavaScript: (...args: Parameters<PageAgent['evaluateJavaScript']>) => ReturnType<PageAgent['evaluateJavaScript']>;
+    logScreenshot: (...args: Parameters<PageAgent['logScreenshot']>) => ReturnType<PageAgent['logScreenshot']>;
+    freezePageContext: (...args: Parameters<PageAgent['freezePageContext']>) => ReturnType<PageAgent['freezePageContext']>;
+    unfreezePageContext: (...args: Parameters<PageAgent['unfreezePageContext']>) => ReturnType<PageAgent['unfreezePageContext']>;
+};
+export {};

package/dist/types/playwright/index.d.ts

@@ -0,0 +1,12 @@
+import { Agent as PageAgent } from '@rpascene/core/agent';
+import type { Page as PlaywrightPage } from 'playwright';
+import { WebPage as PlaywrightWebPage } from './page';
+export type { PlayWrightAiFixtureType } from './ai-fixture';
+export { PlaywrightAiFixture } from './ai-fixture';
+export { overrideAIConfig } from '@rpascene/shared/env';
+export { WebPage as PlaywrightWebPage } from './page';
+import type { WebPageAgentOpt } from '../web-element';
+export declare class PlaywrightAgent extends PageAgent<PlaywrightWebPage> {
+    constructor(page: PlaywrightPage, opts?: WebPageAgentOpt);
+    waitForNetworkIdle(timeout?: number): Promise<void>;
+}

package/dist/types/playwright/page.d.ts

@@ -0,0 +1,6 @@
+import type { Page as PlaywrightPageType } from 'playwright';
+import { Page as BasePage } from '../puppeteer/base-page';
+import type { WebPageOpt } from '../web-element';
+export declare class WebPage extends BasePage<'playwright', PlaywrightPageType> {
+    constructor(page: PlaywrightPageType, opts?: WebPageOpt);
+}

package/dist/types/playwright/reporter/index.d.ts

@@ -0,0 +1,18 @@
+import type { FullConfig, Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
+interface RpasceneReporterOptions {
+    type?: 'merged' | 'separate';
+}
+declare class RpasceneReporter implements Reporter {
+    private mergedFilename?;
+    private testTitleToFilename;
+    mode?: 'merged' | 'separate';
+    constructor(options?: RpasceneReporterOptions);
+    private static getMode;
+    private getSeparatedFilename;
+    private getReportFilename;
+    private updateReport;
+    onBegin(config: FullConfig, suite: Suite): Promise<void>;
+    onTestBegin(_test: TestCase, _result: TestResult): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+}
+export default RpasceneReporter;

package/dist/types/puppeteer/agent-launcher.d.ts

@@ -0,0 +1,29 @@
+import { PuppeteerAgent } from './index';
+import type { Cache, RpasceneYamlScriptWebEnv } from '@rpascene/core';
+import { type Browser } from 'puppeteer';
+export declare const defaultUA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36";
+export declare const defaultViewportWidth = 1440;
+export declare const defaultViewportHeight = 768;
+export declare const defaultViewportScale: number;
+export declare const defaultWaitForNetworkIdleTimeout = 2000;
+interface FreeFn {
+    name: string;
+    fn: () => void;
+}
+export declare function launchPuppeteerPage(target: RpasceneYamlScriptWebEnv, preference?: {
+    headed?: boolean;
+    keepWindow?: boolean;
+}, browser?: Browser): Promise<{
+    page: import("puppeteer").Page;
+    freeFn: FreeFn[];
+}>;
+export declare function puppeteerAgentForTarget(target: RpasceneYamlScriptWebEnv, preference?: {
+    headed?: boolean;
+    keepWindow?: boolean;
+    testId?: string;
+    cache?: Cache;
+}, browser?: Browser): Promise<{
+    agent: PuppeteerAgent;
+    freeFn: FreeFn[];
+}>;
+export {};

package/dist/types/puppeteer/base-page.d.ts

@@ -0,0 +1,90 @@
+import { type WebPageAgentOpt } from '../web-element';
+import type { DeviceAction, ElementCacheFeature, ElementTreeNode, Point, Rect, Size, UIContext } from '@rpascene/core';
+import type { AbstractInterface } from '@rpascene/core/device';
+import type { ElementInfo } from '@rpascene/shared/extractor';
+import { type DebugFunction } from '@rpascene/shared/logger';
+import type { Page as PlaywrightPage } from 'playwright';
+import type { Page as PuppeteerPage } from 'puppeteer';
+import { type KeyInput, type MouseButton } from '../web-page';
+export declare const debugPage: DebugFunction;
+export declare class Page<AgentType extends 'puppeteer' | 'playwright', InterfaceType extends PuppeteerPage | PlaywrightPage> implements AbstractInterface {
+    underlyingPage: InterfaceType;
+    protected waitForNavigationTimeout: number;
+    protected waitForNetworkIdleTimeout: number;
+    private viewportSize?;
+    private onBeforeInvokeAction?;
+    private onAfterInvokeAction?;
+    private customActions?;
+    interfaceType: AgentType;
+    actionSpace(): DeviceAction[];
+    private evaluate;
+    constructor(underlyingPage: InterfaceType, interfaceType: AgentType, opts?: WebPageAgentOpt);
+    evaluateJavaScript<T = any>(script: string): Promise<T>;
+    waitForNavigation(): Promise<void>;
+    waitForNetworkIdle(): Promise<void>;
+    getElementsInfo(): Promise<ElementInfo[]>;
+    getXpathsById(id: string): Promise<any>;
+    getXpathsByPoint(point: Point, isOrderSensitive: boolean): Promise<any>;
+    getElementInfoByXpath(xpath: string): Promise<any>;
+    cacheFeatureForRect(rect: Rect, opt?: {
+        _orderSensitive: boolean;
+    }): Promise<ElementCacheFeature>;
+    rectMatchesCacheFeature(feature: ElementCacheFeature): Promise<Rect>;
+    getElementsNodeTree(): Promise<ElementTreeNode<ElementInfo>>;
+    size(): Promise<Size>;
+    screenshotBase64(): Promise<string>;
+    url(): Promise<string>;
+    describe(): string;
+    get mouse(): {
+        click: (x: number, y: number, options?: {
+            button?: MouseButton;
+            count?: number;
+        }) => Promise<void>;
+        wheel: (deltaX: number, deltaY: number) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        drag: (from: {
+            x: number;
+            y: number;
+        }, to: {
+            x: number;
+            y: number;
+        }) => Promise<void>;
+    };
+    get keyboard(): {
+        type: (text: string) => Promise<void>;
+        press: (action: {
+            key: KeyInput;
+            command?: string;
+        } | {
+            key: KeyInput;
+            command?: string;
+        }[]) => Promise<void>;
+        down: (key: KeyInput) => Promise<void>;
+        up: (key: KeyInput) => Promise<void>;
+    };
+    clearInput(element: ElementInfo): Promise<void>;
+    private everMoved;
+    private moveToPointBeforeScroll;
+    scrollUntilTop(startingPoint?: Point): Promise<void>;
+    scrollUntilBottom(startingPoint?: Point): Promise<void>;
+    scrollUntilLeft(startingPoint?: Point): Promise<void>;
+    scrollUntilRight(startingPoint?: Point): Promise<void>;
+    scrollUp(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollDown(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollLeft(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollRight(distance?: number, startingPoint?: Point): Promise<void>;
+    navigate(url: string): Promise<void>;
+    beforeInvokeAction(name: string, param: any): Promise<void>;
+    afterInvokeAction(name: string, param: any): Promise<void>;
+    destroy(): Promise<void>;
+    getContext(): Promise<UIContext>;
+    swipe(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, duration?: number): Promise<void>;
+    longPress(x: number, y: number, duration?: number): Promise<void>;
+}
+export declare function forceClosePopup(page: PuppeteerPage | PlaywrightPage, debugProfile: DebugFunction): void;

package/dist/types/puppeteer/index.d.ts

@@ -0,0 +1,9 @@
+import type { WebPageAgentOpt } from '../web-element';
+import { Agent as PageAgent } from '@rpascene/core/agent';
+import type { Page as PuppeteerPage } from 'puppeteer';
+import { PuppeteerWebPage } from './page';
+export { PuppeteerWebPage } from './page';
+export declare class PuppeteerAgent extends PageAgent<PuppeteerWebPage> {
+    constructor(page: PuppeteerPage, opts?: WebPageAgentOpt);
+}
+export { overrideAIConfig } from '@rpascene/shared/env';

package/dist/types/puppeteer/page.d.ts

@@ -0,0 +1,6 @@
+import type { WebPageOpt } from '../web-element';
+import type { Page as PuppeteerPageType } from 'puppeteer';
+import { Page as BasePage } from './base-page';
+export declare class PuppeteerWebPage extends BasePage<'puppeteer', PuppeteerPageType> {
+    constructor(page: PuppeteerPageType, opts?: WebPageOpt);
+}

package/dist/types/static/index.d.ts

@@ -0,0 +1,2 @@
+export { StaticPageAgent } from './static-agent';
+export { default as StaticPage } from './static-page';

package/dist/types/static/static-agent.d.ts

@@ -0,0 +1,5 @@
+import { Agent as PageAgent } from '@rpascene/core/agent';
+import type StaticPage from './static-page';
+export declare class StaticPageAgent extends PageAgent {
+    constructor(page: StaticPage);
+}

package/dist/types/static/static-page.d.ts

@@ -0,0 +1,52 @@
+import type { DeviceAction, Point, UIContext } from '@rpascene/core';
+import type { AbstractInterface } from '@rpascene/core/device';
+type WebUIContext = UIContext & {
+    screenshotBase64?: string;
+    size: {
+        width: number;
+        height: number;
+        dpr?: number;
+    };
+};
+export default class StaticPage implements AbstractInterface {
+    interfaceType: string;
+    private uiContext;
+    constructor(uiContext: WebUIContext);
+    actionSpace(): DeviceAction[];
+    evaluateJavaScript<T = unknown>(script: string): Promise<T>;
+    getElementsInfo(): Promise<never>;
+    getElementsNodeTree(): Promise<never>;
+    getXpathsById(id: string): Promise<never>;
+    getXpathsByPoint(point: Point): Promise<never>;
+    getElementInfoByXpath(xpath: string): Promise<never>;
+    size(): Promise<{
+        dpr: number;
+        width: number;
+        height: number;
+    }>;
+    screenshotBase64(): Promise<string>;
+    url(): Promise<string>;
+    scrollUntilTop(startingPoint?: Point): Promise<never>;
+    scrollUntilBottom(startingPoint?: Point): Promise<never>;
+    scrollUntilLeft(startingPoint?: Point): Promise<never>;
+    scrollUntilRight(startingPoint?: Point): Promise<never>;
+    scrollUp(distance?: number, startingPoint?: Point): Promise<never>;
+    scrollDown(distance?: number, startingPoint?: Point): Promise<never>;
+    scrollLeft(distance?: number, startingPoint?: Point): Promise<never>;
+    scrollRight(distance?: number, startingPoint?: Point): Promise<never>;
+    clearInput(): Promise<never>;
+    mouse: {
+        click: () => never;
+        wheel: () => never;
+        move: () => never;
+        drag: () => never;
+    };
+    keyboard: {
+        type: () => never;
+        press: () => never;
+    };
+    destroy(): Promise<void>;
+    getContext(): Promise<UIContext>;
+    updateContext(newContext: WebUIContext): void;
+}
+export {};

package/dist/types/web-element.d.ts

@@ -0,0 +1,51 @@
+import type { AgentOpt, DeviceAction, Rect, UIContext, WebElementInfo } from '@rpascene/core';
+import type { AbstractInterface } from '@rpascene/core/device';
+import type { NodeType } from '@rpascene/shared/constants';
+import type ChromeExtensionProxyPage from './chrome-extension/page';
+import type { PlaywrightWebPage } from './playwright';
+import type { PuppeteerWebPage } from './puppeteer';
+import type { StaticPage } from './static';
+export type { WebElementInfo };
+export type WebPageAgentOpt = AgentOpt & WebPageOpt;
+export type WebPageOpt = {
+    waitForNavigationTimeout?: number;
+    waitForNetworkIdleTimeout?: number;
+    forceSameTabNavigation?: boolean;
+    beforeInvokeAction?: () => Promise<void>;
+    afterInvokeAction?: () => Promise<void>;
+    customActions?: DeviceAction<any>[];
+};
+export type WebPage = PlaywrightWebPage | PuppeteerWebPage | StaticPage | ChromeExtensionProxyPage;
+export declare class WebElementInfoImpl implements WebElementInfo {
+    content: string;
+    rect: Rect;
+    center: [number, number];
+    id: string;
+    indexId: number;
+    attributes: {
+        nodeType: NodeType;
+        [key: string]: string;
+    };
+    xpaths?: string[];
+    isVisible: boolean;
+    allPaths?: any;
+    containerPaths?: any;
+    constructor({ content, rect, id, attributes, indexId, xpaths, isVisible, allPaths, containerPaths }: {
+        content: string;
+        rect: Rect;
+        id: string;
+        attributes: {
+            nodeType: NodeType;
+            [key: string]: string;
+        };
+        indexId: number;
+        xpaths?: string[];
+        isVisible: boolean;
+        allPaths?: any;
+        containerPaths?: any;
+    });
+}
+export declare function WebPageContextParser(page: AbstractInterface, _opt: {
+    uploadServerUrl?: string;
+}): Promise<UIContext>;
+export declare const limitOpenNewTabScript = "\nif (!window.__RPASCENE_NEW_TAB_INTERCEPTOR_INITIALIZED__) {\n  window.__RPASCENE_NEW_TAB_INTERCEPTOR_INITIALIZED__ = true;\n\n  // Intercept the window.open method (only once)\n  window.open = function(url) {\n    console.log('Blocked window.open:', url);\n    window.location.href = url;\n    return null;\n  };\n\n  // Block all a tag clicks with target=\"_blank\" (only once)\n  document.addEventListener('click', function(e) {\n    const target = e.target.closest('a');\n    if (target && target.target === '_blank') {\n      e.preventDefault();\n      console.log('Blocked new tab:', target.href);\n      window.location.href = target.href;\n      target.removeAttribute('target');\n    }\n  }, true);\n}\n";

package/dist/types/web-page.d.ts

@@ -0,0 +1,59 @@
+import type { Point } from '@rpascene/core';
+import { AbstractInterface, type DeviceAction } from '@rpascene/core/device';
+import type { ElementInfo } from '@rpascene/shared/extractor';
+export declare function getKeyCommands(value: string | string[]): Array<{
+    key: string;
+    command?: string;
+}>;
+export declare type KeyInput = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'Power' | 'Eject' | 'Abort' | 'Help' | 'Backspace' | 'Tab' | 'Numpad5' | 'NumpadEnter' | 'Enter' | '\r' | '\n' | 'ShiftLeft' | 'ShiftRight' | 'ControlLeft' | 'ControlRight' | 'AltLeft' | 'AltRight' | 'Pause' | 'CapsLock' | 'Escape' | 'Convert' | 'NonConvert' | 'Space' | 'Numpad9' | 'PageUp' | 'Numpad3' | 'PageDown' | 'End' | 'Numpad1' | 'Home' | 'Numpad7' | 'ArrowLeft' | 'Numpad4' | 'Numpad8' | 'ArrowUp' | 'ArrowRight' | 'Numpad6' | 'Numpad2' | 'ArrowDown' | 'Select' | 'Open' | 'PrintScreen' | 'Insert' | 'Numpad0' | 'Delete' | 'NumpadDecimal' | 'Digit0' | 'Digit1' | 'Digit2' | 'Digit3' | 'Digit4' | 'Digit5' | 'Digit6' | 'Digit7' | 'Digit8' | 'Digit9' | 'KeyA' | 'KeyB' | 'KeyC' | 'KeyD' | 'KeyE' | 'KeyF' | 'KeyG' | 'KeyH' | 'KeyI' | 'KeyJ' | 'KeyK' | 'KeyL' | 'KeyM' | 'KeyN' | 'KeyO' | 'KeyP' | 'KeyQ' | 'KeyR' | 'KeyS' | 'KeyT' | 'KeyU' | 'KeyV' | 'KeyW' | 'KeyX' | 'KeyY' | 'KeyZ' | 'MetaLeft' | 'MetaRight' | 'ContextMenu' | 'NumpadMultiply' | 'NumpadAdd' | 'NumpadSubtract' | 'NumpadDivide' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | 'F13' | 'F14' | 'F15' | 'F16' | 'F17' | 'F18' | 'F19' | 'F20' | 'F21' | 'F22' | 'F23' | 'F24' | 'NumLock' | 'ScrollLock' | 'AudioVolumeMute' | 'AudioVolumeDown' | 'AudioVolumeUp' | 'MediaTrackNext' | 'MediaTrackPrevious' | 'MediaStop' | 'MediaPlayPause' | 'Semicolon' | 'Equal' | 'NumpadEqual' | 'Comma' | 'Minus' | 'Period' | 'Slash' | 'Backquote' | 'BracketLeft' | 'Backslash' | 'BracketRight' | 'Quote' | 'AltGraph' | 'Props' | 'Cancel' | 'Clear' | 'Shift' | 'Control' | 'Alt' | 'Accept' | 'ModeChange' | ' ' | 'Print' | 'Execute' | '\u0000' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | 'Meta' | '*' | '+' | '-' | '/' | ';' | '=' | ',' | '.' | '`' | '[' | '\\' | ']' | "'" | 'Attn' | 'CrSel' | 'ExSel' | 'EraseEof' | 'Play' | 'ZoomOut' | ')' | '!' | '@' | '#' | '$' | '%' | '^' | '&' | '(' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | ':' | '<' | '_' | '>' | '?' | '~' | '{' | '|' | '}' | '"' | 'SoftLeft' | 'SoftRight' | 'Camera' | 'Call' | 'EndCall' | 'VolumeDown' | 'VolumeUp';
+export type MouseButton = 'left' | 'right' | 'middle';
+export interface MouseAction {
+    click: (x: number, y: number, options: {
+        button: MouseButton;
+        count?: number;
+    }) => Promise<void>;
+    wheel: (deltaX: number, deltaY: number) => Promise<void>;
+    move: (x: number, y: number) => Promise<void>;
+    drag: (from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }) => Promise<void>;
+}
+export interface KeyboardAction {
+    type: (text: string) => Promise<void>;
+    press: (action: {
+        key: KeyInput;
+        command?: string;
+    } | {
+        key: KeyInput;
+        command?: string;
+    }[]) => Promise<void>;
+}
+export interface ChromePageDestroyOptions {
+    closeTab?: boolean;
+}
+export declare abstract class AbstractWebPage extends AbstractInterface {
+    get mouse(): MouseAction;
+    get keyboard(): KeyboardAction;
+    clearInput(element: ElementInfo): Promise<void>;
+    abstract scrollUntilTop(startingPoint?: Point): Promise<void>;
+    abstract scrollUntilBottom(startingPoint?: Point): Promise<void>;
+    abstract scrollUntilLeft(startingPoint?: Point): Promise<void>;
+    abstract scrollUntilRight(startingPoint?: Point): Promise<void>;
+    abstract scrollUp(distance?: number, startingPoint?: Point): Promise<void>;
+    abstract scrollDown(distance?: number, startingPoint?: Point): Promise<void>;
+    abstract scrollLeft(distance?: number, startingPoint?: Point): Promise<void>;
+    abstract scrollRight(distance?: number, startingPoint?: Point): Promise<void>;
+    abstract longPress(x: number, y: number, duration?: number): Promise<void>;
+    abstract swipe(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, duration?: number): Promise<void>;
+}
+export declare const commonWebActionsForWebPage: <T extends AbstractWebPage>(page: T) => DeviceAction<any>[];

package/package.json

@@ -0,0 +1,164 @@
+{
+  "name": "@rpascene/web",
+  "description": "Automate browser actions, extract data, and perform assertions using AI. It offers JavaScript SDK, Chrome extension, and support for scripting in YAML.",
+  "keywords": [
+    "AI UI automation",
+    "AI testing",
+    "Computer use",
+    "Browser use",
+    "Android use"
+  ],
+  "version": "0.30.8",
+  "repository": "",
+  "homepage": "",
+  "main": "./dist/lib/index.js",
+  "types": "./dist/types/index.d.ts",
+  "module": "./dist/es/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/lib/index.js",
+      "import": "./dist/es/index.mjs"
+    },
+    "./bridge-mode": {
+      "types": "./dist/types/bridge-mode/index.d.ts",
+      "require": "./dist/lib/bridge-mode/index.js",
+      "import": "./dist/es/bridge-mode/index.mjs"
+    },
+    "./bridge-mode-browser": {
+      "types": "./dist/types/bridge-mode/browser.d.ts",
+      "require": "./dist/lib/bridge-mode/browser.js",
+      "import": "./dist/es/bridge-mode/browser.mjs"
+    },
+    "./utils": {
+      "types": "./dist/types/common/utils.d.ts",
+      "require": "./dist/lib/common/utils.js",
+      "import": "./dist/es/common/utils.mjs"
+    },
+    "./ui-utils": {
+      "types": "./dist/types/common/ui-utils.d.ts",
+      "require": "./dist/lib/common/ui-utils.js",
+      "import": "./dist/es/common/ui-utils.mjs"
+    },
+    "./puppeteer": {
+      "types": "./dist/types/puppeteer/index.d.ts",
+      "require": "./dist/lib/puppeteer/index.js",
+      "import": "./dist/es/puppeteer/index.mjs"
+    },
+    "./puppeteer-agent-launcher": {
+      "types": "./dist/types/puppeteer/agent-launcher.d.ts",
+      "require": "./dist/lib/puppeteer/agent-launcher.js",
+      "import": "./dist/es/puppeteer/agent-launcher.mjs"
+    },
+    "./playwright": {
+      "types": "./dist/types/playwright/index.d.ts",
+      "require": "./dist/lib/playwright/index.js",
+      "import": "./dist/es/playwright/index.mjs"
+    },
+    "./playwright-report": {
+      "types": "./dist/types/playwright/reporter/index.d.ts",
+      "require": "./dist/lib/playwright/reporter/index.js",
+      "import": "./dist/es/playwright/reporter/index.mjs"
+    },
+    "./playwright-reporter": {
+      "types": "./dist/types/playwright/reporter/index.d.ts",
+      "require": "./dist/lib/playwright/reporter/index.js",
+      "import": "./dist/es/playwright/reporter/index.mjs"
+    },
+    "./chrome-extension": {
+      "types": "./dist/types/chrome-extension/index.d.ts",
+      "require": "./dist/lib/chrome-extension/index.js",
+      "import": "./dist/es/chrome-extension/index.mjs"
+    },
+    "./yaml": {
+      "types": "./dist/types/yaml/index.d.ts",
+      "require": "./dist/lib/yaml/index.js",
+      "import": "./dist/es/yaml/index.mjs"
+    },
+    "./agent": {
+      "types": "./dist/types/common/agent.d.ts",
+      "require": "./dist/lib/common/agent.js",
+      "import": "./dist/es/common/agent.mjs"
+    },
+    "./static": {
+      "types": "./dist/types/static/index.d.ts",
+      "require": "./dist/lib/static/index.js",
+      "import": "./dist/es/static/index.mjs"
+    }
+  },
+  "watch": {
+    "build": {
+      "patterns": ["src"],
+      "extensions": "tsx,less,scss,css,js,jsx,ts",
+      "quiet": false
+    }
+  },
+  "scripts": {
+    "dev": "npm run build && npx npm-watch",
+    "dev:server": "npm run build && ./bin/rpascene-playground",
+    "build": "rslib build",
+    "build:watch": "rslib build --watch",
+    "playground": "DEBUG=rpascene:* tsx demo/playground.ts",
+    "test": "vitest --run",
+    "test:u": "vitest --run -u",
+    "test:ai": "AI_TEST_TYPE=web npm run test",
+    "test:ai:cache": "RPASCENE_CACHE=true npm run test:ai",
+    "e2e": "playwright test --config=tests/playwright.config.ts",
+    "e2e:report": "RPASCENE_REPORT=true playwright test --config=tests/playwright.config.ts",
+    "e2e:cache": "RPASCENE_CACHE=true playwright test --config=tests/playwright.config.ts",
+    "e2e:ui": "playwright test --config=tests/playwright.config.ts --ui",
+    "e2e:ui:cache": "RPASCENE_CACHE=true playwright test --config=tests/playwright.config.ts --ui"
+  },
+  "bin": {
+    "rpascene-playground": "./bin/rpascene-playground"
+  },
+  "files": ["static", "dist", "iife-script", "README.md", "bin"],
+  "dependencies": {
+    "@rpascene/core": "workspace:*",
+    "@rpascene/playground": "workspace:*",
+    "@rpascene/shared": "workspace:*",
+    "cors": "^2.8.5",
+    "dayjs": "^1.11.11",
+    "dotenv": "^16.4.5",
+    "http-server": "14.1.1",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "4.8.1"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "4.0.9",
+    "devtools-protocol": "0.0.1380148",
+    "@playwright/test": "^1.44.1",
+    "@rslib/core": "^0.11.2",
+    "@types/chrome": "0.0.279",
+    "@types/cors": "^2.8.17",
+    "@types/http-server": "^0.12.4",
+    "@types/node": "^18.0.0",
+    "playwright": "1.44.1",
+    "puppeteer": "24.2.0",
+    "js-yaml": "4.1.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.8.3",
+    "vitest": "3.0.5"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.44.1",
+    "playwright": "^1.44.1",
+    "puppeteer": ">=20.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    },
+    "puppeteer": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "license": "MIT"
+}