@gooddata/sdk-ui-ext 11.55.0-alpha.3 → 11.55.0-alpha.5

package/esm/internal/components/configurationControls/conditionalFormatting/ConditionalFormattingDialog.js

@@ -4,10 +4,12 @@ import { useState } from "react";
 import cx from "classnames";
 import { isEqual } from "lodash-es";
 import { useIntl } from "react-intl";
-import { Button, Overlay } from "@gooddata/sdk-ui-kit";
+import { v4 as uuid } from "uuid";
+import { Button, Overlay, UiCheckbox, UiIconButton, UiTooltip } from "@gooddata/sdk-ui-kit";
 import { conditionalFormattingMessages } from "../../../../locales.js";
+import { DisabledBubbleMessage } from "../../DisabledBubbleMessage.js";
 import { CfSelect } from "./CfSelect.js";
-import { findTargetOption, isDateTarget, isRuleComplete, newCondition, ruleWithTarget, sanitizeRuleForEditing, targetIcon, } from "./conditionalFormattingModel.js";
+import { findTargetOption, isDateTarget, isRuleComplete, newCondition, ruleWithTarget, sanitizeRuleForEditing, targetIcon, targetLocalId, } from "./conditionalFormattingModel.js";
 import { ConditionEditor } from "./ConditionEditor.js";
 import { ReorderList } from "./ReorderList.js";
 // The config panel sits on the right edge of the screen, so open the popover to the LEFT of the
@@ -16,31 +18,85 @@ const POPOVER_ALIGN_POINTS = [
     { align: "cl cr", offset: { x: -5, y: 0 } },
     { align: "cr cl", offset: { x: 5, y: 0 } },
 ];
+// Small "?" info affordance next to the "Use default rule" checkbox. A real `<button>` anchor (not
+// the older BubbleHoverTrigger/Bubble pair, which only wires mouse enter/leave and never forwards
+// focus-related props to its span) so keyboard/screen-reader users can reach it via Tab too; the
+// full text lives in the button's own aria-label, so the floating tooltip is purely visual.
+function InfoTooltip({ text }) {
+    return (_jsx(UiTooltip, { anchor: _jsx("button", { type: "button", className: "gd-cf-dialog__use-default-info gd-icon-circle-question", "aria-label": text }), content: text, accessibilityHidden: true, triggerBy: ["hover", "focus"], arrowPlacement: "right" }));
+}
 /**
  * @internal
  */
-export function ConditionalFormattingDialog({ rule: initialRule, isNew, targetOptions, separators, dateFilterOptions, dateSettings, alignTo, readOnly = false, fixedTarget = false, onSave, onClose, }) {
+export function ConditionalFormattingDialog({ rule: initialRule, isNew, targetOptions, separators, dateFilterOptions, dateSettings, alignTo, fixedTarget = false, semanticByTarget, onDelete, onRevertToDefault, onSave, onClose, }) {
     const intl = useIntl();
-    const initial = readOnly
-        ? initialRule
-        : sanitizeRuleForEditing(initialRule, isDateTarget(findTargetOption(targetOptions, initialRule.target)));
+    const initial = sanitizeRuleForEditing(initialRule, isDateTarget(findTargetOption(targetOptions, initialRule.target)));
     const [rule, setRule] = useState(initial);
-    const updateCondition = (id, next) => setRule((current) => ({
-        ...current,
-        conditions: current.conditions.map((condition) => (condition.id === id ? next : condition)),
-    }));
-    const removeCondition = (id) => setRule((current) => ({
-        ...current,
-        conditions: current.conditions.filter((condition) => condition.id !== id),
-    }));
-    const addCondition = () => setRule((current) => ({
-        ...current,
-        conditions: [
-            ...current.conditions,
-            newCondition(isDateTarget(findTargetOption(targetOptions, current.target))),
-        ],
-    }));
-    const reorderConditions = (conditions) => setRule((current) => ({ ...current, conditions }));
+    // The blank multi-target Add-Rule flow (isNew, no fixedTarget) must keep its target picker fully
+    // usable — starting "Use default rule" checked there just because targetOptions[0] happens to
+    // have a semantic entry would lock the very picker the user needs to choose a different target.
+    // Editing an EXISTING rule (isNew false) never starts locked regardless of fixedTarget, so this
+    // only needs to suppress the brand-new-blank-rule case specifically.
+    const activeSemantic = isNew && !fixedTarget ? undefined : semanticByTarget?.[targetLocalId(rule.target)];
+    // Only meaningful the first time the dialog opens: a target with no authored rule yet (isNew)
+    // and a semantic default to fall back to starts "on" (Inherited); retargeting mid-authoring
+    // never revisits this, matching `ruleWithTarget`'s existing "values reset, mode doesn't" behavior.
+    const [wantsDefault, setWantsDefault] = useState(() => isNew && activeSemantic !== undefined);
+    // A target's semantic default can disappear while this stays open and checked (the catalog
+    // object's rule was deleted elsewhere, or a data-view blip dropped the field) — the checkbox
+    // itself vanishes with it (rendered only when `activeSemantic` exists), which would otherwise
+    // leave fields silently locked with no visible way to unlock them, and Save would revert/delete
+    // against a default that no longer exists. Adjusting `wantsDefault` itself here (during render,
+    // not in an effect, so there's never a paint where the checkbox is still stale) rather than only
+    // deriving `usingDefault` as false makes the unlock permanent: if the default later reappears
+    // while the user has since edited the now-unlocked fields, it must not silently re-lock and
+    // discard that edit via Save's revert branch.
+    if (activeSemantic === undefined && wantsDefault) {
+        setWantsDefault(false);
+    }
+    const usingDefault = wantsDefault && activeSemantic !== undefined;
+    const locked = usingDefault;
+    // While using the default, always render the LIVE semantic conditions (never a stale draft);
+    // the user's own in-progress edits stay in `rule` untouched so unchecking restores them exactly.
+    const displayRule = usingDefault && activeSemantic ? { ...rule, conditions: activeSemantic.conditions } : rule;
+    // Tracks whether `rule.conditions` is still just a mirror of the semantic default (safe to
+    // silently resync/discard) versus genuinely the user's own content (an existing authored rule,
+    // or anything they've edited since) — which must never be clobbered by a later resync. NOT
+    // derivable from `isDirty` two lines below: `isDirty` is unconditionally true whenever `isNew`
+    // (nothing to compare against yet), but a fresh isNew dialog that opens already checked can be
+    // unchecked before any edit — `draftIsDefault` must still read true there (to reseed from the
+    // live default) while `isDirty` already reads true for an unrelated reason. `setConditions`
+    // below sets both together, so a future condition-mutator can't add itself while forgetting
+    // to flip this — the only way to touch `rule.conditions` here goes through it.
+    const [draftIsDefault, setDraftIsDefault] = useState(() => isNew);
+    const setConditions = (updater) => {
+        setDraftIsDefault(false);
+        setRule(updater);
+    };
+    const updateCondition = (id, next) => {
+        setConditions((current) => ({
+            ...current,
+            conditions: current.conditions.map((condition) => (condition.id === id ? next : condition)),
+        }));
+    };
+    const removeCondition = (id) => {
+        setConditions((current) => ({
+            ...current,
+            conditions: current.conditions.filter((condition) => condition.id !== id),
+        }));
+    };
+    const addCondition = () => {
+        setConditions((current) => ({
+            ...current,
+            conditions: [
+                ...current.conditions,
+                newCondition(isDateTarget(findTargetOption(targetOptions, current.target))),
+            ],
+        }));
+    };
+    const reorderConditions = (conditions) => {
+        setConditions((current) => ({ ...current, conditions }));
+    };
     const changeTarget = (value) => {
         const option = targetOptions.find((candidate) => candidate.value === value);
         if (!option) {
@@ -54,11 +110,23 @@ export function ConditionalFormattingDialog({ rule: initialRule, isNew, targetOp
     const suggestions = selectedTarget?.elements ?? [];
     const complete = isRuleComplete(rule, selectedTarget?.date);
     const isDirty = isNew || !isEqual(rule, initial);
-    const title = intl.formatMessage(readOnly
-        ? conditionalFormattingMessages.dialogViewTitle
-        : isNew
+    // A target with a semantic default reads as a plain "Rule" regardless of which side of the
+    // checkbox it's on — the Add/Edit split only applies to targets with no default to switch to.
+    const title = intl.formatMessage(activeSemantic === undefined
+        ? isNew
             ? conditionalFormattingMessages.dialogAddTitle
-            : conditionalFormattingMessages.dialogEditTitle);
+            : conditionalFormattingMessages.dialogEditTitle
+        : conditionalFormattingMessages.dialogRuleTitle);
+    // Nothing authored yet to delete while still on the default — the disabled state points the
+    // user at the (separate) rule-list toggle instead, per the mock's tooltip. Also disabled whenever
+    // the caller hasn't actually given us a way to delete anything: `onDelete` is only real when the
+    // caller (Section today) found an authored rule for this dialog's synthetic-or-real id, so its
+    // absence must disable the button too, not just leave it clickable-but-inert.
+    const deleteDisabled = isNew || !onDelete;
+    // The blank multi-target Add-Rule flow (isNew, no fixedTarget) has nothing to show a delete
+    // affordance for at all — everywhere else (a semantic-fallback view, or an existing authored
+    // rule) shows one, disabled per `deleteDisabled` above when there's genuinely nothing to delete.
+    const showDelete = fixedTarget || !isNew;
     return (_jsx(Overlay, { alignTo: alignTo, alignPoints: POPOVER_ALIGN_POINTS, closeOnParentScroll: true, closeOnMouseDrag: true, onClose: onClose, children: _jsxs("div", { className: "gd-cf-dialog", "aria-label": title, children: [
                 _jsxs("div", { className: "gd-cf-dialog__header", children: [
                         _jsx("h3", { className: "gd-cf-dialog__title", children: title }), _jsx(Button, { className: "gd-button-link gd-button-icon-only gd-icon-cross", accessibilityConfig: {
@@ -67,15 +135,57 @@ export function ConditionalFormattingDialog({ rule: initialRule, isNew, targetOp
                     ] }), _jsxs("div", { className: "gd-cf-dialog__body", children: [
                         _jsx("span", { className: "gd-cf-dialog__label", children: intl.formatMessage(conditionalFormattingMessages.dialogTarget) }), singleTarget ? (_jsxs("div", { className: "gd-cf-dialog__static-target", children: [
                                 _jsx("span", { className: cx("gd-cf-type-icon", targetIcon(singleTarget.target.kind, isDateTarget(singleTarget))), "aria-hidden": "true" }), _jsx("span", { className: "gd-cf-dialog__static-target-title", children: singleTarget.title })
-                            ] })) : (_jsx("fieldset", { className: "gd-cf-dialog__target-picker", disabled: readOnly, children: _jsx(CfSelect, { value: selectedTarget?.value, items: targetOptions.map((option) => ({
+                            ] })) : (_jsx("fieldset", { className: "gd-cf-dialog__target-picker", disabled: locked, children: _jsx(CfSelect, { value: selectedTarget?.value, items: targetOptions.map((option) => ({
                                     value: option.value,
                                     title: option.title,
                                     icon: targetIcon(option.target.kind, isDateTarget(option)),
-                                })), onSelect: changeTarget, placeholder: intl.formatMessage(conditionalFormattingMessages.dialogSelectTarget) }) })), _jsxs("fieldset", { disabled: readOnly, className: cx("gd-cf-dialog__editable", {
-                                "gd-cf-dialog__editable--readonly": readOnly,
-                            }), children: [_jsx(ReorderList, { items: rule.conditions, getKey: (condition) => condition.id, onReorder: reorderConditions, disabled: readOnly, renderItem: (condition, slot) => (_jsx(ConditionEditor, { condition: condition, kind: rule.target.kind, isPercent: isPercent, separators: separators, suggestions: suggestions, date: selectedTarget?.date, dateFilterOptions: dateFilterOptions, dateSettings: dateSettings, removable: rule.conditions.length > 1, slot: slot, readOnly: readOnly, onChange: (next) => updateCondition(condition.id, next), onRemove: () => removeCondition(condition.id) })) }), _jsx(Button, { className: "gd-button-secondary gd-cf-dialog__add-condition", iconLeft: "gd-icon-plus", value: intl.formatMessage(conditionalFormattingMessages.dialogAddCondition), onClick: addCondition })
-                            ] })
-                    ] }), _jsxs("div", { className: "gd-cf-dialog__footer", children: [
-                        _jsx(Button, { className: "gd-button-secondary", value: intl.formatMessage(conditionalFormattingMessages.dialogCancel), onClick: onClose }), readOnly ? null : (_jsx(Button, { className: "gd-button-action", value: intl.formatMessage(conditionalFormattingMessages.dialogSave), disabled: !complete || !isDirty, onClick: () => onSave(rule) }))] })
+                                })), onSelect: changeTarget, placeholder: intl.formatMessage(conditionalFormattingMessages.dialogSelectTarget) }) })), activeSemantic ? (_jsxs("div", { className: "gd-cf-dialog__use-default", children: [
+                                _jsx(UiCheckbox, { checked: usingDefault, onChange: (e) => {
+                                        const nextUseDefault = e.target.checked;
+                                        // Reseed from the live semantic value exactly at the moment of
+                                        // unchecking — but only while the draft is still just a mirror of
+                                        // the default (draftIsDefault): an existing authored rule, or
+                                        // anything the user has actually edited, must never be clobbered.
+                                        // This still fixes the "fresher payload arrived while this stayed
+                                        // checked" case, since fields are locked (nothing to edit) for as
+                                        // long as it's checked, so draftIsDefault can't have gone false then.
+                                        if (!nextUseDefault && activeSemantic && draftIsDefault) {
+                                            // Sanitize like any other externally-authored rule: a
+                                            // semantic condition can carry an operator/value shape this
+                                            // editor doesn't support (e.g. from an AAC-authored default),
+                                            // which would otherwise dead-end with Save disabled.
+                                            setRule((current) => sanitizeRuleForEditing({ ...current, conditions: activeSemantic.conditions }, isDateTarget(selectedTarget)));
+                                        }
+                                        setWantsDefault(nextUseDefault);
+                                    }, label: intl.formatMessage(conditionalFormattingMessages.dialogUseDefaultRule) }), _jsx(InfoTooltip, { text: intl.formatMessage(conditionalFormattingMessages.dialogUseDefaultRuleInfo) })
+                            ] })) : null, _jsxs("fieldset", { disabled: locked, className: cx("gd-cf-dialog__editable", {
+                                "gd-cf-dialog__editable--readonly": locked,
+                            }), children: [_jsx(ReorderList, { items: displayRule.conditions, getKey: (condition) => condition.id, onReorder: reorderConditions, disabled: locked, renderItem: (condition, slot) => (_jsx(ConditionEditor, { condition: condition, kind: rule.target.kind, isPercent: isPercent, separators: separators, suggestions: suggestions, date: selectedTarget?.date, dateFilterOptions: dateFilterOptions, dateSettings: dateSettings, removable: displayRule.conditions.length > 1, slot: slot, readOnly: locked, onChange: (next) => updateCondition(condition.id, next), onRemove: () => removeCondition(condition.id) })) }), locked ? null : (_jsx(Button, { className: "gd-button-secondary gd-cf-dialog__add-condition", iconLeft: "gd-icon-plus", value: intl.formatMessage(conditionalFormattingMessages.dialogAddCondition), onClick: addCondition }))] })
+                    ] }), _jsxs("div", { className: "gd-cf-dialog__footer", children: [showDelete ? (_jsx(DisabledBubbleMessage, { className: "gd-cf-dialog__delete", showDisabledMessage: deleteDisabled, messageId: conditionalFormattingMessages.dialogRuleCannotBeDeleted.id, children: _jsx(UiIconButton, { icon: "trash", size: "small", variant: "tertiary", isDesctructive: true, isDisabled: deleteDisabled, label: intl.formatMessage(conditionalFormattingMessages.ruleDelete), onClick: () => {
+                                    onDelete?.();
+                                    onClose();
+                                } }) })) : null, _jsx(Button, { className: "gd-button-secondary", value: intl.formatMessage(conditionalFormattingMessages.dialogCancel), onClick: onClose }), _jsx(Button, { className: "gd-button-action", value: intl.formatMessage(conditionalFormattingMessages.dialogSave), disabled: usingDefault ? false : !complete || !isDirty, onClick: () => {
+                                if (usingDefault) {
+                                    // Revert (not delete-this-one): clears every rule already stored
+                                    // against the CURRENT target, plus this rule's own id — needed
+                                    // together because a retarget-then-revert (no fixedTarget) means
+                                    // the rule being edited may still sit under its OLD target in
+                                    // `rules`, not yet the one now selected in this draft. Gated on
+                                    // `isNew` alone, deliberately NOT on `deleteDisabled` — `onDelete` and
+                                    // `onRevertToDefault` are independent optional props, and tying revert
+                                    // eligibility to whether a delete callback happens to be provided
+                                    // would silently skip a valid revert for a caller that only wired one.
+                                    if (!isNew) {
+                                        onRevertToDefault?.(rule.target, rule.id);
+                                    }
+                                    onClose();
+                                    return;
+                                }
+                                // A dialog opened straight from a semantic row (`semanticRuleFor`) still
+                                // carries that display-only synthetic id — give it a real one the instant
+                                // it's actually persisted, exactly like every other freshly authored rule.
+                                onSave(isNew ? { ...rule, id: uuid() } : rule);
+                            } })
+                    ] })
             ] }) }));
 }

package/esm/internal/components/configurationControls/conditionalFormatting/ConditionalFormattingSection.d.ts

@@ -14,6 +14,24 @@ export interface IConditionalFormattingSectionProps {
     separators?: ISeparators;
     isLoading?: boolean;
     pushData?: (data: unknown) => void;
+    /**
+     * Whether insight-level (authored) rules can apply at all — mirrors
+     * `isConditionalFormattingEnabled` in PluggablePivotTableNext.tsx. When `false`, the master
+     * toggle, "Add rule" button, and any authored rule list are hidden entirely: those controls edit
+     * `properties.controls.conditionalFormatting`, which the engine ignores while this is off, so
+     * showing them would let a user "author" formatting that silently never paints. The semantic
+     * block is unaffected — it has its own independent flag below. Defaults to `true` (existing
+     * behavior): most callers only ever render this section when insight-level CF is on.
+     */
+    enableConditionalFormatting?: boolean;
+    /**
+     * Mirrors the engine's own `enableSemanticConditionalFormatting` (set in
+     * PluggablePivotTableNext.tsx from the same setting, by design, today) — a distinct prop rather
+     * than an assumption baked into this component, so the "From semantic layer" block can't drift
+     * out of sync with what the table actually paints if semantic inheritance ever gets its own flag.
+     * Defaults to `false`: never show inherited rows the caller hasn't confirmed the engine will paint.
+     */
+    enableSemanticConditionalFormatting?: boolean;
 }
-export declare function ConditionalFormattingSection({ properties, propertiesMeta, insight, targetData, backend, workspace, dateSettings, separators, isLoading, pushData }: IConditionalFormattingSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function ConditionalFormattingSection({ properties, propertiesMeta, insight, targetData, backend, workspace, dateSettings, separators, isLoading, pushData, enableConditionalFormatting, enableSemanticConditionalFormatting }: IConditionalFormattingSectionProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=ConditionalFormattingSection.d.ts.map

package/esm/internal/components/configurationControls/conditionalFormatting/ConditionalFormattingSection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConditionalFormattingSection.d.ts","sourceRoot":"","sources":["../../../../../src/internal/components/configurationControls/conditionalFormatting/ConditionalFormattingSection.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EACH,KAAK,kBAAkB,EAEvB,KAAK,WAAW,EACnB,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAIrF,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,aAAa,EAWrB,MAAM,iCAAiC,CAAC;AAYzC,MAAM,WAAW,kCAAkC;IAC/C,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,yFAAyF;IACzF,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACtC;AA8GD,wBAAgB,4BAA4B,CAAC,EACzC,UAAU,EACV,cAAc,EACd,OAAO,EACP,UAAU,EACV,OAAO,EACP,SAAS,EACT,YAAY,EACZ,UAAU,EACV,SAAS,EACT,QAAQ,EACX,EAAE,kCAAkC,2CA+KpC"}
+{"version":3,"file":"ConditionalFormattingSection.d.ts","sourceRoot":"","sources":["../../../../../src/internal/components/configurationControls/conditionalFormatting/ConditionalFormattingSection.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EACH,KAAK,kBAAkB,EAEvB,KAAK,WAAW,EACnB,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAIrF,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,aAAa,EAcrB,MAAM,iCAAiC,CAAC;AAYzC,MAAM,WAAW,kCAAkC;IAC/C,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,yFAAyF;IACzF,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC;;;;;;;;OAQG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;;;;OAMG;IACH,mCAAmC,CAAC,EAAE,OAAO,CAAC;CACjD;AAkJD,wBAAgB,4BAA4B,CAAC,EACzC,UAAU,EACV,cAAc,EACd,OAAO,EACP,UAAU,EACV,OAAO,EACP,SAAS,EACT,YAAY,EACZ,UAAU,EACV,SAAS,EACT,QAAQ,EACR,2BAAkC,EAClC,mCAA2C,EAC9C,EAAE,kCAAkC,2CAkSpC"}

package/esm/internal/components/configurationControls/conditionalFormatting/ConditionalFormattingSection.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // (C) 2026 GoodData Corporation
 import { useState } from "react";
 import cx from "classnames";
@@ -8,7 +8,7 @@ import { Button, UiIconButton } from "@gooddata/sdk-ui-kit";
 import { conditionalFormattingMessages } from "../../../../locales.js";
 import { ConfigSection } from "../ConfigSection.js";
 import { ConditionalFormattingDialog } from "./ConditionalFormattingDialog.js";
-import { buildTargetOptions, findTargetOption, isCustomTarget, isDateTarget, isRuleComplete, newRule, semanticRuleFor, targetIcon, targetLocalId, } from "./conditionalFormattingModel.js";
+import { buildTargetOptions, findTargetOption, isCustomTarget, isDateTarget, isRuleComplete, isSuppressedTarget, newRule, semanticRuleFor, targetIcon, targetLocalId, targetToValue, withSuppressedTargets, } from "./conditionalFormattingModel.js";
 import { ReorderList } from "./ReorderList.js";
 import { useCfDateFilterOptions } from "./useCfDateFilterOptions.js";
 const SECTION_ID = "conditionalFormatting_section";
@@ -20,37 +20,50 @@ function RuleChip({ rule, option, invalid, editable, labels, slot, onEdit, onDel
 }
 // A held-open semantic dialog is a snapshot from when "View" was clicked — re-derive it against the
 // current semantic payload every render so it tracks edits, and disappears (rather than showing stale
-// or unrelated rules) once loading clears `targetData.semantic`, the target stops being Inherited (its
-// row left `semanticRows` because it became Custom), or its semantic rule itself is no longer present.
-function resolveActiveDialog(dialog, semanticMap, config) {
+// or unrelated rules) once the target stops being Inherited (an authored rule appeared elsewhere,
+// making the target genuinely Custom) or the target itself is no longer part of the insight at all
+// (removed from its bucket — there's nothing left for a Save to even target). Deliberately does NOT
+// also close it just because the semantic DEFAULT vanished while the target itself is still there
+// (catalog rule removed, a data-view blip) — the dialog's own wantsDefault-recovery logic
+// (ConditionalFormattingDialog.tsx) already handles that gracefully (unlocks, falls back to whatever's
+// in the draft); unmounting it here first would discard an edit made after unchecking "Use default
+// rule" before that logic ever runs. `targetData.semantic` is kept stable across loading transitions
+// so isCustomTarget/target-presence below are the only things that fire on a re-execution, not every
+// one of them.
+function resolveActiveDialog(dialog, semanticMap, config, targetOptions) {
     if (dialog?.kind !== "semantic") {
         return dialog;
     }
     if (isCustomTarget(config, dialog.option.target)) {
         return null;
     }
+    const value = targetToValue(dialog.option.target);
+    if (!targetOptions.some((option) => targetToValue(option.target) === value)) {
+        return null;
+    }
     const current = semanticMap[targetLocalId(dialog.option.target)];
     return current
         ? { kind: "semantic", option: dialog.option, rule: semanticRuleFor(dialog.option, current) }
-        : null;
+        : dialog;
 }
-// `activeDialog.rule.id` alone is stable across a semantic-rule content change (it's target-based, not
-// content-based, per semanticRuleFor) — ConditionalFormattingDialog seeds its local draft from `rule` via
-// useState and won't re-sync on a prop change, so without remounting on content change too, a rule that
-// changes while the (read-only) dialog is open would keep showing what it looked like when opened.
+// Just the (target-based, per semanticRuleFor) id — no need to key on content too: the dialog is
+// handed the live `semanticByTarget` map and re-derives the current semantic conditions from it every
+// render (via `displayRule`), so a semantic-rule update while the dialog is open shows up without a
+// remount. Keying on content as well would risk discarding an in-progress unchecked-and-editing draft
+// if fresh data happened to arrive mid-edit.
 function dialogKey(dialog) {
-    return dialog.kind === "semantic"
-        ? `${dialog.rule.id}:${JSON.stringify(dialog.rule.conditions)}`
-        : dialog.rule.id;
+    return dialog.rule.id;
 }
-// Read-only: no drag handle, no delete — nothing on the row is editable here, only the View
-// button opens the (readOnly) dialog. Turning it off/customizing it is PR-6, not this one.
-function SemanticRuleRow({ option, viewLabel, onView }) {
-    return (_jsxs("div", { className: "gd-cf-rule gd-cf-rule--semantic", children: [
-            _jsx("span", { className: `gd-cf-type-icon ${targetIcon(option.target.kind, isDateTarget(option))}`, "aria-hidden": "true" }), _jsx("span", { className: "gd-cf-rule__title", children: option.title }), _jsx(Button, { className: "gd-button-link gd-cf-rule__view", value: viewLabel, onClick: onView })
-        ] }));
+// No drag handle, no delete row here — the target's own dialog (opened via Edit) carries the
+// "Use default rule" checkbox that switches it to Custom. The row itself only ever offers the
+// on/off toggle (`suppressedTargets` suppression) and, while on, a way to open that dialog.
+function SemanticRuleRow({ option, editLabel, toggleAriaLabel, off, onToggleOff, onEdit, }) {
+    return (_jsxs("div", { className: cx("gd-cf-rule", "gd-cf-rule--semantic", { "gd-cf-rule--off": off }), children: [
+            _jsxs("label", { className: "input-checkbox-toggle s-checkbox-toggle-label gd-cf-rule__toggle", children: [
+                    _jsx("input", { "aria-label": toggleAriaLabel, type: "checkbox", checked: !off, onChange: (e) => onToggleOff(!e.target.checked), className: `s-checkbox-toggle ${off ? "s-disabled" : "s-enabled"}` }), _jsx("span", { className: "input-label-text" })
+                ] }), _jsx("span", { className: `gd-cf-type-icon ${targetIcon(option.target.kind, isDateTarget(option))}`, "aria-hidden": "true" }), _jsx("span", { className: "gd-cf-rule__title", children: option.title }), off ? null : (_jsx(Button, { className: "gd-button-link gd-cf-rule__view", value: editLabel, onClick: onEdit }))] }));
 }
-export function ConditionalFormattingSection({ properties, propertiesMeta, insight, targetData, backend, workspace, dateSettings, separators, isLoading, pushData, }) {
+export function ConditionalFormattingSection({ properties, propertiesMeta, insight, targetData, backend, workspace, dateSettings, separators, isLoading, pushData, enableConditionalFormatting = true, enableSemanticConditionalFormatting = false, }) {
     const intl = useIntl();
     const [dialog, setDialog] = useState(null);
     const config = properties?.controls?.["conditionalFormatting"];
@@ -59,16 +72,36 @@ export function ConditionalFormattingSection({ properties, propertiesMeta, insig
     const targetOptions = insight ? buildTargetOptions(insight, targetData) : [];
     // Only date pickers consume the catalog — skip the backend query when no target is date-eligible.
     const dateFilterOptions = useCfDateFilterOptions(backend, workspace, targetOptions.some(isDateTarget));
-    // Targets inheriting a semantic-layer rule, minus any already Custom (an authored rule or a
-    // customTargets entry). NOT gated on the toggle above: the engine's `enabled` only ever
-    // deactivates the insight's OWN authored rules — an untouched (Inherited) target keeps
-    // painting regardless, so hiding it here would desync the panel from what's on screen.
     const semanticMap = targetData?.semantic ?? {};
-    const semanticRows = targetOptions.flatMap((option) => {
-        const rule = semanticMap[targetLocalId(option.target)];
-        return !rule || isCustomTarget(config, option.target) ? [] : [{ option, semantic: rule }];
-    });
-    const activeDialog = resolveActiveDialog(dialog, semanticMap, config);
+    // Targets with a semantic-layer rule, minus any that have their own authored rule (those render
+    // as a RuleChip above instead). A `suppressedTargets`-suppressed target still renders here (tagged
+    // `off`) — it needs a row to turn back on. NOT gated on the toggle above: the engine's `enabled`
+    // only ever deactivates the insight's OWN authored rules — an untouched (Inherited) target keeps
+    // painting regardless, so hiding it here would desync the panel from what's on screen. IS gated
+    // on `enableSemanticConditionalFormatting`, for the opposite reason: an inherited row the engine
+    // won't actually paint (flag off) would be the desync the paragraph above is trying to avoid. ALSO
+    // gated on `semanticFresh`: unlike an already-open dialog (which the user is already looking at
+    // and which the dialog's own recovery logic protects), a brand-new row opened from a stale map
+    // could let the user View/suppress/customize a rule that's about to be superseded — offer no new
+    // ones while the map is confirmed stale, rather than only guarding the persistence side.
+    const semanticRows = enableSemanticConditionalFormatting && targetData?.semanticFresh !== false
+        ? targetOptions.flatMap((option) => {
+            const rule = semanticMap[targetLocalId(option.target)];
+            const value = targetToValue(option.target);
+            // When insight-level CF is off, the engine never sees `rules` at all (the renderer
+            // passes it `undefined`) — every target resolves as Inherited regardless of what's
+            // still sitting in persisted properties, so a stale authored rule must not hide the
+            // semantic row here either, or the panel would show nothing for a target the table
+            // is actually painting.
+            const hasAuthoredRule = enableConditionalFormatting &&
+                rules.some((existing) => targetToValue(existing.target) === value);
+            if (!rule || hasAuthoredRule) {
+                return [];
+            }
+            return [{ option, semantic: rule, off: isSuppressedTarget(config, option.target) }];
+        })
+        : [];
+    const activeDialog = resolveActiveDialog(dialog, semanticMap, config, targetOptions);
     // `resolveActiveDialog` only hides an invalidated semantic dialog from render — without also
     // clearing the underlying state here, a later data view that happens to carry a rule for the same
     // (possibly stale) target would silently reopen it, with no new View click.
@@ -79,13 +112,48 @@ export function ConditionalFormattingSection({ properties, propertiesMeta, insig
     // it's unknown — don't flash a false "Invalid" badge, don't author a plain-text rule on a date attr.
     const targetDataReady = targetData?.dates !== undefined;
     const canAddRule = !isLoading && targetOptions.length > 0 && targetDataReady;
-    const commit = (rulesNext, enabledNext) => {
+    const commit = (rulesNext, enabledNext, suppressedTargetsNext = config?.suppressedTargets) => {
+        // An entry with no live semantic rule behind it (the catalog's rule was itself removed or
+        // detached elsewhere) suppresses nothing and can never resurface in the panel to be turned
+        // back on — drop it opportunistically on any edit rather than leaving it to accumulate
+        // forever. Guarded three ways: before the first data view, an empty/absent map means "unknown
+        // yet", not "confirmed gone"; `semanticFresh === false` means the map still belongs to a
+        // superseded execution (deliberately NOT gated on `isLoading` instead, which can already read
+        // false before a fresh data view actually lands, or never, if that execution fails — the gap
+        // `semanticFresh` is specifically tracked to close, see ICfTargetData's doc); and a target
+        // temporarily missing from `targetOptions` itself (e.g. removed from the bucket, not from the
+        // catalog) is left untouched — its semantic entry being absent from THIS execution says
+        // nothing about whether its catalog rule still exists, only that it wasn't queried this time.
+        const prunedSuppressedTargets = targetData?.semanticFresh === false || targetData?.semantic === undefined
+            ? suppressedTargetsNext
+            : suppressedTargetsNext?.filter((target) => {
+                const value = targetToValue(target);
+                const inCurrentExecution = targetOptions.some((option) => targetToValue(option.target) === value);
+                return !inCurrentExecution || semanticMap[targetLocalId(target)] !== undefined;
+            });
         // Spread the existing config so version (and any future cross-stack fields) survive an edit.
-        const next = { ...config, enabled: enabledNext, rules: rulesNext };
+        const next = withSuppressedTargets({ ...config, enabled: enabledNext, rules: rulesNext }, prunedSuppressedTargets);
         const cloned = cloneDeep(properties ?? {});
         set(cloned, "controls.conditionalFormatting", next);
         pushData?.({ properties: cloned });
     };
+    // The one place that edits `suppressedTargets` membership for a single target — every other commit
+    // path that touches it (turning suppression on/off, reverting to Inherited, deleting a rule that
+    // leaves a stale entry behind) funnels through here instead of hand-rolling the same add/remove
+    // filter, so `rulesNext` is the only thing each caller still has to think about for itself.
+    const setTargetMode = (target, mode, rulesNext = rules) => {
+        const value = targetToValue(target);
+        const suppressedTargets = config?.suppressedTargets ?? [];
+        const suppressedTargetsNext = mode === "off"
+            ? suppressedTargets.some((existing) => targetToValue(existing) === value)
+                ? suppressedTargets
+                : [...suppressedTargets, target]
+            : suppressedTargets.filter((existing) => targetToValue(existing) !== value);
+        commit(rulesNext, enabled, suppressedTargetsNext);
+    };
+    // Turn a still-Inherited target off (Custom-with-zero-rules, per the engine's suppression
+    // convention) or back on — never touches `rules`, only `suppressedTargets` membership.
+    const setSuppressed = (target, suppressed) => setTargetMode(target, suppressed ? "off" : "inherited");
     const saveRule = (rule, isNew) => {
         const rulesNext = isNew
             ? [...rules, rule]
@@ -95,31 +163,63 @@ export function ConditionalFormattingSection({ properties, propertiesMeta, insig
         commit(rulesNext, isNew ? true : enabled);
         setDialog(null);
     };
-    const deleteRule = (id) => commit(rules.filter((rule) => rule.id !== id), enabled);
+    // Also strips the deleted rule's target from `suppressedTargets`, in case it's stale-listed there
+    // too (e.g. externally-authored data, or a target once suppressed then later given its own
+    // rule without cleanup) — otherwise the target would stay Custom-with-zero-rules (Off) instead
+    // of reverting to Inherited once its last rule is gone, contradicting decision 4's "free
+    // consequence" and the "Use default rule" revert flow this also backs.
+    const deleteRule = (id) => {
+        const rulesNext = rules.filter((rule) => rule.id !== id);
+        const target = rules.find((rule) => rule.id === id)?.target;
+        if (target) {
+            setTargetMode(target, "inherited", rulesNext);
+        }
+        else {
+            commit(rulesNext, enabled);
+        }
+    };
+    // Distinct from `deleteRule`: a target can have several stacked custom rules (the Add flow
+    // doesn't prevent authoring more than one against the same target), so reverting it to
+    // Inherited must clear ALL of them — deleting just the one open in the dialog would leave the
+    // rest still marking the target Custom in `resolvePerTargetConditionalFormatting`. Also clears
+    // `ruleId` specifically (regardless of what target it's currently stored under) so a
+    // retarget-then-revert doesn't strand the edited rule under its original target.
+    const revertToInherited = (target, ruleId) => {
+        const value = targetToValue(target);
+        const rulesNext = rules.filter((rule) => rule.id !== ruleId && targetToValue(rule.target) !== value);
+        setTargetMode(target, "inherited", rulesNext);
+    };
     const chipLabels = {
         invalid: intl.formatMessage(conditionalFormattingMessages.ruleInvalid),
         invalidValue: intl.formatMessage(conditionalFormattingMessages.ruleInvalidValue),
         edit: intl.formatMessage(conditionalFormattingMessages.ruleEdit),
         delete: intl.formatMessage(conditionalFormattingMessages.ruleDelete),
     };
-    const viewLabel = intl.formatMessage(conditionalFormattingMessages.ruleView);
-    return (_jsxs(ConfigSection, { id: SECTION_ID, className: "gd-cf-section", title: conditionalFormattingMessages.sectionTitle.id, propertiesMeta: propertiesMeta, properties: properties, pushData: pushData, canBeToggled: true, toggledOn: enabled, toggleDisabled: isLoading, onToggle: (checked) => commit(rules, checked), children: [
-            _jsx("span", { className: "s-cf-popover-anchor gd-cf-section__anchor" }), _jsxs("div", { className: "gd-cf-section__subcategory", children: [
-                    _jsx("span", { className: "gd-cf-section__rules-label", children: intl.formatMessage(conditionalFormattingMessages.rulesLabel) }), _jsx("span", { className: "gd-cf-section__divider" }), _jsx(Button, { className: "gd-button-link gd-cf-section__add", iconLeft: "gd-icon-plus", value: intl.formatMessage(conditionalFormattingMessages.addRule), disabled: !canAddRule, onClick: () => setDialog({ kind: "custom", rule: newRule(targetOptions[0]), isNew: true }) })
-                ] }), rules.length === 0 ? (
-            // The empty-state hint would contradict an inherited row rendered just below it.
-            semanticRows.length === 0 ? (_jsx("div", { className: "gd-cf-section__empty", children: intl.formatMessage(conditionalFormattingMessages.empty) })) : null) : (_jsx("div", { className: "gd-cf-section__rules", children: _jsx(ReorderList, { items: rules, getKey: (rule) => rule.id, onReorder: (next) => commit(next, enabled), renderItem: (rule, slot) => {
-                        const option = findTargetOption(targetOptions, rule.target);
-                        // A missing target flags immediately; value validation waits for date metadata.
-                        const invalid = !option || (targetDataReady && !isRuleComplete(rule, option.date));
-                        return (_jsx(RuleChip, { rule: rule, option: option, invalid: invalid, editable: targetDataReady, labels: chipLabels, slot: slot, onEdit: () => setDialog({ kind: "custom", rule, isNew: false }), onDelete: () => deleteRule(rule.id) }));
-                    } }) })), semanticRows.length > 0 ? (_jsxs("div", { className: "gd-cf-section__semantic", children: [
+    const editLabel = intl.formatMessage(conditionalFormattingMessages.ruleEdit);
+    const dialogIsNew = activeDialog?.kind === "custom" ? activeDialog.isNew : true;
+    // A "semantic" dialog's synthetic id never matches anything in `rules` — pass a real callback
+    // only when there's an actual rule to delete; the dialog itself (from its own isNew/fixedTarget)
+    // decides whether to render a disabled delete affordance for the "nothing authored yet" case,
+    // not a no-op we hand it.
+    const hasAuthoredRule = activeDialog ? rules.some((rule) => rule.id === activeDialog.rule.id) : false;
+    return (_jsxs(ConfigSection, { id: SECTION_ID, className: "gd-cf-section", title: conditionalFormattingMessages.sectionTitle.id, propertiesMeta: propertiesMeta, properties: properties, pushData: pushData, canBeToggled: enableConditionalFormatting, toggledOn: enabled, toggleDisabled: isLoading, onToggle: (checked) => commit(rules, checked), children: [
+            _jsx("span", { className: "s-cf-popover-anchor gd-cf-section__anchor" }), enableConditionalFormatting ? (_jsxs(_Fragment, { children: [
+                    _jsxs("div", { className: "gd-cf-section__subcategory", children: [
+                            _jsx("span", { className: "gd-cf-section__rules-label", children: intl.formatMessage(conditionalFormattingMessages.rulesLabel) }), _jsx("span", { className: "gd-cf-section__divider" }), _jsx(Button, { className: "gd-button-link gd-cf-section__add", iconLeft: "gd-icon-plus", value: intl.formatMessage(conditionalFormattingMessages.addRule), disabled: !canAddRule, onClick: () => setDialog({ kind: "custom", rule: newRule(targetOptions[0]), isNew: true }) })
+                        ] }), rules.length === 0 ? (
+                    // The empty-state hint would contradict an inherited row rendered just below it.
+                    semanticRows.length === 0 ? (_jsx("div", { className: "gd-cf-section__empty", children: intl.formatMessage(conditionalFormattingMessages.empty) })) : null) : (_jsx("div", { className: "gd-cf-section__rules", children: _jsx(ReorderList, { items: rules, getKey: (rule) => rule.id, onReorder: (next) => commit(next, enabled), renderItem: (rule, slot) => {
+                                const option = findTargetOption(targetOptions, rule.target);
+                                // A missing target flags immediately; value validation waits for date metadata.
+                                const invalid = !option || (targetDataReady && !isRuleComplete(rule, option.date));
+                                return (_jsx(RuleChip, { rule: rule, option: option, invalid: invalid, editable: targetDataReady, labels: chipLabels, slot: slot, onEdit: () => setDialog({ kind: "custom", rule, isNew: false }), onDelete: () => deleteRule(rule.id) }));
+                            } }) }))] })) : null, semanticRows.length > 0 ? (_jsxs("div", { className: "gd-cf-section__semantic", children: [
                     _jsxs("div", { className: "gd-cf-section__subcategory", children: [
                             _jsx("span", { className: "gd-cf-section__rules-label", children: intl.formatMessage(conditionalFormattingMessages.semanticLabel) }), _jsx("span", { className: "gd-cf-section__divider" })
-                        ] }), _jsx("div", { className: "gd-cf-section__rules", children: semanticRows.map(({ option, semantic }) => (_jsx(SemanticRuleRow, { option: option, viewLabel: viewLabel, onView: () => setDialog({
+                        ] }), _jsx("div", { className: "gd-cf-section__rules", children: semanticRows.map(({ option, semantic, off }) => (_jsx(SemanticRuleRow, { option: option, editLabel: editLabel, toggleAriaLabel: intl.formatMessage(conditionalFormattingMessages.semanticToggleAriaLabel, { title: option.title }), off: off, onToggleOff: (nextOff) => setSuppressed(option.target, nextOff), onEdit: () => setDialog({
                                 kind: "semantic",
                                 rule: semanticRuleFor(option, semantic),
                                 option,
                             }) }, option.value))) })
-                ] })) : null, activeDialog ? (_jsx(ConditionalFormattingDialog, { rule: activeDialog.rule, isNew: activeDialog.kind === "custom" && activeDialog.isNew, readOnly: activeDialog.kind === "semantic", fixedTarget: activeDialog.kind === "semantic", targetOptions: targetOptions, separators: separators, dateFilterOptions: dateFilterOptions, dateSettings: dateSettings, alignTo: ".s-cf-popover-anchor", onSave: (rule) => activeDialog.kind === "custom" && saveRule(rule, activeDialog.isNew), onClose: () => setDialog(null) }, dialogKey(activeDialog))) : null] }));
+                ] })) : null, activeDialog ? (_jsx(ConditionalFormattingDialog, { rule: activeDialog.rule, isNew: dialogIsNew, fixedTarget: activeDialog.kind === "semantic", semanticByTarget: semanticMap, targetOptions: targetOptions, separators: separators, dateFilterOptions: dateFilterOptions, dateSettings: dateSettings, alignTo: ".s-cf-popover-anchor", onDelete: hasAuthoredRule ? () => deleteRule(activeDialog.rule.id) : undefined, onRevertToDefault: revertToInherited, onSave: (rule) => saveRule(rule, dialogIsNew), onClose: () => setDialog(null) }, dialogKey(activeDialog))) : null] }));
 }

package/esm/internal/components/configurationControls/conditionalFormatting/conditionalFormattingModel.d.ts

@@ -51,13 +51,21 @@ export interface ICfTargetData {
     dates?: Record<string, ICfDateMeta>;
     /** Semantic-layer conditional formatting carried on the execution result header, by localId. */
     semantic?: Record<string, ISemanticConditionalFormatting>;
+    /**
+     * False while `semantic` still belongs to a superseded execution — distinct from `isLoading`,
+     * which can flip back to false before the new data view actually lands (or never, if that
+     * execution fails), leaving a gap `isLoading` alone can't see. Set false the instant a new
+     * execution starts, true again only once a fresh data view actually rebuilds this object.
+     * Undefined (e.g. in tests that construct this directly) is treated as fresh.
+     */
+    semanticFresh?: boolean;
 }
 /**
  * Extracts {@link ICfTargetData} from the executed data view. Titles must come from here — attribute
  * titles live only on the result headers, and measures resolve to their final header name; formats
  * living on metric metadata also resolve only here (insight-level formats win in buildTargetOptions).
  */
-export declare function buildCfTargetData(dataView: DataViewFacade): Required<ICfTargetData>;
+export declare function buildCfTargetData(dataView: DataViewFacade): Required<Omit<ICfTargetData, "semanticFresh">>;
 export declare function buildTargetOptions(insight: IInsightDefinition, data?: ICfTargetData): ITargetOption[];
 export declare const findTargetOption: (options: ITargetOption[], target: ConditionalFormattingTarget) => ITargetOption | undefined;
 /** Date-eligible target: the option carries execution-resolved date metadata. */
@@ -65,17 +73,36 @@ export declare const isDateTarget: (option: ITargetOption | undefined) => boolea
 export declare const targetLocalId: (target: ConditionalFormattingTarget) => string;
 /**
  * Whether `target` is already in Custom mode on this insight config — an insight rule targets it,
- * or it's explicitly listed in `customTargets`. Mirrors the `customModeTargets` set built by
+ * or it's explicitly listed in `suppressedTargets`. Mirrors the `customModeTargets` set built by
  * sdk-ui-pivot's `resolvePerTargetConditionalFormatting` (semanticConditionalFormatting.ts); the two
  * packages don't share this helper, so keep them in sync by hand if either changes. Honoring
- * `customTargets` here matters even though this PR never writes it: if some other path already
- * marked a target Custom, the semantic block must still hide it as Inherited would be wrong.
+ * `suppressedTargets` here matters regardless of source: the Section's own "Turn off" toggle writes
+ * it (`setSuppressed`/`setTargetMode`), and it can also arrive from AAC or an older panel version —
+ * either way, if a target is already marked Custom, the semantic block must still hide it as
+ * Inherited would be wrong.
  */
 export declare const isCustomTarget: (config: IConditionalFormatting | undefined, target: ConditionalFormattingTarget) => boolean;
 /**
- * Synthesizes a read-only rule for the View dialog from an inherited semantic-layer condition set.
- * The id mirrors the engine's own `semantic:<kind>:<localId>` convention (semanticConditionalFormatting.ts)
- * for consistency only — it's never persisted or compared.
+ * Whether `target` is explicitly suppressed (Custom-with-zero-rules, per the engine's
+ * `resolvePerTargetConditionalFormatting`): listed in `suppressedTargets` with no authored rule.
+ * This is the "Turn off" state for an otherwise-Inherited target — distinct from an authored-Custom
+ * target, which is never in `suppressedTargets` in practice (its own rule already makes it Custom).
+ */
+export declare const isSuppressedTarget: (config: IConditionalFormatting | undefined, target: ConditionalFormattingTarget) => boolean;
+/**
+ * `suppressedTargets` must be OMITTED entirely when empty, never set to `undefined` — persisting the
+ * config as JSON drops an `undefined` value either way, but an in-memory object with an explicit
+ * `suppressedTargets: undefined` key is NOT deep-equal to one where the key is simply absent, which
+ * creates spurious dirty-state noise in the session before that JSON round-trip ever happens. Shared
+ * by every place that builds an `IConditionalFormatting` payload (Section today, a future catalog
+ * authoring adapter next) so this normalization can't be forgotten in one of them.
+ */
+export declare const withSuppressedTargets: (config: IConditionalFormatting, suppressedTargets: readonly ConditionalFormattingTarget[] | undefined) => IConditionalFormatting;
+/**
+ * Synthesizes a rule for the dialog from an inherited semantic-layer condition set, seeding it with
+ * a display-only id (mirroring the engine's own `semantic:<kind>:<localId>` convention in
+ * semanticConditionalFormatting.ts, for consistency only) — the dialog swaps this for a real uuid()
+ * the moment the user customizes and saves, so this synthetic id itself is never persisted.
  */
 export declare const semanticRuleFor: (option: ITargetOption, semantic: ISemanticConditionalFormatting) => IConditionalFormattingRule;
 export declare const operatorsForTarget: (kind: "attribute" | "measure", isDate: boolean) => ConditionalFormattingOperator[];