@sun-asterisk/sungen 3.1.1 → 3.1.2-beta.101

package/dist/generators/test-generator/patterns/assertion-patterns.js

@@ -1,626 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertionPatterns = void 0;
-/**
- * Assertion patterns: visibility, text content, state, attributes
- * Uses template engine for framework-agnostic code generation
- */
-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) {
-                try {
-                    dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
-                }
-                catch {
-                    dataValue = `\${${step.dataRef}}`;
-                }
-            }
-            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',
-        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;
-            try {
-                dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
-            }
-            catch (error) {
-                dataValue = `\${${step.dataRef}}`;
-            }
-            // 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, '')}`;
-            return {
-                templateName: 'column-cell-assertion',
-                data: {
-                    columnName: step.selectorRef,
-                    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) => {
-            let path = step.featurePath || '/';
-            // 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);
-                    // Use selector's value as the path for URL assertion
-                    path = resolved.value || path;
-                }
-                catch (error) {
-                    // Fallback to feature path if selector not found
-                    path = step.featurePath || '/';
-                }
-            }
-            // Convert path to regex-safe string
-            const pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-            return {
-                templateName: 'page-assertion',
-                data: { pathRegex },
-                comment: step.selectorRef ? `Assert on ${step.selectorRef} page` : `Assert on page`,
-            };
-        },
-        priority: 13, // Higher priority than general visibility
-    },
-    // Pattern: Then User see [panel] dialog with {{kudo.title}} hidden -> toBeHidden()
-    {
-        name: 'see-with-variable-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;
-            try {
-                dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
-            }
-            catch (error) {
-                dataValue = `\${${step.dataRef}}`;
-            }
-            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',
-        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;
-            try {
-                dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
-            }
-            catch (error) {
-                dataValue = `\${${step.dataRef}}`;
-            }
-            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,
-    },
-    // 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',
-            ]);
-            // Resolve data variable value
-            let dataValue;
-            try {
-                dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
-            }
-            catch (error) {
-                dataValue = `\${${step.dataRef}}`;
-            }
-            // 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 ---
-            if (step.elementType && INPUT_TYPES.has(step.elementType)) {
-                const code = context.templateEngine.renderStep('have-value-assertion', {
-                    ...resolved,
-                    dataValue,
-                });
-                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) {
-                let label = step.selectorRef;
-                try {
-                    const labelResolved = context.selectorResolver.resolveSelector(step.selectorRef, context.featureName, step.elementType, step.nth);
-                    if (labelResolved.value !== undefined && labelResolved.value.trim() === '') {
-                        label = undefined;
-                    }
-                }
-                catch {
-                    // No selector entry — use label from selectorRef
-                }
-                const code = context.templateEngine.renderStep('label-value-assertion', {
-                    label,
-                    dataValue,
-                });
-                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,
-                });
-                return {
-                    code,
-                    comment: `Assert ${step.selectorRef} image with name ${step.dataRef}`,
-                };
-            }
-            // --- Everything else: toHaveText (exact full match) ---
-            // 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}`,
-                };
-            }
-            // 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',
-        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',
-        // "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',
-        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',
-        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,
-    },
-    {
-        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);
-            return {
-                templateName: 'contain-text-assertion',
-                data: { ...resolved, expectedText },
-                comment: `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`,
-            };
-        },
-        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',
-        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',
-        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',
-        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',
-        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;
-            try {
-                dataValue = context.dataResolver.resolveData(step.dataRef, context.featureName);
-            }
-            catch (error) {
-                dataValue = `\${${step.dataRef}}`;
-            }
-            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) {
-                try {
-                    const resolvedData = context.dataResolver.resolveData(step.dataRef, context.featureName);
-                    const parsed = parseInt(resolvedData);
-                    expectedCount = isNaN(parsed) ? 1 : parsed;
-                }
-                catch {
-                    expectedCount = `\${${step.dataRef}}`;
-                }
-            }
-            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}}"
-                try {
-                    const resolvedData = context.dataResolver.resolveData(step.dataRef, context.featureName);
-                    const parsed = parseInt(resolvedData);
-                    expectedCount = isNaN(parsed) ? 1 : parsed;
-                }
-                catch {
-                    expectedCount = `\${${step.dataRef}}`;
-                }
-            }
-            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',
-        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',
-        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',
-        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',
-        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