@gooddata/sdk-ui-metric-component 0.0.0-stage → 11.65.0-alpha.4

package/esm/MetricComponent/MetricState/hooks/useSaveTab.js

@@ -0,0 +1,93 @@
+// (C) 2021-2026 GoodData Corporation
+import { useCallback } from "react";
+import { useEvents } from "../../../shared/eventing/useEvents.js";
+import { useMetrics } from "../../../shared/metrics/useMetrics.js";
+import { useReloadMetrics } from "../../../shared/metrics/useReloadMetrics.js";
+import { useConflictDetection } from "../../ConflictContext/useConflictDetection.js";
+import { SaveNameMode } from "../../Content/EditMetricContent.data.js";
+import { events } from "../../Content/EditMetricContent.events.js";
+import { useWriteMetricAccess } from "../../Form/Header/share/useApplyMetricAccess.js";
+import { usePrefixes } from "../../Form/Prefixes/usePrefixes.js";
+import { useMetricSave } from "../../hooks/useMetricSave.js";
+import { metricHasChangedId, metricOverridesExistingId } from "../../metric/idChangeHelper.js";
+import { prepareMetricForSaveAs } from "../../metric/metricHelpers.js";
+import { createSaveMetricInfo } from "../../metric/saveInfo.js";
+import { transformToMetricDefinition } from "../../metric/transformer.js";
+export const useSaveTab = (handleChangeId, onMetricsChange, onSave) => {
+    const metrics = useMetrics();
+    const saveMetricHandler = useMetricSave();
+    const getConflicts = useConflictDetection();
+    const { needMetricReload } = useReloadMetrics();
+    const { metricConflictedIdEvent } = useEvents(events);
+    const prefix = usePrefixes();
+    const writeAccess = useWriteMetricAccess();
+    return useCallback((tab) => {
+        const { initial, current, saveMode } = tab.data;
+        const metric = getMetricDefinition(metrics.result || [], current, prefix.current, prefix.parents);
+        const changeIdPromise = getConflicts(current.id).then((conflicts) => {
+            const metricConflicts = metricOverridesExistingId(initial.id, current.id, conflicts);
+            const idChanged = metricHasChangedId(initial.id, current.id, saveMode);
+            const changed = idChanged || metricConflicts.conflictWith.length > 0;
+            if (metricConflicts.conflictWith.length > 0) {
+                metricConflictedIdEvent(current.id);
+            }
+            return changed
+                ? handleChangeId(saveMode, initial.id, current.id, idChanged, metricConflicts)
+                : Promise.resolve(current.id);
+        });
+        return changeIdPromise.then((newId) => {
+            metric.id = newId;
+            return saveMetricHandler(metric)
+                .then(async (metric) => {
+                // This path, not the editor's save, runs when a dirty new metric is
+                // closed with Save. Dropped first so a repeat cannot resend it.
+                const draft = tab.data.draftAccess;
+                if (draft) {
+                    tab.data.draftAccess = undefined;
+                    await writeAccess(metric, draft);
+                }
+                return metric;
+            })
+                .then((metric) => {
+                if (onMetricsChange) {
+                    onMetricsChange(metric);
+                }
+                return metric;
+            })
+                .then((metric) => {
+                needMetricReload();
+                if (onSave) {
+                    onSaveTab(tab, onSave, null);
+                }
+                return metric;
+            })
+                .catch((error) => {
+                if (onSave) {
+                    onSaveTab(tab, onSave, error);
+                }
+                throw error;
+            });
+        });
+    }, [
+        prefix,
+        metrics.result,
+        saveMetricHandler,
+        needMetricReload,
+        metricConflictedIdEvent,
+        onMetricsChange,
+        onSave,
+        handleChangeId,
+        getConflicts,
+        writeAccess,
+    ]);
+};
+function getMetricDefinition(metrics = [], current, prefix = "", parents = []) {
+    if (!current.isLocked) {
+        return current;
+    }
+    const { metric } = prepareMetricForSaveAs(current, current, metrics, prefix, parents);
+    return metric;
+}
+const onSaveTab = (tab, onSave, error) => {
+    return onSave?.(transformToMetricDefinition(tab.data.current), createSaveMetricInfo(tab.data.initial, {}, SaveNameMode.save), error);
+};

package/esm/MetricComponent/MetricState/hooks/useTabsData.d.ts

@@ -0,0 +1,16 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { type IMeasureMetadataObject } from "@gooddata/sdk-model";
+import { type ITab } from "../../../shared/Tabs/Tab.js";
+import { type IMeasureSetting } from "../../metric/metricHelpers.js";
+import { type IMetricInfo } from "../metricState.data.js";
+export declare const createTabFromMetricInfo: (item: IMetricInfo) => ITab<IMetricInfo>;
+export declare const updateTabFromMetric: (tab: ITab<IMetricInfo>, metric: IMeasureMetadataObject, isChanged: boolean, isInvalid: boolean) => Partial<ITab<IMetricInfo>>;
+export declare const revertTabFromMetricInfo: (data: IMetricInfo) => ITab<IMetricInfo>;
+export declare const updateTabDataFromMetric: (data: IMetricInfo, metric: IMeasureMetadataObject, isChanged: boolean) => IMetricInfo;
+export declare const updateTabDataFromSetting: (data: IMetricInfo, setting: Partial<IMeasureSetting>) => IMetricInfo;
+export type TabsData = {
+    metrics: ITab<IMetricInfo>[];
+    active: number;
+};
+export declare const useTabsData: (metricsProps: IMetricInfo[], activeProp: number) => [data: TabsData, setData: Dispatch<SetStateAction<TabsData>>];
+//# sourceMappingURL=useTabsData.d.ts.map

package/esm/MetricComponent/MetricState/hooks/useTabsData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTabsData.d.ts","sourceRoot":"","sources":["../../../../src/MetricComponent/MetricState/hooks/useTabsData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAuB,MAAM,OAAO,CAAC;AAEhF,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE,OAAO,EAAE,KAAK,IAAI,EAAY,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,eAAO,MAAM,uBAAuB,SAAU,WAAW,KAAG,IAAI,CAAC,WAAW,CAM1E,CAAC;AAEH,eAAO,MAAM,mBAAmB,QACvB,IAAI,CAAC,WAAW,CAAC,UACd,sBAAsB,aACnB,OAAO,aACP,OAAO,KACnB,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAU3B,CAAC;AAEF,eAAO,MAAM,uBAAuB,SAAU,WAAW,KAAG,IAAI,CAAC,WAAW,CAG3E,CAAC;AAEF,eAAO,MAAM,uBAAuB,SAC1B,WAAW,UACT,sBAAsB,aACnB,OAAO,KACnB,WAWF,CAAC;AAEF,eAAO,MAAM,wBAAwB,SAC3B,WAAW,WACR,OAAO,CAAC,eAAe,CAAC,KAClC,WAKF,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACnB,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,WAAW,iBACN,WAAW,EAAE,cACf,MAAM,KACnB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAe9D,CAAC"}

package/esm/MetricComponent/MetricState/hooks/useTabsData.js

@@ -0,0 +1,62 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect, useState } from "react";
+import { TabState } from "../../../shared/Tabs/Tab.js";
+export const createTabFromMetricInfo = (item) => ({
+    id: item.identifier,
+    title: item.initial.title || "",
+    data: item,
+    options: { closeable: true },
+    states: { dirty: false },
+});
+export const updateTabFromMetric = (tab, metric, isChanged, isInvalid) => {
+    return {
+        data: updateTabDataFromMetric(tab.data, metric, isChanged),
+        title: metric.title,
+        states: {
+            ...tab.states,
+            [TabState.Dirty]: isChanged,
+            [TabState.Invalid]: isInvalid,
+        },
+    };
+};
+export const revertTabFromMetricInfo = (data) => {
+    data.current = { ...data.initial };
+    return createTabFromMetricInfo(data);
+};
+export const updateTabDataFromMetric = (data, metric, isChanged) => {
+    return {
+        ...data,
+        current: metric,
+        ...(isChanged
+            ? {
+                focusedField: undefined,
+                generateNewId: undefined,
+            }
+            : {}),
+    };
+};
+export const updateTabDataFromSetting = (data, setting) => {
+    return {
+        ...data,
+        ...setting,
+    };
+};
+export const useTabsData = (metricsProps, activeProp) => {
+    const [data, setData] = useState({
+        metrics: processMetrics(metricsProps, []),
+        active: activeProp,
+    });
+    useEffect(() => {
+        setData({
+            metrics: processMetrics(metricsProps, data.metrics),
+            active: activeProp,
+        });
+        // oxlint-disable-next-line react-hooks/exhaustive-deps
+    }, [activeProp, metricsProps, metricsProps.length]);
+    return [data, setData];
+};
+function processMetrics(metricsProps, metrics) {
+    return metricsProps.map((item) => {
+        return metrics.find((row) => row.id == item.identifier) ?? createTabFromMetricInfo(item);
+    });
+}

package/esm/MetricComponent/MetricState/hooks/useUnsavedChanges.d.ts

@@ -0,0 +1,17 @@
+import { type ITab } from "../../../shared/Tabs/Tab.js";
+import { type IMeasureDef } from "../../metric/metricHelpers.js";
+import { type CloseAllTabsResult, type IMetricInfo } from "../metricState.data.js";
+export interface IUnsavedChangesDialogProps {
+    showDialog: boolean;
+    tabs: ITab<IMetricInfo>[];
+    resolver?: (value: CloseAllTabsResult) => void;
+}
+export interface IUseUnsavedChanges {
+    unsavedChangesDialog: IUnsavedChangesDialogProps;
+    openUnsavedChangesDialog: (tabs: ITab<IMetricInfo>[]) => Promise<CloseAllTabsResult>;
+    closeUnsavedChangesDialog: () => void;
+    cancelUnsavedChangesDialog: () => void;
+    saveUnsavedChangesDialog: () => void;
+}
+export declare const useUnsavedChanges: (onClose?: (metricInfos: IMetricInfo[]) => void, save?: (tab: ITab<IMetricInfo>) => Promise<IMeasureDef>) => IUseUnsavedChanges;
+//# sourceMappingURL=useUnsavedChanges.d.ts.map

package/esm/MetricComponent/MetricState/hooks/useUnsavedChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnsavedChanges.d.ts","sourceRoot":"","sources":["../../../../src/MetricComponent/MetricState/hooks/useUnsavedChanges.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAkB,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAEnG,MAAM,WAAW,0BAA0B;IACvC,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAClD;AAED,MAAM,WAAW,kBAAkB;IAC/B,oBAAoB,EAAE,0BAA0B,CAAC;IACjD,wBAAwB,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACrF,yBAAyB,EAAE,MAAM,IAAI,CAAC;IACtC,0BAA0B,EAAE,MAAM,IAAI,CAAC;IACvC,wBAAwB,EAAE,MAAM,IAAI,CAAC;CACxC;AAED,eAAO,MAAM,iBAAiB,aAChB,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,IAAI,SACvC,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,KACxD,kBAgFF,CAAC"}

package/esm/MetricComponent/MetricState/hooks/useUnsavedChanges.js

@@ -0,0 +1,86 @@
+// (C) 2021-2026 GoodData Corporation
+import { useCallback, useState } from "react";
+import { CloseAllStatus } from "../metricState.data.js";
+export const useUnsavedChanges = (onClose, save) => {
+    const [unsavedChangesDialog, setUnsavedChangesDialog] = useState({
+        showDialog: false,
+        tabs: [],
+    });
+    const openUnsavedChangesDialog = useCallback((tabs) => {
+        return new Promise((resolve) => {
+            setUnsavedChangesDialog({
+                showDialog: true,
+                tabs: tabs,
+                resolver: resolve,
+            });
+        });
+    }, [setUnsavedChangesDialog]);
+    const closeUnsavedChangesDialog = useCallback(() => {
+        if (unsavedChangesDialog.resolver) {
+            unsavedChangesDialog.resolver({
+                status: CloseAllStatus.Close,
+            });
+        }
+        setUnsavedChangesDialog({
+            showDialog: false,
+            tabs: [],
+        });
+    }, [setUnsavedChangesDialog, unsavedChangesDialog]);
+    const cancelUnsavedChangesDialog = useCallback(() => {
+        const resolvedData = {
+            status: CloseAllStatus.Canceled,
+        };
+        if (onClose) {
+            onClose(unsavedChangesDialog.tabs.map((tab) => tab.data));
+        }
+        if (unsavedChangesDialog.resolver) {
+            unsavedChangesDialog.resolver(resolvedData);
+        }
+        setUnsavedChangesDialog({
+            showDialog: false,
+            tabs: [],
+        });
+    }, [setUnsavedChangesDialog, onClose, unsavedChangesDialog]);
+    const saveUnsavedChangesDialog = useCallback(() => {
+        closeUnsavedChangesDialog();
+        tabsToSave(unsavedChangesDialog, save)
+            .then(() => {
+            const closedTabs = unsavedChangesDialog.tabs
+                .filter((tab) => !tab.states?.invalid)
+                .map((tab) => tab.data);
+            const invalidTabs = unsavedChangesDialog.tabs
+                .filter((tab) => tab.states?.invalid)
+                .map((tab) => tab.data);
+            const resolvedData = {
+                status: invalidTabs.length > 0 ? CloseAllStatus.Incomplete : CloseAllStatus.Complete,
+                closedTabs,
+                invalidTabs,
+            };
+            if (onClose) {
+                onClose(resolvedData.closedTabs);
+            }
+            if (unsavedChangesDialog.resolver) {
+                unsavedChangesDialog.resolver(resolvedData);
+            }
+        })
+            .catch(() => closeUnsavedChangesDialog());
+    }, [closeUnsavedChangesDialog, onClose, save, unsavedChangesDialog]);
+    return {
+        unsavedChangesDialog,
+        openUnsavedChangesDialog,
+        closeUnsavedChangesDialog,
+        cancelUnsavedChangesDialog,
+        saveUnsavedChangesDialog,
+    };
+};
+function tabsToSave(dialog, save) {
+    const promises = [];
+    dialog.tabs
+        .filter((tab) => tab.states?.dirty && !tab.states.invalid)
+        .forEach((tab) => {
+        if (save) {
+            promises.push(save(tab));
+        }
+    });
+    return Promise.all(promises);
+}

package/esm/MetricComponent/MetricState/hooks/useUpdateMetricData.d.ts

@@ -0,0 +1,5 @@
+import { type ITab } from "../../../shared/Tabs/Tab.js";
+import { type IMetricInfo } from "../metricState.data.js";
+import { type TabsData } from "./useTabsData.js";
+export declare const useUpdateMetricData: (data: TabsData) => ((tab: ITab<IMetricInfo>, newProps: Partial<IMetricInfo>) => void);
+//# sourceMappingURL=useUpdateMetricData.d.ts.map

package/esm/MetricComponent/MetricState/hooks/useUpdateMetricData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateMetricData.d.ts","sourceRoot":"","sources":["../../../../src/MetricComponent/MetricState/hooks/useUpdateMetricData.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,eAAO,MAAM,mBAAmB,SACtB,QAAQ,KACf,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,CAUnE,CAAC"}

package/esm/MetricComponent/MetricState/hooks/useUpdateMetricData.js

@@ -0,0 +1,10 @@
+// (C) 2021-2026 GoodData Corporation
+import { useCallback } from "react";
+export const useUpdateMetricData = (data) => {
+    return useCallback((tab, dataUpdate) => {
+        const foundTab = data.metrics.find((item) => item.id == tab.id);
+        if (foundTab?.data) {
+            foundTab.data = { ...foundTab.data, ...dataUpdate };
+        }
+    }, [data]);
+};

package/esm/MetricComponent/MetricState/hooks/useUpdateMetricTab.d.ts

@@ -0,0 +1,6 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { type ITab } from "../../../shared/Tabs/Tab.js";
+import { type IMetricInfo } from "../metricState.data.js";
+import { type TabsData } from "./useTabsData.js";
+export declare const useUpdateMetricTab: (setData: Dispatch<SetStateAction<TabsData>>) => ((tab: ITab<IMetricInfo>, newProps: Partial<ITab<IMetricInfo>>) => void);
+//# sourceMappingURL=useUpdateMetricTab.d.ts.map

package/esm/MetricComponent/MetricState/hooks/useUpdateMetricTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateMetricTab.d.ts","sourceRoot":"","sources":["../../../../src/MetricComponent/MetricState/hooks/useUpdateMetricTab.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAC;AAExE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,eAAO,MAAM,kBAAkB,YAClB,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,KAC5C,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,KAAK,IAAI,CAiBzE,CAAC"}

package/esm/MetricComponent/MetricState/hooks/useUpdateMetricTab.js

@@ -0,0 +1,17 @@
+// (C) 2021-2026 GoodData Corporation
+import { useCallback } from "react";
+export const useUpdateMetricTab = (setData) => {
+    return useCallback((tab, newProps) => {
+        setData((data) => {
+            const { metrics, active } = data;
+            const foundTabIndex = metrics.findIndex((item) => item.id == tab.id);
+            if (foundTabIndex >= 0) {
+                const foundTab = metrics[foundTabIndex];
+                const newTabs = metrics.slice();
+                newTabs.splice(foundTabIndex, 1, { ...foundTab, ...newProps });
+                return { metrics: newTabs, active };
+            }
+            return data;
+        });
+    }, [setData]);
+};

package/esm/MetricComponent/MetricState/metricState.data.d.ts

@@ -0,0 +1,37 @@
+import { type IObjectShareDraft } from "@gooddata/sdk-ui-ext";
+import { type SaveNameMode } from "../Content/EditMetricContent.data.js";
+import { type FormField } from "../Form/data.js";
+import { type IMeasureDef, type IMeasureSetting } from "../metric/metricHelpers.js";
+export declare enum MetricInfoKind {
+    Create = "CREATE",
+    Edit = "EDIT"
+}
+export type IMetricInfo = IMeasureSetting & {
+    initial: IMeasureDef;
+    current: IMeasureDef;
+    identifier: string;
+    kind: MetricInfoKind;
+    saveMode?: SaveNameMode;
+    focusedField?: FormField;
+    generateNewId?: boolean;
+    /** Access drafted but not saved. Held by the tab because a switch unmounts the editor. */
+    draftAccess?: IObjectShareDraft;
+};
+export type IMetricInfoDraft = Omit<IMetricInfo, "identifier">;
+export declare enum CloseAllStatus {
+    Close = "close",
+    Canceled = "canceled",
+    Complete = "complete",
+    Incomplete = "incomplete"
+}
+export type CloseAllTabsResult = CloseAllTabsWithCancel | CloseAllTabsWithProceed;
+type CloseAllTabsWithCancel = {
+    status: CloseAllStatus.Canceled | CloseAllStatus.Close;
+};
+type CloseAllTabsWithProceed = {
+    status: CloseAllStatus.Incomplete | CloseAllStatus.Complete;
+    closedTabs: IMetricInfo[];
+    invalidTabs: IMetricInfo[];
+};
+export {};
+//# sourceMappingURL=metricState.data.d.ts.map

package/esm/MetricComponent/MetricState/metricState.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricState.data.d.ts","sourceRoot":"","sources":["../../../src/MetricComponent/MetricState/metricState.data.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAEpF,oBAAY,cAAc;IACtB,MAAM,WAAW;IACjB,IAAI,SAAS;CAChB;AAED,MAAM,MAAM,WAAW,GAAG,eAAe,GAAG;IACxC,OAAO,EAAE,WAAW,CAAC;IACrB,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,0FAA0F;IAC1F,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;AAE/D,oBAAY,cAAc;IACtB,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,UAAU,eAAe;CAC5B;AAED,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,uBAAuB,CAAC;AAElF,KAAK,sBAAsB,GAAG;IAC1B,MAAM,EAAE,cAAc,CAAC,QAAQ,GAAG,cAAc,CAAC,KAAK,CAAC;CAC1D,CAAC;AAEF,KAAK,uBAAuB,GAAG;IAC3B,MAAM,EAAE,cAAc,CAAC,UAAU,GAAG,cAAc,CAAC,QAAQ,CAAC;IAC5D,UAAU,EAAE,WAAW,EAAE,CAAC;IAC1B,WAAW,EAAE,WAAW,EAAE,CAAC;CAC9B,CAAC"}

package/esm/MetricComponent/MetricState/metricState.data.js

@@ -0,0 +1,13 @@
+// (C) 2022-2026 GoodData Corporation
+export var MetricInfoKind;
+(function (MetricInfoKind) {
+    MetricInfoKind["Create"] = "CREATE";
+    MetricInfoKind["Edit"] = "EDIT";
+})(MetricInfoKind || (MetricInfoKind = {}));
+export var CloseAllStatus;
+(function (CloseAllStatus) {
+    CloseAllStatus["Close"] = "close";
+    CloseAllStatus["Canceled"] = "canceled";
+    CloseAllStatus["Complete"] = "complete";
+    CloseAllStatus["Incomplete"] = "incomplete";
+})(CloseAllStatus || (CloseAllStatus = {}));

package/esm/MetricComponent/MetricState/useMetricState.d.ts

@@ -0,0 +1,27 @@
+import { type IInsight, type IMeasureMetadataObject, type IMetadataObject, type IWorkspacePermissions } from "@gooddata/sdk-model";
+import { type IDeleteMetricInfo } from "../metric/deleteInfo.js";
+import { type IMeasureDef } from "../metric/metricHelpers.js";
+import { type ISaveMetricInfo } from "../metric/saveInfo.js";
+import { type IMultipleMetricsContextType } from "../MultipleMetricsState.js";
+import { type IMetricInfo, type IMetricInfoDraft } from "./metricState.data.js";
+export interface IUseMetricStateProps {
+    active: number;
+    metrics: IMetricInfo[];
+    permissions?: IWorkspacePermissions;
+    onSave?: (metric: IMeasureMetadataObject, info: ISaveMetricInfo, err: Error | null) => Promise<void> | void;
+    onDelete?: (metric: IMeasureMetadataObject, info: IDeleteMetricInfo, err: Error | null) => void;
+    onDirtyChanged?: (dirty: boolean) => void;
+    onMetricsChange?: (metric: IMeasureDef) => void;
+    activeInsight?: IInsight;
+    insightOpenType?: "external" | "internal";
+    onInsightClick?: (object: IInsight) => void;
+    metricOpenType?: "external" | "internal";
+    onMetricClick?: (object: IMetadataObject) => void;
+    onCancel?: (metricInfo: IMetricInfo) => void;
+    onClose?: (metricInfos: IMetricInfo[]) => void;
+    activateTab?: (metricInfo: IMetricInfo) => void;
+    createTab?: (metricInfo: IMetricInfoDraft) => void;
+    openTab?: (metricInfo: IMetricInfoDraft) => void;
+}
+export declare const useMetricState: ({ active, metrics, permissions, activateTab, createTab, openTab, onSave, onDelete, onDirtyChanged, onMetricsChange, metricOpenType, onMetricClick, activeInsight, insightOpenType, onInsightClick, onClose, onCancel, }: IUseMetricStateProps) => IMultipleMetricsContextType;
+//# sourceMappingURL=useMetricState.d.ts.map

package/esm/MetricComponent/MetricState/useMetricState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMetricState.d.ts","sourceRoot":"","sources":["../../../src/MetricComponent/MetricState/useMetricState.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC7B,MAAM,qBAAqB,CAAC;AAM7B,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EACH,KAAK,WAAW,EAGnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAS9E,OAAO,EAGH,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACxB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,MAAM,CAAC,EAAE,CACL,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,KAAK,GAAG,IAAI,KAChB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,sBAAsB,EAAE,IAAI,EAAE,iBAAiB,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC;IAChG,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;IAChD,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB,eAAe,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC5C,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACzC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;IAClD,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,IAAI,CAAC;IAC7C,OAAO,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC;IAC/C,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,IAAI,CAAC;IAChD,SAAS,CAAC,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACnD,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACpD;AAED,eAAO,MAAM,cAAc,4NAkBxB,oBAAoB,KAAG,2BA2JzB,CAAC"}

package/esm/MetricComponent/MetricState/useMetricState.js

@@ -0,0 +1,127 @@
+// (C) 2022-2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { fullWorkspacePermissions } from "../../shared/permissions.js";
+import { SaveNameMode } from "../Content/EditMetricContent.data.js";
+import { createDraftEditMetricInfo, createDraftNewMetricInfo, } from "../metric/metricHelpers.js";
+import { useChangeIdDialog } from "./hooks/useChangeIdDialog.js";
+import { useDirtyChanged } from "./hooks/useDirtyChanged.js";
+import { useSaveTab } from "./hooks/useSaveTab.js";
+import { revertTabFromMetricInfo, useTabsData } from "./hooks/useTabsData.js";
+import { useUnsavedChanges } from "./hooks/useUnsavedChanges.js";
+import { useUpdateMetricData } from "./hooks/useUpdateMetricData.js";
+import { useUpdateMetricTab } from "./hooks/useUpdateMetricTab.js";
+import { CloseAllStatus, } from "./metricState.data.js";
+export const useMetricState = ({ active, metrics, permissions = fullWorkspacePermissions(), activateTab, createTab, openTab, onSave, onDelete, onDirtyChanged, onMetricsChange, metricOpenType, onMetricClick, activeInsight, insightOpenType, onInsightClick, onClose, onCancel, }) => {
+    const [data, setData] = useTabsData(metrics, active);
+    const { canCreateMetric } = permissions;
+    const updateTab = useUpdateMetricTab(setData);
+    const updateData = useUpdateMetricData(data);
+    const { changeIdDialog, handleChangeId, cancelChangeId, saveChangeId, closeChangeId } = useChangeIdDialog();
+    const saveTabHandler = useSaveTab(handleChangeId, onMetricsChange, onSave);
+    const { unsavedChangesDialog, openUnsavedChangesDialog, closeUnsavedChangesDialog, cancelUnsavedChangesDialog, saveUnsavedChangesDialog, } = useUnsavedChanges(onClose, saveTabHandler);
+    const onCancelCallback = useCallback((tab) => {
+        if (onCancel) {
+            onCancel(tab.data);
+        }
+    }, [onCancel]);
+    const createHandler = useCallback(() => {
+        if (createTab) {
+            createTab(createDraftNewMetricInfo());
+        }
+    }, [createTab]);
+    const closeTabHandler = useCallback((tab) => {
+        if (tab.states?.dirty) {
+            openUnsavedChangesDialog([tab]);
+        }
+        else {
+            if (onClose) {
+                onClose([tab.data]);
+            }
+        }
+    }, [onClose, openUnsavedChangesDialog]);
+    const closeAllTabs = useCallback(() => {
+        const isAnyDirty = data.metrics.some((tab) => tab.states?.dirty === true);
+        if (!isAnyDirty) {
+            const resolvedData = {
+                status: CloseAllStatus.Complete,
+                closedTabs: data.metrics.map((tab) => tab.data),
+                invalidTabs: [],
+            };
+            if (onClose) {
+                onClose(resolvedData.closedTabs);
+            }
+            return Promise.resolve(resolvedData);
+        }
+        return openUnsavedChangesDialog(data.metrics);
+    }, [onClose, openUnsavedChangesDialog, data.metrics]);
+    const activateTabHandler = useCallback((tab) => {
+        if (activateTab) {
+            activateTab(tab.data);
+        }
+    }, [activateTab]);
+    const tabsProps = useMemo(() => ({
+        tabs: data.metrics,
+        active: data.active,
+        creatable: canCreateMetric,
+        onTabActivate: activateTabHandler,
+        onTabClose: closeTabHandler,
+    }), [data, activateTabHandler, closeTabHandler, canCreateMetric]);
+    const onSaveCallback = useCallback((tab, metric, info, err) => {
+        if (!err) {
+            if (metric?.id && info.saveMode === SaveNameMode.saveAsNew) {
+                const { formField, regenerateId, saveMode } = info;
+                updateTab(tab, revertTabFromMetricInfo(tab.data));
+                const metricInfo = createDraftEditMetricInfo(metric, saveMode, formField, regenerateId);
+                if (openTab) {
+                    openTab(metricInfo);
+                }
+            }
+            else {
+                if (onClose) {
+                    onClose([tab.data]);
+                }
+            }
+        }
+        if (onSave) {
+            onSave(metric, info, err);
+        }
+    }, [onSave, onClose, openTab, updateTab]);
+    const onDeleteCallback = useCallback((metric, info, err) => {
+        if (!err) {
+            const metricInfo = metrics.find((item) => item.initial.id === metric.id);
+            if (onClose && metricInfo) {
+                onClose([metricInfo]);
+            }
+        }
+        if (onDelete) {
+            onDelete(metric, info, err);
+        }
+    }, [onDelete, onClose, metrics]);
+    useDirtyChanged(tabsProps.tabs, onDirtyChanged);
+    return {
+        tabsProps,
+        updateTab,
+        updateData,
+        createTab: createHandler,
+        closeTab: closeTabHandler,
+        activateTab: activateTabHandler,
+        onMetricsChange,
+        metricOpenType,
+        onMetricClick,
+        activeInsight,
+        insightOpenType,
+        onInsightClick,
+        onSave: onSaveCallback,
+        onDelete: onDeleteCallback,
+        onCancel: onCancelCallback,
+        unsavedChangesDialog,
+        closeUnsavedChangesDialog,
+        cancelUnsavedChangesDialog,
+        saveUnsavedChangesDialog,
+        closeAllTabs,
+        changeIdDialog,
+        cancelChangeId,
+        saveChangeId,
+        closeChangeId,
+    };
+};

package/esm/MetricComponent/MetricsContext/MetricsContext.d.ts

@@ -0,0 +1,11 @@
+import { type PropsWithChildren } from "react";
+export declare enum MetricContextMode {
+    Single = "single",
+    Multiple = "multiple"
+}
+export interface IMetricsContext {
+    mode: MetricContextMode;
+}
+export declare const MetricsContext: import("react").Context<IMetricsContext>;
+export declare function MetricsContextProvider({ children, ...metricContext }: PropsWithChildren<IMetricsContext>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MetricsContext.d.ts.map

package/esm/MetricComponent/MetricsContext/MetricsContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricsContext.d.ts","sourceRoot":"","sources":["../../../src/MetricComponent/MetricsContext/MetricsContext.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAiB,MAAM,OAAO,CAAC;AAE9D,oBAAY,iBAAiB;IACzB,MAAM,WAAW;IACjB,QAAQ,aAAa;CACxB;AAED,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,iBAAiB,CAAC;CAC3B;AAED,eAAO,MAAM,cAAc,0CAEzB,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,EAAE,QAAQ,EAAE,GAAG,aAAa,EAAE,EAAE,iBAAiB,CAAC,eAAe,CAAC,2CAExG"}

package/esm/MetricComponent/MetricsContext/MetricsContext.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2022-2026 GoodData Corporation
+import { createContext } from "react";
+export var MetricContextMode;
+(function (MetricContextMode) {
+    MetricContextMode["Single"] = "single";
+    MetricContextMode["Multiple"] = "multiple";
+})(MetricContextMode || (MetricContextMode = {}));
+export const MetricsContext = createContext({
+    mode: MetricContextMode.Single,
+});
+export function MetricsContextProvider({ children, ...metricContext }) {
+    return _jsx(MetricsContext.Provider, { value: metricContext, children: children });
+}

package/esm/MetricComponent/MetricsContext/useMetricsContext.d.ts

@@ -0,0 +1,3 @@
+import { type IMetricsContext } from "./MetricsContext.js";
+export declare function useMetricsContext(): IMetricsContext;
+//# sourceMappingURL=useMetricsContext.d.ts.map

package/esm/MetricComponent/MetricsContext/useMetricsContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMetricsContext.d.ts","sourceRoot":"","sources":["../../../src/MetricComponent/MetricsContext/useMetricsContext.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,qBAAqB,CAAC;AAE3E,wBAAgB,iBAAiB,IAAI,eAAe,CAEnD"}

package/esm/MetricComponent/MetricsContext/useMetricsContext.js

@@ -0,0 +1,6 @@
+// (C) 2022-2026 GoodData Corporation
+import { useContext } from "react";
+import { MetricsContext } from "./MetricsContext.js";
+export function useMetricsContext() {
+    return useContext(MetricsContext);
+}

package/esm/MetricComponent/MetricsState.d.ts

@@ -0,0 +1,39 @@
+import { type IInsight, type IMeasureMetadataObject, type IMetadataObject, type ISeparators, type IWorkspacePermissions } from "@gooddata/sdk-model";
+import { type ITab } from "../shared/Tabs/Tab.js";
+import { type ITabsProps } from "../shared/Tabs/Tabs.data.js";
+import { type IPrefixes } from "./Form/Prefixes/PrefixesContext.js";
+import { type IDeleteMetricInfo } from "./metric/deleteInfo.js";
+import { type IMeasureDef } from "./metric/metricHelpers.js";
+import { type ISaveMetricInfo } from "./metric/saveInfo.js";
+import { type IMetricInfo } from "./MetricState/metricState.data.js";
+export interface IMetricStateProps {
+    permissions?: IWorkspacePermissions;
+    prefixes?: IPrefixes;
+    tabsProps: ITabsProps<IMetricInfo>;
+    onDelete?: (metric: IMeasureMetadataObject, info: IDeleteMetricInfo, err: Error | null) => void;
+    onSave?: (tab: ITab<IMetricInfo>, metric: IMeasureMetadataObject, info: ISaveMetricInfo, err: Error | null) => Promise<void> | void;
+    onMetricsChange?: (metric: IMeasureDef) => void;
+    onCancel?: (tab: ITab<IMetricInfo>) => void;
+    onValueChange?: (metric: IMeasureDef, valid: boolean) => void;
+    updateTab: (tab: ITab<IMetricInfo>, props: Partial<ITab<IMetricInfo>>) => void;
+    updateData: (tab: ITab<IMetricInfo>, data: IMetricInfo) => void;
+    closeTab: (tab: ITab<IMetricInfo>) => void;
+    createTab?: () => void;
+    activateTab: (tab: ITab<IMetricInfo>) => void;
+    setMinimized?: (value: boolean) => void;
+    setMaximized?: (value: boolean) => void;
+    closeAllTabs?: () => void;
+    activeInsight?: IInsight;
+    insightOpenType?: "external" | "internal";
+    onInsightClick?: (object: IInsight) => void;
+    metricOpenType?: "external" | "internal";
+    onMetricClick?: (object: IMetadataObject) => void;
+    isWhiteLabeled?: boolean;
+    separators?: ISeparators;
+    maximized?: boolean;
+    useReferences?: boolean;
+    currencyFormatOverride?: string | null;
+    enableMetricFormatOverrides?: boolean;
+}
+export declare function MetricsState({ permissions, prefixes, tabsProps, updateTab, updateData, createTab, closeAllTabs, setMinimized, maximized, setMaximized, metricOpenType, onMetricClick, activeInsight, insightOpenType, onInsightClick, onMetricsChange, onSave, onDelete, onCancel, onValueChange, isWhiteLabeled, separators, useReferences, currencyFormatOverride, enableMetricFormatOverrides, }: IMetricStateProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MetricsState.d.ts.map