@sungen/driver-ui 3.1.2-beta.100

package/src/patterns/scroll-patterns.ts

@@ -0,0 +1,27 @@
+/**
+ * Scroll Patterns
+ * Handles: scroll to [Target] type
+ */
+
+import { StepPattern } from '@sun-asterisk/sungen';
+
+export const scrollPatterns: StepPattern[] = [
+  {
+    name: 'scroll-to-element',
+    matcher: (step) => {
+      return /\bscroll(?:s)?\s+to\b/i.test(step.text) && !!step.selectorRef;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, step.elementType, step.nth
+      );
+
+      return {
+        templateName: 'scroll-action',
+        data: { ...resolved },
+        comment: `Scroll to ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+];

package/src/patterns/setup-patterns.ts

@@ -0,0 +1,76 @@
+import { ParsedStep } from '@sun-asterisk/sungen';
+import { StepPattern } from '@sun-asterisk/sungen';
+
+/**
+ * Setup and precondition patterns: application setup, authentication state, etc.
+ */
+export const setupPatterns: StepPattern[] = [
+  {
+    name: 'application-running',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('application is running') ||
+      step.text.includes('application running') ||
+      step.text.includes('app is running'),
+    resolver: (step, context) => ({
+      templateName: 'application-running',
+      data: {},
+      comment: `Setup: Application is running`,
+    }),
+    priority: 5,
+  },
+  {
+    name: 'user-not-logged-in',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('user is not logged in') ||
+      step.text.includes('not logged in') ||
+      step.text.includes('logged out'),
+    resolver: (step, context) => ({
+      templateName: 'clear-auth',
+      data: {},
+      comment: `Clear authentication state (ensure user is logged out)`,
+    }),
+    priority: 9,
+  },
+  {
+    name: 'user-logged-in',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('user is logged in') ||
+       step.text.includes('logged in as')) &&
+      !step.text.includes('not logged in'),
+    resolver: (step, context) => {
+      const userRef = step.dataRef || 'valid_user';
+      return {
+        templateName: 'user-login-todo',
+        data: { userRef },
+        comment: `Setup: User logged in as ${userRef}`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'clear-database',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('database is empty') ||
+      step.text.includes('database is cleared') ||
+      step.text.includes('clear database'),
+    resolver: (step, context) => ({
+      templateName: 'clear-database',
+      data: {},
+      comment: `Setup: Clear/reset database`,
+    }),
+    priority: 7,
+  },
+  {
+    name: 'browser-state-clean',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('clean browser state') ||
+      step.text.includes('fresh browser') ||
+      step.text.includes('new browser session'),
+    resolver: (step, context) => ({
+      templateName: 'clear-browser-state',
+      data: {},
+      comment: `Clear browser state (cookies, storage)`,
+    }),
+    priority: 8,
+  },
+];

package/src/patterns/table-patterns.ts

@@ -0,0 +1,279 @@
+/**
+ * Table Patterns
+ * Handles: table row assertions, table cell lookups, actions in table rows
+ *
+ * Syntax (v2.4 final):
+ * - User see [Col] column in [Table] table                             # column exists
+ * - User see [Ref] row in [Table] table with {{value}}                 # row exists (enters row scope)
+ * - User see [Ref] row in [Table] table with {{value}} is hidden       # row hidden
+ * - User see [Table] table with {{count}}                              # row count
+ * - User see [Table] table is empty                                    # empty table
+ * - User see [Col] column with {{value}}                               # cell value (row scoped — handled in step-mapper)
+ * - User click [Act] button in [Table] table with {{filter}}           # action in row
+ * - User see [Table] table match data:                                 # exact table match with inline DataTable
+ *       | Header1    | Header2    |
+ *       | {{value1}} | {{value2}} |
+ */
+
+import { StepPattern, PatternContext } from '@sun-asterisk/sungen';
+
+/** Helper: check if current step is in a Given context */
+function isGivenContext(context: PatternContext): boolean {
+  return context.effectiveKeyword === 'Given';
+}
+
+/** Map Gherkin element type to Playwright ARIA role */
+const typeToRole: Record<string, string> = {
+  button: 'button',
+  link: 'link',
+  checkbox: 'checkbox',
+  icon: 'img',
+  image: 'img',
+  radio: 'radio',
+  switch: 'switch',
+};
+
+export const tablePatterns: StepPattern[] = [
+  // "User see [Table] table with {{count}}" — row count (no "rows" keyword needed)
+  {
+    name: 'table-row-count',
+    matcher: (step) => {
+      return step.elementType === 'table' &&
+             /\btable\s+with\b/i.test(step.text) &&
+             !!step.dataRef &&
+             !/\brow\b/i.test(step.text) &&
+             !/\bcolumn\b/i.test(step.text) &&
+             !/\bempty\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+      const count = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+
+      const isGiven = isGivenContext(context);
+      return {
+        templateName: 'table-row-count',
+        data: { ...resolved, expectedCount: count, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table has ${count} rows`,
+      };
+    },
+    priority: 16,
+  },
+
+  // "User see [Col] column in [Table] table"
+  {
+    name: 'table-column-exists',
+    matcher: (step) => {
+      return /\bcolumn\s+in\b/i.test(step.text) &&
+             /\btable\b/i.test(step.text) &&
+             !step.dataRef;
+    },
+    resolver: (step, context) => {
+      // brackets[0] = Col, brackets[1] = Table
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const columnName = brackets[0]?.replace(/[\[\]]/g, '') || 'Unknown';
+      const tableName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : brackets[0]?.replace(/[\[\]]/g, '') || '';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', step.nth
+      );
+
+      const isGiven = isGivenContext(context);
+      return {
+        templateName: 'table-column-exists',
+        data: { ...resolved, columnName, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${columnName} column in ${tableName} table`,
+      };
+    },
+    priority: 16,
+  },
+
+  // "User see [Table] table is empty"
+  {
+    name: 'table-is-empty',
+    matcher: (step) => {
+      return /\btable\s+is\s+empty\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+
+      const isGiven = isGivenContext(context);
+      return {
+        templateName: 'table-empty',
+        data: { ...resolved, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table is empty`,
+      };
+    },
+    priority: 16,
+  },
+
+  // "User see [Ref] row in [Table] table with {{value}}" — row exists (enters row scope)
+  {
+    name: 'table-row-exists',
+    matcher: (step) => {
+      return step.elementType === 'row' &&
+             /\bin\b.*\btable\b/i.test(step.text) &&
+             /\bwith\b/i.test(step.text) &&
+             !!step.dataRef &&
+             !/\bis\s+hidden\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      // brackets[0] = Ref (row label), brackets[1] = Table
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const rowLabel = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const tableName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : '';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', step.nth
+      );
+      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+
+      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}`,
+      };
+    },
+    priority: 17,
+  },
+
+  // "User see [Ref] row in [Table] table with {{value}} is hidden"
+  {
+    name: 'table-row-hidden',
+    matcher: (step) => {
+      return step.elementType === 'row' &&
+             /\bin\b.*\btable\b/i.test(step.text) &&
+             /\bwith\b/i.test(step.text) &&
+             !!step.dataRef &&
+             /\bis\s+hidden\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      // brackets[0] = Ref (row label), brackets[1] = Table
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const rowLabel = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const tableName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : '';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', step.nth
+      );
+      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+
+      const isGiven = isGivenContext(context);
+      return {
+        templateName: 'table-row-not-exists',
+        data: { ...resolved, filterValue, isGiven },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table is hidden`,
+      };
+    },
+    priority: 19,
+  },
+
+  // "User click [Act] button in [Table] table with {{filter}}" — action in row
+  {
+    name: 'table-action-in-row',
+    matcher: (step) => {
+      return /\bin\b.*\btable\b/i.test(step.text) &&
+             /\bwith\b/i.test(step.text) &&
+             !!step.dataRef &&
+             step.elementType !== 'column' &&
+             step.elementType !== 'row' &&
+             step.elementType !== 'table';
+    },
+    resolver: (step, context) => {
+      // brackets[0] = Act (element name), brackets[1] = Table
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const elementName = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const tableName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : '';
+
+      const filterValue = step.dataRef
+        ? context.dataResolver.resolveData(step.dataRef, context.featureName)
+        : '';
+
+      const tableResolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', 0
+      );
+
+      // Determine action from step text
+      const actionMatch = step.text.match(/\b(click|check|uncheck)\b/i);
+      const action = actionMatch ? actionMatch[1].toLowerCase() : 'click';
+
+      // Extract element type (word after [Act]) and map to ARIA role
+      const elementTypeMatch = step.text.match(/\]\s+([\w-]+)\s+in\b/i);
+      const elementType = elementTypeMatch ? elementTypeMatch[1].toLowerCase() : 'button';
+      const elementRole = typeToRole[elementType] || elementType;
+
+      return {
+        templateName: 'table-action-in-row',
+        data: { ...tableResolved, elementName, filterValue, action, elementRole },
+        comment: `${action} ${elementName} in ${tableName} table row with ${step.dataRef}`,
+      };
+    },
+    priority: 17,
+  },
+
+  // "User see [Table] table match data:" — filter-based table match with inline DataTable
+  // First row = headers, remaining rows = expected data
+  // Uses filter({ hasText }) per row — resilient to data changes, row ordering, extra rows
+  {
+    name: 'table-match-data',
+    matcher: (step) => {
+      return step.elementType === 'table' &&
+             /\btable\s+match\s+data\b/i.test(step.text) &&
+             !!step.dataTable;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+
+      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
+      const assertions: string[] = [];
+      for (const row of resolvedRows) {
+        const filters = row.cells
+          .map(cell => `.filter({ hasText: '${cell.replace(/'/g, "\\'")}' })`)
+          .join('');
+        assertions.push(
+          `await expect(rows${filters}).toBeVisible();`
+        );
+      }
+
+      const isGiven = isGivenContext(context);
+      return {
+        templateName: 'table-match-data',
+        data: {
+          ...resolved,
+          assertions,
+          isGiven,
+        },
+        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table contains ${resolvedRows.length} expected row(s)`,
+      };
+    },
+    priority: 20, // Higher than other table patterns to match first
+  },
+];