@tolle_/tolle-ui 18.2.28 → 18.2.30

package/esm2022/lib/command.service.mjs

@@ -0,0 +1,130 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Coordinates a `tolle-command` and its descendants: owns the query, decides
+ * which items survive filtering, and tracks the active (highlighted) item for
+ * `aria-activedescendant`.
+ *
+ * Provided on `CommandComponent`, so each command menu gets its own instance.
+ */
+export class CommandService {
+    items = new Map();
+    nextOrder = 0;
+    querySubject = new BehaviorSubject('');
+    /** Current search query. */
+    query$ = this.querySubject.asObservable();
+    visibleSubject = new BehaviorSubject([]);
+    /** Ids of the items surviving the current query, in DOM order. */
+    visible$ = this.visibleSubject.asObservable();
+    activeIdSubject = new BehaviorSubject(null);
+    /** Id of the highlighted item, or null when nothing matches. */
+    activeId$ = this.activeIdSubject.asObservable();
+    selectedSubject = new Subject();
+    /** Emits the value of the item the user chose. */
+    selected$ = this.selectedSubject.asObservable();
+    /**
+     * When set, filtering is left entirely to the consumer — every registered
+     * item stays visible regardless of the query. Use for server-side search.
+     */
+    shouldFilter = true;
+    get query() {
+        return this.querySubject.value;
+    }
+    get visibleIds() {
+        return this.visibleSubject.value;
+    }
+    get activeId() {
+        return this.activeIdSubject.value;
+    }
+    /**
+     * True when there is nothing to show.
+     *
+     * With built-in filtering that means items exist but the query excluded them
+     * all. With `shouldFilter = false` the consumer renders the result set itself,
+     * so "no items registered" IS the empty result — requiring items to exist
+     * would make `tolle-command-empty` permanently invisible in that mode.
+     */
+    get isEmpty() {
+        if (!this.shouldFilter)
+            return this.items.size === 0;
+        return this.items.size > 0 && this.visibleSubject.value.length === 0;
+    }
+    register(item) {
+        this.items.set(item.id, { ...item, order: this.nextOrder++ });
+        this.recompute();
+    }
+    /** Keeps the stored search text/value in sync when an item's inputs change. */
+    update(id, patch) {
+        const existing = this.items.get(id);
+        if (!existing)
+            return;
+        this.items.set(id, { ...existing, ...patch });
+        this.recompute();
+    }
+    unregister(id) {
+        this.items.delete(id);
+        this.recompute();
+    }
+    setQuery(query) {
+        this.querySubject.next(query);
+        this.recompute();
+    }
+    isVisible(id) {
+        return this.visibleSubject.value.includes(id);
+    }
+    /** Moves the highlight by `delta` positions, wrapping at both ends. */
+    move(delta) {
+        const ids = this.visibleSubject.value;
+        if (!ids.length)
+            return;
+        const current = ids.indexOf(this.activeIdSubject.value ?? '');
+        // From "nothing active", ArrowUp should land on the last item, not the second.
+        const start = current < 0 ? (delta > 0 ? -1 : 0) : current;
+        const next = (start + delta + ids.length) % ids.length;
+        this.activeIdSubject.next(ids[next]);
+    }
+    setActive(id) {
+        if (id !== null && !this.isVisible(id))
+            return;
+        this.activeIdSubject.next(id);
+    }
+    /** Selects the highlighted item, if there is one. */
+    selectActive() {
+        const id = this.activeIdSubject.value;
+        if (!id)
+            return;
+        const item = this.items.get(id);
+        if (!item || item.disabled)
+            return;
+        this.selectedSubject.next(item.value);
+    }
+    selectById(id) {
+        const item = this.items.get(id);
+        if (!item || item.disabled)
+            return;
+        this.selectedSubject.next(item.value);
+    }
+    /** Recomputes the visible set and keeps the highlight on something valid. */
+    recompute() {
+        const q = this.querySubject.value.trim().toLowerCase();
+        const visible = [...this.items.values()]
+            .filter((item) => !this.shouldFilter || !q || item.searchText.toLowerCase().includes(q))
+            .sort((a, b) => a.order - b.order)
+            .map((item) => item.id);
+        this.visibleSubject.next(visible);
+        // If the highlight fell out of the visible set (or there was none), move it
+        // to the first selectable item so Enter always has a sensible target.
+        const active = this.activeIdSubject.value;
+        if (!active || !visible.includes(active)) {
+            const firstEnabled = visible.find((id) => !this.items.get(id)?.disabled) ?? null;
+            this.activeIdSubject.next(firstEnabled);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommandService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command.service.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/command.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Subject } from 'rxjs';\n\n/** One registered `tolle-command-item`, as seen by the service. */\nexport interface CommandItemState {\n  id: string;\n  /** Text the query is matched against — the item's label plus any `keywords`. */\n  searchText: string;\n  value: any;\n  disabled: boolean;\n  /** Registration order, used to keep the visible list in DOM order. */\n  order: number;\n}\n\n/**\n * Coordinates a `tolle-command` and its descendants: owns the query, decides\n * which items survive filtering, and tracks the active (highlighted) item for\n * `aria-activedescendant`.\n *\n * Provided on `CommandComponent`, so each command menu gets its own instance.\n */\n@Injectable()\nexport class CommandService {\n  private readonly items = new Map<string, CommandItemState>();\n  private nextOrder = 0;\n\n  private readonly querySubject = new BehaviorSubject<string>('');\n  /** Current search query. */\n  readonly query$ = this.querySubject.asObservable();\n\n  private readonly visibleSubject = new BehaviorSubject<string[]>([]);\n  /** Ids of the items surviving the current query, in DOM order. */\n  readonly visible$ = this.visibleSubject.asObservable();\n\n  private readonly activeIdSubject = new BehaviorSubject<string | null>(null);\n  /** Id of the highlighted item, or null when nothing matches. */\n  readonly activeId$ = this.activeIdSubject.asObservable();\n\n  private readonly selectedSubject = new Subject<any>();\n  /** Emits the value of the item the user chose. */\n  readonly selected$ = this.selectedSubject.asObservable();\n\n  /**\n   * When set, filtering is left entirely to the consumer — every registered\n   * item stays visible regardless of the query. Use for server-side search.\n   */\n  shouldFilter = true;\n\n  get query(): string {\n    return this.querySubject.value;\n  }\n\n  get visibleIds(): string[] {\n    return this.visibleSubject.value;\n  }\n\n  get activeId(): string | null {\n    return this.activeIdSubject.value;\n  }\n\n  /**\n   * True when there is nothing to show.\n   *\n   * With built-in filtering that means items exist but the query excluded them\n   * all. With `shouldFilter = false` the consumer renders the result set itself,\n   * so \"no items registered\" IS the empty result — requiring items to exist\n   * would make `tolle-command-empty` permanently invisible in that mode.\n   */\n  get isEmpty(): boolean {\n    if (!this.shouldFilter) return this.items.size === 0;\n    return this.items.size > 0 && this.visibleSubject.value.length === 0;\n  }\n\n  register(item: Omit<CommandItemState, 'order'>): void {\n    this.items.set(item.id, { ...item, order: this.nextOrder++ });\n    this.recompute();\n  }\n\n  /** Keeps the stored search text/value in sync when an item's inputs change. */\n  update(id: string, patch: Partial<Omit<CommandItemState, 'id' | 'order'>>): void {\n    const existing = this.items.get(id);\n    if (!existing) return;\n    this.items.set(id, { ...existing, ...patch });\n    this.recompute();\n  }\n\n  unregister(id: string): void {\n    this.items.delete(id);\n    this.recompute();\n  }\n\n  setQuery(query: string): void {\n    this.querySubject.next(query);\n    this.recompute();\n  }\n\n  isVisible(id: string): boolean {\n    return this.visibleSubject.value.includes(id);\n  }\n\n  /** Moves the highlight by `delta` positions, wrapping at both ends. */\n  move(delta: number): void {\n    const ids = this.visibleSubject.value;\n    if (!ids.length) return;\n    const current = ids.indexOf(this.activeIdSubject.value ?? '');\n    // From \"nothing active\", ArrowUp should land on the last item, not the second.\n    const start = current < 0 ? (delta > 0 ? -1 : 0) : current;\n    const next = (start + delta + ids.length) % ids.length;\n    this.activeIdSubject.next(ids[next]);\n  }\n\n  setActive(id: string | null): void {\n    if (id !== null && !this.isVisible(id)) return;\n    this.activeIdSubject.next(id);\n  }\n\n  /** Selects the highlighted item, if there is one. */\n  selectActive(): void {\n    const id = this.activeIdSubject.value;\n    if (!id) return;\n    const item = this.items.get(id);\n    if (!item || item.disabled) return;\n    this.selectedSubject.next(item.value);\n  }\n\n  selectById(id: string): void {\n    const item = this.items.get(id);\n    if (!item || item.disabled) return;\n    this.selectedSubject.next(item.value);\n  }\n\n  /** Recomputes the visible set and keeps the highlight on something valid. */\n  private recompute(): void {\n    const q = this.querySubject.value.trim().toLowerCase();\n\n    const visible = [...this.items.values()]\n      .filter((item) => !this.shouldFilter || !q || item.searchText.toLowerCase().includes(q))\n      .sort((a, b) => a.order - b.order)\n      .map((item) => item.id);\n\n    this.visibleSubject.next(visible);\n\n    // If the highlight fell out of the visible set (or there was none), move it\n    // to the first selectable item so Enter always has a sensible target.\n    const active = this.activeIdSubject.value;\n    if (!active || !visible.includes(active)) {\n      const firstEnabled = visible.find((id) => !this.items.get(id)?.disabled) ?? null;\n      this.activeIdSubject.next(firstEnabled);\n    }\n  }\n}\n"]}

package/esm2022/lib/confirmation.component.mjs

@@ -0,0 +1,219 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const confirmationVariants = cva('w-full rounded-lg border p-3 text-sm transition-colors', {
+    variants: {
+        state: {
+            pending: 'border-border bg-card text-card-foreground',
+            confirmed: 'border-success/40 bg-success/5 text-card-foreground',
+            cancelled: 'border-destructive/40 bg-destructive/5 text-card-foreground',
+        },
+    },
+    defaultVariants: { state: 'pending' },
+});
+const confirmationIconVariants = cva('mt-0.5 shrink-0 text-base leading-none', {
+    variants: {
+        state: {
+            pending: 'text-warning',
+            confirmed: 'text-success',
+            cancelled: 'text-destructive',
+        },
+    },
+    defaultVariants: { state: 'pending' },
+});
+const confirmationResolvedVariants = cva('inline-flex shrink-0 items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium', {
+    variants: {
+        state: {
+            pending: 'border-border text-muted-foreground',
+            confirmed: 'border-success/40 bg-success/10 text-success',
+            cancelled: 'border-destructive/40 bg-destructive/10 text-destructive',
+        },
+    },
+    defaultVariants: { state: 'pending' },
+});
+/** Remixicon class shown beside the prompt for each state. */
+const CONFIRMATION_ICONS = {
+    pending: 'ri-shield-check-line',
+    confirmed: 'ri-checkbox-circle-fill',
+    cancelled: 'ri-close-circle-fill',
+};
+/**
+ * An inline approve / deny prompt for an agent action that needs a human to
+ * sign off. While `state` is `'pending'` it shows both buttons; once the user
+ * answers — or the host sets `state` — the buttons collapse into a compact
+ * resolved row.
+ *
+ * ```html
+ * <tolle-confirmation
+ *   title="Delete 12 rows from the orders table?"
+ *   description="This cannot be undone."
+ *   (confirmed)="run()"
+ *   (cancelled)="skip()"
+ * ></tolle-confirmation>
+ * ```
+ * @new
+ */
+export class ConfirmationComponent {
+    cdr = inject(ChangeDetectorRef);
+    /** Headline describing the action awaiting approval. @default '' */
+    title = '';
+    /** Supporting detail shown under the title. @default '' */
+    description = '';
+    /** Label of the approve button. @default 'Approve' */
+    confirmLabel = 'Approve';
+    /** Label of the deny button. @default 'Deny' */
+    cancelLabel = 'Deny';
+    /** Text shown in the resolved row after approval. @default 'Approved' */
+    confirmedLabel = 'Approved';
+    /** Text shown in the resolved row after denial. @default 'Denied' */
+    cancelledLabel = 'Denied';
+    /** Whether the prompt is still open, and how it was answered. @default 'pending' */
+    state = 'pending';
+    /** Blocks both buttons without resolving the prompt. @default false */
+    disabled = false;
+    /** Extra Tailwind classes merged onto the prompt via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when the user approves the action. */
+    confirmed = new EventEmitter();
+    /** Emitted when the user denies the action. */
+    cancelled = new EventEmitter();
+    /**
+     * Set when the user answers, so the prompt resolves on its own without the
+     * host having to bind `state` back. Cleared whenever `state` is pushed in.
+     */
+    answer = null;
+    ngOnChanges(changes) {
+        if (changes['state'])
+            this.answer = null;
+        // A bound `class` input is written through Angular's styling path,
+        // which does not mark an OnPush view dirty on its own.
+        this.cdr.markForCheck();
+    }
+    /** The state actually rendered: the user's answer if there is one, else `state`. */
+    get currentState() {
+        return this.answer ?? this.state;
+    }
+    get resolvedLabel() {
+        return this.currentState === 'confirmed' ? this.confirmedLabel : this.cancelledLabel;
+    }
+    get iconName() {
+        return CONFIRMATION_ICONS[this.currentState];
+    }
+    get computedClass() {
+        return cn(confirmationVariants({ state: this.currentState }), this.class);
+    }
+    get iconClass() {
+        return cn(confirmationIconVariants({ state: this.currentState }), this.iconName);
+    }
+    get resolvedClass() {
+        return cn(confirmationResolvedVariants({ state: this.currentState }));
+    }
+    get confirmButtonClass() {
+        return cn('inline-flex h-8 items-center gap-1.5 rounded-md bg-primary px-3 text-xs font-medium text-primary-foreground transition-colors', 'hover:bg-primary/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50');
+    }
+    get cancelButtonClass() {
+        return cn('inline-flex h-8 items-center gap-1.5 rounded-md border border-border bg-background px-3 text-xs font-medium text-foreground transition-colors', 'hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50');
+    }
+    confirm() {
+        if (this.disabled || this.currentState !== 'pending')
+            return;
+        this.answer = 'confirmed';
+        this.confirmed.emit();
+    }
+    cancel() {
+        if (this.disabled || this.currentState !== 'pending')
+            return;
+        this.answer = 'cancelled';
+        this.cancelled.emit();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfirmationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ConfirmationComponent, isStandalone: true, selector: "tolle-confirmation", inputs: { title: "title", description: "description", confirmLabel: "confirmLabel", cancelLabel: "cancelLabel", confirmedLabel: "confirmedLabel", cancelledLabel: "cancelledLabel", state: "state", disabled: "disabled", class: "class" }, outputs: { confirmed: "confirmed", cancelled: "cancelled" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass" [attr.data-state]="currentState" role="group" [attr.aria-label]="title">
+      <div class="flex items-start gap-3">
+        <i [class]="iconClass" aria-hidden="true"></i>
+
+        <div class="min-w-0 flex-1">
+          <p class="font-medium text-foreground">{{ title }}</p>
+          <p *ngIf="description" class="mt-0.5 text-sm text-muted-foreground">{{ description }}</p>
+
+          <div class="empty:hidden"><ng-content></ng-content></div>
+
+          <div *ngIf="currentState === 'pending'" class="mt-3 flex flex-wrap items-center gap-2">
+            <button type="button" [disabled]="disabled" [class]="confirmButtonClass" (click)="confirm()">
+              <i class="ri-check-line" aria-hidden="true"></i>
+              {{ confirmLabel }}
+            </button>
+            <button type="button" [disabled]="disabled" [class]="cancelButtonClass" (click)="cancel()">
+              <i class="ri-close-line" aria-hidden="true"></i>
+              {{ cancelLabel }}
+            </button>
+          </div>
+        </div>
+
+        <span *ngIf="currentState !== 'pending'" [class]="resolvedClass">
+          <i [class]="iconName" aria-hidden="true"></i>
+          {{ resolvedLabel }}
+        </span>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfirmationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-confirmation', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass" [attr.data-state]="currentState" role="group" [attr.aria-label]="title">
+      <div class="flex items-start gap-3">
+        <i [class]="iconClass" aria-hidden="true"></i>
+
+        <div class="min-w-0 flex-1">
+          <p class="font-medium text-foreground">{{ title }}</p>
+          <p *ngIf="description" class="mt-0.5 text-sm text-muted-foreground">{{ description }}</p>
+
+          <div class="empty:hidden"><ng-content></ng-content></div>
+
+          <div *ngIf="currentState === 'pending'" class="mt-3 flex flex-wrap items-center gap-2">
+            <button type="button" [disabled]="disabled" [class]="confirmButtonClass" (click)="confirm()">
+              <i class="ri-check-line" aria-hidden="true"></i>
+              {{ confirmLabel }}
+            </button>
+            <button type="button" [disabled]="disabled" [class]="cancelButtonClass" (click)="cancel()">
+              <i class="ri-close-line" aria-hidden="true"></i>
+              {{ cancelLabel }}
+            </button>
+          </div>
+        </div>
+
+        <span *ngIf="currentState !== 'pending'" [class]="resolvedClass">
+          <i [class]="iconName" aria-hidden="true"></i>
+          {{ resolvedLabel }}
+        </span>
+      </div>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], confirmLabel: [{
+                type: Input
+            }], cancelLabel: [{
+                type: Input
+            }], confirmedLabel: [{
+                type: Input
+            }], cancelledLabel: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], confirmed: [{
+                type: Output
+            }], cancelled: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirmation.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/confirmation.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, OnChanges, Output, SimpleChanges, ChangeDetectorRef, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/** Whether the user has answered the prompt yet, and how. */\nexport type ConfirmationState = 'pending' | 'confirmed' | 'cancelled';\n\nconst confirmationVariants = cva('w-full rounded-lg border p-3 text-sm transition-colors', {\n  variants: {\n    state: {\n      pending: 'border-border bg-card text-card-foreground',\n      confirmed: 'border-success/40 bg-success/5 text-card-foreground',\n      cancelled: 'border-destructive/40 bg-destructive/5 text-card-foreground',\n    },\n  },\n  defaultVariants: { state: 'pending' },\n});\n\nconst confirmationIconVariants = cva('mt-0.5 shrink-0 text-base leading-none', {\n  variants: {\n    state: {\n      pending: 'text-warning',\n      confirmed: 'text-success',\n      cancelled: 'text-destructive',\n    },\n  },\n  defaultVariants: { state: 'pending' },\n});\n\nconst confirmationResolvedVariants = cva(\n  'inline-flex shrink-0 items-center gap-1 rounded-full border px-2 py-0.5 text-xs font-medium',\n  {\n    variants: {\n      state: {\n        pending: 'border-border text-muted-foreground',\n        confirmed: 'border-success/40 bg-success/10 text-success',\n        cancelled: 'border-destructive/40 bg-destructive/10 text-destructive',\n      },\n    },\n    defaultVariants: { state: 'pending' },\n  }\n);\n\nexport type ConfirmationProps = VariantProps<typeof confirmationVariants>;\n\n/** Remixicon class shown beside the prompt for each state. */\nconst CONFIRMATION_ICONS: Record<ConfirmationState, string> = {\n  pending: 'ri-shield-check-line',\n  confirmed: 'ri-checkbox-circle-fill',\n  cancelled: 'ri-close-circle-fill',\n};\n\n/**\n * An inline approve / deny prompt for an agent action that needs a human to\n * sign off. While `state` is `'pending'` it shows both buttons; once the user\n * answers — or the host sets `state` — the buttons collapse into a compact\n * resolved row.\n *\n * ```html\n * <tolle-confirmation\n *   title=\"Delete 12 rows from the orders table?\"\n *   description=\"This cannot be undone.\"\n *   (confirmed)=\"run()\"\n *   (cancelled)=\"skip()\"\n * ></tolle-confirmation>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-confirmation',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\" [attr.data-state]=\"currentState\" role=\"group\" [attr.aria-label]=\"title\">\n      <div class=\"flex items-start gap-3\">\n        <i [class]=\"iconClass\" aria-hidden=\"true\"></i>\n\n        <div class=\"min-w-0 flex-1\">\n          <p class=\"font-medium text-foreground\">{{ title }}</p>\n          <p *ngIf=\"description\" class=\"mt-0.5 text-sm text-muted-foreground\">{{ description }}</p>\n\n          <div class=\"empty:hidden\"><ng-content></ng-content></div>\n\n          <div *ngIf=\"currentState === 'pending'\" class=\"mt-3 flex flex-wrap items-center gap-2\">\n            <button type=\"button\" [disabled]=\"disabled\" [class]=\"confirmButtonClass\" (click)=\"confirm()\">\n              <i class=\"ri-check-line\" aria-hidden=\"true\"></i>\n              {{ confirmLabel }}\n            </button>\n            <button type=\"button\" [disabled]=\"disabled\" [class]=\"cancelButtonClass\" (click)=\"cancel()\">\n              <i class=\"ri-close-line\" aria-hidden=\"true\"></i>\n              {{ cancelLabel }}\n            </button>\n          </div>\n        </div>\n\n        <span *ngIf=\"currentState !== 'pending'\" [class]=\"resolvedClass\">\n          <i [class]=\"iconName\" aria-hidden=\"true\"></i>\n          {{ resolvedLabel }}\n        </span>\n      </div>\n    </div>\n  `,\n})\nexport class ConfirmationComponent implements OnChanges {\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /** Headline describing the action awaiting approval. @default '' */\n  @Input() title = '';\n  /** Supporting detail shown under the title. @default '' */\n  @Input() description = '';\n  /** Label of the approve button. @default 'Approve' */\n  @Input() confirmLabel = 'Approve';\n  /** Label of the deny button. @default 'Deny' */\n  @Input() cancelLabel = 'Deny';\n  /** Text shown in the resolved row after approval. @default 'Approved' */\n  @Input() confirmedLabel = 'Approved';\n  /** Text shown in the resolved row after denial. @default 'Denied' */\n  @Input() cancelledLabel = 'Denied';\n  /** Whether the prompt is still open, and how it was answered. @default 'pending' */\n  @Input() state: ConfirmationState = 'pending';\n  /** Blocks both buttons without resolving the prompt. @default false */\n  @Input() disabled = false;\n  /** Extra Tailwind classes merged onto the prompt via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when the user approves the action. */\n  @Output() confirmed = new EventEmitter<void>();\n  /** Emitted when the user denies the action. */\n  @Output() cancelled = new EventEmitter<void>();\n\n  /**\n   * Set when the user answers, so the prompt resolves on its own without the\n   * host having to bind `state` back. Cleared whenever `state` is pushed in.\n   */\n  private answer: ConfirmationState | null = null;\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['state']) this.answer = null;\n  \n    // A bound `class` input is written through Angular's styling path,\n    // which does not mark an OnPush view dirty on its own.\n    this.cdr.markForCheck();\n  }\n\n  /** The state actually rendered: the user's answer if there is one, else `state`. */\n  get currentState(): ConfirmationState {\n    return this.answer ?? this.state;\n  }\n\n  get resolvedLabel(): string {\n    return this.currentState === 'confirmed' ? this.confirmedLabel : this.cancelledLabel;\n  }\n\n  get iconName(): string {\n    return CONFIRMATION_ICONS[this.currentState];\n  }\n\n  get computedClass() {\n    return cn(confirmationVariants({ state: this.currentState }), this.class);\n  }\n\n  get iconClass() {\n    return cn(confirmationIconVariants({ state: this.currentState }), this.iconName);\n  }\n\n  get resolvedClass() {\n    return cn(confirmationResolvedVariants({ state: this.currentState }));\n  }\n\n  get confirmButtonClass() {\n    return cn(\n      'inline-flex h-8 items-center gap-1.5 rounded-md bg-primary px-3 text-xs font-medium text-primary-foreground transition-colors',\n      'hover:bg-primary/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50'\n    );\n  }\n\n  get cancelButtonClass() {\n    return cn(\n      'inline-flex h-8 items-center gap-1.5 rounded-md border border-border bg-background px-3 text-xs font-medium text-foreground transition-colors',\n      'hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50'\n    );\n  }\n\n  confirm(): void {\n    if (this.disabled || this.currentState !== 'pending') return;\n    this.answer = 'confirmed';\n    this.confirmed.emit();\n  }\n\n  cancel(): void {\n    if (this.disabled || this.currentState !== 'pending') return;\n    this.answer = 'cancelled';\n    this.cancelled.emit();\n  }\n}\n"]}

package/esm2022/lib/context-menu-trigger.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, ElementRef, EventEmitter, HostListener, inject, Input, Output } from '@angular/core';
+import { ContextMenuService } from './context-menu.service';
+import * as i0 from "@angular/core";
+export class ContextMenuTriggerDirective {
+    elementRef = inject(ElementRef);
+    contextMenuService = inject(ContextMenuService);
+    items = [];
+    action = new EventEmitter();
+    onContextMenu(event) {
+        event.stopPropagation();
+        this.contextMenuService.open({
+            event,
+            items: this.items,
+            triggerElement: this.elementRef.nativeElement,
+            onAction: (actionId) => this.action.emit(actionId)
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ContextMenuTriggerDirective, isStandalone: true, selector: "[tolleContextMenuTrigger]", inputs: { items: ["tolleContextMenuTrigger", "items"] }, outputs: { action: "action" }, host: { listeners: { "contextmenu": "onContextMenu($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextMenuTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleContextMenuTrigger]',
+                    standalone: true
+                }]
+        }], propDecorators: { items: [{
+                type: Input,
+                args: ['tolleContextMenuTrigger']
+            }], action: [{
+                type: Output
+            }], onContextMenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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