@sungen/driver-ui 3.2.21 → 3.2.22-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.21",
+  "version": "3.2.22-beta.2",
   "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.21"
+    "@sun-asterisk/sungen": "3.2.22-beta.2"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"

package/src/patterns/capture-patterns.ts

@@ -125,8 +125,15 @@ export const capturePatterns: StepPattern[] = [
           selectorRef: step.selectorRef,
           childRef: step.childRef,
           stepCounter: sc,
-          // Render the child RELATIVE to each container row via locator.hbs's parentLocator branch.
-          child: { ...child, parentLocator: `__cards_${sc}.nth(__i_${sc})` },
+          // C4 — plain variable NAMES only, no built locator expression. `.nth()` is a
+          // Playwright-only method; baking it into a string here (as the driver-agnostic
+          // pattern layer) leaked into the Appium output. Each adapter's own
+          // all-contain-element template composes its own per-index child chain
+          // (Playwright: `{{containerVar}}.nth({{containerIndexVar}})`; Appium:
+          // `{{containerVar}}[{{containerIndexVar}}]`).
+          containerVar: `__cards_${sc}`,
+          containerIndexVar: `__i_${sc}`,
+          child,
         },
         comment: `Assert all ${step.selectorRef} contain [${step.childRef}]`,
       };

package/src/patterns/interaction-patterns.ts

@@ -561,7 +561,7 @@ export const interactionPatterns: StepPattern[] = [
       if (!allRefs || allRefs.length < 2) {
         return {
           templateName: 'drag-action',
-          data: { strategy: 'text', value: step.selectorRef, targetLocator: 'page.locator(\'TODO\')' },
+          data: { strategy: 'text', value: step.selectorRef, targetStrategy: 'locator', targetValue: 'TODO' },
           comment: `Drag ${step.selectorRef} (missing target)`,
         };
       }
@@ -571,30 +571,20 @@ export const interactionPatterns: StepPattern[] = [
       const sourceResolved = context.selectorResolver.resolveSelector(sourceRef, undefined, step.elementType, step.nth);
       const targetResolved = context.selectorResolver.resolveSelector(targetRef, undefined, undefined, 0);
 
-      // Build target locator expression from resolved selector
-      let targetLocator: string;
-      switch (targetResolved.strategy) {
-        case 'role':
-          targetLocator = targetResolved.name
-            ? `page.getByRole('${targetResolved.role}', { name: '${targetResolved.name}' })`
-            : `page.getByRole('${targetResolved.role}')`;
-          break;
-        case 'testid':
-          targetLocator = `page.getByTestId('${targetResolved.value}')`;
-          break;
-        case 'text':
-          targetLocator = `page.getByText('${targetResolved.value}')`;
-          break;
-        case 'locator':
-          targetLocator = `page.locator('${targetResolved.value}')`;
-          break;
-        default:
-          targetLocator = `page.getByText('${targetRef}')`;
-      }
-
+      // C3 — pass the resolved TARGET selector FIELDS, not a built Playwright locator string.
+      // Each adapter's own drag-action template renders the target locator for its own
+      // framework (Playwright: page.getByRole/getByText/...; Appium: an accessibility-id/xpath
+      // $() lookup — it already consumes this exact shape).
       return {
         templateName: 'drag-action',
-        data: { ...sourceResolved, targetLocator },
+        data: {
+          ...sourceResolved,
+          targetStrategy: targetResolved.strategy,
+          targetValue: targetResolved.value,
+          targetName: targetResolved.name,
+          targetRole: targetResolved.role,
+          targetRef,
+        },
         comment: `Drag ${sourceRef} to ${targetRef}`,
       };
     },

package/src/patterns/table-patterns.ts

@@ -113,6 +113,40 @@ export const tablePatterns: StepPattern[] = [
     priority: 16,
   },
 
+  // "User see [Result Row] row with {{n}}" — COUNT of matching rows (#575 field report).
+  // Every doc layer (Pattern 5, the gherkin-syntax skill's "# 7. Count") promises this
+  // form counts, and authors write it meaning a count ("40 results after load-more") —
+  // but it fell through to see-with-variable and compiled to toHaveText('40') against
+  // the row's ENTIRE text: a test that can essentially never pass, emitted silently.
+  // The value decides: a numeric base value is a count; any other value keeps the text
+  // semantics (asserting a row's full text equals a bare number is no real intent).
+  // `row in [Table] table with` (row scope/exists) and `is hidden` stay untouched.
+  {
+    name: 'row-count',
+    matcher: (step) => {
+      return step.elementType === 'row' &&
+             /\brow\s+with\b/i.test(step.text) &&
+             !!step.dataRef && !!step.selectorRef &&
+             !/\bin\b.*\btable\b/i.test(step.text) &&
+             !/\bis\s+hidden\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      // Decide by the BASE literal (runtime mode returns an opaque marker from resolveData).
+      const base = context.dataResolver.peekBaseValue?.(step.dataRef!, context.featureName);
+      if (base === undefined || !/^\d+$/.test(String(base).trim())) return null as any; // not numeric → fall through to text semantics
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'row', step.nth
+      );
+      const count = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      return {
+        templateName: 'count-assertion',
+        data: { ...resolved, expectedCount: count },
+        comment: `Assert ${step.selectorRef} row count is ${count}`,
+      };
+    },
+    priority: 18, // above see-with-variable (14) — the count reading wins for numeric values
+  },
+
   // "User see [Ref] row in [Table] table with {{value}}" — row exists (enters row scope)
   {
     name: 'table-row-exists',