@gooddata/sdk-ui-analytical-designer 0.0.0-stage → 11.65.0-alpha.6

package/esm/utils/api.js

@@ -0,0 +1,549 @@
+// (C) 2007-2026 GoodData Corporation
+import { compact, unionBy, uniqBy } from "lodash-es";
+import { areObjRefsEqual, attributeDisplayFormRef, defFingerprint, filterAttributeElements, filterLocalIdentifier, filterObjRef, getAttributeElementsItems, idRef, insightAttributeFilterConfigs, insightAttributes, insightFilters, insightHasDataDefined, insightMeasures, isAttributeElementsByRef, isAttributeFilterWithSelection, measureFilters, newDefForInsight, newDefForItems, objRefToString, } from "@gooddata/sdk-model";
+import { randomString } from "@gooddata/util";
+import { backend } from "../backend.js";
+import { bearLegacyFunctions } from "../bearLegacyFunctions.js";
+import { isElementUrisSupported } from "../selectors/backend_capabilities_selector.js";
+import { getProjectId } from "../selectors/bootstrap_selector.js";
+import { indexValidElements } from "../services/report_service.js";
+import { getItemCacheState } from "../store/item_cache/item_cache_selectors.js";
+import { isSingleEmptyStringElement } from "./date_filter.js";
+import { displayFormToCacheDisplayForm } from "./displayForms.js";
+import { getRouteParams } from "./location.js";
+import { mergeSortedAlphabeticallyByTitle } from "./merge_sorted_by_title.js";
+export function setupSessionId(xhr, id) {
+    xhr.setRequestHeader("X-GDC-REQUEST", id + randomString(10));
+}
+export function getMetricsEditorUrl(projectId, metricUri, workspacesRef = "projects") {
+    return metricUri
+        ? `/#s=/gdc/${workspacesRef}/${projectId}|objectPage|${metricUri}`
+        : `/#s=/gdc/${workspacesRef}/${projectId}|objectPage|none|metric`;
+}
+export const checkMetricOverrides = (workspaceId, identifiers) => backend.workspace(workspaceId).measures().checkEntityOverrides(identifiers);
+export const exportRawToServer = async (definition, projectId, fileName, customOverrides, options) => {
+    return await backend
+        .workspace(projectId)
+        .dashboards()
+        .exportDashboardToCSVRaw(definition, fileName, customOverrides, options);
+};
+export async function getUserProjectConfigs(projectId) {
+    return backend.workspace(projectId).settings().getSettingsForCurrentUser();
+}
+export async function getUserConfigs() {
+    return backend.currentUser().settings().getSettings();
+}
+export async function getColorPalette(workspaceId) {
+    return backend.workspace(workspaceId).styling().getColorPalette();
+}
+export function getObjectIdFromUri(uri) {
+    return uri.split("/").at(-1);
+}
+async function loadAttributeElementsSelectionForElements(projectId, dfRef, displayAsDfRef, elements) {
+    if (isAttributeElementsByRef(elements)) {
+        const result = await backend
+            .workspace(projectId)
+            .attributes()
+            .elements()
+            .forDisplayForm(dfRef)
+            .withOptions({ elements })
+            .withLimit(elements.uris.length)
+            .query();
+        return result.items;
+    }
+    else {
+        const result = await backend
+            .workspace(projectId)
+            .attributes()
+            .elements()
+            .forDisplayForm(displayAsDfRef)
+            .withOptions({
+            elements,
+            filterByPrimaryLabel: !areObjRefsEqual(dfRef, displayAsDfRef),
+        })
+            .withLimit(elements.values.length)
+            .query();
+        return result.items;
+    }
+}
+async function loadAttributeElementsSelection(projectId, dfRef, displayAsDfRef, elements) {
+    // plain valid elements are needed for "totalElementsCount" which is used mainly in
+    // negative filter selection count ("see metadata.ts -> processVisualizationAttributeFilter")
+    const loaderWithLimit = backend
+        .workspace(projectId)
+        .attributes()
+        .elements()
+        .forDisplayForm(dfRef)
+        .withLimit(545);
+    const [limitResults, uriResults] = await Promise.all([
+        loaderWithLimit.query(),
+        loadAttributeElementsSelectionForElements(projectId, dfRef, displayAsDfRef, elements),
+    ]);
+    const union = unionBy(limitResults.items, uriResults, (element) => element.uri);
+    return {
+        items: union,
+        total: limitResults.totalCount,
+    };
+}
+export function exportReportToServer(projectId, insight) {
+    return bearLegacyFunctions.openAsReport(projectId, insight);
+}
+export async function loadVisualizationClasses(projectId) {
+    return backend.workspace(projectId).insights().getVisualizationClasses({ includeDeprecated: false });
+}
+async function getAttributeElementsNew(projectId, dfRef, displayAsDfRef, elements, loadAttributeElementsSelectionFn = loadAttributeElementsSelection) {
+    return loadAttributeElementsSelectionFn(projectId, dfRef, displayAsDfRef, elements).then((result) => ({
+        ...result,
+        filterItemsRef: dfRef,
+    }));
+}
+// TODO: remove and adapt others to use new format
+function convertDateDatasetToLegacyForm(catalogDateDataset, isAvailable = true) {
+    return {
+        ref: catalogDateDataset.dataSet.ref,
+        title: catalogDateDataset.dataSet.title,
+        summary: catalogDateDataset.dataSet.description,
+        identifier: catalogDateDataset.dataSet.id,
+        uri: catalogDateDataset.dataSet.uri,
+        relevance: catalogDateDataset.relevance,
+        type: catalogDateDataset.type,
+        id: catalogDateDataset.dataSet.id, // TODO duplicate with identifier
+        isAvailable,
+        attributes: catalogDateDataset.dateAttributes.map((dateAttribute) => ({
+            ref: dateAttribute.attribute.ref,
+            granularity: dateAttribute.attribute.id, // TODO why not granularity?
+            dfRef: dateAttribute.defaultDisplayForm.ref,
+            dfIdentifier: dateAttribute.defaultDisplayForm.id,
+            dfUri: dateAttribute.defaultDisplayForm.uri,
+            dateType: dateAttribute.granularity,
+            uri: dateAttribute.attribute.uri,
+            title: dateAttribute.attribute.title,
+            displayForms: dateAttribute.attribute.displayForms.map(displayFormToCacheDisplayForm),
+        })),
+    };
+}
+function isDateDatasetItemAvailable(dateDataset, availableDateDatasets) {
+    return availableDateDatasets.some((item) => item.dataSet.id === dateDataset.dataSet.id);
+}
+/**
+ * Checks if the filter has any elements that need to be loaded.
+ * Returns false for empty filters (no elements selected).
+ */
+function hasElementsToLoad(elements) {
+    if (isAttributeElementsByRef(elements)) {
+        return elements.uris.length > 0;
+    }
+    return elements.values.length > 0;
+}
+async function loadFilterElements(insight, state) {
+    const projectId = getProjectId(state);
+    const filtersConfigs = insightAttributeFilterConfigs(insight);
+    const filtersFromInsight = insightFilters(insight);
+    const measures = insightMeasures(insight);
+    const filtersFromMeasures = measures.flatMap(measureFilters);
+    const allFilters = [...filtersFromInsight, ...filtersFromMeasures];
+    const attributeFilters = allFilters.filter(isAttributeFilterWithSelection);
+    const allFilterConfigs = attributeFilters.flatMap((f) => {
+        const filterDisplayFormRef = filterObjRef(f);
+        const elements = filterAttributeElements(f);
+        const filterConfig = filtersConfigs?.[filterLocalIdentifier(f)];
+        const displayAsLabel = filterConfig?.displayAsLabel;
+        return {
+            dfRef: filterDisplayFormRef,
+            displayAsLabelRef: displayAsLabel || filterDisplayFormRef,
+            elements,
+        };
+    });
+    const elementPromises = allFilterConfigs
+        .filter((fc) => hasElementsToLoad(fc.elements) &&
+        !isSingleEmptyStringElement(getAttributeElementsItems(fc.elements)))
+        .map(({ dfRef, displayAsLabelRef, elements }) => getAttributeElementsNew(projectId, dfRef, displayAsLabelRef, elements, undefined));
+    const validElements = await Promise.all(elementPromises);
+    return indexValidElements(validElements);
+}
+async function fetchDateDatasets(projectId, options = {}) {
+    const loader = backend
+        .workspace(projectId)
+        .catalog()
+        .withOptions({
+        types: ["dateDataset"],
+        excludeTags: options.excludeObjectsWithTags ?? [],
+        includeTags: options.includeObjectsWithTags ?? [],
+        dataset: options.dataSetIdentifier,
+        production: options.production,
+        includeDateGranularities: [
+            "GDC.time.day_in_week",
+            "GDC.time.day_in_month",
+            "GDC.time.day_in_quarter",
+            "GDC.time.day_in_year",
+            "GDC.time.week_in_quarter",
+            "GDC.time.week_in_year",
+            "GDC.time.month_in_quarter",
+            "GDC.time.month_in_year",
+            "GDC.time.quarter_in_year",
+            "GDC.time.fiscal_year",
+            "GDC.time.fiscal_quarter",
+            "GDC.time.fiscal_month",
+        ],
+    });
+    const catalog = await loader.load();
+    const isInsightNonEmpty = options.insight && insightHasDataDefined(options.insight);
+    const areItemsNonEmpty = options.items?.length > 0;
+    const needsToLoadAvailableItems = isInsightNonEmpty || areItemsNonEmpty;
+    if (!needsToLoadAvailableItems) {
+        const allDateDatasets = catalog.dateDatasets();
+        return {
+            allDateDatasets,
+            availableDateDatasets: allDateDatasets,
+        };
+    }
+    let availableLoader = catalog.availableItems();
+    if (isInsightNonEmpty) {
+        // Strip dimensionality from measure value filters when not explicitly included
+        const insightToUse = options.insight;
+        availableLoader = availableLoader.forInsight(insightToUse);
+    }
+    if (areItemsNonEmpty) {
+        availableLoader = availableLoader.forItems(options.items);
+    }
+    const availableCatalog = await availableLoader.load();
+    return {
+        allDateDatasets: availableCatalog.dateDatasets(),
+        availableDateDatasets: availableCatalog.availableDateDatasets(),
+    };
+}
+/**
+ * Creates a fingerprint for date datasets loading that includes all relevant options.
+ */
+function createDateDatasetsFingerprint(projectId, options) {
+    const insightFingerprint = options.insight
+        ? defFingerprint(newDefForInsight(projectId, options.insight))
+        : "no-insight";
+    const itemsFingerprint = options.items?.length
+        ? defFingerprint(newDefForItems(projectId, options.items))
+        : "no-items";
+    const includeTags = options.includeObjectsWithTags?.map(objRefToString).sort().join(",") ?? "";
+    const excludeTags = options.excludeObjectsWithTags?.map(objRefToString).sort().join(",") ?? "";
+    const datasetId = options.dataSetIdentifier ? objRefToString(options.dataSetIdentifier) : "";
+    return `${projectId}|${insightFingerprint}|${itemsFingerprint}|${includeTags}|${excludeTags}|${datasetId}`;
+}
+export const loadDateDatasetsWithCaching = (loadDateDatasetsFn) => {
+    let lastFingerprint;
+    let lastResult;
+    let inFlightPromise;
+    let inFlightFingerprint;
+    return async (projectId, options = {}) => {
+        const fingerprint = createDateDatasetsFingerprint(projectId, options);
+        // Return cached result if fingerprint matches
+        if (lastFingerprint === fingerprint && lastResult) {
+            return lastResult;
+        }
+        // Reuse in-flight request if fingerprint matches
+        if (inFlightFingerprint === fingerprint && inFlightPromise) {
+            return inFlightPromise;
+        }
+        // Start new request
+        inFlightFingerprint = fingerprint;
+        inFlightPromise = loadDateDatasetsFn(projectId, options)
+            .then((result) => {
+            // Only update cache if this is still the current request
+            // This prevents stale results from overwriting newer data when requests complete out of order
+            if (fingerprint === inFlightFingerprint) {
+                lastResult = result;
+                lastFingerprint = fingerprint;
+            }
+            return result;
+        })
+            .catch((e) => {
+            // Only bust cache if this is still the current request
+            // This prevents clearing valid cache from a newer request that completed successfully
+            if (fingerprint === inFlightFingerprint) {
+                lastResult = undefined;
+                lastFingerprint = undefined;
+            }
+            throw e;
+        })
+            .finally(() => {
+            // Clear in-flight tracking when done
+            if (inFlightFingerprint === fingerprint) {
+                inFlightPromise = undefined;
+                inFlightFingerprint = undefined;
+            }
+        });
+        return inFlightPromise;
+    };
+};
+export const loadCachedDateDatasets = loadDateDatasetsWithCaching(loadDateDatasets);
+export async function loadDateDatasets(projectId, options = {}) {
+    const { allDateDatasets, availableDateDatasets } = await fetchDateDatasets(projectId, options);
+    return {
+        available: availableDateDatasets.map((item) => convertDateDatasetToLegacyForm(item)),
+        allItems: allDateDatasets.map((item) => convertDateDatasetToLegacyForm(item, isDateDatasetItemAvailable(item, availableDateDatasets))),
+        unavailable: allDateDatasets.length - availableDateDatasets.length,
+    };
+}
+/**
+ * Loads both insight specific date datasets for a given insight and current dataset,
+ * and completely all date datasets for itemCache.
+ *
+ * Unfortunately, the allDateDatasets from the \{insight,dataset\}-aware response are not the same
+ * as really all date datasets in the project (nor should they be), but we need both of them:
+ * - the \{insight,dataset\}-aware allDateDatasets are needed for correct number of unrelated items hidden.
+ * - the "really" allDateDatasets are needed to make sure itemCache has information even for datasets
+ * that could otherwise be hidden by tag config, dataset or other options.
+ *
+ * @param insight - insight to check item availability for
+ * @param state -
+ */
+async function getDateDatasetsForItemCache(insight, state) {
+    const projectId = getProjectId(state);
+    const { dataset } = getRouteParams(state);
+    const [insightAwareDateDatasets, { allDateDatasets }] = await Promise.all([
+        fetchDateDatasets(projectId, {
+            dataSetIdentifier: dataset && idRef(dataset),
+            insight,
+        }),
+        fetchDateDatasets(projectId),
+    ]);
+    return {
+        insightAwareDateDatasets,
+        allDateDatasets,
+    };
+}
+function catalogDateAttributeToDateAttribute(attribute) {
+    return {
+        dateType: attribute.granularity,
+        dfRef: attribute.defaultDisplayForm.ref,
+        dfIdentifier: attribute.defaultDisplayForm.id,
+        dfIdentifiers: [attribute.defaultDisplayForm.id], // other attr display forms ids...
+        dfUri: attribute.defaultDisplayForm.uri,
+        dfUris: [attribute.defaultDisplayForm.uri], // other attr display forms uris...
+        displayForms: attribute.attribute.displayForms?.map((df) => ({
+            id: df.id,
+            uri: df.uri,
+            ref: df.ref,
+            type: df.displayFormType,
+            title: df.title,
+        })) ?? [],
+        dimensionUri: "", // TODO
+        elementsUri: "", // TODO
+        granularity: attribute.attribute.id, // for some reason, this is not granularity...
+        id: attribute.attribute.id,
+        identifier: attribute.attribute.id,
+        isAvailable: true,
+        summary: attribute.attribute.description,
+        title: attribute.attribute.title,
+        type: "attribute",
+        uri: attribute.attribute.uri,
+        ref: attribute.attribute.ref,
+    };
+}
+/**
+ * Loads valid attributes that can be used for measure value filter dimensionality.
+ * Uses computeValidObjects API to validate attributes against the provided execution items.
+ */
+async function fetchValidDimensionalityAttributes(projectId, options) {
+    const catalogLoader = backend
+        .workspace(projectId)
+        .catalog()
+        .withOptions({
+        types: options.enableComputedAttributes ? ["attribute", "computedAttribute"] : ["attribute"],
+        excludeTags: options.excludeObjectsWithTags ?? [],
+        includeTags: options.includeObjectsWithTags ?? [],
+        dataset: options.dataSetIdentifier,
+        production: options.production,
+    });
+    const catalog = await catalogLoader.load();
+    // Load available attributes for provided execution items (this uses computeValidObjects internally)
+    const availableLoader = catalog.availableItems().withOptions({ items: options.items });
+    const availableCatalog = await availableLoader.load();
+    const availableAttributes = availableCatalog.availableAttributes().map((catalogAttr) => {
+        const dataSet = catalogAttr.dataSet ?? catalogAttr.attribute.dataSet;
+        return {
+            attribute: catalogAttr.attribute,
+            displayFormRef: catalogAttr.defaultDisplayForm.ref,
+            dataSetTitle: dataSet?.title,
+            dataSetRef: dataSet?.ref,
+        };
+    });
+    const availableComputedAttributes = (options.enableComputedAttributes ? availableCatalog.availableComputedAttributes() : []).map((catalogAttr) => {
+        const dataSet = catalogAttr.computedAttribute.dataSet;
+        return {
+            attribute: {
+                ...catalogAttr.computedAttribute,
+                type: "attribute",
+            },
+            displayFormRef: catalogAttr.defaultDisplayForm.ref,
+            dataSetTitle: dataSet?.title,
+            dataSetRef: dataSet?.ref,
+        };
+    });
+    return mergeSortedAlphabeticallyByTitle(availableAttributes, availableComputedAttributes, (item) => item.attribute.title);
+}
+/**
+ * Loads valid dimensionality attributes for a measure value filter.
+ * Returns attributes grouped by their dataset.
+ */
+async function loadValidDimensionalityAttributesUncached(projectId, options) {
+    const attributes = await fetchValidDimensionalityAttributes(projectId, options);
+    // Group attributes by dataset
+    const grouped = new Map();
+    for (const attrInfo of attributes) {
+        const datasetKey = attrInfo.dataSetRef ? objRefToString(attrInfo.dataSetRef) : "__ungrouped__";
+        if (!grouped.has(datasetKey)) {
+            grouped.set(datasetKey, {
+                datasetTitle: attrInfo.dataSetTitle,
+                datasetRef: attrInfo.dataSetRef,
+                attributes: [],
+            });
+        }
+        grouped.get(datasetKey).attributes.push({
+            attribute: attrInfo.attribute,
+            displayFormRef: attrInfo.displayFormRef,
+        });
+    }
+    return grouped;
+}
+/**
+ * Creates a cache key fingerprint for dimensionality attributes loading.
+ * Combines project ID, items fingerprint, and tag configuration.
+ */
+function createDimensionalityFingerprint(projectId, options) {
+    // Create execution definition from items to generate fingerprint
+    const itemsFingerprint = defFingerprint(newDefForItems(projectId, options.items));
+    // Include tag configuration in cache key
+    const includeTags = options.includeObjectsWithTags?.map(objRefToString).sort().join(",") ?? "";
+    const excludeTags = options.excludeObjectsWithTags?.map(objRefToString).sort().join(",") ?? "";
+    const datasetId = options.dataSetIdentifier ? objRefToString(options.dataSetIdentifier) : "";
+    // enableComputedAttributes is deliberately NOT part of the key: feature flags come from
+    // bootstrap and cannot change without a full app reload, so it is constant for the cache's
+    // whole lifetime.
+    return `${projectId}|${itemsFingerprint}|${includeTags}|${excludeTags}|${datasetId}`;
+}
+/**
+ * Creates a cached version of the dimensionality attributes loader.
+ * Handles concurrent requests by reusing in-flight promises.
+ */
+const loadValidDimensionalityAttributesWithCaching = (loadFn) => {
+    let lastFingerprint;
+    let lastResult;
+    let inFlightPromise;
+    let inFlightFingerprint;
+    return async (projectId, options) => {
+        const fingerprint = createDimensionalityFingerprint(projectId, options);
+        // Return cached result if fingerprint matches
+        if (lastFingerprint === fingerprint && lastResult) {
+            return lastResult;
+        }
+        // Reuse in-flight request if fingerprint matches
+        if (inFlightFingerprint === fingerprint && inFlightPromise) {
+            return inFlightPromise;
+        }
+        // Start new request
+        inFlightFingerprint = fingerprint;
+        inFlightPromise = loadFn(projectId, options)
+            .then((result) => {
+            // Only update cache if this is still the current request
+            // This prevents stale results from overwriting newer data when requests complete out of order
+            if (fingerprint === inFlightFingerprint) {
+                lastResult = result;
+                lastFingerprint = fingerprint;
+            }
+            return result;
+        })
+            .catch((e) => {
+            // Only bust cache if this is still the current request
+            // This prevents clearing valid cache from a newer request that completed successfully
+            if (fingerprint === inFlightFingerprint) {
+                lastResult = undefined;
+                lastFingerprint = undefined;
+            }
+            throw e;
+        })
+            .finally(() => {
+            // Clear in-flight tracking when done
+            if (inFlightFingerprint === fingerprint) {
+                inFlightPromise = undefined;
+                inFlightFingerprint = undefined;
+            }
+        });
+        return inFlightPromise;
+    };
+};
+/**
+ * Loads valid dimensionality attributes for a measure value filter.
+ * Results are cached based on fingerprint of provided items and options.
+ */
+export const loadValidDimensionalityAttributes = loadValidDimensionalityAttributesWithCaching(loadValidDimensionalityAttributesUncached);
+export async function getItemCacheItems(insight, state) {
+    const [{ allDateDatasets, insightAwareDateDatasets }, filterItems] = await Promise.all([
+        getDateDatasetsForItemCache(insight, state),
+        loadFilterElements(insight, state),
+    ]);
+    const availableDateAttributes = insightAwareDateDatasets.availableDateDatasets.flatMap((ds) => ds.dateAttributes);
+    const insightAttrs = insightAttributes(insight);
+    const dateAttrMatches = insightAttrs.map((attr) => availableDateAttributes.find(({ defaultDisplayForm }) => areObjRefsEqual(attributeDisplayFormRef(attr), defaultDisplayForm.ref)));
+    const accumulator = {};
+    const dateAttrs = compact(dateAttrMatches).reduce((acc, curr) => {
+        acc[curr.attribute.id] = catalogDateAttributeToDateAttribute(curr);
+        return acc;
+    }, accumulator);
+    // slice-owned subtree — the selector serves the empty cache before it materializes
+    const currentCache = getItemCacheState(state);
+    return {
+        // SHALLOW merge: the loaded date attributes REPLACE an entry of the same key rather than
+        // merging field by field (which is what the slice's own `mergeItemsIntoCache` does,
+        // deliberately differently)
+        itemCache: { ...currentCache, ...dateAttrs },
+        filterItems,
+        availableDateDatasets: {
+            available: insightAwareDateDatasets.availableDateDatasets.map((item) => convertDateDatasetToLegacyForm(item)),
+            unavailable: insightAwareDateDatasets.allDateDatasets.length -
+                insightAwareDateDatasets.availableDateDatasets.length,
+        },
+        allDateDatasets: {
+            available: allDateDatasets.map((item) => convertDateDatasetToLegacyForm(item, isDateDatasetItemAvailable(item, insightAwareDateDatasets.availableDateDatasets))),
+            unavailable: 0,
+        },
+    };
+}
+export async function loadValidElementsData(projectId, dfRef, attributeElements) {
+    const elements = isElementUrisSupported() ? { uris: attributeElements } : { values: attributeElements };
+    const result = await backend
+        .workspace(projectId)
+        .attributes()
+        .elements()
+        .forDisplayForm(dfRef)
+        .withLimit(attributeElements.length)
+        .withOptions({
+        elements,
+    })
+        .query();
+    const { items, totalCount } = result;
+    const selectedElements = uniqBy(items, (item) => item.uri);
+    return {
+        items: selectedElements,
+        totalCount,
+    };
+}
+export async function getAttributeDisplayForms(projectId, objRefs) {
+    return await backend.workspace(projectId).attributes().getAttributeDisplayForms(objRefs);
+}
+export async function getAttributes(projectId, objRefs) {
+    return await backend.workspace(projectId).attributes().getAttributes(objRefs);
+}
+/**
+ * Loads computed attributes by their refs. A computed attribute has no labels, so it cannot be resolved
+ * through the attributes service; it is loaded through its own service. Rejects when any of the refs
+ * does not resolve.
+ */
+export async function getComputedAttributes(projectId, objRefs) {
+    const service = backend.workspace(projectId).computedAttributes();
+    return Promise.all(objRefs.map((ref) => service.getComputedAttribute(ref)));
+}
+export async function getInsightReferences(projectId, insightRef) {
+    return backend.workspace(projectId).insights().getInsightReferencingObjects(insightRef);
+}
+export async function getAnalyticalDashboards(projectId) {
+    return backend.workspace(projectId).dashboards().getDashboards();
+}

package/esm/utils/appHeader.d.ts

@@ -0,0 +1,14 @@
+import { type IHeaderMenuItem } from "@gooddata/sdk-ui-kit";
+/**
+ * Builds the AD help menu with all labels resolved from AD's eagerly-loaded default (en-US) messages.
+ * Synchronous, so the pluggable mount can push a complete, correct menu immediately and avoid a flash
+ * of the host's generic fallback while the localized bundle loads. (LX-2573)
+ */
+export declare const getHelpMenuItems: () => IHeaderMenuItem[];
+/**
+ * Builds the AD help menu with all labels resolved from AD's own translations for the given locale.
+ * Used by the pluggable mount to push help items to the host header: the host renders `item.label`
+ * directly, so it needs no knowledge of AD-specific help-menu strings. (LX-2573)
+ */
+export declare const getTranslatedHelpMenuItemsForLocale: (locale?: string) => Promise<IHeaderMenuItem[]>;
+//# sourceMappingURL=appHeader.d.ts.map

package/esm/utils/appHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appHeader.d.ts","sourceRoot":"","sources":["../../src/utils/appHeader.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,eAAe,EAAqC,MAAM,sBAAsB,CAAC;AA2C/F;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,QAAO,eAAe,EAG9C,CAAC;AAEN;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,YAAmB,MAAM,KAAG,OAAO,CAAC,eAAe,EAAE,CAIpG,CAAC"}

package/esm/utils/appHeader.js

@@ -0,0 +1,55 @@
+// (C) 2022-2026 GoodData Corporation
+import { createIntl, createIntlCache, defineMessage } from "react-intl";
+import { resolveLocale } from "@gooddata/sdk-ui";
+import { generateHeaderStaticHelpMenuItems } from "@gooddata/sdk-ui-kit";
+import { DEFAULT_LANGUAGE, DEFAULT_MESSAGES, resolveMessages } from "./translations.js";
+// AD-specific contextual help links. Keys are intl message IDs resolved from AD's own translation
+// bundle — the host shell knows nothing about these strings.
+const contextualHelpMenuItems = [
+    {
+        key: defineMessage({ id: "gs.header.helpMenu.firstSteps" }).id,
+        href: "https://www.gooddata.com/developers/cloud-native/doc/cloud/create-visualizations/analytical-designer/",
+        target: "_blank",
+    },
+    {
+        key: defineMessage({ id: "gs.header.helpMenu.visualizing" }).id,
+        href: "https://www.gooddata.com/developers/cloud-native/doc/cloud/create-visualizations/visualization-types/",
+        target: "_blank",
+    },
+    {
+        key: defineMessage({ id: "gs.header.helpMenu.sorting" }).id,
+        href: "https://www.gooddata.com/developers/cloud-native/doc/cloud/create-visualizations/manage-visualizations/",
+        target: "_blank",
+    },
+    {
+        key: defineMessage({ id: "gs.header.helpMenu.embedding" }).id,
+        href: "https://www.gooddata.com/developers/cloud-native/doc/cloud/embed-visualizations/iframes/#embed-the-analytical-designer",
+        target: "_blank",
+        className: "gd-menu-item-divider",
+    },
+];
+const staticHelpMenuItems = generateHeaderStaticHelpMenuItems();
+const intlCache = createIntlCache();
+// Resolves the full menu (contextual + static) to label-bearing items so the host renders the whole
+// dropdown in a single, locale-consistent language — static keys are not left for the host intl to
+// resolve, which would flip them to the host locale independently and briefly mix languages.
+const buildHelpMenuItems = (intl) => [...contextualHelpMenuItems, ...staticHelpMenuItems].map((item) => ({
+    ...item,
+    label: intl.formatMessage({ id: item.key }),
+}));
+/**
+ * Builds the AD help menu with all labels resolved from AD's eagerly-loaded default (en-US) messages.
+ * Synchronous, so the pluggable mount can push a complete, correct menu immediately and avoid a flash
+ * of the host's generic fallback while the localized bundle loads. (LX-2573)
+ */
+export const getHelpMenuItems = () => buildHelpMenuItems(createIntl({ locale: DEFAULT_LANGUAGE, messages: DEFAULT_MESSAGES[DEFAULT_LANGUAGE] }, intlCache));
+/**
+ * Builds the AD help menu with all labels resolved from AD's own translations for the given locale.
+ * Used by the pluggable mount to push help items to the host header: the host renders `item.label`
+ * directly, so it needs no knowledge of AD-specific help-menu strings. (LX-2573)
+ */
+export const getTranslatedHelpMenuItemsForLocale = async (locale) => {
+    const resolvedLocale = resolveLocale(locale ?? DEFAULT_LANGUAGE);
+    const messages = await resolveMessages(resolvedLocale);
+    return buildHelpMenuItems(createIntl({ locale: resolvedLocale, messages }, intlCache));
+};

package/esm/utils/base.d.ts

@@ -0,0 +1,9 @@
+export interface IShortenTextOptions {
+    maxLength?: number;
+}
+export declare function shortenText(value: string, options?: IShortenTextOptions): string;
+/**
+ * Generates pseudo-random string.
+ */
+export declare function randomString(len: number): string;
+//# sourceMappingURL=base.d.ts.map

package/esm/utils/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/utils/base.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAYpF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOhD"}

package/esm/utils/base.js

@@ -0,0 +1,22 @@
+// (C) 2007-2026 GoodData Corporation
+export function shortenText(value, options = {}) {
+    const maxLength = options.maxLength;
+    if (maxLength < 1) {
+        return "";
+    }
+    if (value && maxLength && value.length > maxLength) {
+        return `${value.substr(0, maxLength - 1)}…`;
+    }
+    return value;
+}
+/**
+ * Generates pseudo-random string.
+ */
+export function randomString(len) {
+    let text = "";
+    const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (let i = 0; i < len; i += 1) {
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+}

package/esm/utils/browser_detect.d.ts

@@ -0,0 +1,2 @@
+export declare function isMobile(): boolean;
+//# sourceMappingURL=browser_detect.d.ts.map

package/esm/utils/browser_detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser_detect.d.ts","sourceRoot":"","sources":["../../src/utils/browser_detect.ts"],"names":[],"mappings":"AAIA,wBAAgB,QAAQ,YAEvB"}

package/esm/utils/browser_detect.js

@@ -0,0 +1,5 @@
+// (C) 2007-2026 GoodData Corporation
+import * as JqBrowser from "jquery.browser";
+export function isMobile() {
+    return !JqBrowser.desktop;
+}