@gooddata/sdk-code-convertors 11.28.0-alpha.1

package/esm/to/yamlDashboardToDeclarative.js

@@ -0,0 +1,732 @@
+// (C) 2023-2026 GoodData Corporation
+import { randomUUID } from "crypto";
+import { VisualisationsTypes } from "../conts.js";
+import { parseUrlTarget } from "../utils/customUrl.js";
+import { convertGranularity } from "../utils/granularityUtils.js";
+import { toDeclarativePermissions } from "../utils/permissionUtils.js";
+import { convertIdToTitle, getFullField } from "../utils/sharedUtils.js";
+import { isAbsoluteDateFilter, isAttributeField, isAttributeFilter, isContainerWidget, isDashboardAbsoluteDateFilter, isDashboardAttributeFilter, isDashboardEmptyDateFilter, isDashboardNoopDateFilter, isDashboardRelativeDateFilter, isInsightWidget, isMetricValueFilter, isRankingFilter, isRelativeDateFilter, isRichTextWidget, isVisualizationSwitcherWidget, parseReferenceObject, } from "../utils/typeGuards.js";
+import { createIdentifier, createLocalIdentifier } from "../utils/yamlUtils.js";
+function extractDashboardEmptyValueHandling(filter) {
+    const value = filter.empty_values;
+    if (value === "include" || value === "exclude" || value === "only") {
+        return value;
+    }
+    return undefined;
+}
+function createFilterContextId(baseId) {
+    return `${baseId}_filterContext_${randomUUID()}`;
+}
+/**
+ * Convert YAML tabs to Dashboard tabs with their own layouts and filter contexts.
+ * Each tab maintains its own sections, filters, and filter configurations independently.
+ * Filter contexts are created as separate entities referenced by filterContextRef.
+ */
+function yamlTabsToDeclarative(entities, tabs, enableSectionHeaders) {
+    const declarativeTabs = [];
+    const filterContexts = [];
+    tabs.forEach((tab) => {
+        // Convert tab sections to layout
+        const layout = yamlLayoutToDeclarative(entities, tab.sections, enableSectionHeaders);
+        // Process tab filters to get filter context and configs
+        const { filterContext, dateFilterConfig, dateFilterConfigs, attributeFilterConfigs, filterGroupsConfig, } = yamlFilterContextToDeclarative(tab.id, tab.filters);
+        // Store the filter context separately
+        filterContexts.push(filterContext);
+        // Create the tab structure with filterContextRef
+        declarativeTabs.push({
+            localIdentifier: tab.id,
+            title: tab.title,
+            layout,
+            filterContextRef: createIdentifier(filterContext.id, { forceType: "filterContext" }),
+            dateFilterConfig,
+            dateFilterConfigs,
+            attributeFilterConfigs,
+            ...(filterGroupsConfig ? { filterGroupsConfig } : {}),
+        });
+    });
+    return {
+        tabs: declarativeTabs,
+        filterContexts,
+    };
+}
+/**
+ * Process dashboard with tabs - uses active tab or first tab as main dashboard for backwards compatibility
+ */
+function processDashboardWithTabs(entities, input) {
+    const tabsResult = yamlTabsToDeclarative(entities, input.tabs, input.enable_section_headers);
+    // Use first tab as default for backwards compatibility
+    const defaultTabIndex = 0;
+    const defaultTab = tabsResult.tabs[defaultTabIndex];
+    return {
+        layout: defaultTab.layout,
+        filterContext: tabsResult.filterContexts[defaultTabIndex],
+        dateFilterConfig: defaultTab.dateFilterConfig,
+        dateFilterConfigs: defaultTab.dateFilterConfigs,
+        attributeFilterConfigs: defaultTab.attributeFilterConfigs,
+        tabs: tabsResult.tabs,
+        tabFilterContexts: tabsResult.filterContexts,
+    };
+}
+/**
+ * Process traditional dashboard without tabs
+ */
+function processDashboardWithoutTabs(entities, input) {
+    const { filterContext, tabFilterContexts: _tabFilterContexts, ...rest } = processDashboardWithTabs(entities, {
+        ...input,
+        tabs: [
+            {
+                id: "defaultTabId",
+                title: "",
+                filters: input.filters,
+                sections: input.sections ?? [],
+            },
+        ],
+    });
+    const dashboardFilterContextId = createFilterContextId(input.id);
+    const dashboardFilterContext = {
+        ...filterContext,
+        id: dashboardFilterContextId,
+    };
+    return {
+        ...rest,
+        tabs: rest.tabs.map((tab) => ({
+            ...tab,
+            filterContextRef: createIdentifier(dashboardFilterContextId, { forceType: "filterContext" }),
+        })),
+        filterContext: dashboardFilterContext,
+        tabFilterContexts: [dashboardFilterContext],
+    };
+}
+/** @public */
+export function yamlDashboardToDeclarative(entities, input) {
+    // Process dashboard based on whether it has tabs
+    const { layout, filterContext, dateFilterConfig, dateFilterConfigs, attributeFilterConfigs, tabs, tabFilterContexts, } = input.tabs ? processDashboardWithTabs(entities, input) : processDashboardWithoutTabs(entities, input);
+    const plugins = yamlPluginsToDeclarative(input.plugins);
+    const [, permissions] = toDeclarativePermissions(input.permissions);
+    const content = {
+        version: "2",
+        layout,
+        plugins,
+        attributeFilterConfigs,
+        dateFilterConfig,
+        dateFilterConfigs,
+        ...(tabs ? { tabs } : {}),
+        ...(input.cross_filtering === false ? { disableCrossFiltering: true } : {}),
+        ...(input.user_filters_save === false ? { disableUserFilterSave: true } : {}),
+        ...(input.user_filters_reset === false ? { disableUserFilterReset: true } : {}),
+        ...(input.filter_views === false ? { disableFilterViews: true } : {}),
+        filterContextRef: createIdentifier(filterContext.id, { forceType: "filterContext" }),
+    };
+    const dashboard = {
+        id: input.id,
+        title: input.title ?? convertIdToTitle(input.id),
+        tags: input.tags ?? [],
+        description: input.description ?? "",
+        content,
+        permissions,
+    };
+    return {
+        dashboard,
+        filterContext,
+        ...(tabFilterContexts && tabFilterContexts.length > 0 ? { tabFilterContexts } : {}),
+    };
+}
+function yamlLayoutToDeclarative(entities, sections = [], enableSectionHeaders) {
+    return {
+        type: "IDashboardLayout",
+        sections: sections.map((yamlSection) => yamlSectionToDeclarative(entities, yamlSection, enableSectionHeaders)),
+        ...(enableSectionHeaders === undefined
+            ? {}
+            : {
+                configuration: {
+                    sections: {
+                        enableHeader: enableSectionHeaders,
+                    },
+                },
+            }),
+    };
+}
+function yamlSectionToDeclarative(entities, yamlSection, enableSectionHeaders) {
+    return {
+        type: "IDashboardLayoutSection",
+        ...(yamlSection.title || yamlSection.description
+            ? {
+                header: {
+                    title: yamlSection.title ?? "",
+                    description: yamlSection.description ?? "",
+                },
+            }
+            : {}),
+        items: yamlSection.widgets
+            .map((widget) => yamlWidgetItemToDeclarative(entities, widget, enableSectionHeaders))
+            .filter(Boolean),
+    };
+}
+export function yamlWidgetItemToDeclarative(entities, input, enableSectionHeaders) {
+    const size = yamlSizeToDeclarative(input);
+    const widget = yamlWidgetToDeclarative(entities, input, enableSectionHeaders ?? true);
+    if (!widget) {
+        return null;
+    }
+    return {
+        type: "IDashboardLayoutItem",
+        size,
+        widget,
+    };
+}
+function yamlSizeToDeclarative(input) {
+    return {
+        xl: {
+            gridWidth: input.columns ?? 12,
+            gridHeight: input.rows ?? 22,
+        },
+    };
+}
+function yamlInsightWidgetToDeclarative(entities, input) {
+    return {
+        ...(input.id ? { localIdentifier: input.id } : {}),
+        type: "insight",
+        insight: createIdentifier(input.visualization, { forceType: "visualizationObject" }),
+        title: input.title || "",
+        description: useInherit(input.description),
+        configuration: {
+            hideTitle: input.title === false,
+            description: {
+                includeMetrics: false,
+                source: input.description === "inherit" || input.description === undefined ? "insight" : "widget",
+                visible: input.description !== false,
+            },
+        },
+        ignoreDashboardFilters: (input.ignored_filters ?? [])
+            .map((filterId) => yamlIgnoredFilterToDeclarative(filterId))
+            .filter(Boolean),
+        ...(input.date
+            ? {
+                dateDataSet: createIdentifier(input.date, { forceType: "dataset" }),
+            }
+            : {}),
+        properties: yamlWidgetPropertiesToDeclarative(input),
+        drills: (input.interactions ?? [])
+            .map((interaction) => yamlInteractionToDeclarative(entities, input.visualization, interaction))
+            .filter(Boolean),
+        ignoredDrillDownHierarchies: (input.ignored_drill_downs ?? [])
+            .map((hierarchy) => yamlIgnoredDrillDownToDeclarative(entities, input.visualization, hierarchy))
+            .filter(Boolean),
+        drillDownIntersectionIgnoredAttributes: (input.ignored_drill_downs_intersections ?? [])
+            .map((intersection) => yamlIgnoredDrillDownsIntersectionsToDeclarative(entities, input.visualization, intersection))
+            .filter(Boolean),
+        ...(input.ignored_cross_filtering ? { ignoreCrossFiltering: true } : {}),
+    };
+}
+export function yamlWidgetToDeclarative(entities, input, enableSectionHeaders) {
+    if (isContainerWidget(input)) {
+        return {
+            ...(input.container ? { localIdentifier: input.container } : {}),
+            type: "IDashboardLayout",
+            sections: input.sections.map((section) => ({
+                type: "IDashboardLayoutSection",
+                header: {
+                    ...(enableSectionHeaders && section.title ? { title: section.title } : {}),
+                    ...(enableSectionHeaders && section.description
+                        ? { description: section.description }
+                        : {}),
+                },
+                items: section.widgets
+                    .map((widget) => yamlWidgetItemToDeclarative(entities, widget, enableSectionHeaders))
+                    .filter(Boolean),
+            })),
+            configuration: {
+                sections: {
+                    enableHeader: input.enable_section_headers === undefined
+                        ? !!input.sections.some((s) => s.title || s.description)
+                        : input.enable_section_headers,
+                },
+                ...(input.layout_direction ? { direction: input.layout_direction } : {}),
+            },
+        };
+    }
+    if (isVisualizationSwitcherWidget(input)) {
+        const visualizations = input.visualizations
+            .map((vis) => yamlInsightWidgetToDeclarative(entities, vis))
+            .filter((vis) => vis !== null && vis !== undefined);
+        return {
+            ...(input.id ? { localIdentifier: input.id } : {}),
+            type: "visualizationSwitcher",
+            visualizations,
+            description: "",
+            title: "",
+            drills: [],
+            ignoreDashboardFilters: [],
+        };
+    }
+    if (isRichTextWidget(input)) {
+        return {
+            ...(input.id ? { localIdentifier: input.id } : {}),
+            type: "richText",
+            content: input.content,
+            description: "",
+            title: "",
+            drills: [],
+            ignoreDashboardFilters: [],
+        };
+    }
+    if (isInsightWidget(input)) {
+        return yamlInsightWidgetToDeclarative(entities, input);
+    }
+    return undefined;
+}
+function yamlIgnoredDrillDownToDeclarative(entities, visualization, hierarchy) {
+    const target = entities
+        .filter((e) => VisualisationsTypes.includes(e.type))
+        .find((e) => e.id === visualization)?.data;
+    if (!target) {
+        return null;
+    }
+    if (hierarchy.hierarchy) {
+        return {
+            type: "attributeHierarchyReference",
+            attributeHierarchy: hierarchy.hierarchy,
+            attribute: createIdentifier(hierarchy.on),
+        };
+    }
+    if (hierarchy.template) {
+        return {
+            type: "dateHierarchyReference",
+            dateHierarchyTemplate: hierarchy.template,
+            dateDatasetAttribute: createIdentifier(hierarchy.on),
+        };
+    }
+    return null;
+}
+function yamlIgnoredDrillDownsIntersectionsToDeclarative(entities, visualization, intersection) {
+    if (!intersection.attributes || intersection.attributes.length === 0) {
+        return null;
+    }
+    const drillDownReference = yamlIgnoredDrillDownToDeclarative(entities, visualization, intersection.hierarchy);
+    if (!drillDownReference) {
+        return null;
+    }
+    return {
+        ignoredAttributes: intersection.attributes.map((attribute) => attribute),
+        drillDownReference,
+    };
+}
+function yamlWidgetPropertiesToDeclarative(input) {
+    const controls = {};
+    if (input.zoom_data) {
+        controls.zoomInsight = true;
+    }
+    if (Object.keys(controls).length > 0) {
+        return {
+            controls,
+        };
+    }
+    return {};
+}
+export function yamlInteractionToDeclarative(entities, visualisation, input) {
+    const target = entities
+        .filter((e) => VisualisationsTypes.includes(e.type))
+        .find((e) => e.id === visualisation)?.data;
+    if (!target) {
+        return null;
+    }
+    const field = target.query.fields[input.click_on] ?? null;
+    if (!field) {
+        return null;
+    }
+    const origin = isAttributeField(getFullField(field))
+        ? {
+            type: "drillFromAttribute",
+            attribute: createLocalIdentifier(input.click_on),
+        }
+        : {
+            type: "drillFromMeasure",
+            measure: createLocalIdentifier(input.click_on),
+        };
+    const interactionFilters = yamlInteractionFiltersToDeclarative(input, target.query?.filter_by);
+    const ignoredAttrs = input.ignored_intersection_attributes?.length
+        ? { drillIntersectionIgnoredAttributes: input.ignored_intersection_attributes }
+        : {};
+    if (input.open_visualization) {
+        const target = createIdentifier((input.open_visualization ?? ""), {
+            forceType: "visualizationObject",
+        });
+        return {
+            type: "drillToInsight",
+            transition: "pop-up",
+            target,
+            origin,
+            ...interactionFilters.ignoredAttrs,
+            ...interactionFilters.ignoredDashboardFilters,
+            ...interactionFilters.includedSourceInsight,
+            ...interactionFilters.includedSourceMeasure,
+        };
+    }
+    if (input.open_dashboard) {
+        const target = createIdentifier((input.open_dashboard ?? ""), {
+            forceType: "analyticalDashboard",
+        });
+        return {
+            type: "drillToDashboard",
+            transition: "in-place",
+            target,
+            origin,
+            ...(input.open_dashboard_tab ? { targetTabLocalIdentifier: input.open_dashboard_tab } : {}),
+            ...interactionFilters.ignoredAttrs,
+            ...interactionFilters.ignoredDashboardFilters,
+            ...interactionFilters.includedSourceInsight,
+            ...interactionFilters.includedSourceMeasure,
+        };
+    }
+    if (input.open_url && typeof input.open_url === "string") {
+        const url = parseUrlTarget(input.open_url);
+        return {
+            type: "drillToCustomUrl",
+            transition: "new-window",
+            target: {
+                url,
+            },
+            origin,
+            ...ignoredAttrs,
+        };
+    }
+    if (input.open_url && typeof input.open_url === "object") {
+        const url = input.open_url;
+        const displayForm = createIdentifier((url["label"] ?? ""));
+        const hyperlinkDisplayForm = createIdentifier((url["href"] ?? ""));
+        return {
+            type: "drillToAttributeUrl",
+            transition: "new-window",
+            target: {
+                displayForm,
+                hyperlinkDisplayForm,
+            },
+            origin,
+            ...ignoredAttrs,
+        };
+    }
+    return null;
+}
+function yamlInteractionFiltersToDeclarative(input, sourceVisualizationFilters) {
+    const interaction = input;
+    const excluded = interaction.filters?.exclude;
+    const included = interaction.filters?.include;
+    const ignoredAttrs = (excluded?.drilled_datapoint ?? interaction.ignored_intersection_attributes)?.length
+        ? {
+            drillIntersectionIgnoredAttributes: (excluded?.drilled_datapoint ??
+                interaction.ignored_intersection_attributes),
+        }
+        : {};
+    const ignoredDashboardFilters = (excluded?.dashboard_filters ?? interaction.ignored_dashboard_filters)
+        ?.length
+        ? {
+            ignoredDashboardFilters: (excluded?.dashboard_filters ??
+                interaction.ignored_dashboard_filters),
+        }
+        : {};
+    const includedSourceInsight = included?.visualization_filters ?? interaction.included_source_insight_filters;
+    const includedSourceMeasure = included?.metric_filters ?? interaction.included_source_measure_filters;
+    return {
+        ignoredAttrs,
+        ignoredDashboardFilters,
+        includedSourceInsight: includedSourceInsight
+            ? {
+                includedSourceInsightFiltersObjRefs: yamlSourceFiltersToDeclarative(includedSourceInsight, sourceVisualizationFilters),
+            }
+            : {},
+        includedSourceMeasure: includedSourceMeasure
+            ? {
+                includedSourceMeasureFiltersObjRefs: yamlSourceFiltersToDeclarative(includedSourceMeasure, sourceVisualizationFilters),
+            }
+            : {},
+    };
+}
+function yamlSourceFiltersToDeclarative(input, sourceVisualizationFilters) {
+    return input
+        .map((filterId) => sourceInsightFilterIdToDeclarative(filterId, sourceVisualizationFilters))
+        .filter(Boolean);
+}
+function sourceInsightFilterIdToDeclarative(filterId, sourceVisualizationFilters) {
+    const filter = sourceVisualizationFilters?.[filterId];
+    if (!filter) {
+        return null;
+    }
+    if (isAttributeFilter(filter)) {
+        return {
+            type: "attributeFilter",
+            label: createIdentifier(filter.using),
+        };
+    }
+    if (isAbsoluteDateFilter(filter) || isRelativeDateFilter(filter)) {
+        return {
+            type: "dateFilter",
+            dataSet: createIdentifier(filter.using, { forceType: "dataset" }),
+        };
+    }
+    if (isMetricValueFilter(filter)) {
+        return {
+            type: "measureValueFilter",
+            measure: createIdentifier(filter.using, { forceMetric: true }) ??
+                createLocalIdentifier(filter.using),
+        };
+    }
+    if (isRankingFilter(filter)) {
+        return {
+            type: "rankingFilter",
+            measure: createIdentifier(filter.using, { forceMetric: true }) ??
+                createLocalIdentifier(filter.using),
+        };
+    }
+    return null;
+}
+function yamlIgnoredFilterToDeclarative(input) {
+    const ref = parseReferenceObject(input);
+    if (ref?.type === "label") {
+        return {
+            type: "attributeFilterReference",
+            displayForm: createIdentifier(input),
+        };
+    }
+    if (ref?.type === "dataset") {
+        return {
+            type: "dateFilterReference",
+            dataSet: createIdentifier(input),
+        };
+    }
+    return null;
+}
+export function yamlPluginsToDeclarative(plugins) {
+    return plugins?.map((plugin) => yamlPluginToDeclarative(plugin));
+}
+function yamlPluginToDeclarative(input) {
+    if (typeof input === "string") {
+        return {
+            type: "IDashboardPluginLink",
+            plugin: createIdentifier(input, { forceType: "dashboardPlugin" }),
+        };
+    }
+    return {
+        type: "IDashboardPluginLink",
+        plugin: createIdentifier(input.id, { forceType: "dashboardPlugin" }),
+        parameters: serialiseParameters(input.parameters ?? ""),
+    };
+}
+function isFilterGroup(filter) {
+    return (typeof filter === "object" &&
+        filter !== null &&
+        "type" in filter &&
+        filter.type === "filter_group" &&
+        "filters" in filter);
+}
+function flattenFilters(yamlFilters) {
+    if (!yamlFilters) {
+        return {};
+    }
+    const result = {};
+    for (const [key, filter] of Object.entries(yamlFilters)) {
+        if (isFilterGroup(filter)) {
+            // Flatten nested filters from the group
+            const nestedFlat = flattenFilters(filter.filters);
+            Object.assign(result, nestedFlat);
+        }
+        else {
+            result[key] = filter;
+        }
+    }
+    return result;
+}
+export function yamlFilterContextToDeclarative(baseId, yamlFilters) {
+    const dateFilterConfig = {};
+    const dateFilterConfigs = [];
+    const attributeFilterConfigs = [];
+    // Extract filter groups configuration
+    const filterGroupsConfig = extractFilterGroupsConfig(yamlFilters);
+    // Flatten filter groups to get individual filters
+    const flatFilters = flattenFilters(yamlFilters);
+    const allFilters = Object.entries(flatFilters);
+    const attributeFilters = allFilters.filter(([, filter]) => isDashboardAttributeFilter(filter));
+    const dateFilters = allFilters.filter(([, filter]) => isDashboardAbsoluteDateFilter(filter) ||
+        isDashboardRelativeDateFilter(filter) ||
+        isDashboardEmptyDateFilter(filter));
+    const filters = Object.keys(flatFilters)
+        .map((key) => {
+        const filter = flatFilters[key];
+        const isAbsoluteDateFilter = isDashboardAbsoluteDateFilter(filter);
+        const isRelativeDateFilter = isDashboardRelativeDateFilter(filter);
+        if (isAbsoluteDateFilter || isRelativeDateFilter) {
+            const emptyValueHandling = extractDashboardEmptyValueHandling(filter);
+            //others date filters
+            if (filter["date"]) {
+                const dateFilterConf = {
+                    dateDataSet: createIdentifier(filter["date"], {
+                        forceType: "dataset",
+                    }),
+                    config: fillDateFilterConfig(filter),
+                };
+                dateFilterConfigs.push(dateFilterConf);
+                //common date filter
+            }
+            else {
+                fillDateFilterConfig(filter, dateFilterConfig);
+                //special case when common filter is empty, do not add it to filter context, but keep settings
+                if (isDashboardNoopDateFilter(filter)) {
+                    return null;
+                }
+            }
+            return {
+                dateFilter: {
+                    localIdentifier: key,
+                    type: isAbsoluteDateFilter ? "absolute" : "relative",
+                    granularity: convertGranularity(filter["granularity"] ?? "DAY"),
+                    ...(filter["from"] === undefined ? {} : { from: filter["from"] }),
+                    ...(filter["to"] === undefined ? {} : { to: filter["to"] }),
+                    ...(filter["date"]
+                        ? {
+                            dataSet: createIdentifier(filter["date"], {
+                                forceType: "dataset",
+                            }),
+                        }
+                        : {}),
+                    ...(emptyValueHandling ? { emptyValueHandling } : {}),
+                    //attribute
+                },
+            };
+        }
+        if (isDashboardAttributeFilter(filter)) {
+            const state = filter.state;
+            const attributeFilterConfig = {};
+            if (filter.mode && filter.mode !== "active") {
+                attributeFilterConfig.mode = filter.mode;
+            }
+            if (filter.display_as) {
+                attributeFilterConfig.displayAsLabel = createIdentifier(filter.display_as, {
+                    forceType: "label",
+                });
+            }
+            if ((filter.mode && filter.mode !== "active") || filter.display_as) {
+                attributeFilterConfig.localIdentifier = key;
+                attributeFilterConfigs.push(attributeFilterConfig);
+            }
+            const attributeParents = filter.parents?.filter((parent) => {
+                const item = normalizeLocalDateFilter(parent);
+                return attributeFilters.some(([key]) => key === item.using);
+            });
+            const dateParents = filter.parents?.filter((parent) => {
+                const item = normalizeLocalDateFilter(parent);
+                return dateFilters.some(([key]) => key === item.using);
+            });
+            return {
+                attributeFilter: {
+                    displayForm: createIdentifier(filter.using ?? ""),
+                    negativeSelection: !state?.include,
+                    attributeElements: {
+                        uris: (state && (state.exclude ?? state.include)) ?? [],
+                    },
+                    localIdentifier: key,
+                    ...(attributeParents && attributeParents.length > 0
+                        ? {
+                            filterElementsBy: attributeParents.map((parent) => {
+                                return {
+                                    filterLocalIdentifier: parent,
+                                    over: {
+                                        attributes: [],
+                                    },
+                                };
+                            }),
+                        }
+                        : {}),
+                    ...(dateParents && dateParents.length > 0
+                        ? {
+                            filterElementsByDate: dateParents.map((parent) => {
+                                const item = normalizeLocalDateFilter(parent);
+                                return {
+                                    filterLocalIdentifier: item.using,
+                                    isCommonDate: item.common,
+                                };
+                            }),
+                        }
+                        : {}),
+                    ...(filter.metric_filters
+                        ? {
+                            validateElementsBy: filter.metric_filters.map((metricFilter) => createIdentifier(metricFilter)),
+                        }
+                        : {}),
+                    title: filter.title,
+                    selectionMode: filter.multiselect === false ? "single" : "multi",
+                },
+            };
+        }
+        return null;
+    })
+        .filter(Boolean);
+    return {
+        dateFilterConfig: Object.keys(dateFilterConfig).length > 0
+            ? { filterName: "", ...dateFilterConfig }
+            : undefined,
+        attributeFilterConfigs: attributeFilterConfigs.length > 0 ? attributeFilterConfigs : undefined,
+        dateFilterConfigs: dateFilterConfigs.length > 0 ? dateFilterConfigs : undefined,
+        filterGroupsConfig,
+        filterContext: {
+            id: createFilterContextId(baseId),
+            title: "",
+            content: {
+                version: "2",
+                filters,
+            },
+        },
+    };
+}
+function extractFilterGroupsConfig(yamlFilters) {
+    if (!yamlFilters) {
+        return undefined;
+    }
+    const groups = [];
+    for (const [groupId, filter] of Object.entries(yamlFilters)) {
+        if (isFilterGroup(filter)) {
+            const nestedFilters = filter.filters;
+            const filterLocalIdentifiers = nestedFilters ? Object.keys(nestedFilters) : [];
+            groups.push({
+                title: filter.title,
+                localIdentifier: groupId,
+                filters: filterLocalIdentifiers.map((filterLocalIdentifier) => ({
+                    filterLocalIdentifier,
+                })),
+            });
+        }
+    }
+    return groups.length > 0 ? { groups } : undefined;
+}
+function fillDateFilterConfig(filter, config) {
+    const current = config ?? {
+        mode: "active",
+        filterName: "",
+    };
+    if (filter.mode && filter.mode !== "active") {
+        current.mode = filter.mode;
+    }
+    if (filter.title) {
+        current.filterName = filter.title;
+    }
+    return current;
+}
+function useInherit(input) {
+    return input && input !== "inherit" ? input : "";
+}
+function serialiseParameters(params) {
+    try {
+        return JSON.stringify(params);
+    }
+    catch {
+        return params;
+    }
+}
+function normalizeLocalDateFilter(item) {
+    if (typeof item === "object") {
+        return item;
+    }
+    return {
+        using: item,
+        common: true,
+    };
+}
+//# sourceMappingURL=yamlDashboardToDeclarative.js.map