@sungen/driver-ui 3.2.12 → 3.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.12",
+  "version": "3.2.14",
   "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"
+    "@sun-asterisk/sungen": "3.2.14"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"

package/src/patterns/assertion-patterns.ts

@@ -6,6 +6,22 @@ import { pathToRegexSource } from '../utils/url-path-regex';
  * Assertion patterns: visibility, text content, state, attributes
  * Uses template engine for framework-agnostic code generation
  */
+
+/** State qualifiers that may follow `with {{value}}` and need value-filtered handling
+ *  (see-with-variable-state). `is disabled`/`is hidden` are EXCLUDED — they keep their
+ *  dedicated -disabled/-hidden twins. `is unchecked` is tested before `is checked` so
+ *  the substring never misclassifies. `selected` probes at runtime (aria-selected vs
+ *  checked) exactly like selected-assertion. */
+function qualifiedState(text: string): { assertion: string; label: string; probe?: boolean } | null {
+  if (/\bis enabled\b/.test(text)) return { assertion: 'toBeEnabled()', label: 'enabled' };
+  if (/\bis unchecked\b/.test(text)) return { assertion: 'toBeChecked({ checked: false })', label: 'unchecked' };
+  if (/\bis checked\b/.test(text)) return { assertion: 'toBeChecked()', label: 'checked' };
+  if (/\bis focused\b/.test(text)) return { assertion: 'toBeFocused()', label: 'focused' };
+  if (/\bis empty\b/.test(text)) return { assertion: 'toBeEmpty()', label: 'empty' };
+  if (/\bis selected\b/.test(text)) return { assertion: '', label: 'selected', probe: true };
+  return null;
+}
+
 export const assertionPatterns: StepPattern[] = [
   // Browser alert text assertion: "see [Are you sure?] alert"
   {
@@ -245,6 +261,60 @@ export const assertionPatterns: StepPattern[] = [
       return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
     },
     priority: 14,
+  },
+  // Pattern: Then User see [Time Slot] option with {{time}} is enabled|selected|checked|…
+  // The value-qualified STATE family. Mirrors see-with-variable-hidden/-disabled (both p14):
+  // without this twin the generic see-with-variable (p13) swallowed the step and emitted a
+  // bare toHaveText — the state qualifier was silently DROPPED, and on a multi-match
+  // `type: locator` selector (e.g. a 96-slot time picker) the unfiltered locator also
+  // strict-mode-failed. Filter by the EXACT value first, then assert the state.
+  // `is disabled` / `is hidden` keep their existing dedicated twins — not matched here.
+  {
+    name: 'see-with-variable-state',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') || !!step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef &&
+      !!step.dataRef &&
+      step.text.includes('with') &&
+      qualifiedState(step.text) !== null,
+    generator: (step, context) => {
+      const state = qualifiedState(step.text)!;
+
+      let resolved: any = {};
+      try {
+        resolved = context.selectorResolver.resolveSelector(
+          step.selectorRef!,
+          context.featureName,
+          step.elementType,
+          step.nth
+        );
+      } catch (error) {}
+
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      // "selected" mirrors selected-assertion: checkbox/radio/switch roles have no
+      // aria-selected — their state is `checked`; other targets probe at runtime.
+      let stateAssertion = state.assertion;
+      let selectedProbe = state.probe === true;
+      if (selectedProbe && resolved.role && ['checkbox', 'radio', 'switch'].includes(resolved.role)) {
+        stateAssertion = 'toBeChecked()';
+        selectedProbe = false;
+      }
+
+      const code = context.templateEngine.renderStep('state-with-filter-assertion', {
+        ...resolved,
+        dataValue,
+        stateAssertion,
+        selectedProbe,
+      });
+      return { code, comment: `Assert ${step.selectorRef} with ${step.dataRef} is ${state.label}` };
+    },
+    priority: 14,
   },
     // NEW: Assertion with variable (handles both empty selector and static + variable)
   // Pattern: Then User see [error] message with {{fail_message}}
@@ -366,6 +436,24 @@ export const assertionPatterns: StepPattern[] = [
       }
 
       // --- Everything else: toHaveText (exact full match) ---
+      // Locator-strategy LIST MEMBERS first: `see [X] item|option|cell with {{v}}` on a
+      // CSS-locator list (custom widgets with no role — e.g. a 96-slot time picker) means
+      // "a member whose text is v exists". A bare toHaveText on the multi-matching locator
+      // strict-mode-fails, so filter by the EXACT value then assert visible — the locator
+      // counterpart of the role-based branch below. Unique-element types (text/message/…)
+      // keep toHaveText: that is a VALUE assertion and must not be weakened to existence.
+      const LOCATOR_LIST_MEMBER_TYPES = new Set(['item', 'listitem', 'option', 'cell']);
+      if (resolved.strategy === 'locator' && step.elementType && LOCATOR_LIST_MEMBER_TYPES.has(step.elementType)) {
+        const code = context.templateEngine.renderStep('visible-filtered-assertion', {
+          ...resolved,
+          dataValue,
+          exact: true,
+        });
+        return {
+          code,
+          comment: `Assert ${step.selectorRef} with text ${step.dataRef} is present`,
+        };
+      }
       // Locator strategy
       if (resolved.strategy === 'locator') {
         const code = context.templateEngine.renderStep('have-text-assertion', {
@@ -378,6 +466,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) =>