@skbkontur/playwright-react-ui-components 1.13.2 → 1.14.0-beta.2

package/build/src/matchers/componentMatchers.d.ts

@@ -0,0 +1,104 @@
+declare const matchers: {
+    readonly toBeEmptyEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0?: import("..").EmptyOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeVisibleEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeHiddenEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").HiddenOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeEnabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeDisabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeFocusedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeFocusableElementLocator, args_0?: import("..").FocusedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveAttributeEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveAttributeElementLocator, args_0: string, args_1?: string | RegExp | undefined, args_2?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0: string | number | RegExp | readonly (string | RegExp)[] | {
+        start?: string;
+        end?: string;
+    }, args_1?: import("..").ValueOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string | RegExp | readonly (string | RegExp)[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveCountEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").ComponentList<any>, args_0: number, args_1?: import("..").CountOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string | RegExp | readonly (string | RegExp)[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeAutoMode: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FxInput, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUnchecked: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeActiveTab: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeInactiveTab: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedByValue: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedByIndex: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUncheckedByValue: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUncheckedByIndex: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedByText: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUncheckedByText: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveHref: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Link, args_0: string | RegExp, args_1?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveItems: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveError: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveWarning: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveActiveTab: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string | RegExp) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHavePageCount: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveActivePage: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveFormattedValue: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveFormattedText: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainItems: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainItem: (this: import("@playwright/test").ExpectMatcherState, component: import("..").MenuComponent & import("./component/LocatorSymbols").ToContainItemElementLocator, args_0: string, args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainTokens: (this: import("@playwright/test").ExpectMatcherState, component: import("..").TokenInput, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainTabs: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainSelectValue: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Select, args_0: string | RegExp | readonly (string | RegExp)[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainFormattedText: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Label, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainUploadedFiles: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FileUploader, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+};
+export type ComponentMatchers = typeof matchers;
+export declare const componentMatchers: import("@playwright/test").Expect<{
+    readonly toBeEmptyEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0?: import("..").EmptyOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeVisibleEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeHiddenEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").HiddenOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeEnabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeDisabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeFocusedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeFocusableElementLocator, args_0?: import("..").FocusedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveAttributeEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveAttributeElementLocator, args_0: string, args_1?: string | RegExp | undefined, args_2?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0: string | number | RegExp | readonly (string | RegExp)[] | {
+        start?: string;
+        end?: string;
+    }, args_1?: import("..").ValueOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string | RegExp | readonly (string | RegExp)[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveCountEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").ComponentList<any>, args_0: number, args_1?: import("..").CountOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string | RegExp | readonly (string | RegExp)[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeAutoMode: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FxInput, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUnchecked: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeActiveTab: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeInactiveTab: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedByValue: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedByIndex: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUncheckedByValue: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUncheckedByIndex: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeCheckedByText: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toBeUncheckedByText: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveHref: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Link, args_0: string | RegExp, args_1?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveItems: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveError: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveWarning: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveActiveTab: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string | RegExp) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHavePageCount: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveActivePage: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveFormattedValue: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toHaveFormattedText: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainItems: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainItem: (this: import("@playwright/test").ExpectMatcherState, component: import("..").MenuComponent & import("./component/LocatorSymbols").ToContainItemElementLocator, args_0: string, args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainTokens: (this: import("@playwright/test").ExpectMatcherState, component: import("..").TokenInput, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainTabs: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainSelectValue: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Select, args_0: string | RegExp | readonly (string | RegExp)[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainFormattedText: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Label, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    readonly toContainUploadedFiles: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FileUploader, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+}>;
+export {};

package/build/src/matchers/componentMatchers.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentMatchers = void 0;
+var test_1 = require("@playwright/test");
+var toBeEmptyEx_1 = require("./component/toBeEmptyEx");
+var toBeVisibleEx_1 = require("./component/toBeVisibleEx");
+var toBeHiddenEx_1 = require("./component/toBeHiddenEx");
+var toBeEnabledEx_1 = require("./component/toBeEnabledEx");
+var toBeDisabledEx_1 = require("./component/toBeDisabledEx");
+var toHaveAttributeEx_1 = require("./component/toHaveAttributeEx");
+var toHaveValueEx_1 = require("./component/toHaveValueEx");
+var toBeFocusedEx_1 = require("./component/toBeFocusedEx");
+var toBeCheckedEx_1 = require("./component/toBeCheckedEx");
+var toBeUnchecked_1 = require("./component/toBeUnchecked");
+var toHaveTextEx_1 = require("./component/toHaveTextEx");
+var toContainTextEx_1 = require("./component/toContainTextEx");
+var toHaveCountEx_1 = require("./component/toHaveCountEx");
+var toHaveItems_1 = require("./component/toHaveItems");
+var toContainItems_1 = require("./component/toContainItems");
+var toContainItem_1 = require("./component/toContainItem");
+var toBeActiveTab_1 = require("./component/toBeActiveTab");
+var toBeInactiveTab_1 = require("./component/toBeInactiveTab");
+var toBeAutoMode_1 = require("./component/toBeAutoMode");
+var toHaveError_1 = require("./component/toHaveError");
+var toHaveWarning_1 = require("./component/toHaveWarning");
+var toContainUploadedFiles_1 = require("./component/toContainUploadedFiles");
+var toContainFormattedText_1 = require("./component/toContainFormattedText");
+var toContainTokens_1 = require("./component/toContainTokens");
+var toHaveActiveTab_1 = require("./component/toHaveActiveTab");
+var toContainTabs_1 = require("./component/toContainTabs");
+var toHaveHref_1 = require("./component/toHaveHref");
+var toHavePageCount_1 = require("./component/toHavePageCount");
+var toBeCheckedByValue_1 = require("./component/toBeCheckedByValue");
+var toBeCheckedByIndex_1 = require("./component/toBeCheckedByIndex");
+var toBeUncheckedByValue_1 = require("./component/toBeUncheckedByValue");
+var toBeUncheckedByIndex_1 = require("./component/toBeUncheckedByIndex");
+var toContainSelectValue_1 = require("./component/toContainSelectValue");
+var toBeCheckedByText_1 = require("./component/toBeCheckedByText");
+var toBeUncheckedByText_1 = require("./component/toBeUncheckedByText");
+var toHaveActivePage_1 = require("./component/toHaveActivePage");
+var toHaveFormattedValue_1 = require("./component/toHaveFormattedValue");
+var toHaveFormattedText_1 = require("./component/toHaveFormattedText");
+var matchers = {
+    /*
+      NOTE: некоторые кастомные матчеры содержат суффикс "Ex",
+      для того чтобы не переопределять стандартные матчеры playwright,
+      тк. уже есть матчеры с такими же именами 'toBeEmpty' и тд и при extend они мутируются и перезаписываются { ...matchers, ...customMatchers }
+      https://playwright.dev/docs/test-assertions#auto-retrying-assertions
+    */
+    toBeEmptyEx: toBeEmptyEx_1.toBeEmptyEx,
+    toBeVisibleEx: toBeVisibleEx_1.toBeVisibleEx,
+    toBeHiddenEx: toBeHiddenEx_1.toBeHiddenEx,
+    toBeEnabledEx: toBeEnabledEx_1.toBeEnabledEx,
+    toBeDisabledEx: toBeDisabledEx_1.toBeDisabledEx,
+    toBeFocusedEx: toBeFocusedEx_1.toBeFocusedEx,
+    toBeCheckedEx: toBeCheckedEx_1.toBeCheckedEx,
+    toHaveAttributeEx: toHaveAttributeEx_1.toHaveAttributeEx,
+    toHaveValueEx: toHaveValueEx_1.toHaveValueEx,
+    toHaveTextEx: toHaveTextEx_1.toHaveTextEx,
+    toHaveCountEx: toHaveCountEx_1.toHaveCountEx,
+    toContainTextEx: toContainTextEx_1.toContainTextEx,
+    toBeAutoMode: toBeAutoMode_1.toBeAutoMode,
+    toBeUnchecked: toBeUnchecked_1.toBeUnchecked,
+    toBeActiveTab: toBeActiveTab_1.toBeActiveTab,
+    toBeInactiveTab: toBeInactiveTab_1.toBeInactiveTab,
+    toBeCheckedByValue: toBeCheckedByValue_1.toBeCheckedByValue,
+    toBeCheckedByIndex: toBeCheckedByIndex_1.toBeCheckedByIndex,
+    toBeUncheckedByValue: toBeUncheckedByValue_1.toBeUncheckedByValue,
+    toBeUncheckedByIndex: toBeUncheckedByIndex_1.toBeUncheckedByIndex,
+    toBeCheckedByText: toBeCheckedByText_1.toBeCheckedByText,
+    toBeUncheckedByText: toBeUncheckedByText_1.toBeUncheckedByText,
+    toHaveHref: toHaveHref_1.toHaveHref,
+    toHaveItems: toHaveItems_1.toHaveItems,
+    toHaveError: toHaveError_1.toHaveError,
+    toHaveWarning: toHaveWarning_1.toHaveWarning,
+    toHaveActiveTab: toHaveActiveTab_1.toHaveActiveTab,
+    toHavePageCount: toHavePageCount_1.toHavePageCount,
+    toHaveActivePage: toHaveActivePage_1.toHaveActivePage,
+    toHaveFormattedValue: toHaveFormattedValue_1.toHaveFormattedValue,
+    toHaveFormattedText: toHaveFormattedText_1.toHaveFormattedText,
+    toContainItems: toContainItems_1.toContainItems,
+    toContainItem: toContainItem_1.toContainItem,
+    toContainTokens: toContainTokens_1.toContainTokens,
+    toContainTabs: toContainTabs_1.toContainTabs,
+    toContainSelectValue: toContainSelectValue_1.toContainSelectValue,
+    toContainFormattedText: toContainFormattedText_1.toContainFormattedText,
+    toContainUploadedFiles: toContainUploadedFiles_1.toContainUploadedFiles,
+};
+exports.componentMatchers = test_1.expect.extend(matchers);

package/build/src/matchers/createAsyncMatcher.d.ts

@@ -0,0 +1,72 @@
+import type { ExpectMatcherState, Locator, MatcherReturnType } from '@playwright/test';
+import type { LocatorType, LocatorTypeFn } from './component/LocatorSymbols';
+export interface CreateMatcherLogicParams<TComponent> {
+    isNot: boolean;
+    locator: Locator;
+    component: TComponent;
+}
+/**
+ * Создает асинхронный матчер для конкретного компонента
+ *
+ *
+ * @param matcherName - уникальное имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogicAsync - функция для создания логики матчера
+ * @param createExpectMessage - функция для создания сообщения для ожидания
+ *
+ * @example
+ *
+ * Дженерик аргументы:
+ *
+ *  createComponentAsyncMatcher<Component, TArgs>
+ *  - Component - тип компонента
+ *  - TArgs - массив аргументов матчера
+ *
+ * const toExampleEx = createComponentAsyncMatcher<Component, [AttributeOptions?]>(
+ *   'toExampleEx',
+ *   component => component.rootLocator,
+ *   async ({ isNot, locator, component }, options) => {
+ *     await component.waitFor();
+ *     const expectation = isNot ? baseExpect(locator).not : baseExpect(locator);
+ *     await expectation.toBeEmpty();
+ *   },
+ *   isNot => (isNot ? 'not to be example' : 'to be example'),
+ * );
+ */
+export declare function createComponentAsyncMatcher<TComponent, TArgs extends unknown[]>(matcherName: string, getLocator: (component: TComponent) => LocatorType, createMatcherLogicAsync: (params: CreateMatcherLogicParams<TComponent>, ...args: TArgs) => Promise<void>, createExpectMessage?: (isNot: boolean, ...args: TArgs) => string): (this: ExpectMatcherState, component: TComponent, ...args: TArgs) => Promise<MatcherReturnType>;
+/**
+ * Создает асинхронный типизированный матчер для компонента с символом локатора
+ *
+ *
+ * @param matcherName - уникальное имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogicAsync - асинхронная функция для создания логики матчера
+ * @param createExpectMessage - функция для создания сообщения для ожидания
+ *
+ * @example
+ * export type ToExampleExLocator = {
+ *   [toExampleExLocator]: () => Locator;
+ * }
+ *
+ * export const toExampleExLocator = Symbol.for('toExampleExLocator');
+ *
+ * Дженерик аргументы:
+ *
+ *  createAsyncMatcher<TLocatorSymbolInterface, TArgs, Component>
+ *  - TLocatorSymbolInterface - тип с символом локатора
+ *  - TArgs - массив аргументов матчера
+ *  - TComponent - тип компонента
+ *
+ *
+ * const toExampleEx = createAsyncMatcher<ToExampleExLocator, [AttributeOptions?], Component>(
+ *   'toExampleEx',
+ *   component => component[toExampleExLocator](),
+ *   async ({ isNot, locator, component }, options) => {
+ *     await component.waitFor();
+ *     const expectation = isNot ? baseExpect(locator).not : baseExpect(locator);
+ *     await expectation.toBeEmpty();
+ *   },
+ *   isNot => (isNot ? 'not to be example' : 'to be example'),
+ * );
+ */
+export declare function createAsyncMatcher<TLocatorSymbolInterface extends Record<symbol, LocatorTypeFn>, TArgs extends unknown[], TComponent = unknown>(matcherName: string, getLocator: (component: TComponent & TLocatorSymbolInterface) => LocatorType, createMatcherLogicAsync: (params: CreateMatcherLogicParams<TComponent>, ...args: TArgs) => Promise<void>, createExpectMessage?: (isNot: boolean, ...args: TArgs) => string): (this: ExpectMatcherState, component: TComponent & TLocatorSymbolInterface, ...args: TArgs) => Promise<MatcherReturnType>;

package/build/src/matchers/createAsyncMatcher.js

@@ -0,0 +1,180 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentAsyncMatcher = createComponentAsyncMatcher;
+exports.createAsyncMatcher = createAsyncMatcher;
+var makeMatcher_1 = require("../utils/makeMatcher");
+var toMatchMessage_1 = require("../utils/toMatchMessage");
+/**
+ * Создает асинхронный матчер для конкретного компонента
+ *
+ *
+ * @param matcherName - уникальное имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogicAsync - функция для создания логики матчера
+ * @param createExpectMessage - функция для создания сообщения для ожидания
+ *
+ * @example
+ *
+ * Дженерик аргументы:
+ *
+ *  createComponentAsyncMatcher<Component, TArgs>
+ *  - Component - тип компонента
+ *  - TArgs - массив аргументов матчера
+ *
+ * const toExampleEx = createComponentAsyncMatcher<Component, [AttributeOptions?]>(
+ *   'toExampleEx',
+ *   component => component.rootLocator,
+ *   async ({ isNot, locator, component }, options) => {
+ *     await component.waitFor();
+ *     const expectation = isNot ? baseExpect(locator).not : baseExpect(locator);
+ *     await expectation.toBeEmpty();
+ *   },
+ *   isNot => (isNot ? 'not to be example' : 'to be example'),
+ * );
+ */
+function createComponentAsyncMatcher(matcherName, getLocator, createMatcherLogicAsync, createExpectMessage) {
+    return function matcher(component) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = toMatchMessage_1.toMatchMessage;
+                        _b = [this,
+                            matcherName];
+                        return [4 /*yield*/, getLocator(component)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, _b.concat([_c.sent(), function (isNot, locator) {
+                                return (0, makeMatcher_1.makeMatcher)(isNot, function () { return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, createMatcherLogicAsync.apply(void 0, __spreadArray([{ isNot: isNot, locator: locator, component: component }], args, false))];
+                                            case 1:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            }, createExpectMessage === null || createExpectMessage === void 0 ? void 0 : createExpectMessage.apply(void 0, __spreadArray([this.isNot], args, false))]))];
+                }
+            });
+        });
+    };
+}
+/**
+ * Создает асинхронный типизированный матчер для компонента с символом локатора
+ *
+ *
+ * @param matcherName - уникальное имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogicAsync - асинхронная функция для создания логики матчера
+ * @param createExpectMessage - функция для создания сообщения для ожидания
+ *
+ * @example
+ * export type ToExampleExLocator = {
+ *   [toExampleExLocator]: () => Locator;
+ * }
+ *
+ * export const toExampleExLocator = Symbol.for('toExampleExLocator');
+ *
+ * Дженерик аргументы:
+ *
+ *  createAsyncMatcher<TLocatorSymbolInterface, TArgs, Component>
+ *  - TLocatorSymbolInterface - тип с символом локатора
+ *  - TArgs - массив аргументов матчера
+ *  - TComponent - тип компонента
+ *
+ *
+ * const toExampleEx = createAsyncMatcher<ToExampleExLocator, [AttributeOptions?], Component>(
+ *   'toExampleEx',
+ *   component => component[toExampleExLocator](),
+ *   async ({ isNot, locator, component }, options) => {
+ *     await component.waitFor();
+ *     const expectation = isNot ? baseExpect(locator).not : baseExpect(locator);
+ *     await expectation.toBeEmpty();
+ *   },
+ *   isNot => (isNot ? 'not to be example' : 'to be example'),
+ * );
+ */
+function createAsyncMatcher(matcherName, getLocator, createMatcherLogicAsync, createExpectMessage) {
+    return function matcher(component) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = toMatchMessage_1.toMatchMessage;
+                        _b = [this,
+                            matcherName];
+                        return [4 /*yield*/, getLocator(component)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, _b.concat([_c.sent(), function (isNot, locator) {
+                                return (0, makeMatcher_1.makeMatcher)(isNot, function () { return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, createMatcherLogicAsync.apply(void 0, __spreadArray([{ isNot: isNot, locator: locator, component: component }], args, false))];
+                                            case 1:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            }, createExpectMessage === null || createExpectMessage === void 0 ? void 0 : createExpectMessage.apply(void 0, __spreadArray([this.isNot], args, false))]))];
+                }
+            });
+        });
+    };
+}

package/build/src/matchers/formattedMatchers.d.ts

@@ -1,37 +1,21 @@
-import type { Locator, ExpectMatcherState } from '@playwright/test';
+import type { Locator, ExpectMatcherState, MatcherReturnType } from '@playwright/test';
+import type { TransformOptions } from '../options';
 export type Transform = (value: string) => string;
+declare const matchers: {
+    readonly toHaveFormattedValue: typeof toHaveFormattedValue;
+    readonly toHaveFormattedText: typeof toHaveFormattedText;
+    readonly toContainFormattedText: typeof toContainFormattedText;
+};
+export type FormattedMatchers = typeof matchers;
 /**
  * Набор проверок, которые игнорируют форматирование значения. По-умолчанию игнорируют пробелы.
  */
 export declare const formattedMatchers: import("@playwright/test").Expect<{
-    toHaveFormattedValue(this: ExpectMatcherState, locator: Locator, expected: string, options?: {
-        timeout?: number;
-        transform?: Transform;
-    }): Promise<{
-        message: () => string;
-        pass: boolean;
-        name: string;
-        expected: string;
-        actual: unknown;
-    }>;
-    toHaveFormattedText(this: ExpectMatcherState, locator: Locator, expected: string, options?: {
-        timeout?: number;
-        transform?: Transform;
-    }): Promise<{
-        message: () => string;
-        pass: boolean;
-        name: string;
-        expected: string;
-        actual: unknown;
-    }>;
-    toContainFormattedText(this: ExpectMatcherState, locator: Locator, expected: string, options?: {
-        timeout?: number;
-        transform?: Transform;
-    }): Promise<{
-        message: () => string;
-        pass: boolean;
-        name: string;
-        expected: string;
-        actual: unknown;
-    }>;
+    readonly toHaveFormattedValue: typeof toHaveFormattedValue;
+    readonly toHaveFormattedText: typeof toHaveFormattedText;
+    readonly toContainFormattedText: typeof toContainFormattedText;
 }>;
+declare function toHaveFormattedValue(this: ExpectMatcherState, locator: Locator, expected: string, options?: TransformOptions): Promise<MatcherReturnType>;
+declare function toHaveFormattedText(this: ExpectMatcherState, locator: Locator, expected: string, options?: TransformOptions): Promise<MatcherReturnType>;
+declare function toContainFormattedText(this: ExpectMatcherState, locator: Locator, expected: string, options?: TransformOptions): Promise<MatcherReturnType>;
+export {};

package/build/src/matchers/formattedMatchers.js

@@ -39,21 +39,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formattedMatchers = void 0;
 var test_1 = require("@playwright/test");
 var removeSpaces = function (value) { return value.replace(/\s/g, ''); };
+var matchers = {
+    toHaveFormattedValue: toHaveFormattedValue,
+    toHaveFormattedText: toHaveFormattedText,
+    toContainFormattedText: toContainFormattedText,
+};
 /**
  * Набор проверок, которые игнорируют форматирование значения. По-умолчанию игнорируют пробелы.
  */
-exports.formattedMatchers = test_1.expect.extend({
-    toHaveFormattedValue: function (locator, expected, options) {
-        return toHaveFormatted(function (locator) { return locator.inputValue(); }, 'toHaveFormattedValue', this)(locator, expected, options);
-    },
-    toHaveFormattedText: function (locator, expected, options) {
-        return toHaveFormatted(function (locator) { return locator.textContent(); }, 'toHaveFormattedText', this)(locator, expected, options);
-    },
-    toContainFormattedText: function (locator, expected, options) {
-        return toHaveFormatted(function (locator) { return locator.textContent(); }, 'toContainFormattedText', this, false)(locator, expected, options);
-    },
-});
-function toHaveFormatted(getter, assertionName, context, strictExpect) {
+exports.formattedMatchers = test_1.expect.extend(matchers);
+function toHaveFormattedValue(locator, expected, options) {
+    return toHaveFormatted(this, 'toHaveFormattedValue', function (locator) { return locator.inputValue(); })(locator, expected, options);
+}
+function toHaveFormattedText(locator, expected, options) {
+    return toHaveFormatted(this, 'toHaveFormattedText', function (locator) { return locator.textContent(); })(locator, expected, options);
+}
+function toContainFormattedText(locator, expected, options) {
+    return toHaveFormatted(this, 'toContainFormattedText', function (locator) { return locator.textContent(); }, false)(locator, expected, options);
+}
+function toHaveFormatted(context, matcherName, getter, strictExpect) {
     var _this = this;
     if (strictExpect === void 0) { strictExpect = true; }
     return function (locator, expected, options) { return __awaiter(_this, void 0, void 0, function () {
@@ -99,14 +103,14 @@ function toHaveFormatted(getter, assertionName, context, strictExpect) {
                 case 7:
                     message = pass
                         ? function () {
-                            return context.utils.matcherHint(assertionName, undefined, undefined, { isNot: context.isNot }) +
+                            return context.utils.matcherHint(matcherName, undefined, undefined, { isNot: context.isNot }) +
                                 '\n\n' +
                                 "Locator: ".concat(locator, "\n") +
                                 "Expected: ".concat(context.isNot ? 'not' : '').concat(context.utils.printExpected(expected), "\n") +
                                 (actual ? "Received: ".concat(context.utils.printReceived(actual)) : '');
                         }
                         : function () {
-                            return context.utils.matcherHint(assertionName, undefined, undefined, { isNot: context.isNot }) +
+                            return context.utils.matcherHint(matcherName, undefined, undefined, { isNot: context.isNot }) +
                                 '\n\n' +
                                 "Locator: ".concat(locator, "\n") +
                                 "Expected: ".concat(context.utils.printExpected(expected), "\n") +
@@ -115,7 +119,7 @@ function toHaveFormatted(getter, assertionName, context, strictExpect) {
                     return [2 /*return*/, {
                             message: message,
                             pass: pass,
-                            name: assertionName,
+                            name: matcherName,
                             expected: expected,
                             actual: actual,
                         }];

package/build/src/matchers/index.d.ts

@@ -1,2 +1,2 @@
 export * from './formattedMatchers';
-export { mergedExpects } from './mergedExpects';
+export * from './componentMatchers';

package/build/src/matchers/index.js

@@ -14,7 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergedExpects = void 0;
 __exportStar(require("./formattedMatchers"), exports);
-var mergedExpects_1 = require("./mergedExpects");
-Object.defineProperty(exports, "mergedExpects", { enumerable: true, get: function () { return mergedExpects_1.mergedExpects; } });
+__exportStar(require("./componentMatchers"), exports);

package/build/src/utils/getMarcherResult.d.ts

@@ -0,0 +1,13 @@
+export type MatcherResult = {
+    message: string;
+    pass: boolean;
+    actual: string;
+    name: string;
+    expected: string;
+    log: string[];
+    stack: string;
+} | string | undefined;
+export type WithMatcherResult = {
+    matcherResult: MatcherResult;
+};
+export declare const getActualFromError: (e: unknown) => MatcherResult;

package/build/src/utils/getMarcherResult.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActualFromError = void 0;
+var getActualFromError = function (e) {
+    if (e && typeof e === 'object' && 'matcherResult' in e && e.matcherResult) {
+        return e.matcherResult;
+    }
+    if (e && typeof e === 'object') {
+        return e.toString();
+    }
+    return undefined;
+};
+exports.getActualFromError = getActualFromError;