@sungen/driver-ui 3.2.34 → 3.3.0-alpha.2

package/dist/patterns/assertion-patterns.js

@@ -0,0 +1,903 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertionPatterns = void 0;
+const sungen_1 = require("@sun-asterisk/sungen");
+const sungen_2 = require("@sun-asterisk/sungen");
+const sungen_3 = require("@sun-asterisk/sungen");
+const url_path_regex_1 = require("../utils/url-path-regex");
+const column_header_1 = require("../utils/column-header");
+/**
+ * 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) {
+    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;
+}
+/** Locator-strategy element-type tokens that name a LIST MEMBER (many-matching by design —
+ *  custom widgets with no role, e.g. a 96-slot time picker). Text assertions on these must
+ *  filter the multi-locator by the value first: a bare toHaveText/toContainText on the raw
+ *  locator strict-mode-fails. The role-strategy counterpart is LIST_MEMBER_ROLES. */
+const LOCATOR_LIST_MEMBER_TYPES = new Set(['item', 'listitem', 'option', 'cell']);
+/** Resolved strategies that pin a node by IDENTITY rather than by the text it renders. A
+ *  `see [X] label with {{v}}` step honours these as real locators and asserts their text (#666).
+ *
+ *  The omissions are deliberate, not an oversight: `text` finds the node by the very caption the
+ *  label pattern is about, so honouring it would assert the caption contains the value; `label`
+ *  (getByLabel) and `placeholder` resolve the labelled CONTROL, whose content is a `value`, not
+ *  text; `role` names an element through its accessible name, which for a caption IS the caption.
+ *  Each of those keeps the caption+value text reading. */
+const IDENTITY_STRATEGIES = new Set([
+    'testid', 'id', 'css', 'locator', 'xpath',
+    'accessibility-id', 'android-uiautomator', 'ios-predicate',
+]);
+/**
+ * INVARIANT — a pattern whose generated code accounts for a trailing state clause (`… is hidden`)
+ * MUST declare it in `states`. Undeclared, the clause reaches SG-E021 and the step compiles to a
+ * `throw`; over-declared, the clause is silently dropped and the assertion reads as something it is
+ * not. Determine the truth from the TEMPLATE the resolver names, never from the matcher.
+ *
+ * Deliberately NOT declared, because each really does drop the clause today: `page-assertion`
+ * (a page has no state — this was the original defect), `wait-for-page`, `table-row-exists`,
+ * `table-column-exists`, `see-with-variable`, `alert-text-assertion`, `all-contain-element`.
+ */
+exports.assertionPatterns = [
+    // Browser alert text assertion: "see [Are you sure?] alert"
+    {
+        name: 'alert-text-assertion',
+        matcher: (step) => (step.text.includes('see') || step.text.includes('sees')) &&
+            step.elementType === 'alert' &&
+            !!step.selectorRef,
+        resolver: (step, context) => {
+            let dataValue = step.selectorRef || '';
+            if (step.dataRef) {
+                dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            }
+            return {
+                templateName: 'alert-text-assertion',
+                data: { dataValue, stepCounter: context.stepCounter },
+                comment: `Assert browser alert contains "${step.selectorRef}"`,
+            };
+        },
+        priority: 21,
+    },
+    // Column cell assertion: "see [Department] column 1 with {{value}}" -> check table cell text
+    {
+        name: 'column-cell-assertion',
+        platforms: ['web'],
+        platformAlternative: 'HTML table roles have no native equivalent - assert the row element itself by accessibility-id (`Then User see [Row 2 Amount] has text {{v}}`), or tag the scenario @manual',
+        matcher: (step) => (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+            !!step.selectorRef &&
+            !!step.dataRef &&
+            (step.elementType === 'column' || step.elementType === 'columnheader'),
+        resolver: (step, context) => {
+            let dataValue;
+            dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            // getByRole('row') includes header row as nth(0), so Gherkin nth=1 maps to locator nth(1)
+            const rowNth = step.nth || 1;
+            // Create a safe variable name from column name
+            const columnIndexVar = `colIndex${step.selectorRef.replace(/[^a-zA-Z0-9]/g, '')}`;
+            // The header TEXT this template matches on — both the visibility assertion and the
+            // findIndex scan — is declarable; the bracket label is only the fallback (issue #674).
+            // No table is named by this step form, so only the `<col>--columnheader` entry applies.
+            const columnName = (0, column_header_1.resolveColumnHeaderName)(step.selectorRef, context);
+            return {
+                templateName: 'column-cell-assertion',
+                data: {
+                    columnName,
+                    rowNth,
+                    columnIndexVar,
+                    dataValue,
+                },
+                comment: `Assert ${step.selectorRef} column row ${step.nth || 1} has text ${step.dataRef}`,
+            };
+        },
+        priority: 15, // Higher than all other assertion patterns
+    },
+    // Page assertion pattern: "see [home] page" -> check URL matches selector value
+    {
+        name: 'page-assertion',
+        matcher: (step) => (step.text.includes('should see') ||
+            step.text.includes('see') ||
+            step.text.includes('sees')) &&
+            step.elementType === 'page',
+        resolver: (step, context) => {
+            // Fallback is the feature's declared Path (context.featurePath) — the page under test.
+            // `step.featurePath` is never populated by the parser, so it always degraded to '/'.
+            const fallbackPath = context.featurePath || '/';
+            let path = fallbackPath;
+            // The page's declared `anchor:` — the element that proves the page rendered. Without it the
+            // step is a URL-only oracle, which a client-side router can satisfy for a few hundred
+            // milliseconds before a guard bounces the user away (#662).
+            let anchor;
+            // The page entry's `query: any` (#748) — set below, once the entry is known to BE a page.
+            let ignoreQuery = false;
+            // If selector is present, extract path from selector's value attribute
+            if (step.selectorRef) {
+                try {
+                    const resolved = context.selectorResolver.resolveSelector(step.selectorRef, context.featureName, step.elementType, step.nth);
+                    // Only a `page`-type entry carries a URL in `value`. Selector keys can collide across
+                    // types (a single `読取結果一覧` entry of type `role` reused for a page assertion), and a
+                    // key-only lookup happily returns that button entry — whose `value` ('button') is not a
+                    // URL. Guard on the entry kind: use `value` only for a page selector, else fall back to
+                    // the feature path rather than compiling `toHaveURL(/button/)`.
+                    path = resolved.selectorType === 'page' ? (resolved.value || fallbackPath) : fallbackPath;
+                    if (resolved.selectorType === 'page' && resolved.anchor)
+                        anchor = { ...resolved.anchor };
+                    // `query: any` — the query is not part of this page's identity (#748). Gated on the entry
+                    // KIND for the same reason `value` and `anchor` are: a key collision can hand back a
+                    // non-page entry, and reading a stray field off it would silently weaken the assertion.
+                    if (resolved.selectorType === 'page' && resolved.query === 'any')
+                        ignoreQuery = true;
+                }
+                catch (error) {
+                    // Fallback to feature path if selector not found
+                    path = fallbackPath;
+                }
+            }
+            // `see [X] page with {{v}}` — the query/fragment value the parser put in dataRef. It used
+            // to be dropped here: the step compiled to a bare base-path toHaveURL that PASSES even when
+            // the query is wrong or gone, so a filter/search regression read as green. The `is on` twin
+            // has asserted it since issue #464; this is the same assertion, so it asserts the same way.
+            let query = '';
+            if (step.dataRef) {
+                query = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            }
+            // Convert path to regex-safe string (dynamic :id segments → [^/]+ wildcard). An ABSOLUTE
+            // page value also yields a host pattern: matching only the path let this assertion pass on
+            // any host, so `see [Admin Jobs] page` declared as https://admin.example.com/jobs was
+            // satisfied by the public site's /jobs.
+            const { pathRegex, hostRegex } = (0, url_path_regex_1.urlToPatternParts)(path);
+            const withSuffix = step.dataRef ? ` with ${step.dataRef}` : '';
+            return {
+                templateName: 'page-assertion',
+                // `dataRef` rides along so a runtime failure can name the test-data key an author must go
+                // fix — an empty/absent value is otherwise the hardest kind of red to trace.
+                data: { pathRegex, hostRegex, query, dataRef: step.dataRef || '', anchor, ignoreQuery },
+                comment: step.selectorRef ? `Assert on ${step.selectorRef} page${withSuffix}` : `Assert on page${withSuffix}`,
+            };
+        },
+        priority: 13, // Higher priority than general visibility
+    },
+    // Pattern: Then User see [panel] dialog with {{kudo.title}} hidden -> toBeHidden()
+    {
+        name: 'see-with-variable-hidden',
+        states: ['hidden'],
+        matcher: (step) => (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+            !!step.selectorRef &&
+            !!step.dataRef &&
+            step.text.includes('with') &&
+            /\bis hidden\b/.test(step.text),
+        generator: (step, context) => {
+            let resolved = {};
+            try {
+                resolved = context.selectorResolver.resolveSelector(step.selectorRef, context.featureName, step.elementType, step.nth);
+            }
+            catch (error) { }
+            let dataValue;
+            dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            const escapedVariable = dataValue.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+            if (resolved.strategy === 'locator') {
+                const code = context.templateEngine.renderStep('hidden-with-filter-assertion', {
+                    ...resolved, dataValue, nth: resolved.nth,
+                });
+                return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+            }
+            if (resolved.strategy === 'role' && resolved.role) {
+                // Dialog role: check heading inside dialog instead of filter on full text content
+                if (resolved.role === 'dialog') {
+                    const code = context.templateEngine.renderStep('hidden-dialog-heading-assertion', {
+                        dataValue,
+                    });
+                    return { code, comment: `Assert ${step.selectorRef} dialog hidden with heading ${step.dataRef}` };
+                }
+                const code = context.templateEngine.renderStep('hidden-with-role-variable-assertion', {
+                    role: resolved.role,
+                    name: resolved.name && resolved.name.trim() ? resolved.name : undefined,
+                    dataValue,
+                    nth: resolved.nth,
+                });
+                return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+            }
+            const selectorValue = resolved.value || '';
+            if (selectorValue && selectorValue.trim()) {
+                const code = context.templateEngine.renderStep('hidden-with-filter-assertion', {
+                    ...resolved, dataValue, nth: resolved.nth,
+                });
+                return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+            }
+            const code = context.templateEngine.renderStep('hidden-with-variable-assertion', {
+                selectorRef: step.selectorRef,
+                selectorValue: resolved.value || '',
+                dataValue,
+                nth: resolved.nth,
+            });
+            return { code, comment: `Assert ${step.selectorRef} hidden with ${step.dataRef}` };
+        },
+        priority: 14,
+    },
+    // Pattern: Then User see [submit] button with {{label}} disabled -> toBeDisabled()
+    {
+        name: 'see-with-variable-disabled',
+        states: ['disabled'],
+        matcher: (step) => (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+            !!step.selectorRef &&
+            !!step.dataRef &&
+            step.text.includes('with') &&
+            /\bis disabled\b/.test(step.text),
+        generator: (step, context) => {
+            let resolved = {};
+            try {
+                resolved = context.selectorResolver.resolveSelector(step.selectorRef, context.featureName, step.elementType, step.nth);
+            }
+            catch (error) { }
+            let dataValue;
+            dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            const escapedVariable = dataValue.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+            if (resolved.strategy === 'locator') {
+                const code = context.templateEngine.renderStep('disabled-with-filter-assertion', {
+                    ...resolved, dataValue, nth: resolved.nth,
+                });
+                return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+            }
+            if (resolved.strategy === 'role' && resolved.role) {
+                const code = context.templateEngine.renderStep('disabled-with-role-variable-assertion', {
+                    role: resolved.role,
+                    name: resolved.name && resolved.name.trim() ? resolved.name : undefined,
+                    dataValue,
+                    nth: resolved.nth,
+                });
+                return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+            }
+            const selectorValue = resolved.value || '';
+            if (selectorValue && selectorValue.trim()) {
+                const code = context.templateEngine.renderStep('disabled-with-filter-assertion', {
+                    ...resolved, dataValue, nth: resolved.nth,
+                });
+                return { code, comment: `Assert ${step.selectorRef} disabled with ${step.dataRef}` };
+            }
+            const code = context.templateEngine.renderStep('disabled-with-variable-assertion', {
+                selectorRef: step.selectorRef,
+                selectorValue: resolved.value || '',
+                dataValue,
+                nth: resolved.nth,
+            });
+            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',
+        // Exactly the labels `qualifiedState()` above resolves — `hidden`/`disabled` are excluded
+        // there and owned by the -hidden/-disabled twins.
+        states: ['checked', 'empty', 'enabled', 'focused', 'selected', 'unchecked'],
+        matcher: (step) => (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 = {};
+            try {
+                resolved = context.selectorResolver.resolveSelector(step.selectorRef, context.featureName, step.elementType, step.nth);
+            }
+            catch (error) { }
+            let dataValue;
+            dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            // "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;
+            // A checked/unchecked assertion must NOT compile to toBeChecked() — it throws
+            // "Not a checkbox or radio button" on an aria-pressed toggle exactly as the action side did
+            // (#675). Flag it so the template can route it through expectCheckedState instead, which
+            // reads the same signals setCheckedState drives.
+            let isCheckedAssertion = state.label === 'checked' || state.label === 'unchecked';
+            let checkedWant = state.label === 'checked';
+            if (selectedProbe && resolved.role && ['checkbox', 'radio', 'switch'].includes(resolved.role)) {
+                stateAssertion = 'toBeChecked()';
+                selectedProbe = false;
+                isCheckedAssertion = true;
+                checkedWant = true;
+            }
+            const code = context.templateEngine.renderStep('state-with-filter-assertion', {
+                ...resolved,
+                selectorRef: step.selectorRef,
+                dataValue,
+                stateAssertion,
+                selectedProbe,
+                isCheckedAssertion,
+                checkedWant,
+            });
+            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}}
+    // If selector YAML has empty value, uses variable-only matching
+    // If selector has value, combines both (static text + variable)
+    // Input types → toHaveValue, everything else → toHaveText
+    {
+        name: 'see-with-variable',
+        matcher: (step) => (step.text.includes('should see') ||
+            step.text.match(/\b(see|sees)\s+\[/)) &&
+            !!step.selectorRef &&
+            !!step.dataRef &&
+            step.text.includes('with'),
+        generator: (step, context) => {
+            // Input element types use toHaveValue instead of toHaveText
+            const INPUT_TYPES = new Set([
+                'field', 'textarea', 'search', 'dropdown', 'slider', 'date-picker',
+                'input', 'textbox', 'editor', 'select', 'combobox',
+            ]);
+            // Subset of INPUT_TYPES whose DOM implementation cannot be inferred from the token:
+            // a component library may render any of these as a non-input trigger element.
+            const AMBIGUOUS_VALUE_TYPES = new Set(['dropdown', 'select', 'combobox']);
+            // Resolve data variable value
+            let dataValue;
+            dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            // Resolve selector from YAML with feature context
+            let resolved = {};
+            try {
+                resolved = context.selectorResolver.resolveSelector(step.selectorRef, context.featureName, step.elementType, step.nth);
+            }
+            catch (error) {
+                // Selector not in YAML or context issue - will use variable-only
+            }
+            // --- Attribute assertion: toHaveAttribute ---
+            // When selector YAML has `attribute` field (e.g., attribute: 'src', 'href')
+            if (resolved.attribute) {
+                const code = context.templateEngine.renderStep('attribute-assertion', {
+                    ...resolved,
+                    dataValue,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} ${resolved.attribute} matches ${step.dataRef}`,
+                };
+            }
+            // --- Input types: toHaveValue ---
+            // `dropdown`/`select`/`combobox` are AMBIGUOUS: ARIA role `combobox` is worn both by a
+            // native <select> and by a `<button role="combobox">` trigger (Radix/shadcn, MUI,
+            // Headless UI). toHaveValue() reads the DOM `value` property, which a button has not got
+            // — hence the runtime "Not an input element". Resolution follows the app-profile layering
+            // (sungen_app_profile_spec.md §3): per-element `variant:` / app-profile recipe wins, and
+            // the built-in default probes the tag at runtime instead of assuming a native input.
+            if (step.elementType && INPUT_TYPES.has(step.elementType)) {
+                const ambiguous = (AMBIGUOUS_VALUE_TYPES.has(step.elementType) ||
+                    ['combobox', 'listbox'].includes(resolved.role)) &&
+                    resolved.variant !== 'native';
+                if (ambiguous) {
+                    // `assertValue` is the third recipe intent the app-profile spec defines alongside
+                    // `fill`/`select` (spec §3.1). Same lookup shape as the select-dropdown fork.
+                    const variantName = resolved.variant || context.appProfile?.widgetVariants?.['select'];
+                    const recipeSteps = variantName && variantName !== 'native'
+                        ? context.appProfile?.recipes?.[variantName]?.['assertValue']
+                        : undefined;
+                    if (recipeSteps) {
+                        try {
+                            const steps = (0, sungen_2.expandRecipe)(recipeSteps, {
+                                triggerCode: context.renderLocator(resolved),
+                                value: dataValue,
+                            });
+                            return {
+                                code: context.templateEngine.renderStep('recipe-sequence', { steps }),
+                                comment: `Assert ${step.selectorRef} has value ${step.dataRef} (${variantName} recipe)`,
+                            };
+                        }
+                        catch {
+                            // malformed recipe -> fall through to the runtime probe below
+                        }
+                    }
+                }
+                const code = context.templateEngine.renderStep('have-value-assertion', {
+                    ...resolved,
+                    dataValue,
+                    probeNative: ambiguous,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} has value ${step.dataRef}`,
+                };
+            }
+            // --- Label-value pattern: "User see [X] label with {{Y}}" ---
+            if (step.elementType === 'label' && step.dataRef) {
+                // A `label` ref reads two different ways, and the selectors.yaml entry decides which.
+                //
+                // NO ENTRY, or an entry that finds its element BY TEXT — the ref names on-screen
+                // CAPTION text rather than an element, so the assertion is "the screen shows
+                // `X <value>`". That is what label-value-assertion renders, and it stays the default.
+                //
+                // AN ENTRY NAMING A CONCRETE NODE (xpath / accessibility-id / testid / id / css / …) —
+                // the author has said WHERE the value lives. That locator used to be resolved and then
+                // thrown away, leaving a page-wide text match: on Android `UiSelector().text(v)`, which
+                // reads only @text, so a Flutter/RN node exposing @content-desc never matched. The
+                // entry was correct and the step failed every time (#666). Honouring it puts `label`
+                // alongside `header`, which never had the special case.
+                //
+                // CONTAINS, not exact: an entry for a label/value pair points legitimately either at
+                // the value node ("JD-001") or at the row holding both ("Job No: JD-001"), and the web
+                // regex it replaces was itself anchored only at the end. `exact: true` opts into the
+                // strict comparison.
+                //
+                // `resolved` is the SAME lookup, already performed above — this branch used to repeat it.
+                if (IDENTITY_STRATEGIES.has(resolved.strategy)) {
+                    const code = context.templateEngine.renderStep(resolved.exact ? 'have-text-assertion' : 'contain-text-assertion', { ...resolved, expectedText: dataValue });
+                    return {
+                        code,
+                        comment: `Assert ${step.selectorRef} label ${resolved.exact ? 'has' : 'contains'} value ${step.dataRef}`,
+                    };
+                }
+                // `value: ''` is the declared opt-out: drop the caption prefix, match the value alone.
+                const label = resolved.value !== undefined && resolved.value.trim() === ''
+                    ? undefined
+                    : step.selectorRef;
+                // The locator here is built from the CAPTION, not from `resolved` — the common case has no
+                // selectors.yaml entry at all, so `resolved` is `{}` and carries nothing. The scope
+                // therefore comes off the context, which `withParentScope` sets whether or not the entry
+                // lookup succeeded; without it `… in [Education Card 6] card` was dropped silently and the
+                // assertion read whichever card the page happened to render first (#747).
+                const code = context.templateEngine.renderStep('label-value-assertion', {
+                    label,
+                    dataValue,
+                    parentLocator: context.parentLocator,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} label with value ${step.dataRef}`,
+                };
+            }
+            // --- Dialog role: check heading inside dialog ---
+            if (resolved.strategy === 'role' && resolved.role === 'dialog') {
+                const code = context.templateEngine.renderStep('visible-dialog-heading-assertion', {
+                    dataValue,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} dialog with heading ${step.dataRef}`,
+                };
+            }
+            // --- Image role: images have no text, use name ---
+            if (resolved.strategy === 'role' && resolved.role === 'img') {
+                const hasName = resolved.name && resolved.name.trim();
+                const code = context.templateEngine.renderStep('visible-with-role-variable-assertion', {
+                    role: resolved.role,
+                    name: hasName ? resolved.name : dataValue,
+                    exact: resolved.exact || false,
+                    nth: resolved.nth,
+                    // Rebuilt field by field rather than spread from `resolved`, so the scope `withParentScope`
+                    // stamped there never arrives — the label branch's twin defect (#747).
+                    parentLocator: resolved.parentLocator ?? context.parentLocator,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} image with name ${step.dataRef}`,
+                };
+            }
+            // --- Everything else: toHaveText (exact full match) ---
+            // Locator-strategy LIST MEMBERS first: `see [X] item|option|cell with {{v}}` on a
+            // CSS-locator list means "a member whose text is v exists". A bare toHaveText on the
+            // multi-matching locator strict-mode-fails, so filter by the value then assert
+            // visible — the locator counterpart of the role-based branch below. The filter
+            // matches by SUBSTRING (Playwright's standard hasText) unless the selector YAML
+            // declares `exact: true` — the same contract as the role branch; a hardcoded exact
+            // here rejected members whose rendered text wraps the value (icons, counts, i18n
+            // suffixes) with no way to opt out. Unique-element types (text/message/…)
+            // keep toHaveText: that is a VALUE assertion and must not be weakened to existence.
+            if (resolved.strategy === 'locator' && step.elementType && LOCATOR_LIST_MEMBER_TYPES.has(step.elementType)) {
+                const code = context.templateEngine.renderStep('visible-filtered-assertion', {
+                    ...resolved,
+                    dataValue,
+                });
+                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', {
+                    ...resolved,
+                    expectedText: dataValue,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+                };
+            }
+            // List-member roles: `see [X] item with {{v}}` on a dynamic list/dropdown means
+            // "an item whose text is v exists" — filter the (many-matching) locator by the value
+            // then assert visible, mirroring click-element-with-text. Plain toHaveText on the bare
+            // getByRole('listitem') strict-mode-fails when many match. SCOPED to role-based
+            // list-member roles only (listitem/option/cell) — unique labelled elements keep
+            // toHaveText (value check), and locator-type lists are unchanged. `row` is excluded
+            // (table rows have dedicated existence patterns).
+            // The name is NOT stripped here any more. It used to be dropped unconditionally, which also
+            // discarded a `name:` the user had declared explicitly — and the strip only ever protected
+            // THIS branch, leaving `is hidden` / `is disabled` to compile the invented name into a locator
+            // that matches nothing. The resolver now withholds the invented name at its source
+            // (LIST_MEMBER_ROLES in selector-resolver), so every branch is covered and an explicit name
+            // still reaches the locator. What stays here is the ROUTING: filter-then-visible instead of
+            // toHaveText, because a bare getByRole('listitem') strict-mode-fails when many match.
+            if (resolved.strategy === 'role' && resolved.role && sungen_3.LIST_MEMBER_ROLES.has(resolved.role)) {
+                const code = context.templateEngine.renderStep('visible-filtered-assertion', {
+                    ...resolved,
+                    dataValue,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} with text ${step.dataRef} is present`,
+                };
+            }
+            // Role-based selector
+            if (resolved.strategy === 'role' && resolved.role) {
+                const hasName = resolved.name && resolved.name.trim();
+                const code = context.templateEngine.renderStep('have-text-assertion', {
+                    ...resolved,
+                    expectedText: dataValue,
+                });
+                return {
+                    code,
+                    comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+                };
+            }
+            // Text/placeholder/testid/other strategies
+            const code = context.templateEngine.renderStep('have-text-assertion', {
+                ...resolved,
+                expectedText: dataValue,
+            });
+            return {
+                code,
+                comment: `Assert ${step.selectorRef} has text ${step.dataRef}`,
+            };
+        },
+        priority: 13,
+    },
+    {
+        name: 'should-be-visible',
+        // `is visible` is redundant (bare `see [X] type` already asserts it) but harmless — the review
+        // checklist flags the redundancy; the compiler must not turn it into a hard failure.
+        states: ['visible'],
+        matcher: (step) => (step.text.includes('should be visible') ||
+            step.text.includes('should be displayed') ||
+            step.text.includes('should see') ||
+            step.text.match(/\b(see|sees)\s+\[/)) &&
+            !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'visible-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is visible`,
+            };
+        },
+        priority: 10,
+    },
+    {
+        name: 'is-hidden',
+        states: ['hidden'],
+        // "see [target] is hidden" — no variable version; with-variable handled by see-with-variable-hidden
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis hidden\b/.test(step.text) &&
+            !step.dataRef && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'is-hidden-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is not visible`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'should-be-enabled',
+        states: ['enabled'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis enabled\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'enabled-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is enabled`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'should-be-disabled',
+        states: ['disabled'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis disabled\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'disabled-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is disabled`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        // `matches "<format>"` — assert the SHAPE of a label, not its value. A spec states a label's
+        // contract as "Format: yyyy/mm/dd ~ yyyy/mm/dd" or "Format: 残りX個"; neither existing text
+        // assertion can carry that (an exact value pins data that changes daily, `contains` passes on
+        // anything). Requires the quoted form so it cannot claim the API-side `matches schema [Ref]`.
+        // Priority above should-have-text / should-contain-text (both 12): those match on the words
+        // "has text" / "contains", which a format step does not use, but the generic visibility
+        // catch-all would otherwise take an unrecognised `see [X] label matches …`.
+        name: 'matches-format',
+        matcher: (step) => /\bmatches\s+"/i.test(step.text) && !!step.selectorRef && !!step.value,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'matches-format-assertion',
+                // `format` rides along so a failure message can name the shape the author asked for —
+                // a bare regex in the error is the hardest kind of red for a QA to read.
+                data: { ...resolved, selectorRef: step.selectorRef, formatRegex: (0, sungen_1.formatToRegexLiteral)(step.value), format: step.value },
+                comment: `Assert ${step.selectorRef} matches the format "${step.value}"`,
+            };
+        },
+        priority: 16,
+    },
+    {
+        name: 'should-contain-text',
+        matcher: (step) => (step.text.includes('should contain') || step.text.includes('contains')) && !!step.selectorRef && !!(step.value || step.dataRef),
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            const expectedText = step.value || context.dataResolver.resolveData(step.dataRef, context.featureName);
+            const comment = `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`;
+            // LIST MEMBERS (locator item/option/cell types, role listitem/option/cell): the
+            // locator matches many elements by design, so a bare toContainText strict-mode-fails.
+            // `contains` on a list means "a member containing v exists" — filter by the substring
+            // then assert visible, the same routing the with-{{v}} existence branches use.
+            // Always substring here (never the YAML `exact`): the step itself says "contains".
+            // Unique elements keep toContainText below — a VALUE assertion is not weakened.
+            // A role entry pinned to ONE element (explicit `name:` or `nth:`) counts as unique:
+            // filter-then-visible would turn its value check into a visibility gate (a collapsed
+            // but present member would flip from pass to fail with a worse failure message).
+            const isListMember = (resolved.strategy === 'locator' && step.elementType && LOCATOR_LIST_MEMBER_TYPES.has(step.elementType)) ||
+                (resolved.strategy === 'role' && !!resolved.role && sungen_3.LIST_MEMBER_ROLES.has(resolved.role) &&
+                    !(resolved.name && resolved.name.trim()) && resolved.nth == null);
+            if (isListMember) {
+                return {
+                    templateName: 'visible-filtered-assertion',
+                    data: { ...resolved, exact: false, dataValue: expectedText },
+                    comment,
+                };
+            }
+            return {
+                templateName: 'contain-text-assertion',
+                data: { ...resolved, expectedText },
+                comment,
+            };
+        },
+        priority: 12,
+    },
+    {
+        name: 'should-have-text',
+        matcher: (step) => (step.text.includes('should have text') || step.text.includes('has text')) && !!step.selectorRef && !!(step.value || step.dataRef),
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            const expectedText = step.value || context.dataResolver.resolveData(step.dataRef, context.featureName);
+            return {
+                templateName: 'have-text-assertion',
+                data: { ...resolved, expectedText },
+                comment: `Assert ${step.selectorRef} has text "${step.value || step.dataRef}"`,
+            };
+        },
+        priority: 12,
+    },
+    {
+        name: 'is-empty',
+        states: ['empty'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis empty\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'empty-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is empty`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'is-checked',
+        states: ['checked'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis checked\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'checked-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is checked`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'is-unchecked',
+        states: ['unchecked'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis unchecked\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'not-checked-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is unchecked`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'is-focused',
+        states: ['focused'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis focused\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'focused-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is focused`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'see-data-text',
+        matcher: (step) => (step.text.includes('should see') ||
+            step.text.match(/\b(see|sees)\b/)) &&
+            !step.selectorRef &&
+            !!step.dataRef,
+        resolver: (step, context) => {
+            // Resolve data reference to actual value
+            let dataValue;
+            dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
+            return {
+                templateName: 'visible-assertion',
+                data: {
+                    strategy: 'text',
+                    value: dataValue,
+                },
+                comment: `Assert ${step.dataRef} is visible`,
+            };
+        },
+        priority: 5, // Lower than selector-based assertions
+    },
+    {
+        name: 'list-item-count',
+        matcher: (step) => step.text.includes('should have') && step.text.includes('count') &&
+            !!step.selectorRef && step.text.includes('items') &&
+            (step.elementType === 'list' || step.elementType === 'list-item' || step.elementType === 'listitem'),
+        resolver: (step, context) => {
+            let expectedCount = 1;
+            const match = step.text.match(/count\s+(\d+)/);
+            if (match) {
+                expectedCount = parseInt(match[1]);
+            }
+            else if (step.dataRef) {
+                const resolvedData = context.dataResolver.resolveData(step.dataRef, context.featureName);
+                const parsed = parseInt(resolvedData);
+                expectedCount = isNaN(parsed) ? 1 : parsed;
+            }
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'list-item-count-assertion',
+                data: { ...resolved, expectedCount },
+                comment: `Assert ${step.selectorRef} list has ${expectedCount} items`,
+            };
+        },
+        priority: 9, // Higher than should-have-count (8)
+    },
+    {
+        name: 'should-have-count',
+        matcher: (step) => step.text.includes('should have') && step.text.includes('count') && !!step.selectorRef,
+        resolver: (step, context) => {
+            let expectedCount = 1;
+            // Try literal digit first: "count 10"
+            const match = step.text.match(/count\s+(\d+)/);
+            if (match) {
+                expectedCount = parseInt(match[1]);
+            }
+            else if (step.dataRef) {
+                // Resolve data reference: "count {{number_items}}"
+                const resolvedData = context.dataResolver.resolveData(step.dataRef, context.featureName);
+                const parsed = parseInt(resolvedData);
+                expectedCount = isNaN(parsed) ? 1 : parsed;
+            }
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'count-assertion',
+                data: { ...resolved, expectedCount },
+                comment: `Assert ${step.selectorRef} has count ${expectedCount}`,
+            };
+        },
+        priority: 8,
+    },
+    {
+        name: 'is-loading',
+        states: ['loading'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis loading\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'loading-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is loading`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'is-selected',
+        states: ['selected'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bis selected\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'selected-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef },
+                comment: `Assert ${step.selectorRef} is selected`,
+            };
+        },
+        priority: 11,
+    },
+    {
+        name: 'is-sorted-ascending',
+        platforms: ['web'],
+        platformAlternative: 'aria-sort has no native equivalent - read the item texts with per-element assertions and compare them, or tag the scenario @manual',
+        states: ['sorted ascending'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bsorted ascending\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'sorted-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef, sortDirection: 'ascending' },
+                comment: `Assert ${step.selectorRef} is sorted ascending`,
+            };
+        },
+        priority: 12,
+    },
+    {
+        name: 'is-sorted-descending',
+        platforms: ['web'],
+        platformAlternative: 'aria-sort has no native equivalent - read the item texts with per-element assertions and compare them, or tag the scenario @manual',
+        states: ['sorted descending'],
+        matcher: (step) => /\b(see|sees)\s+\[/.test(step.text) && /\bsorted descending\b/.test(step.text) && !!step.selectorRef,
+        resolver: (step, context) => {
+            const resolved = context.selectorResolver.resolveSelector(step.selectorRef, undefined, step.elementType, step.nth);
+            return {
+                templateName: 'sorted-assertion',
+                data: { ...resolved, selectorRef: step.selectorRef, sortDirection: 'descending' },
+                comment: `Assert ${step.selectorRef} is sorted descending`,
+            };
+        },
+        priority: 12,
+    },
+];
+//# sourceMappingURL=assertion-patterns.js.map