feat(dashboard): infer native popup reintegration (#13028) (#13085)

Author: neo-gpt

src/draggable/dashboard/SortZone.mjs

@@ -256,6 +256,33 @@ class DashboardSortZone extends SortZone {
         return config
     }
 
+    /**
+     * @summary Returns a terminal detached popup item for geometry-only reintegration.
+     *
+     * Returns the detached terminal popup item represented by a native OS window.
+     * This is the source side of geometry-only titlebar drag reintegration.
+     * @param {String} windowId
+     * @returns {Object|null}
+     */
+    getNativeWindowDrag(windowId) {
+        let me = this;
+
+        if (!me.owner.detachedItems) {
+            return null
+        }
+
+        for (const [widgetName, detachedItem] of me.owner.detachedItems.entries()) {
+            if (detachedItem.windowId === windowId && detachedItem.terminalDrop && detachedItem.widget) {
+                return {
+                    draggedItem: detachedItem.widget,
+                    widgetName
+                }
+            }
+        }
+
+        return null
+    }
+
     /**
      * Completes dashboard drag cleanup under the base drag-end latch.
      * @param {Object} data The drag end event data.

src/manager/DragCoordinator.mjs

@@ -19,6 +19,18 @@ class DragCoordinator extends Manager {
          * @protected
          */
         singleton: true,
+        /**
+         * Minimum time a native popup must remain over a remote dashboard target before
+         * geometry-only reintegration can commit.
+         * @member {Number} nativeWindowDropDwellMs=450
+         */
+        nativeWindowDropDwellMs: 450,
+        /**
+         * Quiescence delay after the last native window-position update before committing
+         * a geometry-only drop. The browser has no mouseup during OS-titlebar drags.
+         * @member {Number} nativeWindowDropSettleMs=250
+         */
+        nativeWindowDropSettleMs: 250,
         /**
          * @member {Map} sortZones=new Map()
          * @protected
@@ -32,6 +44,187 @@ class DragCoordinator extends Manager {
      */
     activeTargetZone = null
 
+    /**
+     * @member {Map<String,Object>} nativeWindowDropCandidates=new Map()
+     * @protected
+     */
+    nativeWindowDropCandidates = new Map()
+
+    /**
+     * @summary Clears a pending geometry-only native window-drop candidate.
+     *
+     * Clears a pending geometry-only native window-drop candidate.
+     * @param {String} windowId
+     */
+    clearNativeWindowDropCandidate(windowId) {
+        let candidate = this.nativeWindowDropCandidates.get(windowId);
+
+        if (candidate) {
+            clearTimeout(candidate.timeoutId);
+            this.nativeWindowDropCandidates.delete(windowId)
+        }
+    }
+
+    /**
+     * @summary Commits an inferred native-titlebar popup drop into the remote dashboard path.
+     *
+     * Commits a conservative geometry-only native titlebar drop into the existing remote
+     * dashboard drop path. The popup is closed only after dwell/settle intent has been inferred.
+     * @param {String} windowId
+     * @param {Object} candidate
+     * @returns {Promise<void>}
+     */
+    async commitNativeWindowDrop(windowId, candidate) {
+        let me      = this,
+            current = me.nativeWindowDropCandidates.get(windowId);
+
+        if (!current || current !== candidate) {
+            return
+        }
+
+        me.nativeWindowDropCandidates.delete(windowId);
+
+        let {
+            draggedItem,
+            localX,
+            localY,
+            offsetX,
+            offsetY,
+            proxyRect,
+            sourceSortZone,
+            targetSortZone,
+            widgetName
+        } = candidate;
+
+        if (sourceSortZone.getNativeWindowDrag?.(windowId)?.draggedItem !== draggedItem) {
+            return
+        }
+
+        if (!targetSortZone.acceptsRemoteDrag(localX, localY)) {
+            return
+        }
+
+        await sourceSortZone.suspendWindowDrag(widgetName);
+
+        await targetSortZone.onRemoteDragMove({
+            draggedItem,
+            localX,
+            localY,
+            offsetX,
+            offsetY,
+            proxyRect
+        });
+
+        await targetSortZone.onRemoteDrop(draggedItem);
+        sourceSortZone.onRemoteDropOut(draggedItem);
+
+        if (me.activeTargetZone === targetSortZone) {
+            me.activeTargetZone = null
+        }
+    }
+
+    /**
+     * @summary Finds the terminal detached dashboard item represented by a native popup window.
+     *
+     * Finds the terminal detached dashboard item represented by a native popup window.
+     * @param {String} windowId
+     * @returns {Object|null}
+     */
+    getNativeWindowDragSource(windowId) {
+        let me = this;
+
+        for (const group of me.sortZones.values()) {
+            for (const sortZone of group.values()) {
+                let drag = sortZone.getNativeWindowDrag?.(windowId);
+
+                if (drag) {
+                    return {
+                        ...drag,
+                        sourceSortZone: sortZone
+                    }
+                }
+            }
+        }
+
+        return null
+    }
+
+    /**
+     * @summary Resolves a window at a point while excluding invalid native-titlebar targets.
+     *
+     * Resolves the first window at a global point while ignoring window ids that
+     * cannot be valid native-titlebar drop targets, especially the popup being moved.
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Set<String>} excludedWindowIds
+     * @returns {String|null}
+     */
+    getWindowAtExcept(x, y, excludedWindowIds) {
+        let item = Window.items?.find(item => !excludedWindowIds.has(item.id) &&
+            item.outerRect?.intersects({bottom: y, right: x, x, y}));
+
+        return item ? item.id : null
+    }
+
+    /**
+     * @summary Resolves native popup geometry to a remote dashboard drop candidate.
+     *
+     * Resolves a native popup's current geometry to a remote dashboard drop candidate.
+     * @param {Object} data
+     * @param {String} data.windowId
+     * @param {Object} sourceDrag
+     * @returns {Object|null}
+     */
+    getNativeWindowDropCandidate(data, sourceDrag) {
+        let me             = this,
+            {sourceSortZone} = sourceDrag,
+            popupWindow    = Window.get(data.windowId),
+            popupRect      = popupWindow?.innerRect,
+            {sortGroup}    = sourceSortZone,
+            targetWindowId, targetSortZone, targetWindow, localX, localY, width, height;
+
+        if (!popupRect || !sortGroup) {
+            return null
+        }
+
+        localX = popupRect.x + popupRect.width  / 2;
+        localY = popupRect.y + popupRect.height / 2;
+
+        targetWindowId = me.getWindowAtExcept(localX, localY, new Set([data.windowId, sourceSortZone.windowId]));
+
+        if (!targetWindowId) {
+            return null
+        }
+
+        targetSortZone = me.sortZones.get(sortGroup)?.get(targetWindowId);
+        targetWindow   = Window.get(targetWindowId);
+
+        if (!targetSortZone || !targetWindow?.innerRect) {
+            return null
+        }
+
+        localX = localX - targetWindow.innerRect.x;
+        localY = localY - targetWindow.innerRect.y;
+
+        if (!targetSortZone.acceptsRemoteDrag(localX, localY)) {
+            return null
+        }
+
+        width  = popupRect.width;
+        height = popupRect.height;
+
+        return {
+            ...sourceDrag,
+            localX,
+            localY,
+            offsetX  : width  / 2,
+            offsetY  : height / 2,
+            proxyRect: new Rectangle(localX - width / 2, localY - height / 2, width, height),
+            targetSortZone,
+            targetWindowId
+        }
+    }
+
     /**
      * @param {Neo.draggable.container.SortZone} sourceSortZone
      * @param {Neo.component.Base} draggedItem
@@ -114,6 +307,57 @@ class DragCoordinator extends Manager {
         me.handleVoid(sourceSortZone, draggedItem, proxyRect)
     }
 
+    /**
+     * @summary Handles geometry updates for native OS-titlebar popup reintegration.
+     *
+     * Consumes high-frequency window geometry updates for native OS-titlebar popup drags,
+     * where the browser does not emit pointer move/up events. A terminal detached popup
+     * reintegrates only after it remains over a remote dashboard target long enough to
+     * satisfy the settle/dwell intent contract.
+     * @param {Object} data
+     * @param {String} data.windowId
+     */
+    onWindowPositionChange(data) {
+        let me         = this,
+            {windowId} = data,
+            sourceDrag = me.getNativeWindowDragSource(windowId),
+            candidate, current, dwellRemaining, firstSeenAt, delay, now;
+
+        if (!sourceDrag) {
+            me.clearNativeWindowDropCandidate(windowId);
+            return
+        }
+
+        candidate = me.getNativeWindowDropCandidate(data, sourceDrag);
+
+        if (!candidate) {
+            me.clearNativeWindowDropCandidate(windowId);
+            return
+        }
+
+        now     = Date.now();
+        current = me.nativeWindowDropCandidates.get(windowId);
+
+        firstSeenAt = current?.targetSortZone === candidate.targetSortZone &&
+            current?.draggedItem === candidate.draggedItem
+                ? current.firstSeenAt
+                : now;
+
+        me.clearNativeWindowDropCandidate(windowId);
+
+        dwellRemaining = Math.max(0, me.nativeWindowDropDwellMs - (now - firstSeenAt));
+        delay          = Math.max(me.nativeWindowDropSettleMs, dwellRemaining);
+
+        candidate.firstSeenAt = firstSeenAt;
+        candidate.timeoutId   = setTimeout(() => {
+            me.commitNativeWindowDrop(windowId, candidate).catch(error => {
+                (Neo.logError || console.error)('Native window drop failed', error)
+            })
+        }, delay);
+
+        me.nativeWindowDropCandidates.set(windowId, candidate)
+    }
+
     /**
      * Finalizes a dashboard window drag by either dropping into the active target
      * or leaving the source popup as the terminal drop state.
@@ -168,6 +412,12 @@ class DragCoordinator extends Manager {
                 me.sortZones.delete(sortGroup)
             }
         }
+
+        for (const [windowId, candidate] of me.nativeWindowDropCandidates.entries()) {
+            if (candidate.sourceSortZone === sortZone || candidate.targetSortZone === sortZone) {
+                me.clearNativeWindowDropCandidate(windowId)
+            }
+        }
     }
 
     /**

src/worker/App.mjs

@@ -812,6 +812,7 @@ class App extends Base {
     onWindowPositionChange({data}) {
         // Only available in shared workers
         Neo.manager.Window?.onWindowPositionChange(data);
+        Neo.manager.DragCoordinator?.onWindowPositionChange(data);
 
         this.fireMainViewsEvent('windowPositionChange', data)
     }