@sungen/driver-ui 3.2.14 → 3.2.15

package/package.json

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

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);