@dev-blinq/cucumber_client 1.0.1265-dev → 1.0.1267-dev

package/bin/assets/bundled_scripts/recorder.js

@@ -316,6 +316,27 @@ var DOM_Parent = class {
     }
     return ancestors;
   }
+  getFullAncestorChainToRoot(element, root) {
+    if (!element || !(element instanceof Element)) {
+      throw new Error("Invalid element provided");
+    }
+    if (!root || !(root instanceof Element)) {
+      throw new Error("Invalid root provided");
+    }
+    if (!this.containsElementCrossShadow(root, element)) {
+      throw new Error("Root does not contain the element");
+    }
+    const ancestors = [];
+    let currentElement = element;
+    while (currentElement && currentElement !== root && this.containsElementCrossShadow(root, currentElement)) {
+      ancestors.push(currentElement);
+      currentElement = this.getActualParent(currentElement);
+    }
+    if (currentElement === root) {
+      ancestors.push(currentElement);
+    }
+    return ancestors;
+  }
   getClimbCountToParent(element, targetParent) {
     if (!element || !(element instanceof Element)) {
       throw new Error("Invalid element provided");
@@ -8230,6 +8251,7 @@ var LocatorGenerator = class {
     this.dom_Parent = new dom_parent_default();
     this.PW = __PW;
     this.injectedScript = injectedScript;
+    this.cache = /* @__PURE__ */ new Map();
   }
   getMatchingElements(selector, options = {}) {
     const { root = window.document, prefix, visible = true } = options;
@@ -8375,12 +8397,16 @@ var LocatorGenerator = class {
           const text = this.injectedScript.utils.elementText(/* @__PURE__ */ new Map(), textElement).full;
           if (!textSet.has(text)) {
             textSet.add(text);
-            result.push({
+            const loc = {
               css: restOfSelector,
               climb: climbCount,
               text,
               priority: 1
-            });
+            };
+            if (locator.index !== void 0) {
+              loc.index = locator.index;
+            }
+            result.push(loc);
           }
         }
       } catch (error) {
@@ -8481,7 +8507,10 @@ var LocatorGenerator = class {
     const nonUnique = [];
     for (const locator of locators) {
       const elements = this.getMatchingElements(locator.css, options);
-      if (elements.length === 1) {
+      if (elements.length === 0) {
+        console.warn(`No elements found for locator: ${locator.css}`);
+        continue;
+      } else if (elements.length === 1) {
         if (element === elements[0]) {
           locator.priority = 1;
           unique.push(locator);
@@ -8501,9 +8530,18 @@ var LocatorGenerator = class {
     }
     return { unique, nonUnique };
   }
+  getCategorizedLocators(element, options = {}) {
+    if (this.cache.has(element)) {
+      return this.cache.get(element);
+    }
+    const locators = this.getElementLocators(element, options);
+  }
   getUniqueLocators(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    return this.getUniqueLocators2(element, locatorGenerator, options);
+  }
+  getUniqueLocators1(element, locatorGenerator = this.getNoTextLocators, options = {}) {
     try {
-      const { maxLocators = 5, root = window.document.body, next = "LCA" } = options;
+      const { maxLocators = 5, root = window.document.body, next = "LCA", minLocators = 3 } = options;
       if (!element) {
         return [];
       }
@@ -8584,7 +8622,7 @@ var LocatorGenerator = class {
                 result.push(_locator);
               } else {
                 const index = _elements.indexOf(element);
-                if (index !== -1) {
+                if (index !== -1 && index < 5) {
                   _locator.css = fullSelector;
                   _locator.index = index;
                   _locator.priority = 2;
@@ -8595,7 +8633,7 @@ var LocatorGenerator = class {
             }
           } else {
             const index = elements.indexOf(element);
-            if (index !== -1) {
+            if (index !== -1 && index < 5) {
               locator.index = index;
               locator.priority = 2;
               result.push(locator);
@@ -8603,7 +8641,7 @@ var LocatorGenerator = class {
           }
         } else {
           const index = elements.indexOf(element);
-          if (index !== -1) {
+          if (index !== -1 && index < 5) {
             locator.index = index;
             locator.priority = 2;
             result.push(locator);
@@ -8614,7 +8652,7 @@ var LocatorGenerator = class {
         delete locator.engine;
         delete locator.selector;
       }
-      if (result.length === 0) {
+      if (result.length < minLocators && root && root.contains(element)) {
         const parent = this.dom_Parent.getActualParent(element);
         const locs = this.getUniqueLocators(parent, locatorGenerator, {
           ...options,
@@ -8631,6 +8669,124 @@ var LocatorGenerator = class {
       return [];
     }
   }
+  getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    try {
+      const { maxLocators = 5, root = window.document.body } = options;
+      if (!element) {
+        return [];
+      }
+      if (element === root) {
+        if (element === window.document.documentElement) {
+          return [
+            {
+              css: "html",
+              score: 1,
+              priority: 1
+            },
+            {
+              css: ":root",
+              score: 1,
+              priority: 1
+            }
+          ];
+        } else {
+          return [
+            {
+              css: ":root",
+              score: 1,
+              priority: 1
+              // }, {
+              // 	css: ":root",
+              // 	score: 1,
+              // 	priority: 1,
+            }
+          ];
+        }
+      }
+      console.log("Generating locators for element:", element);
+      const locators = locatorGenerator(element, options);
+      console.log("Generated locators:", locators);
+      if (!locators || !Array.isArray(locators)) {
+        console.error("Locator generator did not return an array of locators");
+        return [];
+      }
+      console.log("Categorizing locators for element:", element);
+      const categorizedLocators = this.categorizeLocators(element, locators, options);
+      console.log("Categorized locators:", categorizedLocators);
+      const { unique, nonUnique } = categorizedLocators;
+      const result = [];
+      if (unique.length > 0) {
+        result.push(...unique);
+      }
+      if (result.length >= maxLocators) {
+        return result.slice(0, maxLocators);
+      }
+      const elementsCache = /* @__PURE__ */ new Map();
+      const allAncestors = this.dom_Parent.getFullAncestorChainToRoot(element, root);
+      allAncestors.shift();
+      const ancestorLocators = [];
+      for (const ancestor of allAncestors) {
+        const _locators = locatorGenerator(ancestor, options);
+        if (!_locators || !Array.isArray(_locators) || _locators.length === 0) {
+          continue;
+        }
+        const _categorized = this.categorizeLocators(ancestor, _locators, options);
+        ancestorLocators.push({
+          element: ancestor,
+          locators: _categorized
+        });
+        elementsCache.set(ancestor, _categorized);
+        if (_categorized.unique.length > 0) {
+          break;
+        }
+      }
+      const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
+      for (const locator of nonUnique) {
+        const selector = locator.css ?? locator.selector;
+        const elements = locator.elements || this.getMatchingElements(selector, options);
+        if (elements.length === 0) {
+          console.warn(`No elements found for locator: ${selector}`);
+          continue;
+        }
+        for (const unique_locator of uniqueAncestor.locators.unique) {
+          const fullSelector = `${unique_locator.css} >> ${selector}`;
+          const elements2 = this.getMatchingElements(fullSelector, options);
+          if (elements2.length === 1 && elements2[0] === element) {
+            const effectiveScore = (unique_locator.score + locator.score) / 2 + 100;
+            const newLocator = {
+              ...unique_locator,
+              css: fullSelector,
+              score: effectiveScore,
+              priority: 1
+              // unique locators have higher priority
+            };
+            result.push(newLocator);
+          } else {
+            const index = elements2.indexOf(element);
+            if (index !== -1 && index < 5) {
+              const effectiveScore = (unique_locator.score + locator.score) / 2;
+              const newLocator = {
+                ...unique_locator,
+                css: fullSelector,
+                index,
+                score: effectiveScore + 200,
+                priority: 2
+                // non-unique locators have lower priority
+              };
+              result.push(newLocator);
+            }
+          }
+        }
+      }
+      result.sort((a, b) => a.score - b.score);
+      console.log("Final locators:", result, element);
+      console.groupEnd();
+      return result.slice(0, maxLocators);
+    } catch (error) {
+      console.error("Error in getUniqueLocators:", error);
+      return [];
+    }
+  }
   getElementLocators(element, options = {}) {
     var _a;
     const { excludeText = false } = options;

package/bin/assets/scripts/dom_parent.js

@@ -35,6 +35,28 @@ class DOM_Parent {
 
         return ancestors;
     }
+    getFullAncestorChainToRoot(element, root) {
+        if (!element || !(element instanceof Element)) {
+            throw new Error('Invalid element provided');
+        }
+        if (!root || !(root instanceof Element)) {
+            throw new Error('Invalid root provided');
+        }
+        if (!this.containsElementCrossShadow(root, element)) {
+            throw new Error('Root does not contain the element');
+        }
+        const ancestors = [];
+        let currentElement = element;
+        while (currentElement && currentElement !== root && this.containsElementCrossShadow(root, currentElement)) {
+            ancestors.push(currentElement);
+            currentElement = this.getActualParent(currentElement);
+
+        }
+        if (currentElement === root) {
+            ancestors.push(currentElement);
+        }
+        return ancestors;
+    }
     getClimbCountToParent(element, targetParent) {
         if (!element || !(element instanceof Element)) {
             throw new Error('Invalid element provided');

package/bin/assets/scripts/unique_locators.js

@@ -19,6 +19,7 @@ class LocatorGenerator {
 		this.dom_Parent = new DOM_Parent();
 		this.PW = __PW;
 		this.injectedScript = injectedScript;
+		this.cache = new Map();
 	}
 
 	getMatchingElements(selector, options = {}) {
@@ -176,13 +177,16 @@ class LocatorGenerator {
 					const text = this.injectedScript.utils.elementText(new Map(), textElement).full;
 					if (!textSet.has(text)) {
 						textSet.add(text);
-						result.push({
+						const loc = {
 							css: restOfSelector,
 							climb: climbCount,
 							text,
 							priority: 1,
-						});
-
+						}
+						if (locator.index !== undefined) {
+							loc.index = locator.index;
+						}
+						result.push(loc);
 					}
 
 
@@ -297,7 +301,10 @@ class LocatorGenerator {
 		const nonUnique = [];
 		for (const locator of locators) {
 			const elements = this.getMatchingElements(locator.css, options);
-			if (elements.length === 1) {
+			if (elements.length === 0) {
+				console.warn(`No elements found for locator: ${locator.css}`);
+				continue;
+			} else if (elements.length === 1) {
 				if (element === elements[0]) {
 					locator.priority = 1;
 					unique.push(locator);
@@ -318,13 +325,21 @@ class LocatorGenerator {
 		return { unique, nonUnique };
 	}
 
-
+	getCategorizedLocators(element, options = {}) {
+		if (this.cache.has(element)) {
+			return this.cache.get(element);
+		}
+		const locators = this.getElementLocators(element, options);
+	}
 
 
 	getUniqueLocators(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+		return this.getUniqueLocators2(element, locatorGenerator, options);
+	}
+	getUniqueLocators1(element, locatorGenerator = this.getNoTextLocators, options = {}) {
 		try {
 
-			const { maxLocators = 5, root = window.document.body, next = "LCA" } = options;
+			const { maxLocators = 5, root = window.document.body, next = "LCA", minLocators = 3 } = options;
 
 			if (!element) {
 				return [];
@@ -414,7 +429,7 @@ class LocatorGenerator {
 								result.push(_locator);
 							} else {
 								const index = _elements.indexOf(element);
-								if (index !== -1) {
+								if (index !== -1 && index < 5) {
 									// _locator.selector = fullSelector;
 									_locator.css = fullSelector;
 									_locator.index = index;
@@ -428,7 +443,7 @@ class LocatorGenerator {
 
 					} else {
 						const index = elements.indexOf(element);
-						if (index !== -1) {
+						if (index !== -1 && index < 5) {
 							locator.index = index
 							locator.priority = 2; // non-unique locators have lower priority
 							result.push(locator);
@@ -437,7 +452,7 @@ class LocatorGenerator {
 
 				} else {
 					const index = elements.indexOf(element);
-					if (index !== -1) {
+					if (index !== -1 && index < 5) {
 						locator.index = index
 						locator.priority = 2; // non-unique locators have lower priority
 						result.push(locator);
@@ -450,7 +465,7 @@ class LocatorGenerator {
 				delete locator.selector;
 			}
 
-			if (result.length === 0) {
+			if (result.length < minLocators && root && root.contains(element)) {
 				const parent = this.dom_Parent.getActualParent(element);
 				const locs = this.getUniqueLocators(parent, locatorGenerator, {
 					...options,
@@ -470,6 +485,137 @@ class LocatorGenerator {
 			return [];
 		}
 	}
+
+	getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+		try {
+
+			const { maxLocators = 5, root = window.document.body } = options;
+
+			if (!element) {
+				return [];
+			}
+			if (element === root) {
+				if (element === window.document.documentElement) {
+					return [{
+						css: "html",
+						score: 1,
+						priority: 1,
+					}, {
+						css: ":root",
+						score: 1,
+						priority: 1,
+					}
+					]
+				} else {
+					return [{
+						css: ":root",
+						score: 1,
+						priority: 1,
+						// }, {
+						// 	css: ":root",
+						// 	score: 1,
+						// 	priority: 1,
+					}
+					]
+				}
+			}
+
+			console.log("Generating locators for element:", element);
+			const locators = locatorGenerator(element, options);
+			console.log("Generated locators:", locators);
+			if (!locators || !Array.isArray(locators)) {
+				// throw new Error("Locator generator did not return an array of locators");
+				console.error("Locator generator did not return an array of locators");
+				return [];
+			}
+
+			console.log("Categorizing locators for element:", element);
+			const categorizedLocators = this.categorizeLocators(element, locators, options);
+			console.log("Categorized locators:", categorizedLocators);
+			// categorizedLocators.unique = limitLocators(categorizedLocators.unique, options);
+			// categorizedLocators.nonUnique = limitLocators(categorizedLocators.nonUnique, options);
+
+			const { unique, nonUnique } = categorizedLocators;
+			const result = [];
+			if (unique.length > 0) {
+				result.push(...unique);
+			}
+			if (result.length >= maxLocators) {
+				return result.slice(0, maxLocators);
+			}
+
+			const elementsCache = new Map();
+
+			const allAncestors = this.dom_Parent.getFullAncestorChainToRoot(element, root);
+			allAncestors.shift(); // remove the element itself from the ancestors
+
+			const ancestorLocators = [];
+			for (const ancestor of allAncestors) {
+				const _locators = locatorGenerator(ancestor, options);
+				if (!_locators || !Array.isArray(_locators) || _locators.length
+					=== 0) {
+					continue;
+				}
+				const _categorized = this.categorizeLocators(ancestor, _locators, options);
+				ancestorLocators.push({
+					element: ancestor,
+					locators: _categorized,
+				});
+				elementsCache.set(ancestor, _categorized);
+				if (_categorized.unique.length > 0) {
+					break;
+				}
+			}
+
+			const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
+
+			for (const locator of nonUnique) {
+				const selector = locator.css ?? locator.selector;
+				const elements = locator.elements || this.getMatchingElements(selector, options);
+				if (elements.length === 0) {
+					console.warn(`No elements found for locator: ${selector}`);
+					continue;
+				}
+
+				for (const unique_locator of uniqueAncestor.locators.unique) {
+					const fullSelector = `${unique_locator.css} >> ${selector}`;
+					const elements = this.getMatchingElements(fullSelector, options);
+					if (elements.length === 1 && elements[0] === element) {
+						const effectiveScore = (unique_locator.score + locator.score) / 2 + 100;
+						const newLocator = {
+							...unique_locator,
+							css: fullSelector,
+							score: effectiveScore,
+							priority: 1, // unique locators have higher priority
+						};
+						result.push(newLocator);
+					} else {
+						const index = elements.indexOf(element);
+						if (index !== -1 && index < 5) {
+							const effectiveScore = (unique_locator.score + locator.score) / 2;
+							const newLocator = {
+								...unique_locator,
+								css: fullSelector,
+								index,
+								score: effectiveScore + 200,
+								priority: 2, // non-unique locators have lower priority
+							};
+							result.push(newLocator);
+						}
+					}
+				}
+
+			}
+			result.sort((a, b) => a.score - b.score);
+			console.log("Final locators:", result, element);
+			console.groupEnd();
+			return result.slice(0, maxLocators);
+		}
+		catch (error) {
+			console.error("Error in getUniqueLocators:", error);
+			return [];
+		}
+	}
 	getElementLocators(element, options = {}) {
 
 		const { excludeText = false } = options;

package/bin/assets/templates/utils_template.txt

@@ -60,7 +60,6 @@ async function loadUserData(user) {
 async function verifyTextExistsInPage(text) {
   await context.web.verifyTextExistInPage(text, null, this);
 }
-
 Then("Verify the text {string} can be found in the page", verifyTextExistsInPage);
 
 /**
@@ -87,6 +86,7 @@ async function fillElement(elementDescription, value) {
 }
 When("fill {string} with {string}", fillElement);
 When("Fill {string} with {string}", fillElement);
+
 /**
  * Verify text does not exist in page
  * @param {string} text the text to verify does not exist in page
@@ -107,6 +107,24 @@ async function navigateTo(url) {
 }
 When("Navigate to {string}", navigateTo);
 
+/**
+ * Navigate to the current page
+ * @protect
+ */
+async function browserNavigateBack() {
+  await context.web.goBack({}, this);
+}
+Then("Browser navigate back", browserNavigateBack);
+
+/**
+ * Navigate forward in browser history
+ * @protect
+ */
+async function browserNavigateForward() {
+  await context.web.goForward({}, this);
+}
+Then("Browser navigate forward", browserNavigateForward);
+
 /**
  * Store browser session "<path>"
  * @param {string} filePath the file path or empty to store in the test data file
@@ -141,6 +159,7 @@ Then(
   "Identify the text {string}, climb {string} levels in the page, validate text {string} can be found in the context",
   verifyTextRelatedToText
 );
+
 /**
  * execute bruno single request given the bruno project is placed in a folder called bruno under the root of the cucumber project
  * @requestName the name of the bruno request file
@@ -149,7 +168,6 @@ Then(
 async function runBrunoRequest(requestName) {
   await executeBrunoRequest(requestName, {}, context, this);
 }
-
 When("Bruno - {string}", runBrunoRequest);
 When("bruno - {string}", runBrunoRequest);
 
@@ -163,41 +181,41 @@ async function verify_the_downloaded_file_exists(fileName) {
   const downloadFile = path.join(downloadFolder, fileName);
   await verifyFileExists(downloadFile, {}, context, this);
 }
-
 Then("Verify the file {string} exists", { timeout: 60000 }, verify_the_downloaded_file_exists);
 
-When("Noop", async function(){})
-
 /**
-* Verify the page url is "<url>"
-* @param {string} url URL to be verified against current URL
-* @protect
-*/
+ *  Noop step for running only hooks
+ */
+When("Noop", async function () {});
 
-async function verify_page_url(url){
-  await context.web.verifyPagePath(url,{}, this);
+/**
+ * Verify the page url is "<url>"
+ * @param {string} url URL to be verified against current URL
+ * @protect
+ */
+async function verify_page_url(url) {
+  await context.web.verifyPagePath(url, {}, this);
 }
 Then("Verify the page url is {string}", verify_page_url);
 
 /**
-* Verify the page title is "<title>"
-* @param {string} title Title to be verified against current Title
-* @protect
-*/
-async function verify_page_title(title){
+ * Verify the page title is "<title>"
+ * @param {string} title Title to be verified against current Title
+ * @protect
+ */
+async function verify_page_title(title) {
   await context.web.verifyPageTitle(title, {}, this);
 }
-Then("Verify the page title is {string}",verify_page_title)
+Then("Verify the page title is {string}", verify_page_title);
 
 /**
-* Explicit wait/sleep function that pauses execution for a specified duration
-* @param {duration} - Duration to sleep in milliseconds (default: 1000ms)
-* @param {options} - Optional configuration object
-* @param {world} - Optional world context
-* @returns Promise that resolves after the specified duration
-*/
+ * Explicit wait/sleep function that pauses execution for a specified duration
+ * @param {duration} - Duration to sleep in milliseconds (default: 1000ms)
+ * @param {options} - Optional configuration object
+ * @param {world} - Optional world context
+ * @returns Promise that resolves after the specified duration
+ */
 async function sleep(duration) {
   await context.web.sleep(duration, {}, null);
 }
-
-Then("Sleep for {string} ms", {timeout: -1}, sleep);
+Then("Sleep for {string} ms", { timeout: -1 }, sleep);

package/bin/client/code_gen/code_inversion.js

@@ -310,6 +310,14 @@ const invertStableCommand = (call, elements, stepParams) => {
       break;
     }
 
+    case "goBack":
+      step.type = Types.GO_BACK;
+      break;
+
+    case "goForward":
+      step.type = Types.GO_FORWARD;
+      break;
+
     case "reloadPage":
       step.type = Types.RELOAD;
       break;

package/bin/client/recorderv3/bvt_recorder.js

@@ -24,11 +24,11 @@ export function getInitScript(config, options) {
   window.__bvt_Recorder_config = ${JSON.stringify(config ?? null)};
   window.__PW_options = ${JSON.stringify(options ?? null)};
   `;
-  const recorderScript = readFileSync(path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"), "utf8")
-  return (
-    preScript +
-    recorderScript
+  const recorderScript = readFileSync(
+    path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
+    "utf8"
   );
+  return preScript + recorderScript;
 }
 
 async function evaluate(frame, script) {
@@ -190,7 +190,7 @@ export class BVTRecorder {
 
     this.lastKnownUrlPath = "";
     // TODO: what is world?
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
   }
@@ -294,7 +294,7 @@ export class BVTRecorder {
     process.env.CDP_LISTEN_PORT = this.#remoteDebuggerPort;
 
     this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
 
     const ai_config_file = path.join(this.projectDir, "ai_config.json");
     let ai_config = {};
@@ -433,6 +433,75 @@ export class BVTRecorder {
       }
     });
   }
+
+  hasHistoryReplacementAtIndex(previousEntries, currentEntries, index) {
+    if (!previousEntries || !currentEntries) return false;
+    if (index >= previousEntries.length || index >= currentEntries.length) return false;
+
+    const prevEntry = previousEntries[index];
+    // console.log("prevEntry", prevEntry);
+    const currEntry = currentEntries[index];
+    // console.log("currEntry", currEntry);
+
+    // Check if the entry at this index has been replaced
+    return prevEntry.id !== currEntry.id;
+  }
+
+  // Even simpler approach for your specific case
+  analyzeTransitionType(entries, currentIndex, currentEntry) {
+    // console.log("Analyzing transition type");
+    // console.log("===========================");
+    // console.log("Current Index:", currentIndex);
+    // console.log("Current Entry:", currentEntry);
+    // console.log("Current Entries:", entries);
+    // console.log("Current entries length:", entries.length);
+    // console.log("===========================");
+    // console.log("Previous Index:", this.previousIndex);
+    // // console.log("Previous Entry:", this.previousEntries[this.previousIndex]);
+    // console.log("Previous Entries:", this.previousEntries);
+    // console.log("Previous entries length:", this.previousHistoryLength);
+
+    if (this.previousIndex === null || this.previousHistoryLength === null || !this.previousEntries) {
+      return {
+        action: "initial",
+      };
+    }
+
+    const indexDiff = currentIndex - this.previousIndex;
+    const lengthDiff = entries.length - this.previousHistoryLength;
+
+    // Backward navigation
+    if (indexDiff < 0) {
+      return { action: "back" };
+    }
+
+    // Forward navigation
+    if (indexDiff > 0 && lengthDiff === 0) {
+      // Check if the entry at current index is the same as before
+      const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
+
+      if (entryReplaced) {
+        return { action: "navigate" }; // New navigation that replaced forward history
+      } else {
+        return { action: "forward" }; // True forward navigation
+      }
+    }
+
+    // New navigation (history grew)
+    if (lengthDiff > 0) {
+      return { action: "navigate" };
+    }
+
+    // Same position, same length
+    if (lengthDiff <= 0) {
+      const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
+
+      return entryReplaced ? { action: "navigate" } : { action: "reload" };
+    }
+
+    return { action: "unknown" };
+  }
+
   async getCurrentTransition() {
     if (this?.web?.browser?._name !== "chromium") {
       return;
@@ -441,35 +510,70 @@ export class BVTRecorder {
 
     try {
       const result = await client.send("Page.getNavigationHistory");
-      // console.log("result", result);
+      // console.log("Navigation History:", result);
       const entries = result.entries;
       const currentIndex = result.currentIndex;
 
       // ignore if currentIndex is not the last entry
-      if (currentIndex !== entries.length - 1) return;
+      // if (currentIndex !== entries.length - 1) return;
 
       const currentEntry = entries[currentIndex];
-      return currentEntry;
+      const transitionInfo = this.analyzeTransitionType(entries, currentIndex, currentEntry);
+      this.previousIndex = currentIndex;
+      this.previousHistoryLength = entries.length;
+      this.previousUrl = currentEntry.url;
+      this.previousEntries = [...entries]; // Store a copy of current entries
+
+      return {
+        currentEntry,
+        navigationAction: transitionInfo.action,
+      };
     } catch (error) {
-      console.error("Error in getTransistionType event");
+      console.error("Error in getTransistionType event", error);
     } finally {
       await client.detach();
     }
   }
-  userInitiatedTranistionTypes = ["typed", "address_bar"];
+  userInitiatedTransitionTypes = ["typed", "address_bar"];
   async handlePageTransition() {
     const transition = await this.getCurrentTransition();
     if (!transition) return;
-    // console.log("transitionType", transition.transitionType);
-    if (this.userInitiatedTranistionTypes.includes(transition.transitionType)) {
-      const env = JSON.parse(readFileSync(this.envName), "utf8");
-      const baseUrl = env.baseUrl;
-      let url = transition.userTypedURL;
-      if (baseUrl && url.startsWith(baseUrl)) {
-        url = url.replace(baseUrl, "{{env.baseUrl}}");
-      }
-      // console.log("User initiated transition");
-      this.sendEvent(this.events.onGoto, { url });
+
+    const { currentEntry, navigationAction } = transition;
+
+    switch (navigationAction) {
+      case "initial":
+        // console.log("Initial navigation, no action taken");
+        return;
+      case "navigate":
+        // console.log("transitionType", transition.transitionType);
+        // console.log("sending onGoto event", { url: currentEntry.url,
+        // type: "navigate", });
+        if (this.userInitiatedTransitionTypes.includes(currentEntry.transitionType)) {
+          const env = JSON.parse(readFileSync(this.envName), "utf8");
+          const baseUrl = env.baseUrl;
+          let url = currentEntry.userTypedURL;
+          if (baseUrl && url.startsWith(baseUrl)) {
+            url = url.replace(baseUrl, "{{env.baseUrl}}");
+          }
+          // console.log("User initiated transition");
+          this.sendEvent(this.events.onGoto, { url, type: "navigate" });
+        }
+        return;
+      case "back":
+        // console.log("User navigated back");
+        // console.log("sending onGoto event", {
+        //   type: "back",
+        // });
+        this.sendEvent(this.events.onGoto, { type: "back" });
+        return;
+      case "forward":
+        // console.log("User navigated forward"); console.log("sending onGoto event", { type: "forward", });
+        this.sendEvent(this.events.onGoto, { type: "forward" });
+        return;
+      default:
+        this.sendEvent(this.events.onGoto, { type: "unknown" });
+        return;
     }
   }
 
@@ -596,8 +700,14 @@ export class BVTRecorder {
   }
   async closeBrowser() {
     delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => { });
+    await this.watcher.close().then(() => {});
+
     this.watcher = null;
+    this.previousIndex = null;
+    this.previousHistoryLength = null;
+    this.previousUrl = null;
+    this.previousEntries = null;
+
     await closeContext();
     this.pageSet.clear();
   }

package/bin/client/recording.js

@@ -11,6 +11,8 @@ const Types = {
   PARAMETERIZED_CLICK: "parameterized_click",
   CONTEXT_CLICK: "context_click",
   NAVIGATE: "navigate",
+  GO_BACK: "browser_go_back",
+  GO_FORWARD: "browser_go_forward",
   FILL: "fill_element",
   FILL_SIMPLE: "fill_simple",
   EXECUTE: "execute_page_method",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1265-dev",
+  "version": "1.0.1267-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",