@sungen/driver-ui 3.2.13 → 3.2.15

package/package.json

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

package/src/patterns/table-patterns.ts

@@ -136,11 +136,35 @@ export const tablePatterns: StepPattern[] = [
       );
       const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
 
+      // Field report: the row label used to be DECORATIVE (comment-only) — a
+      // positional intent like `[First Contact Row]` silently degraded to an
+      // anywhere-in-the-table existence check, so ordering rules never failed.
+      // Now the label follows the same "resolve via selectors.yaml, fall back
+      // when absent" convention as every other [Ref]: a `type: locator` entry
+      // (RELATIVE to the table, e.g. `tbody tr:first-child`) positions the row,
+      // and the assertion becomes toContainText on that exact row. No entry →
+      // the historical filter-by-value behavior, byte-identical.
+      let rowSelector: string | undefined;
+      if (rowLabel && rowLabel !== tableName) {
+        try {
+          const rowResolved = context.selectorResolver.resolveSelector(
+            rowLabel, context.featureName, 'row', 0
+          );
+          if (rowResolved.strategy === 'locator' && rowResolved.value && rowResolved.value.trim()) {
+            rowSelector = rowResolved.value;
+          }
+        } catch {
+          // no selectors.yaml entry for the row label — display-only label (fallback)
+        }
+      }
+
       const isGiven = isGivenContext(context);
       return {
         templateName: 'table-row-exists',
-        data: { ...resolved, filterValue, isGiven },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table with ${step.dataRef}`,
+        data: { ...resolved, filterValue, isGiven, rowSelector },
+        comment: rowSelector
+          ? `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} (positioned row) in ${tableName} table contains ${step.dataRef}`
+          : `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table with ${step.dataRef}`,
       };
     },
     priority: 17,
@@ -310,27 +334,55 @@ export const tablePatterns: StepPattern[] = [
 
       const dataTable = step.dataTable!;
 
-      // Resolve {{variable}} references in cell values
-      const resolvedRows = dataTable.rows.map(row => ({
-        cells: row.cells.map(cell => {
-          const varMatch = cell.match(/^\{\{([a-z0-9\-\.\_]+)\}\}$/i);
-          if (varMatch) {
-            return context.dataResolver.resolveData(varMatch[1], context.featureName);
-          }
-          return cell;
-        }),
-      }));
-
-      // Pre-compute filter-based assertion lines
-      // For each expected row: chain .filter({ hasText }) for all cell values, then assert visible
+      // Resolve {{variable}} references in a cell (headers included — i18n headers are legal)
+      const resolveCell = (cell: string): string => {
+        const varMatch = cell.match(/^\{\{([a-z0-9\-\.\_]+)\}\}$/i);
+        if (varMatch) {
+          return context.dataResolver.resolveData(varMatch[1], context.featureName);
+        }
+        return cell;
+      };
+      const headers = dataTable.headers.map(resolveCell);
+      const resolvedRows = dataTable.rows.map(row => ({ cells: row.cells.map(resolveCell) }));
+      const esc = (s: string) => s.replace(/'/g, "\\'");
+
+      // Header → cell mapping (field report: the header row was parsed and then IGNORED —
+      // rows were asserted as chained row-level hasText filters, so column-swapped data and
+      // duplicate values like '-' still passed). Now:
+      //  1. span guard — rowspan/colspan shifts ordinal mapping; fail loud instead of
+      //     asserting the wrong cells (span support is a documented follow-up);
+      //  2. resolve each DataTable header to its DOM column index AT RUNTIME by header text
+      //     (exact after trim, else a UNIQUE contains-match to tolerate sort icons); a
+      //     missing/ambiguous header fails with the actual header row in the message —
+      //     robust to extra DOM columns (leading checkbox…) that break compile-time nth;
+      //  3. locate each expected row by the chained co-occurrence filters (kept — resilient
+      //     to row order and extra rows), then prove EVERY cell under its own header with
+      //     an exact toHaveText. `td, th` ordinals count all DOM cells on both the header
+      //     and body sides, so indexes stay aligned even with hidden columns.
       const assertions: string[] = [];
+      assertions.push(
+        `await expect(table.locator('[rowspan]:not([rowspan="1"]), [colspan]:not([colspan="1"])'), 'table match data: rowspan/colspan tables are not supported yet — header-to-cell mapping would be wrong').toHaveCount(0);`
+      );
+      assertions.push(
+        `const __headers = (await table.locator('thead tr').first().locator('th, td').allTextContents()).map((t) => t.trim());`
+      );
+      assertions.push(
+        `const __colIdx = (h: string): number => { const i = __headers.indexOf(h); if (i !== -1) return i; const c = __headers.filter((t) => t.includes(h)); if (c.length === 1) return __headers.indexOf(c[0]); throw new Error(\`table match data: header "\${h}" \${c.length ? 'is ambiguous' : 'not found'} in table header row [\${__headers.join(' | ')}]\`); };`
+      );
       for (const row of resolvedRows) {
         const filters = row.cells
-          .map(cell => `.filter({ hasText: '${cell.replace(/'/g, "\\'")}' })`)
+          .map(cell => `.filter({ hasText: '${esc(cell)}' })`)
           .join('');
-        assertions.push(
-          `await expect(rows${filters}).toBeVisible();`
-        );
+        assertions.push(`{`);
+        assertions.push(`  const row = rows${filters};`);
+        row.cells.forEach((cell, i) => {
+          const header = headers[i];
+          if (header === undefined) return;
+          assertions.push(
+            `  await expect(row.locator('td, th').nth(__colIdx('${esc(header)}'))).toHaveText('${esc(cell)}');`
+          );
+        });
+        assertions.push(`}`);
       }
 
       const isGiven = isGivenContext(context);