@kogeet/sagent-playwright 0.1.0

package/bin/core/Core.d.ts

@@ -0,0 +1,61 @@
+import type { Page } from "playwright";
+import { chromium, firefox, webkit } from "playwright";
+import type { BrowserContextOptions } from "playwright-core";
+type Navigator = typeof chromium | typeof firefox | typeof webkit;
+declare class CoreBrowser {
+    private browser;
+    private ctx;
+    private idxActivePage;
+    /**
+     * **Launch browser and retrieve appropriate context**
+     * @param navig chromium or firefox or webkit
+     * @param device kind of device (ex : iPhone11, Desktop Firefox, ...)
+     * @param channel required for some devices : chrome or firefox or msedge
+     */
+    createBrowser(navig: Navigator, device: BrowserContextOptions | undefined, channel?: string | undefined): Promise<void>;
+    /**
+     * **Create a new page and activate it**
+     */
+    createPage(): Promise<Page | undefined>;
+    /**
+     * **Return current active page**
+     *
+     * return 'undefined' if there is no active page
+     */
+    getActivePage(): Page | undefined;
+    /**
+     * **Return the handle of the current active page**
+     *
+     * The handle is a number converted to string
+     */
+    getCurrentPageHandle(): string;
+    /**
+     * **Switch to another existing page and activate it**
+     *
+     * Return false if handle does not match any page, otherwise return true.
+     * @param handle String that is a unique page identifier
+     */
+    switchToPage(handle: string): Promise<boolean>;
+    /**
+     * **Return a promise for a new page**
+     *
+     * To be used with ***switchToNewPage***
+     */
+    pagePromise(): Promise<Page> | undefined;
+    /**
+     * **Switch to a new page opened on another tab by a previous action**
+     * @param pagePromise the promise of new page
+     */
+    switchToNewPage(pagePromise: Promise<Page>): Promise<void>;
+    /**
+     * **Wait current active page to be loaded**
+     */
+    waitForLoadActivePage(): Promise<void>;
+    /**
+     * **Close browser**
+     */
+    close(): Promise<void>;
+}
+declare const core: CoreBrowser;
+export default core;
+//# sourceMappingURL=Core.d.ts.map

package/bin/core/Core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Core.d.ts","sourceRoot":"","sources":["../../src/core/Core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA0B,IAAI,EAAC,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAC,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,iBAAiB,CAAC;AAE3D,KAAK,SAAS,GAAG,OAAO,QAAQ,GAAG,OAAO,OAAO,GAAG,OAAO,MAAM,CAAA;AAEjE,cAAM,WAAW;IACf,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,GAAG,CAA4B;IACvC,OAAO,CAAC,aAAa,CAAe;IAEpC;;;;;OAKG;IACU,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,qBAAqB,GAAG,SAAS,EAAE,OAAO,GAAC,MAAM,GAAC,SAAqB;IAK5H;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAUpD;;;;OAIG;IACI,aAAa,IAAI,IAAI,GAAG,SAAS;IAOxC;;;;OAIG;IACI,oBAAoB;IAI3B;;;;;OAKG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAY3D;;;;OAIG;IACI,WAAW;IAIlB;;;OAGG;IACU,eAAe,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC;IASvD;;OAEG;IACU,qBAAqB;IAOlC;;OAEG;IACU,KAAK;CAQnB;AAED,QAAA,MAAM,IAAI,aAAoB,CAAA;AAC9B,eAAe,IAAI,CAAA"}

package/bin/core/Core.js

@@ -0,0 +1,108 @@
+import { chromium, firefox, webkit } from "playwright";
+class CoreBrowser {
+    browser;
+    ctx;
+    idxActivePage = '-1';
+    /**
+     * **Launch browser and retrieve appropriate context**
+     * @param navig chromium or firefox or webkit
+     * @param device kind of device (ex : iPhone11, Desktop Firefox, ...)
+     * @param channel required for some devices : chrome or firefox or msedge
+     */
+    async createBrowser(navig, device, channel = undefined) {
+        this.browser = await navig.launch({ channel, headless: false });
+        this.ctx = await this.browser.newContext(device);
+    }
+    /**
+     * **Create a new page and activate it**
+     */
+    async createPage() {
+        if (this.ctx) {
+            const page = await this.ctx.newPage();
+            this.idxActivePage = (this.ctx.pages().length - 1).toString();
+            await page.bringToFront();
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * **Return current active page**
+     *
+     * return 'undefined' if there is no active page
+     */
+    getActivePage() {
+        const idx = Number(this.idxActivePage);
+        if (this.ctx && idx > -1) {
+            return this.ctx.pages()[idx];
+        }
+    }
+    /**
+     * **Return the handle of the current active page**
+     *
+     * The handle is a number converted to string
+     */
+    getCurrentPageHandle() {
+        return this.idxActivePage;
+    }
+    /**
+     * **Switch to another existing page and activate it**
+     *
+     * Return false if handle does not match any page, otherwise return true.
+     * @param handle String that is a unique page identifier
+     */
+    async switchToPage(handle) {
+        const idx = Number(handle);
+        if (this.ctx && idx > -1 && idx <= this.ctx.pages().length) {
+            const page = this.ctx.pages()[idx];
+            await page.bringToFront();
+            this.idxActivePage = handle;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * **Return a promise for a new page**
+     *
+     * To be used with ***switchToNewPage***
+     */
+    pagePromise() {
+        return this.ctx ? this.ctx.waitForEvent('page') : undefined;
+    }
+    /**
+     * **Switch to a new page opened on another tab by a previous action**
+     * @param pagePromise the promise of new page
+     */
+    async switchToNewPage(pagePromise) {
+        const newPage = await pagePromise;
+        await newPage.waitForLoadState('load');
+        await newPage.bringToFront();
+        if (this.ctx) {
+            this.idxActivePage = (this.ctx.pages().length - 1).toString();
+        }
+    }
+    /**
+     * **Wait current active page to be loaded**
+     */
+    async waitForLoadActivePage() {
+        const page = this.getActivePage();
+        if (page) {
+            await page.waitForLoadState();
+        }
+    }
+    /**
+     * **Close browser**
+     */
+    async close() {
+        if (this.ctx) {
+            await this.ctx.close();
+        }
+        if (this.browser) {
+            await this.browser.close();
+        }
+    }
+}
+const core = new CoreBrowser();
+export default core;

package/bin/core/LocatorLib.d.ts

@@ -0,0 +1,4 @@
+import type { StepContext } from "@kogeet/scapin-core-agent";
+import type { Locator } from "playwright";
+export default function uiWrapper(stepCtx: StepContext, callback: (stepCtx: StepContext, elem: Locator) => Promise<boolean>): Promise<boolean>;
+//# sourceMappingURL=LocatorLib.d.ts.map

package/bin/core/LocatorLib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocatorLib.d.ts","sourceRoot":"","sources":["../../src/core/LocatorLib.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAE1E,OAAO,KAAK,EAAe,OAAO,EAAC,MAAM,YAAY,CAAC;AAKtD,wBAA8B,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,oBAchI"}

package/bin/core/LocatorLib.js

@@ -0,0 +1,135 @@
+import { report } from "@kogeet/scapin-core-agent";
+import core from "./Core.js";
+export default async function uiWrapper(stepCtx, callback) {
+    const wl = new LocatorLib(stepCtx.getAllConfigs());
+    const elem = await wl.findLocator();
+    if (elem) {
+        if (await elem.count() > 1) {
+            report.warning('> Found more than one éléments. Take the first one');
+        }
+        return await callback(stepCtx, elem.first());
+    }
+    else {
+        report.warning('No elem found');
+        return false;
+    }
+}
+class LocatorLib {
+    configList;
+    locator = null;
+    frameLocator = null;
+    constructor(configList) {
+        this.configList = configList;
+    }
+    async findLocator() {
+        this.locator = null;
+        if (this.configList && this.configList.length) {
+            for (let idx = 0; idx < this.configList.length; idx++) {
+                const { key, value } = this.configList[idx];
+                let selector = null;
+                let supported_key = true;
+                switch (key) {
+                    case 'id':
+                        selector = `#${value}`;
+                        break;
+                    case 'selector':
+                    case 'iframe':
+                        selector = `${value}`;
+                        break;
+                    case 'class':
+                        selector = `.${value}`;
+                        break;
+                    case 'rank':
+                        await this.nthLocator(value);
+                        break;
+                    case 'name':
+                        selector = `[name="${value}"]`;
+                        break;
+                    case 'role':
+                        selector = `[role="${value}"]`;
+                        break;
+                    case 'exactText':
+                        this.getByText(value, true);
+                        break;
+                    case 'partialText':
+                        this.getByText(value, false);
+                        break;
+                    default:
+                        console.log(`> Mapping ${key} not supported or deprecated`);
+                        supported_key = false;
+                }
+                if (supported_key) {
+                    this.getLocator(idx, selector);
+                    await this.logLocator(key, value);
+                }
+            }
+        }
+        else {
+            // erreur de paramètre
+            report.info('Mapping parameters not found');
+        }
+        return this.locator;
+    }
+    getLocator(idx, selector) {
+        const page = core.getActivePage();
+        if (page) {
+            if (selector) {
+                if (idx === 0) {
+                    this.locator = page.locator(selector);
+                }
+                else if (this.locator) {
+                    this.locator = this.locator.locator(selector);
+                }
+                else if (this.frameLocator) {
+                    this.locator = this.frameLocator.locator(selector);
+                    this.frameLocator = null;
+                }
+                else {
+                    // selector != null && idx > 0 && this.locator = null && this.frameLocator = null
+                    report.info('No such element error');
+                }
+            }
+        }
+        else {
+            report.info('No browser available');
+        }
+    }
+    async logLocator(key, value) {
+        if (this.locator) {
+            try {
+                // Needed for Locator inside an iframe to be found
+                await this.locator.first().waitFor();
+            }
+            catch (e) {
+                console.log(`> [${key}: ${value}] wait for locator failed`);
+                await core.close();
+                throw new Error('LOCATOR_TIMEOUT');
+            }
+            const count = await this.locator.count();
+            console.log(`> [${key}: ${value}] found ${count} éléments`);
+            if (key === 'iframe') {
+                this.frameLocator = this.locator.first().frameLocator(':scope');
+                this.locator = null;
+            }
+        }
+        else {
+            console.log(`> [${key}: ${value}] found 0 éléments`);
+        }
+    }
+    async nthLocator(value) {
+        if (this.locator) {
+            const count = await this.locator.count();
+            let nth = +value - 1;
+            if (nth < 0)
+                nth = 0;
+            if (nth >= count)
+                nth = count - 1;
+            this.locator = this.locator.nth(nth);
+        }
+    }
+    getByText(value, exact) {
+        if (this.locator) {
+            this.locator = this.locator.getByText(value, { exact });
+        }
+    }
+}

package/bin/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/bin/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// La ligne ci-dessus est requise pour que la commande sagent-playwright fonctionne
+// après installation du package en global
+import { sagent } from "@kogeet/scapin-core-agent";
+import * as fs from "fs";
+import BrowserLib from "./libs/BrowserLib.js";
+import StdLib from "./libs/StdLib.js";
+import DatasetEntryPoints from "@kogeet/sagent-plugin-dataset";
+const loadJSON = (path) => JSON.parse(fs.readFileSync(new URL(path, import.meta.url)).toString());
+const pjson = loadJSON('../package.json');
+// Librairies prises en charge
+sagent.use('BrowserLib', BrowserLib.entryPoints);
+sagent.use('StdLib', StdLib.entryPoints);
+sagent.use('DatasetLib', DatasetEntryPoints);
+console.log('Starting Scapin Playwright Agent version', pjson.version);
+sagent.listen();

package/bin/libs/BrowserLib.d.ts

@@ -0,0 +1,19 @@
+import { StepContext } from "@kogeet/scapin-core-agent";
+export default class BrowserLib {
+    static entryPoints: Map<string, typeof BrowserLib.BrowserRunToURL>;
+    static BrowserRunToURL(stepCtx: StepContext): Promise<boolean>;
+    static BrowserQuit(): Promise<boolean>;
+    static BrowserGotoURL(stepCtx: StepContext): Promise<boolean>;
+    static BrowserBack(): Promise<boolean>;
+    static BrowserForward(): Promise<boolean>;
+    static BrowserGetTitle(stepCtx: StepContext): Promise<boolean>;
+    static BrowserHasTitle(stepCtx: StepContext): Promise<boolean>;
+    static BrowserRefresh(): Promise<boolean>;
+    static BrowserTabToUrl(stepCtx: StepContext): Promise<boolean>;
+    static BrowserWindowToUrl(stepCtx: StepContext): Promise<boolean>;
+    static BrowserSwitch(stepCtx: StepContext): Promise<boolean>;
+    static BrowserGetCurrentURL(stepCtx: StepContext): Promise<boolean>;
+    private static goToUrl;
+    private static browserToUrl;
+}
+//# sourceMappingURL=BrowserLib.d.ts.map

package/bin/libs/BrowserLib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserLib.d.ts","sourceRoot":"","sources":["../../src/libs/BrowserLib.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAIvE,MAAM,CAAC,OAAO,OAAO,UAAU;IAE7B,OAAc,WAAW,iDAavB;WAEkB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WAsCvD,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;WAU/B,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WAUtD,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;WAgB/B,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;WAgBlC,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WAiBvD,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WAiBvD,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;WAgBlC,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WAQvD,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WAM1D,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;WASrD,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;mBAiB3D,OAAO;mBAWP,YAAY;CAYlC"}

package/bin/libs/BrowserLib.js

@@ -0,0 +1,220 @@
+import { context, report, StepContext } from "@kogeet/scapin-core-agent";
+import { chromium, devices, firefox } from "playwright";
+import core from "../core/Core.js";
+export default class BrowserLib {
+    static entryPoints = new Map([
+        ['browserRunToURL', BrowserLib.BrowserRunToURL],
+        ['browserQuit', BrowserLib.BrowserQuit],
+        ['browserGotoURL', BrowserLib.BrowserGotoURL],
+        ['browserBack', BrowserLib.BrowserBack],
+        ['browserForward', BrowserLib.BrowserForward],
+        ['browserGetTitle', BrowserLib.BrowserGetTitle],
+        ['browserHasTitle', BrowserLib.BrowserHasTitle],
+        ['browserRefresh', BrowserLib.BrowserRefresh],
+        ['browserWin2Url', BrowserLib.BrowserWindowToUrl],
+        ['browserTab2Url', BrowserLib.BrowserTabToUrl],
+        ['browserSwitch', BrowserLib.BrowserSwitch],
+        ['browserGetCurrentURL', BrowserLib.BrowserGetCurrentURL]
+    ]);
+    static async BrowserRunToURL(stepCtx) {
+        // Récupération des paramètres
+        const browserName = stepCtx.getStringParam('0');
+        const url = (stepCtx.getStringParam('1')).toLowerCase();
+        // Exécution
+        try {
+            switch (browserName) {
+                case 'chrome':
+                    await core.createBrowser(chromium, { ...devices['Desktop Chrome'] }, 'chrome');
+                    break;
+                case 'firefox':
+                    await core.createBrowser(firefox, { ...devices['Desktop Firefox'] }, 'firefox');
+                    break;
+                case 'msedge':
+                    await core.createBrowser(chromium, { ...devices['Desktop Edge'] }, 'msedge');
+                    break;
+                case 'pixel5':
+                    await core.createBrowser(chromium, { ...devices['Pixel 5'] });
+                    break;
+                case 'pixel5L':
+                    await core.createBrowser(chromium, { ...devices['Pixel 5 landscape'] });
+                    break;
+                default:
+                    report.error(`LaunchToUrl value '${browserName}' is invalid for Browser parameter`);
+                    return false;
+            }
+            await core.createPage();
+            context.setVariable(stepCtx.getStringParam('2'), core.getCurrentPageHandle());
+            return await BrowserLib.goToUrl(url, 'LaunchToUrl');
+        }
+        catch (e) {
+            report.error(`LaunchToUrl error for '${browserName}' : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserQuit() {
+        try {
+            await core.close();
+            return true;
+        }
+        catch (e) {
+            report.error(`Quit browser error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserGotoURL(stepCtx) {
+        const url = stepCtx.getStringParam('0');
+        try {
+            return await BrowserLib.goToUrl(url, 'GoToUrl');
+        }
+        catch (e) {
+            report.error(`GoToUrl error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserBack() {
+        try {
+            const page = core.getActivePage();
+            if (page) {
+                await page.goBack();
+                return true;
+            }
+            else {
+                report.error(`Back unexpected error : There is no active page`);
+                return false;
+            }
+        }
+        catch (e) {
+            report.error(`Back error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserForward() {
+        try {
+            const page = core.getActivePage();
+            if (page) {
+                await page.goForward();
+                return true;
+            }
+            else {
+                report.error(`Forward unexpected error : There is no active page`);
+                return false;
+            }
+        }
+        catch (e) {
+            report.error(`Forward error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserGetTitle(stepCtx) {
+        try {
+            const page = core.getActivePage();
+            if (page) {
+                const title = await page.title();
+                context.setVariable(stepCtx.getStringParam('0'), title);
+                return true;
+            }
+            else {
+                report.error(`GetTitle unexpected error : There is no active page`);
+                return false;
+            }
+        }
+        catch (e) {
+            report.error(`GetTitle error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserHasTitle(stepCtx) {
+        try {
+            const page = core.getActivePage();
+            if (page) {
+                const title = await page.title();
+                return stepCtx.getStringParam('0') === title;
+            }
+            else {
+                report.error(`HasTitle unexpected error : There is no active page`);
+                return false;
+            }
+        }
+        catch (e) {
+            report.error(`HasTitle error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserRefresh() {
+        try {
+            const page = core.getActivePage();
+            if (page) {
+                await page.reload();
+                return true;
+            }
+            else {
+                report.error(`Refresh unexpected error : There is no active page`);
+                return false;
+            }
+        }
+        catch (e) {
+            report.error(`Refresh error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserTabToUrl(stepCtx) {
+        const url = stepCtx.getStringParam('0');
+        const varName = stepCtx.getStringParam('1');
+        return await BrowserLib.browserToUrl(url, varName, 'OpenTabToUrl');
+    }
+    // 'BrowserWindowToUrl' est maintenu pour des raisons de compatibilité avec Selenium
+    // mais fait la même chose que 'BrowserTabToUrl'
+    static async BrowserWindowToUrl(stepCtx) {
+        const url = stepCtx.getStringParam('0');
+        const varName = stepCtx.getStringParam('1');
+        return await BrowserLib.browserToUrl(url, varName, 'OpenWindowToUrl');
+    }
+    static async BrowserSwitch(stepCtx) {
+        try {
+            return core.switchToPage(stepCtx.getStringParam('0'));
+        }
+        catch (e) {
+            report.error(`SwitchTo error : ${e.message}`);
+            return false;
+        }
+    }
+    static async BrowserGetCurrentURL(stepCtx) {
+        try {
+            const page = core.getActivePage();
+            if (page) {
+                context.setVariable(stepCtx.getStringParam('0'), page.url());
+                return true;
+            }
+            else {
+                report.error(`GetTabUrl unexpected error : There is no active page`);
+                return false;
+            }
+        }
+        catch (e) {
+            report.error(`GetTabUrl error : ${e.message}`);
+            return false;
+        }
+    }
+    static async goToUrl(url, fromMsg = '') {
+        const page = core.getActivePage();
+        if (page) {
+            await page.goto(url);
+            return true;
+        }
+        else {
+            report.error(`${fromMsg} unexpected error : There is no active page`);
+            return false;
+        }
+    }
+    static async browserToUrl(url, varName, fromMsg) {
+        try {
+            await core.createPage();
+            context.setVariable(varName, core.getCurrentPageHandle());
+            return await BrowserLib.goToUrl(url, fromMsg);
+        }
+        catch (e) {
+            report.error(`${fromMsg} error : ${e.message}`);
+            return false;
+        }
+    }
+}

package/bin/libs/StdLib.d.ts

@@ -0,0 +1,75 @@
+import type { StepContext } from "@kogeet/scapin-core-agent";
+export default class StdLib {
+    static entryPoints: Map<string, typeof StdLib.elemClick>;
+    /**
+     * **Implémentation de l'instruction d'action Click**
+     * @param stepCtx Paramètre du step
+     */
+    static elemClick(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action InputText**
+     * @param stepCtx Paramètre du step
+     */
+    static elemSetText(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action GetText**
+     *
+     * Retrieve the text of an element
+     * @param stepCtx Paramètre du step
+     */
+    static elemGetText(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction de contrôle HasText**
+     *
+     * Renvoie *true* si le texte passé en paramètre est celui de l'élément
+     * @param stepCtx Paramètre du step
+     */
+    static elemHasText(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction de contrôle IsVisible**
+     * @param stepCtx Paramètre du step
+     */
+    static elemIsVisible(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction de contrôle IsEnabled**
+     * @param stepCtx Paramètre du step
+     */
+    static elemIsEnabled(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction de contrôle HasState**
+     *
+     * Contrôle l'état coché ou non d'une checkbox ou d'un radio-bouton
+     * @param stepCtx Paramètre du step
+     */
+    static elemHasState(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action GetState**
+     *
+     * Récupère l'état coché ou décoché d'une checkbox ou d'un radio-bouton
+     * @param stepCtx Paramètre du step
+     */
+    static elemGetState(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action setState**
+     *
+     * Coche ou décoche une checkbox ou un radio-bouton
+     * @param stepCtx Paramètre du step
+     */
+    static elemSetState(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action ClickAndOpen**
+     * @param stepCtx Paramètre du step
+     */
+    static elemClickToNew(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action setTimer**
+     * @param stepCtx Paramètre du step
+     */
+    static wait(stepCtx: StepContext): Promise<boolean>;
+    /**
+     * **Implémentation de l'instruction d'action Calculator**
+     * @param stepCtx Paramètre du step
+     */
+    static calculator(stepCtx: StepContext): Promise<boolean>;
+}
+//# sourceMappingURL=StdLib.d.ts.map

package/bin/libs/StdLib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StdLib.d.ts","sourceRoot":"","sources":["../../src/libs/StdLib.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAM3D,MAAM,CAAC,OAAO,OAAO,MAAM;IAEzB,OAAc,WAAW,uCAavB;IAEF;;;OAGG;WACiB,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAarE;;;OAGG;WACiB,WAAW,CAAC,OAAO,EAAE,WAAW;IAiBpD;;;;;OAKG;WACiB,WAAW,CAAC,OAAO,EAAE,WAAW;IAapD;;;;;OAKG;WACiB,WAAW,CAAC,OAAO,EAAE,WAAW;IAqBpD;;;OAGG;WACiB,aAAa,CAAC,OAAO,EAAE,WAAW;IAYtD;;;OAGG;WACiB,aAAa,CAAC,OAAO,EAAE,WAAW;IAYtD;;;;;OAKG;WACiB,YAAY,CAAC,OAAO,EAAE,WAAW;IAarD;;;;;OAKG;WACiB,YAAY,CAAC,OAAO,EAAE,WAAW;IAYrD;;;;;OAKG;WACiB,YAAY,CAAC,OAAO,EAAE,WAAW;IAgBrD;;;OAGG;WACiB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB1E;;;OAGG;WACiB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAMhE;;;OAGG;WACiB,UAAU,CAAC,OAAO,EAAE,WAAW;CAkCpD"}

package/bin/libs/StdLib.js

@@ -0,0 +1,234 @@
+import uiWrapper from "../core/LocatorLib.js";
+import { context, report } from "@kogeet/scapin-core-agent";
+import core from "../core/Core.js";
+export default class StdLib {
+    static entryPoints = new Map([
+        ['elemClick', StdLib.elemClick],
+        ['elemSetText', StdLib.elemSetText],
+        ['elemGetText', StdLib.elemGetText],
+        ['elemHasText', StdLib.elemHasText],
+        ['elemIsVisible', StdLib.elemIsVisible],
+        ['elemIsEnabled', StdLib.elemIsEnabled],
+        ['elemHasState', StdLib.elemHasState],
+        ['elemGetState', StdLib.elemGetState],
+        ['elemSetState', StdLib.elemSetState],
+        ['elemClickToNew', StdLib.elemClickToNew],
+        ['wait', StdLib.wait],
+        ['calculator', StdLib.calculator]
+    ]);
+    /**
+     * **Implémentation de l'instruction d'action Click**
+     * @param stepCtx Paramètre du step
+     */
+    static async elemClick(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                await elem.click();
+                await core.waitForLoadActivePage();
+                return true;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'Click' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction d'action InputText**
+     * @param stepCtx Paramètre du step
+     */
+    static async elemSetText(stepCtx) {
+        const text = stepCtx.getStringParam('0', '');
+        // const clickBefore = stepCtx.getParam('1', true) Obsolète avec Playwright
+        // const eraseBefore = stepCtx.getParam('2', false) Obsolète avec Playwright
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                await elem.fill(text);
+                return true;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'InputText' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction d'action GetText**
+     *
+     * Retrieve the text of an element
+     * @param stepCtx Paramètre du step
+     */
+    static async elemGetText(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                const text = await elem.innerText();
+                context.setVariable(stepCtx.getStringParam('0'), text);
+                return true;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'GetText' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction de contrôle HasText**
+     *
+     * Renvoie *true* si le texte passé en paramètre est celui de l'élément
+     * @param stepCtx Paramètre du step
+     */
+    static async elemHasText(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                const text = await elem.innerText();
+                let pattern = stepCtx.getStringParam('0');
+                if (stepCtx.getParam('1', false) === true) {
+                    pattern = `^${pattern}$`;
+                }
+                const regex = new RegExp(pattern);
+                const found = text.match(regex);
+                return !!found;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'HasText' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction de contrôle IsVisible**
+     * @param stepCtx Paramètre du step
+     */
+    static async elemIsVisible(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                const elemVisible = await elem.isVisible();
+                return elemVisible === stepCtx.getParam('0', true);
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'IsVisible' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction de contrôle IsEnabled**
+     * @param stepCtx Paramètre du step
+     */
+    static async elemIsEnabled(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                const elemEnabled = await elem.isEnabled();
+                return elemEnabled === stepCtx.getParam('0', true);
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'IsEnabled' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction de contrôle HasState**
+     *
+     * Contrôle l'état coché ou non d'une checkbox ou d'un radio-bouton
+     * @param stepCtx Paramètre du step
+     */
+    static async elemHasState(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                const state = await elem.isChecked();
+                return state === stepCtx.getParam('0', true);
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'HasState' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction d'action GetState**
+     *
+     * Récupère l'état coché ou décoché d'une checkbox ou d'un radio-bouton
+     * @param stepCtx Paramètre du step
+     */
+    static async elemGetState(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                context.setVariable(stepCtx.getStringParam('0'), await elem.isChecked());
+                return true;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'GetState' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction d'action setState**
+     *
+     * Coche ou décoche une checkbox ou un radio-bouton
+     * @param stepCtx Paramètre du step
+     */
+    static async elemSetState(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                if (stepCtx.getParam('0', true)) {
+                    await elem.check();
+                }
+                else {
+                    await elem.uncheck();
+                }
+                return true;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'SetState' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction d'action ClickAndOpen**
+     * @param stepCtx Paramètre du step
+     */
+    static async elemClickToNew(stepCtx) {
+        return await uiWrapper(stepCtx, async (stepCtx, elem) => {
+            try {
+                const pagePromise = core.pagePromise();
+                if (pagePromise) {
+                    await elem.click();
+                    await core.switchToNewPage(pagePromise);
+                    context.setVariable(stepCtx.getStringParam('0'), core.getCurrentPageHandle());
+                }
+                return true;
+            }
+            catch (e) {
+                report.warning(`Paywright error on 'ClickAndOpen' instruction : ${e.message}`);
+                return false;
+            }
+        });
+    }
+    /**
+     * **Implémentation de l'instruction d'action setTimer**
+     * @param stepCtx Paramètre du step
+     */
+    static async wait(stepCtx) {
+        const t = stepCtx.getParam('0', stepCtx.getConfig('0', 0));
+        await delay(t);
+        return true;
+    }
+    /**
+     * **Implémentation de l'instruction d'action Calculator**
+     * @param stepCtx Paramètre du step
+     */
+    static async calculator(stepCtx) {
+        context.setVariable(stepCtx.getStringParam('1'), stepCtx.getParam('0'));
+        return true;
+    }
+}
+function delay(t) {
+    return new Promise((done) => {
+        setTimeout(() => {
+            done();
+        }, t);
+    });
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kogeet/sagent-playwright",
+  "version": "0.1.0",
+  "description": "Scapin Agent for Playwright",
+  "main": "bin/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^18.17.1"
+  },
+  "scripts": {
+    "build": "tsc --sourceMap false --declaration true",
+    "termprod": "npm run build && node bin/index.js",
+    "np": "np --no-tests --message=sagent-playwright-%s"
+  },
+  "author": "Loïc Griveau",
+  "license": "MIT",
+  "dependencies": {
+    "@kogeet/sagent-plugin-dataset": "^0.1.1",
+    "@kogeet/scapin-core-agent": "^0.1.5",
+    "@playwright/browser-chromium": "^1.39.0",
+    "@playwright/browser-firefox": "^1.39.0",
+    "@playwright/browser-webkit": "^1.39.0",
+    "playwright": "^1.39.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.10",
+    "@typescript-eslint/eslint-plugin": "^6.8.0",
+    "@typescript-eslint/parser": "^6.8.0",
+    "eslint": "^8.51.0",
+    "typescript": "^5.2.2"
+  },
+  "type": "module",
+  "bin": {
+    "sagent-playwright": "bin/index.js"
+  }
+}