fix(core): schedule a reconnect() call to match react-dnd's behaviour

Not completely sure why this is necessary, but they do it. I think if a
component changes as a result of a new listen() value being emitted, and
requires reconnecting as a result, this will catch the new DOM element.

Author: cormacrelf

packages/core/src/internal/connection-factory.ts

@@ -119,10 +119,14 @@ export class Connection<TMonitor extends DragSourceMonitor | DropTargetMonitor,
             // this schedules a single batch change detection run after all the listeners have heard their newest value
             // thus all changes resulting from subscriptions to this are caught by the
             // change detector.
-            scheduleMicroTaskAfter(this.skyhookZone)
+            scheduleMicroTaskAfter(this.skyhookZone, this.onUpdate)
         );
     }
 
+    private onUpdate = () => {
+        this.handlerConnector.reconnect();
+    };
+
     connect(fn: (connector: TConnector) => void): Subscription {
         const subscription = this.resolvedType$.pipe(take(1)).subscribe(() => {
             // must run inside skyhookZone, so things like timers firing after a long hover with touch backend

packages/core/src/internal/scheduleMicroTaskAfter.ts

@@ -8,31 +8,31 @@ import { Observable, TeardownLogic, Subscriber, Operator } from 'rxjs';
  * processing all the listeners and are ready for Angular to perform change detection.
  */
 
-export function scheduleMicroTaskAfter<T>(zone: Zone) {
+export function scheduleMicroTaskAfter<T>(zone: Zone, uTask?: () => void) {
     return (source: Observable<T>): Observable<T> => {
-        return source.lift(new RunInZoneOperator(zone));
+        return source.lift(new RunInZoneOperator(zone, uTask));
     };
 }
 
 /**
  * @ignore
  */
 export class ZoneSubscriber<T> extends Subscriber<T> {
-    constructor(destination: Subscriber<T>, private zone: Zone) {
+    constructor(destination: Subscriber<T>, private zone: Zone, private uTask: () => void = (() => {})) {
         super(destination);
     }
     protected _next(val: T) {
         this.destination.next && this.destination.next(val);
-        this.zone.scheduleMicroTask('ZoneSubscriber', () => { });
+        this.zone.scheduleMicroTask('ZoneSubscriber', this.uTask);
     }
 }
 
 /**
  * @ignore
  */
 export class RunInZoneOperator<T, R> implements Operator<T, R> {
-    constructor(private zone: Zone) { }
+    constructor(private zone: Zone, private uTask?: () => void) { }
     call(subscriber: Subscriber<R>, source: any): TeardownLogic {
-        return source.subscribe(new ZoneSubscriber(subscriber, this.zone));
+        return source.subscribe(new ZoneSubscriber(subscriber, this.zone, this.uTask));
     }
 }