@skbkontur/playwright-react-ui-components 1.13.0

package/build/src/assertions/TooltipAssertions.js

@@ -0,0 +1,114 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooltipAssertions = void 0;
+var BaseComponentAssertions_1 = require("./BaseComponentAssertions");
+var matchers_1 = require("../matchers");
+var TooltipAssertions = /** @class */ (function (_super) {
+    __extends(TooltipAssertions, _super);
+    function TooltipAssertions(tooltip) {
+        var _this = _super.call(this, tooltip) || this;
+        _this.tooltip = tooltip;
+        return _this;
+    }
+    TooltipAssertions.prototype.toHaveText = function (text, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, matchers_1.mergedExpects)(this.tooltip.rootLocator).toHaveText(text, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TooltipAssertions.prototype.notToHaveText = function (text, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, matchers_1.mergedExpects)(this.tooltip.rootLocator).not.toHaveText(text, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TooltipAssertions.prototype.toContainText = function (text, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, matchers_1.mergedExpects)(this.tooltip.rootLocator).toContainText(text, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TooltipAssertions.prototype.notToContainText = function (text, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, matchers_1.mergedExpects)(this.tooltip.rootLocator).not.toContainText(text, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return TooltipAssertions;
+}(BaseComponentAssertions_1.BaseComponentAssertions));
+exports.TooltipAssertions = TooltipAssertions;

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

@@ -0,0 +1,34 @@
+export { BaseComponentAssertions } from './BaseComponentAssertions';
+export { ButtonAssertions } from './ButtonAssertions';
+export { PortalAssertions } from './PortalAssertions';
+export { TooltipAssertions } from './TooltipAssertions';
+export { CheckboxAssertions } from './CheckboxAssertions';
+export { ComboBoxAssertions } from './ComboBoxAssertions';
+export { ComponentListAssertions } from './ComponentListAssertions';
+export { LabelAssertions } from './LabelAssertions';
+export { MenuItemAssertations } from './MenuItemAssertations';
+export { RadioAssertions } from './RadioAssertions';
+export { RadioGroupAssertions } from './RadioGroupAssertions';
+export { InputAssertions } from './InputAssertions';
+export { CurrencyInputAssertions } from './CurrencyInputAssertions';
+export { TokenAssertions } from './TokenAssertions';
+export { TokenInputAssertions } from './TokenInputAssertions';
+export { TextareaAssertions } from './TextareaAssertions';
+export { DatePickerAssertions } from './DatePickerAssertions';
+export { DateRangePickerAssertions } from './DateRangePickerAssertions';
+export { DropdownMenuAssertions } from './DropdownMenuAssertions';
+export { DropdownAssertions } from './DropdownAssertions';
+export { ToastAssertions } from './ToastAssertions';
+export { SelectAssertions } from './SelectAssertions';
+export { ToggleAssertions } from './ToggleAssertions';
+export { LinkAssertions } from './LinkAssertions';
+export { TabsAssertions } from './TabsAssertions';
+export { TabAssertions } from './TabAssertions';
+export { LoaderAssertions } from './LoaderAssertions';
+export { SpinnerAssertions } from './SpinnerAssertions';
+export { AutocompleteAssertions } from './AutocompleteAssertions';
+export { DateInputAssertions } from './DateInputAssertions';
+export { FileUploaderAssertions } from './FileUploaderAssertions';
+export { FxInputAssertions } from './FxInputAssertions';
+export { KebabAssertions } from './KebabAssertions';
+export { PagingAssertions } from './PagingAssertions';

package/build/src/assertions/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PagingAssertions = exports.KebabAssertions = exports.FxInputAssertions = exports.FileUploaderAssertions = exports.DateInputAssertions = exports.AutocompleteAssertions = exports.SpinnerAssertions = exports.LoaderAssertions = exports.TabAssertions = exports.TabsAssertions = exports.LinkAssertions = exports.ToggleAssertions = exports.SelectAssertions = exports.ToastAssertions = exports.DropdownAssertions = exports.DropdownMenuAssertions = exports.DateRangePickerAssertions = exports.DatePickerAssertions = exports.TextareaAssertions = exports.TokenInputAssertions = exports.TokenAssertions = exports.CurrencyInputAssertions = exports.InputAssertions = exports.RadioGroupAssertions = exports.RadioAssertions = exports.MenuItemAssertations = exports.LabelAssertions = exports.ComponentListAssertions = exports.ComboBoxAssertions = exports.CheckboxAssertions = exports.TooltipAssertions = exports.PortalAssertions = exports.ButtonAssertions = exports.BaseComponentAssertions = void 0;
+var BaseComponentAssertions_1 = require("./BaseComponentAssertions");
+Object.defineProperty(exports, "BaseComponentAssertions", { enumerable: true, get: function () { return BaseComponentAssertions_1.BaseComponentAssertions; } });
+var ButtonAssertions_1 = require("./ButtonAssertions");
+Object.defineProperty(exports, "ButtonAssertions", { enumerable: true, get: function () { return ButtonAssertions_1.ButtonAssertions; } });
+var PortalAssertions_1 = require("./PortalAssertions");
+Object.defineProperty(exports, "PortalAssertions", { enumerable: true, get: function () { return PortalAssertions_1.PortalAssertions; } });
+var TooltipAssertions_1 = require("./TooltipAssertions");
+Object.defineProperty(exports, "TooltipAssertions", { enumerable: true, get: function () { return TooltipAssertions_1.TooltipAssertions; } });
+var CheckboxAssertions_1 = require("./CheckboxAssertions");
+Object.defineProperty(exports, "CheckboxAssertions", { enumerable: true, get: function () { return CheckboxAssertions_1.CheckboxAssertions; } });
+var ComboBoxAssertions_1 = require("./ComboBoxAssertions");
+Object.defineProperty(exports, "ComboBoxAssertions", { enumerable: true, get: function () { return ComboBoxAssertions_1.ComboBoxAssertions; } });
+var ComponentListAssertions_1 = require("./ComponentListAssertions");
+Object.defineProperty(exports, "ComponentListAssertions", { enumerable: true, get: function () { return ComponentListAssertions_1.ComponentListAssertions; } });
+var LabelAssertions_1 = require("./LabelAssertions");
+Object.defineProperty(exports, "LabelAssertions", { enumerable: true, get: function () { return LabelAssertions_1.LabelAssertions; } });
+var MenuItemAssertations_1 = require("./MenuItemAssertations");
+Object.defineProperty(exports, "MenuItemAssertations", { enumerable: true, get: function () { return MenuItemAssertations_1.MenuItemAssertations; } });
+var RadioAssertions_1 = require("./RadioAssertions");
+Object.defineProperty(exports, "RadioAssertions", { enumerable: true, get: function () { return RadioAssertions_1.RadioAssertions; } });
+var RadioGroupAssertions_1 = require("./RadioGroupAssertions");
+Object.defineProperty(exports, "RadioGroupAssertions", { enumerable: true, get: function () { return RadioGroupAssertions_1.RadioGroupAssertions; } });
+var InputAssertions_1 = require("./InputAssertions");
+Object.defineProperty(exports, "InputAssertions", { enumerable: true, get: function () { return InputAssertions_1.InputAssertions; } });
+var CurrencyInputAssertions_1 = require("./CurrencyInputAssertions");
+Object.defineProperty(exports, "CurrencyInputAssertions", { enumerable: true, get: function () { return CurrencyInputAssertions_1.CurrencyInputAssertions; } });
+var TokenAssertions_1 = require("./TokenAssertions");
+Object.defineProperty(exports, "TokenAssertions", { enumerable: true, get: function () { return TokenAssertions_1.TokenAssertions; } });
+var TokenInputAssertions_1 = require("./TokenInputAssertions");
+Object.defineProperty(exports, "TokenInputAssertions", { enumerable: true, get: function () { return TokenInputAssertions_1.TokenInputAssertions; } });
+var TextareaAssertions_1 = require("./TextareaAssertions");
+Object.defineProperty(exports, "TextareaAssertions", { enumerable: true, get: function () { return TextareaAssertions_1.TextareaAssertions; } });
+var DatePickerAssertions_1 = require("./DatePickerAssertions");
+Object.defineProperty(exports, "DatePickerAssertions", { enumerable: true, get: function () { return DatePickerAssertions_1.DatePickerAssertions; } });
+var DateRangePickerAssertions_1 = require("./DateRangePickerAssertions");
+Object.defineProperty(exports, "DateRangePickerAssertions", { enumerable: true, get: function () { return DateRangePickerAssertions_1.DateRangePickerAssertions; } });
+var DropdownMenuAssertions_1 = require("./DropdownMenuAssertions");
+Object.defineProperty(exports, "DropdownMenuAssertions", { enumerable: true, get: function () { return DropdownMenuAssertions_1.DropdownMenuAssertions; } });
+var DropdownAssertions_1 = require("./DropdownAssertions");
+Object.defineProperty(exports, "DropdownAssertions", { enumerable: true, get: function () { return DropdownAssertions_1.DropdownAssertions; } });
+var ToastAssertions_1 = require("./ToastAssertions");
+Object.defineProperty(exports, "ToastAssertions", { enumerable: true, get: function () { return ToastAssertions_1.ToastAssertions; } });
+var SelectAssertions_1 = require("./SelectAssertions");
+Object.defineProperty(exports, "SelectAssertions", { enumerable: true, get: function () { return SelectAssertions_1.SelectAssertions; } });
+var ToggleAssertions_1 = require("./ToggleAssertions");
+Object.defineProperty(exports, "ToggleAssertions", { enumerable: true, get: function () { return ToggleAssertions_1.ToggleAssertions; } });
+var LinkAssertions_1 = require("./LinkAssertions");
+Object.defineProperty(exports, "LinkAssertions", { enumerable: true, get: function () { return LinkAssertions_1.LinkAssertions; } });
+var TabsAssertions_1 = require("./TabsAssertions");
+Object.defineProperty(exports, "TabsAssertions", { enumerable: true, get: function () { return TabsAssertions_1.TabsAssertions; } });
+var TabAssertions_1 = require("./TabAssertions");
+Object.defineProperty(exports, "TabAssertions", { enumerable: true, get: function () { return TabAssertions_1.TabAssertions; } });
+var LoaderAssertions_1 = require("./LoaderAssertions");
+Object.defineProperty(exports, "LoaderAssertions", { enumerable: true, get: function () { return LoaderAssertions_1.LoaderAssertions; } });
+var SpinnerAssertions_1 = require("./SpinnerAssertions");
+Object.defineProperty(exports, "SpinnerAssertions", { enumerable: true, get: function () { return SpinnerAssertions_1.SpinnerAssertions; } });
+var AutocompleteAssertions_1 = require("./AutocompleteAssertions");
+Object.defineProperty(exports, "AutocompleteAssertions", { enumerable: true, get: function () { return AutocompleteAssertions_1.AutocompleteAssertions; } });
+var DateInputAssertions_1 = require("./DateInputAssertions");
+Object.defineProperty(exports, "DateInputAssertions", { enumerable: true, get: function () { return DateInputAssertions_1.DateInputAssertions; } });
+var FileUploaderAssertions_1 = require("./FileUploaderAssertions");
+Object.defineProperty(exports, "FileUploaderAssertions", { enumerable: true, get: function () { return FileUploaderAssertions_1.FileUploaderAssertions; } });
+var FxInputAssertions_1 = require("./FxInputAssertions");
+Object.defineProperty(exports, "FxInputAssertions", { enumerable: true, get: function () { return FxInputAssertions_1.FxInputAssertions; } });
+var KebabAssertions_1 = require("./KebabAssertions");
+Object.defineProperty(exports, "KebabAssertions", { enumerable: true, get: function () { return KebabAssertions_1.KebabAssertions; } });
+var PagingAssertions_1 = require("./PagingAssertions");
+Object.defineProperty(exports, "PagingAssertions", { enumerable: true, get: function () { return PagingAssertions_1.PagingAssertions; } });

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

@@ -0,0 +1,25 @@
+import type { Locator } from '@playwright/test';
+import { BaseComponent } from './BaseComponent';
+import { type TooltipType } from '../utils';
+import { AutocompleteAssertions } from '../assertions';
+import type { BlurOptions, ClearOptions, ClickOptions, FillOptions, FocusOptions, InputValueOptions, IsDisabledOptions, PressOptions, PressSequentiallyOptions } from '../options';
+export declare class Autocomplete extends BaseComponent {
+    private readonly portal;
+    readonly inputLocator: Locator;
+    constructor(rootLocator: Locator);
+    isDisabled(options?: IsDisabledOptions): Promise<boolean>;
+    getValue(options?: InputValueOptions): Promise<string>;
+    fill(value: string, options?: FillOptions): Promise<void>;
+    press(value: string, options?: PressOptions): Promise<void>;
+    pressSequentially(value: string, options?: PressSequentiallyOptions): Promise<void>;
+    clear(options?: ClearOptions): Promise<void>;
+    focus(options?: FocusOptions): Promise<void>;
+    blur(options?: BlurOptions): Promise<void>;
+    click(options?: ClickOptions): Promise<void>;
+    getTooltip(type: TooltipType): Promise<import("./Tooltip").Tooltip>;
+    selectFirstSuggestion(options?: ClickOptions): Promise<void>;
+    selectSuggestionByIndex(index: number, options?: ClickOptions): Promise<void>;
+    selectSuggestionByText(text: string | RegExp, options?: ClickOptions): Promise<void>;
+    expect(): AutocompleteAssertions;
+    private getSuggestions;
+}

package/build/src/components/Autocomplete.js

@@ -0,0 +1,256 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autocomplete = void 0;
+var test_1 = require("@playwright/test");
+var react_ui_1 = require("@skbkontur/react-ui");
+var BaseComponent_1 = require("./BaseComponent");
+var Portal_1 = require("./Portal");
+var utils_1 = require("../utils");
+var assertions_1 = require("../assertions");
+var dataTidSelector_1 = require("../utils/dataTidSelector");
+var Autocomplete = /** @class */ (function (_super) {
+    __extends(Autocomplete, _super);
+    function Autocomplete(rootLocator) {
+        var _this = _super.call(this, rootLocator) || this;
+        _this.portal = new Portal_1.Portal(rootLocator.locator('noscript'));
+        _this.inputLocator = rootLocator.locator('input');
+        return _this;
+    }
+    Autocomplete.prototype.isDisabled = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.isDisabled(options)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.getValue = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.inputValue(options)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.fill = function (value, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.focus()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.clear()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.inputLocator.fill(value, options)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.press = function (value, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.press(value, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.pressSequentially = function (value, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.pressSequentially(value, options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.clear = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.clear(options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.focus = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, test_1.expect)(this.inputLocator).toBeEnabled()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.inputLocator.focus(options)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.blur = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.blur(options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.click = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.inputLocator.click(options)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.getTooltip = function (type) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, utils_1.getTooltip)(type, this)];
+            });
+        });
+    };
+    Autocomplete.prototype.selectFirstSuggestion = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var suggestions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getSuggestions()];
+                    case 1:
+                        suggestions = _a.sent();
+                        return [4 /*yield*/, suggestions.first().click(options)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.selectSuggestionByIndex = function (index, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var suggestions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getSuggestions()];
+                    case 1:
+                        suggestions = _a.sent();
+                        return [4 /*yield*/, suggestions.nth(index).click(options)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.selectSuggestionByText = function (text, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var suggestions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getSuggestions()];
+                    case 1:
+                        suggestions = _a.sent();
+                        return [4 /*yield*/, suggestions.getByText(text).click(options)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Autocomplete.prototype.expect = function () {
+        return new assertions_1.AutocompleteAssertions(this);
+    };
+    Autocomplete.prototype.getSuggestions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var container;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.portal.getContainer()];
+                    case 1:
+                        container = _a.sent();
+                        return [2 /*return*/, container.locator((0, dataTidSelector_1.getDataTidSelector)(react_ui_1.MenuItemDataTids.root))];
+                }
+            });
+        });
+    };
+    return Autocomplete;
+}(BaseComponent_1.BaseComponent));
+exports.Autocomplete = Autocomplete;

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

@@ -0,0 +1,18 @@
+import type { Locator, Page } from '@playwright/test';
+import { BaseComponentAssertions } from '../assertions';
+import type { ClickOptions, GetAttributeOptions, HoverOptions, IsVisibleOptions, ScrollIntoViewIfNeededOptions, WaitForOptions } from '../options';
+export declare abstract class BaseComponent {
+    readonly rootLocator: Locator;
+    readonly page: Page;
+    protected constructor(rootLocator: Locator);
+    isVisible(options?: IsVisibleOptions): Promise<boolean>;
+    hasError(options?: GetAttributeOptions): Promise<boolean>;
+    hasWarning(options?: GetAttributeOptions): Promise<boolean>;
+    click(options?: ClickOptions): Promise<void>;
+    hover(options?: HoverOptions): Promise<void>;
+    scrollIntoViewIfNeeded(options?: ScrollIntoViewIfNeededOptions): Promise<void>;
+    waitFor(options?: WaitForOptions): Promise<void>;
+    hasAttribute(name: string, options?: GetAttributeOptions): Promise<boolean>;
+    getAttribute(name: string, options?: GetAttributeOptions): Promise<string | null>;
+    expect(): BaseComponentAssertions;
+}