@sungen/driver-ui 3.2.12-beta.9 → 3.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.12-beta.9",
+  "version": "3.2.13",
   "description": "Sungen UI capability (Playwright) — step patterns, viewpoint gate, and phase hooks. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -13,7 +13,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.12-beta.9"
+    "@sun-asterisk/sungen": "3.2.13"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"

package/src/patterns/assertion-patterns.ts

@@ -378,6 +378,26 @@ export const assertionPatterns: StepPattern[] = [
         };
       }
 
+      // List-member roles: `see [X] item with {{v}}` on a dynamic list/dropdown means
+      // "an item whose text is v exists" — filter the (many-matching) locator by the value
+      // then assert visible, mirroring click-element-with-text. Plain toHaveText on the bare
+      // getByRole('listitem') strict-mode-fails when many match. SCOPED to role-based
+      // list-member roles only (listitem/option/cell) — unique labelled elements keep
+      // toHaveText (value check), and locator-type lists are unchanged. `row` is excluded
+      // (table rows have dedicated existence patterns).
+      const LIST_MEMBER_ROLES = new Set(['listitem', 'option', 'cell']);
+      if (resolved.strategy === 'role' && resolved.role && LIST_MEMBER_ROLES.has(resolved.role)) {
+        const { name: _name, ...resolvedWithoutName } = resolved;
+        const code = context.templateEngine.renderStep('visible-filtered-assertion', {
+          ...resolvedWithoutName,
+          dataValue,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} with text ${step.dataRef} is present`,
+        };
+      }
+
       // Role-based selector
       if (resolved.strategy === 'role' && resolved.role) {
         const hasName = resolved.name && resolved.name.trim();

package/src/patterns/interaction-patterns.ts

@@ -229,6 +229,42 @@ export const interactionPatterns: StepPattern[] = [
     },
     priority: 11,
   },
+  {
+    // `hover [X] item with {{v}}` — pick the element whose text matches the value, mirroring
+    // click-element-with-text. Without this, hover fell through to hover-element which IGNORED
+    // the value and hovered the first match (strict-mode / wrong element on dynamic lists).
+    name: 'hover-element-with-text',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('hovers') || step.text.match(/\bhover\b/))
+      && !!step.selectorRef
+      && !!(step.dataRef || step.value)
+      && step.text.includes('with'),
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, undefined, step.elementType, step.nth
+      );
+
+      let dataValue: string;
+      if (step.value) {
+        dataValue = step.value;
+      } else {
+        try {
+          dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+        } catch {
+          dataValue = `\${${step.dataRef}}`;
+        }
+      }
+
+      const { name: _name, ...resolvedWithoutName } = resolved;
+
+      return {
+        templateName: 'hover-element-with-text',
+        data: { ...resolvedWithoutName, dataValue },
+        comment: `Hover ${step.selectorRef} with text ${step.dataRef || step.value}`,
+      };
+    },
+    priority: 9,  // above hover-element (8) so `with {{v}}` filters instead of hovering the first
+  },
   {
     name: 'hover-element',
     matcher: (step: ParsedStep) =>