@gooddata/sdk-ui-catalog 11.46.0-alpha.2 → 11.46.0-alpha.4

package/esm/localization/bundles/en-US.localization-bundle.js

@@ -761,6 +761,118 @@ export const en_US = {
         "text": "Parameter could not be deleted.",
         "crowdinContext": "Error toast shown when parameter deletion fails."
     },
+    "analyticsCatalog.metric.dialog.create.title": {
+        "text": "Create metric",
+        "crowdinContext": "Title of the dialog for creating a new metric as code."
+    },
+    "analyticsCatalog.metric.dialog.edit.title": {
+        "text": "Edit metric",
+        "crowdinContext": "Title of the dialog for editing a metric as code."
+    },
+    "analyticsCatalog.metric.dialog.sectionHeader": {
+        "text": "Metric definition",
+        "crowdinContext": "Header above the as-code editor in the metric dialog."
+    },
+    "analyticsCatalog.metric.dialog.sectionHeader.tooltip": {
+        "text": "Define the metric in YAML, including its MAQL expression and format.",
+        "crowdinContext": "Tooltip explaining the as-code metric editor."
+    },
+    "analyticsCatalog.metric.dialog.create.submit": {
+        "text": "Create",
+        "crowdinContext": "Submit button of the create metric dialog."
+    },
+    "analyticsCatalog.metric.dialog.edit.submit": {
+        "text": "Save",
+        "crowdinContext": "Submit button of the edit metric dialog."
+    },
+    "analyticsCatalog.metric.actions.openInEditor": {
+        "text": "Open in metric editor",
+        "crowdinContext": "Detail-panel menu action that opens the metric in the standalone metric editor (as opposed to the inline as-code editor)."
+    },
+    "analyticsCatalog.metric.dialog.edit.duplicate": {
+        "text": "Duplicate",
+        "crowdinContext": "Button that duplicates the metric being edited into a new metric."
+    },
+    "analyticsCatalog.metric.dialog.edit.idImmutable": {
+        "text": "The metric id cannot be changed. Use Duplicate to create a metric with a different id.",
+        "crowdinContext": "Validation error shown when the user changes the id while editing a metric."
+    },
+    "analyticsCatalog.metric.dialog.cancel": {
+        "text": "Cancel",
+        "crowdinContext": "Cancel button of the metric dialogs."
+    },
+    "analyticsCatalog.metric.dialog.help": {
+        "text": "How to write a metric",
+        "crowdinContext": "Help link in the metric as-code dialog."
+    },
+    "analyticsCatalog.metric.dialog.submit.error": {
+        "text": "The metric could not be saved.",
+        "crowdinContext": "Generic error shown when saving a metric fails."
+    },
+    "analyticsCatalog.metric.validation.empty": {
+        "text": "The metric definition cannot be empty.",
+        "crowdinContext": "Validation error shown when the metric editor is empty."
+    },
+    "analyticsCatalog.metric.validation.syntax": {
+        "text": "The metric definition is not valid YAML.",
+        "crowdinContext": "Validation error shown when the metric YAML has a syntax error."
+    },
+    "analyticsCatalog.metric.validation.invalidStructure": {
+        "text": "The metric definition has an invalid structure.",
+        "crowdinContext": "Validation error shown when the metric YAML does not match the expected structure."
+    },
+    "analyticsCatalog.metric.validation.missingMaql": {
+        "text": "The metric must define a MAQL expression.",
+        "crowdinContext": "Validation error shown when the metric YAML is missing the maql field."
+    },
+    "analyticsCatalog.metric.validation.invalidTags": {
+        "text": "Tags must be a list of text values.",
+        "crowdinContext": "Validation error shown when the metric tags are not a list of strings."
+    },
+    "analyticsCatalog.dialog.error.label": {
+        "text": "Error:",
+        "crowdinContext": "Bold label prefixing the error message in the as-code editor dialogs (metrics, parameters)."
+    },
+    "analyticsCatalog.metric.create.defaultTitle": {
+        "text": "My metric",
+        "crowdinContext": "Default placeholder title seeded into the new-metric as-code editor before the user types their own."
+    },
+    "analyticsCatalog.metric.create.success": {
+        "text": "Metric created.",
+        "crowdinContext": "Toast shown after a metric is created successfully from the Analytics Catalog."
+    },
+    "analyticsCatalog.metric.update.success": {
+        "text": "Metric saved.",
+        "crowdinContext": "Toast shown after a metric is updated successfully from the Analytics Catalog."
+    },
+    "analyticsCatalog.metric.load.error": {
+        "text": "The metric could not be loaded.",
+        "crowdinContext": "Error toast shown when loading a metric for editing or duplication fails."
+    },
+    "analyticsCatalog.metric.dialog.delete.title": {
+        "text": "Delete metric",
+        "crowdinContext": "Title of the confirmation dialog for deleting a metric."
+    },
+    "analyticsCatalog.metric.dialog.delete.body": {
+        "text": "Are you sure you want to delete <b>{name}</b>?",
+        "crowdinContext": "Body of the confirmation dialog for deleting a metric. {name} is the metric title."
+    },
+    "analyticsCatalog.metric.dialog.delete.usageWarning": {
+        "text": "This metric is used by {count, plural, one {# object} other {# objects}}. Deleting it may break them.",
+        "crowdinContext": "Warning shown in the metric delete dialog when the metric is referenced by other objects."
+    },
+    "analyticsCatalog.metric.dialog.delete.submit": {
+        "text": "Delete",
+        "crowdinContext": "Submit button of the delete metric confirmation dialog."
+    },
+    "analyticsCatalog.metric.delete.success": {
+        "text": "Metric deleted.",
+        "crowdinContext": "Toast shown after a metric is deleted successfully from the Analytics Catalog."
+    },
+    "analyticsCatalog.metric.delete.error": {
+        "text": "Metric could not be deleted.",
+        "crowdinContext": "Error toast shown when metric deletion fails."
+    },
     "analyticsCatalog.share.button": {
         "text": "Share",
         "crowdinContext": "Button label opening the share dialog from the catalog detail page."

package/esm/main/Main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Main.d.ts","sourceRoot":"","sources":["../../src/main/Main.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,OAAO,CAAC;AAIxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAelF,KAAK,KAAK,GAAG;IACT,OAAO,EAAE,kBAAkB,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,CAAC;IAClD,aAAa,EAAE,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;IACrE,YAAY,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IAC3C,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,WAAW,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC3E,uBAAuB,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/E,CAAC;AAQF,wBAAgB,IAAI,CAAC,EACjB,OAAO,EACP,SAAS,EACT,IAAI,EACJ,UAAU,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,WAAW,EACX,uBAAuB,EAC1B,EAAE,KAAK,2CAmEP"}
+{"version":3,"file":"Main.d.ts","sourceRoot":"","sources":["../../src/main/Main.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,OAAO,CAAC;AAIxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAclF,KAAK,KAAK,GAAG;IACT,OAAO,EAAE,kBAAkB,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,CAAC;IAClD,aAAa,EAAE,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;IACrE,YAAY,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IAC3C,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,WAAW,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC3E,uBAAuB,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/E,CAAC;AAQF,wBAAgB,IAAI,CAAC,EACjB,OAAO,EACP,SAAS,EACT,IAAI,EACJ,UAAU,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,WAAW,EACX,uBAAuB,EAC1B,EAAE,KAAK,2CAmEP"}

package/esm/main/Main.js

@@ -16,7 +16,6 @@ import { FilterQualityMemo } from "../filter/FilterQuality.js";
 import { FilterResetButtonMemo } from "../filter/FilterResetButton.js";
 import { FilterTagsMemo } from "../filter/FilterTags.js";
 import { FilterVisibilityMemo } from "../filter/FilterVisibility.js";
-import { ObjectTypes } from "../objectType/constants.js";
 import { useIsCatalogQualityEnabled } from "../quality/gate.js";
 import { Table } from "../table/Table.js";
 const messages = defineMessages({
@@ -41,13 +40,13 @@ export function Main({ backend, workspace, open, openedItem, setItemOpened, onOp
                     onCatalogItemNavigation?.(event, ref);
                 }, onCatalogItemCreate: (item) => {
                     setItemOpened(item);
-                    refetchObjectType(ObjectTypes.PARAMETER);
+                    refetchObjectType(item.type);
                 }, onCatalogItemUpdate: (item) => {
                     setItemOpened(item);
                     updateItem(item);
                 }, onCatalogItemDelete: (ref) => {
                     removeItem(ref);
-                    refetchObjectType(ObjectTypes.PARAMETER);
+                    refetchObjectType(ref.type);
                     onCloseDetail();
                 }, onCatalogItemUpdateError: (err) => {
                     addError(messages.updateFailed, {

package/esm/metric/MetricCreateDialog.d.ts

@@ -0,0 +1,11 @@
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { ICatalogItemMeasure } from "../catalogItem/types.js";
+type Props = {
+    sourceDefinition?: IMeasureMetadataObjectDefinition;
+    isLoading?: boolean;
+    onClose: () => void;
+    onCreated?: (item: ICatalogItemMeasure) => void;
+};
+export declare function MetricCreateDialog({ sourceDefinition, isLoading, onClose, onCreated }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MetricCreateDialog.d.ts.map

package/esm/metric/MetricCreateDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricCreateDialog.d.ts","sourceRoot":"","sources":["../../src/metric/MetricCreateDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAG5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAYnE,KAAK,KAAK,GAAG;IACT,gBAAgB,CAAC,EAAE,gCAAgC,CAAC;IACpD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAC;CACnD,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,SAAiB,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,2CA0DpG"}

package/esm/metric/MetricCreateDialog.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { defineMessages, useIntl } from "react-intl";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { definitionToMetricYaml, mergeCopiedMetricDefinition } from "./metricConverter.js";
+import { createCopiedMetric, isDuplicateIdError } from "./metricCopy.js";
+import { MetricDialog } from "./MetricDialog.js";
+import { useMetricMutation } from "./MetricMutationContext.js";
+const messages = defineMessages({
+    metricCreateSuccess: { id: "analyticsCatalog.metric.create.success" },
+    metricCreateDefaultTitle: { id: "analyticsCatalog.metric.create.defaultTitle" },
+});
+export function MetricCreateDialog({ sourceDefinition, isLoading = false, onClose, onCreated }) {
+    const intl = useIntl();
+    const { addSuccess } = useToastMessage();
+    const mutation = useMetricMutation();
+    // The single source of truth for a duplicate's copy semantics (title bump, id derivation, and
+    // which author-owned fields carry over). Undefined for a blank create.
+    const copiedMetric = useMemo(() => (sourceDefinition ? createCopiedMetric(sourceDefinition) : undefined), [sourceDefinition]);
+    const initialMetric = useMemo(() => {
+        if (!copiedMetric) {
+            return {
+                type: "metric",
+                title: intl.formatMessage(messages.metricCreateDefaultTitle),
+                maql: "SELECT 1",
+            };
+        }
+        return definitionToMetricYaml(copiedMetric);
+    }, [copiedMetric, intl]);
+    const copiedId = copiedMetric ? initialMetric.id : undefined;
+    const handleSubmit = useCallback(async (metric) => {
+        // A duplicate layers the author's YAML edits over the copied source so its non-YAML
+        // fields (metricType, isHiddenFromKda) survive the lossy YAML round-trip; a blank create
+        // has no source and persists the parsed YAML as-is.
+        const definition = copiedMetric ? mergeCopiedMetricDefinition(copiedMetric, metric) : metric;
+        let createdMetric;
+        try {
+            createdMetric = await mutation.create(definition);
+        }
+        catch (error) {
+            if (copiedId !== undefined && definition.id === copiedId && isDuplicateIdError(error)) {
+                const { id: _id, ...metricWithoutId } = definition;
+                createdMetric = await mutation.create(metricWithoutId);
+            }
+            else {
+                throw error;
+            }
+        }
+        onCreated?.(createdMetric);
+        onClose();
+        addSuccess(messages.metricCreateSuccess);
+    }, [addSuccess, copiedId, copiedMetric, mutation, onClose, onCreated]);
+    return (_jsx(MetricDialog, { mode: "create", isLoading: isLoading, initialMetric: initialMetric, onClose: onClose, onSubmit: handleSubmit }));
+}

package/esm/metric/MetricDeleteDialog.d.ts

@@ -0,0 +1,9 @@
+import { type ICatalogItemMeasure } from "../catalogItem/types.js";
+type Props = {
+    item: ICatalogItemMeasure;
+    onClose: () => void;
+    onDeleted: () => void;
+};
+export declare function MetricDeleteDialog({ item, onClose, onDeleted }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MetricDeleteDialog.d.ts.map

package/esm/metric/MetricDeleteDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricDeleteDialog.d.ts","sourceRoot":"","sources":["../../src/metric/MetricDeleteDialog.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAcnE,KAAK,KAAK,GAAG;IACT,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,2CA+ErE"}

package/esm/metric/MetricDeleteDialog.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useEffect, useState } from "react";
+import { FormattedMessage, defineMessages, useIntl } from "react-intl";
+import { ConfirmDialog, useToastMessage } from "@gooddata/sdk-ui-kit";
+import {} from "../catalogItem/types.js";
+import { useMetricMutation } from "./MetricMutationContext.js";
+const messages = defineMessages({
+    title: { id: "analyticsCatalog.metric.dialog.delete.title" },
+    body: { id: "analyticsCatalog.metric.dialog.delete.body" },
+    usageWarning: { id: "analyticsCatalog.metric.dialog.delete.usageWarning" },
+    submit: { id: "analyticsCatalog.metric.dialog.delete.submit" },
+    cancel: { id: "analyticsCatalog.metric.dialog.cancel" },
+    deleteSuccess: { id: "analyticsCatalog.metric.delete.success" },
+    deleteError: { id: "analyticsCatalog.metric.delete.error" },
+});
+export function MetricDeleteDialog({ item, onClose, onDeleted }) {
+    const intl = useIntl();
+    const { addSuccess, addError } = useToastMessage();
+    const mutation = useMetricMutation();
+    const [isDeleting, setIsDeleting] = useState(false);
+    // undefined until the usage lookup resolves; deletion is withheld until then so the dependent-object
+    // warning can surface before the user can confirm.
+    const [referencingCount, setReferencingCount] = useState(undefined);
+    const displayName = item.title || item.identifier;
+    useEffect(() => {
+        let cancelled = false;
+        mutation
+            .getReferencingObjects(item)
+            .then((referencing) => {
+            if (!cancelled) {
+                const count = (referencing.insights?.length ?? 0) + (referencing.measures?.length ?? 0);
+                setReferencingCount(count);
+            }
+        })
+            .catch(() => {
+            // Usage lookup is advisory; on failure fall back to no warning rather than block deletion.
+            if (!cancelled) {
+                setReferencingCount(0);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [item, mutation]);
+    const handleDelete = useCallback(async () => {
+        setIsDeleting(true);
+        try {
+            await mutation.delete(item);
+            onDeleted();
+            onClose();
+            addSuccess(messages.deleteSuccess);
+        }
+        catch {
+            addError(messages.deleteError);
+            setIsDeleting(false);
+        }
+    }, [addError, addSuccess, item, mutation, onClose, onDeleted]);
+    const handleClose = useCallback(() => {
+        if (!isDeleting) {
+            onClose();
+        }
+    }, [isDeleting, onClose]);
+    return (_jsxs(ConfirmDialog, { headline: intl.formatMessage(messages.title), cancelButtonText: intl.formatMessage(messages.cancel), submitButtonText: intl.formatMessage(messages.submit), isPositive: false, isSubmitDisabled: isDeleting || referencingCount === undefined, isCancelDisabled: isDeleting, showProgressIndicator: isDeleting, onCancel: handleClose, onClose: handleClose, onSubmit: handleDelete, displayCloseButton: !isDeleting, children: [_jsx(FormattedMessage, { ...messages.body, values: {
+                    name: displayName,
+                    b: (chunks) => _jsx("b", { children: chunks }),
+                } }), referencingCount ? (_jsx("div", { children: _jsx(FormattedMessage, { ...messages.usageWarning, values: { count: referencingCount } }) })) : null] }));
+}

package/esm/metric/MetricDetailActions.d.ts

@@ -0,0 +1,23 @@
+import { type MouseEvent } from "react";
+import type { OpenHandlerEvent } from "../catalogDetail/types.js";
+import type { ICatalogItemMeasure, ICatalogItemRef } from "../catalogItem/types.js";
+/**
+ * @internal
+ */
+export interface IMetricDetailActionsProps {
+    item: ICatalogItemMeasure;
+    /** When provided, adds an "Open in metric editor" menu action that opens the standalone editor. */
+    onOpen?: (event: MouseEvent, openEvent: OpenHandlerEvent) => void;
+    canShare?: boolean;
+    onShare?: () => void;
+    onCatalogItemCreate?: (item: ICatalogItemMeasure) => void;
+    onCatalogItemUpdate?: (item: ICatalogItemMeasure) => void;
+    onCatalogItemDelete?: (ref: ICatalogItemRef) => void;
+}
+/**
+ * Detail-panel actions for a metric: inline edit, duplicate, and delete via the as-code editor,
+ * alongside the shared Share button and "Open in metric editor" action.
+ * @internal
+ */
+export declare function MetricDetailActions({ item, onOpen, canShare, onShare, onCatalogItemCreate, onCatalogItemUpdate, onCatalogItemDelete }: IMetricDetailActionsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MetricDetailActions.d.ts.map

package/esm/metric/MetricDetailActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricDetailActions.d.ts","sourceRoot":"","sources":["../../src/metric/MetricDetailActions.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,UAAU,EAMlB,MAAM,OAAO,CAAC;AAWf,OAAO,KAAK,EAAwB,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACxF,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAqBpF;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,mGAAmG;IACnG,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC1D,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC1D,mBAAmB,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;CACxD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAChC,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,OAAO,EACP,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACtB,EAAE,yBAAyB,2CA6H3B"}

package/esm/metric/MetricDetailActions.js

@@ -0,0 +1,101 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useEffect, useMemo, useRef, useState, } from "react";
+import { defineMessages, useIntl } from "react-intl";
+import { useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { catalogDetailActionDelete, catalogDetailActionDuplicate } from "../automation/testIds.js";
+import { CatalogDetailActionBar } from "../catalogDetail/CatalogDetailActionBar.js";
+import { ShareButton } from "../catalogDetail/share/ShareButton.js";
+import { MetricCreateDialog } from "./MetricCreateDialog.js";
+import { MetricDeleteDialog } from "./MetricDeleteDialog.js";
+import { MetricEditDialog } from "./MetricEditDialog.js";
+import { useMetricMutation } from "./MetricMutationContext.js";
+const messages = defineMessages({
+    openInEditor: { id: "analyticsCatalog.metric.actions.openInEditor" },
+    duplicate: { id: "analyticsCatalog.metric.dialog.edit.duplicate" },
+    delete: { id: "analyticsCatalog.metric.dialog.delete.submit" },
+    loadError: { id: "analyticsCatalog.metric.load.error" },
+});
+/**
+ * Detail-panel actions for a metric: inline edit, duplicate, and delete via the as-code editor,
+ * alongside the shared Share button and "Open in metric editor" action.
+ * @internal
+ */
+export function MetricDetailActions({ item, onOpen, canShare, onShare, onCatalogItemCreate, onCatalogItemUpdate, onCatalogItemDelete, }) {
+    const intl = useIntl();
+    const workspaceId = useWorkspaceStrict();
+    const { addError } = useToastMessage();
+    const mutation = useMetricMutation();
+    const [dialog, setDialog] = useState(undefined);
+    const isMounted = useRef(true);
+    useEffect(() => {
+        // Reset on (re)mount: StrictMode runs mount -> cleanup -> remount, and without this the ref
+        // would stay false after the remount even though the component is mounted.
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    const actions = useMemo(() => {
+        const result = [];
+        // The standalone metric editor stays reachable alongside the inline Edit; omitted when the
+        // host does not provide an open handler, so the menu never shows a dead item.
+        if (onOpen) {
+            result.push({ id: "open", label: intl.formatMessage(messages.openInEditor) });
+        }
+        result.push({
+            id: "duplicate",
+            label: intl.formatMessage(messages.duplicate),
+            dataTestId: catalogDetailActionDuplicate,
+        }, {
+            id: "delete",
+            label: intl.formatMessage(messages.delete),
+            isDestructive: true,
+            dataTestId: catalogDetailActionDelete,
+        });
+        return result;
+    }, [intl, onOpen]);
+    const closeDialog = useCallback(() => setDialog(undefined), []);
+    const handleEditOpen = useCallback(() => setDialog({ kind: "edit", item }), [item]);
+    const handleActionsMenuSelect = useCallback(async (actionId, event) => {
+        if (actionId === "open") {
+            onOpen?.(event, {
+                item,
+                workspaceId,
+                newTab: event.metaKey || event.ctrlKey,
+                preventDefault: event.preventDefault.bind(event),
+            });
+            return;
+        }
+        if (actionId === "delete") {
+            setDialog({ kind: "delete", item });
+            return;
+        }
+        if (actionId === "duplicate") {
+            // The catalog item carries no MAQL, so show the create dialog in its loading state
+            // and feed it the copied definition once the full metric is fetched. Only advance
+            // while still in this loading state, so closing the dialog or opening Edit/Delete
+            // meanwhile cancels the duplicate.
+            setDialog({ kind: "duplicate", isLoading: true });
+            try {
+                const measure = await mutation.load(item);
+                if (isMounted.current) {
+                    setDialog((current) => current?.kind === "duplicate" && current.isLoading
+                        ? { kind: "duplicate", sourceDefinition: measure, isLoading: false }
+                        : current);
+                }
+            }
+            catch {
+                if (isMounted.current) {
+                    addError(messages.loadError);
+                    setDialog((current) => current?.kind === "duplicate" && current.isLoading ? undefined : current);
+                }
+            }
+        }
+    }, [addError, item, mutation, onOpen, workspaceId]);
+    const handleEditDuplicate = useCallback((sourceDefinition) => {
+        setDialog({ kind: "duplicate", sourceDefinition, isLoading: false });
+    }, []);
+    return (_jsxs(_Fragment, { children: [_jsx(CatalogDetailActionBar, { item: item, workspaceId: workspaceId, actions: actions, leadingActions: canShare && onShare ? _jsx(ShareButton, { onClick: onShare }) : null, onEditClick: handleEditOpen, onActionsMenuSelect: handleActionsMenuSelect }), dialog?.kind === "edit" ? (_jsx(MetricEditDialog, { item: dialog.item, onClose: closeDialog, onSaved: (saved) => onCatalogItemUpdate?.(saved), onDuplicate: handleEditDuplicate })) : null, dialog?.kind === "duplicate" ? (_jsx(MetricCreateDialog, { sourceDefinition: dialog.sourceDefinition, isLoading: dialog.isLoading, onClose: closeDialog, onCreated: (created) => onCatalogItemCreate?.(created) })) : null, dialog?.kind === "delete" ? (_jsx(MetricDeleteDialog, { item: dialog.item, onClose: closeDialog, onDeleted: () => onCatalogItemDelete?.(dialog.item) })) : null] }));
+}

package/esm/metric/MetricDialog.d.ts

@@ -0,0 +1,14 @@
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { MetricYaml } from "./metricConverter.js";
+export type MetricDialogMode = "create" | "edit";
+type Props = {
+    mode: MetricDialogMode;
+    initialMetric?: MetricYaml;
+    isLoading?: boolean;
+    onClose: () => void;
+    onSubmit: (measure: IMeasureMetadataObjectDefinition) => Promise<void>;
+    onDuplicate?: (measure: IMeasureMetadataObjectDefinition) => void;
+};
+export declare function MetricDialog(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MetricDialog.d.ts.map

package/esm/metric/MetricDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricDialog.d.ts","sourceRoot":"","sources":["../../src/metric/MetricDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAO5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AA0BvD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEjD,KAAK,KAAK,GAAG;IACT,IAAI,EAAE,gBAAgB,CAAC;IAGvB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,CAAC,OAAO,EAAE,gCAAgC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,gCAAgC,KAAK,IAAI,CAAC;CACrE,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,2CA8KxC"}

package/esm/metric/MetricDialog.js

@@ -0,0 +1,100 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { Suspense, lazy, useCallback, useMemo, useRef, useState } from "react";
+import { FormattedMessage, defineMessages, useIntl } from "react-intl";
+import { LoadingComponent } from "@gooddata/sdk-ui";
+import { ConfirmDialog, UiButton, UiIcon, UiLink, UiTooltip } from "@gooddata/sdk-ui-kit";
+import { useIsWhiteLabeled } from "../permission/PermissionsContext.js";
+import { extractBackendErrorDetail } from "../utils/backendError.js";
+import { serializeMetricToYaml } from "./metricSerialization.js";
+import { validateMetricYaml } from "./metricValidation.js";
+const MetricYamlEditor = lazy(() => import("./MetricYamlEditor.js").then((m) => ({ default: m.MetricYamlEditor })));
+const METRIC_DOCS_URL = "https://www.gooddata.ai/docs/cloud/api-and-sdk/vs-code-extension/structures/#metric";
+const messages = defineMessages({
+    empty: { id: "analyticsCatalog.metric.validation.empty" },
+    syntax: { id: "analyticsCatalog.metric.validation.syntax" },
+    invalidStructure: { id: "analyticsCatalog.metric.validation.invalidStructure" },
+    idImmutable: { id: "analyticsCatalog.metric.dialog.edit.idImmutable" },
+    missingMaql: { id: "analyticsCatalog.metric.validation.missingMaql" },
+    invalidTags: { id: "analyticsCatalog.metric.validation.invalidTags" },
+    dialogSubmitError: { id: "analyticsCatalog.metric.dialog.submit.error" },
+    dialogCreateTitle: { id: "analyticsCatalog.metric.dialog.create.title" },
+    dialogEditTitle: { id: "analyticsCatalog.metric.dialog.edit.title" },
+    dialogCreateSubmit: { id: "analyticsCatalog.metric.dialog.create.submit" },
+    dialogEditSubmit: { id: "analyticsCatalog.metric.dialog.edit.submit" },
+    dialogCancel: { id: "analyticsCatalog.metric.dialog.cancel" },
+    dialogDuplicate: { id: "analyticsCatalog.metric.dialog.edit.duplicate" },
+});
+export function MetricDialog(props) {
+    const { mode, initialMetric, isLoading = false, onClose, onSubmit, onDuplicate } = props;
+    const intl = useIntl();
+    const isEdit = mode === "edit";
+    const isWhiteLabeled = useIsWhiteLabeled();
+    const initialYaml = useMemo(() => (initialMetric ? serializeMetricToYaml(initialMetric) : ""), [initialMetric]);
+    // The user's edits; `null` until they type. Submit falls back to `initialYaml`, so the editor
+    // mounts once with real data and is the single source of truth — no re-seed effect needed.
+    const yamlValue = useRef(null);
+    const [validationError, setValidationError] = useState(null);
+    const [submitError, setSubmitError] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [isDirty, setIsDirty] = useState(false);
+    const headlineMessage = intl.formatMessage(isEdit ? messages.dialogEditTitle : messages.dialogCreateTitle);
+    const submitMessage = intl.formatMessage(isEdit ? messages.dialogEditSubmit : messages.dialogCreateSubmit);
+    const cancelMessage = intl.formatMessage(messages.dialogCancel);
+    const fixedIdentifier = isEdit ? initialMetric?.id : undefined;
+    const validate = useCallback((value, allowIdChange = false) => {
+        return validateMetricYaml(value, {
+            fixedIdentifier: isEdit && !allowIdChange ? fixedIdentifier : undefined,
+        });
+    }, [fixedIdentifier, isEdit]);
+    const handleClose = useCallback(() => {
+        if (!isSubmitting) {
+            onClose();
+        }
+    }, [isSubmitting, onClose]);
+    const handleChange = useCallback((nextValue) => {
+        yamlValue.current = nextValue;
+        setIsDirty(true);
+        setSubmitError(null);
+        setValidationError(null);
+    }, []);
+    const handleSubmit = useCallback(async () => {
+        const result = validate(yamlValue.current ?? initialYaml);
+        if (!result.isValid) {
+            setValidationError(intl.formatMessage(messages[result.errorCode]));
+            return;
+        }
+        setIsSubmitting(true);
+        setSubmitError(null);
+        try {
+            await onSubmit(result.measure);
+        }
+        catch (error) {
+            setSubmitError(extractBackendErrorDetail(error) ?? intl.formatMessage(messages.dialogSubmitError));
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [initialYaml, intl, onSubmit, validate]);
+    const handleDuplicate = useCallback(() => {
+        if (!onDuplicate) {
+            return;
+        }
+        setSubmitError(null);
+        const result = validate(yamlValue.current ?? initialYaml, true);
+        if (!result.isValid) {
+            setValidationError(intl.formatMessage(messages[result.errorCode]));
+            return;
+        }
+        onDuplicate(result.measure);
+    }, [initialYaml, intl, onDuplicate, validate]);
+    const footerLeftRenderer = useCallback(() => (_jsxs("div", { className: "gd-ascode-dialog-footer-left", children: [isWhiteLabeled ? null : (_jsxs(UiLink, { variant: "secondary", href: METRIC_DOCS_URL, target: "_blank", rel: "noopener noreferrer", children: [
+                    _jsx(UiIcon, { type: "question", size: 14, color: "complementary-6" }), _jsx(FormattedMessage, { id: "analyticsCatalog.metric.dialog.help" })
+                ] })), isEdit && onDuplicate ? (_jsx(UiButton, { label: intl.formatMessage(messages.dialogDuplicate), variant: "tertiary", isDisabled: isSubmitting || isLoading, onClick: handleDuplicate })) : null] })), [handleDuplicate, intl, isEdit, isLoading, isSubmitting, isWhiteLabeled, onDuplicate]);
+    const bodySpinner = (_jsx("div", { className: "gd-ascode-dialog-loading", children: _jsx(LoadingComponent, {}) }));
+    return (_jsx(ConfirmDialog, { className: "gd-ascode-dialog", containerClassName: "gd-ascode-dialog-overlay", headline: headlineMessage, cancelButtonText: cancelMessage, submitButtonText: submitMessage, isPositive: true, isSubmitDisabled: isSubmitting || isLoading || (isEdit && !isDirty), isCancelDisabled: isSubmitting, shouldCloseOnEscape: !isSubmitting, onCancel: handleClose, onClose: handleClose, onSubmit: handleSubmit, displayCloseButton: !isSubmitting, footerLeftRenderer: footerLeftRenderer, children: _jsx("div", { className: "gd-ascode-dialog-content", children: _jsx(Suspense, { fallback: bodySpinner, children: isLoading ? (bodySpinner) : (_jsxs(_Fragment, { children: [
+                        _jsxs("div", { className: "gd-ascode-dialog-section-header", children: [
+                                _jsx(FormattedMessage, { id: "analyticsCatalog.metric.dialog.sectionHeader" }), _jsx(UiTooltip, { arrowPlacement: "top", optimalPlacement: true, triggerBy: ["hover", "click", "focus"], anchor: _jsx(UiIcon, { type: "question", size: 14, color: "complementary-6" }), content: _jsx(FormattedMessage, { id: "analyticsCatalog.metric.dialog.sectionHeader.tooltip" }) })
+                            ] }), _jsx("div", { className: "gd-ascode-dialog-editor", children: _jsx(MetricYamlEditor, { initialValue: initialYaml, onChange: handleChange, disabled: isSubmitting }) }), validationError || submitError ? (_jsxs("div", { className: "gd-ascode-dialog-error", children: [
+                                _jsx("span", { className: "gd-ascode-dialog-error-label", children: _jsx(FormattedMessage, { id: "analyticsCatalog.dialog.error.label" }) }), " ", validationError ?? submitError] })) : null] })) }) }) }));
+}

package/esm/metric/MetricEditDialog.d.ts

@@ -0,0 +1,11 @@
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+import { type ICatalogItemMeasure } from "../catalogItem/types.js";
+type Props = {
+    item: ICatalogItemMeasure;
+    onClose: () => void;
+    onSaved: (item: ICatalogItemMeasure) => void;
+    onDuplicate?: (metric: IMeasureMetadataObjectDefinition) => void;
+};
+export declare function MetricEditDialog({ item, onClose, onSaved, onDuplicate }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MetricEditDialog.d.ts.map

package/esm/metric/MetricEditDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricEditDialog.d.ts","sourceRoot":"","sources":["../../src/metric/MetricEditDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAA0B,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAIpG,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAWnE,KAAK,KAAK,GAAG;IACT,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC7C,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,gCAAgC,KAAK,IAAI,CAAC;CACpE,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,KAAK,2CA8D9E"}

package/esm/metric/MetricEditDialog.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo } from "react";
+import { defineMessages } from "react-intl";
+import { useCancelablePromise } from "@gooddata/sdk-ui";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import {} from "../catalogItem/types.js";
+import { definitionToMetricYaml, overlayMetricYamlFields } from "./metricConverter.js";
+import { MetricDialog } from "./MetricDialog.js";
+import { useMetricMutation } from "./MetricMutationContext.js";
+const messages = defineMessages({
+    metricUpdateSuccess: { id: "analyticsCatalog.metric.update.success" },
+    metricLoadError: { id: "analyticsCatalog.metric.load.error" },
+});
+export function MetricEditDialog({ item, onClose, onSaved, onDuplicate }) {
+    const { addSuccess, addError } = useToastMessage();
+    const mutation = useMetricMutation();
+    // The catalog item carries only metadata; the full metric (incl. MAQL and fields the YAML does
+    // not carry, such as metricType) is fetched on open and reused as the base for the update. The
+    // fetch is re-run only when the item or backend port changes, and a stale in-flight load is
+    // discarded when they do.
+    const { result: loadedMetric } = useCancelablePromise({
+        promise: () => mutation.load(item),
+        onError: () => {
+            addError(messages.metricLoadError);
+            onClose();
+        },
+    }, [item, mutation]);
+    const handleSubmit = useCallback(async (definition) => {
+        if (!loadedMetric) {
+            return;
+        }
+        const savedMetric = await mutation.update(loadedMetric, definition);
+        onSaved(savedMetric);
+        onClose();
+        addSuccess(messages.metricUpdateSuccess);
+    }, [addSuccess, loadedMetric, mutation, onClose, onSaved]);
+    // The duplicate is seeded from the loaded metric overlaid with the current YAML edits, so the
+    // copy inherits fields the YAML cannot express (metricType, isHiddenFromKda) that the parsed
+    // editor content alone would not carry.
+    const handleDuplicate = useCallback((edited) => {
+        if (!loadedMetric || !onDuplicate) {
+            return;
+        }
+        onDuplicate(overlayMetricYamlFields(loadedMetric, edited));
+    }, [loadedMetric, onDuplicate]);
+    // Undefined until the fetch completes: the eager dialog frame shows an in-frame spinner via
+    // isLoading and mounts the editor (seeded with the real metric) only once this is present.
+    const initialMetric = useMemo(() => (loadedMetric ? definitionToMetricYaml(loadedMetric) : undefined), [loadedMetric]);
+    return (_jsx(MetricDialog, { mode: "edit", isLoading: !loadedMetric, initialMetric: initialMetric, onClose: onClose, onSubmit: handleSubmit, onDuplicate: onDuplicate ? handleDuplicate : undefined }));
+}