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

package/esm/utils/buckets.d.ts

@@ -0,0 +1,3 @@
+import { type IRawBucketItems, type IRawBuckets } from "../typings/buckets.js";
+export declare function getDerivedBucketItems(buckets: IRawBuckets): IRawBucketItems;
+//# sourceMappingURL=buckets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buckets.d.ts","sourceRoot":"","sources":["../../src/utils/buckets.ts"],"names":[],"mappings":"AAGA,OAAO,EAAuB,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpG,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAE3E"}

package/esm/utils/buckets.js

@@ -0,0 +1,5 @@
+// (C) 2007-2026 GoodData Corporation
+import { isDerived } from "../models/bucket_item.js";
+export function getDerivedBucketItems(buckets) {
+    return buckets.flatMap((bucket) => bucket?.items).filter(isDerived);
+}

package/esm/utils/catalog_details_loader_api.d.ts

@@ -0,0 +1,9 @@
+import { type IntlShape } from "react-intl";
+import { type IOrganizedCatalogItem, type IOrganizedCatalogTooltipDetails } from "../typings/catalog.js";
+/**
+ * Kicks off loading of all detail parts for the given item and returns the in-flight promises. The
+ * parts run concurrently; the caller is expected to consume each promise independently so a resolved
+ * part can be shown without waiting for the others.
+ */
+export declare function loadDetailParts(item: IOrganizedCatalogItem, projectId: string, intl: IntlShape): Promise<IOrganizedCatalogTooltipDetails>[];
+//# sourceMappingURL=catalog_details_loader_api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog_details_loader_api.d.ts","sourceRoot":"","sources":["../../src/utils/catalog_details_loader_api.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,+BAA+B,EAAE,MAAM,uBAAuB,CAAC;AA8FzG;;;;GAIG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,qBAAqB,EAC3B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,SAAS,GAChB,OAAO,CAAC,+BAA+B,CAAC,EAAE,CAO5C"}

package/esm/utils/catalog_details_loader_api.js

@@ -0,0 +1,82 @@
+// (C) 2007-2026 GoodData Corporation
+import { backend } from "../backend.js";
+import { getComputedAttributeExpressionTokens as loadComputedAttributeExpressionTokens, getMeasureExpressionTokens as loadMeasureExpressionTokens, } from "./metric_details_loader_api.js";
+const ELEMENT_COUNT = 5;
+function loadAttrElements(attribute, projectId) {
+    return backend
+        .workspace(projectId)
+        .attributes()
+        .elements()
+        .forDisplayForm(attribute.dfRef)
+        .withLimit(ELEMENT_COUNT)
+        .query();
+}
+function loadFactDataset(item, projectId) {
+    return backend.workspace(projectId).facts().getFactDatasetMeta(item.ref);
+}
+function loadAttributeDataset(item, projectId) {
+    return backend.workspace(projectId).attributes().getAttributeDatasetMeta(item.ref);
+}
+/**
+ * Each catalog item type is loaded as a set of independent detail "parts". Splitting the loading
+ * this way lets callers render each part as soon as it resolves, instead of waiting for the slowest
+ * one. For attributes in particular, the (fast) dataset info is a separate part from the (potentially
+ * slow) value samples, so users can see which dataset an attribute belongs to without waiting for the
+ * CollectLabelElements query to finish.
+ */
+const detailLoaders = {
+    metric: [
+        async (item, projectId, intl) => {
+            const tokenizedExpression = await loadMeasureExpressionTokens(intl, projectId, item.ref);
+            return { metricMaql: tokenizedExpression };
+        },
+    ],
+    attribute: [
+        async (item, projectId) => {
+            const dataset = await loadAttributeDataset(item, projectId);
+            return { dataset };
+        },
+        async (item, projectId) => {
+            const validElements = await loadAttrElements(item, projectId);
+            return {
+                attrElements: validElements.items,
+                attrElementsTotalCount: validElements.totalCount,
+                attrElementsNumberFormat: validElements.numberFormat,
+            };
+        },
+    ],
+    fact: [
+        async (item, projectId) => {
+            const dataset = await loadFactDataset(item, projectId);
+            return { dataset };
+        },
+    ],
+    // A computed attribute is an attribute with values AND a MAQL definition, so both are shown:
+    // the values like an attribute's, the definition resolved the same way a metric's is.
+    computedAttribute: [
+        async (item, projectId) => {
+            const validElements = await loadAttrElements(item, projectId);
+            return {
+                attrElements: validElements.items,
+                attrElementsTotalCount: validElements.totalCount,
+                attrElementsNumberFormat: validElements.numberFormat,
+            };
+        },
+        async (item, projectId, intl) => {
+            const tokenizedExpression = await loadComputedAttributeExpressionTokens(intl, projectId, item.ref);
+            return { metricMaql: tokenizedExpression };
+        },
+    ],
+};
+/**
+ * Kicks off loading of all detail parts for the given item and returns the in-flight promises. The
+ * parts run concurrently; the caller is expected to consume each promise independently so a resolved
+ * part can be shown without waiting for the others.
+ */
+export function loadDetailParts(item, projectId, intl) {
+    const loaders = detailLoaders[item.type];
+    if (!loaders) {
+        throw new Error(`Unsupported item type = '${item.type}' for detail request`);
+    }
+    return loaders.map((loader) => loader(item, projectId, intl));
+}

package/esm/utils/css_class.d.ts

@@ -0,0 +1,2 @@
+export declare function getCssClass(value: string, prefix?: string): string;
+//# sourceMappingURL=css_class.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"css_class.d.ts","sourceRoot":"","sources":["../../src/utils/css_class.ts"],"names":[],"mappings":"AAIA,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,SAAK,GAAG,MAAM,CAE9D"}

package/esm/utils/css_class.js

@@ -0,0 +1,5 @@
+// (C) 2007-2026 GoodData Corporation
+import { simplifyText } from "@gooddata/util";
+export function getCssClass(value, prefix = "") {
+    return prefix + simplifyText(value);
+}

package/esm/utils/custom_mouse_backend.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2015, Yahoo Inc.
+ * Copyrights licensed under the MIT License.
+ *
+ * This is a fork of the Touch Backend, which has been adapted for mouse functionality.
+ * Its main purpose is to provide an alternative to the HTML5 Backend, for applications which need to
+ * circumvent the limitations of HTML5 drag and drop in Edge and IE browsers.
+ *
+ * The original touch functionality has not been tested and is therefore quite possibly broken.
+ */
+import { type Backend, type BackendFactory, type DragDropActions, type DragDropManager, type DragDropMonitor, type HandlerRegistry, type Unsubscribe } from "dnd-core";
+interface ITouchBackendOptions {
+    delay?: number;
+    enableTouchEvents?: boolean;
+    enableMouseEvents?: boolean;
+}
+export declare class TouchBackend implements Backend {
+    private static isSetUp;
+    actions: DragDropActions;
+    monitor: DragDropMonitor;
+    registry: HandlerRegistry;
+    sourceNodes: {
+        [key: string]: HTMLElement;
+    };
+    sourcePreviewNodes: {
+        [key: string]: HTMLElement;
+    };
+    sourceNodeOptions: {
+        [key: string]: HTMLElement;
+    };
+    sourcePreviewNodeOptions: {
+        [key: string]: unknown;
+    };
+    targetNodes: {
+        [key: string]: HTMLElement;
+    };
+    delay: number;
+    private _mouseClientOffset;
+    private listenerTypes;
+    private moveStartSourceIds;
+    private timeout;
+    private startListenerCapture;
+    constructor(manager: DragDropManager, options?: ITouchBackendOptions);
+    profile(): Record<string, number>;
+    startHandler(): (e: MouseEvent | TouchEvent) => void;
+    setup(): void;
+    teardown(): void;
+    private addEventListener;
+    private removeEventListener;
+    connectDragSource(sourceId: string, node: HTMLElement): Unsubscribe;
+    connectDragPreview(sourceId: string, node: HTMLElement, options: unknown): Unsubscribe;
+    connectDropTarget(targetId: string, node: HTMLElement): Unsubscribe;
+    private getSourceClientOffset;
+    handleTopMoveStartCapture: (_e: Event) => void;
+    handleMoveStart: (sourceId: string) => void;
+    handleCancelClick: (sourceId: string, e: Event) => void;
+    handleTopMoveStart: (e: MouseEvent | TouchEvent) => void;
+    handleTopMoveStartDelay: (e: MouseEvent | TouchEvent) => void;
+    handleTopMoveCapture: (e: MouseEvent | TouchEvent) => void;
+    handleTopMoveEndCapture: (e: Event) => void;
+    cancelDrag(): void;
+}
+export declare function createCustomMouseBackend(): BackendFactory;
+export {};
+//# sourceMappingURL=custom_mouse_backend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"custom_mouse_backend.d.ts","sourceRoot":"","sources":["../../src/utils/custom_mouse_backend.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,OAAO,EACH,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,WAAW,EAEnB,MAAM,UAAU,CAAC;AAiBlB,UAAU,oBAAoB;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AA6ED,qBAAa,YAAa,YAAW,OAAO;IACxC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAU;IAEzB,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;IAC5C,kBAAkB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;IACnD,iBAAiB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;IAClD,wBAAwB,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IACrD,WAAW,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAC;IAErB,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,oBAAoB,CAAU;IAEtC,YAAY,OAAO,EAAE,eAAe,EAAE,OAAO,GAAE,oBAAyB,EA8BvE;IAEM,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvC;IAEM,YAAY,QA2Ia,UAAU,GAAG,UAAU,KAAG,IAAI,CAzI7D;IAEM,KAAK,SAsCX;IAEM,QAAQ,SAYd;IAED,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,mBAAmB;IAcpB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW,CAczE;IAEM,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,WAAW,CAQ5F;IAEM,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW,CAMzE;IAED,OAAO,CAAC,qBAAqB,CAE3B;IAEK,yBAAyB,OAAQ,KAAK,KAAG,IAAI,CAElD;IAEK,eAAe,aAAc,MAAM,KAAG,IAAI,CAE/C;IAEK,iBAAiB,aAAc,MAAM,KAAK,KAAK,KAAG,IAAI,CAI3D;IAEK,kBAAkB,MAAO,UAAU,GAAG,UAAU,KAAG,IAAI,CAmB5D;IAEK,uBAAuB,MAAO,UAAU,GAAG,UAAU,KAAG,IAAI,CAEjE;IAEK,oBAAoB,MAAO,UAAU,GAAG,UAAU,KAAG,IAAI,CAkC9D;IAEK,uBAAuB,MAAO,KAAK,KAAG,IAAI,CAY/C;IAEF,UAAU,SAIT;CACJ;AAED,wBAAgB,wBAAwB,IAAI,cAAc,CAIzD"}

package/esm/utils/custom_mouse_backend.js

@@ -0,0 +1,287 @@
+// (C) 2021-2026 GoodData Corporation
+import invariant from "invariant";
+import { isHostedComponentSelector } from "../appMode/appMode.js";
+import { store } from "../reduxStore.js";
+import { getIsEmbedded } from "../selectors/meta_selector.js";
+var ListenerType;
+(function (ListenerType) {
+    ListenerType["mouse"] = "mouse";
+    ListenerType["touch"] = "touch";
+})(ListenerType || (ListenerType = {}));
+function getEventClientTouchOffset(e) {
+    if (e.targetTouches.length === 1) {
+        return getEventClientOffset(e.targetTouches[0]);
+    }
+    return undefined;
+}
+function isTouchEvent(e) {
+    return !!e.targetTouches;
+}
+function getEventClientOffset(e) {
+    if (isTouchEvent(e)) {
+        return getEventClientTouchOffset(e);
+    }
+    else {
+        return {
+            x: e.clientX,
+            y: e.clientY,
+        };
+    }
+}
+const ELEMENT_NODE = 1;
+function getNodeClientOffset(node) {
+    const el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;
+    if (!el) {
+        return null;
+    }
+    const { top, left } = el.getBoundingClientRect();
+    return { x: left, y: top };
+}
+const eventNames = {
+    mouse: {
+        start: "mousedown",
+        move: "mousemove",
+        end: "mouseup",
+        click: "click",
+    },
+    touch: {
+        start: "touchstart",
+        move: "touchmove",
+        end: "touchend",
+    },
+};
+function getNodesAtOffset(nodes, clientOffset) {
+    return Object.keys(nodes).filter((nodeId) => {
+        const boundingRect = nodes[nodeId].getBoundingClientRect();
+        return (clientOffset.x >= boundingRect.left &&
+            clientOffset.x <= boundingRect.right &&
+            clientOffset.y >= boundingRect.top &&
+            clientOffset.y <= boundingRect.bottom);
+    });
+}
+function getDistance(p1, p2) {
+    const a = p1.x - p2.x;
+    const b = p1.y - p2.y;
+    return Math.sqrt(a * a + b * b);
+}
+export class TouchBackend {
+    static isSetUp;
+    actions;
+    monitor;
+    registry;
+    sourceNodes;
+    sourcePreviewNodes;
+    sourceNodeOptions;
+    sourcePreviewNodeOptions;
+    targetNodes;
+    delay;
+    _mouseClientOffset;
+    listenerTypes;
+    moveStartSourceIds;
+    timeout;
+    startListenerCapture;
+    constructor(manager, options = {}) {
+        options = {
+            enableTouchEvents: true,
+            enableMouseEvents: false,
+            delay: 0,
+            ...options,
+        };
+        this.actions = manager.getActions();
+        this.monitor = manager.getMonitor();
+        this.registry = manager.getRegistry();
+        this.delay = options.delay;
+        this.sourceNodes = {};
+        this.sourceNodeOptions = {};
+        this.sourcePreviewNodes = {};
+        this.sourcePreviewNodeOptions = {};
+        this.moveStartSourceIds = {};
+        this.targetNodes = {};
+        this.listenerTypes = [];
+        this._mouseClientOffset = null;
+        this.startListenerCapture = false;
+        if (options.enableMouseEvents) {
+            this.listenerTypes.push(ListenerType.mouse);
+        }
+        if (options.enableTouchEvents) {
+            this.listenerTypes.push(ListenerType.touch);
+        }
+    }
+    profile() {
+        return {};
+    }
+    startHandler() {
+        return this.delay ? this.handleTopMoveStartDelay : this.handleTopMoveStart;
+    }
+    setup() {
+        if (typeof window === "undefined") {
+            return;
+        }
+        invariant(!TouchBackend.isSetUp, "Cannot have two Touch backends at the same time.");
+        TouchBackend.isSetUp = true;
+        /**
+         * We should cancel drag only in embedded mode.
+         */
+        const isEmbedded = getIsEmbedded(store.getState());
+        if (isEmbedded) {
+            document.onmouseout = (event) => {
+                /**
+                 * The relatedTarget with the mouseout event can be used to indicate the element the cursor just entered.
+                 * It means that if you leave the "window", there is no element.
+                 */
+                if (event.relatedTarget === null && this.monitor.isDragging()) {
+                    this.cancelDrag();
+                }
+            };
+        }
+        /**
+         * Hosted-component mode: AD shares the page with a host whose sdk-ui-kit Overlay (with
+         * closeOnOutsideClick) registers a document-level mousedown listener that stopPropagation()s
+         * inside-clicks, so a bubble-phase window listener would never see the drag-start mousedown.
+         * Capture phase runs window-first, before any document handler, and is immune to that. The
+         * drag gating is unaffected: beginDrag still requires the bubble-phase source-node listener
+         * (handleMoveStart) to have fired. Standalone/pluggable keep the original bubble phase.
+         */
+        this.startListenerCapture = isHostedComponentSelector(store.getState());
+        this.addEventListener(window, "start", this.startHandler(), this.startListenerCapture);
+        this.addEventListener(window, "start", this.handleTopMoveStartCapture, true);
+        this.addEventListener(window, "move", this.handleTopMoveCapture, true);
+        this.addEventListener(window, "end", this.handleTopMoveEndCapture, true);
+    }
+    teardown() {
+        if (typeof window === "undefined") {
+            return;
+        }
+        TouchBackend.isSetUp = false;
+        this._mouseClientOffset = null;
+        this.removeEventListener(window, "start", this.startHandler(), this.startListenerCapture);
+        this.removeEventListener(window, "start", this.handleTopMoveStartCapture, true);
+        this.removeEventListener(window, "move", this.handleTopMoveCapture, true);
+        this.removeEventListener(window, "end", this.handleTopMoveEndCapture, true);
+    }
+    addEventListener(subject, event, handler, capture) {
+        this.listenerTypes.forEach(function (listenerType) {
+            const eventName = eventNames[listenerType][event];
+            if (eventName) {
+                // the DOM types the listener by the event name only when that name is a literal
+                subject.addEventListener(eventName, handler, capture);
+            }
+        });
+    }
+    removeEventListener(subject, event, handler, capture) {
+        this.listenerTypes.forEach(function (listenerType) {
+            const eventName = eventNames[listenerType][event];
+            if (eventName) {
+                subject.removeEventListener(eventName, handler, capture);
+            }
+        });
+    }
+    connectDragSource(sourceId, node) {
+        const handleMoveStart = this.handleMoveStart.bind(this, sourceId);
+        const handleCancelClick = this.handleCancelClick.bind(this, sourceId);
+        this.sourceNodes[sourceId] = node;
+        this.addEventListener(node, "start", handleMoveStart);
+        this.addEventListener(node, "click", handleCancelClick, true);
+        return () => {
+            delete this.sourceNodes[sourceId];
+            this.removeEventListener(node, "start", handleMoveStart);
+            this.removeEventListener(node, "click", handleCancelClick, true);
+        };
+    }
+    connectDragPreview(sourceId, node, options) {
+        this.sourcePreviewNodeOptions[sourceId] = options;
+        this.sourcePreviewNodes[sourceId] = node;
+        return () => {
+            delete this.sourcePreviewNodes[sourceId];
+            delete this.sourcePreviewNodeOptions[sourceId];
+        };
+    }
+    connectDropTarget(targetId, node) {
+        this.targetNodes[targetId] = node;
+        return () => {
+            delete this.targetNodes[targetId];
+        };
+    }
+    getSourceClientOffset = (sourceId) => {
+        return getNodeClientOffset(this.sourceNodes[sourceId]);
+    };
+    handleTopMoveStartCapture = (_e) => {
+        this.moveStartSourceIds = {};
+    };
+    handleMoveStart = (sourceId) => {
+        this.moveStartSourceIds[sourceId] = true;
+    };
+    handleCancelClick = (sourceId, e) => {
+        if (this.moveStartSourceIds[sourceId]) {
+            e.stopPropagation();
+        }
+    };
+    handleTopMoveStart = (e) => {
+        const clientOffset = getEventClientOffset(e);
+        if (clientOffset && getNodesAtOffset(this.sourceNodes, clientOffset).length > 0) {
+            this._mouseClientOffset = clientOffset;
+            // note: calling preventDefault here, seems to be the only way to defeat text selection in Safari
+            // to handle other browsers, we could just call window.getSelection().removeAllRanges();
+            const target = e.target;
+            if (target.tagName !== "SELECT" && target.tagName !== "INPUT" && target.tagName !== "TEXTAREA") {
+                e.preventDefault();
+                // when clicking on draggable (DragSource decorated) component, document.activeElement doesn't change
+                // the following resets document.activeElement to document.body
+                const activeElement = document.activeElement;
+                if (activeElement && typeof activeElement.blur === "function") {
+                    activeElement.blur();
+                }
+            }
+        }
+    };
+    handleTopMoveStartDelay = (e) => {
+        this.timeout = setTimeout(this.handleTopMoveStart.bind(this, e), this.delay);
+    };
+    handleTopMoveCapture = (e) => {
+        clearTimeout(this.timeout);
+        const clientOffset = getEventClientOffset(e);
+        if (!clientOffset) {
+            return;
+        }
+        // If we're not dragging and we've moved a little, that counts as a drag start
+        if (!this.monitor.isDragging()) {
+            if (this._mouseClientOffset && getDistance(this._mouseClientOffset, clientOffset) > 2) {
+                const sourceIdsArray = Object.keys(this.moveStartSourceIds);
+                if (sourceIdsArray.length > 0) {
+                    e.preventDefault();
+                    this.actions.beginDrag(sourceIdsArray, {
+                        clientOffset: this._mouseClientOffset,
+                        getSourceClientOffset: this.getSourceClientOffset,
+                        publishSource: false,
+                    });
+                    this._mouseClientOffset = null;
+                }
+            }
+            return;
+        }
+        this.actions.publishDragSource();
+        e.preventDefault();
+        const matchingTargetIds = getNodesAtOffset(this.targetNodes, clientOffset);
+        this.actions.hover(matchingTargetIds, { clientOffset });
+    };
+    handleTopMoveEndCapture = (e) => {
+        this._mouseClientOffset = null;
+        if (!this.monitor.isDragging() || this.monitor.didDrop()) {
+            this.moveStartSourceIds = {};
+            return;
+        }
+        e.preventDefault();
+        this.actions.drop();
+        this.actions.endDrag();
+    };
+    cancelDrag() {
+        this._mouseClientOffset = null;
+        this.actions.drop();
+        this.actions.endDrag();
+    }
+}
+export function createCustomMouseBackend() {
+    return (manager) => {
+        return new TouchBackend(manager, { enableMouseEvents: true, enableTouchEvents: false });
+    };
+}

package/esm/utils/date_dataset_status.d.ts

@@ -0,0 +1,11 @@
+import { type IMeasureDateDatasetsStatusEntry } from "../store/measure_date_datasets/measure_date_datasets_state.js";
+export declare const DateDatasetStatusUtils: {
+    hasSelectedDateDataset: typeof hasSelectedDateDataset;
+};
+/**
+ * Checks if the provided date dataset status have date dataset selected or not
+ * @param dateDatasetStatus -
+ */
+declare function hasSelectedDateDataset(dateDatasetStatus: IMeasureDateDatasetsStatusEntry): boolean;
+export {};
+//# sourceMappingURL=date_dataset_status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"date_dataset_status.d.ts","sourceRoot":"","sources":["../../src/utils/date_dataset_status.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,+DAA+D,CAAC;AAErH,eAAO,MAAM,sBAAsB;;CAElC,CAAC;AAEF;;;GAGG;AACH,iBAAS,sBAAsB,CAAC,iBAAiB,EAAE,+BAA+B,GAAG,OAAO,CAE3F"}

package/esm/utils/date_dataset_status.js

@@ -0,0 +1,11 @@
+// (C) 2007-2026 GoodData Corporation
+export const DateDatasetStatusUtils = {
+    hasSelectedDateDataset,
+};
+/**
+ * Checks if the provided date dataset status have date dataset selected or not
+ * @param dateDatasetStatus -
+ */
+function hasSelectedDateDataset(dateDatasetStatus) {
+    return !!dateDatasetStatus.selectedDateDatasetUri;
+}

package/esm/utils/date_datasets.d.ts

@@ -0,0 +1,9 @@
+import { type IDateDataset } from "../typings/datasets.js";
+export declare const DateDatasetUtils: {
+    getDateDatasetUri: typeof getDateDatasetUri;
+    getMostRelevantDateDatasetUri: typeof getMostRelevantDateDatasetUri;
+};
+declare function getDateDatasetUri(dateDataset: IDateDataset): string;
+declare function getMostRelevantDateDatasetUri(dateDatasets: IDateDataset[]): string;
+export {};
+//# sourceMappingURL=date_datasets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"date_datasets.d.ts","sourceRoot":"","sources":["../../src/utils/date_datasets.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAK3D,eAAO,MAAM,gBAAgB;;;CAG5B,CAAC;AAEF,iBAAS,iBAAiB,CAAC,WAAW,EAAE,YAAY,GAAG,MAAM,CAE5D;AAYD,iBAAS,6BAA6B,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,MAAM,CAQ3E"}

package/esm/utils/date_datasets.js

@@ -0,0 +1,31 @@
+// (C) 2007-2026 GoodData Corporation
+import { cloneDeep, isEmpty } from "lodash-es";
+// `findDateBucketItems` (the state form)
+// died with its callers, the shortcuts/recommendations wrappers — the value level is
+// store/buckets/buckets_read_helpers.ts#getDateBucketItemsInBucket
+export const DateDatasetUtils = {
+    getDateDatasetUri,
+    getMostRelevantDateDatasetUri,
+};
+function getDateDatasetUri(dateDataset) {
+    return isEmpty(dateDataset) ? undefined : dateDataset.uri;
+}
+function dateDatasetRelevanceComparator(item1, item2) {
+    if (item1.relevance > item2.relevance) {
+        return -1;
+    }
+    else if (item1.relevance === item2.relevance) {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+function getMostRelevantDateDatasetUri(dateDatasets) {
+    if (isEmpty(dateDatasets)) {
+        return undefined;
+    }
+    const sortedDateDatasets = cloneDeep(dateDatasets).sort(dateDatasetRelevanceComparator);
+    const firstDateDataset = sortedDateDatasets[0];
+    return firstDateDataset.uri;
+}

package/esm/utils/date_datasets_meta.d.ts

@@ -0,0 +1,14 @@
+import { type ObjRef } from "@gooddata/sdk-model";
+import { type IDateDatasetsMeta } from "../models/date_datasets_meta.js";
+import type { IDateDatasetsMetaItem } from "../models/date_datasets_meta_item.js";
+import { type IDateDatasets } from "../typings/datasets.js";
+export declare const DateDatasetsMetaUtils: {
+    collectMeta: typeof collectMeta;
+    findDateDatasetMetaByUri: typeof findDateDatasetMetaByUri;
+    findDateDatasetMetaByRef: typeof findDateDatasetMetaByRef;
+};
+declare function collectMeta(dateDatasets: IDateDatasets): IDateDatasetsMeta;
+declare function findDateDatasetMetaByUri(uri: string, dateDatasetMetas: IDateDatasetsMetaItem[]): IDateDatasetsMetaItem;
+declare function findDateDatasetMetaByRef(ref: ObjRef, dateDatasetMetas: IDateDatasetsMetaItem[]): IDateDatasetsMetaItem;
+export {};
+//# sourceMappingURL=date_datasets_meta.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"date_datasets_meta.d.ts","sourceRoot":"","sources":["../../src/utils/date_datasets_meta.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAmB,MAAM,qBAAqB,CAAC;AAEnE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D,eAAO,MAAM,qBAAqB;;;;CAIjC,CAAC;AAEF,iBAAS,WAAW,CAAC,YAAY,EAAE,aAAa,GAAG,iBAAiB,CAkBnE;AAED,iBAAS,wBAAwB,CAC7B,GAAG,EAAE,MAAM,EACX,gBAAgB,EAAE,qBAAqB,EAAE,GAC1C,qBAAqB,CAKvB;AAED,iBAAS,wBAAwB,CAC7B,GAAG,EAAE,MAAM,EACX,gBAAgB,EAAE,qBAAqB,EAAE,GAC1C,qBAAqB,CAKvB"}

package/esm/utils/date_datasets_meta.js

@@ -0,0 +1,38 @@
+// (C) 2007-2026 GoodData Corporation
+import { isEmpty } from "lodash-es";
+import { areObjRefsEqual } from "@gooddata/sdk-model";
+export const DateDatasetsMetaUtils = {
+    collectMeta,
+    findDateDatasetMetaByUri,
+    findDateDatasetMetaByRef,
+};
+function collectMeta(dateDatasets) {
+    if (isEmpty(dateDatasets)) {
+        return null;
+    }
+    return {
+        items: dateDatasets.available.map((dateDataset) => {
+            return {
+                ref: dateDataset.ref,
+                identifier: dateDataset.identifier,
+                uri: dateDataset.uri,
+                type: dateDataset.type,
+                title: dateDataset.title,
+                summary: dateDataset.summary,
+                attributes: dateDataset.attributes,
+            };
+        }),
+    };
+}
+function findDateDatasetMetaByUri(uri, dateDatasetMetas) {
+    if (isEmpty(dateDatasetMetas)) {
+        return undefined;
+    }
+    return dateDatasetMetas.find((dateDatasetMeta) => dateDatasetMeta.uri === uri);
+}
+function findDateDatasetMetaByRef(ref, dateDatasetMetas) {
+    if (isEmpty(dateDatasetMetas)) {
+        return undefined;
+    }
+    return dateDatasetMetas.find((dateDatasetMeta) => areObjRefsEqual(dateDatasetMeta.ref, ref));
+}

package/esm/utils/date_filter.d.ts

@@ -0,0 +1,11 @@
+export declare function extractVisualizationObjectAttributeFilterElements<T>(attributeFilter: {
+    positiveAttributeFilter: {
+        in: T;
+    };
+} | {
+    negativeAttributeFilter: {
+        notIn: T;
+    };
+}): T;
+export declare function isSingleEmptyStringElement(elements: unknown[]): boolean;
+//# sourceMappingURL=date_filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"date_filter.d.ts","sourceRoot":"","sources":["../../src/utils/date_filter.ts"],"names":[],"mappings":"AAEA,wBAAgB,iDAAiD,CAAC,CAAC,EAC/D,eAAe,EAAE;IAAE,uBAAuB,EAAE;QAAE,EAAE,EAAE,CAAC,CAAA;KAAE,CAAA;CAAE,GAAG;IAAE,uBAAuB,EAAE;QAAE,KAAK,EAAE,CAAC,CAAA;KAAE,CAAA;CAAE,GACpG,CAAC,CAQH;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAEvE"}

package/esm/utils/date_filter.js

@@ -0,0 +1,13 @@
+// (C) 2026 GoodData Corporation
+export function extractVisualizationObjectAttributeFilterElements(attributeFilter) {
+    if ("positiveAttributeFilter" in attributeFilter) {
+        return attributeFilter.positiveAttributeFilter.in;
+    }
+    if ("negativeAttributeFilter" in attributeFilter) {
+        return attributeFilter.negativeAttributeFilter.notIn;
+    }
+    return undefined;
+}
+export function isSingleEmptyStringElement(elements) {
+    return elements.length === 1 && elements[0] === "";
+}