@sungen/driver-ui 3.2.13 → 3.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.13",
+  "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.13"
+    "@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', {