[scheduler-premium] Apply review: clear the selection of a dependency whose type becomes unknown

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: rita-codes

packages/x-scheduler-internals-premium/src/event-timeline-premium-selectors/eventTimelinePremiumDependencySelectors.ts

@@ -9,10 +9,9 @@ import type {
 } from '../models';
 import type { EventTimelinePremiumState as State } from '../use-event-timeline-premium';
 import {
-  classifyDependencyEvent,
   groupByEventId,
+  isDependencyActive,
   isDependencyReadOnly,
-  isDependencyType,
 } from '../internals/utils/dependency-utils';
 
 // Typed against the two slices they read, so the scheduling plugin (generic over
@@ -25,12 +24,8 @@ const activeModelListSelector = createSelectorMemoized(
   (dependencyModelLookup, processedEventLookup) =>
     // `dependencyModelLookup` already deduped duplicate ids (last wins) while
     // preserving insertion order, so no separate dedup pass is needed here.
-    Array.from(dependencyModelLookup.values()).filter(
-      (dependency) =>
-        isDependencyType(dependency.type) &&
-        [dependency.source, dependency.target].every(
-          (eventId) => classifyDependencyEvent(processedEventLookup, eventId) === 'ok',
-        ),
+    Array.from(dependencyModelLookup.values()).filter((dependency) =>
+      isDependencyActive(processedEventLookup, dependency),
     ),
 );
 

packages/x-scheduler-internals-premium/src/internals/utils/dependency-utils.ts

@@ -169,3 +169,19 @@ export function classifyDependencyEvent(
   }
   return 'ok';
 }
+
+/**
+ * Whether the timeline renders the dependency: a supported type and two endpoint
+ * events that are known and non-recurring. Shared by the active-list selector and
+ * the selection cleanup, so a dependency the arrows drop can never stay selected.
+ */
+export function isDependencyActive(
+  processedEventLookup: Map<SchedulerEventId, SchedulerProcessedEvent>,
+  dependency: SchedulerDependency,
+): boolean {
+  return (
+    isDependencyType(dependency.type) &&
+    classifyDependencyEvent(processedEventLookup, dependency.source) === 'ok' &&
+    classifyDependencyEvent(processedEventLookup, dependency.target) === 'ok'
+  );
+}

packages/x-scheduler-internals-premium/src/use-event-timeline-premium/EventTimelinePremiumStore.ts

@@ -33,10 +33,7 @@ import {
   EVENT_TIMELINE_PREMIUM_PRESET_DEFINITIONS,
   getPresetPxPerDay,
 } from '../internals/utils/preset-utils';
-import {
-  buildDependenciesState,
-  classifyDependencyEvent,
-} from '../internals/utils/dependency-utils';
+import { buildDependenciesState, isDependencyActive } from '../internals/utils/dependency-utils';
 
 // Sorted by descending px/day (most zoomed-in first). Each preset's `(timeResolution,
 // tickWidth)` must produce a unique px/day — otherwise the order is decided by
@@ -243,11 +240,7 @@ export class EventTimelinePremiumStore<
         return;
       }
       const dependency = dependencyModelLookup.get(selection.id);
-      if (
-        dependency === undefined ||
-        classifyDependencyEvent(processedEventLookup, dependency.source) !== 'ok' ||
-        classifyDependencyEvent(processedEventLookup, dependency.target) !== 'ok'
-      ) {
+      if (dependency === undefined || !isDependencyActive(processedEventLookup, dependency)) {
         this.setSelection(null);
       }
     };

packages/x-scheduler-internals-premium/src/use-event-timeline-premium/tests/dependencies.EventTimelinePremiumStore.test.ts

@@ -877,6 +877,24 @@ describe('Dependencies - EventTimelinePremiumStore', () => {
     expect(store.state.selection).to.equal(null);
   });
 
+  it('should clear the selection when the type of the selected dependency becomes unknown', () => {
+    const store = new EventTimelinePremiumStore(
+      { ...DEFAULT_PARAMS, dependencies: [DEP_AB] },
+      adapter,
+    );
+    store.setSelectedDependencyId('dep-1');
+
+    // Same id, unsupported type: the arrows drop it, so the selection must go too.
+    expect(() => {
+      store.updateStateFromParameters(
+        { ...DEFAULT_PARAMS, dependencies: [{ ...DEP_AB, type: 'FS' as any }] },
+        adapter,
+      );
+    }).toWarnDev(['MUI X Scheduler: The dependency "dep-1" has the unknown type "FS".']);
+
+    expect(store.state.selection).to.equal(null);
+  });
+
   describe('dev warnings', () => {
     it('should warn and keep the feature disabled when onDependenciesChange is provided without dependencies', () => {
       let store!: EventTimelinePremiumStore<any, any>;

packages/x-scheduler-premium/src/event-timeline-premium/tests/dependencyTerminals.EventTimelinePremium.test.tsx

@@ -1649,6 +1649,26 @@ describe('<EventTimelinePremium /> dependency terminals', () => {
       expect(store.state.selection).to.equal(null);
     });
 
+    it('should clear the selection when the type of the selected dependency becomes unknown', async () => {
+      const dependency = buildDependency('dep-1', 'event-a', 'event-b');
+      const view = await renderTimeline({ events: [eventA, eventB], dependencies: [dependency] });
+
+      fireEvent.click(document.querySelector('[data-dependency-hit="dep-1"]')!);
+      expect(view.store.state.selection).to.deep.equal({ type: 'dependency', id: 'dep-1' });
+
+      // Same id, unsupported type: the arrows drop it and the terminals must not
+      // resolve the edges of a type they cannot draw.
+      expect(() => {
+        view.setProps({ dependencies: [{ ...dependency, type: 'FS' as any }] });
+      }).toWarnDev(['MUI X Scheduler: The dependency "dep-1" has the unknown type "FS".']);
+
+      await waitFor(() => {
+        expect(getArrowPaths()).to.have.length(0);
+      });
+      expect(document.querySelector('[data-dependency-delete-button]')).to.equal(null);
+      expect(view.store.state.selection).to.equal(null);
+    });
+
     it('should discard the creation gesture when the timeline unmounts mid-drag', async () => {
       const { store, unmount } = await renderTimeline({
         events: [eventA, eventB],