@dynatrace/strato-components-testing 3.11.3 → 3.12.1

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

@@ -0,0 +1,7 @@
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+export declare function createCreateRangeMockHelpers(fn: MockFnCreator): {
+    setupCreateRangeMock: () => void;
+    clearCreateRangeMock: () => void;
+};
+export {};
+//# sourceMappingURL=create-range-mock.d.ts.map

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

@@ -0,0 +1,47 @@
+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, {
+  createCreateRangeMockHelpers: () => createCreateRangeMockHelpers
+});
+module.exports = __toCommonJS(create_range_mock_exports);
+function createCreateRangeMockHelpers(fn) {
+  const pristineCreateRange = global.document.createRange;
+  function setupCreateRangeMock() {
+    Object.defineProperty(global.document, "createRange", {
+      writable: true,
+      value: () => {
+        const range = new Range();
+        range.getBoundingClientRect = fn();
+        range.getClientRects = () => {
+          return {
+            item: () => null,
+            length: 0,
+            [Symbol.iterator]: function* () {
+            }
+          };
+        };
+        return range;
+      }
+    });
+  }
+  function clearCreateRangeMock() {
+    global.document.createRange = pristineCreateRange;
+  }
+  return { setupCreateRangeMock, clearCreateRangeMock };
+}

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

@@ -0,0 +1,13 @@
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+/** @public */
+export interface MockedResponse {
+    ok: boolean;
+    status: number;
+    json: () => unknown;
+}
+export declare function createFetchMockHelpers(fn: MockFnCreator): {
+    setupFetchMock: (mockedValue?: Partial<MockedResponse>) => void;
+    clearFetchMock: () => void;
+};
+export {};
+//# sourceMappingURL=fetch-mock.d.ts.map

package/shared/mocks/fetch-mock.js

@@ -0,0 +1,41 @@
+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, {
+  createFetchMockHelpers: () => createFetchMockHelpers
+});
+module.exports = __toCommonJS(fetch_mock_exports);
+const defaultMockedValue = {
+  ok: true,
+  status: 200,
+  json: () => ({})
+};
+function createFetchMockHelpers(fn) {
+  const pristineFetch = global.fetch;
+  function setupFetchMock(mockedValue = {}) {
+    const merged = { ...defaultMockedValue, ...mockedValue };
+    const mockedFetchPromise = Promise.resolve(merged);
+    global.fetch = fn(
+      () => mockedFetchPromise
+    );
+  }
+  function clearFetchMock() {
+    global.fetch = pristineFetch;
+  }
+  return { setupFetchMock, clearFetchMock };
+}

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

@@ -0,0 +1,15 @@
+import { type PropsWithChildren, type ComponentType, type RefAttributes } from 'react';
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+interface FramerMotionActual {
+    isValidMotionProp: (key: string) => boolean;
+    cubicBezier: (mX1: number, mY1: number, mX2: number, mY2: number) => (t: number) => number;
+}
+type MotionComponentType = ComponentType<Record<string, unknown> & RefAttributes<unknown>>;
+export declare function buildFramerMotionMock(fn: MockFnCreator, actual: FramerMotionActual): {
+    motion: Record<string, MotionComponentType>;
+    AnimatePresence: ComponentType<PropsWithChildren>;
+    useReducedMotion: (value?: boolean) => boolean;
+    cubicBezier: (mX1: number, mY1: number, mX2: number, mY2: number) => (t: number) => number;
+};
+export {};
+//# sourceMappingURL=framer-motion-mock.d.ts.map

package/shared/mocks/framer-motion-mock.js

@@ -0,0 +1,70 @@
+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 framer_motion_mock_exports = {};
+__export(framer_motion_mock_exports, {
+  buildFramerMotionMock: () => buildFramerMotionMock
+});
+module.exports = __toCommonJS(framer_motion_mock_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+function buildFramerMotionMock(fn, actual) {
+  const MockedTransition = fn(
+    ({ children }) => children
+  );
+  const MockedAnimatePresence = fn(({ children }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MockedTransition, { children }));
+  function motionMock(Component, _customMotionComponentConfig = {}) {
+    const motion = {
+      div: (0, import_react.forwardRef)((props, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ...props, ref }))
+    };
+    return (0, import_react.forwardRef)(
+      (props, forwardedRef) => {
+        const componentProps = Object.fromEntries(
+          Object.entries(props).filter(
+            ([key]) => !actual.isValidMotionProp(key)
+          )
+        );
+        if (typeof Component === "string") {
+          const MotionComponent = motion[Component];
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            MotionComponent,
+            {
+              ...componentProps,
+              ref: forwardedRef
+            }
+          );
+        }
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          Component,
+          {
+            ref: forwardedRef,
+            ...componentProps
+          }
+        );
+      }
+    );
+  }
+  const motionProxy = new Proxy(motionMock, {
+    get: (_target, prop) => motionMock(prop)
+  });
+  return {
+    motion: motionProxy,
+    AnimatePresence: MockedAnimatePresence,
+    useReducedMotion: (value = true) => value,
+    cubicBezier: actual.cubicBezier
+  };
+}

package/shared/mocks/intersection-observer-mock.d.ts

@@ -0,0 +1,7 @@
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+export declare function createIntersectionObserverMockHelpers(fn: MockFnCreator): {
+    setupIntersectionObserverMock: (entries?: Partial<IntersectionObserverEntry>[]) => void;
+    clearIntersectionObserverMock: () => void;
+};
+export {};
+//# sourceMappingURL=intersection-observer-mock.d.ts.map

package/shared/mocks/intersection-observer-mock.js

@@ -0,0 +1,57 @@
+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 intersection_observer_mock_exports = {};
+__export(intersection_observer_mock_exports, {
+  createIntersectionObserverMockHelpers: () => createIntersectionObserverMockHelpers
+});
+module.exports = __toCommonJS(intersection_observer_mock_exports);
+function createIntersectionObserverMockHelpers(fn) {
+  const pristineIntersectionObserver = window.IntersectionObserver;
+  function setupIntersectionObserverMock(entries = [
+    {
+      isIntersecting: true,
+      intersectionRatio: 1
+    }
+  ]) {
+    class MockIntersectionObserver {
+      root = null;
+      rootMargin = "";
+      scrollMargin = "";
+      thresholds = [];
+      callback;
+      constructor(callback, _options) {
+        this.callback = callback;
+      }
+      disconnect = fn();
+      observe = fn(
+        () => this.callback(entries, this)
+      );
+      takeRecords = fn();
+      unobserve = fn();
+    }
+    Object.defineProperty(global, "IntersectionObserver", {
+      writable: true,
+      configurable: true,
+      value: MockIntersectionObserver
+    });
+  }
+  function clearIntersectionObserverMock() {
+    global.IntersectionObserver = pristineIntersectionObserver;
+  }
+  return { setupIntersectionObserverMock, clearIntersectionObserverMock };
+}

package/shared/mocks/match-media-mock.d.ts

@@ -0,0 +1,7 @@
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+export declare function createMatchMediaMockHelpers(fn: MockFnCreator): {
+    setupMatchMediaMock: (isMatching?: boolean) => void;
+    clearMatchMediaMock: () => void;
+};
+export {};
+//# sourceMappingURL=match-media-mock.d.ts.map

package/shared/mocks/match-media-mock.js

@@ -0,0 +1,46 @@
+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 match_media_mock_exports = {};
+__export(match_media_mock_exports, {
+  createMatchMediaMockHelpers: () => createMatchMediaMockHelpers
+});
+module.exports = __toCommonJS(match_media_mock_exports);
+function createMatchMediaMockHelpers(fn) {
+  const pristineMatchMedia = window.matchMedia;
+  function setupMatchMediaMock(isMatching = false) {
+    Object.defineProperty(window, "matchMedia", {
+      writable: true,
+      value: fn((query) => ({
+        matches: isMatching,
+        media: query,
+        onchange: null,
+        addListener: fn(),
+        // Deprecated
+        removeListener: fn(),
+        // Deprecated
+        addEventListener: fn(),
+        removeEventListener: fn(),
+        dispatchEvent: fn()
+      }))
+    });
+  }
+  function clearMatchMediaMock() {
+    window.matchMedia = pristineMatchMedia;
+  }
+  return { setupMatchMediaMock, clearMatchMediaMock };
+}

package/shared/mocks/resize-observer-mock.d.ts

@@ -0,0 +1,8 @@
+import { PartialDeep } from 'type-fest';
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+export declare function createResizeObserverMockHelpers(fn: MockFnCreator): {
+    setupResizeObserverMock: (mockedObserveCallbackValue?: PartialDeep<ResizeObserverEntry>[]) => void;
+    clearResizeObserverMock: () => void;
+};
+export {};
+//# sourceMappingURL=resize-observer-mock.d.ts.map

package/shared/mocks/resize-observer-mock.js

@@ -0,0 +1,43 @@
+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 resize_observer_mock_exports = {};
+__export(resize_observer_mock_exports, {
+  createResizeObserverMockHelpers: () => createResizeObserverMockHelpers
+});
+module.exports = __toCommonJS(resize_observer_mock_exports);
+function createResizeObserverMockHelpers(fn) {
+  const pristineResizeObserver = window.ResizeObserver;
+  function setupResizeObserverMock(mockedObserveCallbackValue) {
+    Object.defineProperty(window, "ResizeObserver", {
+      writable: true,
+      value: fn(function(callback) {
+        return {
+          observe: mockedObserveCallbackValue ? fn(() => {
+            callback(mockedObserveCallbackValue);
+          }) : fn(),
+          unobserve: fn(),
+          disconnect: fn()
+        };
+      })
+    });
+  }
+  function clearResizeObserverMock() {
+    window.ResizeObserver = pristineResizeObserver;
+  }
+  return { setupResizeObserverMock, clearResizeObserverMock };
+}

package/shared/mocks/scroll-into-view-mock.d.ts

@@ -0,0 +1,7 @@
+type MockFnCreator = <TArgs extends unknown[], TReturn>(impl?: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
+export declare function createScrollIntoViewMockHelpers(fn: MockFnCreator): {
+    setupScrollIntoViewMock: () => void;
+    clearScrollIntoViewMock: () => void;
+};
+export {};
+//# sourceMappingURL=scroll-into-view-mock.d.ts.map

package/shared/mocks/scroll-into-view-mock.js

@@ -0,0 +1,35 @@
+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 scroll_into_view_mock_exports = {};
+__export(scroll_into_view_mock_exports, {
+  createScrollIntoViewMockHelpers: () => createScrollIntoViewMockHelpers
+});
+module.exports = __toCommonJS(scroll_into_view_mock_exports);
+function createScrollIntoViewMockHelpers(fn) {
+  const pristineScrollIntoView = window.HTMLElement.prototype.scrollIntoView;
+  function setupScrollIntoViewMock() {
+    Object.defineProperty(HTMLElement.prototype, "scrollIntoView", {
+      writable: true,
+      value: fn()
+    });
+  }
+  function clearScrollIntoViewMock() {
+    window.HTMLElement.prototype.scrollIntoView = pristineScrollIntoView;
+  }
+  return { setupScrollIntoViewMock, clearScrollIntoViewMock };
+}

package/shared/testing-helpers/filters/filter-field.d.ts

@@ -0,0 +1,128 @@
+import { type Options, UserEvent } from '@testing-library/user-event';
+/** @internal */
+export interface _FilterFieldDeps {
+    isFakeTimersEnabled: () => boolean;
+    runOnlyPendingTimers: () => void;
+    setupUserEvent: (options?: Options) => UserEvent;
+}
+/**
+ * Base class for pinned or recent filter field suggestion.
+ * @public */
+export declare class FilterFieldPinnedAndRecentSuggestionBase {
+    readonly suggestionRoot: HTMLDivElement;
+    private readonly _deps;
+    /** @internal */
+    constructor(suggestionRoot: HTMLDivElement, deps: _FilterFieldDeps);
+    get pinButtonElement(): HTMLButtonElement | null;
+    /**
+     * Receives the value of the suggestion that would be applied.
+     */
+    get value(): string | null;
+    /**
+     * Returns if the current suggestion is currently pinned or not.
+     */
+    get pinned(): boolean;
+    /**
+     * Applies the suggestion to the filter field.
+     */
+    apply(): Promise<void>;
+    get pinEnabled(): boolean;
+    /**
+     * Allows the suggestion to be pinned if not pinned already.
+     */
+    pin(): Promise<void>;
+    /**
+     * Allows the suggestion to be unpinned if not unpinned already.
+     */
+    unpin(): Promise<void>;
+}
+/**
+ * Testing helper class for pinned suggestions in the filter field
+ * @public */
+export declare class FilterFieldPinnedSuggestion extends FilterFieldPinnedAndRecentSuggestionBase {
+    /**
+     * Receives the value of the suggestion that would be applied.
+     */
+    get value(): string | null;
+}
+/**
+ * Testing helper class for recent suggestions in the filter field
+ * @public */
+export declare class FilterFieldRecentSuggestion extends FilterFieldPinnedAndRecentSuggestionBase {
+    /**
+     * Receives the value of the suggestion that would be applied.
+     */
+    get value(): string | null;
+    /**
+     * Receives time offset indicating when the filter statement has last been used.
+     */
+    get lastUsed(): string | null;
+}
+/**
+ * Helper class for interacting with the filter field.
+ * @public
+ */
+export declare class FilterFieldHelper {
+    readonly dataTestId: string;
+    private readonly _deps;
+    get filterFieldWrapper(): HTMLElement;
+    get editorView(): {
+        dispatch: (spec: {
+            selection: {
+                anchor: number;
+            };
+        }) => void;
+        state: {
+            doc: {
+                length: number;
+            };
+        };
+    } | undefined;
+    get inputElement(): HTMLInputElement;
+    get filterFieldElement(): HTMLDivElement;
+    get placeholderElement(): HTMLSpanElement | null;
+    get suggestionsContainer(): HTMLDivElement | null;
+    /** @internal */
+    constructor(dataTestId: string, deps: _FilterFieldDeps);
+    /** Returns the value of the native text input. */
+    get value(): string;
+    /** Returns the value of the filter field. */
+    get filterFieldValue(): string;
+    /**
+     * The placeholder text shown in the filter field.
+     * Undefined if the placeholder is currently not rendered.
+     */
+    get placeholder(): string | undefined;
+    /** Focus the filter field if not already focused. */
+    focus(): Promise<void>;
+    /** Blur the filter field by tabbing out of it. */
+    blur(): Promise<void>;
+    /** Fill a provided value into the filter field. */
+    type(text: string, cursorIndex?: number): Promise<void>;
+    /** Clears the filter field value. */
+    clear(): Promise<void>;
+    /**
+     * Moves the cursor to the given index.
+     * -1 moves to the end of the input.
+     */
+    moveCursorTo(index: number): Promise<void>;
+    /** Open the suggestions overlay with the keyboard shortcut. */
+    openSuggestions(): Promise<void>;
+    /**
+     * Close the suggestions overlay using the `Escape` key.
+     * If the filter field is focused, the focus will stay in the filter field.
+     */
+    closeSuggestions(): Promise<void>;
+    /** Apply the suggestion with the given text. */
+    applySuggestion(queryString: string): Promise<void>;
+    /** Get recent suggestions */
+    getRecentSuggestions(): Promise<FilterFieldRecentSuggestion[]>;
+    /** Get pinned suggestions */
+    getPinnedSuggestions(): Promise<FilterFieldPinnedSuggestion[]>;
+    /** Paste text at the current cursor position */
+    paste(text: string, cursorIndex?: number): Promise<void>;
+}
+export declare function createFilterFieldHelpers(deps: _FilterFieldDeps): {
+    getFilterFieldHelper: (dataTestId: string) => FilterFieldHelper;
+};
+//# sourceMappingURL=filter-field.d.ts.map