@tolle_/tolle-ui 18.2.29 → 18.3.0

package/esm2022/lib/context-menu.component.mjs

@@ -0,0 +1,460 @@
+import { Component, ElementRef, HostListener, inject, ViewChild, ViewChildren, ChangeDetectorRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ContextMenuService } from './context-menu.service';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+export class ContextMenuComponent {
+    contextMenuService = inject(ContextMenuService);
+    elementRef = inject(ElementRef);
+    cdr = inject(ChangeDetectorRef);
+    menuElement;
+    // We only have one active submenu now, so we can use ViewChild instead of ViewChildren
+    submenuElement;
+    itemButtons;
+    isOpen = false;
+    isPositioned = false;
+    isSubmenuPositioned = false;
+    items = [];
+    openSubmenuId = null;
+    activeSubmenuTrigger = null; // Store the button that triggered the submenu
+    activeIndex = -1;
+    stateSubscription;
+    submenuTimeout;
+    cn = cn;
+    ngOnInit() {
+        this.stateSubscription = this.contextMenuService.stateChanged.subscribe((state) => {
+            this.isOpen = state.isOpen;
+            this.items = state.items;
+            if (state.isOpen) {
+                this.activeIndex = -1;
+                this.isPositioned = false;
+                this.cdr.detectChanges();
+                requestAnimationFrame(() => {
+                    this.positionMenu();
+                    this.focusFirstItem();
+                });
+            }
+            else {
+                this.closeSubmenu();
+                this.activeIndex = -1;
+                this.isPositioned = false;
+            }
+        });
+    }
+    // Helper to get items for the currently open submenu
+    get activeSubmenuItems() {
+        if (!this.openSubmenuId)
+            return [];
+        return this.items.find(i => i.id === this.openSubmenuId)?.submenu || [];
+    }
+    onDocumentEvents(event) {
+        if (!this.isOpen)
+            return;
+        // Check if click is inside main menu OR the active submenu
+        const clickedInsideMenu = this.menuElement?.nativeElement.contains(event.target);
+        const clickedInsideSubmenu = this.submenuElement?.nativeElement.contains(event.target);
+        if (clickedInsideMenu || clickedInsideSubmenu) {
+            return;
+        }
+        this.contextMenuService.close();
+    }
+    async positionMenu() {
+        if (this.menuElement?.nativeElement) {
+            this.isPositioned = false;
+            this.cdr.detectChanges();
+            await this.contextMenuService.positionMenu(this.menuElement.nativeElement);
+            this.isPositioned = true;
+            this.cdr.detectChanges();
+            // Focus the menu container so Arrow/Enter/Escape keydown handlers fire.
+            this.menuElement.nativeElement.focus();
+        }
+    }
+    focusFirstItem() {
+        const firstEnabledIndex = this.items.findIndex(item => !item.disabled && !item.separator);
+        if (firstEnabledIndex !== -1) {
+            this.activeIndex = firstEnabledIndex;
+        }
+    }
+    onItemClick(item) {
+        if (item.disabled || item.separator)
+            return;
+        if (item.submenu) {
+            // Toggle logic handled by enter/leave mostly, but click can force toggle
+            if (this.openSubmenuId === item.id) {
+                this.closeSubmenu();
+            }
+            else {
+                // We need the button ref to open it via click. 
+                // Implementation detail: Hover is preferred for submenus.
+            }
+        }
+        else {
+            this.contextMenuService.performAction(item.id);
+        }
+    }
+    onItemMouseEnter(item, trigger) {
+        if (item.disabled || item.separator)
+            return;
+        // Clear any pending close actions
+        clearTimeout(this.submenuTimeout);
+        this.submenuTimeout = setTimeout(() => {
+            if (item.submenu) {
+                this.openSubmenuId = item.id;
+                this.activeSubmenuTrigger = trigger; // Save the trigger for positioning
+                this.positionSubmenu();
+            }
+            else {
+                this.closeSubmenu();
+            }
+        }, 150);
+    }
+    onItemMouseLeave() {
+        // We don't close immediately; we wait to see if the user enters the submenu
+        // Logic handled by the timeout in `onItemMouseEnter` of a sibling, 
+        // or we could add a timeout here to close if they go nowhere.
+    }
+    onSubmenuMouseEnter() {
+        // If user is hovering the submenu, keep it open
+        clearTimeout(this.submenuTimeout);
+    }
+    onSubmenuMouseLeave() {
+        // If user leaves submenu, standard behavior is usually to keep it open 
+        // until they hover another main item or click away.
+    }
+    closeSubmenu() {
+        this.openSubmenuId = null;
+        this.activeSubmenuTrigger = null;
+        this.isSubmenuPositioned = false;
+    }
+    async positionSubmenu() {
+        this.isSubmenuPositioned = false;
+        this.cdr.detectChanges(); // Render the submenu DOM
+        requestAnimationFrame(async () => {
+            if (this.activeSubmenuTrigger && this.submenuElement) {
+                await this.contextMenuService.positionSubmenu(this.activeSubmenuTrigger, this.submenuElement.nativeElement);
+                this.isSubmenuPositioned = true;
+                this.cdr.detectChanges();
+            }
+        });
+    }
+    onSubItemClick(item) {
+        if (item.disabled || item.separator)
+            return;
+        this.contextMenuService.performAction(item.id);
+    }
+    onKeyDown(event) {
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.navigate(1);
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                this.navigate(-1);
+                break;
+            case 'ArrowRight':
+                const currentItem = this.items[this.activeIndex];
+                if (currentItem?.submenu) {
+                    event.preventDefault();
+                    // Force open submenu via keyboard
+                    this.openSubmenuId = currentItem.id;
+                    const trigger = this.itemButtons.toArray()[this.activeIndex]?.nativeElement;
+                    if (trigger) {
+                        this.activeSubmenuTrigger = trigger;
+                        this.positionSubmenu();
+                    }
+                }
+                break;
+            case 'ArrowLeft':
+                if (this.openSubmenuId) {
+                    event.preventDefault();
+                    this.closeSubmenu();
+                }
+                break;
+            case 'Enter':
+                if (this.activeIndex !== -1) {
+                    event.preventDefault();
+                    this.onItemClick(this.items[this.activeIndex]);
+                }
+                break;
+            case 'Escape':
+                event.preventDefault();
+                this.contextMenuService.close();
+                break;
+        }
+    }
+    navigate(direction) {
+        let nextIndex = this.activeIndex + direction;
+        const count = this.items.length;
+        while (nextIndex >= 0 && nextIndex < count) {
+            const item = this.items[nextIndex];
+            if (!item.disabled && !item.separator) {
+                this.activeIndex = nextIndex;
+                return;
+            }
+            nextIndex += direction;
+        }
+    }
+    onEscape() {
+        this.contextMenuService.close();
+    }
+    ngOnDestroy() {
+        if (this.stateSubscription) {
+            this.stateSubscription.unsubscribe();
+        }
+        clearTimeout(this.submenuTimeout);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ContextMenuComponent, isStandalone: true, selector: "tolle-context-menu", host: { listeners: { "document:click": "onDocumentEvents($event)", "document:contextmenu": "onDocumentEvents($event)", "document:keydown.escape": "onEscape()" } }, viewQueries: [{ propertyName: "menuElement", first: true, predicate: ["menu"], descendants: true }, { propertyName: "submenuElement", first: true, predicate: ["submenu"], descendants: true }, { propertyName: "itemButtons", predicate: ["itemButton"], descendants: true }], ngImport: i0, template: `
+    @if (isOpen) {
+      <div
+        #menu
+        role="menu"
+        aria-orientation="vertical"
+        tabindex="-1"
+        [attr.data-state]="isOpen ? 'open' : 'closed'"
+        class="fixed z-50 min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md
+               data-[state=closed]:animate-out data-[state=open]:animate-in
+               data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0
+               data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95
+               slide-in-from-top-2"
+        [style.visibility]="isPositioned ? 'visible' : 'hidden'"
+        [style.opacity]="isPositioned ? '1' : '0'"
+        style="will-change: transform; top: 0; left: 0;"
+        (keydown)="onKeyDown($event)"
+      >
+        <div class="flex flex-col">
+          @for (item of items; track $index) {
+            @if (item.separator) {
+              <div role="separator" class="h-px -mx-1 my-1 bg-border"></div>
+            } @else {
+              <div class="relative group">
+                <button
+                  #itemButton
+                  type="button"
+                  role="menuitem"
+                  [attr.aria-haspopup]="item.submenu ? 'true' : null"
+                  [attr.aria-expanded]="openSubmenuId === item.id ? 'true' : null"
+                  [attr.aria-disabled]="item.disabled ? 'true' : null"
+                  (click)="onItemClick(item)"
+                  (mouseenter)="onItemMouseEnter(item, itemButton)"
+                  (mouseleave)="onItemMouseLeave()"
+                  [disabled]="item.disabled"
+                  [class]="cn(
+                    'relative flex w-full cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none',
+                    'transition-colors focus:bg-accent focus:text-accent-foreground hover:bg-accent hover:text-accent-foreground',
+                    'data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+                    item.destructive ? 'text-destructive focus:bg-destructive/10 focus:text-destructive' : '',
+                    item.disabled && 'opacity-50 cursor-not-allowed pointer-events-none',
+                    (item.type === 'checkbox' || item.type === 'radio') ? 'pl-8' : '',
+                    activeIndex === $index && 'bg-accent text-accent-foreground'
+                  )"
+                >
+                  @if (item.checked) {
+                    <span class="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+                      <i [class]="item.type === 'radio' ? 'ri-checkbox-blank-circle-fill h-2 w-2 fill-current' : 'ri-check-line h-4 w-4'"></i>
+                    </span>
+                  }
+                  @if (item.icon) {
+                    <i [class]="cn(item.icon, 'mr-2 h-4 w-4')"></i>
+                  }
+                  <span class="flex-1 text-left">{{ item.label }}</span>
+                  @if (item.shortcut && !item.submenu) {
+                    <span class="ml-auto text-xs tracking-widest text-muted-foreground pl-2">{{ item.shortcut }}</span>
+                  }
+                  @if (item.submenu) {
+                    <i class="ri-arrow-right-s-line ml-auto h-4 w-4 opacity-50"></i>
+                  }
+                </button>
+              </div>
+            }
+          }
+        </div>
+      </div>
+
+      @if (openSubmenuId && activeSubmenuItems.length > 0) {
+        <div
+          #submenu
+          role="menu"
+          [id]="'submenu-' + openSubmenuId"
+          class="fixed z-50 min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md"
+          [style.visibility]="isSubmenuPositioned ? 'visible' : 'hidden'"
+          [style.opacity]="isSubmenuPositioned ? '1' : '0'"
+          style="will-change: transform"
+          (mouseenter)="onSubmenuMouseEnter()"
+          (mouseleave)="onSubmenuMouseLeave()"
+        >
+          @for (subItem of activeSubmenuItems; track $index) {
+            @if (subItem.separator) {
+              <div role="separator" class="h-px -mx-1 my-1 bg-border"></div>
+            } @else {
+              <button
+                type="button"
+                role="menuitem"
+                (click)="onSubItemClick(subItem)"
+                [disabled]="subItem.disabled"
+                [class]="cn(
+                  'relative flex w-full cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none',
+                  'transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground',
+                  subItem.disabled && 'opacity-50 cursor-not-allowed pointer-events-none',
+                  (subItem.type === 'checkbox' || subItem.type === 'radio') ? 'pl-8' : '',
+                  subItem.destructive ? 'text-destructive hover:bg-destructive/10' : ''
+                )"
+              >
+                @if (subItem.checked) {
+                  <span class="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+                    <i [class]="subItem.type === 'radio' ? 'ri-checkbox-blank-circle-fill h-2 w-2 fill-current' : 'ri-check-line h-4 w-4'"></i>
+                  </span>
+                }
+                @if (subItem.icon) {
+                  <i [class]="cn(subItem.icon, 'mr-2 h-4 w-4')"></i>
+                }
+                <span class="flex-1 text-left">{{ subItem.label }}</span>
+                @if (subItem.shortcut) {
+                  <span class="ml-auto text-xs tracking-widest text-muted-foreground pl-2">{{ subItem.shortcut }}</span>
+                }
+              </button>
+            }
+          }
+        </div>
+      }
+    }
+  `, isInline: true, styles: [":host{display:contents}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-context-menu', standalone: true, imports: [CommonModule], template: `
+    @if (isOpen) {
+      <div
+        #menu
+        role="menu"
+        aria-orientation="vertical"
+        tabindex="-1"
+        [attr.data-state]="isOpen ? 'open' : 'closed'"
+        class="fixed z-50 min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md
+               data-[state=closed]:animate-out data-[state=open]:animate-in
+               data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0
+               data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95
+               slide-in-from-top-2"
+        [style.visibility]="isPositioned ? 'visible' : 'hidden'"
+        [style.opacity]="isPositioned ? '1' : '0'"
+        style="will-change: transform; top: 0; left: 0;"
+        (keydown)="onKeyDown($event)"
+      >
+        <div class="flex flex-col">
+          @for (item of items; track $index) {
+            @if (item.separator) {
+              <div role="separator" class="h-px -mx-1 my-1 bg-border"></div>
+            } @else {
+              <div class="relative group">
+                <button
+                  #itemButton
+                  type="button"
+                  role="menuitem"
+                  [attr.aria-haspopup]="item.submenu ? 'true' : null"
+                  [attr.aria-expanded]="openSubmenuId === item.id ? 'true' : null"
+                  [attr.aria-disabled]="item.disabled ? 'true' : null"
+                  (click)="onItemClick(item)"
+                  (mouseenter)="onItemMouseEnter(item, itemButton)"
+                  (mouseleave)="onItemMouseLeave()"
+                  [disabled]="item.disabled"
+                  [class]="cn(
+                    'relative flex w-full cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none',
+                    'transition-colors focus:bg-accent focus:text-accent-foreground hover:bg-accent hover:text-accent-foreground',
+                    'data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+                    item.destructive ? 'text-destructive focus:bg-destructive/10 focus:text-destructive' : '',
+                    item.disabled && 'opacity-50 cursor-not-allowed pointer-events-none',
+                    (item.type === 'checkbox' || item.type === 'radio') ? 'pl-8' : '',
+                    activeIndex === $index && 'bg-accent text-accent-foreground'
+                  )"
+                >
+                  @if (item.checked) {
+                    <span class="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+                      <i [class]="item.type === 'radio' ? 'ri-checkbox-blank-circle-fill h-2 w-2 fill-current' : 'ri-check-line h-4 w-4'"></i>
+                    </span>
+                  }
+                  @if (item.icon) {
+                    <i [class]="cn(item.icon, 'mr-2 h-4 w-4')"></i>
+                  }
+                  <span class="flex-1 text-left">{{ item.label }}</span>
+                  @if (item.shortcut && !item.submenu) {
+                    <span class="ml-auto text-xs tracking-widest text-muted-foreground pl-2">{{ item.shortcut }}</span>
+                  }
+                  @if (item.submenu) {
+                    <i class="ri-arrow-right-s-line ml-auto h-4 w-4 opacity-50"></i>
+                  }
+                </button>
+              </div>
+            }
+          }
+        </div>
+      </div>
+
+      @if (openSubmenuId && activeSubmenuItems.length > 0) {
+        <div
+          #submenu
+          role="menu"
+          [id]="'submenu-' + openSubmenuId"
+          class="fixed z-50 min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md"
+          [style.visibility]="isSubmenuPositioned ? 'visible' : 'hidden'"
+          [style.opacity]="isSubmenuPositioned ? '1' : '0'"
+          style="will-change: transform"
+          (mouseenter)="onSubmenuMouseEnter()"
+          (mouseleave)="onSubmenuMouseLeave()"
+        >
+          @for (subItem of activeSubmenuItems; track $index) {
+            @if (subItem.separator) {
+              <div role="separator" class="h-px -mx-1 my-1 bg-border"></div>
+            } @else {
+              <button
+                type="button"
+                role="menuitem"
+                (click)="onSubItemClick(subItem)"
+                [disabled]="subItem.disabled"
+                [class]="cn(
+                  'relative flex w-full cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none',
+                  'transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground',
+                  subItem.disabled && 'opacity-50 cursor-not-allowed pointer-events-none',
+                  (subItem.type === 'checkbox' || subItem.type === 'radio') ? 'pl-8' : '',
+                  subItem.destructive ? 'text-destructive hover:bg-destructive/10' : ''
+                )"
+              >
+                @if (subItem.checked) {
+                  <span class="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+                    <i [class]="subItem.type === 'radio' ? 'ri-checkbox-blank-circle-fill h-2 w-2 fill-current' : 'ri-check-line h-4 w-4'"></i>
+                  </span>
+                }
+                @if (subItem.icon) {
+                  <i [class]="cn(subItem.icon, 'mr-2 h-4 w-4')"></i>
+                }
+                <span class="flex-1 text-left">{{ subItem.label }}</span>
+                @if (subItem.shortcut) {
+                  <span class="ml-auto text-xs tracking-widest text-muted-foreground pl-2">{{ subItem.shortcut }}</span>
+                }
+              </button>
+            }
+          }
+        </div>
+      }
+    }
+  `, styles: [":host{display:contents}\n"] }]
+        }], propDecorators: { menuElement: [{
+                type: ViewChild,
+                args: ['menu']
+            }], submenuElement: [{
+                type: ViewChild,
+                args: ['submenu']
+            }], itemButtons: [{
+                type: ViewChildren,
+                args: ['itemButton']
+            }], onDocumentEvents: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['document:contextmenu', ['$event']]
+            }], onEscape: [{
+                type: HostListener,
+                args: ['document:keydown.escape']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-menu.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/context-menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, HostListener, inject, OnDestroy, OnInit, ViewChild, ViewChildren, QueryList, ChangeDetectorRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ContextMenuItem, ContextMenuService, ContextMenuState } from './context-menu.service';\nimport { cn } from './utils/cn';\n\n@Component({\n  selector: 'tolle-context-menu',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    @if (isOpen) {\n      <div\n        #menu\n        role=\"menu\"\n        aria-orientation=\"vertical\"\n        tabindex=\"-1\"\n        [attr.data-state]=\"isOpen ? 'open' : 'closed'\"\n        class=\"fixed z-50 min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md\n               data-[state=closed]:animate-out data-[state=open]:animate-in\n               data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0\n               data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95\n               slide-in-from-top-2\"\n        [style.visibility]=\"isPositioned ? 'visible' : 'hidden'\"\n        [style.opacity]=\"isPositioned ? '1' : '0'\"\n        style=\"will-change: transform; top: 0; left: 0;\"\n        (keydown)=\"onKeyDown($event)\"\n      >\n        <div class=\"flex flex-col\">\n          @for (item of items; track $index) {\n            @if (item.separator) {\n              <div role=\"separator\" class=\"h-px -mx-1 my-1 bg-border\"></div>\n            } @else {\n              <div class=\"relative group\">\n                <button\n                  #itemButton\n                  type=\"button\"\n                  role=\"menuitem\"\n                  [attr.aria-haspopup]=\"item.submenu ? 'true' : null\"\n                  [attr.aria-expanded]=\"openSubmenuId === item.id ? 'true' : null\"\n                  [attr.aria-disabled]=\"item.disabled ? 'true' : null\"\n                  (click)=\"onItemClick(item)\"\n                  (mouseenter)=\"onItemMouseEnter(item, itemButton)\"\n                  (mouseleave)=\"onItemMouseLeave()\"\n                  [disabled]=\"item.disabled\"\n                  [class]=\"cn(\n                    'relative flex w-full cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none',\n                    'transition-colors focus:bg-accent focus:text-accent-foreground hover:bg-accent hover:text-accent-foreground',\n                    'data-[disabled]:pointer-events-none data-[disabled]:opacity-50',\n                    item.destructive ? 'text-destructive focus:bg-destructive/10 focus:text-destructive' : '',\n                    item.disabled && 'opacity-50 cursor-not-allowed pointer-events-none',\n                    (item.type === 'checkbox' || item.type === 'radio') ? 'pl-8' : '',\n                    activeIndex === $index && 'bg-accent text-accent-foreground'\n                  )\"\n                >\n                  @if (item.checked) {\n                    <span class=\"absolute left-2 flex h-3.5 w-3.5 items-center justify-center\">\n                      <i [class]=\"item.type === 'radio' ? 'ri-checkbox-blank-circle-fill h-2 w-2 fill-current' : 'ri-check-line h-4 w-4'\"></i>\n                    </span>\n                  }\n                  @if (item.icon) {\n                    <i [class]=\"cn(item.icon, 'mr-2 h-4 w-4')\"></i>\n                  }\n                  <span class=\"flex-1 text-left\">{{ item.label }}</span>\n                  @if (item.shortcut && !item.submenu) {\n                    <span class=\"ml-auto text-xs tracking-widest text-muted-foreground pl-2\">{{ item.shortcut }}</span>\n                  }\n                  @if (item.submenu) {\n                    <i class=\"ri-arrow-right-s-line ml-auto h-4 w-4 opacity-50\"></i>\n                  }\n                </button>\n              </div>\n            }\n          }\n        </div>\n      </div>\n\n      @if (openSubmenuId && activeSubmenuItems.length > 0) {\n        <div\n          #submenu\n          role=\"menu\"\n          [id]=\"'submenu-' + openSubmenuId\"\n          class=\"fixed z-50 min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md\"\n          [style.visibility]=\"isSubmenuPositioned ? 'visible' : 'hidden'\"\n          [style.opacity]=\"isSubmenuPositioned ? '1' : '0'\"\n          style=\"will-change: transform\"\n          (mouseenter)=\"onSubmenuMouseEnter()\"\n          (mouseleave)=\"onSubmenuMouseLeave()\"\n        >\n          @for (subItem of activeSubmenuItems; track $index) {\n            @if (subItem.separator) {\n              <div role=\"separator\" class=\"h-px -mx-1 my-1 bg-border\"></div>\n            } @else {\n              <button\n                type=\"button\"\n                role=\"menuitem\"\n                (click)=\"onSubItemClick(subItem)\"\n                [disabled]=\"subItem.disabled\"\n                [class]=\"cn(\n                  'relative flex w-full cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none',\n                  'transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground',\n                  subItem.disabled && 'opacity-50 cursor-not-allowed pointer-events-none',\n                  (subItem.type === 'checkbox' || subItem.type === 'radio') ? 'pl-8' : '',\n                  subItem.destructive ? 'text-destructive hover:bg-destructive/10' : ''\n                )\"\n              >\n                @if (subItem.checked) {\n                  <span class=\"absolute left-2 flex h-3.5 w-3.5 items-center justify-center\">\n                    <i [class]=\"subItem.type === 'radio' ? 'ri-checkbox-blank-circle-fill h-2 w-2 fill-current' : 'ri-check-line h-4 w-4'\"></i>\n                  </span>\n                }\n                @if (subItem.icon) {\n                  <i [class]=\"cn(subItem.icon, 'mr-2 h-4 w-4')\"></i>\n                }\n                <span class=\"flex-1 text-left\">{{ subItem.label }}</span>\n                @if (subItem.shortcut) {\n                  <span class=\"ml-auto text-xs tracking-widest text-muted-foreground pl-2\">{{ subItem.shortcut }}</span>\n                }\n              </button>\n            }\n          }\n        </div>\n      }\n    }\n  `,\n  styles: [`\n    :host { display: contents; }\n  `]\n})\nexport class ContextMenuComponent implements OnInit, OnDestroy {\n  private contextMenuService = inject(ContextMenuService);\n  private elementRef = inject(ElementRef);\n  private cdr = inject(ChangeDetectorRef);\n\n  @ViewChild('menu') menuElement!: ElementRef<HTMLDivElement>;\n\n  // We only have one active submenu now, so we can use ViewChild instead of ViewChildren\n  @ViewChild('submenu') submenuElement!: ElementRef<HTMLDivElement>;\n\n  @ViewChildren('itemButton') itemButtons!: QueryList<ElementRef<HTMLButtonElement>>;\n\n  isOpen = false;\n  isPositioned = false;\n  isSubmenuPositioned = false;\n  items: ContextMenuItem[] = [];\n\n  openSubmenuId: string | null = null;\n  activeSubmenuTrigger: HTMLElement | null = null; // Store the button that triggered the submenu\n\n  activeIndex = -1;\n  private stateSubscription: any;\n  private submenuTimeout: any;\n\n  protected readonly cn = cn;\n\n  ngOnInit() {\n    this.stateSubscription = this.contextMenuService.stateChanged.subscribe((state: ContextMenuState) => {\n      this.isOpen = state.isOpen;\n      this.items = state.items;\n\n      if (state.isOpen) {\n        this.activeIndex = -1;\n        this.isPositioned = false;\n        this.cdr.detectChanges();\n        requestAnimationFrame(() => {\n          this.positionMenu();\n          this.focusFirstItem();\n        });\n      } else {\n        this.closeSubmenu();\n        this.activeIndex = -1;\n        this.isPositioned = false;\n      }\n    });\n  }\n\n  // Helper to get items for the currently open submenu\n  get activeSubmenuItems(): ContextMenuItem[] {\n    if (!this.openSubmenuId) return [];\n    return this.items.find(i => i.id === this.openSubmenuId)?.submenu || [];\n  }\n\n  @HostListener('document:click', ['$event'])\n  @HostListener('document:contextmenu', ['$event'])\n  onDocumentEvents(event: MouseEvent) {\n    if (!this.isOpen) return;\n\n    // Check if click is inside main menu OR the active submenu\n    const clickedInsideMenu = this.menuElement?.nativeElement.contains(event.target as Node);\n    const clickedInsideSubmenu = this.submenuElement?.nativeElement.contains(event.target as Node);\n\n    if (clickedInsideMenu || clickedInsideSubmenu) {\n      return;\n    }\n\n    this.contextMenuService.close();\n  }\n\n  async positionMenu() {\n    if (this.menuElement?.nativeElement) {\n      this.isPositioned = false;\n      this.cdr.detectChanges();\n      await this.contextMenuService.positionMenu(this.menuElement.nativeElement);\n      this.isPositioned = true;\n      this.cdr.detectChanges();\n      // Focus the menu container so Arrow/Enter/Escape keydown handlers fire.\n      this.menuElement.nativeElement.focus();\n    }\n  }\n\n  focusFirstItem() {\n    const firstEnabledIndex = this.items.findIndex(item => !item.disabled && !item.separator);\n    if (firstEnabledIndex !== -1) {\n      this.activeIndex = firstEnabledIndex;\n    }\n  }\n\n  onItemClick(item: ContextMenuItem) {\n    if (item.disabled || item.separator) return;\n\n    if (item.submenu) {\n      // Toggle logic handled by enter/leave mostly, but click can force toggle\n      if (this.openSubmenuId === item.id) {\n        this.closeSubmenu();\n      } else {\n        // We need the button ref to open it via click. \n        // Implementation detail: Hover is preferred for submenus.\n      }\n    } else {\n      this.contextMenuService.performAction(item.id!);\n    }\n  }\n\n  onItemMouseEnter(item: ContextMenuItem, trigger: HTMLButtonElement) {\n    if (item.disabled || item.separator) return;\n\n    // Clear any pending close actions\n    clearTimeout(this.submenuTimeout);\n\n    this.submenuTimeout = setTimeout(() => {\n      if (item.submenu) {\n        this.openSubmenuId = item.id!;\n        this.activeSubmenuTrigger = trigger; // Save the trigger for positioning\n        this.positionSubmenu();\n      } else {\n        this.closeSubmenu();\n      }\n    }, 150);\n  }\n\n  onItemMouseLeave() {\n    // We don't close immediately; we wait to see if the user enters the submenu\n    // Logic handled by the timeout in `onItemMouseEnter` of a sibling, \n    // or we could add a timeout here to close if they go nowhere.\n  }\n\n  onSubmenuMouseEnter() {\n    // If user is hovering the submenu, keep it open\n    clearTimeout(this.submenuTimeout);\n  }\n\n  onSubmenuMouseLeave() {\n    // If user leaves submenu, standard behavior is usually to keep it open \n    // until they hover another main item or click away.\n  }\n\n  private closeSubmenu() {\n    this.openSubmenuId = null;\n    this.activeSubmenuTrigger = null;\n    this.isSubmenuPositioned = false;\n  }\n\n  private async positionSubmenu() {\n    this.isSubmenuPositioned = false;\n    this.cdr.detectChanges(); // Render the submenu DOM\n\n    requestAnimationFrame(async () => {\n      if (this.activeSubmenuTrigger && this.submenuElement) {\n        await this.contextMenuService.positionSubmenu(\n          this.activeSubmenuTrigger,\n          this.submenuElement.nativeElement\n        );\n        this.isSubmenuPositioned = true;\n        this.cdr.detectChanges();\n      }\n    });\n  }\n\n  onSubItemClick(item: ContextMenuItem) {\n    if (item.disabled || item.separator) return;\n    this.contextMenuService.performAction(item.id!);\n  }\n\n  onKeyDown(event: KeyboardEvent) {\n    switch (event.key) {\n      case 'ArrowDown':\n        event.preventDefault();\n        this.navigate(1);\n        break;\n      case 'ArrowUp':\n        event.preventDefault();\n        this.navigate(-1);\n        break;\n      case 'ArrowRight':\n        const currentItem = this.items[this.activeIndex];\n        if (currentItem?.submenu) {\n          event.preventDefault();\n          // Force open submenu via keyboard\n          this.openSubmenuId = currentItem.id!;\n          const trigger = this.itemButtons.toArray()[this.activeIndex]?.nativeElement;\n          if (trigger) {\n            this.activeSubmenuTrigger = trigger;\n            this.positionSubmenu();\n          }\n        }\n        break;\n      case 'ArrowLeft':\n        if (this.openSubmenuId) {\n          event.preventDefault();\n          this.closeSubmenu();\n        }\n        break;\n      case 'Enter':\n        if (this.activeIndex !== -1) {\n          event.preventDefault();\n          this.onItemClick(this.items[this.activeIndex]);\n        }\n        break;\n      case 'Escape':\n        event.preventDefault();\n        this.contextMenuService.close();\n        break;\n    }\n  }\n\n  private navigate(direction: number) {\n    let nextIndex = this.activeIndex + direction;\n    const count = this.items.length;\n    while (nextIndex >= 0 && nextIndex < count) {\n      const item = this.items[nextIndex];\n      if (!item.disabled && !item.separator) {\n        this.activeIndex = nextIndex;\n        return;\n      }\n      nextIndex += direction;\n    }\n  }\n\n  @HostListener('document:keydown.escape')\n  onEscape() {\n    this.contextMenuService.close();\n  }\n\n  ngOnDestroy() {\n    if (this.stateSubscription) {\n      this.stateSubscription.unsubscribe();\n    }\n    clearTimeout(this.submenuTimeout);\n  }\n}"]}

package/esm2022/lib/context-menu.service.mjs

@@ -0,0 +1,125 @@
+import { Injectable, EventEmitter } from '@angular/core';
+import { computePosition, offset, shift, flip, size } from '@floating-ui/dom';
+import * as i0 from "@angular/core";
+export class ContextMenuService {
+    _state = {
+        x: 0,
+        y: 0,
+        items: [],
+        isOpen: false
+    };
+    stateChanged = new EventEmitter();
+    open(config) {
+        const { event, items = [], triggerElement, onAction } = config;
+        // Prevent browser context menu
+        event.preventDefault();
+        this._state = {
+            x: event.clientX,
+            y: event.clientY,
+            items,
+            isOpen: true,
+            triggerElement,
+            onAction
+        };
+        this.stateChanged.emit(this._state);
+    }
+    close() {
+        this._state = { ...this._state, isOpen: false };
+        this.stateChanged.emit(this._state);
+    }
+    async positionMenu(menuElement) {
+        const state = this._state;
+        if (!state.isOpen || !menuElement)
+            return;
+        // Create a precise virtual element for the mouse coordinates
+        const virtualEl = {
+            getBoundingClientRect() {
+                return {
+                    width: 0,
+                    height: 0,
+                    x: state.x,
+                    y: state.y,
+                    top: state.y,
+                    left: state.x,
+                    right: state.x,
+                    bottom: state.y,
+                };
+            }
+        };
+        const { x, y } = await computePosition(virtualEl, menuElement, {
+            placement: 'bottom-start', // Standard: Menu top-left aligns with mouse
+            strategy: 'fixed',
+            middleware: [
+                offset(2), // Slight offset so mouse isn't covering the first pixel
+                flip({
+                    padding: 10,
+                    fallbackPlacements: ['bottom-end', 'top-start', 'top-end']
+                }),
+                shift({ padding: 10 }),
+                size({
+                    apply({ availableHeight, availableWidth, elements }) {
+                        Object.assign(elements.floating.style, {
+                            maxHeight: `${Math.max(100, availableHeight - 16)}px`,
+                            maxWidth: `${Math.max(200, availableWidth - 16)}px`,
+                            overflowY: 'auto'
+                        });
+                    }
+                })
+            ]
+        });
+        // Position via left/top, not transform: the menu's own
+        // data-[state=open]:zoom-in-95/slide-in-from-top-2 enter animation also
+        // drives `transform`, and a CSS animation overrides whatever an inline
+        // transform says for as long as it's running — so a translate() here
+        // would get clobbered by the animation and only "snap" into place once
+        // it finishes, which is exactly the top-left-then-jump flash this avoids.
+        Object.assign(menuElement.style, {
+            position: 'fixed',
+            left: `${Math.round(x)}px`,
+            top: `${Math.round(y)}px`,
+        });
+    }
+    async positionSubmenu(triggerElement, submenuElement) {
+        if (!triggerElement || !submenuElement)
+            return;
+        const { x, y } = await computePosition(triggerElement, submenuElement, {
+            placement: 'right-start', // Standard: Submenu opens to the right
+            strategy: 'fixed',
+            middleware: [
+                offset(-4), // Overlap slightly with parent menu
+                flip({
+                    padding: 10,
+                    fallbackPlacements: ['left-start', 'bottom-start']
+                }),
+                shift({ padding: 10 }),
+                size({
+                    apply({ availableHeight, availableWidth, elements }) {
+                        Object.assign(elements.floating.style, {
+                            maxHeight: `${Math.max(100, availableHeight - 16)}px`,
+                            maxWidth: `${Math.max(200, availableWidth - 16)}px`,
+                            overflowY: 'auto'
+                        });
+                    }
+                })
+            ]
+        });
+        Object.assign(submenuElement.style, {
+            position: 'fixed',
+            left: `${Math.round(x)}px`,
+            top: `${Math.round(y)}px`,
+        });
+    }
+    performAction(actionId) {
+        this._state.onAction?.(actionId);
+        this.close();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-menu.service.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/context-menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, EventEmitter } from '@angular/core';\nimport { computePosition, offset, shift, flip, size } from '@floating-ui/dom';\n\nexport type ContextMenuItem = {\n  id?: string;\n  label?: string;\n  icon?: string;\n  disabled?: boolean;\n  destructive?: boolean;\n  separator?: boolean;\n  submenu?: ContextMenuItem[];\n  shortcut?: string;\n  checked?: boolean;\n  type?: 'default' | 'checkbox' | 'radio';\n}\n\nexport type ContextMenuState = {\n  x: number;\n  y: number;\n  items: ContextMenuItem[];\n  isOpen: boolean;\n  triggerElement?: HTMLElement;\n  onAction?: (actionId: string) => void;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ContextMenuService {\n  private _state: ContextMenuState = {\n    x: 0,\n    y: 0,\n    items: [],\n    isOpen: false\n  };\n\n  readonly stateChanged = new EventEmitter<ContextMenuState>();\n\n  open(config: {\n    event: MouseEvent;\n    items?: ContextMenuItem[];\n    triggerElement?: HTMLElement;\n    onAction?: (actionId: string) => void;\n  }) {\n    const { event, items = [], triggerElement, onAction } = config;\n\n    // Prevent browser context menu\n    event.preventDefault();\n\n    this._state = {\n      x: event.clientX,\n      y: event.clientY,\n      items,\n      isOpen: true,\n      triggerElement,\n      onAction\n    };\n\n    this.stateChanged.emit(this._state);\n  }\n\n  close() {\n    this._state = { ...this._state, isOpen: false };\n    this.stateChanged.emit(this._state);\n  }\n\n  async positionMenu(menuElement: HTMLElement) {\n    const state = this._state;\n    if (!state.isOpen || !menuElement) return;\n\n    // Create a precise virtual element for the mouse coordinates\n    const virtualEl = {\n      getBoundingClientRect() {\n        return {\n          width: 0,\n          height: 0,\n          x: state.x,\n          y: state.y,\n          top: state.y,\n          left: state.x,\n          right: state.x,\n          bottom: state.y,\n        };\n      }\n    };\n\n    const { x, y } = await computePosition(virtualEl as any, menuElement, {\n      placement: 'bottom-start', // Standard: Menu top-left aligns with mouse\n      strategy: 'fixed',\n      middleware: [\n        offset(2), // Slight offset so mouse isn't covering the first pixel\n        flip({\n          padding: 10,\n          fallbackPlacements: ['bottom-end', 'top-start', 'top-end']\n        }),\n        shift({ padding: 10 }),\n        size({\n          apply({ availableHeight, availableWidth, elements }) {\n            Object.assign(elements.floating.style, {\n              maxHeight: `${Math.max(100, availableHeight - 16)}px`,\n              maxWidth: `${Math.max(200, availableWidth - 16)}px`,\n              overflowY: 'auto'\n            });\n          }\n        })\n      ]\n    });\n\n    // Position via left/top, not transform: the menu's own\n    // data-[state=open]:zoom-in-95/slide-in-from-top-2 enter animation also\n    // drives `transform`, and a CSS animation overrides whatever an inline\n    // transform says for as long as it's running — so a translate() here\n    // would get clobbered by the animation and only \"snap\" into place once\n    // it finishes, which is exactly the top-left-then-jump flash this avoids.\n    Object.assign(menuElement.style, {\n      position: 'fixed',\n      left: `${Math.round(x)}px`,\n      top: `${Math.round(y)}px`,\n    });\n  }\n\n  async positionSubmenu(triggerElement: HTMLElement, submenuElement: HTMLElement) {\n    if (!triggerElement || !submenuElement) return;\n\n    const { x, y } = await computePosition(triggerElement, submenuElement, {\n      placement: 'right-start', // Standard: Submenu opens to the right\n      strategy: 'fixed',\n      middleware: [\n        offset(-4), // Overlap slightly with parent menu\n        flip({\n          padding: 10,\n          fallbackPlacements: ['left-start', 'bottom-start']\n        }),\n        shift({ padding: 10 }),\n        size({\n          apply({ availableHeight, availableWidth, elements }) {\n            Object.assign(elements.floating.style, {\n              maxHeight: `${Math.max(100, availableHeight - 16)}px`,\n              maxWidth: `${Math.max(200, availableWidth - 16)}px`,\n              overflowY: 'auto'\n            });\n          }\n        })\n      ]\n    });\n\n    Object.assign(submenuElement.style, {\n      position: 'fixed',\n      left: `${Math.round(x)}px`,\n      top: `${Math.round(y)}px`,\n    });\n  }\n\n  performAction(actionId: string) {\n    this._state.onAction?.(actionId);\n    this.close();\n  }\n}"]}