fix: support split update animation starts

VChart bar update can split one diffAttrs handoff into channel subset animations.

The first fix matched the snapshot by object identity, so split planner subsets missed it.

Consume the Graphic-owned start snapshot by key while preserving stale-snapshot guards.

Constraint: Split planners replace context.diffAttrs before running each update step
Rejected: Match only original diffAttrs identity | misses valid channel subset planners
Rejected: Store VRender snapshot on consumer context | leaks internals to VChart/VGrammar
Confidence: high
Scope-risk: moderate
Directive: Keep update start snapshots on Graphic and consume them only by matching keys
Tested: vrender-animate animation-runtime-attribute targeted test
Tested: vrender-animate rushx test
Tested: vrender-core state animation and transition targeted tests
Tested: rush compile for vrender-core and vrender-animate
Tested: targeted eslint; perf smoke; git diff --check
Not-tested: VChart browser consumer smoke

Author: xuefei1313

packages/vrender-animate/__tests__/unit/animation-runtime-attribute.test.ts

@@ -991,6 +991,85 @@ describe('D3 pre-handoff animation runtime', () => {
     expect(rect.getFinalAttribute().y).toBe(next.y);
   });
 
+  test('executor update consumes start snapshots after split planners replace diffAttrs by channel subset', () => {
+    const { group, ticker, graphicService } = createStageHarness('executor-update-split-start-snapshot');
+    const initial = {
+      x: 10,
+      y: 50,
+      width: 20,
+      height: 10,
+      visible: true
+    };
+    const next = {
+      ...initial,
+      x: 100,
+      y: 3,
+      height: 34
+    };
+    const rect = createRect(initial);
+    bindGraphicService(rect as any, graphicService);
+    rect.setFinalAttributes(initial);
+    group.appendChild(rect);
+
+    const diffAttrs = {
+      x: next.x,
+      y: next.y,
+      height: next.height
+    };
+    (rect as any).context = {
+      animationState: 'update',
+      diffState: 'update',
+      data: [{ id: 'China_share_global_co2' }],
+      diffAttrs,
+      finalAttrs: next
+    };
+
+    rect.setAttributesAndPreventAnimate(diffAttrs);
+    rect.setFinalAttributes(next);
+
+    (rect as any).context.diffAttrs = {
+      y: next.y,
+      height: next.height
+    };
+    (rect as any).executeAnimation({
+      type: 'update',
+      duration: 300,
+      easing: 'linear'
+    });
+
+    tick(ticker, 150);
+    expect(rect.attribute.y).toBeGreaterThan(next.y);
+    expect(rect.attribute.y).toBeLessThan(initial.y);
+    expect(rect.attribute.height).toBeGreaterThan(initial.height);
+    expect(rect.attribute.height).toBeLessThan(next.height);
+
+    tick(ticker, 150);
+    expect(rect.attribute.y).toBe(next.y);
+    expect(rect.attribute.height).toBe(next.height);
+
+    (rect as any).context.diffAttrs = {
+      x: next.x
+    };
+    (rect as any).executeAnimation({
+      type: 'update',
+      duration: 300,
+      easing: 'linear'
+    });
+
+    tick(ticker, 150);
+    expect(rect.attribute.x).toBeGreaterThan(initial.x);
+    expect(rect.attribute.x).toBeLessThan(next.x);
+
+    tick(ticker, 150);
+    expect(rect.attribute.x).toBe(next.x);
+    expect((rect as any).baseAttributes.x).toBe(next.x);
+    expect((rect as any).baseAttributes.y).toBe(next.y);
+    expect((rect as any).baseAttributes.height).toBe(next.height);
+    expect(rect.getFinalAttribute().x).toBe(next.x);
+    expect(rect.getFinalAttribute().y).toBe(next.y);
+    expect(rect.getFinalAttribute().height).toBe(next.height);
+  });
+
   test('superseded executor update cannot commit stale layout when it ends late', () => {
     const { group, ticker, graphicService } = createStageHarness('executor-update-stale-end');
     const threeItemLayout = {

packages/vrender-animate/src/custom/update.ts

@@ -66,16 +66,13 @@ export class Update extends ACustomAnimate<Record<string, number>> {
     const targetContext = this.target.context ?? ({} as any);
     let { diffAttrs = {} } = targetContext;
     const { options } = this.params as any;
-    const rawDiffAttrs = diffAttrs;
 
     diffAttrs = filterExcludedChannels(diffAttrs, options?.excludeChannels);
 
     this.props = diffAttrs;
     const consumeTransientFromAttrs = (this.target as any).consumeTransientFromAttrsBeforePreventAnimate;
     this.updateFromAttrs =
-      typeof consumeTransientFromAttrs === 'function'
-        ? consumeTransientFromAttrs.call(this.target, rawDiffAttrs, diffAttrs)
-        : null;
+      typeof consumeTransientFromAttrs === 'function' ? consumeTransientFromAttrs.call(this.target, diffAttrs) : null;
     this.clipPathSyncKeys = Object.keys(diffAttrs).filter(key => clipPathGeometryAttrs[key]);
     this.clipPathSyncDisabled = !this.clipPathSyncKeys.length;
     this.syncParentClipPathToTarget();

packages/vrender-core/src/graphic/graphic.ts

@@ -1343,10 +1343,14 @@ export abstract class Graphic<T extends Partial<IGraphicAttribute> = Partial<IGr
       return;
     }
 
-    let fromAttrs: Record<string, any> | null =
-      this.transientFromAttrsBeforePreventAnimateDiffAttrs === diffAttrs
-        ? this.transientFromAttrsBeforePreventAnimate ?? null
-        : null;
+    const sameDiffAttrs = this.transientFromAttrsBeforePreventAnimateDiffAttrs === diffAttrs;
+    let fromAttrs: Record<string, any> | null = sameDiffAttrs
+      ? this.transientFromAttrsBeforePreventAnimate ?? null
+      : null;
+    if (!sameDiffAttrs) {
+      this.transientFromAttrsBeforePreventAnimate = null;
+      this.transientFromAttrsBeforePreventAnimateDiffAttrs = null;
+    }
     let captured = false;
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
@@ -1371,14 +1375,20 @@ export abstract class Graphic<T extends Partial<IGraphicAttribute> = Partial<IGr
     }
   }
 
-  protected consumeTransientFromAttrsBeforePreventAnimate(
-    rawDiffAttrs: Record<string, any>,
-    diffAttrs: Record<string, any>
-  ): Record<string, any> | null {
+  protected consumeTransientFromAttrsBeforePreventAnimate(diffAttrs: Record<string, any>): Record<string, any> | null {
     const transientFromAttrs = this.transientFromAttrsBeforePreventAnimate;
-    if (!transientFromAttrs || this.transientFromAttrsBeforePreventAnimateDiffAttrs !== rawDiffAttrs) {
+    const sourceDiffAttrs = this.transientFromAttrsBeforePreventAnimateDiffAttrs;
+    if (!transientFromAttrs || !sourceDiffAttrs) {
       return null;
     }
+    for (const key in diffAttrs) {
+      if (
+        Object.prototype.hasOwnProperty.call(diffAttrs, key) &&
+        (!Object.prototype.hasOwnProperty.call(sourceDiffAttrs, key) || !isEqual(sourceDiffAttrs[key], diffAttrs[key]))
+      ) {
+        return null;
+      }
+    }
 
     let fromAttrs: Record<string, any> | null = null;
     let remaining = false;