@skbkontur/playwright-react-ui-components 1.18.0 → 1.19.0-beta.1

package/build/src/assertions/ComponentListAssertions.d.ts

@@ -1,7 +1,7 @@
 import { BaseComponentAssertions } from './BaseComponentAssertions';
 import type { ComponentList } from '../components';
 import type { BaseComponent } from '../components';
-import type { HiddenOptions, VisibleOptions, CountOptions } from '../options';
+import type { HiddenOptions, VisibleOptions, CountOptions, TextOptions } from '../options';
 export declare class ComponentListAssertions<TItem extends BaseComponent> extends BaseComponentAssertions {
     private readonly componentList;
     constructor(componentList: ComponentList<TItem>);
@@ -10,4 +10,9 @@ export declare class ComponentListAssertions<TItem extends BaseComponent> extend
     toHaveCount(count: number, options?: CountOptions): Promise<void>;
     toBeEmpty(options?: CountOptions): Promise<void>;
     notToBeEmpty(options?: CountOptions): Promise<void>;
+    toHaveItems(itemsText: string[], options?: TextOptions): Promise<void>;
+    toContainItems(itemsText: string[], options?: TextOptions): Promise<void>;
+    toContainItem(itemText: string, options?: TextOptions): Promise<void>;
+    notToContainItem(itemText: string, options?: TextOptions): Promise<void>;
+    toHaveItemsByPredicate<TResult extends BaseComponent>(itemsText: string[], selector: (item: TItem) => TResult, options?: TextOptions): Promise<void>;
 }

package/build/src/assertions/ComponentListAssertions.js

@@ -121,6 +121,66 @@ var ComponentListAssertions = /** @class */ (function (_super) {
             });
         });
     };
+    ComponentListAssertions.prototype.toHaveItems = function (itemsText, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.componentList).toHaveItems(itemsText, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ComponentListAssertions.prototype.toContainItems = function (itemsText, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.componentList).toContainItems(itemsText, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ComponentListAssertions.prototype.toContainItem = function (itemText, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.componentList).toContainItem(itemText, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ComponentListAssertions.prototype.notToContainItem = function (itemText, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.componentList).not.toContainItem(itemText, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ComponentListAssertions.prototype.toHaveItemsByPredicate = function (itemsText, selector, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.componentList).toHaveItemsByPredicate(itemsText, selector, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     return ComponentListAssertions;
 }(BaseComponentAssertions_1.BaseComponentAssertions));
 exports.ComponentListAssertions = ComponentListAssertions;

package/build/src/assertions/FileUploaderAssertions.d.ts

@@ -1,12 +1,10 @@
 import { BaseComponentAssertions } from './BaseComponentAssertions';
 import type { FileUploader } from '../components';
-import type { EnabledOptions } from '../options';
+import type { EnabledOptions, TextOptions } from '../options';
 export declare class FileUploaderAssertions extends BaseComponentAssertions {
     private readonly fileUploader;
     constructor(fileUploader: FileUploader);
     toBeEnabled(options?: EnabledOptions): Promise<void>;
     toBeDisabled(options?: EnabledOptions): Promise<void>;
-    toContainUploadedFiles(fileNames: string[], options?: {
-        timeout: number;
-    }): Promise<void>;
+    toContainUploadedFiles(fileNames: string[], options?: TextOptions): Promise<void>;
 }

package/build/src/assertions/PagingAssertions.d.ts

@@ -7,9 +7,9 @@ export declare class PagingAssertions extends BaseComponentAssertions {
     toBeEnabled(options?: AttributeOptions): Promise<void>;
     toBeDisabled(options?: AttributeOptions): Promise<void>;
     toHavePageCount(count: number, options?: {
-        timeout: number;
+        timeout?: number;
     }): Promise<void>;
     toHaveActivePage(activePageNumber: number, options?: {
-        timeout: number;
+        timeout?: number;
     }): Promise<void>;
 }

package/build/src/assertions/TabsAssertions.d.ts

@@ -1,11 +1,13 @@
 import { BaseComponentAssertions } from './BaseComponentAssertions';
 import type { Tabs } from '../components';
+import type { TextOptions } from '../options';
 export declare class TabsAssertions extends BaseComponentAssertions {
     private readonly tabs;
     constructor(tabs: Tabs);
     toHaveActiveTab(tabName: string | RegExp): Promise<void>;
     notToHaveActiveTab(tabName: string | RegExp): Promise<void>;
-    toContainTabs(tabNames: string[], options?: {
-        timeout: number;
-    }): Promise<void>;
+    toHaveTabs(tabNames: string[], options?: TextOptions): Promise<void>;
+    toContainTabs(tabNames: string[], options?: TextOptions): Promise<void>;
+    toContainTab(tabName: string, options?: TextOptions): Promise<void>;
+    notToContainTab(tabName: string, options?: TextOptions): Promise<void>;
 }

package/build/src/assertions/TabsAssertions.js

@@ -85,6 +85,18 @@ var TabsAssertions = /** @class */ (function (_super) {
             });
         });
     };
+    TabsAssertions.prototype.toHaveTabs = function (tabNames, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.tabs).toHaveTabs(tabNames, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     TabsAssertions.prototype.toContainTabs = function (tabNames, options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -97,6 +109,30 @@ var TabsAssertions = /** @class */ (function (_super) {
             });
         });
     };
+    TabsAssertions.prototype.toContainTab = function (tabName, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.tabs).toContainTab(tabName, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TabsAssertions.prototype.notToContainTab = function (tabName, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.tabs).not.toContainTab(tabName, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     return TabsAssertions;
 }(BaseComponentAssertions_1.BaseComponentAssertions));
 exports.TabsAssertions = TabsAssertions;

package/build/src/assertions/TokenInputAssertions.d.ts

@@ -1,5 +1,5 @@
 import { BaseComponentAssertions } from './BaseComponentAssertions';
-import type { CountOptions, EnabledOptions, FocusedOptions } from '../options';
+import type { CountOptions, EnabledOptions, FocusedOptions, TextOptions } from '../options';
 import type { TokenInput } from '../components';
 export declare class TokenInputAssertions extends BaseComponentAssertions {
     private readonly tokenInput;
@@ -10,7 +10,8 @@ export declare class TokenInputAssertions extends BaseComponentAssertions {
     notToBeEmpty(options?: CountOptions): Promise<void>;
     toBeFocused(options?: FocusedOptions): Promise<void>;
     notToBeFocused(options?: FocusedOptions): Promise<void>;
-    toContainTokens(tokenNames: string[], options?: {
-        timeout: number;
-    }): Promise<void>;
+    toHaveTokens(tokenNames: string[], options?: TextOptions): Promise<void>;
+    toContainTokens(tokenNames: string[], options?: TextOptions): Promise<void>;
+    toContainToken(tokenName: string, options?: TextOptions): Promise<void>;
+    notToContainToken(tokenName: string, options?: TextOptions): Promise<void>;
 }

package/build/src/assertions/TokenInputAssertions.js

@@ -133,6 +133,18 @@ var TokenInputAssertions = /** @class */ (function (_super) {
             });
         });
     };
+    TokenInputAssertions.prototype.toHaveTokens = function (tokenNames, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.tokenInput).toHaveTokens(tokenNames, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     TokenInputAssertions.prototype.toContainTokens = function (tokenNames, options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -145,6 +157,30 @@ var TokenInputAssertions = /** @class */ (function (_super) {
             });
         });
     };
+    TokenInputAssertions.prototype.toContainToken = function (tokenName, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.tokenInput).toContainToken(tokenName, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TokenInputAssertions.prototype.notToContainToken = function (tokenName, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, extensions_1.expect)(this.tokenInput).not.toContainToken(tokenName, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     return TokenInputAssertions;
 }(BaseComponentAssertions_1.BaseComponentAssertions));
 exports.TokenInputAssertions = TokenInputAssertions;

package/build/src/components/Autocomplete.js

@@ -97,10 +97,10 @@ var Autocomplete = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.focus()];
+                    case 0: return [4 /*yield*/, this.focus(options)];
                     case 1:
                         _d.sent();
-                        return [4 /*yield*/, this.clear()];
+                        return [4 /*yield*/, this.clear(options)];
                     case 2:
                         _d.sent();
                         return [4 /*yield*/, this.inputLocator.fill(value, options)];
@@ -151,7 +151,7 @@ var Autocomplete = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.inputLocator).toBeEnabled()];
+                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.inputLocator).toBeEnabled(options)];
                     case 1:
                         _d.sent();
                         return [4 /*yield*/, this.inputLocator.focus(options)];

package/build/src/components/BaseComponent.js

@@ -64,7 +64,7 @@ var BaseComponent = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.waitFor()];
+                    case 0: return [4 /*yield*/, this.waitFor(options)];
                     case 1:
                         _d.sent();
                         return [4 /*yield*/, this.hasAttribute(utils_1.DataVisualState.Error, options)];
@@ -77,7 +77,7 @@ var BaseComponent = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.waitFor()];
+                    case 0: return [4 /*yield*/, this.waitFor(options)];
                     case 1:
                         _d.sent();
                         return [4 /*yield*/, this.hasAttribute(utils_1.DataVisualState.Warning, options)];
@@ -138,7 +138,7 @@ var BaseComponent = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.waitFor()];
+                    case 0: return [4 /*yield*/, this.waitFor(options)];
                     case 1:
                         _d.sent();
                         return [4 /*yield*/, this.getAttribute(name, options)];

package/build/src/components/Button.d.ts

@@ -2,7 +2,7 @@ import { type Locator } from '@playwright/test';
 import { BaseComponent } from './BaseComponent';
 import { ButtonAssertions } from '../assertions';
 import type { TooltipType } from '../utils';
-import type { BlurOptions, ClickOptions, FocusOptions, InnerTextOptions, IsDisabledOptions } from '../options';
+import type { BlurOptions, ClickOptions, FocusOptions, HoverOptions, InnerTextOptions, IsDisabledOptions } from '../options';
 import { toControlElementLocator, toFocusableElementLocator, toTextElementLocator } from '../matchers/component/LocatorSymbols';
 /**
  * Button можно использовать как для @skbkontur/react-ui, так и для react
@@ -20,6 +20,7 @@ export declare class Button extends BaseComponent {
     click(options?: ClickOptions): Promise<void>;
     focus(options?: FocusOptions): Promise<void>;
     blur(options?: BlurOptions): Promise<void>;
+    hover(options?: HoverOptions): Promise<void>;
     getTooltip(type: TooltipType): Promise<import("./Tooltip").Tooltip>;
     expect(): ButtonAssertions;
 }

package/build/src/components/Button.js

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -111,7 +122,7 @@ var Button = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.buttonLocator).toBeEnabled()];
+                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.buttonLocator).toBeEnabled(options)];
                     case 1:
                         _d.sent();
                         return [4 /*yield*/, this.buttonLocator.focus(options)];
@@ -134,6 +145,29 @@ var Button = /** @class */ (function (_super) {
             });
         });
     };
+    Button.prototype.hover = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.waitFor()];
+                    case 1:
+                        _d.sent();
+                        return [4 /*yield*/, this.isDisabled()];
+                    case 2:
+                        if (!_d.sent()) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.buttonLocator.hover(__assign(__assign({}, options), { force: true }))];
+                    case 3:
+                        _d.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, this.buttonLocator.hover(options)];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
     Button.prototype.getTooltip = function (type) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_d) {

package/build/src/components/Checkbox.js

@@ -119,7 +119,7 @@ var Checkbox = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_f) {
                 switch (_f.label) {
-                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.inputLocator).toBeEnabled()];
+                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.inputLocator).toBeEnabled(options)];
                     case 1:
                         _f.sent();
                         return [4 /*yield*/, this.inputLocator.focus(options)];

package/build/src/components/ComboBox.d.ts

@@ -19,7 +19,9 @@ export declare class ComboBox extends MenuComponent {
     private getInputLocator;
     isDisabled(options?: IsDisabledOptions): Promise<boolean>;
     isFocused(options?: GetAttributeOptions): Promise<boolean>;
-    getSelectedValue(): Promise<string>;
+    getSelectedValue(options?: {
+        timeout?: number;
+    }): Promise<string>;
     /**
      * Этот метод только выбирает элемент из списка.
      *
@@ -39,7 +41,7 @@ export declare class ComboBox extends MenuComponent {
     clear(options?: ClearOptions): Promise<void>;
     focus(options?: FocusOptions): Promise<void>;
     blur(options?: BlurOptions): Promise<void>;
-    click(): Promise<void>;
+    click(options?: ClickOptions): Promise<void>;
     getTooltip(type: TooltipType): Promise<import("./Tooltip").Tooltip>;
     /**
      * Возвращает список меню по data-tid'ам из react-ui:
@@ -50,7 +52,9 @@ export declare class ComboBox extends MenuComponent {
      * - MenuHeaderDataTids.root
      * - MenuFooterDataTids.root
      */
-    getMenuItems(): Promise<ComponentList<MenuItem>>;
+    getMenuItems(options?: {
+        timeout?: number;
+    }): Promise<ComponentList<MenuItem>>;
     expect(): ComboBoxAssertions;
     private getComboBoxMenuItemsLocator;
 }

package/build/src/components/ComboBox.js

@@ -112,16 +112,16 @@ var ComboBox = /** @class */ (function (_super) {
             });
         });
     };
-    ComboBox.prototype.getSelectedValue = function () {
+    ComboBox.prototype.getSelectedValue = function (options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0: return [4 /*yield*/, this.isFocused()];
                     case 1:
                         if (!_e.sent()) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.nativeInputLocator.inputValue()];
+                        return [4 /*yield*/, this.nativeInputLocator.inputValue(options)];
                     case 2: return [2 /*return*/, _e.sent()];
-                    case 3: return [4 /*yield*/, this.inputLikeTextLocator.innerText()];
+                    case 3: return [4 /*yield*/, this.inputLikeTextLocator.innerText(options)];
                     case 4: return [2 /*return*/, _e.sent()];
                 }
             });
@@ -140,7 +140,7 @@ var ComboBox = /** @class */ (function (_super) {
             var items;
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.getComboBoxMenuItemsLocator(value)];
+                    case 0: return [4 /*yield*/, this.getComboBoxMenuItemsLocator(value, options)];
                     case 1:
                         items = _e.sent();
                         return [4 /*yield*/, items.first().click(options)];
@@ -161,10 +161,10 @@ var ComboBox = /** @class */ (function (_super) {
             var items;
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.getComboBoxMenuItemsLocator(value)];
+                    case 0: return [4 /*yield*/, this.getComboBoxMenuItemsLocator(value, options)];
                     case 1:
                         items = _e.sent();
-                        return [4 /*yield*/, (0, test_1.expect)(items).toHaveCount(1)];
+                        return [4 /*yield*/, (0, test_1.expect)(items).toHaveCount(1, options)];
                     case 2:
                         _e.sent();
                         return [4 /*yield*/, items.click(options)];
@@ -179,7 +179,7 @@ var ComboBox = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.focus()];
+                    case 0: return [4 /*yield*/, this.focus(options)];
                     case 1:
                         _e.sent();
                         return [4 /*yield*/, this.nativeInputLocator.fill(value, options)];
@@ -194,7 +194,7 @@ var ComboBox = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.focus()];
+                    case 0: return [4 /*yield*/, this.focus(options)];
                     case 1:
                         _e.sent();
                         return [4 /*yield*/, this.nativeInputLocator.clear(options)];
@@ -209,7 +209,7 @@ var ComboBox = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.nativeInputLocator).toBeEnabled()];
+                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.nativeInputLocator).toBeEnabled(options)];
                     case 1:
                         _e.sent();
                         return [4 /*yield*/, this.rootLocator
@@ -227,7 +227,7 @@ var ComboBox = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.nativeInputLocator.press('Tab', { timeout: options === null || options === void 0 ? void 0 : options.timeout })];
+                    case 0: return [4 /*yield*/, this.nativeInputLocator.press('Tab', options)];
                     case 1:
                         _e.sent();
                         return [2 /*return*/];
@@ -235,17 +235,17 @@ var ComboBox = /** @class */ (function (_super) {
             });
         });
     };
-    ComboBox.prototype.click = function () {
+    ComboBox.prototype.click = function (options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0: 
                     // NOTE: rootLocator всегда в состоянии enabled, даже если ComboBox disabled
-                    return [4 /*yield*/, (0, test_1.expect)(this.nativeInputLocator).toBeEnabled()];
+                    return [4 /*yield*/, (0, test_1.expect)(this.nativeInputLocator).toBeEnabled(options)];
                     case 1:
                         // NOTE: rootLocator всегда в состоянии enabled, даже если ComboBox disabled
                         _e.sent();
-                        return [4 /*yield*/, _super.prototype.click.call(this)];
+                        return [4 /*yield*/, _super.prototype.click.call(this, options)];
                     case 2:
                         _e.sent();
                         return [2 /*return*/];
@@ -265,18 +265,20 @@ var ComboBox = /** @class */ (function (_super) {
      * - MenuHeaderDataTids.root
      * - MenuFooterDataTids.root
      */
-    ComboBox.prototype.getMenuItems = function () {
+    ComboBox.prototype.getMenuItems = function (options) {
         return __awaiter(this, void 0, void 0, function () {
             var container;
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.focus()];
+                    case 0: return [4 /*yield*/, this.focus(options)];
                     case 1:
                         _e.sent();
-                        return [4 /*yield*/, this.portal.getContainer()];
+                        return [4 /*yield*/, this.portal.getContainer(options)];
                     case 2:
                         container = _e.sent();
-                        return [4 /*yield*/, container.locator((0, dataTidSelector_1.getDataTidSelector)(react_ui_1.SpinnerDataTids.root)).waitFor({ state: 'hidden' })];
+                        return [4 /*yield*/, container
+                                .locator((0, dataTidSelector_1.getDataTidSelector)(react_ui_1.SpinnerDataTids.root))
+                                .waitFor({ state: 'hidden', timeout: options === null || options === void 0 ? void 0 : options.timeout })];
                     case 3:
                         _e.sent();
                         return [2 /*return*/, new ComponentList_1.ComponentList(container, function (locator) {
@@ -295,12 +297,12 @@ var ComboBox = /** @class */ (function (_super) {
     ComboBox.prototype.expect = function () {
         return new assertions_1.ComboBoxAssertions(this);
     };
-    ComboBox.prototype.getComboBoxMenuItemsLocator = function (byText) {
+    ComboBox.prototype.getComboBoxMenuItemsLocator = function (byText, options) {
         return __awaiter(this, void 0, void 0, function () {
             var container, items;
             return __generator(this, function (_e) {
                 switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.portal.getContainer()];
+                    case 0: return [4 /*yield*/, this.portal.getContainer(options)];
                     case 1:
                         container = _e.sent();
                         items = container.locator((0, dataTidSelector_1.getDataTidSelector)(CustomComboBox_1.ComboBoxMenuDataTids.item));

package/build/src/components/ComponentList.d.ts

@@ -2,14 +2,16 @@ import type { Locator } from '@playwright/test';
 import { BaseComponent } from './BaseComponent';
 import { ComponentListAssertions } from '../assertions';
 import { type TooltipType } from '../utils';
-import type { IsVisibleOptions } from '../options';
-import { toVisibleElementLocator, toValueElementLocator } from '../matchers/component/LocatorSymbols';
+import type { FilterOptions, IsVisibleOptions } from '../options';
+import { toVisibleElementLocator, toValueElementLocator, toItemsElementLocator, toContainItemElementLocator } from '../matchers/component/LocatorSymbols';
 export declare class ComponentList<TItem extends BaseComponent> extends BaseComponent {
     readonly rootLocator: Locator;
     private readonly itemFactory;
     readonly itemsLocator: Locator;
     readonly [toVisibleElementLocator]: () => Locator;
     readonly [toValueElementLocator]: () => Locator;
+    readonly [toItemsElementLocator]: () => Locator;
+    readonly [toContainItemElementLocator]: () => Locator;
     constructor(rootLocator: Locator, itemsLocator: (rootLocator: Locator) => Locator, itemFactory: (locator: Locator) => TItem);
     isVisible(options?: IsVisibleOptions): Promise<boolean>;
     /**
@@ -20,6 +22,7 @@ export declare class ComponentList<TItem extends BaseComponent> extends BaseComp
      * Когда список элементов стабилен, но загружается динамически, необходимо дождаться полной загрузки списка перед вызовом getItems
      */
     getItems(): Promise<TItem[]>;
+    filter(options?: FilterOptions): ComponentList<TItem>;
     /**
      * Поведение метода идентично вызову locator.nth(0)
      */