@auto-wiz/puppeteer 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./runner";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./runner"), exports);

package/dist/runner.d.ts

@@ -0,0 +1,8 @@
+import { type FlowRunner, type RunResult, type ExecutionResult, type RunnerOptions, type Flow, type Step } from "@auto-wiz/core";
+import { Page } from "puppeteer";
+export declare class PuppeteerFlowRunner implements FlowRunner<Page> {
+    run(flow: Flow, page: Page, options?: RunnerOptions): Promise<RunResult>;
+    runStep(step: Step, page: Page, options?: RunnerOptions): Promise<ExecutionResult>;
+    private getSelector;
+    private getElement;
+}

package/dist/runner.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerFlowRunner = void 0;
+class PuppeteerFlowRunner {
+    async run(flow, page, options = {}) {
+        const extractedData = {};
+        for (const [index, step] of flow.steps.entries()) {
+            try {
+                const result = await this.runStep(step, page, options);
+                if (!result.success) {
+                    if (options.stopOnError !== false) {
+                        return {
+                            success: false,
+                            error: result.error,
+                            failedStepIndex: index,
+                            extractedData,
+                        };
+                    }
+                }
+                if (result.extractedData) {
+                    extractedData[`step_${index}`] = result.extractedData;
+                }
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error.message,
+                    failedStepIndex: index,
+                    extractedData,
+                };
+            }
+        }
+        return { success: true, extractedData };
+    }
+    async runStep(step, page, options = {}) {
+        const timeout = options.timeout || 5000;
+        try {
+            switch (step.type) {
+                case "navigate":
+                    if (step.url) {
+                        await page.goto(step.url, { timeout });
+                    }
+                    break;
+                case "click": {
+                    const el = await this.getElement(page, step, timeout);
+                    await el.click();
+                    break;
+                }
+                case "type": {
+                    const el = await this.getElement(page, step, timeout);
+                    const text = step.text || step.originalText || "";
+                    await el.type(text);
+                    if (step.submit) {
+                        await page.keyboard.press("Enter");
+                    }
+                    break;
+                }
+                case "select": {
+                    const selector = this.getSelector(step);
+                    // Puppeteer select uses selector string, not element handle usually
+                    if (step.value) {
+                        // Need to wait for it first
+                        await page.waitForSelector(selector, { timeout });
+                        await page.select(selector, step.value);
+                    }
+                    break;
+                }
+                case "extract": {
+                    const selector = this.getSelector(step);
+                    await page.waitForSelector(selector, { timeout });
+                    // Extract text
+                    const text = await page.$eval(selector, (el) => el.textContent);
+                    return { success: true, extractedData: text?.trim() };
+                }
+                case "waitFor": {
+                    if (step.selector || step.locator) {
+                        const selector = this.getSelector(step);
+                        await page.waitForSelector(selector, {
+                            visible: true,
+                            timeout: step.timeoutMs || timeout,
+                        });
+                    }
+                    else if (step.timeoutMs) {
+                        await new Promise((r) => setTimeout(r, step.timeoutMs));
+                    }
+                    break;
+                }
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    getSelector(step) {
+        if ("locator" in step && step.locator) {
+            const { primary } = step.locator;
+            return primary;
+        }
+        if ("selector" in step && step.selector) {
+            return step.selector;
+        }
+        throw new Error(`Step ${step.type} requires a selector or locator`);
+    }
+    async getElement(page, step, timeout) {
+        const selector = this.getSelector(step);
+        const element = await page.waitForSelector(selector, {
+            visible: true,
+            timeout,
+        });
+        if (!element)
+            throw new Error(`Element not found: ${selector}`);
+        return element;
+    }
+}
+exports.PuppeteerFlowRunner = PuppeteerFlowRunner;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@auto-wiz/puppeteer",
+  "version": "1.0.0",
+  "license": "MIT",
+  "author": "JaeSang",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JaeSang1998/automation-wizard.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "puppeteer": "^23.0.0",
+    "@auto-wiz/core": "1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}