arn-browser 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "arn-browser",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "A lightweight, browser autmation helper.",
 	"main": "src/index.js",
 	"types": "src/index.d.ts",

package/src/human-cursor/HumanCursor.js

@@ -20,6 +20,22 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Simple mutex for serializing keyboard operations
+ */
+let typingLock = Promise.resolve();
+async function withTypingLock(fn) {
+    const previousLock = typingLock;
+    let releaseLock;
+    typingLock = new Promise(resolve => { releaseLock = resolve; });
+    await previousLock;
+    try {
+        return await fn();
+    } finally {
+        releaseLock();
+    }
+}
+
 /**
  * Creates a HumanLocator that wraps a Playwright Locator
  * with human-like cursor movement for actions
@@ -70,18 +86,33 @@ function createHumanLocator(cursor, locator) {
             if (!cursor.config.humanize) {
                 return await locator.fill(value, options);
             }
-            await this.click(options);
-            await cursor._page.keyboard.press('Control+A');
-            await sleep(randInt(50, 100));
-            await cursor._type(value, options);
+            // Humanize: Move to element, then fill instantly (Playwright handles focus)
+            await cursor._moveToLocator(locator, options);
+            return await locator.fill(value, options);
+        },
+
+        async fillSequentially(value, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.fill(value, options);
+            }
+            return await withTypingLock(async () => {
+                await this.click(options);
+                // Clear field reliably using fill('') before human typing
+                await locator.fill('');
+                await sleep(randInt(50, 100));
+                // Human type with delays
+                await cursor._type(value, options);
+            });
         },
 
         async type(text, options = {}) {
             if (!cursor.config.humanize) {
                 return await locator.type(text, options);
             }
-            await this.click(options);
-            await cursor._type(text, options);
+            return await withTypingLock(async () => {
+                await this.click(options);
+                await cursor._type(text, options);
+            });
         },
 
         async hover(options = {}) {
@@ -99,6 +130,46 @@ function createHumanLocator(cursor, locator) {
             await cursor._page.keyboard.press(key);
         },
 
+        async check(options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.check(options);
+            }
+            if (!(await locator.isChecked())) {
+                await this.click(options);
+            }
+        },
+
+        async uncheck(options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.uncheck(options);
+            }
+            if (await locator.isChecked()) {
+                await this.click(options);
+            }
+        },
+
+        async setChecked(checked, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.setChecked(checked, options);
+            }
+            if (checked) {
+                await this.check(options);
+            } else {
+                await this.uncheck(options);
+            }
+        },
+
+        async pressSequentially(text, options = {}) {
+            if (!cursor.config.humanize) {
+                return await locator.pressSequentially(text, options);
+            }
+            return await withTypingLock(async () => {
+                await this.click(options);
+                await locator.clear();
+                await cursor._type(text, options);
+            });
+        },
+
         // Chainable methods that return new HumanLocators
         filter(options) {
             return createHumanLocator(cursor, locator.filter(options));
@@ -151,7 +222,7 @@ function createHumanLocator(cursor, locator) {
 
 /**
  * Create a HumanCursor that acts as a drop-in replacement for Page
- * All page methods work, but click/fill/type/hover use human cursor
+ * All page methods work, but click/fill/type/check/hover use human cursor
  * 
  * @param {import('playwright').Page} page - Playwright Page object
  * @param {Object} options - Configuration options
@@ -411,6 +482,27 @@ export function createCursor(page, options = {}) {
             if (prop in locatorMethods) {
                 return locatorMethods[prop];
             }
+
+            // Override Page methods to use HumanLocator
+            if (['click', 'dblclick', 'fill', 'hover', 'type', 'press', 'check', 'uncheck'].includes(prop)) {
+                return async (selector, ...args) => {
+                    const humanLocator = createHumanLocator(cursor, page.locator(selector));
+                    return await humanLocator[prop](...args);
+                };
+            }
+            if (prop === 'fillSequentially') {
+                return async (selector, ...args) => {
+                    const humanLocator = createHumanLocator(cursor, page.locator(selector));
+                    return await humanLocator.fillSequentially(...args);
+                };
+            }
+            if (prop === 'pressSequentially') {
+                return async (selector, ...args) => {
+                    const humanLocator = createHumanLocator(cursor, page.locator(selector));
+                    return await humanLocator.pressSequentially(...args);
+                };
+            }
+
             // Expose cursor utilities
             if (prop === 'showCursor') {
                 return cursor.showCursor.bind(cursor);

package/src/human-cursor/index.d.ts

@@ -66,7 +66,9 @@ export interface HumanClickOptions {
 }
 
 export interface HumanFillOptions extends HumanClickOptions {
+    /** Minimum delay between keystrokes in ms (default: 50) */
     minDelay?: number;
+    /** Maximum delay between keystrokes in ms (default: 150) */
     maxDelay?: number;
 }
 
@@ -77,8 +79,13 @@ export interface HumanFillOptions extends HumanClickOptions {
 export interface HumanLocator extends Locator {
     click(options?: HumanClickOptions): Promise<void>;
     dblclick(options?: HumanClickOptions): Promise<void>;
-    fill(value: string, options?: HumanFillOptions): Promise<void>;
+    fill(value: string, options?: HumanClickOptions): Promise<void>;
+    fillSequentially(value: string, options?: HumanFillOptions): Promise<void>;
     type(text: string, options?: HumanFillOptions): Promise<void>;
+    pressSequentially(text: string, options?: HumanFillOptions): Promise<void>;
+    check(options?: HumanClickOptions): Promise<void>;
+    uncheck(options?: HumanClickOptions): Promise<void>;
+    setChecked(checked: boolean, options?: HumanClickOptions): Promise<void>;
     hover(options?: HumanClickOptions): Promise<void>;
     press(key: string, options?: HumanClickOptions): Promise<void>;