@tolle_/tolle-ui 18.2.29 → 18.2.30

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

@@ -0,0 +1,642 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Injectable, Input, Output, ViewChild, inject } from '@angular/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { computePosition, flip, shift, offset, size, autoUpdate } from '@floating-ui/dom';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+let navigationMenuItemCounter = 0;
+/**
+ * Coordinates the items of a single `tolle-navigation-menu`. Provided by
+ * `NavigationMenuComponent`, injected by its descendants.
+ *
+ * Closing is deferred by `closeDelay` so a pointer travelling diagonally from a
+ * trigger into its panel does not dismiss the menu mid-flight; re-entering
+ * either surface calls `cancelClose()` and the pending close is dropped.
+ */
+export class NavigationMenuService {
+    openIdSource = new BehaviorSubject(null);
+    /** Emits the id of the currently open item, or `null` when all are closed. */
+    openId$ = this.openIdSource.asObservable();
+    /** Milliseconds to wait before closing after the pointer leaves. */
+    closeDelay = 150;
+    closeTimer;
+    /** Id of the open item, or `null`. */
+    get openId() {
+        return this.openIdSource.value;
+    }
+    /** True while any panel is open. */
+    get isAnyOpen() {
+        return this.openIdSource.value !== null;
+    }
+    /** True while a deferred close is pending — exposed for tests/diagnostics. */
+    get isCloseScheduled() {
+        return this.closeTimer !== undefined;
+    }
+    isOpen(id) {
+        return this.openId === id;
+    }
+    /** Opens an item immediately and cancels any pending close. */
+    open(id) {
+        this.cancelClose();
+        if (this.openId !== id)
+            this.openIdSource.next(id);
+    }
+    /** Closes immediately, dropping any pending close. */
+    closeNow() {
+        this.cancelClose();
+        if (this.openId !== null)
+            this.openIdSource.next(null);
+    }
+    /** Queues a close in `closeDelay` ms; a later `open`/`cancelClose` wins. */
+    scheduleClose() {
+        this.cancelClose();
+        this.closeTimer = setTimeout(() => {
+            this.closeTimer = undefined;
+            this.closeNow();
+        }, this.closeDelay);
+    }
+    /** Drops a pending close (pointer came back). */
+    cancelClose() {
+        if (this.closeTimer !== undefined) {
+            clearTimeout(this.closeTimer);
+            this.closeTimer = undefined;
+        }
+    }
+    toggle(id) {
+        if (this.openId === id)
+            this.closeNow();
+        else
+            this.open(id);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuService, decorators: [{
+            type: Injectable
+        }] });
+const navigationMenuVariants = cva('relative z-10 flex max-w-max flex-1 items-center justify-center', {
+    variants: {
+        align: {
+            start: 'justify-start',
+            center: 'justify-center',
+            end: 'justify-end',
+        },
+    },
+    defaultVariants: {
+        align: 'center',
+    },
+});
+const navigationMenuTriggerVariants = cva('group inline-flex w-max select-none items-center justify-center gap-1 rounded-md bg-background font-medium transition-colors ' +
+    'hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-none ' +
+    'data-[state=open]:bg-accent/50 data-[state=open]:text-accent-foreground ' +
+    'disabled:pointer-events-none disabled:opacity-50', {
+    variants: {
+        size: {
+            sm: 'h-8 px-3 text-xs',
+            default: 'h-9 px-4 py-2 text-sm',
+            lg: 'h-10 px-5 text-sm',
+        },
+    },
+    defaultVariants: {
+        size: 'default',
+    },
+});
+const navigationMenuLinkVariants = cva('flex select-none flex-col gap-1 rounded-md p-3 leading-none no-underline outline-none transition-colors ' +
+    'hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground', {
+    variants: {
+        variant: {
+            default: 'text-foreground',
+            muted: 'text-muted-foreground hover:text-accent-foreground',
+        },
+        active: {
+            true: 'bg-accent text-accent-foreground',
+            false: '',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        active: false,
+    },
+});
+/**
+ * Site navigation menu: a row of links and triggers, where each trigger reveals
+ * a floating panel on hover, focus or click.
+ *
+ * ```html
+ * <tolle-navigation-menu>
+ *   <tolle-navigation-menu-list>
+ *     <tolle-navigation-menu-item>
+ *       <tolle-navigation-menu-trigger>Products</tolle-navigation-menu-trigger>
+ *       <tolle-navigation-menu-content class="w-[420px]">
+ *         <tolle-navigation-menu-link href="/analytics">Analytics</tolle-navigation-menu-link>
+ *       </tolle-navigation-menu-content>
+ *     </tolle-navigation-menu-item>
+ *   </tolle-navigation-menu-list>
+ * </tolle-navigation-menu>
+ * ```
+ * @new
+ */
+export class NavigationMenuComponent {
+    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();
+    }
+    /** Horizontal alignment of the list within the nav. @default 'center' */
+    align = 'center';
+    /** Accessible name for the `<nav>` landmark. @default 'Main' */
+    ariaLabel = 'Main';
+    /**
+     * Milliseconds before a panel closes after the pointer leaves — the grace
+     * period that lets the pointer travel diagonally into the panel. @default 150
+     */
+    set closeDelay(value) {
+        this.service.closeDelay = value;
+    }
+    get closeDelay() {
+        return this.service.closeDelay;
+    }
+    /** Extra Tailwind classes merged onto the `<nav>` via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the id of the item that opened, or `null` when the menu closes. */
+    openChange = new EventEmitter();
+    service = inject(NavigationMenuService);
+    host = inject(ElementRef);
+    sub = new Subscription();
+    listening = false;
+    get computedClass() {
+        return cn(navigationMenuVariants({ align: this.align }), this.class);
+    }
+    ngOnInit() {
+        this.sub.add(this.service.openId$.subscribe(id => {
+            this.openChange.emit(id);
+            if (id !== null)
+                this.startListening();
+            else
+                this.stopListening();
+        }));
+    }
+    onKeydown(event) {
+        if (event.key === 'Escape' && this.service.isAnyOpen) {
+            event.preventDefault();
+            this.service.closeNow();
+        }
+    }
+    // Capture phase so containers that stopPropagation() on their root cannot
+    // prevent the outside click from reaching us.
+    outsideClick = (event) => {
+        if (!this.host.nativeElement.contains(event.target))
+            this.service.closeNow();
+    };
+    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();
+        this.service.cancelClose();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: NavigationMenuComponent, isStandalone: true, selector: "tolle-navigation-menu", inputs: { align: "align", ariaLabel: "ariaLabel", closeDelay: "closeDelay", class: "class" }, outputs: { openChange: "openChange" }, providers: [NavigationMenuService], usesOnChanges: true, ngImport: i0, template: `
+    <nav [attr.aria-label]="ariaLabel" [class]="computedClass" (keydown)="onKeydown($event)">
+      <ng-content></ng-content>
+    </nav>
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-navigation-menu', standalone: true, imports: [], providers: [NavigationMenuService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <nav [attr.aria-label]="ariaLabel" [class]="computedClass" (keydown)="onKeydown($event)">
+      <ng-content></ng-content>
+    </nav>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { align: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], closeDelay: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+/** The horizontal list that holds the navigation items. */
+export class NavigationMenuListComponent {
+    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 `<ul>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: NavigationMenuListComponent, isStandalone: true, selector: "tolle-navigation-menu-list", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <ul [class]="cn('group flex flex-1 list-none items-center justify-center gap-1', class)">
+      <ng-content></ng-content>
+    </ul>
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-navigation-menu-list', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <ul [class]="cn('group flex flex-1 list-none items-center justify-center gap-1', class)">
+      <ng-content></ng-content>
+    </ul>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** One entry in the list — a plain link, or a trigger plus its content panel. */
+export class NavigationMenuItemComponent {
+    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();
+    }
+    /** Explicit id for the item; one is generated when omitted. */
+    id = `tolle-navigation-menu-item-${navigationMenuItemCounter++}`;
+    /** Extra Tailwind classes merged onto the `<li>` via `cn()` (last-wins). */
+    class = '';
+    service = inject(NavigationMenuService);
+    cn = cn;
+    triggerElement = null;
+    get triggerId() {
+        return `${this.id}-trigger`;
+    }
+    get contentId() {
+        return `${this.id}-content`;
+    }
+    get isOpen() {
+        return this.service.isOpen(this.id);
+    }
+    ngOnDestroy() {
+        if (this.isOpen)
+            this.service.closeNow();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: NavigationMenuItemComponent, isStandalone: true, selector: "tolle-navigation-menu-item", inputs: { id: "id", class: "class" }, host: { properties: { "class": "'contents'" } }, usesOnChanges: true, ngImport: i0, template: `
+    <li [class]="cn('relative', class)">
+      <ng-content></ng-content>
+    </li>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-navigation-menu-item',
+                    standalone: true,
+                    imports: [],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { '[class]': "'contents'" },
+                    template: `
+    <li [class]="cn('relative', class)">
+      <ng-content></ng-content>
+    </li>
+  `,
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Button that reveals its item's panel on hover, focus or click. */
+export class NavigationMenuTriggerComponent {
+    /**
+     * 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 panel from opening. @default false */
+    disabled = false;
+    /** Height/padding scale of the trigger. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class = '';
+    item = inject(NavigationMenuItemComponent);
+    service = inject(NavigationMenuService);
+    cdr = inject(ChangeDetectorRef);
+    sub;
+    constructor() {
+        this.sub = this.service.openId$.subscribe(() => this.cdr.markForCheck());
+    }
+    set triggerRef(ref) {
+        this.item.triggerElement = ref?.nativeElement ?? null;
+    }
+    get isOpen() {
+        return this.item.isOpen;
+    }
+    get computedClass() {
+        return cn(navigationMenuTriggerVariants({ size: this.size }), this.class);
+    }
+    onClick() {
+        if (this.disabled)
+            return;
+        this.service.toggle(this.item.id);
+    }
+    onPointerEnter() {
+        if (this.disabled)
+            return;
+        this.service.open(this.item.id);
+    }
+    onPointerLeave() {
+        this.service.scheduleClose();
+    }
+    onKeydown(event) {
+        if (this.disabled)
+            return;
+        if (event.key === 'ArrowDown' || event.key === 'Enter' || event.key === ' ') {
+            event.preventDefault();
+            this.service.open(this.item.id);
+        }
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuTriggerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: NavigationMenuTriggerComponent, isStandalone: true, selector: "tolle-navigation-menu-trigger", inputs: { disabled: "disabled", size: "size", class: "class" }, viewQueries: [{ propertyName: "triggerRef", first: true, predicate: ["trigger"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <button
+      #trigger
+      type="button"
+      [id]="item.triggerId"
+      [disabled]="disabled"
+      aria-haspopup="true"
+      [attr.aria-expanded]="isOpen"
+      [attr.aria-controls]="isOpen ? item.contentId : null"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onClick()"
+      (mouseenter)="onPointerEnter()"
+      (mouseleave)="onPointerLeave()"
+      (focus)="onPointerEnter()"
+      (keydown)="onKeydown($event)"
+    >
+      <ng-content></ng-content>
+      <i
+        class="ri-arrow-down-s-line text-[16px] transition-transform duration-200"
+        [class.rotate-180]="isOpen"
+        aria-hidden="true"
+      ></i>
+    </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: NavigationMenuTriggerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-navigation-menu-trigger', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      #trigger
+      type="button"
+      [id]="item.triggerId"
+      [disabled]="disabled"
+      aria-haspopup="true"
+      [attr.aria-expanded]="isOpen"
+      [attr.aria-controls]="isOpen ? item.contentId : null"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onClick()"
+      (mouseenter)="onPointerEnter()"
+      (mouseleave)="onPointerLeave()"
+      (focus)="onPointerEnter()"
+      (keydown)="onKeydown($event)"
+    >
+      <ng-content></ng-content>
+      <i
+        class="ri-arrow-down-s-line text-[16px] transition-transform duration-200"
+        [class.rotate-180]="isOpen"
+        aria-hidden="true"
+      ></i>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { disabled: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], triggerRef: [{
+                type: ViewChild,
+                args: ['trigger']
+            }] } });
+/** The floating panel revealed by a trigger. Rendered only while open. */
+export class NavigationMenuContentComponent {
+    /**
+     * 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' */
+    placement = 'bottom';
+    /** Gap in pixels between the trigger and the panel. @default 8 */
+    sideOffset = 8;
+    /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */
+    class = '';
+    item = inject(NavigationMenuItemComponent);
+    service = inject(NavigationMenuService);
+    cdr = inject(ChangeDetectorRef);
+    sub;
+    cleanup;
+    constructor() {
+        this.sub = this.service.openId$.subscribe(() => this.cdr.markForCheck());
+    }
+    set panelRef(ref) {
+        this.stopPositioning();
+        if (ref?.nativeElement)
+            this.startPositioning(ref.nativeElement);
+    }
+    get isOpen() {
+        return this.item.isOpen;
+    }
+    get computedClass() {
+        return cn('z-[1000] overflow-auto rounded-md border border-border bg-popover p-2 text-popover-foreground', 'shadow-lg animate-in fade-in zoom-in-95', this.class);
+    }
+    onPointerEnter() {
+        this.service.cancelClose();
+    }
+    onPointerLeave() {
+        this.service.scheduleClose();
+    }
+    startPositioning(panel) {
+        const trigger = this.item.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 }),
+                    // Wide panels are common here — clamp to what the viewport can show
+                    // instead of letting them overflow.
+                    size({
+                        padding: 8,
+                        apply({ elements, availableWidth, availableHeight }) {
+                            Object.assign(elements.floating.style, {
+                                maxWidth: `${Math.max(0, availableWidth)}px`,
+                                maxHeight: `${Math.max(0, availableHeight)}px`,
+                            });
+                        },
+                    }),
+                ],
+            }).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: NavigationMenuContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: NavigationMenuContentComponent, isStandalone: true, selector: "tolle-navigation-menu-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
+        [id]="item.contentId"
+        [attr.aria-labelledby]="item.triggerId"
+        data-state="open"
+        [class]="computedClass"
+        style="position: fixed; top: 0; left: 0;"
+        (mouseenter)="onPointerEnter()"
+        (mouseleave)="onPointerLeave()"
+      >
+        <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: NavigationMenuContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-navigation-menu-content', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    @if (isOpen) {
+      <div
+        #panel
+        [id]="item.contentId"
+        [attr.aria-labelledby]="item.triggerId"
+        data-state="open"
+        [class]="computedClass"
+        style="position: fixed; top: 0; left: 0;"
+        (mouseenter)="onPointerEnter()"
+        (mouseleave)="onPointerLeave()"
+      >
+        <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 link inside a panel (or directly in the list, for flat entries). */
+export class NavigationMenuLinkComponent {
+    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();
+    }
+    /** Destination URL. Omit to render a non-navigating item. */
+    href = '';
+    /** Anchor target; `_blank` also sets a safe `rel`. */
+    target = '';
+    /** Marks the link as the current page. @default false */
+    active = false;
+    /** Visual style of the link. @default 'default' */
+    variant = 'default';
+    /** Extra Tailwind classes merged onto the anchor via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the click event when the link is activated. */
+    navigate = new EventEmitter();
+    get computedClass() {
+        return cn(navigationMenuLinkVariants({ variant: this.variant, active: this.active }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuLinkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: NavigationMenuLinkComponent, isStandalone: true, selector: "tolle-navigation-menu-link", inputs: { href: "href", target: "target", active: "active", variant: "variant", class: "class" }, outputs: { navigate: "navigate" }, usesOnChanges: true, ngImport: i0, template: `
+    <a
+      [attr.href]="href || null"
+      [attr.target]="target || null"
+      [attr.rel]="target === '_blank' ? 'noreferrer noopener' : null"
+      [attr.aria-current]="active ? 'page' : null"
+      [attr.data-active]="active ? '' : null"
+      [class]="computedClass"
+      (click)="navigate.emit($event)"
+    >
+      <ng-content select="[label]"></ng-content>
+      <ng-content></ng-content>
+      <ng-content select="[description]"></ng-content>
+    </a>
+  `, isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NavigationMenuLinkComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-navigation-menu-link', standalone: true, imports: [], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <a
+      [attr.href]="href || null"
+      [attr.target]="target || null"
+      [attr.rel]="target === '_blank' ? 'noreferrer noopener' : null"
+      [attr.aria-current]="active ? 'page' : null"
+      [attr.data-active]="active ? '' : null"
+      [class]="computedClass"
+      (click)="navigate.emit($event)"
+    >
+      <ng-content select="[label]"></ng-content>
+      <ng-content></ng-content>
+      <ng-content select="[description]"></ng-content>
+    </a>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { href: [{
+                type: Input
+            }], target: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], navigate: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-menu.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/navigation-menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Injectable, Input, OnDestroy, OnInit, Output, ViewChild, inject, OnChanges } from '@angular/core';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { computePosition, flip, shift, offset, size, autoUpdate } from '@floating-ui/dom';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nlet navigationMenuItemCounter = 0;\n\n/**\n * Coordinates the items of a single `tolle-navigation-menu`. Provided by\n * `NavigationMenuComponent`, injected by its descendants.\n *\n * Closing is deferred by `closeDelay` so a pointer travelling diagonally from a\n * trigger into its panel does not dismiss the menu mid-flight; re-entering\n * either surface calls `cancelClose()` and the pending close is dropped.\n */\n@Injectable()\nexport class NavigationMenuService {\n  private openIdSource = new BehaviorSubject<string | null>(null);\n  /** Emits the id of the currently open item, or `null` when all are closed. */\n  readonly openId$ = this.openIdSource.asObservable();\n\n  /** Milliseconds to wait before closing after the pointer leaves. */\n  closeDelay = 150;\n\n  private closeTimer: ReturnType<typeof setTimeout> | undefined;\n\n  /** Id of the open item, or `null`. */\n  get openId(): string | null {\n    return this.openIdSource.value;\n  }\n\n  /** True while any panel is open. */\n  get isAnyOpen(): boolean {\n    return this.openIdSource.value !== null;\n  }\n\n  /** True while a deferred close is pending — exposed for tests/diagnostics. */\n  get isCloseScheduled(): boolean {\n    return this.closeTimer !== undefined;\n  }\n\n  isOpen(id: string): boolean {\n    return this.openId === id;\n  }\n\n  /** Opens an item immediately and cancels any pending close. */\n  open(id: string): void {\n    this.cancelClose();\n    if (this.openId !== id) this.openIdSource.next(id);\n  }\n\n  /** Closes immediately, dropping any pending close. */\n  closeNow(): void {\n    this.cancelClose();\n    if (this.openId !== null) this.openIdSource.next(null);\n  }\n\n  /** Queues a close in `closeDelay` ms; a later `open`/`cancelClose` wins. */\n  scheduleClose(): void {\n    this.cancelClose();\n    this.closeTimer = setTimeout(() => {\n      this.closeTimer = undefined;\n      this.closeNow();\n    }, this.closeDelay);\n  }\n\n  /** Drops a pending close (pointer came back). */\n  cancelClose(): void {\n    if (this.closeTimer !== undefined) {\n      clearTimeout(this.closeTimer);\n      this.closeTimer = undefined;\n    }\n  }\n\n  toggle(id: string): void {\n    if (this.openId === id) this.closeNow();\n    else this.open(id);\n  }\n}\n\nconst navigationMenuVariants = cva('relative z-10 flex max-w-max flex-1 items-center justify-center', {\n  variants: {\n    align: {\n      start: 'justify-start',\n      center: 'justify-center',\n      end: 'justify-end',\n    },\n  },\n  defaultVariants: {\n    align: 'center',\n  },\n});\n\nexport type NavigationMenuProps = VariantProps<typeof navigationMenuVariants>;\n\nconst navigationMenuTriggerVariants = cva(\n  'group inline-flex w-max select-none items-center justify-center gap-1 rounded-md bg-background font-medium transition-colors ' +\n    'hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-none ' +\n    'data-[state=open]:bg-accent/50 data-[state=open]:text-accent-foreground ' +\n    'disabled:pointer-events-none disabled:opacity-50',\n  {\n    variants: {\n      size: {\n        sm: 'h-8 px-3 text-xs',\n        default: 'h-9 px-4 py-2 text-sm',\n        lg: 'h-10 px-5 text-sm',\n      },\n    },\n    defaultVariants: {\n      size: 'default',\n    },\n  }\n);\n\nexport type NavigationMenuTriggerProps = VariantProps<typeof navigationMenuTriggerVariants>;\n\nconst navigationMenuLinkVariants = cva(\n  'flex select-none flex-col gap-1 rounded-md p-3 leading-none no-underline outline-none transition-colors ' +\n    'hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground',\n  {\n    variants: {\n      variant: {\n        default: 'text-foreground',\n        muted: 'text-muted-foreground hover:text-accent-foreground',\n      },\n      active: {\n        true: 'bg-accent text-accent-foreground',\n        false: '',\n      },\n    },\n    defaultVariants: {\n      variant: 'default',\n      active: false,\n    },\n  }\n);\n\nexport type NavigationMenuLinkProps = VariantProps<typeof navigationMenuLinkVariants>;\n\n/**\n * Site navigation menu: a row of links and triggers, where each trigger reveals\n * a floating panel on hover, focus or click.\n *\n * ```html\n * <tolle-navigation-menu>\n *   <tolle-navigation-menu-list>\n *     <tolle-navigation-menu-item>\n *       <tolle-navigation-menu-trigger>Products</tolle-navigation-menu-trigger>\n *       <tolle-navigation-menu-content class=\"w-[420px]\">\n *         <tolle-navigation-menu-link href=\"/analytics\">Analytics</tolle-navigation-menu-link>\n *       </tolle-navigation-menu-content>\n *     </tolle-navigation-menu-item>\n *   </tolle-navigation-menu-list>\n * </tolle-navigation-menu>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-navigation-menu',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  providers: [NavigationMenuService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <nav [attr.aria-label]=\"ariaLabel\" [class]=\"computedClass\" (keydown)=\"onKeydown($event)\">\n      <ng-content></ng-content>\n    </nav>\n  `,\n})\nexport class NavigationMenuComponent implements OnChanges, OnInit, OnDestroy {\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  /** Horizontal alignment of the list within the nav. @default 'center' */\n  @Input() align: NavigationMenuProps['align'] = 'center';\n  /** Accessible name for the `<nav>` landmark. @default 'Main' */\n  @Input() ariaLabel = 'Main';\n  /**\n   * Milliseconds before a panel closes after the pointer leaves — the grace\n   * period that lets the pointer travel diagonally into the panel. @default 150\n   */\n  @Input() set closeDelay(value: number) {\n    this.service.closeDelay = value;\n  }\n  get closeDelay(): number {\n    return this.service.closeDelay;\n  }\n  /** Extra Tailwind classes merged onto the `<nav>` via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the id of the item that opened, or `null` when the menu closes. */\n  @Output() openChange = new EventEmitter<string | null>();\n\n  private readonly service = inject(NavigationMenuService);\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly sub = new Subscription();\n  private listening = false;\n\n  protected get computedClass(): string {\n    return cn(navigationMenuVariants({ align: this.align }), this.class);\n  }\n\n  ngOnInit(): void {\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    if (event.key === 'Escape' && this.service.isAnyOpen) {\n      event.preventDefault();\n      this.service.closeNow();\n    }\n  }\n\n  // Capture phase so containers that stopPropagation() on their root cannot\n  // prevent the outside click from reaching us.\n  private outsideClick = (event: Event) => {\n    if (!this.host.nativeElement.contains(event.target as Node)) this.service.closeNow();\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    this.service.cancelClose();\n  }\n}\n\n/** The horizontal list that holds the navigation items. */\n@Component({\n  selector: 'tolle-navigation-menu-list',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <ul [class]=\"cn('group flex flex-1 list-none items-center justify-center gap-1', class)\">\n      <ng-content></ng-content>\n    </ul>\n  `,\n})\nexport class NavigationMenuListComponent  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 `<ul>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected readonly cn = cn;\n}\n\n/** One entry in the list — a plain link, or a trigger plus its content panel. */\n@Component({\n  selector: 'tolle-navigation-menu-item',\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { '[class]': \"'contents'\" },\n  template: `\n    <li [class]=\"cn('relative', class)\">\n      <ng-content></ng-content>\n    </li>\n  `,\n})\nexport class NavigationMenuItemComponent implements OnChanges, OnDestroy {\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  /** Explicit id for the item; one is generated when omitted. */\n  @Input() id = `tolle-navigation-menu-item-${navigationMenuItemCounter++}`;\n  /** Extra Tailwind classes merged onto the `<li>` via `cn()` (last-wins). */\n  @Input() class = '';\n\n  readonly service = inject(NavigationMenuService);\n  protected readonly cn = cn;\n\n  triggerElement: HTMLElement | null = null;\n\n  get triggerId(): string {\n    return `${this.id}-trigger`;\n  }\n\n  get contentId(): string {\n    return `${this.id}-content`;\n  }\n\n  get isOpen(): boolean {\n    return this.service.isOpen(this.id);\n  }\n\n  ngOnDestroy(): void {\n    if (this.isOpen) this.service.closeNow();\n  }\n}\n\n/** Button that reveals its item's panel on hover, focus or click. */\n@Component({\n  selector: 'tolle-navigation-menu-trigger',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      #trigger\n      type=\"button\"\n      [id]=\"item.triggerId\"\n      [disabled]=\"disabled\"\n      aria-haspopup=\"true\"\n      [attr.aria-expanded]=\"isOpen\"\n      [attr.aria-controls]=\"isOpen ? item.contentId : null\"\n      [attr.data-state]=\"isOpen ? 'open' : 'closed'\"\n      [class]=\"computedClass\"\n      (click)=\"onClick()\"\n      (mouseenter)=\"onPointerEnter()\"\n      (mouseleave)=\"onPointerLeave()\"\n      (focus)=\"onPointerEnter()\"\n      (keydown)=\"onKeydown($event)\"\n    >\n      <ng-content></ng-content>\n      <i\n        class=\"ri-arrow-down-s-line text-[16px] transition-transform duration-200\"\n        [class.rotate-180]=\"isOpen\"\n        aria-hidden=\"true\"\n      ></i>\n    </button>\n  `,\n})\nexport class NavigationMenuTriggerComponent 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 panel from opening. @default false */\n  @Input() disabled = false;\n  /** Height/padding scale of the trigger. @default 'default' */\n  @Input() size: NavigationMenuTriggerProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  protected readonly item = inject(NavigationMenuItemComponent);\n  private readonly service = inject(NavigationMenuService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub: Subscription;\n\n  constructor() {\n    this.sub = this.service.openId$.subscribe(() => this.cdr.markForCheck());\n  }\n\n  @ViewChild('trigger') set triggerRef(ref: ElementRef<HTMLButtonElement> | undefined) {\n    this.item.triggerElement = ref?.nativeElement ?? null;\n  }\n\n  protected get isOpen(): boolean {\n    return this.item.isOpen;\n  }\n\n  protected get computedClass(): string {\n    return cn(navigationMenuTriggerVariants({ size: this.size }), this.class);\n  }\n\n  protected onClick(): void {\n    if (this.disabled) return;\n    this.service.toggle(this.item.id);\n  }\n\n  protected onPointerEnter(): void {\n    if (this.disabled) return;\n    this.service.open(this.item.id);\n  }\n\n  protected onPointerLeave(): void {\n    this.service.scheduleClose();\n  }\n\n  protected onKeydown(event: KeyboardEvent): void {\n    if (this.disabled) return;\n    if (event.key === 'ArrowDown' || event.key === 'Enter' || event.key === ' ') {\n      event.preventDefault();\n      this.service.open(this.item.id);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n}\n\n/** The floating panel revealed by a trigger. Rendered only while open. */\n@Component({\n  selector: 'tolle-navigation-menu-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        [id]=\"item.contentId\"\n        [attr.aria-labelledby]=\"item.triggerId\"\n        data-state=\"open\"\n        [class]=\"computedClass\"\n        style=\"position: fixed; top: 0; left: 0;\"\n        (mouseenter)=\"onPointerEnter()\"\n        (mouseleave)=\"onPointerLeave()\"\n      >\n        <ng-content></ng-content>\n      </div>\n    }\n  `,\n})\nexport class NavigationMenuContentComponent 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' */\n  @Input() placement: 'bottom' | 'bottom-start' | 'bottom-end' | 'top' | 'top-start' | 'top-end' =\n    'bottom';\n  /** Gap in pixels between the trigger and the panel. @default 8 */\n  @Input() sideOffset = 8;\n  /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */\n  @Input() class = '';\n\n  protected readonly item = inject(NavigationMenuItemComponent);\n  private readonly service = inject(NavigationMenuService);\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    this.stopPositioning();\n    if (ref?.nativeElement) this.startPositioning(ref.nativeElement);\n  }\n\n  protected get isOpen(): boolean {\n    return this.item.isOpen;\n  }\n\n  protected get computedClass(): string {\n    return cn(\n      'z-[1000] overflow-auto rounded-md border border-border bg-popover p-2 text-popover-foreground',\n      'shadow-lg animate-in fade-in zoom-in-95',\n      this.class\n    );\n  }\n\n  protected onPointerEnter(): void {\n    this.service.cancelClose();\n  }\n\n  protected onPointerLeave(): void {\n    this.service.scheduleClose();\n  }\n\n  private startPositioning(panel: HTMLElement): void {\n    const trigger = this.item.triggerElement;\n    if (!trigger) return;\n    this.cleanup = autoUpdate(trigger, panel, () => {\n      computePosition(trigger, panel, {\n        strategy: 'fixed',\n        placement: this.placement,\n        middleware: [\n          offset(this.sideOffset),\n          flip(),\n          shift({ padding: 8 }),\n          // Wide panels are common here — clamp to what the viewport can show\n          // instead of letting them overflow.\n          size({\n            padding: 8,\n            apply({ elements, availableWidth, availableHeight }) {\n              Object.assign(elements.floating.style, {\n                maxWidth: `${Math.max(0, availableWidth)}px`,\n                maxHeight: `${Math.max(0, availableHeight)}px`,\n              });\n            },\n          }),\n        ],\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 link inside a panel (or directly in the list, for flat entries). */\n@Component({\n  selector: 'tolle-navigation-menu-link',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <a\n      [attr.href]=\"href || null\"\n      [attr.target]=\"target || null\"\n      [attr.rel]=\"target === '_blank' ? 'noreferrer noopener' : null\"\n      [attr.aria-current]=\"active ? 'page' : null\"\n      [attr.data-active]=\"active ? '' : null\"\n      [class]=\"computedClass\"\n      (click)=\"navigate.emit($event)\"\n    >\n      <ng-content select=\"[label]\"></ng-content>\n      <ng-content></ng-content>\n      <ng-content select=\"[description]\"></ng-content>\n    </a>\n  `,\n})\nexport class NavigationMenuLinkComponent  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  /** Destination URL. Omit to render a non-navigating item. */\n  @Input() href = '';\n  /** Anchor target; `_blank` also sets a safe `rel`. */\n  @Input() target = '';\n  /** Marks the link as the current page. @default false */\n  @Input() active = false;\n  /** Visual style of the link. @default 'default' */\n  @Input() variant: NavigationMenuLinkProps['variant'] = 'default';\n  /** Extra Tailwind classes merged onto the anchor via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the click event when the link is activated. */\n  @Output() navigate = new EventEmitter<MouseEvent>();\n\n  protected get computedClass(): string {\n    return cn(\n      navigationMenuLinkVariants({ variant: this.variant, active: this.active }),\n      this.class\n    );\n  }\n}\n"]}