@tolle_/tolle-ui 18.2.29 → 18.3.0

package/esm2022/lib/menubar.component.mjs

@@ -0,0 +1,683 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Injectable, Input, Output, ViewChild, inject } from '@angular/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+let menubarMenuCounter = 0;
+/**
+ * Coordinates the menus of a single `tolle-menubar`. Provided by
+ * `MenubarComponent`, injected by every descendant menu/trigger/content.
+ *
+ * The defining behaviour of a menu bar lives here: once *any* menu is open,
+ * hovering a different trigger switches to it immediately (`hoverEnter`), while
+ * hovering with everything closed does nothing.
+ */
+export class MenubarService {
+    openIdSource = new BehaviorSubject(null);
+    /** Emits the id of the currently open menu, or `null` when all are closed. */
+    openId$ = this.openIdSource.asObservable();
+    sizeSource = new BehaviorSubject('default');
+    /**
+     * Emits the bar's size so OnPush triggers re-render when it changes. Reading
+     * the parent component's property directly would not mark them dirty.
+     */
+    size$ = this.sizeSource.asObservable();
+    /** The bar's current size scale. */
+    get size() {
+        return this.sizeSource.value;
+    }
+    setSize(size) {
+        if (this.sizeSource.value !== size)
+            this.sizeSource.next(size);
+    }
+    /** Registered menus in DOM (registration) order. */
+    menus = [];
+    /** Id of the open menu, or `null`. */
+    get openId() {
+        return this.openIdSource.value;
+    }
+    /** True while one of the bar's menus is open. */
+    get isAnyOpen() {
+        return this.openIdSource.value !== null;
+    }
+    register(menu) {
+        if (this.menus.indexOf(menu) === -1)
+            this.menus.push(menu);
+    }
+    unregister(menu) {
+        const i = this.menus.indexOf(menu);
+        if (i > -1)
+            this.menus.splice(i, 1);
+        if (this.openId === menu.id)
+            this.close();
+    }
+    isOpen(id) {
+        return this.openId === id;
+    }
+    open(id) {
+        if (this.openId !== id)
+            this.openIdSource.next(id);
+    }
+    close() {
+        if (this.openId !== null)
+            this.openIdSource.next(null);
+    }
+    toggle(id) {
+        if (this.openId === id)
+            this.close();
+        else
+            this.open(id);
+    }
+    /**
+     * Pointer entered a trigger. Only switches menus when the bar is already
+     * "active" (something open) — this is what makes a menu bar feel native.
+     */
+    hoverEnter(id) {
+        if (this.isAnyOpen)
+            this.open(id);
+    }
+    /** Moves focus to the previous/next menu, keeping the open state. */
+    moveMenu(delta) {
+        if (!this.menus.length)
+            return;
+        const current = this.menus.findIndex(m => m.id === this.openId);
+        const from = current > -1 ? current : this.indexOfFocusedTrigger();
+        const next = from < 0
+            ? delta > 0
+                ? 0
+                : this.menus.length - 1
+            : (from + delta + this.menus.length) % this.menus.length;
+        const target = this.menus[next];
+        if (this.isAnyOpen)
+            this.open(target.id);
+        target.triggerElement?.focus();
+    }
+    /** Moves focus between the enabled items of the currently open menu. */
+    moveItem(delta) {
+        const items = this.openItems();
+        if (!items.length)
+            return;
+        const current = items.indexOf(document.activeElement);
+        const next = current < 0
+            ? delta > 0
+                ? 0
+                : items.length - 1
+            : (current + delta + items.length) % items.length;
+        items[next].focus();
+    }
+    /** Focuses the trigger of the given menu (used when Escape closes a menu). */
+    focusTrigger(id) {
+        this.menus.find(m => m.id === id)?.triggerElement?.focus();
+    }
+    openItems() {
+        const content = this.menus.find(m => m.id === this.openId)?.contentElement;
+        if (!content)
+            return [];
+        return Array.from(content.querySelectorAll('[role="menuitem"]:not([data-disabled])'));
+    }
+    indexOfFocusedTrigger() {
+        const active = document.activeElement;
+        return this.menus.findIndex(m => !!m.triggerElement && m.triggerElement === active);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarService, decorators: [{
+            type: Injectable
+        }] });
+const menubarVariants = cva('flex items-center gap-1 rounded-md border border-border bg-background shadow-sm', {
+    variants: {
+        size: {
+            sm: 'h-8 p-0.5',
+            default: 'h-10 p-1',
+            lg: 'h-12 p-1.5',
+        },
+    },
+    defaultVariants: {
+        size: 'default',
+    },
+});
+const menubarTriggerVariants = cva('flex select-none items-center rounded-sm font-medium outline-none transition-colors ' +
+    'hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground ' +
+    'data-[state=open]:bg-accent data-[state=open]:text-accent-foreground ' +
+    'disabled:pointer-events-none disabled:opacity-50', {
+    variants: {
+        size: {
+            sm: 'h-7 px-2 text-xs',
+            default: 'h-8 px-3 text-sm',
+            lg: 'h-9 px-4 text-sm',
+        },
+    },
+    defaultVariants: {
+        size: 'default',
+    },
+});
+const menubarItemVariants = cva('relative flex w-full cursor-default select-none items-center gap-2 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', {
+    variants: {
+        variant: {
+            default: 'text-popover-foreground',
+            destructive: 'text-destructive focus:bg-destructive/10 hover:bg-destructive/10',
+        },
+        inset: {
+            true: 'pl-8',
+            false: '',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        inset: false,
+    },
+});
+/**
+ * Desktop-application style menu bar.
+ *
+ * ```html
+ * <tolle-menubar>
+ *   <tolle-menubar-menu>
+ *     <tolle-menubar-trigger>File</tolle-menubar-trigger>
+ *     <tolle-menubar-content>
+ *       <tolle-menubar-label>Document</tolle-menubar-label>
+ *       <tolle-menubar-item (select)="onNew()">New</tolle-menubar-item>
+ *       <tolle-menubar-separator />
+ *       <tolle-menubar-item variant="destructive">Delete</tolle-menubar-item>
+ *     </tolle-menubar-content>
+ *   </tolle-menubar-menu>
+ * </tolle-menubar>
+ * ```
+ * @new
+ */
+export class MenubarComponent {
+    /** Height/padding scale, inherited by every trigger in the bar. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the bar via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the id of the menu that opened, or `null` when the bar closes. */
+    openChange = new EventEmitter();
+    service = inject(MenubarService);
+    host = inject(ElementRef);
+    sub = new Subscription();
+    listening = false;
+    get computedClass() {
+        return cn(menubarVariants({ size: this.size }), this.class);
+    }
+    ngOnChanges() {
+        // Push size into the service so OnPush triggers get told about it.
+        this.service.setSize(this.size ?? 'default');
+    }
+    ngOnInit() {
+        this.service.setSize(this.size ?? 'default');
+        this.sub.add(this.service.openId$.subscribe(id => {
+            this.openChange.emit(id);
+            if (id !== null)
+                this.startListening();
+            else
+                this.stopListening();
+        }));
+    }
+    onKeydown(event) {
+        switch (event.key) {
+            case 'ArrowRight':
+                event.preventDefault();
+                this.service.moveMenu(1);
+                break;
+            case 'ArrowLeft':
+                event.preventDefault();
+                this.service.moveMenu(-1);
+                break;
+            case 'ArrowDown':
+                if (!this.service.isAnyOpen)
+                    break;
+                event.preventDefault();
+                this.service.moveItem(1);
+                break;
+            case 'ArrowUp':
+                if (!this.service.isAnyOpen)
+                    break;
+                event.preventDefault();
+                this.service.moveItem(-1);
+                break;
+            case 'Escape': {
+                const openId = this.service.openId;
+                if (openId === null)
+                    break;
+                event.preventDefault();
+                this.service.close();
+                this.service.focusTrigger(openId);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    // Capture phase so nested containers that stopPropagation() on their root
+    // (modal, sheet) cannot prevent the outside click from reaching us.
+    outsideClick = (event) => {
+        if (!this.host.nativeElement.contains(event.target))
+            this.service.close();
+    };
+    startListening() {
+        if (this.listening)
+            return;
+        this.listening = true;
+        document.addEventListener('pointerdown', this.outsideClick, true);
+    }
+    stopListening() {
+        if (!this.listening)
+            return;
+        this.listening = false;
+        document.removeEventListener('pointerdown', this.outsideClick, true);
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+        this.stopListening();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MenubarComponent, isStandalone: true, selector: "tolle-menubar", inputs: { size: "size", class: "class" }, outputs: { openChange: "openChange" }, host: { attributes: { "role": "menubar" }, listeners: { "keydown": "onKeydown($event)" }, properties: { "class": "computedClass" } }, providers: [MenubarService], usesOnChanges: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-menubar',
+                    standalone: true,
+                    imports: [],
+                    providers: [MenubarService],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        role: 'menubar',
+                        '[class]': 'computedClass',
+                        '(keydown)': 'onKeydown($event)',
+                    },
+                    template: `<ng-content></ng-content>`,
+                }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+/** A single menu in the bar — wraps one trigger and its content panel. */
+export class MenubarMenuComponent {
+    /** Explicit id for the menu; one is generated when omitted. */
+    id = `tolle-menubar-menu-${menubarMenuCounter++}`;
+    triggerElement = null;
+    contentElement = null;
+    service = inject(MenubarService);
+    get triggerId() {
+        return `${this.id}-trigger`;
+    }
+    get isOpen() {
+        return this.service.isOpen(this.id);
+    }
+    ngOnInit() {
+        this.service.register(this);
+    }
+    ngOnDestroy() {
+        this.service.unregister(this);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MenubarMenuComponent, isStandalone: true, selector: "tolle-menubar-menu", inputs: { id: "id" }, host: { attributes: { "role": "none" }, properties: { "class": "'relative inline-flex'" } }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-menubar-menu',
+                    standalone: true,
+                    imports: [],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    // Presentational so the menubar "owns" the trigger's menuitem role directly
+                    // even though this wrapper element sits in between.
+                    host: { role: 'none', '[class]': "'relative inline-flex'" },
+                    template: `<ng-content></ng-content>`,
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }] } });
+/** Button that opens its menu on click, and on hover once the bar is active. */
+export class MenubarTriggerComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Prevents the menu from opening. @default false */
+    disabled = false;
+    /** Overrides the size inherited from `tolle-menubar`. */
+    size;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class = '';
+    menu = inject(MenubarMenuComponent);
+    service = inject(MenubarService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    constructor() {
+        this.sub.add(this.service.openId$.subscribe(() => this.cdr.markForCheck()));
+        // The bar's size is not an input of this component, so nothing else would
+        // mark an OnPush trigger dirty when it changes.
+        this.sub.add(this.service.size$.subscribe(() => this.cdr.markForCheck()));
+    }
+    set triggerRef(ref) {
+        this.menu.triggerElement = ref?.nativeElement ?? null;
+    }
+    get isOpen() {
+        return this.menu.isOpen;
+    }
+    get computedClass() {
+        return cn(menubarTriggerVariants({ size: this.size ?? this.service.size }), this.class);
+    }
+    onClick() {
+        if (this.disabled)
+            return;
+        this.service.toggle(this.menu.id);
+    }
+    onMouseEnter() {
+        if (this.disabled)
+            return;
+        this.service.hoverEnter(this.menu.id);
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarTriggerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MenubarTriggerComponent, isStandalone: true, selector: "tolle-menubar-trigger", inputs: { disabled: "disabled", size: "size", class: "class" }, host: { attributes: { "role": "none" } }, viewQueries: [{ propertyName: "triggerRef", first: true, predicate: ["trigger"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <button
+      #trigger
+      type="button"
+      role="menuitem"
+      [id]="menu.triggerId"
+      [disabled]="disabled"
+      aria-haspopup="menu"
+      [attr.aria-expanded]="isOpen"
+      [attr.aria-controls]="isOpen ? menu.id + '-content' : null"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onClick()"
+      (mouseenter)="onMouseEnter()"
+    >
+      <ng-content></ng-content>
+    </button>
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarTriggerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-menubar-trigger', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, host: { role: 'none' }, template: `
+    <button
+      #trigger
+      type="button"
+      role="menuitem"
+      [id]="menu.triggerId"
+      [disabled]="disabled"
+      aria-haspopup="menu"
+      [attr.aria-expanded]="isOpen"
+      [attr.aria-controls]="isOpen ? menu.id + '-content' : null"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onClick()"
+      (mouseenter)="onMouseEnter()"
+    >
+      <ng-content></ng-content>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { disabled: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], triggerRef: [{
+                type: ViewChild,
+                args: ['trigger']
+            }] } });
+/** The dropdown panel of a menu. Rendered only while its menu is open. */
+export class MenubarContentComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Preferred side of the trigger to render on; flips when space is tight. @default 'bottom-start' */
+    placement = 'bottom-start';
+    /** Gap in pixels between the trigger and the panel. @default 4 */
+    sideOffset = 4;
+    /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */
+    class = '';
+    menu = inject(MenubarMenuComponent);
+    service = inject(MenubarService);
+    cdr = inject(ChangeDetectorRef);
+    sub;
+    cleanup;
+    constructor() {
+        this.sub = this.service.openId$.subscribe(() => this.cdr.markForCheck());
+    }
+    set panelRef(ref) {
+        const el = ref?.nativeElement ?? null;
+        this.menu.contentElement = el;
+        this.stopPositioning();
+        if (el)
+            this.startPositioning(el);
+    }
+    get isOpen() {
+        return this.menu.isOpen;
+    }
+    get computedClass() {
+        return cn('z-[1000] min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1', 'text-popover-foreground shadow-md animate-in fade-in zoom-in-95', this.class);
+    }
+    startPositioning(panel) {
+        const trigger = this.menu.triggerElement;
+        if (!trigger)
+            return;
+        this.cleanup = autoUpdate(trigger, panel, () => {
+            computePosition(trigger, panel, {
+                strategy: 'fixed',
+                placement: this.placement,
+                middleware: [offset(this.sideOffset), flip(), shift({ padding: 8 })],
+            }).then(({ x, y }) => {
+                Object.assign(panel.style, { left: `${x}px`, top: `${y}px` });
+            });
+        });
+    }
+    stopPositioning() {
+        this.cleanup?.();
+        this.cleanup = undefined;
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+        this.stopPositioning();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: MenubarContentComponent, isStandalone: true, selector: "tolle-menubar-content", inputs: { placement: "placement", sideOffset: "sideOffset", class: "class" }, viewQueries: [{ propertyName: "panelRef", first: true, predicate: ["panel"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    @if (isOpen) {
+      <div
+        #panel
+        role="menu"
+        aria-orientation="vertical"
+        [id]="menu.id + '-content'"
+        [attr.aria-labelledby]="menu.triggerId"
+        data-state="open"
+        [class]="computedClass"
+        style="position: fixed; top: 0; left: 0;"
+      >
+        <ng-content></ng-content>
+      </div>
+    }
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-menubar-content', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    @if (isOpen) {
+      <div
+        #panel
+        role="menu"
+        aria-orientation="vertical"
+        [id]="menu.id + '-content'"
+        [attr.aria-labelledby]="menu.triggerId"
+        data-state="open"
+        [class]="computedClass"
+        style="position: fixed; top: 0; left: 0;"
+      >
+        <ng-content></ng-content>
+      </div>
+    }
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { placement: [{
+                type: Input
+            }], sideOffset: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], panelRef: [{
+                type: ViewChild,
+                args: ['panel']
+            }] } });
+/** A selectable row inside a menu. Closes the bar when activated. */
+export class MenubarItemComponent {
+    cdr = inject(ChangeDetectorRef);
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Visual style of the item. @default 'default' */
+    variant = 'default';
+    /** Adds left padding so the label lines up with items that have icons. @default false */
+    inset = false;
+    /** Blocks activation and dims the item. @default false */
+    disabled = false;
+    /** Extra Tailwind classes merged onto the item via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when the item is clicked or activated with Enter/Space. */
+    select = new EventEmitter();
+    service = inject(MenubarService);
+    get computedClass() {
+        return cn(menubarItemVariants({ variant: this.variant, inset: this.inset }), this.class);
+    }
+    activate(event) {
+        if (this.disabled)
+            return;
+        event.preventDefault();
+        this.select.emit(event);
+        this.service.close();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MenubarItemComponent, isStandalone: true, selector: "tolle-menubar-item", inputs: { variant: "variant", inset: "inset", disabled: "disabled", class: "class" }, outputs: { select: "select" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      role="menuitem"
+      [attr.tabindex]="disabled ? null : -1"
+      [attr.data-disabled]="disabled ? '' : null"
+      [attr.aria-disabled]="disabled || null"
+      [class]="computedClass"
+      (click)="activate($event)"
+      (keydown.enter)="activate($event)"
+      (keydown.space)="activate($event)"
+    >
+      <ng-content select="[prefix]"></ng-content>
+      <span class="flex-1 truncate"><ng-content></ng-content></span>
+      <ng-content select="[shortcut]"></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-menubar-item', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      role="menuitem"
+      [attr.tabindex]="disabled ? null : -1"
+      [attr.data-disabled]="disabled ? '' : null"
+      [attr.aria-disabled]="disabled || null"
+      [class]="computedClass"
+      (click)="activate($event)"
+      (keydown.enter)="activate($event)"
+      (keydown.space)="activate($event)"
+    >
+      <ng-content select="[prefix]"></ng-content>
+      <span class="flex-1 truncate"><ng-content></ng-content></span>
+      <ng-content select="[shortcut]"></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], inset: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], select: [{
+                type: Output
+            }] } });
+/** A non-interactive heading inside a menu. */
+export class MenubarLabelComponent {
+    cdr = inject(ChangeDetectorRef);
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Adds left padding so the label lines up with items that have icons. @default false */
+    inset = false;
+    /** Extra Tailwind classes merged onto the label via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarLabelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MenubarLabelComponent, isStandalone: true, selector: "tolle-menubar-label", inputs: { inset: "inset", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      [class]="cn('px-2 py-1.5 text-xs font-semibold text-muted-foreground', inset ? 'pl-8' : '', class)"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarLabelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-menubar-label', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      [class]="cn('px-2 py-1.5 text-xs font-semibold text-muted-foreground', inset ? 'pl-8' : '', class)"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { inset: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** A horizontal rule between groups of menu items. */
+export class MenubarSeparatorComponent {
+    cdr = inject(ChangeDetectorRef);
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Extra Tailwind classes merged onto the separator via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarSeparatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MenubarSeparatorComponent, isStandalone: true, selector: "tolle-menubar-separator", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div role="separator" aria-orientation="horizontal" [class]="cn('-mx-1 my-1 h-px bg-border', class)"></div>`, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MenubarSeparatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-menubar-separator', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div role="separator" aria-orientation="horizontal" [class]="cn('-mx-1 my-1 h-px bg-border', class)"></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menubar.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/menubar.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, ViewChild, inject } from '@angular/core';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/**\n * Contract a `tolle-menubar-menu` fulfils so `MenubarService` can drive focus and\n * keyboard navigation without importing the component (which would be circular).\n */\nexport interface MenubarMenuRef {\n  /** Stable id, unique per menu instance. */\n  readonly id: string;\n  /** The menu's trigger button, once rendered. */\n  triggerElement: HTMLElement | null;\n  /** The menu's open panel, or `null` while closed. */\n  contentElement: HTMLElement | null;\n}\n\nlet menubarMenuCounter = 0;\n\n/**\n * Coordinates the menus of a single `tolle-menubar`. Provided by\n * `MenubarComponent`, injected by every descendant menu/trigger/content.\n *\n * The defining behaviour of a menu bar lives here: once *any* menu is open,\n * hovering a different trigger switches to it immediately (`hoverEnter`), while\n * hovering with everything closed does nothing.\n */\n@Injectable()\nexport class MenubarService {\n  private openIdSource = new BehaviorSubject<string | null>(null);\n  /** Emits the id of the currently open menu, or `null` when all are closed. */\n  readonly openId$ = this.openIdSource.asObservable();\n\n  private sizeSource = new BehaviorSubject<'sm' | 'default' | 'lg'>('default');\n  /**\n   * Emits the bar's size so OnPush triggers re-render when it changes. Reading\n   * the parent component's property directly would not mark them dirty.\n   */\n  readonly size$ = this.sizeSource.asObservable();\n\n  /** The bar's current size scale. */\n  get size(): 'sm' | 'default' | 'lg' {\n    return this.sizeSource.value;\n  }\n\n  setSize(size: 'sm' | 'default' | 'lg'): void {\n    if (this.sizeSource.value !== size) this.sizeSource.next(size);\n  }\n\n  /** Registered menus in DOM (registration) order. */\n  private menus: MenubarMenuRef[] = [];\n\n  /** Id of the open menu, or `null`. */\n  get openId(): string | null {\n    return this.openIdSource.value;\n  }\n\n  /** True while one of the bar's menus is open. */\n  get isAnyOpen(): boolean {\n    return this.openIdSource.value !== null;\n  }\n\n  register(menu: MenubarMenuRef): void {\n    if (this.menus.indexOf(menu) === -1) this.menus.push(menu);\n  }\n\n  unregister(menu: MenubarMenuRef): void {\n    const i = this.menus.indexOf(menu);\n    if (i > -1) this.menus.splice(i, 1);\n    if (this.openId === menu.id) this.close();\n  }\n\n  isOpen(id: string): boolean {\n    return this.openId === id;\n  }\n\n  open(id: string): void {\n    if (this.openId !== id) this.openIdSource.next(id);\n  }\n\n  close(): void {\n    if (this.openId !== null) this.openIdSource.next(null);\n  }\n\n  toggle(id: string): void {\n    if (this.openId === id) this.close();\n    else this.open(id);\n  }\n\n  /**\n   * Pointer entered a trigger. Only switches menus when the bar is already\n   * \"active\" (something open) — this is what makes a menu bar feel native.\n   */\n  hoverEnter(id: string): void {\n    if (this.isAnyOpen) this.open(id);\n  }\n\n  /** Moves focus to the previous/next menu, keeping the open state. */\n  moveMenu(delta: number): void {\n    if (!this.menus.length) return;\n    const current = this.menus.findIndex(m => m.id === this.openId);\n    const from = current > -1 ? current : this.indexOfFocusedTrigger();\n    const next =\n      from < 0\n        ? delta > 0\n          ? 0\n          : this.menus.length - 1\n        : (from + delta + this.menus.length) % this.menus.length;\n    const target = this.menus[next];\n    if (this.isAnyOpen) this.open(target.id);\n    target.triggerElement?.focus();\n  }\n\n  /** Moves focus between the enabled items of the currently open menu. */\n  moveItem(delta: number): void {\n    const items = this.openItems();\n    if (!items.length) return;\n    const current = items.indexOf(document.activeElement as HTMLElement);\n    const next =\n      current < 0\n        ? delta > 0\n          ? 0\n          : items.length - 1\n        : (current + delta + items.length) % items.length;\n    items[next].focus();\n  }\n\n  /** Focuses the trigger of the given menu (used when Escape closes a menu). */\n  focusTrigger(id: string): void {\n    this.menus.find(m => m.id === id)?.triggerElement?.focus();\n  }\n\n  private openItems(): HTMLElement[] {\n    const content = this.menus.find(m => m.id === this.openId)?.contentElement;\n    if (!content) return [];\n    return Array.from(\n      content.querySelectorAll<HTMLElement>('[role=\"menuitem\"]:not([data-disabled])')\n    );\n  }\n\n  private indexOfFocusedTrigger(): number {\n    const active = document.activeElement;\n    return this.menus.findIndex(m => !!m.triggerElement && m.triggerElement === active);\n  }\n}\n\nconst menubarVariants = cva(\n  'flex items-center gap-1 rounded-md border border-border bg-background shadow-sm',\n  {\n    variants: {\n      size: {\n        sm: 'h-8 p-0.5',\n        default: 'h-10 p-1',\n        lg: 'h-12 p-1.5',\n      },\n    },\n    defaultVariants: {\n      size: 'default',\n    },\n  }\n);\n\nexport type MenubarProps = VariantProps<typeof menubarVariants>;\n\nconst menubarTriggerVariants = cva(\n  'flex select-none items-center rounded-sm font-medium outline-none transition-colors ' +\n    'hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground ' +\n    'data-[state=open]:bg-accent data-[state=open]:text-accent-foreground ' +\n    'disabled:pointer-events-none disabled:opacity-50',\n  {\n    variants: {\n      size: {\n        sm: 'h-7 px-2 text-xs',\n        default: 'h-8 px-3 text-sm',\n        lg: 'h-9 px-4 text-sm',\n      },\n    },\n    defaultVariants: {\n      size: 'default',\n    },\n  }\n);\n\nexport type MenubarTriggerProps = VariantProps<typeof menubarTriggerVariants>;\n\nconst menubarItemVariants = cva(\n  'relative flex w-full cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors ' +\n    '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  {\n    variants: {\n      variant: {\n        default: 'text-popover-foreground',\n        destructive: 'text-destructive focus:bg-destructive/10 hover:bg-destructive/10',\n      },\n      inset: {\n        true: 'pl-8',\n        false: '',\n      },\n    },\n    defaultVariants: {\n      variant: 'default',\n      inset: false,\n    },\n  }\n);\n\nexport type MenubarItemProps = VariantProps<typeof menubarItemVariants>;\n\n/**\n * Desktop-application style menu bar.\n *\n * ```html\n * <tolle-menubar>\n *   <tolle-menubar-menu>\n *     <tolle-menubar-trigger>File</tolle-menubar-trigger>\n *     <tolle-menubar-content>\n *       <tolle-menubar-label>Document</tolle-menubar-label>\n *       <tolle-menubar-item (select)=\"onNew()\">New</tolle-menubar-item>\n *       <tolle-menubar-separator />\n *       <tolle-menubar-item variant=\"destructive\">Delete</tolle-menubar-item>\n *     </tolle-menubar-content>\n *   </tolle-menubar-menu>\n * </tolle-menubar>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-menubar',\n  standalone: true,\n  imports: [],\n  providers: [MenubarService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    role: 'menubar',\n    '[class]': 'computedClass',\n    '(keydown)': 'onKeydown($event)',\n  },\n  template: `<ng-content></ng-content>`,\n})\nexport class MenubarComponent implements OnInit, OnChanges, OnDestroy {\n  /** Height/padding scale, inherited by every trigger in the bar. @default 'default' */\n  @Input() size: MenubarProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the bar via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the id of the menu that opened, or `null` when the bar closes. */\n  @Output() openChange = new EventEmitter<string | null>();\n\n  protected readonly service = inject(MenubarService);\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly sub = new Subscription();\n  private listening = false;\n\n  get computedClass(): string {\n    return cn(menubarVariants({ size: this.size }), this.class);\n  }\n\n  ngOnChanges(): void {\n    // Push size into the service so OnPush triggers get told about it.\n    this.service.setSize(this.size ?? 'default');\n  }\n\n  ngOnInit(): void {\n    this.service.setSize(this.size ?? 'default');\n    this.sub.add(\n      this.service.openId$.subscribe(id => {\n        this.openChange.emit(id);\n        if (id !== null) this.startListening();\n        else this.stopListening();\n      })\n    );\n  }\n\n  protected onKeydown(event: KeyboardEvent): void {\n    switch (event.key) {\n      case 'ArrowRight':\n        event.preventDefault();\n        this.service.moveMenu(1);\n        break;\n      case 'ArrowLeft':\n        event.preventDefault();\n        this.service.moveMenu(-1);\n        break;\n      case 'ArrowDown':\n        if (!this.service.isAnyOpen) break;\n        event.preventDefault();\n        this.service.moveItem(1);\n        break;\n      case 'ArrowUp':\n        if (!this.service.isAnyOpen) break;\n        event.preventDefault();\n        this.service.moveItem(-1);\n        break;\n      case 'Escape': {\n        const openId = this.service.openId;\n        if (openId === null) break;\n        event.preventDefault();\n        this.service.close();\n        this.service.focusTrigger(openId);\n        break;\n      }\n      default:\n        break;\n    }\n  }\n\n  // Capture phase so nested containers that stopPropagation() on their root\n  // (modal, sheet) cannot prevent the outside click from reaching us.\n  private outsideClick = (event: Event) => {\n    if (!this.host.nativeElement.contains(event.target as Node)) this.service.close();\n  };\n\n  private startListening(): void {\n    if (this.listening) return;\n    this.listening = true;\n    document.addEventListener('pointerdown', this.outsideClick, true);\n  }\n\n  private stopListening(): void {\n    if (!this.listening) return;\n    this.listening = false;\n    document.removeEventListener('pointerdown', this.outsideClick, true);\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n    this.stopListening();\n  }\n}\n\n/** A single menu in the bar — wraps one trigger and its content panel. */\n@Component({\n  selector: 'tolle-menubar-menu',\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  // Presentational so the menubar \"owns\" the trigger's menuitem role directly\n  // even though this wrapper element sits in between.\n  host: { role: 'none', '[class]': \"'relative inline-flex'\" },\n  template: `<ng-content></ng-content>`,\n})\nexport class MenubarMenuComponent implements MenubarMenuRef, OnInit, OnDestroy {\n  /** Explicit id for the menu; one is generated when omitted. */\n  @Input() id = `tolle-menubar-menu-${menubarMenuCounter++}`;\n\n  triggerElement: HTMLElement | null = null;\n  contentElement: HTMLElement | null = null;\n\n  readonly service = inject(MenubarService);\n\n  get triggerId(): string {\n    return `${this.id}-trigger`;\n  }\n\n  get isOpen(): boolean {\n    return this.service.isOpen(this.id);\n  }\n\n  ngOnInit(): void {\n    this.service.register(this);\n  }\n\n  ngOnDestroy(): void {\n    this.service.unregister(this);\n  }\n}\n\n/** Button that opens its menu on click, and on hover once the bar is active. */\n@Component({\n  selector: 'tolle-menubar-trigger',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { role: 'none' },\n  template: `\n    <button\n      #trigger\n      type=\"button\"\n      role=\"menuitem\"\n      [id]=\"menu.triggerId\"\n      [disabled]=\"disabled\"\n      aria-haspopup=\"menu\"\n      [attr.aria-expanded]=\"isOpen\"\n      [attr.aria-controls]=\"isOpen ? menu.id + '-content' : null\"\n      [attr.data-state]=\"isOpen ? 'open' : 'closed'\"\n      [class]=\"computedClass\"\n      (click)=\"onClick()\"\n      (mouseenter)=\"onMouseEnter()\"\n    >\n      <ng-content></ng-content>\n    </button>\n  `,\n})\nexport class MenubarTriggerComponent implements OnChanges, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Prevents the menu from opening. @default false */\n  @Input() disabled = false;\n  /** Overrides the size inherited from `tolle-menubar`. */\n  @Input() size?: MenubarTriggerProps['size'];\n  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  protected readonly menu = inject(MenubarMenuComponent);\n  private readonly service = inject(MenubarService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  constructor() {\n    this.sub.add(this.service.openId$.subscribe(() => this.cdr.markForCheck()));\n    // The bar's size is not an input of this component, so nothing else would\n    // mark an OnPush trigger dirty when it changes.\n    this.sub.add(this.service.size$.subscribe(() => this.cdr.markForCheck()));\n  }\n\n  @ViewChild('trigger') set triggerRef(ref: ElementRef<HTMLButtonElement> | undefined) {\n    this.menu.triggerElement = ref?.nativeElement ?? null;\n  }\n\n  protected get isOpen(): boolean {\n    return this.menu.isOpen;\n  }\n\n  protected get computedClass(): string {\n    return cn(menubarTriggerVariants({ size: this.size ?? this.service.size }), this.class);\n  }\n\n  protected onClick(): void {\n    if (this.disabled) return;\n    this.service.toggle(this.menu.id);\n  }\n\n  protected onMouseEnter(): void {\n    if (this.disabled) return;\n    this.service.hoverEnter(this.menu.id);\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n}\n\n/** The dropdown panel of a menu. Rendered only while its menu is open. */\n@Component({\n  selector: 'tolle-menubar-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    @if (isOpen) {\n      <div\n        #panel\n        role=\"menu\"\n        aria-orientation=\"vertical\"\n        [id]=\"menu.id + '-content'\"\n        [attr.aria-labelledby]=\"menu.triggerId\"\n        data-state=\"open\"\n        [class]=\"computedClass\"\n        style=\"position: fixed; top: 0; left: 0;\"\n      >\n        <ng-content></ng-content>\n      </div>\n    }\n  `,\n})\nexport class MenubarContentComponent implements OnChanges, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Preferred side of the trigger to render on; flips when space is tight. @default 'bottom-start' */\n  @Input() placement: 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' = 'bottom-start';\n  /** Gap in pixels between the trigger and the panel. @default 4 */\n  @Input() sideOffset = 4;\n  /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */\n  @Input() class = '';\n\n  protected readonly menu = inject(MenubarMenuComponent);\n  private readonly service = inject(MenubarService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub: Subscription;\n  private cleanup?: () => void;\n\n  constructor() {\n    this.sub = this.service.openId$.subscribe(() => this.cdr.markForCheck());\n  }\n\n  @ViewChild('panel') set panelRef(ref: ElementRef<HTMLElement> | undefined) {\n    const el = ref?.nativeElement ?? null;\n    this.menu.contentElement = el;\n    this.stopPositioning();\n    if (el) this.startPositioning(el);\n  }\n\n  protected get isOpen(): boolean {\n    return this.menu.isOpen;\n  }\n\n  protected get computedClass(): string {\n    return cn(\n      'z-[1000] min-w-[12rem] overflow-hidden rounded-md border border-border bg-popover p-1',\n      'text-popover-foreground shadow-md animate-in fade-in zoom-in-95',\n      this.class\n    );\n  }\n\n  private startPositioning(panel: HTMLElement): void {\n    const trigger = this.menu.triggerElement;\n    if (!trigger) return;\n    this.cleanup = autoUpdate(trigger, panel, () => {\n      computePosition(trigger, panel, {\n        strategy: 'fixed',\n        placement: this.placement,\n        middleware: [offset(this.sideOffset), flip(), shift({ padding: 8 })],\n      }).then(({ x, y }) => {\n        Object.assign(panel.style, { left: `${x}px`, top: `${y}px` });\n      });\n    });\n  }\n\n  private stopPositioning(): void {\n    this.cleanup?.();\n    this.cleanup = undefined;\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n    this.stopPositioning();\n  }\n}\n\n/** A selectable row inside a menu. Closes the bar when activated. */\n@Component({\n  selector: 'tolle-menubar-item',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      role=\"menuitem\"\n      [attr.tabindex]=\"disabled ? null : -1\"\n      [attr.data-disabled]=\"disabled ? '' : null\"\n      [attr.aria-disabled]=\"disabled || null\"\n      [class]=\"computedClass\"\n      (click)=\"activate($event)\"\n      (keydown.enter)=\"activate($event)\"\n      (keydown.space)=\"activate($event)\"\n    >\n      <ng-content select=\"[prefix]\"></ng-content>\n      <span class=\"flex-1 truncate\"><ng-content></ng-content></span>\n      <ng-content select=\"[shortcut]\"></ng-content>\n    </div>\n  `,\n})\nexport class MenubarItemComponent  implements OnChanges{\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Visual style of the item. @default 'default' */\n  @Input() variant: MenubarItemProps['variant'] = 'default';\n  /** Adds left padding so the label lines up with items that have icons. @default false */\n  @Input() inset = false;\n  /** Blocks activation and dims the item. @default false */\n  @Input() disabled = false;\n  /** Extra Tailwind classes merged onto the item via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when the item is clicked or activated with Enter/Space. */\n  @Output() select = new EventEmitter<Event>();\n\n  private readonly service = inject(MenubarService);\n\n  protected get computedClass(): string {\n    return cn(\n      menubarItemVariants({ variant: this.variant, inset: this.inset }),\n      this.class\n    );\n  }\n\n  protected activate(event: Event): void {\n    if (this.disabled) return;\n    event.preventDefault();\n    this.select.emit(event);\n    this.service.close();\n  }\n}\n\n/** A non-interactive heading inside a menu. */\n@Component({\n  selector: 'tolle-menubar-label',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      [class]=\"cn('px-2 py-1.5 text-xs font-semibold text-muted-foreground', inset ? 'pl-8' : '', class)\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class MenubarLabelComponent  implements OnChanges{\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Adds left padding so the label lines up with items that have icons. @default false */\n  @Input() inset = false;\n  /** Extra Tailwind classes merged onto the label via `cn()` (last-wins). */\n  @Input() class = '';\n  protected readonly cn = cn;\n}\n\n/** A horizontal rule between groups of menu items. */\n@Component({\n  selector: 'tolle-menubar-separator',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div role=\"separator\" aria-orientation=\"horizontal\" [class]=\"cn('-mx-1 my-1 h-px bg-border', class)\"></div>`,\n})\nexport class MenubarSeparatorComponent  implements OnChanges{\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Extra Tailwind classes merged onto the separator via `cn()` (last-wins). */\n  @Input() class = '';\n  protected readonly cn = cn;\n}\n"]}