@skbkontur/playwright-react-ui-components 1.13.1 → 1.14.0-beta.1

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

@@ -0,0 +1,104 @@
+declare const matchers: {
+    toBeEmptyEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0?: import("..").EmptyOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeVisibleEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeHiddenEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").HiddenOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeEnabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeDisabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveErrorEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveWarningEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    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>;
+    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>;
+    toBeFocusedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeFocusableElementLocator, args_0?: import("..").FocusedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainUploadedFilesEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FileUploader, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeCheckedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    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>;
+    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>;
+    toHaveItemsEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainItemsEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainItemEx: (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>;
+    toHaveCountEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").ComponentList<any>, args_0: number, args_1?: import("..").CountOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeActiveEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeInactiveEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainTokensEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").TokenInput, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveActiveTabEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string | RegExp) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainTabsEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeAutoEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FxInput, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveHrefEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Link, args_0: string | RegExp, args_1?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHavePageCountEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeCheckedByValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeCheckedByIndexEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedByValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedByIndexEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainValueEx: (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>;
+    toBeCheckedByTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedByTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveActivePageEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveFormattedValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveFormattedTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainFormattedTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Label, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+};
+export type ComponentMatchers = typeof matchers;
+export declare const componentMatchers: import("@playwright/test").Expect<{
+    toBeEmptyEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0?: import("..").EmptyOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeVisibleEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeHiddenEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").VisibleElementLocator, args_0?: import("..").HiddenOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeEnabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeDisabledEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ControlElementLocator, args_0?: import("..").EnabledOptions | import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveErrorEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveWarningEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").RootSymbolLocator, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    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>;
+    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>;
+    toBeFocusedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeFocusableElementLocator, args_0?: import("..").FocusedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainUploadedFilesEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FileUploader, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeCheckedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToBeCheckableElementLocator, args_0?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    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>;
+    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>;
+    toHaveItemsEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainItemsEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToHaveItemsElementLocator, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainItemEx: (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>;
+    toHaveCountEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").ComponentList<any>, args_0: number, args_1?: import("..").CountOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeActiveEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeInactiveEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tab, args_0?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainTokensEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").TokenInput, args_0: string[], args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveActiveTabEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string | RegExp) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainTabsEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Tabs, args_0: string[], args_1?: import("..").TextOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeAutoEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").FxInput, args_0?: import("..").VisibleOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveHrefEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Link, args_0: string | RegExp, args_1?: import("..").AttributeOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHavePageCountEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeCheckedByValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeCheckedByIndexEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedByValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedByIndexEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: number, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainValueEx: (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>;
+    toBeCheckedByTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toBeUncheckedByTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").RadioGroup, args_0: string | RegExp, args_1?: import("..").CheckedOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveActivePageEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Paging, args_0: number, args_1?: {
+        timeout?: number;
+    } | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveFormattedValueEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToWithValueElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toHaveFormattedTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("./component/LocatorSymbols").ToTextElementLocator, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+    toContainFormattedTextEx: (this: import("@playwright/test").ExpectMatcherState, component: import("..").Label, args_0: string, args_1?: import("..").TransformOptions | undefined) => Promise<import("@playwright/test").MatcherReturnType>;
+}>;
+export {};

package/build/src/matchers/componentMatchers.js

@@ -0,0 +1,83 @@
+"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 toHaveErrorEx_1 = require("./component/toHaveErrorEx");
+var toHaveWarningEx_1 = require("./component/toHaveWarningEx");
+var toHaveAttributeEx_1 = require("./component/toHaveAttributeEx");
+var toHaveValueEx_1 = require("./component/toHaveValueEx");
+var toBeFocusedEx_1 = require("./component/toBeFocusedEx");
+var toContainUploadedFilesEx_1 = require("./component/toContainUploadedFilesEx");
+var toBeCheckedEx_1 = require("./component/toBeCheckedEx");
+var toBeUncheckedEx_1 = require("./component/toBeUncheckedEx");
+var toHaveTextEx_1 = require("./component/toHaveTextEx");
+var toContainTextEx_1 = require("./component/toContainTextEx");
+var toHaveItemsEx_1 = require("./component/toHaveItemsEx");
+var toContainItemsEx_1 = require("./component/toContainItemsEx");
+var toContainItemEx_1 = require("./component/toContainItemEx");
+var toContainFormattedTextEx_1 = require("./component/toContainFormattedTextEx");
+var toHaveCountEx_1 = require("./component/toHaveCountEx");
+var toBeActiveEx_1 = require("./component/toBeActiveEx");
+var toBeInactiveEx_1 = require("./component/toBeInactiveEx");
+var toContainTokensEx_1 = require("./component/toContainTokensEx");
+var toHaveActiveTabEx_1 = require("./component/toHaveActiveTabEx");
+var toContainTabsEx_1 = require("./component/toContainTabsEx");
+var toBeAutoEx_1 = require("./component/toBeAutoEx");
+var toHaveHrefEx_1 = require("./component/toHaveHrefEx");
+var toHavePageCountEx_1 = require("./component/toHavePageCountEx");
+var toBeCheckedByValueEx_1 = require("./component/toBeCheckedByValueEx");
+var toBeCheckedByIndexEx_1 = require("./component/toBeCheckedByIndexEx");
+var toBeUncheckedByValueEx_1 = require("./component/toBeUncheckedByValueEx");
+var toBeUncheckedByIndexEx_1 = require("./component/toBeUncheckedByIndexEx");
+var toContainValueEx_1 = require("./component/toContainValueEx");
+var toBeCheckedByTextEx_1 = require("./component/toBeCheckedByTextEx");
+var toBeUncheckedByTextEx_1 = require("./component/toBeUncheckedByTextEx");
+var toHaveActivePageEx_1 = require("./component/toHaveActivePageEx");
+var toHaveFormattedValueEx_1 = require("./component/toHaveFormattedValueEx");
+var toHaveFormattedTextEx_1 = require("./component/toHaveFormattedTextEx");
+var matchers = {
+    toBeEmptyEx: toBeEmptyEx_1.toBeEmptyEx,
+    toBeVisibleEx: toBeVisibleEx_1.toBeVisibleEx,
+    toBeHiddenEx: toBeHiddenEx_1.toBeHiddenEx,
+    toBeEnabledEx: toBeEnabledEx_1.toBeEnabledEx,
+    toBeDisabledEx: toBeDisabledEx_1.toBeDisabledEx,
+    toHaveErrorEx: toHaveErrorEx_1.toHaveErrorEx,
+    toHaveWarningEx: toHaveWarningEx_1.toHaveWarningEx,
+    toHaveAttributeEx: toHaveAttributeEx_1.toHaveAttributeEx,
+    toHaveValueEx: toHaveValueEx_1.toHaveValueEx,
+    toBeFocusedEx: toBeFocusedEx_1.toBeFocusedEx,
+    toContainUploadedFilesEx: toContainUploadedFilesEx_1.toContainUploadedFilesEx,
+    toBeCheckedEx: toBeCheckedEx_1.toBeCheckedEx,
+    toBeUncheckedEx: toBeUncheckedEx_1.toBeUncheckedEx,
+    toHaveTextEx: toHaveTextEx_1.toHaveTextEx,
+    toContainTextEx: toContainTextEx_1.toContainTextEx,
+    toHaveItemsEx: toHaveItemsEx_1.toHaveItemsEx,
+    toContainItemsEx: toContainItemsEx_1.toContainItemsEx,
+    toContainItemEx: toContainItemEx_1.toContainItemEx,
+    toHaveCountEx: toHaveCountEx_1.toHaveCountEx,
+    toBeActiveEx: toBeActiveEx_1.toBeActiveEx,
+    toBeInactiveEx: toBeInactiveEx_1.toBeInactiveEx,
+    toContainTokensEx: toContainTokensEx_1.toContainTokensEx,
+    toHaveActiveTabEx: toHaveActiveTabEx_1.toHaveActiveTabEx,
+    toContainTabsEx: toContainTabsEx_1.toContainTabsEx,
+    toBeAutoEx: toBeAutoEx_1.toBeAutoEx,
+    toHaveHrefEx: toHaveHrefEx_1.toHaveHrefEx,
+    toHavePageCountEx: toHavePageCountEx_1.toHavePageCountEx,
+    toBeCheckedByValueEx: toBeCheckedByValueEx_1.toBeCheckedByValueEx,
+    toBeCheckedByIndexEx: toBeCheckedByIndexEx_1.toBeCheckedByIndexEx,
+    toBeUncheckedByValueEx: toBeUncheckedByValueEx_1.toBeUncheckedByValueEx,
+    toBeUncheckedByIndexEx: toBeUncheckedByIndexEx_1.toBeUncheckedByIndexEx,
+    toContainValueEx: toContainValueEx_1.toContainValueEx,
+    toBeCheckedByTextEx: toBeCheckedByTextEx_1.toBeCheckedByTextEx,
+    toBeUncheckedByTextEx: toBeUncheckedByTextEx_1.toBeUncheckedByTextEx,
+    toHaveActivePageEx: toHaveActivePageEx_1.toHaveActivePageEx,
+    toHaveFormattedValueEx: toHaveFormattedValueEx_1.toHaveFormattedValueEx,
+    toHaveFormattedTextEx: toHaveFormattedTextEx_1.toHaveFormattedTextEx,
+    toContainFormattedTextEx: toContainFormattedTextEx_1.toContainFormattedTextEx,
+};
+exports.componentMatchers = test_1.expect.extend(matchers);

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

@@ -0,0 +1,47 @@
+import type { ExpectMatcherState, Locator, MatcherReturnType } from '@playwright/test';
+import type { LocatorType } from './component/LocatorSymbols';
+export interface CreateMatcherLogicParams<TComponent> {
+    isNot: boolean;
+    locator: Locator;
+    component: TComponent;
+}
+/**
+ * Создает асинхронный матчер для конкретного компонента
+ * @param matcherName - имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogic - функция для создания логики матчера
+ * @param createMessage - функция для создания сообщения
+ *
+ * @example
+ * 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, createMatcherLogic: (params: CreateMatcherLogicParams<TComponent>, ...args: TArgs) => Promise<void>, createMessage?: (isNot: boolean, ...args: TArgs) => string): (this: ExpectMatcherState, component: TComponent, ...args: TArgs) => Promise<MatcherReturnType>;
+/**
+ * Создает асинхронный типизированный матчер для компонента с символом локатора
+ * @param matcherName - имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogic - функция для создания логики матчера
+ * @param createMessage - функция для создания сообщения
+ *
+ * @example
+ * const toExampleEx = createAsyncMatcher<ToExampleExLocator, [AttributeOptions?], BaseComponent>(
+ *   '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, TArgs extends unknown[], TComponent = unknown>(matcherName: string, getLocator: (component: TComponent & TLocatorSymbolInterface) => LocatorType, createMatcherLogic: (params: CreateMatcherLogicParams<TComponent>, ...args: TArgs) => Promise<void>, createMessage?: (isNot: boolean, ...args: TArgs) => string): (this: ExpectMatcherState, component: TComponent & TLocatorSymbolInterface, ...args: TArgs) => Promise<MatcherReturnType>;

package/build/src/matchers/createAsyncMatcher.js

@@ -0,0 +1,155 @@
+"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 createMatcherLogic - функция для создания логики матчера
+ * @param createMessage - функция для создания сообщения
+ *
+ * @example
+ * 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, createMatcherLogic, createMessage) {
+    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*/, createMatcherLogic.apply(void 0, __spreadArray([{ isNot: isNot, locator: locator, component: component }], args, false))];
+                                            case 1:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            }, createMessage === null || createMessage === void 0 ? void 0 : createMessage.apply(void 0, __spreadArray([this.isNot], args, false))]))];
+                }
+            });
+        });
+    };
+}
+/**
+ * Создает асинхронный типизированный матчер для компонента с символом локатора
+ * @param matcherName - имя матчера
+ * @param getLocator - функция для получения локатора
+ * @param createMatcherLogic - функция для создания логики матчера
+ * @param createMessage - функция для создания сообщения
+ *
+ * @example
+ * const toExampleEx = createAsyncMatcher<ToExampleExLocator, [AttributeOptions?], BaseComponent>(
+ *   '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, createMatcherLogic, createMessage) {
+    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*/, createMatcherLogic.apply(void 0, __spreadArray([{ isNot: isNot, locator: locator, component: component }], args, false))];
+                                            case 1:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            }, createMessage === null || createMessage === void 0 ? void 0 : createMessage.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;

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

@@ -1,2 +1,5 @@
 export { getTooltip } from './tooltipProvider';
 export * from './constants';
+export * from './toMatchMessage';
+export * from './getMarcherResult';
+export * from './makeMatcher';

package/build/src/utils/index.js

@@ -18,3 +18,6 @@ exports.getTooltip = void 0;
 var tooltipProvider_1 = require("./tooltipProvider");
 Object.defineProperty(exports, "getTooltip", { enumerable: true, get: function () { return tooltipProvider_1.getTooltip; } });
 __exportStar(require("./constants"), exports);
+__exportStar(require("./toMatchMessage"), exports);
+__exportStar(require("./getMarcherResult"), exports);
+__exportStar(require("./makeMatcher"), exports);

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

@@ -0,0 +1,3 @@
+import type { Locator } from '@playwright/test';
+import type { BaseComponent } from '../components';
+export declare const isComponent: <T extends BaseComponent>(component: unknown, instance: new (rootLocator: Locator, itemsLocator: (rootLocator: Locator) => Locator, itemFactory: (locator: Locator) => BaseComponent) => T) => component is T;

package/build/src/utils/is.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComponent = void 0;
+var isComponent = function (component, instance) { return component instanceof instance; };
+exports.isComponent = isComponent;

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

@@ -0,0 +1,5 @@
+import type { MatcherResult } from './getMarcherResult';
+export declare const makeMatcher: (isNot: boolean, matcher: () => Promise<void>) => Promise<{
+    matches: boolean;
+    matcherResult: MatcherResult | undefined;
+}>;