@auto-wiz/dom 1.0.2 → 1.1.1

package/dist/runner.d.ts

@@ -1,6 +1,5 @@
 import { type FlowRunner, type RunResult, type ExecutionResult, type RunnerOptions, type Flow, type Step } from "@auto-wiz/core";
 export declare class DomFlowRunner implements FlowRunner<void> {
-    run(flow: Flow, _context?: any, // unused
-    _options?: RunnerOptions): Promise<RunResult>;
-    runStep(step: Step): Promise<ExecutionResult>;
+    run(flow: Flow, _context?: any, options?: RunnerOptions): Promise<RunResult>;
+    runStep(step: Step, _context?: void, options?: RunnerOptions): Promise<ExecutionResult>;
 }

package/dist/runner.js

@@ -1,14 +1,12 @@
 import { executeStep } from "./steps/stepExecution";
 export class DomFlowRunner {
-    async run(flow, _context = {}, // unused
-    _options = {} // unused
-    ) {
+    async run(flow, _context = {}, options = {}) {
         const extractedData = {};
         const steps = flow.steps;
         for (let i = 0; i < steps.length; i++) {
             const step = steps[i];
             try {
-                const result = await this.runStep(step);
+                const result = await this.runStep(step, undefined, options);
                 if (!result.success) {
                     return {
                         success: false,
@@ -32,10 +30,10 @@ export class DomFlowRunner {
         }
         return { success: true, extractedData };
     }
-    async runStep(step) {
+    async runStep(step, _context, options = {}) {
         try {
             // Direct DOM execution using existing logic
-            const result = await executeStep(step);
+            const result = await executeStep(step, options);
             return result;
         }
         catch (error) {

package/dist/steps/stepExecution.d.ts

@@ -1,11 +1,10 @@
-import type { Step } from "@auto-wiz/core";
+import type { Step, RunnerOptions } from "@auto-wiz/core";
 /**
  * Step execution 유틸리티
  * 각 Step 타입별 실행 로직
  *
- * 새로운 locator 시스템 지원:
- * - step.locator가 있으면 다중 selector fallback 사용
- * - 없으면 기존 step.selector 사용 (하위 호환성)
+ * locator 시스템 사용:
+ * - step.locator의 다중 selector fallback 사용
  */
 export interface ExecutionResult {
     success: boolean;
@@ -20,7 +19,7 @@ export declare function executeClickStep(step: Step): Promise<ExecutionResult>;
 /**
  * Type step 실행
  */
-export declare function executeTypeStep(step: Step): Promise<ExecutionResult>;
+export declare function executeTypeStep(step: Step, options?: RunnerOptions): Promise<ExecutionResult>;
 /**
  * Select step 실행
  */
@@ -36,4 +35,4 @@ export declare function executeWaitForStep(step: Step): Promise<ExecutionResult>
 /**
  * Step 실행 (타입에 따라 자동 분기)
  */
-export declare function executeStep(step: Step): Promise<ExecutionResult>;
+export declare function executeStep(step: Step, options?: RunnerOptions): Promise<ExecutionResult>;

package/dist/steps/stepExecution.js

@@ -1,30 +1,23 @@
-import { querySelector } from "../selectors/selectorGenerator";
 import { waitForLocator, isInteractable } from "../selectors/locatorUtils";
 /**
- * Step에서 요소 찾기 (locator 우선, fallback to selector)
+ * Step에서 요소 찾기 (locator 시스템 사용)
  */
 async function findElement(step) {
-    // 1. 새로운 locator 시스템 시도
-    if ("locator" in step && step.locator) {
-        try {
-            const element = await waitForLocator(step.locator, {
-                timeout: step.timeoutMs || 5000,
-                visible: true,
-                interactable: true,
-            });
-            return { element, usedSelector: step.locator.primary };
-        }
-        catch (error) {
-            // Locator로 찾지 못하면 selector로 폴백
-            console.warn("Locator failed, falling back to selector", error);
-        }
+    if (!("locator" in step) || !step.locator) {
+        return { element: null, usedSelector: "none" };
     }
-    // 2. 기존 selector 사용 (하위 호환성)
-    if ("selector" in step && step.selector) {
-        const element = querySelector(step.selector);
-        return { element, usedSelector: step.selector };
+    try {
+        const element = await waitForLocator(step.locator, {
+            timeout: step.timeoutMs || 5000,
+            visible: true,
+            interactable: true,
+        });
+        return { element, usedSelector: step.locator.primary };
+    }
+    catch (error) {
+        console.warn("Locator failed:", error);
+        return { element: null, usedSelector: step.locator.primary };
     }
-    return { element: null, usedSelector: "none" };
 }
 /**
  * Click step 실행
@@ -59,10 +52,18 @@ export async function executeClickStep(step) {
         };
     }
 }
+/**
+ * Resolve placeholders in text (e.g., {{username}} → variables.username)
+ */
+function resolveText(text, variables) {
+    if (!variables || !text)
+        return text;
+    return text.replace(/\{\{(\w+)\}\}/g, (_, key) => variables[key] ?? "");
+}
 /**
  * Type step 실행
  */
-export async function executeTypeStep(step) {
+export async function executeTypeStep(step, options = {}) {
     if (step.type !== "type") {
         return { success: false, error: "Invalid type step" };
     }
@@ -88,7 +89,8 @@ export async function executeTypeStep(step) {
         };
     }
     try {
-        const text = step.originalText || step.text || "";
+        const rawText = step.originalText || step.text || "";
+        const text = resolveText(rawText, options.variables);
         element.value = text;
         element.dispatchEvent(new Event("input", { bubbles: true }));
         element.dispatchEvent(new Event("change", { bubbles: true }));
@@ -231,7 +233,7 @@ export async function executeWaitForStep(step) {
         return { success: false, error: "Invalid waitFor step" };
     }
     // 단순 timeout인 경우
-    if (!("selector" in step) && !("locator" in step) && step.timeoutMs) {
+    if (!("locator" in step) && step.timeoutMs) {
         await new Promise((resolve) => setTimeout(resolve, step.timeoutMs));
         return { success: true };
     }
@@ -245,25 +247,9 @@ export async function executeWaitForStep(step) {
             });
             return { success: true, usedSelector: step.locator.primary };
         }
-        // selector가 있으면 기존 방식 (하위 호환성)
-        if ("selector" in step && step.selector) {
-            const startTime = Date.now();
-            const pollInterval = 100;
-            while (Date.now() - startTime < timeout) {
-                const element = querySelector(step.selector);
-                if (element) {
-                    return { success: true, usedSelector: step.selector };
-                }
-                await new Promise((resolve) => setTimeout(resolve, pollInterval));
-            }
-            return {
-                success: false,
-                error: `Timeout waiting for element: ${step.selector}`,
-            };
-        }
         return {
             success: false,
-            error: "WaitFor step requires selector, locator, or timeoutMs",
+            error: "WaitFor step requires locator or timeoutMs",
         };
     }
     catch (error) {
@@ -276,13 +262,13 @@ export async function executeWaitForStep(step) {
 /**
  * Step 실행 (타입에 따라 자동 분기)
  */
-export async function executeStep(step) {
+export async function executeStep(step, options = {}) {
     try {
         switch (step.type) {
             case "click":
                 return await executeClickStep(step);
             case "type":
-                return await executeTypeStep(step);
+                return await executeTypeStep(step, options);
             case "select":
                 return await executeSelectStep(step);
             case "extract":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auto-wiz/dom",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "license": "MIT",
   "author": "JaeSang",
   "repository": {
@@ -23,7 +23,7 @@
     }
   },
   "dependencies": {
-    "@auto-wiz/core": "1.0.1"
+    "@auto-wiz/core": "1.2.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0"