@ggts-sh/svelte 0.43.0

package/dist/legend/focus-reconcile.svelte.js

@@ -0,0 +1,113 @@
+import { samePropertyKeySet, } from "./focus.js";
+import { reconcileLegendPreview } from "./focus-emphasis.js";
+import { planLegendCommittedReconcile, planLegendFocusDisabledClear, planLegendRovingFocusSync, } from "./focus-plans.js";
+// ---------------------------------------------------------------------------
+// Effect registration
+// ---------------------------------------------------------------------------
+/**
+ * Register the four reconcile effects. Called synchronously from
+ * `installHostDerivedEffects` while the component initializes — never from a
+ * callback or after init.
+ */
+export function installLegendFocusReconcileEffects(ports) {
+    $effect.pre(() => {
+        const count = ports.entries().length;
+        const active = document.activeElement;
+        // Number(dataset.index) may be NaN — pure plan maps non-finite → 0.
+        const focusedIndex = active instanceof HTMLElement &&
+            active.matches("[data-gg-legend-target]") &&
+            (ports.root()?.contains(active) ?? false)
+            ? Number(active.dataset["index"])
+            : null;
+        const currentRoving = ports.rovingIndex();
+        const plan = planLegendRovingFocusSync({
+            currentRoving,
+            entryCount: count,
+            focusedIndex,
+        });
+        if (plan.nextIndex !== currentRoving)
+            ports.setRovingIndex(plan.nextIndex);
+        if (plan.type !== "refocus")
+            return;
+        const returnIndex = plan.returnIndex;
+        queueMicrotask(() => {
+            ports
+                .root()
+                ?.querySelector(`[data-gg-legend-target][data-index="${String(returnIndex)}"]`)
+                ?.focus();
+        });
+    });
+    $effect(() => {
+        const usesLocalEmphasis = ports.interaction() === undefined;
+        const plan = planLegendCommittedReconcile({
+            committed: ports.committed(),
+            entries: ports.entries(),
+            keyIndex: ports.entryKeys().legendEntryKeyIndex,
+            usesLocalEmphasis,
+            // Only consulted when usesLocalEmphasis; store value is the local shadow.
+            localEmphasisCount: usesLocalEmphasis ? ports.emphasisKeys.value.length : 0,
+        });
+        switch (plan.type) {
+            case "noop":
+                return;
+            case "clear-committed":
+                ports.setCommitted(null);
+                break;
+            case "clear-committed-local-emit":
+                ports.setCommitted(null);
+                ports.emphasisKeys.clear("programmatic");
+                ports.emitLegendFocus({
+                    type: "legend-focus",
+                    phase: "clear",
+                    source: "programmatic",
+                });
+                break;
+        }
+    });
+    // Reconcile transient preview when data/domain reshuffles entry membership.
+    $effect(() => {
+        const preview = ports.preview();
+        if (preview === null)
+            return;
+        const next = reconcileLegendPreview({
+            preview: { identity: preview.action.identity, keys: preview.keys },
+            entries: ports.entries(),
+            keyIndex: ports.entryKeys().legendEntryKeyIndex,
+        });
+        if (next === null) {
+            ports.previewLegend(null);
+            return;
+        }
+        if (samePropertyKeySet(next.keys, preview.keys))
+            return;
+        ports.setPreview({
+            action: { ...preview.action, identity: next.identity },
+            keys: next.keys,
+        });
+    });
+    // Drop chart-local emphasis when legend focus is turned off at runtime.
+    // Shared controller emphasis is intentionally retained (clear-host only).
+    $effect(() => {
+        const usesLocalEmphasis = ports.interaction() === undefined;
+        const plan = planLegendFocusDisabledClear({
+            legendFocusEnabled: ports.legendFocusEnabled(),
+            hasPreview: ports.preview() !== null,
+            hasCommitted: ports.committed() !== null,
+            hasLocalEmphasis: usesLocalEmphasis && ports.emphasisKeys.value.length > 0,
+            usesLocalEmphasis,
+        });
+        switch (plan.type) {
+            case "noop":
+                return;
+            case "clear-host":
+                ports.setPreview(null);
+                ports.setCommitted(null);
+                break;
+            case "clear-host-local":
+                ports.setPreview(null);
+                ports.setCommitted(null);
+                ports.emphasisKeys.clear("programmatic");
+                break;
+        }
+    });
+}

package/dist/legend/focus-state.svelte.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Legend-focus controller extracted from GGPlot for S3.
+ *
+ * Owns chart-local emphasis, preview/commit state, roving/touch suppress
+ * flags, and interaction handlers. The four host-derived reconcile effects
+ * live in focus-reconcile.svelte.ts, registered synchronously by
+ * installHostDerivedEffects. Construction-time
+ * deriveds must NOT read model/entryKeys/entries (construction-order DAG).
+ * Those are methods/effects registered after the host declares the later
+ * bindings.
+ */
+import type { CellValue, RenderModel } from "@ggts-sh/core";
+import type { PlotInteractionController } from "../interaction/controller.svelte.js";
+import type { LegendFocusEvent, PlotInteractionEvent, PlotInteractionScope } from "../interaction/interaction.js";
+import type { InteractiveLegendEntry, LegendEntryIdentity } from "./focus.js";
+import type { LegendEntryKeyAccess } from "./entry-key-index.svelte.js";
+export type LegendFocusStateDeps = {
+    interaction: () => PlotInteractionController | undefined;
+    resolvedInteractionScope: () => PlotInteractionScope;
+    legendFocusEnabled: () => boolean;
+    /** Narrow reactive getter over `interactionConfig.legendFocus?.preview`. */
+    legendFocusPreviewEnabled: () => boolean;
+    root: () => HTMLDivElement | null;
+    /**
+     * Legend entry → semantic-key access. Accessed only inside methods /
+     * effects / handlers (declared after the factory in the host).
+     */
+    entryKeys: () => LegendEntryKeyAccess;
+    /**
+     * Component-side interactive entries derived. Read only in effects/handlers.
+     */
+    entries: () => readonly InteractiveLegendEntry[];
+    /**
+     * Host's cached `effectiveLegendPressed` derived (computeLegendPressed over
+     * the current model). Called only from commit handlers — never at
+     * construction — so it may close over a later-declared host binding.
+     */
+    pressed: () => LegendEntryIdentity | null;
+    onlegendfocus: () => ((event: LegendFocusEvent) => void) | undefined;
+    oninteraction: () => ((event: PlotInteractionEvent<Record<string, CellValue>>) => void) | undefined;
+    /** Stable announce sink (not a getter). */
+    announce: (message: string) => void;
+};
+export type LegendFocusState = {
+    readonly effectiveEmphasisKeys: readonly PropertyKey[];
+    readonly previewIdentity: LegendEntryIdentity | null;
+    readonly rovingIndex: number;
+    computeInteractiveEntries(model: RenderModel | null): InteractiveLegendEntry[];
+    computeLegendPressed(model: RenderModel | null): LegendEntryIdentity | null;
+    onPreviewIndex(index: number): void;
+    onPreviewClear(): void;
+    onLegendFocus(index: number): void;
+    onLegendKeydown(event: KeyboardEvent, index: number): void;
+    onLegendPointerDown(event: PointerEvent, index: number): void;
+    onLegendPointerUp(event: PointerEvent, index: number): void;
+    onLegendClick(event: MouseEvent, index: number): void;
+    onLegendBlur(event: FocusEvent): void;
+    clearLegendFromControl(event: MouseEvent): void;
+    setTouchIndexCleared(): void;
+    setClearPointerType(type: string | null): void;
+    /**
+     * Install reconcile effects after host `$derived` entry lists exist.
+     * Irreducible late hook: entries/pressed close over host-held deriveds that
+     * require this factory's compute* methods (#627 — not a sibling-controller cycle).
+     */
+    installHostDerivedEffects(): void;
+};
+/**
+ * Create the legend-focus controller. Construction registers
+ * `effectiveEmphasisKeys`. Call `installHostDerivedEffects` after the host
+ * declares entry/pressed deriveds that this factory's compute* methods feed.
+ */
+export declare function createLegendFocusState(deps: LegendFocusStateDeps): LegendFocusState;

package/dist/legend/focus-state.svelte.js

@@ -0,0 +1,338 @@
+import { createScopedStore } from "../interaction/scoped-store.svelte.js";
+import { legendFocusAnnouncement } from "../assembly/labels.js";
+import { buildInteractiveLegendEntries, moveLegendRovingIndex, samePropertyKeySet, } from "./focus.js";
+import { findLegendPressedIdentity, resolveLegendEmphasisKeys, resolveLegendPreviewKeysDecision, } from "./focus-emphasis.js";
+import { installLegendFocusReconcileEffects, } from "./focus-reconcile.svelte.js";
+import { resolveLegendClearControlSource, resolveLegendClickAction, resolveLegendCommitAction, resolveLegendKeyAction, resolveLegendPointerUpAction, resolveLegendPreviewDismissAction, shouldClearLegendPreviewOnBlur, shouldEmitLegendFocusClear, } from "./surface.js";
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the legend-focus controller. Construction registers
+ * `effectiveEmphasisKeys`. Call `installHostDerivedEffects` after the host
+ * declares entry/pressed deriveds that this factory's compute* methods feed.
+ */
+export function createLegendFocusState(deps) {
+    const emphasisKeys = createScopedStore({
+        initial: [],
+        controller: deps.interaction,
+        scope: deps.resolvedInteractionScope,
+        read: (controller, scope) => controller.emphasized(scope),
+        write: (controller, next, scope, source) => {
+            const transition = controller.setEmphasis(next, { scope, source });
+            if (transition === null)
+                return null;
+            return {
+                value: transition.snapshot.emphases.find((emphasis) => emphasis.scope === scope.keys)?.keys ??
+                    [],
+            };
+        },
+        clearShared: (controller, scope, source) => controller.clearEmphasis({ scope, source }) !== null,
+        same: samePropertyKeySet,
+    });
+    let legendPreview = $state(null);
+    let legendCommitted = $state(null);
+    let legendRovingIndex = $state(0);
+    let legendTouchIndex = -1;
+    let legendClearPointerType = null;
+    let suppressLegendClick = false;
+    let suppressLegendFocusPreview = false;
+    const effectiveEmphasisKeys = $derived.by(() => {
+        const baseKeys = emphasisKeys.value;
+        return resolveLegendEmphasisKeys({
+            legendFocusEnabled: deps.legendFocusEnabled(),
+            previewKeys: legendPreview?.keys ?? null,
+            // Shared: baseKeys are controller-backed. Local: baseKeys fill localKeys.
+            controllerKeys: deps.interaction() === undefined ? null : baseKeys,
+            localKeys: baseKeys,
+        });
+    });
+    function emitLegendFocus(event) {
+        deps.announce(legendFocusAnnouncement(event));
+        deps.onlegendfocus()?.(event);
+        deps.oninteraction()?.(event);
+    }
+    function previewLegend(action) {
+        if (action === null) {
+            // Decision table is pure (legend/surface); host owns emit + mutation.
+            // Emit gate uses committed emphasis, not effectiveEmphasisKeys (preview).
+            // Pure table maps preview source → InteractionSource on non-none actions.
+            const dismiss = resolveLegendPreviewDismissAction({
+                previewSource: legendPreview?.action.source ?? null,
+                committedEmphasisEmpty: emphasisKeys.value.length === 0,
+            });
+            if (dismiss.type === "none")
+                return;
+            legendPreview = null;
+            if (dismiss.type === "clear-and-emit")
+                emitLegendFocus({
+                    type: "legend-focus",
+                    phase: "clear",
+                    source: dismiss.source,
+                });
+            return;
+        }
+        const decision = resolveLegendPreviewKeysDecision({
+            keys: deps.entryKeys().keysForLegend(action),
+            entrySource: action.source,
+        });
+        if (decision.type === "clear") {
+            // Empty domain entry: do not leave the previous entry's preview active.
+            previewLegend(null);
+            return;
+        }
+        legendPreview = { action, keys: decision.keys };
+        emitLegendFocus({
+            type: "legend-focus",
+            phase: "change",
+            state: "transient",
+            source: decision.source,
+            scale: action.identity.scale,
+            value: action.entry.value,
+            label: action.entry.label,
+            keys: decision.keys,
+        });
+    }
+    function clearLegendFocus(source) {
+        const emitClear = shouldEmitLegendFocusClear({
+            hasPreview: legendPreview !== null,
+            hasCommitted: legendCommitted !== null,
+            emphasisKeyCount: effectiveEmphasisKeys.length,
+        });
+        legendPreview = null;
+        legendCommitted = null;
+        emphasisKeys.clear(source);
+        if (emitClear)
+            emitLegendFocus({ type: "legend-focus", phase: "clear", source });
+    }
+    function clearLegendFromControl(event) {
+        const returnTarget = deps
+            .root()
+            ?.querySelector(".gg-legend-target[aria-pressed='true']");
+        const source = resolveLegendClearControlSource({
+            detail: event.detail,
+            pointerType: legendClearPointerType,
+        });
+        legendClearPointerType = null;
+        clearLegendFocus(source);
+        queueMicrotask(() => {
+            if (returnTarget === null || returnTarget === undefined)
+                return;
+            suppressLegendFocusPreview = true;
+            returnTarget.focus();
+            suppressLegendFocusPreview = false;
+        });
+    }
+    function computeInteractiveEntries(model) {
+        if (model === null || !deps.legendFocusEnabled())
+            return [];
+        return buildInteractiveLegendEntries(model.scene.legends);
+    }
+    function computeLegendPressed(model) {
+        const keys = emphasisKeys.value;
+        if (keys.length === 0 || model === null)
+            return null;
+        // Match against all discrete scene legends (not only interactive targets).
+        return findLegendPressedIdentity({
+            keys,
+            entries: buildInteractiveLegendEntries(model.scene.legends),
+            keyIndex: deps.entryKeys().legendEntryKeyIndex,
+            committed: legendCommitted,
+        });
+    }
+    function commitLegend(action) {
+        // Eager key lookup (O(1) Map.get) before pure routing; unused on toggle-clear.
+        const keys = deps.entryKeys().keysForLegend(action);
+        // Host's cached effectiveLegendPressed derived — the single source of
+        // truth shared with aria-pressed, not a per-commit recompute.
+        const commit = resolveLegendCommitAction({
+            pressed: deps.pressed(),
+            identity: action.identity,
+            keyCount: keys.length,
+            entrySource: action.source,
+        });
+        switch (commit.type) {
+            case "toggle-clear":
+                clearLegendFocus(commit.source);
+                break;
+            case "ignore":
+                break;
+            case "commit":
+                legendPreview = null;
+                legendCommitted = { identity: action.identity, keys };
+                emphasisKeys.set([...keys], commit.source);
+                emitLegendFocus({
+                    type: "legend-focus",
+                    phase: "change",
+                    state: "committed",
+                    source: commit.source,
+                    scale: action.identity.scale,
+                    value: action.entry.value,
+                    label: action.entry.label,
+                    keys,
+                });
+                break;
+        }
+    }
+    function legendAction(index, source) {
+        const target = deps.entries()[index];
+        return target === undefined ? null : { identity: target.identity, entry: target.entry, source };
+    }
+    function previewLegendIndex(index, source) {
+        if (!deps.legendFocusPreviewEnabled())
+            return;
+        previewLegend(legendAction(index, source));
+    }
+    function onLegendFocus(index) {
+        if (suppressLegendFocusPreview)
+            return;
+        previewLegendIndex(index, "focus");
+    }
+    function moveLegendFocus(index, key) {
+        const next = moveLegendRovingIndex(index, key, deps.entries().length);
+        legendRovingIndex = next;
+        deps
+            .root()
+            ?.querySelector(`[data-gg-legend-target][data-index="${String(next)}"]`)
+            ?.focus();
+    }
+    function onLegendKeydown(event, index) {
+        // Decision table is pure (legend/surface); this switch owns side
+        // effects only. Roving move, commit, and clear stay host-owned.
+        const { action, preventDefault } = resolveLegendKeyAction({
+            key: event.key,
+        });
+        if (preventDefault)
+            event.preventDefault();
+        switch (action.type) {
+            case "move":
+                moveLegendFocus(index, action.key);
+                break;
+            case "commit": {
+                const next = legendAction(index, "keyboard");
+                if (next !== null)
+                    commitLegend(next);
+                break;
+            }
+            case "clear":
+                clearLegendFocus("keyboard");
+                break;
+            case "none":
+                break;
+        }
+    }
+    function onLegendPointerDown(event, index) {
+        if (event.pointerType === "touch")
+            legendTouchIndex = index;
+    }
+    function onLegendPointerUp(event, index) {
+        // Pure gate: touch + matching legendTouchIndex. Host always clears the
+        // index and sets suppressLegendClick on touch-commit (exact-once with the
+        // synthetic click). pointercancel clears the index in the template.
+        const resolved = resolveLegendPointerUpAction({
+            pointerType: event.pointerType,
+            index,
+            touchIndex: legendTouchIndex,
+        });
+        switch (resolved.type) {
+            case "touch-commit": {
+                legendTouchIndex = -1;
+                suppressLegendClick = true;
+                const next = legendAction(index, "touch");
+                if (next !== null)
+                    commitLegend(next);
+                break;
+            }
+            case "none":
+                break;
+        }
+    }
+    function onLegendClick(event, index) {
+        // Pure priority: suppress (after touch) outranks detail-classified commit.
+        // detail === 0 is current source classification (not an a11y guarantee).
+        const resolved = resolveLegendClickAction({
+            suppressClick: suppressLegendClick,
+            detail: event.detail,
+        });
+        switch (resolved.type) {
+            case "suppress":
+                suppressLegendClick = false;
+                break;
+            case "commit": {
+                const next = legendAction(index, resolved.source);
+                if (next !== null)
+                    commitLegend(next);
+                break;
+            }
+        }
+    }
+    function onLegendBlur(event) {
+        if (!shouldClearLegendPreviewOnBlur({
+            relatedTarget: event.relatedTarget,
+            root: deps.root(),
+        }))
+            return;
+        previewLegend(null);
+    }
+    function setTouchIndexCleared() {
+        legendTouchIndex = -1;
+    }
+    function setClearPointerType(type) {
+        legendClearPointerType = type;
+    }
+    function onPreviewIndex(index) {
+        previewLegendIndex(index, "pointer");
+    }
+    function onPreviewClear() {
+        previewLegend(null);
+    }
+    function installHostDerivedEffects() {
+        installLegendFocusReconcileEffects({
+            entries: deps.entries,
+            entryKeys: deps.entryKeys,
+            root: deps.root,
+            interaction: deps.interaction,
+            legendFocusEnabled: deps.legendFocusEnabled,
+            emphasisKeys,
+            rovingIndex: () => legendRovingIndex,
+            setRovingIndex: (next) => {
+                legendRovingIndex = next;
+            },
+            committed: () => legendCommitted,
+            setCommitted: (next) => {
+                legendCommitted = next;
+            },
+            preview: () => legendPreview,
+            setPreview: (next) => {
+                legendPreview = next;
+            },
+            emitLegendFocus,
+            previewLegend,
+        });
+    }
+    return {
+        get effectiveEmphasisKeys() {
+            return effectiveEmphasisKeys;
+        },
+        get previewIdentity() {
+            return legendPreview?.action.identity ?? null;
+        },
+        get rovingIndex() {
+            return legendRovingIndex;
+        },
+        computeInteractiveEntries,
+        computeLegendPressed,
+        onPreviewIndex,
+        onPreviewClear,
+        onLegendFocus,
+        onLegendKeydown,
+        onLegendPointerDown,
+        onLegendPointerUp,
+        onLegendClick,
+        onLegendBlur,
+        clearLegendFromControl,
+        setTouchIndexCleared,
+        setClearPointerType,
+        installHostDerivedEffects,
+    };
+}

package/dist/legend/focus.d.ts

@@ -0,0 +1 @@
+export { type LegendEntryIdentity, type LegendInteractionSource, type LegendEntryAction, type InteractiveLegendEntry, legendIdentityKey, buildInteractiveLegendEntries, samePropertyKeySet, legendInteractionSource, keysForLegendEntry, clampLegendRovingIndex, moveLegendRovingIndex, } from "@ggts-sh/core/interaction";

package/dist/legend/focus.js

@@ -0,0 +1,2 @@
+// Shared pure behavior used by React and Svelte.
+export { legendIdentityKey, buildInteractiveLegendEntries, samePropertyKeySet, legendInteractionSource, keysForLegendEntry, clampLegendRovingIndex, moveLegendRovingIndex, } from "@ggts-sh/core/interaction";

package/dist/legend/resolve-legend-capability.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared core of the legend channel capabilities (GuideLegend `focus` /
+ * `filter`). Owns the skeleton both share: off when nothing enables the kind,
+ * children define the channel set and route through the capability-specific
+ * merge, a plot prop alone means every channel (`"all"`) and passes the RAW
+ * prop through (same reference — no normalization on that path).
+ *
+ * The capability-specific config merges stay with their owners:
+ * focus = any explicit `preview: false` wins; filter = last explicit
+ * `mode`/`multiple` wins (plot first, then children in registry order).
+ */
+export type LegendChannelSet = ReadonlySet<string> | "all";
+export type ResolvedLegendChannelCapability<TInput> = {
+    /** Opt-in for wiring advisories (truthy even when later checks null it). */
+    readonly requested: TInput | false;
+    /** Value fed to the capability's config consumer. */
+    readonly configInput: TInput | false;
+    /** `"all"` = plot prop only; otherwise the children's channel set. */
+    readonly channels: LegendChannelSet;
+};
+/** Registry layer shape (values may be live getters — read via access). */
+type ChannelLayerLike = {
+    readonly kind: string;
+    readonly value?: unknown;
+};
+type ChannelChild<TInput> = {
+    channel: string;
+    input: Exclude<TInput, false>;
+};
+/**
+ * Combine plot prop + declaration children into one channel capability.
+ * `mergeChildrenConfig` runs ONLY when children are present — plot-alone
+ * returns the raw prop unchanged.
+ */
+export declare function resolveLegendChannelCapability<TInput>(args: {
+    readonly plotProp: TInput | undefined;
+    readonly layers: readonly ChannelLayerLike[];
+    readonly layerKind: string;
+    readonly mergeChildrenConfig: (plotProp: TInput | undefined, children: ReadonlyArray<ChannelChild<TInput>>) => Exclude<TInput, false>;
+}): ResolvedLegendChannelCapability<TInput>;
+/**
+ * Keep entries whose scene legend aesthetics intersect the enabled channel
+ * set. Merged legends expose all aesthetics on `legend.aesthetics` (primary
+ * `scale` alone is not enough).
+ */
+export declare function filterEntriesByChannels<T extends {
+    readonly legend: {
+        readonly scale: string;
+        readonly aesthetics?: readonly string[];
+    };
+}>(entries: readonly T[], channels: LegendChannelSet): T[];
+export {};

package/dist/legend/resolve-legend-capability.js

@@ -0,0 +1,68 @@
+/**
+ * Shared core of the legend channel capabilities (GuideLegend `focus` /
+ * `filter`). Owns the skeleton both share: off when nothing enables the kind,
+ * children define the channel set and route through the capability-specific
+ * merge, a plot prop alone means every channel (`"all"`) and passes the RAW
+ * prop through (same reference — no normalization on that path).
+ *
+ * The capability-specific config merges stay with their owners:
+ * focus = any explicit `preview: false` wins; filter = last explicit
+ * `mode`/`multiple` wins (plot first, then children in registry order).
+ */
+function isEnabledInput(input) {
+    return input !== undefined && input !== false;
+}
+function readChildLayers(layers, layerKind) {
+    const out = [];
+    for (const layer of layers) {
+        if (layer.kind !== layerKind)
+            continue;
+        const value = layer.value;
+        if (value === null || value === undefined)
+            continue;
+        if (!isEnabledInput(value.input))
+            continue;
+        out.push({ channel: value.channel, input: value.input });
+    }
+    return out;
+}
+/**
+ * Combine plot prop + declaration children into one channel capability.
+ * `mergeChildrenConfig` runs ONLY when children are present — plot-alone
+ * returns the raw prop unchanged.
+ */
+export function resolveLegendChannelCapability(args) {
+    const children = readChildLayers(args.layers, args.layerKind);
+    const plotOn = isEnabledInput(args.plotProp);
+    if (children.length === 0 && !plotOn) {
+        return { requested: false, configInput: false, channels: new Set() };
+    }
+    if (children.length > 0) {
+        const configInput = args.mergeChildrenConfig(args.plotProp, children);
+        return {
+            requested: configInput,
+            configInput,
+            channels: new Set(children.map((child) => child.channel)),
+        };
+    }
+    return {
+        requested: args.plotProp ?? false,
+        configInput: args.plotProp ?? false,
+        channels: "all",
+    };
+}
+/**
+ * Keep entries whose scene legend aesthetics intersect the enabled channel
+ * set. Merged legends expose all aesthetics on `legend.aesthetics` (primary
+ * `scale` alone is not enough).
+ */
+export function filterEntriesByChannels(entries, channels) {
+    if (channels === "all")
+        return entries.slice();
+    if (channels.size === 0)
+        return [];
+    return entries.filter((entry) => {
+        const aesthetics = entry.legend.aesthetics ?? [entry.legend.scale];
+        return aesthetics.some((aesthetic) => channels.has(aesthetic));
+    });
+}