@dynatrace/strato-components-testing 3.11.3 → 3.12.0

package/shared/testing-helpers/filters/filter-field.js

@@ -0,0 +1,449 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filter_field_exports = {};
+__export(filter_field_exports, {
+  FilterFieldHelper: () => FilterFieldHelper,
+  FilterFieldPinnedAndRecentSuggestionBase: () => FilterFieldPinnedAndRecentSuggestionBase,
+  FilterFieldPinnedSuggestion: () => FilterFieldPinnedSuggestion,
+  FilterFieldRecentSuggestion: () => FilterFieldRecentSuggestion,
+  createFilterFieldHelpers: () => createFilterFieldHelpers
+});
+module.exports = __toCommonJS(filter_field_exports);
+var import_react = require("@testing-library/react");
+var import_user_event = require("@testing-library/user-event");
+class FilterFieldPinnedAndRecentSuggestionBase {
+  /** @internal */
+  constructor(suggestionRoot, deps) {
+    this.suggestionRoot = suggestionRoot;
+    this._deps = deps;
+  }
+  suggestionRoot;
+  _deps;
+  get pinButtonElement() {
+    return this.suggestionRoot.querySelector(
+      "button[aria-checked]"
+    );
+  }
+  /**
+   * Receives the value of the suggestion that would be applied.
+   */
+  get value() {
+    return this.suggestionRoot.childNodes.item(1).textContent;
+  }
+  /**
+   * Returns if the current suggestion is currently pinned or not.
+   */
+  get pinned() {
+    if (this.pinButtonElement) {
+      return this.pinButtonElement.getAttribute("aria-checked") === "true";
+    }
+    return false;
+  }
+  /**
+   * Applies the suggestion to the filter field.
+   */
+  async apply() {
+    await this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).click(this.suggestionRoot);
+  }
+  get pinEnabled() {
+    if (this.pinButtonElement) {
+      return this.pinButtonElement.getAttribute("aria-disabled") === "false";
+    }
+    return false;
+  }
+  /**
+   * Allows the suggestion to be pinned if not pinned already.
+   */
+  async pin() {
+    if (this.pinned === true) {
+      return;
+    }
+    if (this.pinButtonElement) {
+      await this._deps.setupUserEvent({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(this.pinButtonElement);
+      if (this._deps.isFakeTimersEnabled()) {
+        await (0, import_react.act)(async () => {
+          this._deps.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+  /**
+   * Allows the suggestion to be unpinned if not unpinned already.
+   */
+  async unpin() {
+    if (this.pinned === false) {
+      return;
+    }
+    if (this.pinButtonElement) {
+      await this._deps.setupUserEvent({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(this.pinButtonElement);
+      if (this._deps.isFakeTimersEnabled()) {
+        await (0, import_react.act)(async () => {
+          this._deps.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+}
+class FilterFieldPinnedSuggestion extends FilterFieldPinnedAndRecentSuggestionBase {
+  /**
+   * Receives the value of the suggestion that would be applied.
+   */
+  get value() {
+    return this.suggestionRoot.childNodes.item(0).textContent;
+  }
+}
+class FilterFieldRecentSuggestion extends FilterFieldPinnedAndRecentSuggestionBase {
+  /**
+   * Receives the value of the suggestion that would be applied.
+   */
+  get value() {
+    return this.suggestionRoot.querySelector('[role="option"]')?.childNodes.item(0).textContent ?? null;
+  }
+  /**
+   * Receives time offset indicating when the filter statement has last been used.
+   */
+  get lastUsed() {
+    return this.suggestionRoot.querySelector('[role="option"]')?.childNodes.item(1).textContent ?? null;
+  }
+}
+class FilterFieldHelper {
+  /** @internal */
+  constructor(dataTestId, deps) {
+    this.dataTestId = dataTestId;
+    this._deps = deps;
+  }
+  dataTestId;
+  _deps;
+  get filterFieldWrapper() {
+    return import_react.screen.getByTestId(this.dataTestId);
+  }
+  get editorView() {
+    return this.filterFieldWrapper.querySelector(
+      ".cm-content"
+    )?.cmTile?.view;
+  }
+  get inputElement() {
+    return (0, import_react.within)(this.filterFieldWrapper).getAllByRole(
+      "textbox",
+      { hidden: true }
+    )[1];
+  }
+  get filterFieldElement() {
+    return (0, import_react.within)(this.filterFieldWrapper).getByRole(
+      "textbox",
+      {
+        name: "Filter field",
+        hidden: true
+      }
+    );
+  }
+  get placeholderElement() {
+    return this.filterFieldWrapper.querySelector(".cm-placeholder");
+  }
+  get suggestionsContainer() {
+    return import_react.screen.queryByTestId(`filterfield-suggestions-${this.dataTestId}`);
+  }
+  /** Returns the value of the native text input. */
+  get value() {
+    return this.inputElement.value;
+  }
+  /** Returns the value of the filter field. */
+  get filterFieldValue() {
+    return this.filterFieldElement.textContent || "";
+  }
+  /**
+   * The placeholder text shown in the filter field.
+   * Undefined if the placeholder is currently not rendered.
+   */
+  get placeholder() {
+    return this.placeholderElement?.textContent || void 0;
+  }
+  /** Focus the filter field if not already focused. */
+  async focus() {
+    if (!this.filterFieldWrapper.contains(document.activeElement)) {
+      await (0, import_react.act)(async () => {
+        this.inputElement.focus();
+      });
+      expect(
+        this.filterFieldWrapper.contains(document.activeElement)
+      ).toBeTruthy();
+      if (this._deps.isFakeTimersEnabled()) {
+        await (0, import_react.act)(async () => {
+          this._deps.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+  /** Blur the filter field by tabbing out of it. */
+  async blur() {
+    await (0, import_react.act)(async () => {
+      this.filterFieldElement.blur();
+    });
+    if (this._deps.isFakeTimersEnabled()) {
+      await (0, import_react.act)(async () => {
+        this._deps.runOnlyPendingTimers();
+      });
+    }
+  }
+  /** Fill a provided value into the filter field. */
+  async type(text, cursorIndex) {
+    const regEx = new RegExp(text, "g");
+    const matches = this.value.match(regEx);
+    await this.moveCursorTo(cursorIndex ?? -1);
+    await this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).keyboard(text);
+    await (0, import_react.waitFor)(() => {
+      expect(this.value.match(regEx) ?? []).toHaveLength(
+        (matches?.length ?? 0) + 1
+      );
+    });
+    if (this._deps.isFakeTimersEnabled()) {
+      await (0, import_react.act)(async () => {
+        this._deps.runOnlyPendingTimers();
+      });
+    }
+  }
+  /** Clears the filter field value. */
+  async clear() {
+    if (this.value !== "") {
+      await this._deps.setupUserEvent({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(
+        await (0, import_react.within)(this.filterFieldWrapper).findByRole("button", {
+          name: "Clear filter",
+          hidden: true
+        })
+      );
+      if (this._deps.isFakeTimersEnabled()) {
+        await (0, import_react.act)(async () => {
+          this._deps.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+  /**
+   * Moves the cursor to the given index.
+   * -1 moves to the end of the input.
+   */
+  async moveCursorTo(index) {
+    const user = this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    });
+    if (index === -1) {
+      await (0, import_react.act)(async () => {
+        await this.focus();
+      });
+      await user.keyboard("{PageDown}");
+      return;
+    }
+    const editorView = this.editorView;
+    if (!editorView) {
+      console.warn("FilterField editor could not be found. Panic now.");
+      return;
+    }
+    await (0, import_react.act)(async () => {
+      await this.focus();
+      editorView.dispatch({
+        selection: {
+          anchor: Math.min(index, editorView.state.doc.length)
+        }
+      });
+    });
+    if (this._deps.isFakeTimersEnabled()) {
+      await (0, import_react.act)(async () => {
+        this._deps.runOnlyPendingTimers();
+      });
+    }
+  }
+  /** Open the suggestions overlay with the keyboard shortcut. */
+  async openSuggestions() {
+    await (0, import_react.act)(async () => {
+      await this.focus();
+    });
+    await this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).keyboard("{Control>}{Space}{/Control}");
+    await (0, import_react.waitFor)(
+      async () => expect(this.suggestionsContainer).toBeInTheDocument()
+    );
+    if (this._deps.isFakeTimersEnabled()) {
+      await (0, import_react.act)(async () => {
+        this._deps.runOnlyPendingTimers();
+      });
+    }
+  }
+  /**
+   * Close the suggestions overlay using the `Escape` key.
+   * If the filter field is focused, the focus will stay in the filter field.
+   */
+  async closeSuggestions() {
+    await (0, import_react.act)(async () => {
+      await this.focus();
+    });
+    await this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).keyboard("{Escape}");
+    if (this.suggestionsContainer !== null) {
+      await (0, import_react.waitForElementToBeRemoved)(() => this.suggestionsContainer);
+    }
+  }
+  /** Apply the suggestion with the given text. */
+  async applySuggestion(queryString) {
+    await (0, import_react.act)(async () => {
+      await this.focus();
+    });
+    await (0, import_react.waitFor)(() => {
+      expect(this.suggestionsContainer).toBeInTheDocument();
+    });
+    if (!this.suggestionsContainer) {
+      console.warn(
+        "The filter field suggestions overlay seems to be closed. Make sure to open it before applying a suggestion."
+      );
+      return;
+    }
+    const showMore = (0, import_react.within)(this.suggestionsContainer).queryByRole("option", {
+      name: "Show more"
+    });
+    if (showMore) {
+      await this._deps.setupUserEvent({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(showMore);
+    }
+    let suggestions = (0, import_react.within)(this.suggestionsContainer).queryAllByTestId(
+      queryString,
+      { exact: true }
+    );
+    if (suggestions.length > 0) {
+      suggestions = suggestions.reduce((acc, container) => {
+        const suggestion = (0, import_react.within)(container).queryByRole("option");
+        if (suggestion) {
+          acc.push(suggestion);
+        }
+        return acc;
+      }, []);
+    }
+    if (suggestions.length === 0) {
+      suggestions.push(
+        ...(0, import_react.within)(this.suggestionsContainer).queryAllByText(
+          (_, element) => element?.getAttribute("role") === "option" && // The replace is needed to ignore non-breaking spaces
+          element.firstElementChild?.textContent?.replace(/\s+/g, " ") === queryString.replace(/\s+/g, " ")
+        )
+      );
+    }
+    if (suggestions.length === 0) {
+      console.warn(
+        `Could not query a suggestion with the given queryString '${queryString}' (trying queryByTestId and queryByText).`
+      );
+      return;
+    }
+    if (suggestions.length > 1) {
+      console.warn(
+        "Found multiple suggestions with the given testId. Will apply the first one"
+      );
+    }
+    await this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).click(suggestions[0]);
+  }
+  /** Get recent suggestions */
+  async getRecentSuggestions() {
+    if (this.suggestionsContainer) {
+      const recentGroup = (0, import_react.within)(this.suggestionsContainer).getByRole("group", {
+        name: "Recently used filters"
+      });
+      const suggestions = (0, import_react.within)(recentGroup).getAllByRole(
+        "group",
+        {
+          hidden: true,
+          name(_accessibleName, element) {
+            return element.getAttribute(
+              "data-strato-filter-field-virtual-focus-type"
+            ) === "recent-suggestion";
+          }
+        }
+      );
+      return suggestions.map(
+        (el) => new FilterFieldRecentSuggestion(el, this._deps)
+      );
+    }
+    return [];
+  }
+  /** Get pinned suggestions */
+  async getPinnedSuggestions() {
+    if (this.suggestionsContainer) {
+      try {
+        await (0, import_react.waitFor)(
+          () => import_react.screen.getByRole("group", {
+            name: "Pinned filters",
+            hidden: true,
+            suggest: false
+          })
+        );
+        const pinnedGroup = (0, import_react.within)(this.suggestionsContainer).getByRole(
+          "group",
+          {
+            name: "Pinned filters",
+            hidden: true
+          }
+        );
+        const suggestions = (0, import_react.within)(pinnedGroup).getAllByRole(
+          "group",
+          {
+            hidden: true,
+            name(_accessibleName, element) {
+              return element.getAttribute(
+                "data-strato-filter-field-virtual-focus-type"
+              ) === "pinned-suggestion";
+            }
+          }
+        );
+        return suggestions.map(
+          (el) => new FilterFieldPinnedSuggestion(el, this._deps)
+        );
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+  /** Paste text at the current cursor position */
+  async paste(text, cursorIndex) {
+    await this.moveCursorTo(cursorIndex ?? -1);
+    await this._deps.setupUserEvent({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).paste(text);
+    if (this._deps.isFakeTimersEnabled()) {
+      await (0, import_react.act)(async () => {
+        this._deps.runOnlyPendingTimers();
+      });
+    }
+  }
+}
+function createFilterFieldHelpers(deps) {
+  function getFilterFieldHelper(dataTestId) {
+    return new FilterFieldHelper(dataTestId, deps);
+  }
+  return { getFilterFieldHelper };
+}

package/vitest/index.d.ts

@@ -0,0 +1,32 @@
+import '@testing-library/jest-dom/vitest';
+export { customRender as render, type RenderWithIntlOptions, } from '../jest/custom-render.js';
+export { stratoVitestPreset } from './preset/index.js';
+export { getTextInputHelper, type TextInputHelper, } from '../jest/testing-helpers/forms/text-input.js';
+export { getPasswordInputHelper, type PasswordInputHelper, } from '../jest/testing-helpers/forms/password-input.js';
+export { getSearchInputHelper, type SearchInputHelper, } from '../jest/testing-helpers/forms/search-input.js';
+export { getDataTableHelper, type DataTableHelper, type DataTablePaginationHelper, type DataTableUserActionHelper, type DataTableSortingHelper, type DataTableRowSelectionHelper, type DataTableSubRowsHelper, type DataTableInteractiveRowsHelper, type DataTableDownloadHelper, type DataTableExpandableRowHelper, } from '../jest/testing-helpers/tables/datatable.js';
+export type { BaseInputHelper } from '../jest/testing-helpers/forms/base-input.js';
+export { getFilterFieldHelper, FilterFieldHelper, FilterFieldPinnedAndRecentSuggestionBase, FilterFieldPinnedSuggestion, FilterFieldRecentSuggestion, } from './testing-helpers/filters/filter-field.js';
+export type { _FilterFieldDeps } from './testing-helpers/filters/filter-field.js';
+export { getSelectTestingHelper, type SelectTestingHelper, } from '../jest/testing-helpers/forms/select.js';
+export { setupGetBoundingClientRectMock, clearGetBoundingClientRectMock, } from '../jest/mocks/bounding-client-rect-mock.js';
+export { createMockElement } from '../jest/mocks/create-mock-element.js';
+export { setupCanvasMeasureTextMock, clearCanvasMeasureTextMock, } from '../jest/mocks/canvas-mock.js';
+export { setupOffsetWidthMock, clearOffsetWidthMock, } from '../jest/mocks/offset-width-mock.js';
+export { setupOffsetHeightMock, clearOffsetHeightMock, } from '../jest/mocks/offset-height-mock.js';
+export { setupDomRectMock, clearDomRectMock, } from '../jest/mocks/dom-rect-mock.js';
+export { setupPointerEventMock, clearPointerEventMock, } from '../jest/mocks/pointer-event-mock.js';
+export { setupScreenSizeMock, clearScreenSizeMock, } from '../jest/mocks/screen-size-mock.js';
+export { setupScrollWidthMock, clearScrollWidthMock, } from '../jest/mocks/scroll-width-mock.js';
+export { setupVirtualizationMock, clearVirtualizationMock, } from '../jest/mocks/virtualization-mock.js';
+export { setupTextEllipsisMock, clearTextEllipsisMock, } from '../jest/mocks/text-ellipsis-mock.js';
+export { setupElementFromPointMock, clearElementFromPointMock, } from '../jest/mocks/element-from-point-mock.js';
+export { setupResizeObserverMock, clearResizeObserverMock, } from './mocks/resize-observer-mock.js';
+export { setupMatchMediaMock, clearMatchMediaMock, } from './mocks/match-media-mock.js';
+export { setupIntersectionObserverMock, clearIntersectionObserverMock, } from './mocks/intersection-observer-mock.js';
+export { setupScrollIntoViewMock, clearScrollIntoViewMock, } from './mocks/scroll-into-view-mock.js';
+export { setupCreateRangeMock, clearCreateRangeMock, } from './mocks/create-range-mock.js';
+export { setupFetchMock, clearFetchMock } from './mocks/fetch-mock.js';
+export type { MockedResponse } from '../shared/mocks/fetch-mock.js';
+export { setupFramerMotionMock, clearFramerMotionMock, type FramerMotionActual, } from './mocks/framer-motion-mock.js';
+//# sourceMappingURL=index.d.ts.map

package/vitest/index.js

@@ -0,0 +1,98 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vitest_exports = {};
+__export(vitest_exports, {
+  FilterFieldHelper: () => import_filter_field.FilterFieldHelper,
+  FilterFieldPinnedAndRecentSuggestionBase: () => import_filter_field.FilterFieldPinnedAndRecentSuggestionBase,
+  FilterFieldPinnedSuggestion: () => import_filter_field.FilterFieldPinnedSuggestion,
+  FilterFieldRecentSuggestion: () => import_filter_field.FilterFieldRecentSuggestion,
+  clearCanvasMeasureTextMock: () => import_canvas_mock.clearCanvasMeasureTextMock,
+  clearCreateRangeMock: () => import_create_range_mock.clearCreateRangeMock,
+  clearDomRectMock: () => import_dom_rect_mock.clearDomRectMock,
+  clearElementFromPointMock: () => import_element_from_point_mock.clearElementFromPointMock,
+  clearFetchMock: () => import_fetch_mock.clearFetchMock,
+  clearFramerMotionMock: () => import_framer_motion_mock.clearFramerMotionMock,
+  clearGetBoundingClientRectMock: () => import_bounding_client_rect_mock.clearGetBoundingClientRectMock,
+  clearIntersectionObserverMock: () => import_intersection_observer_mock.clearIntersectionObserverMock,
+  clearMatchMediaMock: () => import_match_media_mock.clearMatchMediaMock,
+  clearOffsetHeightMock: () => import_offset_height_mock.clearOffsetHeightMock,
+  clearOffsetWidthMock: () => import_offset_width_mock.clearOffsetWidthMock,
+  clearPointerEventMock: () => import_pointer_event_mock.clearPointerEventMock,
+  clearResizeObserverMock: () => import_resize_observer_mock.clearResizeObserverMock,
+  clearScreenSizeMock: () => import_screen_size_mock.clearScreenSizeMock,
+  clearScrollIntoViewMock: () => import_scroll_into_view_mock.clearScrollIntoViewMock,
+  clearScrollWidthMock: () => import_scroll_width_mock.clearScrollWidthMock,
+  clearTextEllipsisMock: () => import_text_ellipsis_mock.clearTextEllipsisMock,
+  clearVirtualizationMock: () => import_virtualization_mock.clearVirtualizationMock,
+  createMockElement: () => import_create_mock_element.createMockElement,
+  getDataTableHelper: () => import_datatable.getDataTableHelper,
+  getFilterFieldHelper: () => import_filter_field.getFilterFieldHelper,
+  getPasswordInputHelper: () => import_password_input.getPasswordInputHelper,
+  getSearchInputHelper: () => import_search_input.getSearchInputHelper,
+  getSelectTestingHelper: () => import_select.getSelectTestingHelper,
+  getTextInputHelper: () => import_text_input.getTextInputHelper,
+  render: () => import_custom_render.customRender,
+  setupCanvasMeasureTextMock: () => import_canvas_mock.setupCanvasMeasureTextMock,
+  setupCreateRangeMock: () => import_create_range_mock.setupCreateRangeMock,
+  setupDomRectMock: () => import_dom_rect_mock.setupDomRectMock,
+  setupElementFromPointMock: () => import_element_from_point_mock.setupElementFromPointMock,
+  setupFetchMock: () => import_fetch_mock.setupFetchMock,
+  setupFramerMotionMock: () => import_framer_motion_mock.setupFramerMotionMock,
+  setupGetBoundingClientRectMock: () => import_bounding_client_rect_mock.setupGetBoundingClientRectMock,
+  setupIntersectionObserverMock: () => import_intersection_observer_mock.setupIntersectionObserverMock,
+  setupMatchMediaMock: () => import_match_media_mock.setupMatchMediaMock,
+  setupOffsetHeightMock: () => import_offset_height_mock.setupOffsetHeightMock,
+  setupOffsetWidthMock: () => import_offset_width_mock.setupOffsetWidthMock,
+  setupPointerEventMock: () => import_pointer_event_mock.setupPointerEventMock,
+  setupResizeObserverMock: () => import_resize_observer_mock.setupResizeObserverMock,
+  setupScreenSizeMock: () => import_screen_size_mock.setupScreenSizeMock,
+  setupScrollIntoViewMock: () => import_scroll_into_view_mock.setupScrollIntoViewMock,
+  setupScrollWidthMock: () => import_scroll_width_mock.setupScrollWidthMock,
+  setupTextEllipsisMock: () => import_text_ellipsis_mock.setupTextEllipsisMock,
+  setupVirtualizationMock: () => import_virtualization_mock.setupVirtualizationMock,
+  stratoVitestPreset: () => import_preset.stratoVitestPreset
+});
+module.exports = __toCommonJS(vitest_exports);
+var import_vitest = require("@testing-library/jest-dom/vitest");
+var import_custom_render = require("../jest/custom-render.js");
+var import_preset = require("./preset/index.js");
+var import_text_input = require("../jest/testing-helpers/forms/text-input.js");
+var import_password_input = require("../jest/testing-helpers/forms/password-input.js");
+var import_search_input = require("../jest/testing-helpers/forms/search-input.js");
+var import_datatable = require("../jest/testing-helpers/tables/datatable.js");
+var import_filter_field = require("./testing-helpers/filters/filter-field.js");
+var import_select = require("../jest/testing-helpers/forms/select.js");
+var import_bounding_client_rect_mock = require("../jest/mocks/bounding-client-rect-mock.js");
+var import_create_mock_element = require("../jest/mocks/create-mock-element.js");
+var import_canvas_mock = require("../jest/mocks/canvas-mock.js");
+var import_offset_width_mock = require("../jest/mocks/offset-width-mock.js");
+var import_offset_height_mock = require("../jest/mocks/offset-height-mock.js");
+var import_dom_rect_mock = require("../jest/mocks/dom-rect-mock.js");
+var import_pointer_event_mock = require("../jest/mocks/pointer-event-mock.js");
+var import_screen_size_mock = require("../jest/mocks/screen-size-mock.js");
+var import_scroll_width_mock = require("../jest/mocks/scroll-width-mock.js");
+var import_virtualization_mock = require("../jest/mocks/virtualization-mock.js");
+var import_text_ellipsis_mock = require("../jest/mocks/text-ellipsis-mock.js");
+var import_element_from_point_mock = require("../jest/mocks/element-from-point-mock.js");
+var import_resize_observer_mock = require("./mocks/resize-observer-mock.js");
+var import_match_media_mock = require("./mocks/match-media-mock.js");
+var import_intersection_observer_mock = require("./mocks/intersection-observer-mock.js");
+var import_scroll_into_view_mock = require("./mocks/scroll-into-view-mock.js");
+var import_create_range_mock = require("./mocks/create-range-mock.js");
+var import_fetch_mock = require("./mocks/fetch-mock.js");
+var import_framer_motion_mock = require("./mocks/framer-motion-mock.js");

package/vitest/mocks/create-range-mock.d.ts

@@ -0,0 +1,5 @@
+/** @public */
+export declare const setupCreateRangeMock: () => void;
+/** @public */
+export declare const clearCreateRangeMock: () => void;
+//# sourceMappingURL=create-range-mock.d.ts.map

package/vitest/mocks/create-range-mock.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_range_mock_exports = {};
+__export(create_range_mock_exports, {
+  clearCreateRangeMock: () => clearCreateRangeMock,
+  setupCreateRangeMock: () => setupCreateRangeMock
+});
+module.exports = __toCommonJS(create_range_mock_exports);
+var import_vitest = require("vitest");
+var import_create_range_mock = require("../../shared/mocks/create-range-mock.js");
+const _helpers = (0, import_create_range_mock.createCreateRangeMockHelpers)(import_vitest.vi.fn);
+const setupCreateRangeMock = _helpers.setupCreateRangeMock;
+const clearCreateRangeMock = _helpers.clearCreateRangeMock;

package/vitest/mocks/fetch-mock.d.ts

@@ -0,0 +1,5 @@
+/** @public */
+export declare const setupFetchMock: (mockedValue?: Partial<import("../index.js").MockedResponse>) => void;
+/** @public */
+export declare const clearFetchMock: () => void;
+//# sourceMappingURL=fetch-mock.d.ts.map

package/vitest/mocks/fetch-mock.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetch_mock_exports = {};
+__export(fetch_mock_exports, {
+  clearFetchMock: () => clearFetchMock,
+  setupFetchMock: () => setupFetchMock
+});
+module.exports = __toCommonJS(fetch_mock_exports);
+var import_vitest = require("vitest");
+var import_fetch_mock = require("../../shared/mocks/fetch-mock.js");
+const _helpers = (0, import_fetch_mock.createFetchMockHelpers)(import_vitest.vi.fn);
+const setupFetchMock = _helpers.setupFetchMock;
+const clearFetchMock = _helpers.clearFetchMock;

package/vitest/mocks/framer-motion-mock.d.ts

@@ -0,0 +1,27 @@
+/** @public */
+export type FramerMotionActual = {
+    isValidMotionProp: (key: string) => boolean;
+    cubicBezier: (mX1: number, mY1: number, mX2: number, mY2: number) => (t: number) => number;
+};
+/**
+ * Mocks framer motion so children are rendered without animations for easier testing.
+ * Needs to be called inside 'vi.mock' at the root level of the test file (vi.mock is hoisted):
+ *
+ *   vi.mock('framer-motion', async (importOriginal) =\> \{
+ *     const actual = await importOriginal\<typeof import('framer-motion')\>();
+ *     const \{ setupFramerMotionMock \} = await import('\@dynatrace/strato-components-testing/vitest');
+ *     return setupFramerMotionMock(actual);
+ *   \});
+ * @public
+ */
+export declare function setupFramerMotionMock(actual: FramerMotionActual): {
+    motion: any;
+    AnimatePresence: any;
+    useReducedMotion: (value?: boolean) => boolean;
+    cubicBezier: (mX1: number, mY1: number, mX2: number, mY2: number) => (t: number) => number;
+};
+/**
+ * @public
+ */
+export declare function clearFramerMotionMock(): void;
+//# sourceMappingURL=framer-motion-mock.d.ts.map