@gooddata/sdk-ui-filters 11.54.0-alpha.3 → 11.54.0-alpha.5

package/esm/AttributeFilterHandler/fixtures.d.ts

@@ -0,0 +1,34 @@
+import { type ElementsQueryOptionsElementsSpecification, type IElementsQueryAttributeFilter } from "@gooddata/sdk-backend-spi";
+import { type IAttributeElement, type IAttributeFilter, type IMeasure, type IRelativeDateFilter } from "@gooddata/sdk-model";
+export declare const particularAttributeElements: ElementsQueryOptionsElementsSpecification;
+export declare const anotherParticularAttributeElements: ElementsQueryOptionsElementsSpecification;
+export declare const limitingAttributeFilters: IElementsQueryAttributeFilter[];
+export declare const limitingMeasures: IMeasure[];
+export declare const limitingDateFilters: IRelativeDateFilter[];
+export declare const staticElements: IAttributeElement[];
+export declare const hiddenElements: string[];
+export declare const newTestAttributeFilterHandler: (useCase: "hidden" | "negative" | "nonExisting" | "positive" | "static") => import("./types/attributeFilterHandler.js").IMultiSelectAttributeFilterHandler;
+export declare const positiveAttributeFilterDefaultDF: import("@gooddata/sdk-model").IPositiveAttributeFilter;
+export declare const emptyPositiveAttributeFilterDefaultDF: import("@gooddata/sdk-model").IPositiveAttributeFilter;
+export declare const negativeAttributeFilterDefaultDF: import("@gooddata/sdk-model").INegativeAttributeFilter;
+export declare const newTestAttributeFilterHandlerWithAttributeFilter: (attributeFilter: IAttributeFilter, advancedOptions?: {
+    staticElements?: IAttributeElement[] | undefined;
+    hiddenElements?: string[] | undefined;
+} | undefined) => import("./types/attributeFilterHandler.js").IMultiSelectAttributeFilterHandler;
+/**
+ * Handler whose elements loads can be made to fail on demand.
+ *
+ * The failure is injected into the backend the handler talks to, so that the tests of the error
+ * paths do not have to mock the internal loadElements module. A module mock cannot be relied on
+ * here, because the test files share the module registry (see `isolate: false` in vitest.config.ts)
+ * and the module is already evaluated unmocked by the time such a suite runs.
+ */
+export declare const newTestAttributeFilterHandlerWithElementsLoadFailures: (attributeFilter: IAttributeFilter) => {
+    attributeFilterHandler: import("./types/attributeFilterHandler.js").IMultiSelectAttributeFilterHandler;
+    /**
+     * Makes the next elements load reject with the provided error. Call it repeatedly to queue up
+     * more failures, one per load - the equivalent of several mockRejectedValueOnce() calls.
+     */
+    failNextElementsLoad: (error: unknown) => void;
+};
+//# sourceMappingURL=fixtures.d.ts.map

package/esm/AttributeFilterHandler/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/AttributeFilterHandler/fixtures.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,yCAAyC,EAG9C,KAAK,6BAA6B,EACrC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAQ3B,MAAM,qBAAqB,CAAC;AAI7B,eAAO,MAAM,2BAA2B,EAAE,yCAEzC,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,yCAEhD,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,6BAA6B,EAOnE,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,EAAyB,CAAC;AAEjE,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,EAEpD,CAAC;AAyDF,eAAO,MAAM,cAAc,qBAKpB,CAAC;AAIR,eAAO,MAAM,cAAc,UAAsB,CAAC;AAElD,eAAO,MAAM,6BAA6B,4JAuBzC,CAAC;AAEF,eAAO,MAAM,gCAAgC,wDAE3C,CAAC;AAEH,eAAO,MAAM,qCAAqC,wDAEhD,CAAC;AAEH,eAAO,MAAM,gCAAgC,wDAE3C,CAAC;AAEH,eAAO,MAAM,gDAAgD;;;gGAU5D,CAAC;AA2EF;;;;;;;GAOG;AACH,eAAO,MAAM,qDAAqD;;IAU1D;;;OAGG;;CAKV,CAAC"}

package/esm/AttributeFilterHandler/fixtures.js

@@ -0,0 +1,184 @@
+// (C) 2019-2026 GoodData Corporation
+import { ReferenceMd, ReferenceRecordings } from "@gooddata/reference-workspace";
+import { recordedBackend } from "@gooddata/sdk-backend-mockingbird";
+import { attributeIdentifier, idRef, measureIdentifier, newNegativeAttributeFilter, newPositiveAttributeFilter, newRelativeDateFilter, } from "@gooddata/sdk-model";
+import { newAttributeFilterHandler } from "./factory.js";
+export const particularAttributeElements = {
+    values: ["TouchAll", "WonderKid"],
+};
+export const anotherParticularAttributeElements = {
+    values: ["PhoenixSoft"],
+};
+export const limitingAttributeFilters = [
+    {
+        attributeFilter: newPositiveAttributeFilter(ReferenceMd.Product.Name, {
+            uris: ["460488"],
+        }),
+        overAttribute: idRef("attr.opportunitysnapshot.id"),
+    },
+];
+export const limitingMeasures = [ReferenceMd.Amount];
+export const limitingDateFilters = [
+    newRelativeDateFilter(ReferenceMd.DateDatasets.Snapshot.SnapshotDate.identifier, "GDC.time.date", 0, -1),
+];
+const productNameAttrId = attributeIdentifier(ReferenceMd.Product.Name);
+const amountMeasureId = measureIdentifier(ReferenceMd.Amount);
+const snapshotDateId = ReferenceMd.DateDatasets.Snapshot.SnapshotDate.identifier;
+const productDefaultId = attributeIdentifier(ReferenceMd.Product.Default);
+const backend = recordedBackend(ReferenceRecordings.Recordings, {
+    attributeElementsFiltering: {
+        attributeFilters: {
+            [productNameAttrId]: (_element, index) => {
+                return (index + 1) % 2 === 0;
+            },
+            [productDefaultId]: (_element, index) => {
+                return (index + 1) % 2 === 0;
+            },
+        },
+        measures: {
+            [amountMeasureId]: (_element, index) => {
+                return (index + 1) % 3 === 0;
+            },
+        },
+        dateFilters: {
+            [snapshotDateId]: (_element, index) => {
+                return (index + 1) % 4 === 0;
+            },
+        },
+    },
+});
+const workspace = "testWorkspace";
+const positiveAttributeFilter = newPositiveAttributeFilter(ReferenceMd.Product.Name, {
+    uris: ["165678", "165847"],
+});
+const emptyPositiveAttributeFilter = newPositiveAttributeFilter(ReferenceMd.Product.Name, {
+    uris: [],
+});
+const negativeAttributeFilter = newNegativeAttributeFilter(ReferenceMd.Product.Name, {
+    uris: ["165678", "165847"],
+});
+const nonExistingAttributeFilter = newPositiveAttributeFilter("non-existing-displayForm", {
+    uris: [],
+});
+const createDummyElements = (createElement, size) => new Array(size).fill(null).reduce((result, _, index) => {
+    result.push(createElement(index));
+    return result;
+}, []);
+export const staticElements = createDummyElements((index) => {
+    return {
+        title: `Element ${index}`,
+        uri: `/element?id=${index}`,
+    };
+}, 100);
+// This actually does not filter elements in mockingbirg
+// It just triggers usage of the attributeElementsFiltering
+export const hiddenElements = ["/hidden-element"];
+export const newTestAttributeFilterHandler = (useCase) => {
+    let filter = positiveAttributeFilter;
+    const options = {
+        selectionMode: "multi",
+    };
+    if (useCase === "positive") {
+        filter = positiveAttributeFilter;
+    }
+    else if (useCase === "negative") {
+        filter = negativeAttributeFilter;
+    }
+    else if (useCase === "nonExisting") {
+        filter = nonExistingAttributeFilter;
+    }
+    else if (useCase === "static") {
+        filter = emptyPositiveAttributeFilter;
+        options.staticElements = staticElements;
+    }
+    else if (useCase === "hidden") {
+        filter = positiveAttributeFilter;
+        options.hiddenElements = hiddenElements;
+    }
+    return newAttributeFilterHandler(backend, workspace, filter, options);
+};
+export const positiveAttributeFilterDefaultDF = newPositiveAttributeFilter(ReferenceMd.Product.Default, {
+    uris: ["165678", "165847"],
+});
+export const emptyPositiveAttributeFilterDefaultDF = newPositiveAttributeFilter(ReferenceMd.Product.Default, {
+    uris: [],
+});
+export const negativeAttributeFilterDefaultDF = newNegativeAttributeFilter(ReferenceMd.Product.Default, {
+    uris: ["165678", "165847"],
+});
+export const newTestAttributeFilterHandlerWithAttributeFilter = (attributeFilter, advancedOptions) => {
+    const options = {
+        selectionMode: "multi",
+        ...(advancedOptions ?? {}),
+    };
+    return newAttributeFilterHandler(backend, workspace, attributeFilter, options);
+};
+const isFunction = (value) => typeof value === "function";
+const isElementsQuery = (value) => typeof value === "object" && value !== null && isFunction(value.query);
+/**
+ * Facade of `target` with a single method replaced.
+ *
+ * A proxy is used instead of an object spread, because the backend services are class instances -
+ * their methods live on the prototype and a spread would drop them.
+ */
+const withReplacedMethod = (target, method, replacement) => new Proxy(target, {
+    get(proxiedTarget, property) {
+        if (property === method) {
+            return replacement;
+        }
+        const value = Reflect.get(proxiedTarget, property, proxiedTarget);
+        return isFunction(value) ? value.bind(proxiedTarget) : value;
+    },
+});
+/**
+ * Elements query that rejects with the queued errors, one error per query() call, and delegates to
+ * the recorded implementation once the queue is empty.
+ */
+const withQueuedElementsLoadFailures = (elementsQuery, errors) => new Proxy(elementsQuery, {
+    get(proxiedTarget, property) {
+        const value = Reflect.get(proxiedTarget, property, proxiedTarget);
+        if (!isFunction(value)) {
+            return value;
+        }
+        if (property === "query") {
+            return (...args) => errors.length > 0 ? Promise.reject(errors.shift()) : value.apply(proxiedTarget, args);
+        }
+        return (...args) => {
+            const result = value.apply(proxiedTarget, args);
+            // The builder methods return the query itself, so the result has to be wrapped again
+            // to keep the interception in place for the rest of the chain.
+            return isElementsQuery(result) ? withQueuedElementsLoadFailures(result, errors) : result;
+        };
+    },
+});
+const backendWithQueuedElementsLoadFailures = (errors) => withReplacedMethod(backend, "workspace", (workspaceId) => {
+    const analyticalWorkspace = backend.workspace(workspaceId);
+    return withReplacedMethod(analyticalWorkspace, "attributes", () => {
+        const attributes = analyticalWorkspace.attributes();
+        return withReplacedMethod(attributes, "elements", () => {
+            const elements = attributes.elements();
+            return withReplacedMethod(elements, "forDisplayForm", (ref) => withQueuedElementsLoadFailures(elements.forDisplayForm(ref), errors));
+        });
+    });
+});
+/**
+ * Handler whose elements loads can be made to fail on demand.
+ *
+ * The failure is injected into the backend the handler talks to, so that the tests of the error
+ * paths do not have to mock the internal loadElements module. A module mock cannot be relied on
+ * here, because the test files share the module registry (see `isolate: false` in vitest.config.ts)
+ * and the module is already evaluated unmocked by the time such a suite runs.
+ */
+export const newTestAttributeFilterHandlerWithElementsLoadFailures = (attributeFilter) => {
+    const errors = [];
+    return {
+        attributeFilterHandler: newAttributeFilterHandler(backendWithQueuedElementsLoadFailures(errors), workspace, attributeFilter, { selectionMode: "multi" }),
+        /**
+         * Makes the next elements load reject with the provided error. Call it repeatedly to queue up
+         * more failures, one per load - the equivalent of several mockRejectedValueOnce() calls.
+         */
+        failNextElementsLoad: (error) => {
+            errors.push(error);
+        },
+    };
+};

package/esm/AttributeFilterHandler/testUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const waitForAsync: () => Promise<any>;
+//# sourceMappingURL=testUtils.d.ts.map

package/esm/AttributeFilterHandler/testUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../src/AttributeFilterHandler/testUtils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,oBAAmF,CAAC"}

package/esm/AttributeFilterHandler/testUtils.js

@@ -0,0 +1,2 @@
+// (C) 2019-2026 GoodData Corporation
+export const waitForAsync = () => new Promise((resolve) => setTimeout(resolve, 0));

package/esm/DateFilter/AbsoluteForm.d.ts

@@ -0,0 +1,15 @@
+export declare class AbsoluteForm {
+    setStartDate: (value: string) => void;
+    submitStartDateWithEnter: (value: string) => void;
+    setEndDate: (value: string) => void;
+    submitEndDateWithEnter: (value: string) => void;
+    setStartTime: (value: string) => void;
+    setEndTime: (value: string) => void;
+    getStartDate: () => string;
+    getEndDate: () => string;
+    getStartTime: () => string;
+    getEndTime: () => string;
+    isVisible: () => boolean;
+    isErrorVisible: () => boolean;
+}
+//# sourceMappingURL=AbsoluteForm.d.ts.map

package/esm/DateFilter/AbsoluteForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbsoluteForm.d.ts","sourceRoot":"","sources":["../../src/DateFilter/AbsoluteForm.tsx"],"names":[],"mappings":"AAWA,qBAAa,YAAY;IACd,YAAY,0BAIjB;IAEK,wBAAwB,0BAI7B;IAEK,UAAU,0BAIf;IAEK,sBAAsB,0BAI3B;IAEK,YAAY,0BAIjB;IAEK,UAAU,0BAIf;IAEK,YAAY,eAGjB;IAEK,UAAU,eAGf;IAEK,YAAY,eAGjB;IAEK,UAAU,eAGf;IAEK,SAAS,gBAA+C;IAExD,cAAc,gBAAyC;CACjE"}

package/esm/DateFilter/AbsoluteForm.js

@@ -0,0 +1,58 @@
+// (C) 2022-2026 GoodData Corporation
+import { fireEvent } from "@testing-library/react";
+const rangePicker = ".s-date-range-picker";
+const error = ".s-absolute-range-error";
+const startDateInput = ".s-date-range-picker-from .s-date-range-picker-input-field";
+const endDateInput = ".s-date-range-picker-to .s-date-range-picker-input-field";
+const startTimeInput = ".s-date-range-picker-from .s-date-range-picker-input-time .input-text";
+const endTimeInput = ".s-date-range-picker-to .s-date-range-picker-input-time .input-text";
+export class AbsoluteForm {
+    setStartDate = (value) => {
+        const input = document.querySelector(startDateInput);
+        fireEvent.change(input, { target: { value } });
+        fireEvent.blur(input);
+    };
+    submitStartDateWithEnter = (value) => {
+        const input = document.querySelector(startDateInput);
+        fireEvent.change(input, { target: { value } });
+        fireEvent.keyDown(input, { key: "Enter" });
+    };
+    setEndDate = (value) => {
+        const input = document.querySelector(endDateInput);
+        fireEvent.change(input, { target: { value } });
+        fireEvent.blur(input);
+    };
+    submitEndDateWithEnter = (value) => {
+        const input = document.querySelector(endDateInput);
+        fireEvent.change(input, { target: { value } });
+        fireEvent.keyDown(input, { key: "Enter" });
+    };
+    setStartTime = (value) => {
+        const input = document.querySelector(startTimeInput);
+        fireEvent.change(input, { target: { value } });
+        fireEvent.blur(input);
+    };
+    setEndTime = (value) => {
+        const input = document.querySelector(endTimeInput);
+        fireEvent.change(input, { target: { value } });
+        fireEvent.blur(input);
+    };
+    getStartDate = () => {
+        const input = document.querySelector(startDateInput);
+        return input.value;
+    };
+    getEndDate = () => {
+        const input = document.querySelector(endDateInput);
+        return input.value;
+    };
+    getStartTime = () => {
+        const input = document.querySelector(startTimeInput);
+        return input.value;
+    };
+    getEndTime = () => {
+        const input = document.querySelector(endTimeInput);
+        return input.value;
+    };
+    isVisible = () => !!document.querySelector(rangePicker);
+    isErrorVisible = () => !!document.querySelector(error);
+}

package/esm/DateFilter/DateRangePicker/IntlDecorators.d.ts

@@ -0,0 +1,3 @@
+import { type ReactElement } from "react";
+export declare function IntlDecorator(components: ReactElement, locale?: string): ReactElement;
+//# sourceMappingURL=IntlDecorators.d.ts.map

package/esm/DateFilter/DateRangePicker/IntlDecorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntlDecorators.d.ts","sourceRoot":"","sources":["../../../src/DateFilter/DateRangePicker/IntlDecorators.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAI1C,wBAAgB,aAAa,CAAC,UAAU,EAAE,YAAY,EAAE,MAAM,GAAE,MAAgB,GAAG,YAAY,CAE9F"}

package/esm/DateFilter/DateRangePicker/IntlDecorators.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { IntlWrapper } from "@gooddata/sdk-ui";
+export function IntlDecorator(components, locale = "en-US") {
+    return _jsx(IntlWrapper, { locale: locale, children: components });
+}

package/esm/DateFilter/extendedDateFilters.test.helpers.d.ts

@@ -0,0 +1,45 @@
+import { type RenderResult } from "@testing-library/react";
+import { type IDateFilterProps } from "./DateFilter.js";
+import { type DateFilterOption, type IDateFilterOptionsByType } from "./interfaces/index.js";
+export declare const defaultDateFilterOptions: IDateFilterOptionsByType;
+export declare const createDateFilter: (customProps?: Partial<IDateFilterProps>) => RenderResult;
+/**
+ * Use this component renderer if you need to check some state changes regarding apply handler
+ */
+export declare const createDateFilterWithState: (customProps?: Partial<IDateFilterProps>) => RenderResult;
+export declare function DateFilterWithState(customProps?: Partial<IDateFilterProps>): import("react/jsx-runtime").JSX.Element;
+export declare const clickDateFilterButton: () => boolean;
+export declare const clickApplyButton: () => boolean;
+export declare const isApplyButtonDisabled: () => boolean;
+export declare const clickCancelButton: () => boolean;
+export declare const getDateFilterButtonText: () => string;
+export declare const clickConfigurationButton: () => boolean;
+export declare const getFilterTitle: () => string;
+export declare const isDateFilterBodyVisible: () => boolean;
+export declare const isDateFilterVisible: () => boolean;
+export declare const getSelectedItemText: () => string;
+export declare const isConfigurationButtonVisible: () => boolean;
+export declare const getPresetByItem: (item: string, relativePreset: DateFilterOption[]) => DateFilterOption | undefined;
+export declare const clickAllTime: () => boolean;
+export declare const clickStaticFilter: (filter: string) => void;
+export declare const getAllStaticItemsLabels: () => string[];
+export declare const clickAbsoluteFilter: (filter: string) => void;
+export declare const clickAbsoluteFormFilter: () => boolean;
+export declare const openAbsoluteFormFilter: () => void;
+export declare const dateToAbsoluteInputFormat: (dateString: string, dateFormat?: string) => string;
+export declare const getTodayDate: (dateFormat?: string) => string;
+export declare const getMonthAgo: (dateFormat?: string) => string;
+export declare const clickRelativeFormFilter: () => void;
+export declare const openRelativeFormFilter: () => void;
+export declare const getRelativeFormInputFromValue: () => string;
+export declare const getRelativeFormInputToValue: () => string;
+export declare const setRelativeFormInputs: (from: string, to: string) => void;
+export declare const clickRelativeFormGranularity: (granularity: string) => void;
+export declare const isRelativeFormGranularitySelected: (granularity: string) => boolean;
+export declare const isRelativeFormVisible: () => boolean;
+export declare const isRelativeFormSelectMenuVisible: () => boolean;
+export declare const queryExcludeCurrentPeriodCheckbox: () => HTMLInputElement | null;
+export declare const getExcludeCurrentPeriodCheckbox: () => HTMLInputElement;
+export declare const clickExcludeCurrentPeriodCheckBox: () => void;
+export declare const isExcludeCurrentPeriodChecked: () => boolean;
+//# sourceMappingURL=extendedDateFilters.test.helpers.d.ts.map

package/esm/DateFilter/extendedDateFilters.test.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extendedDateFilters.test.helpers.d.ts","sourceRoot":"","sources":["../../src/DateFilter/extendedDateFilters.test.helpers.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAA6B,MAAM,wBAAwB,CAAC;AAOtF,OAAO,EAAc,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAE7F,eAAO,MAAM,wBAAwB,EAAE,wBAuJtC,CAAC;AAgDF,eAAO,MAAM,gBAAgB,2DAI5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,2DAIrC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,WAAW,GAAE,OAAO,CAAC,gBAAgB,CAAM,2CAsB9E;AAID,eAAO,MAAM,qBAAqB,eAAmE,CAAC;AAItG,eAAO,MAAM,gBAAgB,eAA0C,CAAC;AAExE,eAAO,MAAM,qBAAqB,eAAuE,CAAC;AAE1G,eAAO,MAAM,iBAAiB,eAAoD,CAAC;AAEnF,eAAO,MAAM,uBAAuB,cAAkE,CAAC;AAEvG,eAAO,MAAM,wBAAwB,eAAsE,CAAC;AAI5G,eAAO,MAAM,cAAc,cAAmE,CAAC;AAE/F,eAAO,MAAM,uBAAuB,eAAiD,CAAC;AAEtF,eAAO,MAAM,mBAAmB,eAAmD,CAAC;AAEpF,eAAO,MAAM,mBAAmB,cAAoE,CAAC;AAErG,eAAO,MAAM,4BAA4B,eAAsD,CAAC;AAQhG,eAAO,MAAM,eAAe,oFAK3B,CAAC;AAUF,eAAO,MAAM,YAAY,eAAgE,CAAC;AAE1F,eAAO,MAAM,iBAAiB,0BAG7B,CAAC;AAEF,eAAO,MAAM,uBAAuB,gBAMnC,CAAC;AAGF,eAAO,MAAM,mBAAmB,0BAG/B,CAAC;AAGF,eAAO,MAAM,uBAAuB,eAAqE,CAAC;AAE1G,eAAO,MAAM,sBAAsB,YAGlC,CAAC;AAEF,eAAO,MAAM,yBAAyB,qDAErC,CAAC;AAEF,eAAO,MAAM,YAAY,iCAExB,CAAC;AAEF,eAAO,MAAM,WAAW,iCAOvB,CAAC;AAGF,eAAO,MAAM,uBAAuB,YAEnC,CAAC;AAEF,eAAO,MAAM,sBAAsB,YAGlC,CAAC;AAEF,eAAO,MAAM,6BAA6B,cACmC,CAAC;AAE9E,eAAO,MAAM,2BAA2B,cACmC,CAAC;AAE5E,eAAO,MAAM,qBAAqB,oCAKjC,CAAC;AAkBF,eAAO,MAAM,4BAA4B,+BAGxC,CAAC;AAEF,eAAO,MAAM,iCAAiC,kCAG7C,CAAC;AAEF,eAAO,MAAM,qBAAqB,eAAqD,CAAC;AAExF,eAAO,MAAM,+BAA+B,eAAyD,CAAC;AAItG,eAAO,MAAM,iCAAiC,+BACU,CAAC;AAEzD,eAAO,MAAM,+BAA+B,wBAA+D,CAAC;AAE5G,eAAO,MAAM,iCAAiC,YAE7C,CAAC;AAEF,eAAO,MAAM,6BAA6B,eAAkD,CAAC"}

package/esm/DateFilter/extendedDateFilters.test.helpers.js

@@ -0,0 +1,327 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useState } from "react";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { add, formatDate } from "date-fns";
+import moment from "moment";
+import { platformDateFormat } from "./constants/Platform.js";
+import { DateFilter } from "./DateFilter.js";
+export const defaultDateFilterOptions = {
+    allTime: {
+        localIdentifier: "ALL_TIME",
+        type: "allTime",
+        name: "",
+        visible: true,
+    },
+    absoluteForm: {
+        localIdentifier: "ABSOLUTE_FORM",
+        type: "absoluteForm",
+        from: moment().subtract(1, "month").startOf("day").format(platformDateFormat),
+        to: moment().startOf("day").format(platformDateFormat),
+        name: "",
+        visible: true,
+    },
+    absolutePreset: [
+        {
+            from: "2019-12-24",
+            to: "2019-12-26",
+            name: "Christmas 2019",
+            localIdentifier: "CHRISTMAS_2019",
+            visible: true,
+            type: "absolutePreset",
+        },
+        {
+            from: "2018-01-01",
+            to: "2018-12-31",
+            name: "Year 2018",
+            localIdentifier: "YEAR_2018",
+            visible: true,
+            type: "absolutePreset",
+        },
+    ],
+    relativeForm: {
+        localIdentifier: "RELATIVE_FORM",
+        type: "relativeForm",
+        granularity: "GDC.time.month",
+        from: undefined,
+        to: undefined,
+        name: "",
+        visible: true,
+    },
+    relativePreset: {
+        "GDC.time.date": [
+            {
+                from: -6,
+                to: 0,
+                granularity: "GDC.time.date",
+                localIdentifier: "LAST_7_DAYS",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -29,
+                to: 0,
+                granularity: "GDC.time.date",
+                localIdentifier: "LAST_30_DAYS",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -89,
+                to: 0,
+                granularity: "GDC.time.date",
+                localIdentifier: "LAST_90_DAYS",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+        ],
+        "GDC.time.month": [
+            {
+                from: 0,
+                to: 0,
+                granularity: "GDC.time.month",
+                localIdentifier: "THIS_MONTH",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -1,
+                to: -1,
+                granularity: "GDC.time.month",
+                localIdentifier: "LAST_MONTH",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -11,
+                to: 0,
+                granularity: "GDC.time.month",
+                localIdentifier: "LAST_12_MONTHS",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+        ],
+        "GDC.time.quarter": [
+            {
+                from: 0,
+                to: 0,
+                granularity: "GDC.time.quarter",
+                localIdentifier: "THIS_QUARTER",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -1,
+                to: -1,
+                granularity: "GDC.time.quarter",
+                localIdentifier: "LAST_QUARTER",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -3,
+                to: 0,
+                granularity: "GDC.time.quarter",
+                localIdentifier: "LAST_4_QUARTERS",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+        ],
+        "GDC.time.year": [
+            {
+                from: 0,
+                to: 0,
+                granularity: "GDC.time.year",
+                localIdentifier: "THIS_YEAR",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+            {
+                from: -1,
+                to: -1,
+                granularity: "GDC.time.year",
+                localIdentifier: "LAST_YEAR",
+                type: "relativePreset",
+                visible: true,
+                name: "",
+            },
+        ],
+    },
+};
+const availableGranularities = [
+    "GDC.time.month",
+    "GDC.time.year",
+    "GDC.time.quarter",
+    "GDC.time.date",
+    "GDC.time.hour",
+    "GDC.time.minute",
+];
+const defaultProps = {
+    excludeCurrentPeriod: false,
+    selectedFilterOption: defaultDateFilterOptions.allTime,
+    filterOptions: defaultDateFilterOptions,
+    availableGranularities,
+    isEditMode: false,
+    customFilterName: "Filter name",
+    dateFilterMode: "active",
+    onApply: () => { },
+    onCancel: () => { },
+    onOpen: () => { },
+    onClose: () => { },
+};
+const configurationButton = ".s-configuration-button";
+const dateFilterButton = ".s-date-filter-button";
+const dateButtonFilterTitle = ".s-date-filter-title";
+const dateFilterButtonText = ".s-button-text";
+const dateFilterSelectedItem = ".gd-list-item.is-selected";
+const dateFilterBody = ".s-extended-date-filters-body";
+const excludeCurrentPeriodCheckbox = ".s-exclude-current-period input";
+const allTimeButton = "button.s-all-time";
+const absoluteFormButton = "button.s-absolute-form-button";
+const relativeFormButton = "button.s-relative-form-button";
+const relativeFormPicker = ".s-relative-range-picker";
+const relativeFormSelectMenu = ".s-select-menu";
+const relativeFormInputFrom = ".s-relative-range-picker-from input";
+const relativeFormInputTo = ".s-relative-range-picker-to input";
+const relativeFormGranularityTab = (intlGranularity) => `.gd-tab.s-granularity-${intlGranularity}`;
+const defaultDateFormat = "MM/dd/yyyy";
+export const createDateFilter = (customProps = {}) => {
+    const props = { ...defaultProps, ...customProps };
+    return render(_jsx(DateFilter, { ...props }));
+};
+/**
+ * Use this component renderer if you need to check some state changes regarding apply handler
+ */
+export const createDateFilterWithState = (customProps = {}) => {
+    const props = { ...defaultProps, ...customProps };
+    return render(_jsx(DateFilterWithState, { ...props }));
+};
+export function DateFilterWithState(customProps = {}) {
+    const [selectedFilterOption, setSelectedFilterOption] = useState(customProps.selectedFilterOption ?? defaultProps.selectedFilterOption);
+    const [excludeCurrentPeriod, setExcludeCurrentPeriod] = useState(customProps.excludeCurrentPeriod ?? defaultProps.excludeCurrentPeriod);
+    const handleApply = (selectedFilterOption, excludeCurrentPeriod) => {
+        setSelectedFilterOption(selectedFilterOption);
+        setExcludeCurrentPeriod(excludeCurrentPeriod);
+        customProps.onApply?.(selectedFilterOption, excludeCurrentPeriod);
+    };
+    return (_jsx(DateFilter, { ...defaultProps, ...customProps, selectedFilterOption: selectedFilterOption, excludeCurrentPeriod: excludeCurrentPeriod, onApply: handleApply }));
+}
+// common methods
+export const clickDateFilterButton = () => fireEvent.click(document.querySelector(dateFilterButton));
+const getApplyButton = () => screen.getByText("Apply");
+export const clickApplyButton = () => fireEvent.click(getApplyButton());
+export const isApplyButtonDisabled = () => getApplyButton().parentElement.classList.contains("disabled");
+export const clickCancelButton = () => fireEvent.click(screen.getByText("Cancel"));
+export const getDateFilterButtonText = () => document.querySelector(dateFilterButtonText).textContent;
+export const clickConfigurationButton = () => fireEvent.click(document.querySelector(configurationButton));
+// config
+export const getFilterTitle = () => document.querySelector(dateButtonFilterTitle).textContent;
+export const isDateFilterBodyVisible = () => !!document.querySelector(dateFilterBody);
+export const isDateFilterVisible = () => !!document.querySelector(dateFilterButton);
+export const getSelectedItemText = () => document.querySelector(dateFilterSelectedItem).textContent;
+export const isConfigurationButtonVisible = () => !!document.querySelector(configurationButton);
+// relative presets
+const getLocalIdentifierFromItem = (item) => {
+    return item.toUpperCase().replace(/-/g, "_");
+};
+export const getPresetByItem = (item, relativePreset) => {
+    const localIdentifier = getLocalIdentifierFromItem(item);
+    return relativePreset.find((x) => {
+        return x.localIdentifier === localIdentifier.toUpperCase();
+    });
+};
+const getStaticFilterSelectorClass = (filter) => {
+    return `button.s-relative-preset-${filter}`;
+};
+const getAbsoluteFilterSelectorClass = (filter) => {
+    return `button.s-absolute-preset-${filter}`;
+};
+export const clickAllTime = () => fireEvent.click(document.querySelector(allTimeButton));
+export const clickStaticFilter = (filter) => {
+    const filterSelector = getStaticFilterSelectorClass(filter);
+    fireEvent.click(document.querySelector(filterSelector));
+};
+export const getAllStaticItemsLabels = () => {
+    const labels = [];
+    document
+        .querySelectorAll("[class*='s-relative-preset-']")
+        .forEach((item) => labels.push(item.textContent));
+    return labels;
+};
+// absolute presets
+export const clickAbsoluteFilter = (filter) => {
+    const filterSelector = getAbsoluteFilterSelectorClass(filter);
+    fireEvent.click(document.querySelector(filterSelector));
+};
+// Absolute filter form
+export const clickAbsoluteFormFilter = () => fireEvent.click(document.querySelector(absoluteFormButton));
+export const openAbsoluteFormFilter = () => {
+    clickDateFilterButton();
+    clickAbsoluteFormFilter();
+};
+export const dateToAbsoluteInputFormat = (dateString, dateFormat = defaultDateFormat) => {
+    return formatDate(new Date(dateString), dateFormat);
+};
+export const getTodayDate = (dateFormat = defaultDateFormat) => {
+    return formatDate(new Date(), dateFormat);
+};
+export const getMonthAgo = (dateFormat = defaultDateFormat) => {
+    return formatDate(add(new Date(), {
+        months: -1,
+    }), dateFormat);
+};
+// Relative filter form
+export const clickRelativeFormFilter = () => {
+    fireEvent.click(document.querySelector(relativeFormButton));
+};
+export const openRelativeFormFilter = () => {
+    clickDateFilterButton();
+    clickRelativeFormFilter();
+};
+export const getRelativeFormInputFromValue = () => document.querySelector(relativeFormInputFrom).value;
+export const getRelativeFormInputToValue = () => document.querySelector(relativeFormInputTo).value;
+export const setRelativeFormInputs = (from, to) => {
+    // it is necessary set value TO first and than FROM because strange menu opening in RelativeDateFilter copoment
+    // if FROM is set first than in TO is problem to select menu item  (is not visible)
+    writeToRelativeFormInputTo(to);
+    writeToRelativeFormInputFrom(from);
+};
+const writeToRelativeFormInputTo = (value) => {
+    const input = document.querySelector(relativeFormInputTo);
+    fireEvent.change(input, { target: { value } });
+    const menuItem = document.querySelector(".s-select-item-focused");
+    fireEvent.click(menuItem);
+};
+const writeToRelativeFormInputFrom = (value) => {
+    const input = document.querySelector(relativeFormInputFrom);
+    fireEvent.change(input, { target: { value } });
+    const menuItem = document.querySelector(".s-select-item-focused");
+    fireEvent.click(menuItem);
+};
+export const clickRelativeFormGranularity = (granularity) => {
+    const tab = document.querySelector(relativeFormGranularityTab(granularity));
+    fireEvent.click(tab);
+};
+export const isRelativeFormGranularitySelected = (granularity) => {
+    const tab = document.querySelector(relativeFormGranularityTab(granularity));
+    return tab.classList.contains("is-active");
+};
+export const isRelativeFormVisible = () => !!document.querySelector(relativeFormPicker);
+export const isRelativeFormSelectMenuVisible = () => !!document.querySelector(relativeFormSelectMenu);
+// exclude
+export const queryExcludeCurrentPeriodCheckbox = () => document.querySelector(excludeCurrentPeriodCheckbox);
+export const getExcludeCurrentPeriodCheckbox = () => queryExcludeCurrentPeriodCheckbox();
+export const clickExcludeCurrentPeriodCheckBox = () => {
+    fireEvent.click(getExcludeCurrentPeriodCheckbox());
+};
+export const isExcludeCurrentPeriodChecked = () => getExcludeCurrentPeriodCheckbox().checked;

package/esm/DateFilter/utils/Translations/fixtures.d.ts

@@ -0,0 +1,15 @@
+import { type IAbsoluteDateFilterPreset, type IAllTimeDateFilterOption, type IRelativeDateFilterPreset } from "@gooddata/sdk-model";
+import { type IUiAbsoluteDateFilterForm } from "../../interfaces/index.js";
+export declare const allTimeFilter: IAllTimeDateFilterOption;
+export declare const absoluteFormFilter: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterOneDay: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithTime: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithTimeInOneDay: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithSecondsInOneDay: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithSecondsOnlyChangeInOneDay: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithWholeDaySeconds: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithSecondsWithinMoreDays: IUiAbsoluteDateFilterForm;
+export declare const absoluteFormFilterWithTimeWithinMoreDays: IUiAbsoluteDateFilterForm;
+export declare const absolutePresetFilter: IAbsoluteDateFilterPreset;
+export declare const relativePresetFilter: IRelativeDateFilterPreset;
+//# sourceMappingURL=fixtures.d.ts.map

package/esm/DateFilter/utils/Translations/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../../../src/DateFilter/utils/Translations/fixtures.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EACjC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAE3E,eAAO,MAAM,aAAa,EAAE,wBAK3B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,yBAOhC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,yBAOtC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,yBAOxC,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,yBAOhD,CAAC;AAEF,eAAO,MAAM,qCAAqC,EAAE,yBAOnD,CAAC;AAEF,eAAO,MAAM,+CAA+C,EAAE,yBAO7D,CAAC;AAEF,eAAO,MAAM,qCAAqC,EAAE,yBAOnD,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,yBAOzD,CAAC;AAEF,eAAO,MAAM,wCAAwC,EAAE,yBAOtD,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,yBAOlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,yBAQlC,CAAC"}

package/esm/DateFilter/utils/Translations/fixtures.js

@@ -0,0 +1,96 @@
+// (C) 2019-2026 GoodData Corporation
+export const allTimeFilter = {
+    localIdentifier: "ALL_TIME",
+    type: "allTime",
+    name: "",
+    visible: true,
+};
+export const absoluteFormFilter = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01",
+    to: "2019-02-01",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterOneDay = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01",
+    to: "2019-01-01",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithTime = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 1:00",
+    to: "2019-02-01 16:55",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithTimeInOneDay = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 00:00",
+    to: "2019-01-01 23:59",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithSecondsInOneDay = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 22:11:00",
+    to: "2019-01-01 22:31:05",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithSecondsOnlyChangeInOneDay = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 00:00:30",
+    to: "2019-01-01 23:59:40",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithWholeDaySeconds = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 00:00:00",
+    to: "2019-01-01 23:59:59",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithSecondsWithinMoreDays = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 22:11:00",
+    to: "2019-01-04 22:31:05",
+    name: "Static range",
+    visible: true,
+};
+export const absoluteFormFilterWithTimeWithinMoreDays = {
+    localIdentifier: "ABSOLUTE_FORM",
+    type: "absoluteForm",
+    from: "2019-01-01 00:00",
+    to: "2019-01-04 23:59",
+    name: "Static range",
+    visible: true,
+};
+export const absolutePresetFilter = {
+    localIdentifier: "ABSOLUTE_PRESET_FOO",
+    type: "absolutePreset",
+    from: "2019-01-01",
+    to: "2019-02-01",
+    name: "foo",
+    visible: true,
+};
+export const relativePresetFilter = {
+    localIdentifier: "RELATIVE_PRESET_FOO",
+    type: "relativePreset",
+    from: -5,
+    to: 5,
+    granularity: "GDC.time.date",
+    name: "foo",
+    visible: true,
+};

package/esm/MeasureValueFilter/fragments/MeasureValueFilterDropdown.d.ts

@@ -0,0 +1,29 @@
+export declare class MeasureValueFilterFragment {
+    getOperatorDropdown: () => HTMLElement | null;
+    getOperatorDropdownButtons: () => NodeListOf<Element>;
+    getOperatorDropdownButton: (index?: number) => Element;
+    isOperatorDropdownOpen: () => boolean;
+    getApplyButton: () => HTMLElement | null;
+    clickApply: () => this;
+    clickCancel: () => this;
+    openOperatorDropdown: (index?: number) => this;
+    getOperator: (operator: string) => Element | null;
+    getOperatorBubbles: (operator: string) => NodeListOf<Element>;
+    selectOperator: (operator: string) => this;
+    getComparisonValueInput: () => HTMLInputElement;
+    setComparisonValue: (value: string) => this;
+    getRangeFromInput: () => HTMLInputElement;
+    setRangeFrom: (value: string) => this;
+    getRangeToInput: () => HTMLInputElement;
+    setRangeTo: (value: string) => this;
+    isApplyButtonDisabled: () => boolean;
+    pressEnterInComparisonInput: () => boolean;
+    getSelectedOperatorTitle: (index?: number) => string;
+    getInputSuffixes: () => NodeListOf<Element>;
+    getWarningMessage: () => Element | null;
+    getWarningMessageBySeverity: (severity: string) => Element | null;
+    getPreview: () => HTMLElement | null;
+    clickTreatNullAsCheckbox: () => this;
+    getTreatNullAsCheckbox: () => HTMLInputElement | null;
+}
+//# sourceMappingURL=MeasureValueFilterDropdown.d.ts.map

package/esm/MeasureValueFilter/fragments/MeasureValueFilterDropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureValueFilterDropdown.d.ts","sourceRoot":"","sources":["../../../src/MeasureValueFilter/fragments/MeasureValueFilterDropdown.tsx"],"names":[],"mappings":"AASA,qBAAa,0BAA0B;IAC5B,mBAAmB,2BAC+B;IAElD,0BAA0B,4BAAmE;IAE7F,yBAAyB,8BAAgE;IAEzF,sBAAsB,gBAAsC;IAE5D,cAAc,2BAAiD;IAE/D,UAAU,aAGf;IAEK,WAAW,aAGhB;IAEK,oBAAoB,2BAKzB;IAEK,WAAW,uCACsD;IAEjE,kBAAkB,4CACoE;IAEtF,cAAc,6BAGnB;IAEK,uBAAuB,yBACqC;IAE5D,kBAAkB,0BAGvB;IAEK,iBAAiB,yBACqC;IAEtD,YAAY,0BAGjB;IAEK,eAAe,yBAAkF;IAEjG,UAAU,0BAGf;IAEK,qBAAqB,gBAA+D;IAEpF,2BAA2B,gBACqC;IAEhE,wBAAwB,6BAAoE;IAE5F,gBAAgB,4BAAuD;IAEvE,iBAAiB,uBAA0D;IAE3E,2BAA2B,uCAC+B;IAE1D,UAAU,2BAAwF;IAElG,wBAAwB,aAM7B;IAEK,sBAAsB,gCACsE;CACtG"}

package/esm/MeasureValueFilter/fragments/MeasureValueFilterDropdown.js

@@ -0,0 +1,62 @@
+// (C) 2019-2026 GoodData Corporation
+import { fireEvent, screen } from "@testing-library/react";
+import { simplifyText } from "@gooddata/util";
+const CLASS_OPERATOR_DROPDOWN_BUTTON = ".s-mvf-operator-dropdown-button";
+const CLASS_OPERATOR_DROPDOWN_BODY = ".s-mvf-operator-dropdown-body";
+export class MeasureValueFilterFragment {
+    getOperatorDropdown = () => document.querySelector(CLASS_OPERATOR_DROPDOWN_BODY);
+    getOperatorDropdownButtons = () => document.querySelectorAll(CLASS_OPERATOR_DROPDOWN_BUTTON);
+    getOperatorDropdownButton = (index = 0) => this.getOperatorDropdownButtons().item(index);
+    isOperatorDropdownOpen = () => !!this.getOperatorDropdown();
+    getApplyButton = () => screen.getByText("Apply").parentElement;
+    clickApply = () => {
+        fireEvent.click(this.getApplyButton());
+        return this;
+    };
+    clickCancel = () => {
+        fireEvent.click(screen.getByText("Cancel"));
+        return this;
+    };
+    openOperatorDropdown = (index = 0) => {
+        if (!this.isOperatorDropdownOpen()) {
+            fireEvent.click(this.getOperatorDropdownButton(index));
+        }
+        return this;
+    };
+    getOperator = (operator) => document.querySelector(`.s-mvf-operator-${simplifyText(operator)}`);
+    getOperatorBubbles = (operator) => document.querySelectorAll(`.s-mvf-operator-${simplifyText(operator)} .s-list-item-info`);
+    selectOperator = (operator) => {
+        fireEvent.click(this.getOperator(operator));
+        return this;
+    };
+    getComparisonValueInput = () => document.querySelector(".s-mvf-comparison-value-input input");
+    setComparisonValue = (value) => {
+        fireEvent.change(this.getComparisonValueInput(), { target: { value } });
+        return this;
+    };
+    getRangeFromInput = () => document.querySelector(".s-mvf-range-from-input input");
+    setRangeFrom = (value) => {
+        fireEvent.change(this.getRangeFromInput(), { target: { value } });
+        return this;
+    };
+    getRangeToInput = () => document.querySelector(".s-mvf-range-to-input input");
+    setRangeTo = (value) => {
+        fireEvent.change(this.getRangeToInput(), { target: { value } });
+        return this;
+    };
+    isApplyButtonDisabled = () => this.getApplyButton().classList.contains("disabled");
+    pressEnterInComparisonInput = () => fireEvent.keyDown(this.getComparisonValueInput(), { keyCode: 13 });
+    getSelectedOperatorTitle = (index = 0) => this.getOperatorDropdownButton(index).textContent;
+    getInputSuffixes = () => document.querySelectorAll(".gd-input-suffix");
+    getWarningMessage = () => document.querySelector(".s-mvf-warning-message");
+    getWarningMessageBySeverity = (severity) => document.querySelector(`.s-mvf-warning-message-${severity}`);
+    getPreview = () => document.querySelector("[data-testid='mvf-preview-text']");
+    clickTreatNullAsCheckbox = () => {
+        const checkbox = this.getTreatNullAsCheckbox();
+        const nextChecked = !checkbox.checked;
+        fireEvent.click(checkbox);
+        fireEvent.change(checkbox, { target: { checked: nextChecked } });
+        return this;
+    };
+    getTreatNullAsCheckbox = () => document.querySelector("[data-testid='mvf-treat-null-values-as-zero'] input[type='checkbox']");
+}

package/esm/RankingFilter/fragments/RankingFilterDropdown.d.ts

@@ -0,0 +1,35 @@
+export declare class RankingFilterDropdownFragment {
+    clickCancel: () => RankingFilterDropdownFragment;
+    clickApply: () => RankingFilterDropdownFragment;
+    getApplyButton: () => HTMLElement | null;
+    isApplyButtonDisabled: () => boolean;
+    isOperatorDropdownOpen: () => boolean;
+    getOperatorDropdownButton: () => Element | null;
+    openOperatorDropdown: () => RankingFilterDropdownFragment;
+    setOperator: (value: string) => RankingFilterDropdownFragment;
+    getOperator: () => string;
+    getValueDropdown: () => Element | null;
+    getValueDropdownItems: () => NodeListOf<Element>;
+    isValueDropdownVisible: () => boolean;
+    changeInputValue: (value: string) => RankingFilterDropdownFragment;
+    setValue: (value: string) => RankingFilterDropdownFragment;
+    setValueByBlur: (value: string) => RankingFilterDropdownFragment;
+    getValue: () => string;
+    isMeasureDropdownOpen: () => boolean;
+    getMeasureDropdownButton: () => Element | null;
+    openMeasureDropdown: () => RankingFilterDropdownFragment;
+    getMeasureItem: (value: string) => Element | null;
+    setMeasureItem: (value: string) => RankingFilterDropdownFragment;
+    getMeasure: () => string;
+    isAttributeButtonDisabled: () => boolean;
+    isAttributeDropdownOpen: () => boolean;
+    openAttributeDropdown: () => RankingFilterDropdownFragment;
+    getAttributeDropdownDisabledButtons: () => NodeListOf<Element>;
+    getAttributeItem: (value: string) => Element | null;
+    setAttributeItem: (value: string) => RankingFilterDropdownFragment;
+    setAttributeToAllRecords: () => RankingFilterDropdownFragment;
+    getAttributeDropdownButton: () => Element | null;
+    getAttribute: () => string;
+    getPreview: () => string;
+}
+//# sourceMappingURL=RankingFilterDropdown.d.ts.map

package/esm/RankingFilter/fragments/RankingFilterDropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RankingFilterDropdown.d.ts","sourceRoot":"","sources":["../../../src/RankingFilter/fragments/RankingFilterDropdown.tsx"],"names":[],"mappings":"AAiBA,qBAAa,6BAA6B;IAC/B,WAAW,sCAGhB;IAEK,UAAU,sCAGf;IAEK,cAAc,2BAAiD;IAE/D,qBAAqB,gBAA+D;IAEpF,sBAAsB,gBAAmE;IAEzF,yBAAyB,uBAA0D;IAEnF,oBAAoB,sCAKzB;IAEK,WAAW,mDAGhB;IAEK,WAAW,eAA+E;IAE1F,gBAAgB,uBAA2D;IAE3E,qBAAqB,4BAC+C;IAEpE,sBAAsB,gBAAmC;IAEzD,gBAAgB,mDAIrB;IAEK,QAAQ,mDAIb;IAEK,cAAc,mDAInB;IAEK,QAAQ,eAAkF;IAE1F,qBAAqB,gBAAkE;IAEvF,wBAAwB,uBAAyD;IAEjF,mBAAmB,sCAKxB;IAEK,cAAc,oCAEnB;IAEK,cAAc,mDAGnB;IAEK,UAAU,eAA8E;IAExF,yBAAyB,gBACsC;IAE/D,uBAAuB,gBAAoE;IAE3F,qBAAqB,sCAK1B;IAEK,mCAAmC,4BAExC;IAEK,gBAAgB,oCAErB;IAEK,gBAAgB,mDAGrB;IAEK,wBAAwB,sCAG7B;IAEK,0BAA0B,uBAA2D;IAErF,YAAY,eAAgE;IAE5E,UAAU,eAAmE;CACvF"}

package/esm/RankingFilter/fragments/RankingFilterDropdown.js

@@ -0,0 +1,98 @@
+// (C) 2020-2026 GoodData Corporation
+import { fireEvent, screen } from "@testing-library/react";
+import { simplifyText } from "@gooddata/util";
+const OPERATOR_DROPDOWN_BUTTON = ".s-rf-operator-dropdown-button";
+const OPERATOR_DROPDOWN_BODY = ".s-rf-operator-dropdown-body";
+const VALUE_DROPDOWN_INPUT = ".s-rf-value-dropdown-button input";
+const VALUE_DROPDOWN_ITEM = ".s-rf-value-dropdown-item";
+const MEASURE_DROPDOWN_BUTTON = ".s-rf-measure-dropdown-button";
+const MEASURE_DROPDOWN_BODY = ".s-rf-measure-dropdown-body";
+const ATTRIBUTE_DROPDOWN_BUTTON = ".s-rf-attribute-dropdown-button";
+const ATTRIBUTE_DROPDOWN_BODY = ".s-rf-attribute-dropdown-body";
+const ATTRIBUTE_ALL_RECORDS = ".s-rf-attribute-all-records";
+const PREVIEW_TEXT = ".s-rf-preview";
+export class RankingFilterDropdownFragment {
+    clickCancel = () => {
+        fireEvent.click(screen.getByText("Cancel"));
+        return this;
+    };
+    clickApply = () => {
+        fireEvent.click(this.getApplyButton());
+        return this;
+    };
+    getApplyButton = () => screen.getByText("Apply").parentElement;
+    isApplyButtonDisabled = () => this.getApplyButton().classList.contains("disabled");
+    isOperatorDropdownOpen = () => !!document.querySelector(OPERATOR_DROPDOWN_BODY);
+    getOperatorDropdownButton = () => document.querySelector(OPERATOR_DROPDOWN_BUTTON);
+    openOperatorDropdown = () => {
+        if (!this.isOperatorDropdownOpen()) {
+            fireEvent.click(this.getOperatorDropdownButton());
+        }
+        return this;
+    };
+    setOperator = (value) => {
+        fireEvent.click(document.querySelector(`.s-rf-operator-${simplifyText(value)}`));
+        return this;
+    };
+    getOperator = () => document.querySelector(OPERATOR_DROPDOWN_BUTTON).textContent;
+    getValueDropdown = () => document.querySelector(".gd-dynamic-select-menu");
+    getValueDropdownItems = () => this.getValueDropdown().querySelectorAll(".s-rf-value-dropdown-item");
+    isValueDropdownVisible = () => !!this.getValueDropdown();
+    changeInputValue = (value) => {
+        const input = document.querySelector(VALUE_DROPDOWN_INPUT);
+        fireEvent.change(input, { target: { value } });
+        return this;
+    };
+    setValue = (value) => {
+        this.changeInputValue(value);
+        fireEvent.click(document.querySelector(VALUE_DROPDOWN_ITEM));
+        return this;
+    };
+    setValueByBlur = (value) => {
+        this.changeInputValue(value);
+        fireEvent.blur(document.querySelector(VALUE_DROPDOWN_INPUT));
+        return this;
+    };
+    getValue = () => document.querySelector(VALUE_DROPDOWN_INPUT).value;
+    isMeasureDropdownOpen = () => !!document.querySelector(MEASURE_DROPDOWN_BODY);
+    getMeasureDropdownButton = () => document.querySelector(MEASURE_DROPDOWN_BUTTON);
+    openMeasureDropdown = () => {
+        if (!this.isMeasureDropdownOpen()) {
+            fireEvent.click(document.querySelector(MEASURE_DROPDOWN_BUTTON));
+        }
+        return this;
+    };
+    getMeasureItem = (value) => {
+        return document.querySelector(`.s-rf-measure-${simplifyText(value)}`);
+    };
+    setMeasureItem = (value) => {
+        fireEvent.click(this.getMeasureItem(value));
+        return this;
+    };
+    getMeasure = () => document.querySelector(MEASURE_DROPDOWN_BUTTON).textContent;
+    isAttributeButtonDisabled = () => this.getAttributeDropdownButton().classList.contains("disabled");
+    isAttributeDropdownOpen = () => !!document.querySelector(ATTRIBUTE_DROPDOWN_BODY);
+    openAttributeDropdown = () => {
+        if (!this.isAttributeDropdownOpen()) {
+            fireEvent.click(this.getAttributeDropdownButton());
+        }
+        return this;
+    };
+    getAttributeDropdownDisabledButtons = () => {
+        return document.querySelectorAll(`${ATTRIBUTE_DROPDOWN_BODY} button.disabled`);
+    };
+    getAttributeItem = (value) => {
+        return document.querySelector(`.s-rf-attribute-${simplifyText(value)}`);
+    };
+    setAttributeItem = (value) => {
+        fireEvent.click(this.getAttributeItem(value));
+        return this;
+    };
+    setAttributeToAllRecords = () => {
+        fireEvent.click(document.querySelector(ATTRIBUTE_ALL_RECORDS));
+        return this;
+    };
+    getAttributeDropdownButton = () => document.querySelector(ATTRIBUTE_DROPDOWN_BUTTON);
+    getAttribute = () => this.getAttributeDropdownButton().textContent;
+    getPreview = () => document.querySelector(PREVIEW_TEXT).textContent;
+}

package/esm/RankingFilter/mocks.d.ts

@@ -0,0 +1,17 @@
+import { type IRankingFilter } from "@gooddata/sdk-model";
+import { type IAttributeDropdownItem, type IMeasureDropdownItem } from "./types.js";
+export declare const attribute1Ref: import("@gooddata/sdk-model").UriRef;
+export declare const attribute2Ref: import("@gooddata/sdk-model").IdentifierRef;
+export declare const attribute3Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const attribute4Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const measure1Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const measure2Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const measure3Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const measure4Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const measure5Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const date1Ref: import("@gooddata/sdk-model").LocalIdRef;
+export declare const defaultFilter: IRankingFilter;
+export declare const filterWithRichSetting: IRankingFilter;
+export declare const measureItems: IMeasureDropdownItem[];
+export declare const attributeItems: IAttributeDropdownItem[];
+//# sourceMappingURL=mocks.d.ts.map

package/esm/RankingFilter/mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/RankingFilter/mocks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAA6B,MAAM,qBAAqB,CAAC;AAErF,OAAO,EAAE,KAAK,sBAAsB,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEpF,eAAO,MAAM,aAAa,sCAAuB,CAAC;AAClD,eAAO,MAAM,aAAa,6CAAsB,CAAC;AACjD,eAAO,MAAM,aAAa,0CAA2B,CAAC;AACtD,eAAO,MAAM,aAAa,0CAA2B,CAAC;AAEtD,eAAO,MAAM,WAAW,0CAAyB,CAAC;AAClD,eAAO,MAAM,WAAW,0CAAyB,CAAC;AAClD,eAAO,MAAM,WAAW,0CAAyB,CAAC;AAClD,eAAO,MAAM,WAAW,0CAAyB,CAAC;AAClD,eAAO,MAAM,WAAW,0CAAyB,CAAC;AAElD,eAAO,MAAM,QAAQ,0CAAsB,CAAC;AAE5C,eAAO,MAAM,aAAa,EAAE,cAM3B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,cAOnC,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,oBAAoB,EAM9C,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,sBAAsB,EAMlD,CAAC"}

package/esm/RankingFilter/mocks.js

@@ -0,0 +1,41 @@
+// (C) 2020-2026 GoodData Corporation
+import { idRef, localIdRef, uriRef } from "@gooddata/sdk-model";
+export const attribute1Ref = uriRef("attribute1");
+export const attribute2Ref = idRef("attribute2");
+export const attribute3Ref = localIdRef("attribute3");
+export const attribute4Ref = localIdRef("attribute4");
+export const measure1Ref = localIdRef("measure1");
+export const measure2Ref = localIdRef("measure2");
+export const measure3Ref = localIdRef("measure3");
+export const measure4Ref = localIdRef("measure4");
+export const measure5Ref = localIdRef("measure5");
+export const date1Ref = localIdRef("date1");
+export const defaultFilter = {
+    rankingFilter: {
+        measure: measure1Ref,
+        operator: "TOP",
+        value: 10,
+    },
+};
+export const filterWithRichSetting = {
+    rankingFilter: {
+        measure: measure3Ref,
+        attributes: [attribute1Ref, attribute2Ref, attribute3Ref, attribute4Ref],
+        operator: "BOTTOM",
+        value: 100,
+    },
+};
+export const measureItems = [
+    { title: "Measure 1", ref: measure1Ref },
+    { title: "Measure 2", ref: measure2Ref },
+    { title: "Measure 3", ref: measure3Ref },
+    { title: "Measure 4", ref: measure4Ref },
+    { title: "Measure 5", ref: measure5Ref },
+];
+export const attributeItems = [
+    { title: "Attribute 1", ref: attribute1Ref, type: "ATTRIBUTE" },
+    { title: "Attribute 2", ref: attribute2Ref, type: "ATTRIBUTE" },
+    { title: "Attribute 3", ref: attribute3Ref, type: "ATTRIBUTE" },
+    { title: "Date", ref: date1Ref, type: "DATE" },
+    { title: "Attribute 4", ref: attribute4Ref, type: "ATTRIBUTE" },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-filters",
-  "version": "11.54.0-alpha.3",
+  "version": "11.54.0-alpha.5",
   "description": "GoodData.UI SDK - Filter Components",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -46,11 +46,11 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/sdk-backend-spi": "11.54.0-alpha.3",
-    "@gooddata/sdk-model": "11.54.0-alpha.3",
-    "@gooddata/sdk-ui": "11.54.0-alpha.3",
-    "@gooddata/sdk-ui-kit": "11.54.0-alpha.3",
-    "@gooddata/util": "11.54.0-alpha.3"
+    "@gooddata/sdk-backend-spi": "11.54.0-alpha.5",
+    "@gooddata/sdk-model": "11.54.0-alpha.5",
+    "@gooddata/sdk-ui": "11.54.0-alpha.5",
+    "@gooddata/sdk-ui-kit": "11.54.0-alpha.5",
+    "@gooddata/util": "11.54.0-alpha.5"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -92,12 +92,12 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.54.0-alpha.3",
-    "@gooddata/oxlint-config": "11.54.0-alpha.3",
-    "@gooddata/reference-workspace": "11.54.0-alpha.3",
-    "@gooddata/sdk-ui-theme-provider": "11.54.0-alpha.3",
-    "@gooddata/sdk-backend-mockingbird": "11.54.0-alpha.3",
-    "@gooddata/stylelint-config": "11.54.0-alpha.3"
+    "@gooddata/eslint-config": "11.54.0-alpha.5",
+    "@gooddata/oxlint-config": "11.54.0-alpha.5",
+    "@gooddata/reference-workspace": "11.54.0-alpha.5",
+    "@gooddata/sdk-backend-mockingbird": "11.54.0-alpha.5",
+    "@gooddata/sdk-ui-theme-provider": "11.54.0-alpha.5",
+    "@gooddata/stylelint-config": "11.54.0-alpha.5"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",