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

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.4",
   "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-model": "11.54.0-alpha.4",
+    "@gooddata/sdk-backend-spi": "11.54.0-alpha.4",
+    "@gooddata/sdk-ui-kit": "11.54.0-alpha.4",
+    "@gooddata/sdk-ui": "11.54.0-alpha.4",
+    "@gooddata/util": "11.54.0-alpha.4"
   },
   "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.4",
+    "@gooddata/oxlint-config": "11.54.0-alpha.4",
+    "@gooddata/reference-workspace": "11.54.0-alpha.4",
+    "@gooddata/sdk-backend-mockingbird": "11.54.0-alpha.4",
+    "@gooddata/stylelint-config": "11.54.0-alpha.4",
+    "@gooddata/sdk-ui-theme-provider": "11.54.0-alpha.4"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",