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

package/esm/backend.js

@@ -0,0 +1,122 @@
+// (C) 2020-2026 GoodData Corporation
+import { RecommendedCachingConfiguration, withCaching, withCustomWorkspaceSettings, withEventing, } from "@gooddata/sdk-backend-base";
+import { ContextDeferredAuthProvider, TigerJwtAuthProvider, TigerTokenAuthProvider, tigerFactory, } from "@gooddata/sdk-backend-tiger";
+import { IS_DEBUG } from "./buildParams.js";
+import { emitApiTokenIsAboutToExpire } from "./postMessageApi/outgoing/set_api_token_events.js";
+import { withSemanticCfSimulation } from "./semanticCfSimulation.js";
+import { createNotAuthenticatedHandler } from "./tigerNotAuthenticatedHandler.js";
+const hasWindow = typeof window !== "undefined";
+const wrapWithCustomSettings = (backend) => {
+    if (hasWindow && window["customWorkspaceSettings"]) {
+        const settingsConfig = {
+            commonSettingsWrapper: (originalSettings) => {
+                return {
+                    ...originalSettings,
+                    ...window["customWorkspaceSettings"],
+                };
+            },
+        };
+        return withCustomWorkspaceSettings(backend, settingsConfig);
+    }
+    return backend;
+};
+const wrapWithSemanticCfSimulation = (backend) => {
+    if (IS_DEBUG && hasWindow && window["semanticCfSimConfig"]) {
+        return withSemanticCfSimulation(backend, window["semanticCfSimConfig"]);
+    }
+    return backend;
+};
+export const isValidApiTokenType = (type) => type === undefined || type === "gooddata" || type === "jwt";
+// reference to a callback that can update token in existing JWT analytical backend auth provider instance
+// without necessity to exchange the instance for a new one
+export let setJwtHandler = undefined;
+// reference to a callback that can update token in existing Tiger API token analytical backend auth provider
+// instance without necessity to exchange the instance for a new one
+export let setApiTokenHandler = undefined;
+export const jwtIsAboutToExpire = (setJwt) => {
+    setJwtHandler = setJwt;
+    emitApiTokenIsAboutToExpire();
+};
+const getBackendImplementation = (apiTokenConfiguration, externalProviderId) => {
+    const backend = tigerFactory(undefined, {
+        packageName: "@gooddata/sdk-ui-analytical-designer",
+        packageVersion: hasWindow && typeof window.COMMITHASH === "string" ? window.COMMITHASH : "dev",
+    });
+    const { apiToken, apiTokenType, secondsBeforeTokenExpirationToCallReminder } = apiTokenConfiguration;
+    if (apiToken && apiTokenType === "gooddata") {
+        /*
+         * Authentication using Tiger API Token is the only viable way at the moment because Tiger
+         * cross-origin dev support is flaky.
+         */
+        // oxlint-disable-next-line eslint-js/no-console
+        console.log("Using Tiger API Token for authentication");
+        const notAuthenticatedHandler = createNotAuthenticatedHandler();
+        const tigerTokenAuthProvider = new TigerTokenAuthProvider(apiToken, notAuthenticatedHandler);
+        // Store the reference to Tiger API Token update callback (used by postMessage API saga).
+        setApiTokenHandler = tigerTokenAuthProvider.updateApiToken;
+        return wrapWithCustomSettings(backend.withAuthentication(tigerTokenAuthProvider));
+    }
+    else if (apiToken && apiTokenType === "jwt") {
+        // oxlint-disable-next-line eslint-js/no-console
+        console.log("Using JWT for authentication");
+        const notAuthenticatedHandler = createNotAuthenticatedHandler();
+        const jwtAuthProvider = new TigerJwtAuthProvider(apiToken, notAuthenticatedHandler, jwtIsAboutToExpire, secondsBeforeTokenExpirationToCallReminder);
+        // Store the reference to JWT update callback (used by postMessage API saga).
+        setJwtHandler = jwtAuthProvider.updateJwt;
+        return wrapWithCustomSettings(backend.withAuthentication(jwtAuthProvider));
+    }
+    const handler = createNotAuthenticatedHandler(externalProviderId);
+    return wrapWithCustomSettings(backend.withAuthentication(new ContextDeferredAuthProvider(handler)));
+};
+export let clearCache = () => { };
+export let resetCatalogs = () => { };
+export let explainExecDef;
+const withExplainEventing = (backend) => withEventing(backend, {
+    beforeExecute: (execDefinition) => {
+        explainExecDef = execDefinition;
+    },
+});
+const decorateBackend = (backend) => {
+    return withExplainEventing(wrapWithSemanticCfSimulation(withCaching(backend, {
+        ...RecommendedCachingConfiguration,
+        onCacheReady: (callbacks) => {
+            clearCache = callbacks.resetAll;
+            resetCatalogs = callbacks.resetCatalogs;
+        },
+    })));
+};
+const decorateWithNoAccessProxy = (backend) => new Proxy(backend, {
+    get(target, prop, receiver) {
+        // capabilities are OK to use, these are static — tiger is the only backend
+        // and will not change when backend is re-initiated with new API token
+        if (prop === "capabilities") {
+            return Reflect.get(target, prop, receiver);
+        }
+        throw new Error("Backend API cannot be used as it was not yet initialized!");
+    },
+});
+// Optional compile-time global with a safe default: this file evaluates it at module scope, so
+// without the guard every consumer bundling the runtime would have to DefinePlugin it or crash on
+// chunk load. Builds that define it (the standalone/iframe AD app) fold this to the defined value.
+const DEFAULT_TIGER_API_TOKEN = typeof TIGER_API_TOKEN === "undefined" ? undefined : TIGER_API_TOKEN;
+export let backend = decorateWithNoAccessProxy(decorateBackend(getBackendImplementation({ apiToken: DEFAULT_TIGER_API_TOKEN, apiTokenType: "gooddata" })));
+export const reinitializeBackend = (apiToken = { apiToken: DEFAULT_TIGER_API_TOKEN, apiTokenType: "gooddata" }, externalProviderId) => {
+    backend = decorateBackend(getBackendImplementation(apiToken, externalProviderId));
+    isHostBackendAdopted = false;
+};
+export let isHostBackendAdopted = false;
+/**
+ * Makes AD run against the host's backend instance instead of creating its own — the
+ * hosted-component counterpart of reinitializeBackend. The host's auth provider owns
+ * authentication and token renewal (there is no AD-side provider to update, so the SetApiToken
+ * handlers are cleared) and the host's cache is shared: AD's cache-invalidation refs are wired to
+ * the host's callbacks, so e.g. a metric edit in AD also drops the host's stale executions.
+ */
+export const adoptHostBackend = (host) => {
+    backend = withExplainEventing(wrapWithSemanticCfSimulation(host.instance));
+    clearCache = host.resetAllCaches ?? (() => { });
+    resetCatalogs = host.resetCatalogs ?? (() => { });
+    setApiTokenHandler = undefined;
+    setJwtHandler = undefined;
+    isHostBackendAdopted = true;
+};

package/esm/bearLegacyFunctions.d.ts

@@ -0,0 +1,22 @@
+import { type IDrillableItemsCommandBody } from "@gooddata/sdk-embedding";
+import { type IInsight } from "@gooddata/sdk-model";
+import { type IBearBootstrap } from "./typings/bear/bearTypes.js";
+export type BearLegacyFunctions = {
+    openAsReport?(workspace: string, insight: IInsight): Promise<string>;
+    getBootstrapResource?(options: {
+        projectId?: string;
+        loadAnalyticalDashboards?: boolean;
+    }): Promise<IBearBootstrap>;
+    sanitizeDrillingActivationPostMessageData?(workspace: string, postMessageData: IDrillableItemsCommandBody): Promise<IDrillableItemsCommandBody>;
+};
+declare class BearLegacyFunctionsProxy implements BearLegacyFunctions {
+    private legacyFunctionImpl;
+    private static getErrorMessage;
+    private static printMissingImplWarning;
+    getBootstrapResource: BearLegacyFunctions["getBootstrapResource"];
+    openAsReport: BearLegacyFunctions["openAsReport"];
+    sanitizeDrillingActivationPostMessageData: BearLegacyFunctions["sanitizeDrillingActivationPostMessageData"];
+}
+export declare const bearLegacyFunctions: BearLegacyFunctionsProxy;
+export {};
+//# sourceMappingURL=bearLegacyFunctions.d.ts.map

package/esm/bearLegacyFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bearLegacyFunctions.d.ts","sourceRoot":"","sources":["../src/bearLegacyFunctions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,YAAY,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,oBAAoB,CAAC,CAAC,OAAO,EAAE;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,wBAAwB,CAAC,EAAE,OAAO,CAAC;KACtC,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC5B,yCAAyC,CAAC,CACtC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,0BAA0B,GAC5C,OAAO,CAAC,0BAA0B,CAAC,CAAC;CAC1C,CAAC;AAIF,cAAM,wBAAyB,YAAW,mBAAmB;IACzD,OAAO,CAAC,kBAAkB,CAA2B;IAErD,OAAO,CAAC,MAAM,CAAC,eAAe,CACkI;IAEhK,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAIpC;IAEK,oBAAoB,EAAE,mBAAmB,CAAC,sBAAsB,CAAC,CAMtE;IAEK,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAMtD;IAEK,yCAAyC,EAAE,mBAAmB,CAAC,2CAA2C,CAAC,CAU5G;CACT;AAED,eAAO,MAAM,mBAAmB,0BAAiC,CAAC"}

package/esm/bearLegacyFunctions.js

@@ -0,0 +1,35 @@
+// (C) 2020-2026 GoodData Corporation
+import { IS_DEBUG } from "./buildParams.js";
+// This makes sure that calls to non-essential legacy functions from incompatible backend instances do not fail.
+// Any warning this produces should be taken care of, though, as there is likely some error in the calling logic.
+class BearLegacyFunctionsProxy {
+    legacyFunctionImpl = {};
+    static getErrorMessage = (name) => `Trying to call the ${name} bear legacy function, but no implementation of it is available. Please make sure you are running on a bear-compatible backend.`;
+    static printMissingImplWarning = (name) => {
+        if (IS_DEBUG) {
+            console.warn(BearLegacyFunctionsProxy.getErrorMessage(name));
+        }
+    };
+    getBootstrapResource = (...params) => {
+        if (!this.legacyFunctionImpl.getBootstrapResource) {
+            // this is unrecoverable, there is no sensible default to return here
+            throw new Error(BearLegacyFunctionsProxy.getErrorMessage("getBootstrapResource"));
+        }
+        return this.legacyFunctionImpl.getBootstrapResource(...params);
+    };
+    openAsReport = (...params) => {
+        if (!this.legacyFunctionImpl.openAsReport) {
+            BearLegacyFunctionsProxy.printMissingImplWarning("openAsReport");
+            return Promise.resolve("");
+        }
+        return this.legacyFunctionImpl.openAsReport(...params);
+    };
+    sanitizeDrillingActivationPostMessageData = (workspace, postMessageData) => {
+        if (!this.legacyFunctionImpl.sanitizeDrillingActivationPostMessageData) {
+            BearLegacyFunctionsProxy.printMissingImplWarning("sanitizeDrillingActivationPostMessageData");
+            return Promise.resolve(postMessageData);
+        }
+        return this.legacyFunctionImpl.sanitizeDrillingActivationPostMessageData(workspace, postMessageData);
+    };
+}
+export const bearLegacyFunctions = new BearLegacyFunctionsProxy();

package/esm/buildParams.d.ts

@@ -0,0 +1,4 @@
+export declare const IS_DEBUG: boolean;
+export declare const IS_TESTING: boolean;
+export declare const isReadOnlyMode: () => boolean;
+//# sourceMappingURL=buildParams.d.ts.map

package/esm/buildParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildParams.d.ts","sourceRoot":"","sources":["../src/buildParams.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,EAAE,OAAsD,CAAC;AAC9E,eAAO,MAAM,UAAU,EAAE,OAA0D,CAAC;AAGpF,eAAO,MAAM,cAAc,eAAyB,CAAC"}

package/esm/buildParams.js

@@ -0,0 +1,7 @@
+// (C) 2020-2026 GoodData Corporation
+// A consumer that does not define these identifiers gets the production defaults. Builds that
+// define them fold the typeof checks away.
+export const IS_DEBUG = typeof DEBUG === "undefined" ? false : DEBUG;
+export const IS_TESTING = typeof TESTING === "undefined" ? false : TESTING;
+const IS_READONLY_MODE = typeof READONLY_MODE === "undefined" ? false : READONLY_MODE === true;
+export const isReadOnlyMode = () => IS_READONLY_MODE;

package/esm/components/AttributeFilter/AttributeFilter.d.ts

@@ -0,0 +1,3 @@
+import { type IAttributeFilterProps } from "./types.js";
+export declare function AttributeFilter(props: IAttributeFilterProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AttributeFilter.d.ts.map

package/esm/components/AttributeFilter/AttributeFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeFilter.d.ts","sourceRoot":"","sources":["../../../src/components/AttributeFilter/AttributeFilter.tsx"],"names":[],"mappings":"AA2BA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAuBxD,wBAAgB,eAAe,CAAC,KAAK,EAAE,qBAAqB,2CA4D3D"}

package/esm/components/AttributeFilter/AttributeFilter.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { useIntl } from "react-intl";
+import { useSelector } from "react-redux";
+import { filterAttributeElements, filterLocalIdentifier, filterObjRef, isAttributeElementsByValue, isAttributeFilterWithSelection, isPositiveAttributeFilter, newNegativeAttributeFilter, newPositiveAttributeFilter, } from "@gooddata/sdk-model";
+import { AttributeFilterButton } from "@gooddata/sdk-ui-filters";
+import { isElementUrisSupported } from "../../selectors/backend_capabilities_selector.js";
+import { getSeparators } from "../../selectors/bootstrap_selector.js";
+import { getFeatureFlags } from "../../selectors/feature_flag_selector.js";
+import { useAttributeFilterCustomizations } from "./customization/useAttributeFilterCustomizations.js";
+import { withElementIdClassName } from "./customization/withElementIdClassName.js";
+// In analytical designer, filter is always "uri" based.
+// In the past, we were relying on the fact, that tiger/panther does not support multiple labels and uri was always equal to the title.
+// This is not correct anymore, and all filters in panther and tiger are saved as values, so we need to send them as values also to AttributeFilter.
+function convertAttributeFilterElementsUrisToValues(filter) {
+    // Text-mode filters (arbitrary, match, …) have no element list — skip the conversion
+    if (!isAttributeFilterWithSelection(filter)) {
+        return filter;
+    }
+    const elements = filterAttributeElements(filter);
+    if (isAttributeElementsByValue(elements)) {
+        return filter;
+    }
+    const convertedElements = { values: elements.uris };
+    return isPositiveAttributeFilter(filter)
+        ? newPositiveAttributeFilter(filterObjRef(filter), convertedElements, filterLocalIdentifier(filter))
+        : newNegativeAttributeFilter(filterObjRef(filter), convertedElements, filterLocalIdentifier(filter));
+}
+export function AttributeFilter(props) {
+    const settings = useSelector(getFeatureFlags);
+    const separators = useSelector(getSeparators);
+    const intl = useIntl();
+    const { availableSelectionTypes } = props;
+    const menuConfig = useMemo(() => (availableSelectionTypes ? { availableSelectionTypes } : undefined), [availableSelectionTypes]);
+    const { backend, workspace, filter, displayAsDisplayForm, onApplyCallback, onChangeCallback, CustomStatusBarComponent, CustomDropdownButton, CustomDropdownBody, CustomElementsSearchBarComponent, CustomElementsDropdownActionsComponent, } = useAttributeFilterCustomizations({ ...props, settings });
+    const filterToUse = useMemo(() => {
+        if (isElementUrisSupported()) {
+            return filter;
+        }
+        return convertAttributeFilterElementsUrisToValues(filter);
+    }, [filter]);
+    const LoadingComponent = useCallback(({ onClick, isOpen }) => {
+        return _jsx(CustomDropdownButton, { onClick: onClick, isOpen: isOpen, isLoading: true });
+    }, [CustomDropdownButton]);
+    return (_jsx(AttributeFilterButton, { backend: backend, workspace: workspace, separators: separators, filter: filterToUse, displayAsLabel: displayAsDisplayForm, onApply: onApplyCallback, onChange: onChangeCallback, StatusBarComponent: CustomStatusBarComponent, DropdownButtonComponent: CustomDropdownButton, DropdownBodyComponent: CustomDropdownBody, ElementsSearchBarComponent: CustomElementsSearchBarComponent, ElementsSelectItemComponent: withElementIdClassName, DropdownActionsComponent: CustomElementsDropdownActionsComponent, LoadingComponent: LoadingComponent, locale: intl.locale, menuConfig: menuConfig }));
+}

package/esm/components/AttributeFilter/components/AdditionalDateAttributeButton.d.ts

@@ -0,0 +1,6 @@
+import { type IAttributeFilterDropdownButtonProps } from "@gooddata/sdk-ui-filters";
+/**
+ * @internal
+ */
+export declare function AdditionalDateAttributeButton({ isOpen, subtitle, selectedItemsCount, onClick, isLoading, isFiltering, }: IAttributeFilterDropdownButtonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AdditionalDateAttributeButton.d.ts.map

package/esm/components/AttributeFilter/components/AdditionalDateAttributeButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdditionalDateAttributeButton.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/components/AdditionalDateAttributeButton.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,0BAA0B,CAAC;AAGpF;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,EAC1C,MAAM,EACN,QAAQ,EACR,kBAAkB,EAClB,OAAO,EACP,SAAS,EACT,WAAW,GACd,EAAE,mCAAmC,2CA6BrC"}

package/esm/components/AttributeFilter/components/AdditionalDateAttributeButton.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2022-2026 GoodData Corporation
+import classNames from "classnames";
+import { useIntl } from "react-intl";
+import { FilterLabel } from "@gooddata/sdk-ui-kit";
+/**
+ * @internal
+ */
+export function AdditionalDateAttributeButton({ isOpen, subtitle, selectedItemsCount, onClick, isLoading, isFiltering, }) {
+    const intl = useIntl();
+    let buttonTitle = subtitle;
+    if (isLoading || isFiltering) {
+        buttonTitle = intl.formatMessage({ id: "loading" });
+    }
+    const buttonClassNames = classNames("adi-additional-date-attribute-dropdown-button", "gd-button-primary", "gd-button-small", "button-dropdown", "dropdown-button", "gd-icon-right", { "is-dropdown-open": isOpen }, { "is-active": isOpen }, { "gd-icon-navigateup": isOpen }, { "gd-icon-navigatedown": !isOpen });
+    const selectionSize = selectedItemsCount === 0 ? undefined : selectedItemsCount;
+    return (_jsx("button", { tabIndex: -1, className: buttonClassNames, onClick: onClick, children: _jsx(FilterLabel, { title: buttonTitle, selectionSize: selectionSize }) }));
+}

package/esm/components/AttributeFilter/components/AdditionalDateAttributeDropdownBody.d.ts

@@ -0,0 +1,3 @@
+import { type IAttributeFilterDropdownBodyProps } from "@gooddata/sdk-ui-filters";
+export declare function AdditionalDateAttributeDropdownBody(props: IAttributeFilterDropdownBodyProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AdditionalDateAttributeDropdownBody.d.ts.map

package/esm/components/AttributeFilter/components/AdditionalDateAttributeDropdownBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdditionalDateAttributeDropdownBody.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/components/AdditionalDateAttributeDropdownBody.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,iCAAiC,EACzC,MAAM,0BAA0B,CAAC;AAIlC,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,iCAAiC,2CAE3F"}

package/esm/components/AttributeFilter/components/AdditionalDateAttributeDropdownBody.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { AttributeFilterDropdownBody, } from "@gooddata/sdk-ui-filters";
+import { DATE_ATTRIBUTE_DROPDOWN_WIDTH } from "../constants.js";
+export function AdditionalDateAttributeDropdownBody(props) {
+    return _jsx(AttributeFilterDropdownBody, { ...props, width: DATE_ATTRIBUTE_DROPDOWN_WIDTH });
+}

package/esm/components/AttributeFilter/components/AdditionalDateElementsSearchBarComponent.d.ts

@@ -0,0 +1,3 @@
+import { EmptyElementsSearchBar } from "@gooddata/sdk-ui-filters";
+export declare const AdditionalDateElementsSearchBarComponent: typeof EmptyElementsSearchBar;
+//# sourceMappingURL=AdditionalDateElementsSearchBarComponent.d.ts.map

package/esm/components/AttributeFilter/components/AdditionalDateElementsSearchBarComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdditionalDateElementsSearchBarComponent.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/components/AdditionalDateElementsSearchBarComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,eAAO,MAAM,wCAAwC,+BAAyB,CAAC"}

package/esm/components/AttributeFilter/components/AdditionalDateElementsSearchBarComponent.js

@@ -0,0 +1,3 @@
+// (C) 2007-2026 GoodData Corporation
+import { EmptyElementsSearchBar } from "@gooddata/sdk-ui-filters";
+export const AdditionalDateElementsSearchBarComponent = EmptyElementsSearchBar;

package/esm/components/AttributeFilter/components/AttributeDropdownBody.d.ts

@@ -0,0 +1,3 @@
+import { type IAttributeFilterDropdownBodyProps } from "@gooddata/sdk-ui-filters";
+export declare function AttributeDropdownBody(props: IAttributeFilterDropdownBodyProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AttributeDropdownBody.d.ts.map

package/esm/components/AttributeFilter/components/AttributeDropdownBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeDropdownBody.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/components/AttributeDropdownBody.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,iCAAiC,EACzC,MAAM,0BAA0B,CAAC;AAIlC,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,iCAAiC,2CAE7E"}

package/esm/components/AttributeFilter/components/AttributeDropdownBody.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { AttributeFilterDropdownBody, } from "@gooddata/sdk-ui-filters";
+import { ATTRIBUTE_DROPDOWN_WIDTH } from "../constants.js";
+export function AttributeDropdownBody(props) {
+    return _jsx(AttributeFilterDropdownBody, { ...props, width: ATTRIBUTE_DROPDOWN_WIDTH });
+}

package/esm/components/AttributeFilter/components/AttributeFilterDragItem.d.ts

@@ -0,0 +1,13 @@
+export interface IAttributeFilterDragItemOwnProps {
+    filterLocalIdentifier: string;
+}
+export interface IAttributeFilterDragItemStateProps {
+    filterTitle: string | null;
+}
+export type IAttributeFilterDragItemProps = IAttributeFilterDragItemOwnProps & IAttributeFilterDragItemStateProps;
+export declare const AttributeFilterDragItem: import("react-redux").ConnectedComponent<({ filterTitle }: IAttributeFilterDragItemProps) => import("react/jsx-runtime").JSX.Element, {
+    context?: import("react").Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null>;
+    store?: import("redux").Store;
+    filterLocalIdentifier: string;
+}>;
+//# sourceMappingURL=AttributeFilterDragItem.d.ts.map

package/esm/components/AttributeFilter/components/AttributeFilterDragItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeFilterDragItem.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/components/AttributeFilterDragItem.tsx"],"names":[],"mappings":"AAiBA,MAAM,WAAW,gCAAgC;IAC7C,qBAAqB,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,kCAAkC;IAC/C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,MAAM,6BAA6B,GAAG,gCAAgC,GACxE,kCAAkC,CAAC;AAQvC,eAAO,MAAM,uBAAuB,6DAKqC,6BAA6B;;;2BArB3E,MAAM;EAsD/B,CAAC"}

package/esm/components/AttributeFilter/components/AttributeFilterDragItem.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import classNames from "classnames";
+import { connect } from "react-redux";
+import { createSelector, createStructuredSelector } from "reselect";
+import { DecoratedMetricAttributeFilter, createDecoratedMetricAttributeFilter, } from "../../../models/decorated_metric_attribute_filter.js";
+import { getItemCache } from "../../../selectors/item_cache_selector.js";
+import { getBucketsMeta } from "../../../services/buckets_service.js";
+import { getFilterItems } from "../../../store/filter_bar/filter_bar_selector.js";
+import { FilterBar } from "../../../store/filter_bar/filter_bar_types.js";
+const makeMapStateToProps = () => {
+    return createStructuredSelector({
+        filterTitle: createGetAttributeFilterProp(),
+    });
+};
+export const AttributeFilterDragItem = connect(makeMapStateToProps)(function AttributeFilterDragItem({ filterTitle }) {
+    const buttonClassNames = classNames("adi-filter-button", "adi-filter-button-hover", "adi-attr-filter-button", "s-filter-drag-item", "s-filter-button", "dropdown-button", "toggle-menu", "gd-button", "button-dropdown", "gd-icon-right");
+    const buttonTitleClassNames = classNames("adi-filter-title", `s-${filterTitle}`, "s-attribute-filter-button-title", "adi-filter-selection", "s-global-attribute-filter-title");
+    return (_jsx("div", { className: buttonClassNames, children: _jsx("span", { className: "gd-button-text", children: _jsx("div", { children: _jsx("div", { className: buttonTitleClassNames, children: _jsx("span", { className: "shortened is-whole", children: filterTitle }) }) }) }) }));
+});
+const getFilterLocalIdentifier = (_, props) => props.filterLocalIdentifier;
+const getAttributeFilterItem = createSelector(getFilterItems, getFilterLocalIdentifier, (filterItems, filterLocalIdentifier) => filterItems
+    .filter(FilterBar.isAttributeFilter)
+    .find((item) => item.localIdentifier === filterLocalIdentifier));
+const createGetAttributeFilterProp = () => {
+    return createSelector(getAttributeFilterItem, getItemCache, getBucketsMeta, (attributeFilterState, itemCache, bucketsMeta) => {
+        const attributeFilter = attributeFilterState;
+        if (!attributeFilter) {
+            // dnd react is re-rendering AttributeFilterItem after filter is removed from state
+            return null;
+        }
+        const oldFilterDefinition = {
+            allElements: [],
+            attribute: attributeFilter.cacheItemIdentifier,
+            displayFormRef: attributeFilter.displayFormRef,
+            ...attributeFilter.filterConfig,
+        };
+        const decoratedFilter = createDecoratedMetricAttributeFilter(oldFilterDefinition, itemCache, bucketsMeta);
+        return DecoratedMetricAttributeFilter.getAttributeTitle(decoratedFilter);
+    });
+};

package/esm/components/AttributeFilter/components/MetricAttributeFilterButton.d.ts

@@ -0,0 +1,10 @@
+import { type IAttributeFilterDropdownButtonProps } from "@gooddata/sdk-ui-filters";
+export declare function MetricAttributeFilterButtonWithClassName(className: string): (props: IAttributeFilterDropdownButtonProps) => import("react/jsx-runtime").JSX.Element;
+export interface IMetricAttributeFilterButtonProps extends IAttributeFilterDropdownButtonProps {
+    className: string;
+}
+/**
+ * @internal
+ */
+export declare function MetricAttributeFilterButton({ isOpen, subtitle, title, selectedItemsCount, onClick, isLoading, isFiltering, className, }: IMetricAttributeFilterButtonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MetricAttributeFilterButton.d.ts.map

package/esm/components/AttributeFilter/components/MetricAttributeFilterButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricAttributeFilterButton.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/components/MetricAttributeFilterButton.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,0BAA0B,CAAC;AAGpF,wBAAgB,wCAAwC,CAAC,SAAS,EAAE,MAAM,WAC5C,mCAAmC,6CAKhE;AAED,MAAM,WAAW,iCAAkC,SAAQ,mCAAmC;IAC1F,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,EACxC,MAAM,EACN,QAAQ,EACR,KAAK,EACL,kBAAkB,EAClB,OAAO,EACP,SAAS,EACT,WAAW,EACX,SAAS,GACZ,EAAE,iCAAiC,2CAkCnC"}

package/esm/components/AttributeFilter/components/MetricAttributeFilterButton.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2022-2026 GoodData Corporation
+import cx from "classnames";
+import { useIntl } from "react-intl";
+import { FilterLabel } from "@gooddata/sdk-ui-kit";
+export function MetricAttributeFilterButtonWithClassName(className) {
+    function Component(props) {
+        return _jsx(MetricAttributeFilterButton, { ...props, className: className });
+    }
+    return Component;
+}
+/**
+ * @internal
+ */
+export function MetricAttributeFilterButton({ isOpen, subtitle, title, selectedItemsCount, onClick, isLoading, isFiltering, className, }) {
+    const intl = useIntl();
+    let buttonTitle = `${title}: ${subtitle}`;
+    if (isLoading || isFiltering) {
+        buttonTitle = intl.formatMessage({ id: "loading" });
+    }
+    const buttonClassNames = cx("adi-metric-attribute-filter", "gd-icon-right", "button-dropdown", "gd-button", "adi-attr-filter-button", "s-filter-button", "adi-filter-button", "toggle-menu", "dropdown-button", "s-attr-filter", className, { "is-dropdown-open": isOpen }, { "is-active": isOpen }, { "gd-icon-navigateup": isOpen }, { "gd-icon-navigatedown": !isOpen });
+    const selectionSize = selectedItemsCount === 0 ? undefined : selectedItemsCount;
+    return (_jsx("button", { tabIndex: -1, className: buttonClassNames, onClick: onClick, children: _jsx(FilterLabel, { title: buttonTitle, selectionSize: selectionSize }) }));
+}

package/esm/components/AttributeFilter/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ATTRIBUTE_DROPDOWN_WIDTH = 208;
+export declare const DATE_ATTRIBUTE_DROPDOWN_WIDTH = 180;
+//# sourceMappingURL=constants.d.ts.map

package/esm/components/AttributeFilter/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/AttributeFilter/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,6BAA6B,MAAM,CAAC"}

package/esm/components/AttributeFilter/constants.js

@@ -0,0 +1,3 @@
+// (C) 2007-2026 GoodData Corporation
+export const ATTRIBUTE_DROPDOWN_WIDTH = 208;
+export const DATE_ATTRIBUTE_DROPDOWN_WIDTH = 180;

package/esm/components/AttributeFilter/customization/useAttributeFilterCustomizations.d.ts

@@ -0,0 +1,17 @@
+import { type DashboardAttributeFilterSelectionMode, type IAttributeElement, type IAttributeFilter, type ObjRef } from "@gooddata/sdk-model";
+import { type OnChangeCallbackType } from "@gooddata/sdk-ui-filters";
+import { type IAttributeFilterProps, type IAttributeFilterStateProps } from "../types.js";
+export declare const useAttributeFilterCustomizations: (props: IAttributeFilterProps & IAttributeFilterStateProps) => {
+    workspace: string;
+    backend: import("@gooddata/sdk-backend-spi").IAnalyticalBackend | undefined;
+    filter: IAttributeFilter;
+    displayAsDisplayForm: ObjRef;
+    onApplyCallback: (filter: IAttributeFilter, isInverted: boolean, _selectionMode: DashboardAttributeFilterSelectionMode, itemTitles: IAttributeElement[] | undefined, displayAsLabel: ObjRef) => void;
+    onChangeCallback: OnChangeCallbackType | undefined;
+    CustomStatusBarComponent: ((props: import("@gooddata/sdk-ui-filters").IAttributeFilterStatusBarProps) => import("react/jsx-runtime").JSX.Element) | null;
+    CustomDropdownButton: (props: import("@gooddata/sdk-ui-filters").IAttributeFilterDropdownButtonProps) => import("react/jsx-runtime").JSX.Element;
+    CustomDropdownBody: (props: import("@gooddata/sdk-ui-filters").IAttributeFilterDropdownBodyProps) => import("react/jsx-runtime").JSX.Element;
+    CustomElementsSearchBarComponent: import("react").ComponentType<import("@gooddata/sdk-ui-filters").IAttributeFilterElementsSearchBarProps> | null;
+    CustomElementsDropdownActionsComponent: (props: import("@gooddata/sdk-ui-filters").IAttributeFilterDropdownActionsProps) => import("react/jsx-runtime").JSX.Element;
+};
+//# sourceMappingURL=useAttributeFilterCustomizations.d.ts.map

package/esm/components/AttributeFilter/customization/useAttributeFilterCustomizations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttributeFilterCustomizations.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/customization/useAttributeFilterCustomizations.ts"],"names":[],"mappings":"AAMA,OAAO,EACH,KAAK,qCAAqC,EAC1C,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,MAAM,EAGd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAKrE,OAAO,EACH,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAGlC,MAAM,aAAa,CAAC;AAoBrB,eAAO,MAAM,gCAAgC,UAClC,qBAAqB,GAAG,0BAA0B;;;;;8BAkCzC,gBAAgB,cACZ,OAAO,kBACH,qCAAqC,cACzC,iBAAiB,EAAE,8BACf,MAAM;;;;;;;CA0GjC,CAAC"}

package/esm/components/AttributeFilter/customization/useAttributeFilterCustomizations.js

@@ -0,0 +1,101 @@
+// (C) 2007-2026 GoodData Corporation
+import { useCallback, useMemo, useRef } from "react";
+import { useIntl } from "react-intl";
+import { areObjRefsEqual, filterObjRef, } from "@gooddata/sdk-model";
+import { useBackend } from "@gooddata/sdk-ui";
+import { AttributeDropdownBody } from "../components/AttributeDropdownBody.js";
+import { elementsToItemTitlesMap, extractTextModeFilterData, isDisplayFormSelectVisible, mapDecoratedFilterToFilter, mapFilterToSelectedItems, } from "../utils.js";
+import { withDisplayFormSelect } from "./withDisplayFormSelect.js";
+import { withDropdownButton } from "./withDropdownButton.js";
+import { withDropdownClassName } from "./withDropdownClassName.js";
+import { withTitleElementsDropdownActionsComponent } from "./withTitleElementsDropdownActionsComponent.js";
+function checkIsPrimaryDisplayForm(attribute, displayFormKey) {
+    const displayForms = attribute?.displayForms ?? [];
+    const primaryDf = displayForms.find((df) => df?.isPrimary);
+    return primaryDf && areObjRefsEqual(primaryDf?.ref, displayFormKey);
+}
+export const useAttributeFilterCustomizations = (props) => {
+    const { autoOpen, filter, settings, useAlternativeDisplayForms, availableDisplayForms, availableSelectionTypes, isUsedByInsight, onApply, onClose, onDisplayFormChange, dropdownButtonComponent, dropdownBodyComponent, elementsSearchBarComponent, dropdownClassName, } = props;
+    const backend = useBackend();
+    const original = filter.original;
+    const isPrimaryDisplayForm = checkIsPrimaryDisplayForm(filter.attribute, original?.displayFormRef);
+    const mappedFilter = useMemo(() => mapDecoratedFilterToFilter(filter, isPrimaryDisplayForm), [filter, isPrimaryDisplayForm]);
+    const currentDisplayAsLabel = original?.displayAsDisplayFormRef;
+    const selectedTitlesRef = useRef({ totalElementsCount: 0, itemTitles: {} });
+    const intl = useIntl();
+    const onApplyCallback = useCallback((filter, isInverted, _selectionMode, itemTitles = [], displayAsLabel) => {
+        const itemTitlesMap = itemTitles.length
+            ? elementsToItemTitlesMap(itemTitles)
+            : selectedTitlesRef.current.itemTitles;
+        const selectedItems = mapFilterToSelectedItems(filter, itemTitlesMap);
+        const textModeFilter = extractTextModeFilterData(filter);
+        const payload = {
+            displayFormRef: filterObjRef(filter),
+            totalElementsCount: selectedTitlesRef.current.totalElementsCount,
+            selectedElements: selectedItems,
+            isInverted: isInverted,
+            ...(textModeFilter ? { textModeFilter } : {}),
+        };
+        onApply(payload);
+        if (displayAsLabel && !areObjRefsEqual(currentDisplayAsLabel, displayAsLabel)) {
+            onDisplayFormChange(displayAsLabel);
+        }
+    }, [onApply, onDisplayFormChange, currentDisplayAsLabel]);
+    const hasTextSelectionTypes = availableSelectionTypes?.some((mode) => mode === "arbitrary" || mode === "match");
+    const onChangeCallback = useMemo(() => {
+        if (!hasTextSelectionTypes) {
+            return undefined;
+        }
+        return (_filter, _isInverted, _selectionMode, _itemTitles, displayAsLabel) => {
+            if (displayAsLabel && !areObjRefsEqual(currentDisplayAsLabel, displayAsLabel)) {
+                onDisplayFormChange(displayAsLabel);
+            }
+        };
+    }, [hasTextSelectionTypes, currentDisplayAsLabel, onDisplayFormChange]);
+    const CustomStatusBarComponent = useMemo(() => {
+        // When text filter modes are enabled, the SDK component provides its own
+        // display form handling — skip the custom display form select.
+        if (hasTextSelectionTypes) {
+            return null;
+        }
+        if (isDisplayFormSelectVisible(useAlternativeDisplayForms, availableDisplayForms)) {
+            return withDisplayFormSelect(onDisplayFormChange);
+        }
+        return null;
+    }, [onDisplayFormChange, useAlternativeDisplayForms, availableDisplayForms, hasTextSelectionTypes]);
+    const CustomDropdownButton = useMemo(() => {
+        const warningMessage = intl.formatMessage({ id: "filter.isUnusedWarning" });
+        return withDropdownButton(isUsedByInsight, autoOpen, warningMessage, onClose, dropdownButtonComponent);
+    }, [autoOpen, isUsedByInsight, dropdownButtonComponent, onClose, intl]);
+    const CustomDropdownBody = useMemo(() => {
+        if (dropdownBodyComponent) {
+            return withDropdownClassName(dropdownBodyComponent, dropdownClassName);
+        }
+        return withDropdownClassName(AttributeDropdownBody, dropdownClassName);
+    }, [dropdownBodyComponent, dropdownClassName]);
+    const CustomElementsSearchBarComponent = useMemo(() => {
+        if (elementsSearchBarComponent) {
+            return elementsSearchBarComponent;
+        }
+        return null;
+    }, [elementsSearchBarComponent]);
+    const CustomElementsDropdownActionsComponent = useMemo(() => {
+        const onApplyTitles = (itemTitles, totalElementsCount) => {
+            selectedTitlesRef.current = { itemTitles, totalElementsCount };
+        };
+        return withTitleElementsDropdownActionsComponent(onApplyTitles);
+    }, []);
+    return {
+        workspace: settings.workspace,
+        backend,
+        filter: mappedFilter,
+        displayAsDisplayForm: currentDisplayAsLabel,
+        onApplyCallback,
+        onChangeCallback,
+        CustomStatusBarComponent,
+        CustomDropdownButton,
+        CustomDropdownBody,
+        CustomElementsSearchBarComponent,
+        CustomElementsDropdownActionsComponent,
+    };
+};

package/esm/components/AttributeFilter/customization/withDisplayFormSelect.d.ts

@@ -0,0 +1,7 @@
+import { type IAttributeFilterStatusBarProps } from "@gooddata/sdk-ui-filters";
+import { type OnDisplayFormChangeHandler } from "../types.js";
+/**
+ * This function customize AttributeFilterStatusBar by adding AttributeDisplayFormSelect
+ */
+export declare function withDisplayFormSelect(onSelect: OnDisplayFormChangeHandler): (props: IAttributeFilterStatusBarProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=withDisplayFormSelect.d.ts.map

package/esm/components/AttributeFilter/customization/withDisplayFormSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withDisplayFormSelect.d.ts","sourceRoot":"","sources":["../../../../src/components/AttributeFilter/customization/withDisplayFormSelect.tsx"],"names":[],"mappings":"AAKA,OAAO,EAGH,KAAK,8BAA8B,EAEtC,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE9D;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,0BAA0B,WAC5C,8BAA8B,6CAiB3D"}

package/esm/components/AttributeFilter/customization/withDisplayFormSelect.js

@@ -0,0 +1,17 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2007-2026 GoodData Corporation
+import { useCallback } from "react";
+import { AttributeDisplayFormSelect, AttributeFilterStatusBar, useAttributeFilterContext, } from "@gooddata/sdk-ui-filters";
+/**
+ * This function customize AttributeFilterStatusBar by adding AttributeDisplayFormSelect
+ */
+export function withDisplayFormSelect(onSelect) {
+    function Component(props) {
+        const { currentDisplayFormRef, committedSelectionElements } = useAttributeFilterContext();
+        const onSelectHandler = useCallback((df) => {
+            onSelect(df, currentDisplayFormRef, committedSelectionElements);
+        }, [committedSelectionElements, currentDisplayFormRef]);
+        return (_jsxs(_Fragment, { children: [_jsx(AttributeFilterStatusBar, { ...props }), _jsx(AttributeDisplayFormSelect, { onSelect: onSelectHandler })] }));
+    }
+    return Component;
+}