@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/command.component.mjs

@@ -0,0 +1,514 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Subscription } from 'rxjs';
+import { cn } from './utils/cn';
+import { CommandService } from './command.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+let commandItemId = 0;
+/**
+ * A filterable command menu — the list half of a command palette (⌘K),
+ * a searchable dropdown, or an inline action list.
+ *
+ * Compose it from `tolle-command-input`, `tolle-command-list`,
+ * `tolle-command-group`, `tolle-command-item` and `tolle-command-empty`.
+ * Filtering, keyboard navigation and `aria-activedescendant` are handled for
+ * you by the `CommandService` this component provides.
+ *
+ * For the ⌘K modal version use `tolle-command-dialog`; for a form control use
+ * `tolle-combobox`.
+ * @new
+ */
+export class CommandComponent {
+    /**
+     * Set false to keep every item visible and filter the list yourself —
+     * for server-side or fuzzy search. @default true
+     */
+    shouldFilter = true;
+    /** Accessible name for the command menu. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the menu via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the chosen item's `value` when the user selects one. */
+    selected = new EventEmitter();
+    /** Emitted with the query text whenever the search input changes. */
+    queryChange = new EventEmitter();
+    service = inject(CommandService);
+    subscriptions = new Subscription();
+    ngOnInit() {
+        this.service.shouldFilter = this.shouldFilter;
+        this.subscriptions.add(this.service.selected$.subscribe((value) => this.selected.emit(value)));
+        this.subscriptions.add(this.service.query$.subscribe((query) => this.queryChange.emit(query)));
+    }
+    ngOnChanges() {
+        this.service.shouldFilter = this.shouldFilter;
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn('flex w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground', this.class);
+    }
+    /**
+     * Menu-level keyboard handling, so the arrows work whether focus is in the
+     * search input or on the menu itself.
+     */
+    onKeyDown(event) {
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.service.move(1);
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                this.service.move(-1);
+                break;
+            case 'Home':
+                event.preventDefault();
+                this.service.setActive(this.service.visibleIds[0] ?? null);
+                break;
+            case 'End':
+                event.preventDefault();
+                this.service.setActive(this.service.visibleIds[this.service.visibleIds.length - 1] ?? null);
+                break;
+            case 'Enter':
+                event.preventDefault();
+                this.service.selectActive();
+                break;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandComponent, isStandalone: true, selector: "tolle-command", inputs: { shouldFilter: "shouldFilter", ariaLabel: "ariaLabel", class: "class" }, outputs: { selected: "selected", queryChange: "queryChange" }, providers: [CommandService], usesOnChanges: true, ngImport: i0, template: `
+    <div
+      role="combobox"
+      aria-haspopup="listbox"
+      aria-expanded="true"
+      [attr.aria-label]="ariaLabel || null"
+      [class]="computedClass"
+      (keydown)="onKeyDown($event)"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command', standalone: true, imports: [CommonModule], providers: [CommandService], template: `
+    <div
+      role="combobox"
+      aria-haspopup="listbox"
+      aria-expanded="true"
+      [attr.aria-label]="ariaLabel || null"
+      [class]="computedClass"
+      (keydown)="onKeyDown($event)"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { shouldFilter: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], selected: [{
+                type: Output
+            }], queryChange: [{
+                type: Output
+            }] } });
+/** Search box for a `tolle-command`. Typing here drives the filtering. */
+export class CommandInputComponent {
+    /** Placeholder shown when the query is empty. @default 'Type a command or search…' */
+    placeholder = 'Type a command or search…';
+    /** Accessible name for the search box. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the search row via `cn()` (last-wins). */
+    class = '';
+    /** Extra Tailwind classes merged onto the `<input>` itself via `cn()` (last-wins). */
+    inputClass = '';
+    service = inject(CommandService);
+    subscriptions = new Subscription();
+    cdr = inject(ChangeDetectorRef);
+    value = '';
+    activeId = null;
+    cn = cn;
+    ngOnInit() {
+        this.subscriptions.add(this.service.activeId$.subscribe((id) => {
+            this.activeId = id;
+            this.cdr.markForCheck();
+        }));
+        // The dialog clears the query when it reopens; mirror that back into the box.
+        this.subscriptions.add(this.service.query$.subscribe((query) => {
+            if (query !== this.value) {
+                this.value = query;
+                this.cdr.markForCheck();
+            }
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    onInput(event) {
+        const next = event.target.value;
+        this.value = next;
+        this.service.setQuery(next);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandInputComponent, isStandalone: true, selector: "tolle-command-input", inputs: { placeholder: "placeholder", ariaLabel: "ariaLabel", class: "class", inputClass: "inputClass" }, ngImport: i0, template: `
+    <div [class]="cn('flex items-center gap-2 border-b border-border px-3', class)">
+      <i class="ri-search-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+      <input
+        [attr.placeholder]="placeholder"
+        [attr.aria-activedescendant]="activeId"
+        [attr.aria-label]="ariaLabel || placeholder || 'Search'"
+        aria-autocomplete="list"
+        autocomplete="off"
+        spellcheck="false"
+        [value]="value"
+        [class]="cn(
+          'h-11 w-full bg-transparent py-3 text-sm text-foreground outline-none',
+          'placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50',
+          inputClass
+        )"
+        (input)="onInput($event)"
+      />
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-input', standalone: true, imports: [CommonModule], template: `
+    <div [class]="cn('flex items-center gap-2 border-b border-border px-3', class)">
+      <i class="ri-search-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+      <input
+        [attr.placeholder]="placeholder"
+        [attr.aria-activedescendant]="activeId"
+        [attr.aria-label]="ariaLabel || placeholder || 'Search'"
+        aria-autocomplete="list"
+        autocomplete="off"
+        spellcheck="false"
+        [value]="value"
+        [class]="cn(
+          'h-11 w-full bg-transparent py-3 text-sm text-foreground outline-none',
+          'placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50',
+          inputClass
+        )"
+        (input)="onInput($event)"
+      />
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { placeholder: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], inputClass: [{
+                type: Input
+            }] } });
+/** Scrolling container for the command items. */
+export class CommandListComponent {
+    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();
+    }
+    /** Accessible name for the list. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the list via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandListComponent, isStandalone: true, selector: "tolle-command-list", inputs: { ariaLabel: "ariaLabel", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div role="listbox" [attr.aria-label]="ariaLabel || null" [class]="cn('max-h-80 overflow-y-auto overflow-x-hidden p-1', class)">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-list', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div role="listbox" [attr.aria-label]="ariaLabel || null" [class]="cn('max-h-80 overflow-y-auto overflow-x-hidden p-1', class)">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/**
+ * Shown only when the query matches nothing. Renders nothing otherwise, so it
+ * can live in the template permanently.
+ */
+export class CommandEmptyComponent {
+    /** Extra Tailwind classes merged onto the empty state via `cn()` (last-wins). */
+    class = '';
+    service = inject(CommandService);
+    subscriptions = new Subscription();
+    cdr = inject(ChangeDetectorRef);
+    isEmpty = false;
+    cn = cn;
+    ngOnInit() {
+        this.subscriptions.add(this.service.visible$.subscribe(() => {
+            this.isEmpty = this.service.isEmpty;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandEmptyComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandEmptyComponent, isStandalone: true, selector: "tolle-command-empty", inputs: { class: "class" }, ngImport: i0, template: `
+    <div *ngIf="isEmpty" role="status" [class]="cn('py-6 text-center text-sm text-muted-foreground', class)">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandEmptyComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-empty', standalone: true, imports: [CommonModule], template: `
+    <div *ngIf="isEmpty" role="status" [class]="cn('py-6 text-center text-sm text-muted-foreground', class)">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/**
+ * A labelled section of items. The heading hides itself when filtering removes
+ * every item in the group, so you never get a stranded header.
+ */
+export class CommandGroupComponent {
+    /** Section heading. @default '' */
+    heading = '';
+    /** Extra Tailwind classes merged onto the group via `cn()` (last-wins). */
+    class = '';
+    service = inject(CommandService);
+    subscriptions = new Subscription();
+    cdr = inject(ChangeDetectorRef);
+    memberIds = new Set();
+    hidden = false;
+    cn = cn;
+    ngOnInit() {
+        this.subscriptions.add(this.service.visible$.subscribe((visible) => {
+            // Hide the heading once none of this group's items survive the filter.
+            this.hidden = this.memberIds.size > 0 && !visible.some((id) => this.memberIds.has(id));
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** Called by child items so the group knows which ids belong to it. */
+    addMember(id) {
+        this.memberIds.add(id);
+    }
+    removeMember(id) {
+        this.memberIds.delete(id);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandGroupComponent, isStandalone: true, selector: "tolle-command-group", inputs: { heading: "heading", class: "class" }, ngImport: i0, template: `
+    <div role="group" [attr.aria-label]="heading || null" [class]="cn('overflow-hidden p-1 text-foreground', class)">
+      <div
+        *ngIf="heading"
+        [class]="cn('px-2 py-1.5 text-xs font-medium text-muted-foreground', hidden && 'hidden')"
+      >
+        {{ heading }}
+      </div>
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-group', standalone: true, imports: [CommonModule], template: `
+    <div role="group" [attr.aria-label]="heading || null" [class]="cn('overflow-hidden p-1 text-foreground', class)">
+      <div
+        *ngIf="heading"
+        [class]="cn('px-2 py-1.5 text-xs font-medium text-muted-foreground', hidden && 'hidden')"
+      >
+        {{ heading }}
+      </div>
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { heading: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** A selectable row in a command menu. */
+export class CommandItemComponent {
+    /** Value emitted from the menu's `selected` output when this row is chosen. */
+    value = null;
+    /**
+     * Text matched against the query. Defaults to `value` when omitted — set it
+     * explicitly whenever the row's visible text differs from its value.
+     * @default ''
+     */
+    label = '';
+    /** Extra terms that should also match this row, e.g. synonyms. @default [] */
+    keywords = [];
+    /** Makes the row unselectable and skipped by the arrow keys. @default false */
+    disabled = false;
+    /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when this specific row is chosen. */
+    selected = new EventEmitter();
+    service = inject(CommandService);
+    group = inject(CommandGroupComponent, { optional: true });
+    subscriptions = new Subscription();
+    cdr = inject(ChangeDetectorRef);
+    id = `command-item-${commandItemId++}`;
+    visible = true;
+    active = false;
+    ngOnInit() {
+        this.service.register({
+            id: this.id,
+            searchText: this.searchText,
+            value: this.value,
+            disabled: this.disabled,
+        });
+        this.group?.addMember(this.id);
+        this.subscriptions.add(this.service.visible$.subscribe((ids) => {
+            this.visible = ids.includes(this.id);
+            this.cdr.markForCheck();
+        }));
+        this.subscriptions.add(this.service.activeId$.subscribe((activeId) => {
+            this.active = activeId === this.id;
+            this.cdr.markForCheck();
+        }));
+        this.subscriptions.add(this.service.selected$.subscribe((value) => {
+            if (value === this.value)
+                this.selected.emit(value);
+        }));
+    }
+    ngOnChanges() {
+        this.service.update(this.id, {
+            searchText: this.searchText,
+            value: this.value,
+            disabled: this.disabled,
+        });
+    }
+    ngOnDestroy() {
+        this.group?.removeMember(this.id);
+        this.service.unregister(this.id);
+        this.subscriptions.unsubscribe();
+    }
+    /** Label plus keywords, so synonyms match without being displayed. */
+    get searchText() {
+        const base = this.label || (this.value != null ? String(this.value) : '');
+        return [base, ...this.keywords].join(' ');
+    }
+    get computedClass() {
+        return cn('relative flex cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors', this.active && !this.disabled && 'bg-accent text-accent-foreground', this.disabled && 'pointer-events-none opacity-50', this.class);
+    }
+    onClick() {
+        if (this.disabled)
+            return;
+        this.service.selectById(this.id);
+    }
+    onMouseEnter() {
+        if (this.disabled)
+            return;
+        this.service.setActive(this.id);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandItemComponent, isStandalone: true, selector: "tolle-command-item", inputs: { value: "value", label: "label", keywords: "keywords", disabled: "disabled", class: "class" }, outputs: { selected: "selected" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      *ngIf="visible"
+      [id]="id"
+      role="option"
+      [attr.aria-selected]="active"
+      [attr.aria-disabled]="disabled || null"
+      [attr.data-active]="active ? '' : null"
+      [class]="computedClass"
+      (click)="onClick()"
+      (mouseenter)="onMouseEnter()"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-item', standalone: true, imports: [CommonModule], template: `
+    <div
+      *ngIf="visible"
+      [id]="id"
+      role="option"
+      [attr.aria-selected]="active"
+      [attr.aria-disabled]="disabled || null"
+      [attr.data-active]="active ? '' : null"
+      [class]="computedClass"
+      (click)="onClick()"
+      (mouseenter)="onMouseEnter()"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], keywords: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], selected: [{
+                type: Output
+            }] } });
+/** Divider between command groups. */
+export class CommandSeparatorComponent {
+    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: CommandSeparatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandSeparatorComponent, isStandalone: true, selector: "tolle-command-separator", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div role="separator" [class]="cn('-mx-1 h-px bg-border', class)"></div>`, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandSeparatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-separator', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div role="separator" [class]="cn('-mx-1 h-px bg-border', class)"></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Right-aligned shortcut hint inside a command item. Pairs with `tolle-kbd`. */
+export class CommandShortcutComponent {
+    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 shortcut via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandShortcutComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CommandShortcutComponent, isStandalone: true, selector: "tolle-command-shortcut", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<span [class]="cn('ml-auto flex items-center gap-1 text-xs tracking-widest text-muted-foreground', class)"><ng-content></ng-content></span>`, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandShortcutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-command-shortcut', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<span [class]="cn('ml-auto flex items-center gap-1 text-xs tracking-widest text-muted-foreground', class)"><ng-content></ng-content></span>`, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/command.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,uBAAuB,EAAE,iBAAiB,EAAgC,MAAM,EAAE,MAAM,eAAe,CAAC;AACzJ,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;;;AAEnD,IAAI,aAAa,GAAG,CAAC,CAAC;AAEtB;;;;;;;;;;;;GAYG;AAoBH,MAAM,OAAO,gBAAgB;IAC3B;;;OAGG;IACM,YAAY,GAAG,IAAI,CAAC;IAC7B,wDAAwD;IAC/C,SAAS,GAAG,EAAE,CAAC;IACxB,0EAA0E;IACjE,KAAK,GAAG,EAAE,CAAC;IAEpB,wEAAwE;IAC9D,QAAQ,GAAG,IAAI,YAAY,EAAO,CAAC;IAC7C,qEAAqE;IAC3D,WAAW,GAAG,IAAI,YAAY,EAAU,CAAC;IAElC,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IACjC,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IAEpD,QAAQ;QACN,IAAI,CAAC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QAC9C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/F,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACjG,CAAC;IAED,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;IAChD,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,IAAI,aAAa;QACf,OAAO,EAAE,CAAC,oFAAoF,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9G,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,KAAoB;QAC5B,QAAQ,KAAK,CAAC,GAAG,EAAE,CAAC;YAClB,KAAK,WAAW;gBACd,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACrB,MAAM;YACR,KAAK,SAAS;gBACZ,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtB,MAAM;YACR,KAAK,MAAM;gBACT,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;gBAC3D,MAAM;YACR,KAAK,KAAK;gBACR,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;gBAC5F,MAAM;YACR,KAAK,OAAO;gBACV,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;gBAC5B,MAAM;QACV,CAAC;IACH,CAAC;wGAhEU,gBAAgB;4FAAhB,gBAAgB,6MAdhB,CAAC,cAAc,CAAC,+CACjB;;;;;;;;;;;GAWT,+FAbS,YAAY;;4FAeX,gBAAgB;kBAnB5B,SAAS;+BACE,eAAe,cAEb,IAAI,WACP,CAAC,YAAY,CAAC,aACZ,CAAC,cAAc,CAAC,YACjB;;;;;;;;;;;GAWT;8BAOQ,YAAY;sBAApB,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAEG,KAAK;sBAAb,KAAK;gBAGI,QAAQ;sBAAjB,MAAM;gBAEG,WAAW;sBAApB,MAAM;;AAqDT,0EAA0E;AA2B1E,MAAM,OAAO,qBAAqB;IAChC,sFAAsF;IAC7E,WAAW,GAAG,2BAA2B,CAAC;IACnD,sDAAsD;IAC7C,SAAS,GAAG,EAAE,CAAC;IACxB,gFAAgF;IACvE,KAAK,GAAG,EAAE,CAAC;IACpB,sFAAsF;IAC7E,UAAU,GAAG,EAAE,CAAC;IAER,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IACjC,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IACnC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEjD,KAAK,GAAG,EAAE,CAAC;IACX,QAAQ,GAAkB,IAAI,CAAC;IACrB,EAAE,GAAG,EAAE,CAAC;IAElB,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE;YACtC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC,CACH,CAAC;QACF,8EAA8E;QAC9E,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACtC,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;gBACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;gBACnB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;YAC1B,CAAC;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,OAAO,CAAC,KAAY;QAClB,MAAM,IAAI,GAAI,KAAK,CAAC,MAA2B,CAAC,KAAK,CAAC;QACtD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;wGA5CU,qBAAqB;4FAArB,qBAAqB,yLArBtB;;;;;;;;;;;;;;;;;;;GAmBT,+FApBS,YAAY;;4FAsBX,qBAAqB;kBA1BjC,SAAS;+BACE,qBAAqB,cAEnB,IAAI,WACP,CAAC,YAAY,CAAC,YACb;;;;;;;;;;;;;;;;;;;GAmBT;8BAIQ,WAAW;sBAAnB,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAEG,KAAK;sBAAb,KAAK;gBAEG,UAAU;sBAAlB,KAAK;;AAuCR,iDAAiD;AAajD,MAAM,OAAO,oBAAoB;IACd,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEjD;;;;OAIG;IACH,WAAW;QACT,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC1B,CAAC;IAED,gDAAgD;IACvC,SAAS,GAAG,EAAE,CAAC;IACxB,0EAA0E;IACjE,KAAK,GAAG,EAAE,CAAC;IACV,EAAE,GAAG,EAAE,CAAC;wGAhBP,oBAAoB;4FAApB,oBAAoB,uJANrB;;;;GAIT,+FANS,YAAY;;4FAQX,oBAAoB;kBAZhC,SAAS;+BACE,oBAAoB,cAElB,IAAI,WACP,CAAC,YAAY,CAAC,mBACN,uBAAuB,CAAC,MAAM,YACrC;;;;GAIT;8BAeQ,SAAS;sBAAjB,KAAK;gBAEG,KAAK;sBAAb,KAAK;;AAIR;;;GAGG;AAYH,MAAM,OAAO,qBAAqB;IAChC,iFAAiF;IACxE,KAAK,GAAG,EAAE,CAAC;IAEH,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IACjC,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IACnC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEjD,OAAO,GAAG,KAAK,CAAC;IACN,EAAE,GAAG,EAAE,CAAC;IAElB,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,EAAE;YACnC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;YACpC,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;wGAtBU,qBAAqB;4FAArB,qBAAqB,2GANtB;;;;GAIT,+FALS,YAAY;;4FAOX,qBAAqB;kBAXjC,SAAS;+BACE,qBAAqB,cAEnB,IAAI,WACP,CAAC,YAAY,CAAC,YACb;;;;GAIT;8BAIQ,KAAK;sBAAb,KAAK;;AAuBR;;;GAGG;AAkBH,MAAM,OAAO,qBAAqB;IAChC,mCAAmC;IAC1B,OAAO,GAAG,EAAE,CAAC;IACtB,2EAA2E;IAClE,KAAK,GAAG,EAAE,CAAC;IAEH,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IACjC,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IACnC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAChC,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IAE/C,MAAM,GAAG,KAAK,CAAC;IACL,EAAE,GAAG,EAAE,CAAC;IAElB,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YAC1C,uEAAuE;YACvE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;YACvF,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,uEAAuE;IACvE,SAAS,CAAC,EAAU;QAClB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACzB,CAAC;IAED,YAAY,CAAC,EAAU;QACrB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;wGAnCU,qBAAqB;4FAArB,qBAAqB,+HAZtB;;;;;;;;;;GAUT,+FAXS,YAAY;;4FAaX,qBAAqB;kBAjBjC,SAAS;+BACE,qBAAqB,cAEnB,IAAI,WACP,CAAC,YAAY,CAAC,YACb;;;;;;;;;;GAUT;8BAIQ,OAAO;sBAAf,KAAK;gBAEG,KAAK;sBAAb,KAAK;;AAkCR,0CAA0C;AAsB1C,MAAM,OAAO,oBAAoB;IAC/B,+EAA+E;IACtE,KAAK,GAAQ,IAAI,CAAC;IAC3B;;;;OAIG;IACM,KAAK,GAAG,EAAE,CAAC;IACpB,8EAA8E;IACrE,QAAQ,GAAa,EAAE,CAAC;IACjC,+EAA+E;IACtE,QAAQ,GAAG,KAAK,CAAC;IAC1B,yEAAyE;IAChE,KAAK,GAAG,EAAE,CAAC;IAEpB,gDAAgD;IACtC,QAAQ,GAAG,IAAI,YAAY,EAAO,CAAC;IAE5B,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IACjC,KAAK,GAAG,MAAM,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IACnC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAExC,EAAE,GAAG,gBAAgB,aAAa,EAAE,EAAE,CAAC;IAChD,OAAO,GAAG,IAAI,CAAC;IACf,MAAM,GAAG,KAAK,CAAC;IAEf,QAAQ;QACN,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;YACpB,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAE/B,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;YACtC,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC,CACH,CAAC;QACF,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC5C,IAAI,CAAC,MAAM,GAAG,QAAQ,KAAK,IAAI,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC,CACH,CAAC;QACF,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACzC,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK;gBAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtD,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,sEAAsE;IACtE,IAAY,UAAU;QACpB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1E,OAAO,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,aAAa;QACf,OAAO,EAAE,CACP,2HAA2H,EAC3H,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,kCAAkC,EACnE,IAAI,CAAC,QAAQ,IAAI,gCAAgC,EACjD,IAAI,CAAC,KAAK,CACX,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,YAAY;QACV,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClC,CAAC;wGA7FU,oBAAoB;4FAApB,oBAAoB,8OAhBrB;;;;;;;;;;;;;;GAcT,+FAfS,YAAY;;4FAiBX,oBAAoB;kBArBhC,SAAS;+BACE,oBAAoB,cAElB,IAAI,WACP,CAAC,YAAY,CAAC,YACb;;;;;;;;;;;;;;GAcT;8BAIQ,KAAK;sBAAb,KAAK;gBAMG,KAAK;sBAAb,KAAK;gBAEG,QAAQ;sBAAhB,KAAK;gBAEG,QAAQ;sBAAhB,KAAK;gBAEG,KAAK;sBAAb,KAAK;gBAGI,QAAQ;sBAAjB,MAAM;;AA+ET,sCAAsC;AAStC,MAAM,OAAO,yBAAyB;IACnB,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEjD;;;;OAIG;IACH,WAAW;QACT,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC1B,CAAC;IAED,+EAA+E;IACtE,KAAK,GAAG,EAAE,CAAC;IACV,EAAE,GAAG,EAAE,CAAC;wGAdP,yBAAyB;4FAAzB,yBAAyB,oIAF1B,0EAA0E,+FAF1E,YAAY;;4FAIX,yBAAyB;kBARrC,SAAS;+BACE,yBAAyB,cAEvB,IAAI,WACP,CAAC,YAAY,CAAC,mBACN,uBAAuB,CAAC,MAAM,YACrC,0EAA0E;8BAe3E,KAAK;sBAAb,KAAK;;AAIR,iFAAiF;AASjF,MAAM,OAAO,wBAAwB;IAClB,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAEjD;;;;OAIG;IACH,WAAW;QACT,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC1B,CAAC;IAED,8EAA8E;IACrE,KAAK,GAAG,EAAE,CAAC;IACV,EAAE,GAAG,EAAE,CAAC;wGAdP,wBAAwB;4FAAxB,wBAAwB,mIAFzB,6IAA6I,qGAF7I,YAAY;;4FAIX,wBAAwB;kBARpC,SAAS;+BACE,wBAAwB,cAEtB,IAAI,WACP,CAAC,YAAY,CAAC,mBACN,uBAAuB,CAAC,MAAM,YACrC,6IAA6I;8BAe9I,KAAK;sBAAb,KAAK","sourcesContent":["import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, OnInit, OnChanges, OnDestroy, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { Subscription } from 'rxjs';\nimport { cn } from './utils/cn';\nimport { CommandService } from './command.service';\n\nlet commandItemId = 0;\n\n/**\n * A filterable command menu — the list half of a command palette (⌘K),\n * a searchable dropdown, or an inline action list.\n *\n * Compose it from `tolle-command-input`, `tolle-command-list`,\n * `tolle-command-group`, `tolle-command-item` and `tolle-command-empty`.\n * Filtering, keyboard navigation and `aria-activedescendant` are handled for\n * you by the `CommandService` this component provides.\n *\n * For the ⌘K modal version use `tolle-command-dialog`; for a form control use\n * `tolle-combobox`.\n * @new\n */\n@Component({\n  selector: 'tolle-command',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [CommandService],\n  template: `\n    <div\n      role=\"combobox\"\n      aria-haspopup=\"listbox\"\n      aria-expanded=\"true\"\n      [attr.aria-label]=\"ariaLabel || null\"\n      [class]=\"computedClass\"\n      (keydown)=\"onKeyDown($event)\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class CommandComponent implements OnInit, OnChanges, OnDestroy {\n  /**\n   * Set false to keep every item visible and filter the list yourself —\n   * for server-side or fuzzy search. @default true\n   */\n  @Input() shouldFilter = true;\n  /** Accessible name for the command menu. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the menu via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the chosen item's `value` when the user selects one. */\n  @Output() selected = new EventEmitter<any>();\n  /** Emitted with the query text whenever the search input changes. */\n  @Output() queryChange = new EventEmitter<string>();\n\n  private readonly service = inject(CommandService);\n  private readonly subscriptions = new Subscription();\n\n  ngOnInit(): void {\n    this.service.shouldFilter = this.shouldFilter;\n    this.subscriptions.add(this.service.selected$.subscribe((value) => this.selected.emit(value)));\n    this.subscriptions.add(this.service.query$.subscribe((query) => this.queryChange.emit(query)));\n  }\n\n  ngOnChanges(): void {\n    this.service.shouldFilter = this.shouldFilter;\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn('flex w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground', this.class);\n  }\n\n  /**\n   * Menu-level keyboard handling, so the arrows work whether focus is in the\n   * search input or on the menu itself.\n   */\n  onKeyDown(event: KeyboardEvent): void {\n    switch (event.key) {\n      case 'ArrowDown':\n        event.preventDefault();\n        this.service.move(1);\n        break;\n      case 'ArrowUp':\n        event.preventDefault();\n        this.service.move(-1);\n        break;\n      case 'Home':\n        event.preventDefault();\n        this.service.setActive(this.service.visibleIds[0] ?? null);\n        break;\n      case 'End':\n        event.preventDefault();\n        this.service.setActive(this.service.visibleIds[this.service.visibleIds.length - 1] ?? null);\n        break;\n      case 'Enter':\n        event.preventDefault();\n        this.service.selectActive();\n        break;\n    }\n  }\n}\n\n/** Search box for a `tolle-command`. Typing here drives the filtering. */\n@Component({\n  selector: 'tolle-command-input',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div [class]=\"cn('flex items-center gap-2 border-b border-border px-3', class)\">\n      <i class=\"ri-search-line shrink-0 text-muted-foreground\" aria-hidden=\"true\"></i>\n      <input\n        [attr.placeholder]=\"placeholder\"\n        [attr.aria-activedescendant]=\"activeId\"\n        [attr.aria-label]=\"ariaLabel || placeholder || 'Search'\"\n        aria-autocomplete=\"list\"\n        autocomplete=\"off\"\n        spellcheck=\"false\"\n        [value]=\"value\"\n        [class]=\"cn(\n          'h-11 w-full bg-transparent py-3 text-sm text-foreground outline-none',\n          'placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50',\n          inputClass\n        )\"\n        (input)=\"onInput($event)\"\n      />\n    </div>\n  `,\n})\nexport class CommandInputComponent implements OnInit, OnDestroy {\n  /** Placeholder shown when the query is empty. @default 'Type a command or search…' */\n  @Input() placeholder = 'Type a command or search…';\n  /** Accessible name for the search box. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the search row via `cn()` (last-wins). */\n  @Input() class = '';\n  /** Extra Tailwind classes merged onto the `<input>` itself via `cn()` (last-wins). */\n  @Input() inputClass = '';\n\n  private readonly service = inject(CommandService);\n  private readonly subscriptions = new Subscription();\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  value = '';\n  activeId: string | null = null;\n  protected cn = cn;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.activeId$.subscribe((id) => {\n        this.activeId = id;\n        this.cdr.markForCheck();\n      })\n    );\n    // The dialog clears the query when it reopens; mirror that back into the box.\n    this.subscriptions.add(\n      this.service.query$.subscribe((query) => {\n        if (query !== this.value) {\n          this.value = query;\n          this.cdr.markForCheck();\n        }\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  onInput(event: Event): void {\n    const next = (event.target as HTMLInputElement).value;\n    this.value = next;\n    this.service.setQuery(next);\n  }\n}\n\n/** Scrolling container for the command items. */\n@Component({\n  selector: 'tolle-command-list',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div role=\"listbox\" [attr.aria-label]=\"ariaLabel || null\" [class]=\"cn('max-h-80 overflow-y-auto overflow-x-hidden p-1', class)\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class CommandListComponent  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  /** Accessible name for the list. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the list via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/**\n * Shown only when the query matches nothing. Renders nothing otherwise, so it\n * can live in the template permanently.\n */\n@Component({\n  selector: 'tolle-command-empty',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div *ngIf=\"isEmpty\" role=\"status\" [class]=\"cn('py-6 text-center text-sm text-muted-foreground', class)\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class CommandEmptyComponent implements OnInit, OnDestroy {\n  /** Extra Tailwind classes merged onto the empty state via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(CommandService);\n  private readonly subscriptions = new Subscription();\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  isEmpty = false;\n  protected cn = cn;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.visible$.subscribe(() => {\n        this.isEmpty = this.service.isEmpty;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n}\n\n/**\n * A labelled section of items. The heading hides itself when filtering removes\n * every item in the group, so you never get a stranded header.\n */\n@Component({\n  selector: 'tolle-command-group',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div role=\"group\" [attr.aria-label]=\"heading || null\" [class]=\"cn('overflow-hidden p-1 text-foreground', class)\">\n      <div\n        *ngIf=\"heading\"\n        [class]=\"cn('px-2 py-1.5 text-xs font-medium text-muted-foreground', hidden && 'hidden')\"\n      >\n        {{ heading }}\n      </div>\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class CommandGroupComponent implements OnInit, OnDestroy {\n  /** Section heading. @default '' */\n  @Input() heading = '';\n  /** Extra Tailwind classes merged onto the group via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(CommandService);\n  private readonly subscriptions = new Subscription();\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly memberIds = new Set<string>();\n\n  hidden = false;\n  protected cn = cn;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.visible$.subscribe((visible) => {\n        // Hide the heading once none of this group's items survive the filter.\n        this.hidden = this.memberIds.size > 0 && !visible.some((id) => this.memberIds.has(id));\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** Called by child items so the group knows which ids belong to it. */\n  addMember(id: string): void {\n    this.memberIds.add(id);\n  }\n\n  removeMember(id: string): void {\n    this.memberIds.delete(id);\n  }\n}\n\n/** A selectable row in a command menu. */\n@Component({\n  selector: 'tolle-command-item',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      *ngIf=\"visible\"\n      [id]=\"id\"\n      role=\"option\"\n      [attr.aria-selected]=\"active\"\n      [attr.aria-disabled]=\"disabled || null\"\n      [attr.data-active]=\"active ? '' : null\"\n      [class]=\"computedClass\"\n      (click)=\"onClick()\"\n      (mouseenter)=\"onMouseEnter()\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class CommandItemComponent implements OnInit, OnChanges, OnDestroy {\n  /** Value emitted from the menu's `selected` output when this row is chosen. */\n  @Input() value: any = null;\n  /**\n   * Text matched against the query. Defaults to `value` when omitted — set it\n   * explicitly whenever the row's visible text differs from its value.\n   * @default ''\n   */\n  @Input() label = '';\n  /** Extra terms that should also match this row, e.g. synonyms. @default [] */\n  @Input() keywords: string[] = [];\n  /** Makes the row unselectable and skipped by the arrow keys. @default false */\n  @Input() disabled = false;\n  /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when this specific row is chosen. */\n  @Output() selected = new EventEmitter<any>();\n\n  private readonly service = inject(CommandService);\n  private readonly group = inject(CommandGroupComponent, { optional: true });\n  private readonly subscriptions = new Subscription();\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  readonly id = `command-item-${commandItemId++}`;\n  visible = true;\n  active = false;\n\n  ngOnInit(): void {\n    this.service.register({\n      id: this.id,\n      searchText: this.searchText,\n      value: this.value,\n      disabled: this.disabled,\n    });\n    this.group?.addMember(this.id);\n\n    this.subscriptions.add(\n      this.service.visible$.subscribe((ids) => {\n        this.visible = ids.includes(this.id);\n        this.cdr.markForCheck();\n      })\n    );\n    this.subscriptions.add(\n      this.service.activeId$.subscribe((activeId) => {\n        this.active = activeId === this.id;\n        this.cdr.markForCheck();\n      })\n    );\n    this.subscriptions.add(\n      this.service.selected$.subscribe((value) => {\n        if (value === this.value) this.selected.emit(value);\n      })\n    );\n  }\n\n  ngOnChanges(): void {\n    this.service.update(this.id, {\n      searchText: this.searchText,\n      value: this.value,\n      disabled: this.disabled,\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.group?.removeMember(this.id);\n    this.service.unregister(this.id);\n    this.subscriptions.unsubscribe();\n  }\n\n  /** Label plus keywords, so synonyms match without being displayed. */\n  private get searchText(): string {\n    const base = this.label || (this.value != null ? String(this.value) : '');\n    return [base, ...this.keywords].join(' ');\n  }\n\n  get computedClass() {\n    return cn(\n      'relative flex cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors',\n      this.active && !this.disabled && 'bg-accent text-accent-foreground',\n      this.disabled && 'pointer-events-none opacity-50',\n      this.class\n    );\n  }\n\n  onClick(): void {\n    if (this.disabled) return;\n    this.service.selectById(this.id);\n  }\n\n  onMouseEnter(): void {\n    if (this.disabled) return;\n    this.service.setActive(this.id);\n  }\n}\n\n/** Divider between command groups. */\n@Component({\n  selector: 'tolle-command-separator',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div role=\"separator\" [class]=\"cn('-mx-1 h-px bg-border', class)\"></div>`,\n})\nexport class CommandSeparatorComponent  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 cn = cn;\n}\n\n/** Right-aligned shortcut hint inside a command item. Pairs with `tolle-kbd`. */\n@Component({\n  selector: 'tolle-command-shortcut',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<span [class]=\"cn('ml-auto flex items-center gap-1 text-xs tracking-widest text-muted-foreground', class)\"><ng-content></ng-content></span>`,\n})\nexport class CommandShortcutComponent  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 shortcut via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n"]}