ng-primitives 0.122.0 → 0.123.0

package/fesm2022/ng-primitives-portal.mjs

@@ -93,6 +93,13 @@ function coerceOffset(value) {
 class NgpOverlayCooldownManager {
     constructor() {
         this.lastCloseTimestamps = new Map();
+        /**
+         * Active overlays per type, stored as a stack ordered oldest-first / topmost-last.
+         * Most types only ever hold a single overlay, but when an overlay is nested inside
+         * another of the same type (e.g. a popover whose trigger lives inside another
+         * popover) the child is pushed on top of its ancestor instead of evicting it.
+         * Closing the child then restores the ancestor as the active overlay.
+         */
         this.activeOverlays = new Map();
     }
     /**
@@ -117,23 +124,50 @@ class NgpOverlayCooldownManager {
     }
     /**
      * Register an overlay as active for its type.
-     * Any existing overlay of the same type will be closed immediately.
+     *
+     * Any existing overlay of the same type is closed immediately so that only one
+     * overlay of each type is open at a time - *unless* it is an ancestor of the
+     * overlay being registered. A nested overlay (its trigger rendered inside an
+     * ancestor overlay's content) is stacked on top of its ancestor instead of
+     * evicting it, allowing legitimate nesting to coexist while sibling overlays
+     * still replace one another.
+     *
      * @param overlayType The type identifier for the overlay group
      * @param overlay The overlay instance
      * @param cooldown The cooldown duration - if > 0, enables instant transitions
      */
     registerActive(overlayType, overlay, cooldown) {
-        const existing = this.activeOverlays.get(overlayType);
-        // If there's an existing overlay of the same type, close it immediately.
-        // This ensures only one overlay of each type is open at a time.
-        if (existing && existing !== overlay) {
+        const stack = this.activeOverlays.get(overlayType) ?? [];
+        if (stack.includes(overlay)) {
+            return;
+        }
+        // Evict overlays from the top of the stack until we reach the overlay itself
+        // or one of its ancestors (or the stack empties). Ancestors are preserved so
+        // nested same-type overlays can coexist; peers are closed immediately.
+        while (stack.length > 0) {
+            const top = stack[stack.length - 1];
+            if (overlay.isDescendantOf?.(top)) {
+                break;
+            }
+            if (top.isDescendantOf?.(overlay)) {
+                const firstDescendantIndex = stack.findIndex(entry => entry.isDescendantOf?.(overlay));
+                stack.splice(firstDescendantIndex, 0, overlay);
+                this.activeOverlays.set(overlayType, stack);
+                return;
+            }
+            stack.pop();
             // Enable instant transition only if cooldown is active
             if (cooldown > 0) {
-                existing.instantTransition?.set(true);
+                top.instantTransition?.set(true);
             }
-            existing.hideImmediate();
+            top.hideImmediate();
         }
-        this.activeOverlays.set(overlayType, overlay);
+        // Push as the topmost active overlay, avoiding a duplicate entry if it is
+        // already there (e.g. re-registering after a cancelled destruction).
+        if (stack[stack.length - 1] !== overlay) {
+            stack.push(overlay);
+        }
+        this.activeOverlays.set(overlayType, stack);
     }
     /**
      * Unregister an overlay when it closes.
@@ -141,7 +175,15 @@ class NgpOverlayCooldownManager {
      * @param overlay The overlay instance to remove
      */
     unregisterActive(overlayType, overlay) {
-        if (this.activeOverlays.get(overlayType) === overlay) {
+        const stack = this.activeOverlays.get(overlayType);
+        if (!stack) {
+            return;
+        }
+        const index = stack.indexOf(overlay);
+        if (index !== -1) {
+            stack.splice(index, 1);
+        }
+        if (stack.length === 0) {
             this.activeOverlays.delete(overlayType);
         }
     }
@@ -151,7 +193,8 @@ class NgpOverlayCooldownManager {
      * @returns true if there's an active overlay, false otherwise
      */
     hasActiveOverlay(overlayType) {
-        return this.activeOverlays.has(overlayType);
+        const stack = this.activeOverlays.get(overlayType);
+        return stack !== undefined && stack.length > 0;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: NgpOverlayCooldownManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: NgpOverlayCooldownManager, providedIn: 'root' }); }
@@ -1396,6 +1439,25 @@ class NgpOverlay {
     unregisterChildOverlay(child) {
         this.childOverlays.delete(child);
     }
+    /**
+     * Determine whether this overlay is a descendant of the given overlay - i.e.
+     * its trigger is rendered within the other overlay's content. Walks the parent
+     * overlay chain established through dependency injection.
+     *
+     * Used by the cooldown manager to avoid evicting an ancestor overlay when a
+     * nested overlay of the same type is activated.
+     * @internal
+     */
+    isDescendantOf(other) {
+        let current = this.parentOverlay;
+        while (current) {
+            if (current === other) {
+                return true;
+            }
+            current = current.parentOverlay;
+        }
+        return false;
+    }
     /**
      * Check if the event path includes any child overlay elements (recursively).
      * @internal
@@ -1556,6 +1618,7 @@ class NgpOverlay {
         this.position.set({ x: position.x, y: position.y });
         // Update final placement signal
         this.finalPlacement.set(position.placement);
+        this.transformOrigin.set(this.getTransformOrigin(position.placement));
         // Update arrow position if available
         if (this.arrowElement) {
             this.arrowPosition.set({
@@ -1630,8 +1693,7 @@ class NgpOverlay {
     /**
      * Get the transform origin for the overlay
      */
-    getTransformOrigin() {
-        const placement = this.config.placement?.() ?? 'top';
+    getTransformOrigin(placement = this.config.placement?.() ?? 'top') {
         const basePlacement = placement.split('-')[0]; // Extract "top", "bottom", etc.
         const alignment = placement.split('-')[1]; // Extract "start" or "end"
         const map = {