@gooddata/sdk-ui-dashboard 11.42.0 → 11.43.0-alpha.1

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.d.ts

@@ -0,0 +1,10 @@
+import { type IDateFilterConfig } from "@gooddata/sdk-model";
+import { type IDateFilterOptionsByType } from "@gooddata/sdk-ui-filters";
+/**
+ * Converts date filter config - as stored on the backend - into the date filter options that are aimed for
+ * consumption by the actual date filtering view components.
+ *
+ * @param config - date filter config from backend
+ */
+export declare function convertDateFilterConfigToDateFilterOptions(config: IDateFilterConfig): IDateFilterOptionsByType;
+//# sourceMappingURL=dateFilterConfigConverters.d.ts.map

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateFilterConfigConverters.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.ts"],"names":[],"mappings":"AAKA,OAAO,EAIH,KAAK,iBAAiB,EAIzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGH,KAAK,wBAAwB,EAIhC,MAAM,0BAA0B,CAAC;AAKlC;;;;;GAKG;AACH,wBAAgB,0CAA0C,CACtD,MAAM,EAAE,iBAAiB,GAC1B,wBAAwB,CAgB1B"}

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterConfigConverters.js

@@ -0,0 +1,89 @@
+// (C) 2019-2026 GoodData Corporation
+import { endOfDay, format, startOfDay, subMonths } from "date-fns";
+import { groupBy, isEmpty, max, min } from "lodash-es";
+// TODO: this import was coming from internal/esm and was wrecking tests
+const PLATFORM_DATE_FORMAT = "yyyy-MM-dd HH:mm";
+/**
+ * Converts date filter config - as stored on the backend - into the date filter options that are aimed for
+ * consumption by the actual date filtering view components.
+ *
+ * @param config - date filter config from backend
+ */
+export function convertDateFilterConfigToDateFilterOptions(config) {
+    const allTime = convertAllTime(config.allTime);
+    const emptyValues = convertEmptyValues(config.emptyValues);
+    const absoluteForm = convertAbsoluteForm(config.absoluteForm);
+    const relativeForm = convertRelativeForm(config.relativeForm);
+    const absolutePreset = convertAbsolutePresets(config.absolutePresets);
+    const relativePreset = convertRelativePresets(config.relativePresets);
+    return removeEmptyKeysFromDateFilterOptions({
+        allTime,
+        emptyValues,
+        absoluteForm,
+        absolutePreset,
+        relativeForm,
+        relativePreset,
+    });
+}
+function convertAllTime(filter) {
+    return (filter && {
+        ...filter,
+        type: "allTime",
+    });
+}
+function convertEmptyValues(filter) {
+    return (filter && {
+        ...filter,
+        type: "emptyValues",
+    });
+}
+function convertAbsoluteForm(filter) {
+    return (filter && {
+        ...filter,
+        from: format(startOfDay(subMonths(new Date(), 1)), PLATFORM_DATE_FORMAT),
+        to: format(endOfDay(new Date()), PLATFORM_DATE_FORMAT),
+        type: "absoluteForm",
+    });
+}
+function convertRelativeForm(filter) {
+    return (filter && {
+        from: undefined,
+        // we order the granularities anyway, this lets the user to config the default
+        granularity: filter.availableGranularities[0],
+        localIdentifier: filter.localIdentifier,
+        name: filter.name,
+        to: undefined,
+        type: "relativeForm",
+        visible: filter.visible,
+    });
+}
+function convertAbsolutePresets(filters) {
+    return filters?.map((preset) => sanitizeDateFilterOption({
+        ...preset,
+        type: "absolutePreset",
+    }));
+}
+function convertRelativePresets(filters) {
+    return (filters &&
+        groupBy(filters.map((preset) => sanitizeDateFilterOption({
+            ...preset,
+            type: "relativePreset",
+        })), (preset) => preset.granularity));
+}
+function removeEmptyKeysFromDateFilterOptions({ absoluteForm, absolutePreset, allTime, emptyValues, relativeForm, relativePreset, }) {
+    return {
+        ...(allTime && { allTime }),
+        ...(emptyValues && { emptyValues }),
+        ...(absoluteForm && { absoluteForm }),
+        ...(!isEmpty(absolutePreset) && { absolutePreset }),
+        ...(relativeForm && { relativeForm }),
+        ...(!isEmpty(relativePreset) && { relativePreset }),
+    };
+}
+function sanitizeDateFilterOption(option) {
+    return {
+        ...option,
+        from: min([option.from, option.to]),
+        to: max([option.from, option.to]),
+    };
+}

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.d.ts

@@ -0,0 +1,34 @@
+import { type IDashboardDateFilter } from "@gooddata/sdk-model";
+import { type DateFilterOption, type IDateFilterOptionsByType } from "@gooddata/sdk-ui-filters";
+interface IDateFilterOptionInfo {
+    dateFilterOption: DateFilterOption;
+    excludeCurrentPeriod: boolean;
+}
+/**
+ * Tries to match a preset or a form with the provided value. Prioritizes the provided option if possible.
+ *
+ * @remarks
+ * This is to handle cases when user picked a form and filled values that match an existing preset.
+ * In those cases we want to show the form as picked even though a preset would otherwise be preferred.
+ *
+ * @param dateFilter - value to match against
+ * @param availableOptions - date options available
+ * @param preferredOptionId - id of the option that should be matched first if possible
+ */
+export declare function matchDateFilterToDateFilterOptionWithPreference(dateFilter: IDashboardDateFilter | undefined, availableOptions: IDateFilterOptionsByType, preferredOptionId: string | undefined): IDateFilterOptionInfo;
+/**
+ * Tries to match a preset or a form with the provided value. Prioritizes presets over forms.
+ * @param dateFilterValue - value to match against
+ * @param availableOptions - date options available
+ */
+export declare function matchDateFilterToDateFilterOption(dateFilter: IDashboardDateFilter | undefined, availableOptions: IDateFilterOptionsByType): IDateFilterOptionInfo;
+/**
+ * Flattens the provided date filter options. The flattening maintains a stable, predefined order in which
+ * the options should be rendered by the date filter component.
+ *
+ * @param dateFilterOptions - available options to flatten
+ */
+export declare function flattenDateFilterOptions(dateFilterOptions: IDateFilterOptionsByType): DateFilterOption[];
+export declare function findDateFilterOptionByValue(dateFilter: IDashboardDateFilter, dateFilterOptions: IDateFilterOptionsByType): DateFilterOption | undefined;
+export {};
+//# sourceMappingURL=dateFilterOptionMapping.d.ts.map

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateFilterOptionMapping.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.ts"],"names":[],"mappings":"AAIA,OAAO,EAKH,KAAK,oBAAoB,EAM5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACH,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAKhC,MAAM,0BAA0B,CAAC;AAUlC,UAAU,qBAAqB;IAC3B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,EAAE,OAAO,CAAC;CACjC;AAaD;;;;;;;;;;GAUG;AACH,wBAAgB,+CAA+C,CAC3D,UAAU,EAAE,oBAAoB,GAAG,SAAS,EAC5C,gBAAgB,EAAE,wBAAwB,EAC1C,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACtC,qBAAqB,CAmBvB;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC7C,UAAU,EAAE,oBAAoB,GAAG,SAAS,EAC5C,gBAAgB,EAAE,wBAAwB,GAC3C,qBAAqB,CAqEvB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,iBAAiB,EAAE,wBAAwB,GAAG,gBAAgB,EAAE,CAmBxG;AAsDD,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,oBAAoB,EAChC,iBAAiB,EAAE,wBAAwB,gCAG9C"}

package/esm/presentation/automations/shared/dateFilterConfig/dateFilterOptionMapping.js

@@ -0,0 +1,261 @@
+// (C) 2021-2026 GoodData Corporation
+import { compact } from "lodash-es";
+import { isAllTimeDashboardDateFilter, isLowerBound, isUpperBound, } from "@gooddata/sdk-model";
+import { isAbsoluteDateFilterOption, isRelativeDateFilterOption, } from "@gooddata/sdk-ui-filters";
+const VIRTUAL_PRESET_IDENTIFIER = "GDC__VIRTUAL_PRESET";
+const virtualPresetBase = {
+    localIdentifier: VIRTUAL_PRESET_IDENTIFIER,
+    name: "",
+    visible: false,
+};
+const isAllTimeDateFilter = (dateFilter) => dateFilter && isAllTimeDashboardDateFilter(dateFilter);
+function applyEmptyValueHandling(dateFilterOption, dateFilter) {
+    const emptyValueHandling = dateFilter?.dateFilter.emptyValueHandling;
+    return emptyValueHandling ? { ...dateFilterOption, emptyValueHandling } : dateFilterOption;
+}
+/**
+ * Tries to match a preset or a form with the provided value. Prioritizes the provided option if possible.
+ *
+ * @remarks
+ * This is to handle cases when user picked a form and filled values that match an existing preset.
+ * In those cases we want to show the form as picked even though a preset would otherwise be preferred.
+ *
+ * @param dateFilter - value to match against
+ * @param availableOptions - date options available
+ * @param preferredOptionId - id of the option that should be matched first if possible
+ */
+export function matchDateFilterToDateFilterOptionWithPreference(dateFilter, availableOptions, preferredOptionId) {
+    const preferredOption = preferredOptionId
+        ? findDateFilterOptionById(preferredOptionId, availableOptions)
+        : undefined;
+    const isAllTime = isAllTimeDateFilter(dateFilter);
+    // we only really need to handle the cases when the selected option is a form
+    // other cases are correctly handled by the unbiased matching function
+    if (dateFilter &&
+        !isAllTime &&
+        (preferredOption?.type === "absoluteForm" || preferredOption?.type === "relativeForm") &&
+        canReconstructFormForStoredFilter(availableOptions, dateFilter)) {
+        return reconstructFormForStoredFilter(availableOptions, dateFilter);
+    }
+    return matchDateFilterToDateFilterOption(dateFilter, availableOptions);
+}
+/**
+ * Tries to match a preset or a form with the provided value. Prioritizes presets over forms.
+ * @param dateFilterValue - value to match against
+ * @param availableOptions - date options available
+ */
+export function matchDateFilterToDateFilterOption(dateFilter, availableOptions) {
+    // no value means common All Time, try matching against All time (if it is available) or create virtual preset for it
+    const isAllTime = isAllTimeDateFilter(dateFilter);
+    if (!dateFilter || isAllTime) {
+        const emptyValueHandling = dateFilter?.dateFilter.emptyValueHandling;
+        if (emptyValueHandling === "only") {
+            const { emptyValues: emptyValuesOption } = availableOptions;
+            if (isDateFilterOptionVisible(emptyValuesOption)) {
+                return {
+                    dateFilterOption: { ...emptyValuesOption, emptyValueHandling: "only" },
+                    excludeCurrentPeriod: false,
+                };
+            }
+        }
+        const { allTime } = availableOptions;
+        if (allTime) {
+            return {
+                dateFilterOption: applyEmptyValueHandling(allTime, dateFilter),
+                excludeCurrentPeriod: false,
+            };
+        }
+        const virtual = createVirtualPresetForStoredFilter(undefined);
+        return {
+            ...virtual,
+            dateFilterOption: applyEmptyValueHandling(virtual.dateFilterOption, dateFilter),
+        };
+    }
+    // try matching the filter as is
+    const matchingFilter = findDateFilterOptionByValue(dateFilter, availableOptions);
+    if (matchingFilter) {
+        return {
+            dateFilterOption: applyEmptyValueHandling(matchingFilter, dateFilter),
+            excludeCurrentPeriod: false,
+        };
+    }
+    // try matching the filter with excludeCurrentPeriod === true, but only for relativeFormPresets
+    if (dateFilter.dateFilter.type === "relative" && dateFilter.dateFilter.to?.toString() === "-1") {
+        const filterToMatch = {
+            dateFilter: {
+                ...dateFilter.dateFilter,
+                from: Number.parseInt(dateFilter.dateFilter.from.toString(), 10) + 1,
+                to: 0,
+            },
+        };
+        const matchingFilter = findDateFilterOptionByValueAndType(filterToMatch, availableOptions, "relativePreset");
+        if (matchingFilter) {
+            return {
+                dateFilterOption: applyEmptyValueHandling(matchingFilter, dateFilter),
+                excludeCurrentPeriod: true,
+            };
+        }
+    }
+    // the stored filter must be a form with custom values
+    if (canReconstructFormForStoredFilter(availableOptions, dateFilter)) {
+        return reconstructFormForStoredFilter(availableOptions, dateFilter);
+    }
+    // we cannot use the form because it is disabled or otherwise incompatible
+    // -> we must create a virtual hidden preset
+    const virtual = createVirtualPresetForStoredFilter(dateFilter);
+    return { ...virtual, dateFilterOption: applyEmptyValueHandling(virtual.dateFilterOption, dateFilter) };
+}
+/**
+ * Flattens the provided date filter options. The flattening maintains a stable, predefined order in which
+ * the options should be rendered by the date filter component.
+ *
+ * @param dateFilterOptions - available options to flatten
+ */
+export function flattenDateFilterOptions(dateFilterOptions) {
+    const relativePresets = Object.values((dateFilterOptions.relativePreset ?? {})).flat();
+    // the order is significant here
+    // the first visible filter is selected for new dashboards if none is specified in config
+    return compact([
+        dateFilterOptions.allTime,
+        dateFilterOptions.emptyValues,
+        ...(dateFilterOptions.absolutePreset || []),
+        ...relativePresets,
+        dateFilterOptions.absoluteForm,
+        dateFilterOptions.relativeForm,
+    ]);
+}
+function canReconstructFormForStoredFilter(options, dateFilter) {
+    switch (dateFilter.dateFilter.type) {
+        case "absolute":
+            return isDateFilterOptionVisible(options.absoluteForm);
+        case "relative":
+            return isDateFilterOptionVisible(options.relativeForm);
+        default:
+            throw new Error("Unknown dateFilterValue type");
+    }
+}
+function reconstructFormForStoredFilter(options, dateFilter) {
+    if (dateFilter.dateFilter.type === "absolute") {
+        const dateFilterOption = {
+            ...options.absoluteForm,
+            from: dateFilter.dateFilter.from.toString(),
+            to: dateFilter.dateFilter.to.toString(),
+            type: "absoluteForm",
+            ...(dateFilter.dateFilter.emptyValueHandling
+                ? { emptyValueHandling: dateFilter.dateFilter.emptyValueHandling }
+                : {}),
+        };
+        return { dateFilterOption, excludeCurrentPeriod: false };
+    }
+    else {
+        const dateFilterOption = {
+            ...options.relativeForm,
+            from: Number.parseInt(dateFilter.dateFilter.from.toString(), 10),
+            to: Number.parseInt(dateFilter.dateFilter.to.toString(), 10),
+            granularity: dateFilter.dateFilter.granularity,
+            type: "relativeForm",
+            ...(dateFilter.dateFilter.emptyValueHandling
+                ? { emptyValueHandling: dateFilter.dateFilter.emptyValueHandling }
+                : {}),
+        };
+        return { dateFilterOption, excludeCurrentPeriod: false };
+    }
+}
+function isDateFilterOptionVisible(option) {
+    return !!option?.visible;
+}
+function findDateFilterOptionById(id, dateFilterOptions) {
+    return flattenDateFilterOptions(dateFilterOptions).find((option) => option.localIdentifier === id);
+}
+export function findDateFilterOptionByValue(dateFilter, dateFilterOptions) {
+    return flattenDateFilterOptions(dateFilterOptions).find(filterMatchesData(dateFilter));
+}
+function findDateFilterOptionByValueAndType(dateFilter, dateFilterOptions, type) {
+    return flattenDateFilterOptions(dateFilterOptions)
+        .filter((option) => option.type === type)
+        .find(filterMatchesData(dateFilter));
+}
+const filterMatchesData = (dateFilter) => (filter) => {
+    if (!filter) {
+        return false;
+    }
+    const data = dateFilter.dateFilter;
+    if (isAbsoluteDateFilterOption(filter)) {
+        return data.type === "absolute" && filter.from === data.from && filter.to === data.to;
+    }
+    if (isRelativeDateFilterOption(filter)) {
+        // Check if boundedFilter properties match exactly
+        const boundedFiltersMatch = (() => {
+            // If both don't have boundedFilter, they match
+            if (!filter.boundedFilter && !data.boundedFilter) {
+                return true;
+            }
+            // If only one has boundedFilter, they don't match
+            if (!filter.boundedFilter || !data.boundedFilter) {
+                return false;
+            }
+            // Both have boundedFilter - check granularity first
+            if (filter.boundedFilter.granularity !== data.boundedFilter.granularity) {
+                return false;
+            }
+            // Both must be the same type (both lower or both upper)
+            if (isLowerBound(filter.boundedFilter) && isLowerBound(data.boundedFilter)) {
+                return filter.boundedFilter.from === data.boundedFilter.from;
+            }
+            else if (isUpperBound(filter.boundedFilter) && isUpperBound(data.boundedFilter)) {
+                return filter.boundedFilter.to === data.boundedFilter.to;
+            }
+            // Different bound types don't match
+            return false;
+        })();
+        return (data.type === "relative" &&
+            filter.from?.toString() === data.from?.toString() &&
+            filter.to?.toString() === data.to?.toString() &&
+            filter.granularity === data.granularity &&
+            boundedFiltersMatch);
+    }
+    return false;
+};
+/**
+ * Creates a virtual preset with values corresponding to a provided server-side value.
+ * This is used in situations when a dashboard was saved with setting
+ * that can no longer be reproduced by the available options (e.g. relativeForm was used and later, was disabled)
+ */
+function createVirtualPresetForStoredFilter(dateFilter) {
+    if (!dateFilter) {
+        const dateFilterOption = {
+            ...virtualPresetBase,
+            type: "allTime",
+        };
+        return { dateFilterOption, excludeCurrentPeriod: false };
+    }
+    const { type, from, to, granularity } = dateFilter.dateFilter;
+    if (type === "absolute") {
+        const dateFilterOption = {
+            ...virtualPresetBase,
+            from: from.toString(),
+            to: to.toString(),
+            type: "absolutePreset",
+            ...(dateFilter.dateFilter.emptyValueHandling
+                ? { emptyValueHandling: dateFilter.dateFilter.emptyValueHandling }
+                : {}),
+        };
+        return { dateFilterOption, excludeCurrentPeriod: false };
+    }
+    else {
+        const dateFilterOption = {
+            ...virtualPresetBase,
+            from: Number.parseInt(from.toString(), 10),
+            to: Number.parseInt(to.toString(), 10),
+            granularity,
+            type: "relativePreset",
+            ...(dateFilter.dateFilter.boundedFilter
+                ? { boundedFilter: dateFilter.dateFilter.boundedFilter }
+                : {}),
+            ...(dateFilter.dateFilter.emptyValueHandling
+                ? { emptyValueHandling: dateFilter.dateFilter.emptyValueHandling }
+                : {}),
+        };
+        return { dateFilterOption, excludeCurrentPeriod: false };
+    }
+}

package/esm/presentation/automations/shared/dateFilterConfig/defaultConfig.d.ts

@@ -0,0 +1,12 @@
+import { type IDateFilterConfig } from "@gooddata/sdk-model";
+/**
+ * Default date filter preset for standard calendar.
+ */
+export declare const DEFAULT_DATE_FILTER_PRESET = "THIS_MONTH";
+/**
+ * Default date filter preset for fiscal calendar.
+ * Used when fiscal calendar is set as the default calendar type.
+ */
+export declare const DEFAULT_FISCAL_DATE_FILTER_PRESET = "THIS_FISCAL_MONTH";
+export declare const defaultDateFilterConfig: IDateFilterConfig;
+//# sourceMappingURL=defaultConfig.d.ts.map

package/esm/presentation/automations/shared/dateFilterConfig/defaultConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConfig.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/automations/shared/dateFilterConfig/defaultConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAS,MAAM,qBAAqB,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,0BAA0B,eAAe,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,iCAAiC,sBAAsB,CAAC;AAErE,eAAO,MAAM,uBAAuB,EAAE,iBAyarC,CAAC"}