@tolle_/tolle-ui 18.2.29 → 18.3.0

package/esm2022/lib/context.component.mjs

@@ -0,0 +1,377 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injectable, Input, forwardRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import { HoverCardComponent, HoverCardTriggerComponent, HoverCardContentComponent, } from './hover-card.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const contextTriggerVariants = cva('inline-flex items-center gap-1.5 rounded-md px-1.5 py-1 text-xs font-medium tabular-nums transition-colors', {
+    variants: {
+        level: {
+            normal: 'text-muted-foreground hover:text-foreground',
+            warning: 'text-warning hover:text-warning',
+            critical: 'text-destructive hover:text-destructive',
+        },
+    },
+    defaultVariants: { level: 'normal' },
+});
+const contextBarVariants = cva('h-full rounded-full transition-[width,background-color] duration-300', {
+    variants: {
+        level: {
+            normal: 'bg-primary',
+            warning: 'bg-warning',
+            critical: 'bg-destructive',
+        },
+    },
+    defaultVariants: { level: 'normal' },
+});
+/** Formats a raw token count as a short, readable string. */
+export function formatTokens(value) {
+    if (!isFinite(value))
+        return '0';
+    const abs = Math.abs(value);
+    if (abs >= 1_000_000)
+        return (value / 1_000_000).toFixed(1).replace(/\.0$/, '') + 'M';
+    if (abs >= 1_000)
+        return (value / 1_000).toFixed(1).replace(/\.0$/, '') + 'K';
+    return String(Math.round(value));
+}
+/**
+ * Publishes the parent `tolle-context`'s numbers to its OnPush trigger and
+ * content children, which receive none of it as their own inputs.
+ */
+export class ContextService {
+    usageSource = new BehaviorSubject({
+        used: 0,
+        total: 0,
+        inputTokens: null,
+        outputTokens: null,
+        cost: null,
+        ratio: 0,
+        level: 'normal',
+    });
+    /** Emits the current context-window usage. */
+    usage$ = this.usageSource.asObservable();
+    get usage() {
+        return this.usageSource.value;
+    }
+    setUsage(usage) {
+        this.usageSource.next(usage);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * A token / context-window usage indicator: a compact percentage and bar that
+ * shifts to the warning and destructive tokens as the window fills, with a
+ * hover breakdown of input, output and cost.
+ *
+ * ```html
+ * <tolle-context [used]="82000" [total]="128000" [inputTokens]="61000" [outputTokens]="21000" [cost]="0.42"></tolle-context>
+ * ```
+ * @new
+ */
+export class ContextComponent {
+    /** Tokens consumed so far. @default 0 */
+    used = 0;
+    /** Size of the context window in tokens. @default 0 */
+    total = 0;
+    /** Tokens spent on the prompt, shown in the breakdown. @default null */
+    inputTokens = null;
+    /** Tokens produced by the model, shown in the breakdown. @default null */
+    outputTokens = null;
+    /** Spend for this context, shown in the breakdown. @default null */
+    cost = null;
+    /** Ratio at or above which the indicator turns warning-coloured. @default 0.75 */
+    warningThreshold = 0.75;
+    /** Ratio at or above which the indicator turns destructive-coloured. @default 0.9 */
+    criticalThreshold = 0.9;
+    /** Side of the indicator the breakdown opens on. @default 'top' */
+    placement = 'top';
+    /** Milliseconds to wait before opening the breakdown. @default 150 */
+    openDelay = 150;
+    /** Milliseconds to wait before closing the breakdown. @default 200 */
+    closeDelay = 200;
+    /** Extra Tailwind classes merged onto the indicator via `cn()` (last-wins). */
+    class = '';
+    service = inject(ContextService);
+    cdr = inject(ChangeDetectorRef);
+    refreshTimer;
+    ngOnInit() {
+        this.push();
+    }
+    ngOnChanges() {
+        this.push();
+    }
+    /** Fraction of the window consumed, clamped to 0–1. */
+    get ratio() {
+        if (!this.total || this.total <= 0)
+            return 0;
+        return Math.min(1, Math.max(0, this.used / this.total));
+    }
+    /** Which colour band the current usage falls into. */
+    get level() {
+        const ratio = this.ratio;
+        if (ratio >= this.criticalThreshold)
+            return 'critical';
+        if (ratio >= this.warningThreshold)
+            return 'warning';
+        return 'normal';
+    }
+    push() {
+        this.service.setUsage({
+            used: this.used,
+            total: this.total,
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+            cost: this.cost,
+            ratio: this.ratio,
+            level: this.level,
+        });
+    }
+    /**
+     * `tolle-hover-card` toggles its own visibility from a `setTimeout`, which
+     * never marks this OnPush view dirty — re-check once the delay has elapsed.
+     */
+    scheduleRefresh(delay) {
+        clearTimeout(this.refreshTimer);
+        this.refreshTimer = setTimeout(() => this.cdr.markForCheck(), delay + 32);
+    }
+    ngOnDestroy() {
+        clearTimeout(this.refreshTimer);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ContextComponent, isStandalone: true, selector: "tolle-context", inputs: { used: "used", total: "total", inputTokens: "inputTokens", outputTokens: "outputTokens", cost: "cost", warningThreshold: "warningThreshold", criticalThreshold: "criticalThreshold", placement: "placement", openDelay: "openDelay", closeDelay: "closeDelay", class: "class" }, providers: [ContextService], usesOnChanges: true, ngImport: i0, template: `
+    <tolle-hover-card
+      [openDelay]="openDelay"
+      [closeDelay]="closeDelay"
+      [placement]="placement"
+      (mouseenter)="scheduleRefresh(openDelay)"
+      (mouseleave)="scheduleRefresh(closeDelay)"
+    >
+      <tolle-hover-card-trigger>
+        <tolle-context-trigger></tolle-context-trigger>
+      </tolle-hover-card-trigger>
+      <tolle-hover-card-content class="w-60 p-0">
+        <tolle-context-content></tolle-context-content>
+      </tolle-hover-card-content>
+    </tolle-hover-card>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: i0.forwardRef(() => CommonModule) }, { kind: "component", type: i0.forwardRef(() => HoverCardComponent), selector: "tolle-hover-card", inputs: ["openDelay", "closeDelay", "placement"] }, { kind: "component", type: i0.forwardRef(() => HoverCardTriggerComponent), selector: "tolle-hover-card-trigger" }, { kind: "component", type: i0.forwardRef(() => HoverCardContentComponent), selector: "tolle-hover-card-content", inputs: ["class"] }, { kind: "component", type: i0.forwardRef(() => ContextTriggerComponent), selector: "tolle-context-trigger", inputs: ["class"] }, { kind: "component", type: i0.forwardRef(() => ContextContentComponent), selector: "tolle-context-content", inputs: ["currency", "class"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-context', standalone: true, imports: [
+                        CommonModule,
+                        HoverCardComponent,
+                        HoverCardTriggerComponent,
+                        HoverCardContentComponent,
+                        // The sub-components are declared further down this file, so they are
+                        // referenced lazily rather than read at decoration time.
+                        forwardRef(() => ContextTriggerComponent),
+                        forwardRef(() => ContextContentComponent),
+                    ], providers: [ContextService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <tolle-hover-card
+      [openDelay]="openDelay"
+      [closeDelay]="closeDelay"
+      [placement]="placement"
+      (mouseenter)="scheduleRefresh(openDelay)"
+      (mouseleave)="scheduleRefresh(closeDelay)"
+    >
+      <tolle-hover-card-trigger>
+        <tolle-context-trigger></tolle-context-trigger>
+      </tolle-hover-card-trigger>
+      <tolle-hover-card-content class="w-60 p-0">
+        <tolle-context-content></tolle-context-content>
+      </tolle-hover-card-content>
+    </tolle-hover-card>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { used: [{
+                type: Input
+            }], total: [{
+                type: Input
+            }], inputTokens: [{
+                type: Input
+            }], outputTokens: [{
+                type: Input
+            }], cost: [{
+                type: Input
+            }], warningThreshold: [{
+                type: Input
+            }], criticalThreshold: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], openDelay: [{
+                type: Input
+            }], closeDelay: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** The always-visible part of a `tolle-context`: percentage plus usage bar. */
+export class ContextTriggerComponent {
+    /**
+     * 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 trigger via `cn()` (last-wins). */
+    class = '';
+    service = inject(ContextService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    usage = this.service.usage;
+    ngOnInit() {
+        this.sub.add(this.service.usage$.subscribe((usage) => {
+            this.usage = usage;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    /** Usage as a whole percentage. */
+    get percent() {
+        return Math.round(this.usage.ratio * 100);
+    }
+    get computedClass() {
+        return cn(contextTriggerVariants({ level: this.usage.level }), this.class);
+    }
+    get barClass() {
+        return cn('block', contextBarVariants({ level: this.usage.level }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextTriggerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ContextTriggerComponent, isStandalone: true, selector: "tolle-context-trigger", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <span
+      role="meter"
+      [attr.aria-valuenow]="percent"
+      aria-valuemin="0"
+      aria-valuemax="100"
+      [attr.aria-label]="'Context window ' + percent + '% used'"
+      [attr.data-level]="usage.level"
+      [class]="computedClass"
+    >
+      <span class="h-1.5 w-10 overflow-hidden rounded-full bg-muted">
+        <span [class]="barClass" [style.width.%]="percent"></span>
+      </span>
+      <span>{{ percent }}%</span>
+      <ng-content></ng-content>
+    </span>
+  `, 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: ContextTriggerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-context-trigger', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <span
+      role="meter"
+      [attr.aria-valuenow]="percent"
+      aria-valuemin="0"
+      aria-valuemax="100"
+      [attr.aria-label]="'Context window ' + percent + '% used'"
+      [attr.data-level]="usage.level"
+      [class]="computedClass"
+    >
+      <span class="h-1.5 w-10 overflow-hidden rounded-full bg-muted">
+        <span [class]="barClass" [style.width.%]="percent"></span>
+      </span>
+      <span>{{ percent }}%</span>
+      <ng-content></ng-content>
+    </span>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** The hover breakdown of a `tolle-context`: used, total, input, output, cost. */
+export class ContextContentComponent {
+    /**
+     * 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();
+    }
+    /** Symbol prefixed to the cost figure. @default '$' */
+    currency = '$';
+    /** Extra Tailwind classes merged onto the breakdown via `cn()` (last-wins). */
+    class = '';
+    service = inject(ContextService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    usage = this.service.usage;
+    tokens = formatTokens;
+    ngOnInit() {
+        this.sub.add(this.service.usage$.subscribe((usage) => {
+            this.usage = usage;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get computedClass() {
+        return cn('flex flex-col p-3', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ContextContentComponent, isStandalone: true, selector: "tolle-context-content", inputs: { currency: "currency", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div class="flex items-baseline justify-between gap-2">
+        <span class="text-sm font-medium text-popover-foreground">Context</span>
+        <span class="text-xs tabular-nums text-muted-foreground">{{ tokens(usage.used) }} / {{ tokens(usage.total) }}</span>
+      </div>
+      <dl class="mt-2 flex flex-col gap-1 text-xs">
+        <div *ngIf="usage.inputTokens !== null" class="flex items-center justify-between gap-2">
+          <dt class="text-muted-foreground">Input</dt>
+          <dd class="tabular-nums text-popover-foreground">{{ tokens(usage.inputTokens) }}</dd>
+        </div>
+        <div *ngIf="usage.outputTokens !== null" class="flex items-center justify-between gap-2">
+          <dt class="text-muted-foreground">Output</dt>
+          <dd class="tabular-nums text-popover-foreground">{{ tokens(usage.outputTokens) }}</dd>
+        </div>
+        <div *ngIf="usage.cost !== null" class="flex items-center justify-between gap-2">
+          <dt class="text-muted-foreground">Cost</dt>
+          <dd class="tabular-nums text-popover-foreground">{{ currency }}{{ usage.cost }}</dd>
+        </div>
+      </dl>
+      <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"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ContextContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-context-content', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div class="flex items-baseline justify-between gap-2">
+        <span class="text-sm font-medium text-popover-foreground">Context</span>
+        <span class="text-xs tabular-nums text-muted-foreground">{{ tokens(usage.used) }} / {{ tokens(usage.total) }}</span>
+      </div>
+      <dl class="mt-2 flex flex-col gap-1 text-xs">
+        <div *ngIf="usage.inputTokens !== null" class="flex items-center justify-between gap-2">
+          <dt class="text-muted-foreground">Input</dt>
+          <dd class="tabular-nums text-popover-foreground">{{ tokens(usage.inputTokens) }}</dd>
+        </div>
+        <div *ngIf="usage.outputTokens !== null" class="flex items-center justify-between gap-2">
+          <dt class="text-muted-foreground">Output</dt>
+          <dd class="tabular-nums text-popover-foreground">{{ tokens(usage.outputTokens) }}</dd>
+        </div>
+        <div *ngIf="usage.cost !== null" class="flex items-center justify-between gap-2">
+          <dt class="text-muted-foreground">Cost</dt>
+          <dd class="tabular-nums text-popover-foreground">{{ currency }}{{ usage.cost }}</dd>
+        </div>
+      </dl>
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { currency: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/context.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injectable, Input, OnChanges, OnDestroy, OnInit, forwardRef, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\nimport {\n  HoverCardComponent,\n  HoverCardTriggerComponent,\n  HoverCardContentComponent,\n} from './hover-card.component';\n\n/** How close the context window is to being full. */\nexport type ContextLevel = 'normal' | 'warning' | 'critical';\n\n/** Everything a `tolle-context` knows about the current window. */\nexport interface ContextUsage {\n  used: number;\n  total: number;\n  inputTokens: number | null;\n  outputTokens: number | null;\n  cost: number | null;\n  /** Fraction of the window consumed, clamped to 0–1. */\n  ratio: number;\n  level: ContextLevel;\n}\n\nconst contextTriggerVariants = cva(\n  'inline-flex items-center gap-1.5 rounded-md px-1.5 py-1 text-xs font-medium tabular-nums transition-colors',\n  {\n    variants: {\n      level: {\n        normal: 'text-muted-foreground hover:text-foreground',\n        warning: 'text-warning hover:text-warning',\n        critical: 'text-destructive hover:text-destructive',\n      },\n    },\n    defaultVariants: { level: 'normal' },\n  }\n);\n\nconst contextBarVariants = cva('h-full rounded-full transition-[width,background-color] duration-300', {\n  variants: {\n    level: {\n      normal: 'bg-primary',\n      warning: 'bg-warning',\n      critical: 'bg-destructive',\n    },\n  },\n  defaultVariants: { level: 'normal' },\n});\n\nexport type ContextProps = VariantProps<typeof contextTriggerVariants>;\n\n/** Formats a raw token count as a short, readable string. */\nexport function formatTokens(value: number): string {\n  if (!isFinite(value)) return '0';\n  const abs = Math.abs(value);\n  if (abs >= 1_000_000) return (value / 1_000_000).toFixed(1).replace(/\\.0$/, '') + 'M';\n  if (abs >= 1_000) return (value / 1_000).toFixed(1).replace(/\\.0$/, '') + 'K';\n  return String(Math.round(value));\n}\n\n/**\n * Publishes the parent `tolle-context`'s numbers to its OnPush trigger and\n * content children, which receive none of it as their own inputs.\n */\n@Injectable()\nexport class ContextService {\n  private readonly usageSource = new BehaviorSubject<ContextUsage>({\n    used: 0,\n    total: 0,\n    inputTokens: null,\n    outputTokens: null,\n    cost: null,\n    ratio: 0,\n    level: 'normal',\n  });\n\n  /** Emits the current context-window usage. */\n  readonly usage$ = this.usageSource.asObservable();\n\n  get usage(): ContextUsage {\n    return this.usageSource.value;\n  }\n\n  setUsage(usage: ContextUsage): void {\n    this.usageSource.next(usage);\n  }\n}\n\n/**\n * A token / context-window usage indicator: a compact percentage and bar that\n * shifts to the warning and destructive tokens as the window fills, with a\n * hover breakdown of input, output and cost.\n *\n * ```html\n * <tolle-context [used]=\"82000\" [total]=\"128000\" [inputTokens]=\"61000\" [outputTokens]=\"21000\" [cost]=\"0.42\"></tolle-context>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-context',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [\n    CommonModule,\n    HoverCardComponent,\n    HoverCardTriggerComponent,\n    HoverCardContentComponent,\n    // The sub-components are declared further down this file, so they are\n    // referenced lazily rather than read at decoration time.\n    forwardRef(() => ContextTriggerComponent),\n    forwardRef(() => ContextContentComponent),\n  ],\n  providers: [ContextService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <tolle-hover-card\n      [openDelay]=\"openDelay\"\n      [closeDelay]=\"closeDelay\"\n      [placement]=\"placement\"\n      (mouseenter)=\"scheduleRefresh(openDelay)\"\n      (mouseleave)=\"scheduleRefresh(closeDelay)\"\n    >\n      <tolle-hover-card-trigger>\n        <tolle-context-trigger></tolle-context-trigger>\n      </tolle-hover-card-trigger>\n      <tolle-hover-card-content class=\"w-60 p-0\">\n        <tolle-context-content></tolle-context-content>\n      </tolle-hover-card-content>\n    </tolle-hover-card>\n  `,\n})\nexport class ContextComponent implements OnInit, OnChanges, OnDestroy {\n  /** Tokens consumed so far. @default 0 */\n  @Input() used = 0;\n  /** Size of the context window in tokens. @default 0 */\n  @Input() total = 0;\n  /** Tokens spent on the prompt, shown in the breakdown. @default null */\n  @Input() inputTokens: number | null = null;\n  /** Tokens produced by the model, shown in the breakdown. @default null */\n  @Input() outputTokens: number | null = null;\n  /** Spend for this context, shown in the breakdown. @default null */\n  @Input() cost: number | null = null;\n  /** Ratio at or above which the indicator turns warning-coloured. @default 0.75 */\n  @Input() warningThreshold = 0.75;\n  /** Ratio at or above which the indicator turns destructive-coloured. @default 0.9 */\n  @Input() criticalThreshold = 0.9;\n  /** Side of the indicator the breakdown opens on. @default 'top' */\n  @Input() placement: 'top' | 'bottom' | 'left' | 'right' = 'top';\n  /** Milliseconds to wait before opening the breakdown. @default 150 */\n  @Input() openDelay = 150;\n  /** Milliseconds to wait before closing the breakdown. @default 200 */\n  @Input() closeDelay = 200;\n  /** Extra Tailwind classes merged onto the indicator via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(ContextService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private refreshTimer?: ReturnType<typeof setTimeout>;\n\n  ngOnInit(): void {\n    this.push();\n  }\n\n  ngOnChanges(): void {\n    this.push();\n  }\n\n  /** Fraction of the window consumed, clamped to 0–1. */\n  get ratio(): number {\n    if (!this.total || this.total <= 0) return 0;\n    return Math.min(1, Math.max(0, this.used / this.total));\n  }\n\n  /** Which colour band the current usage falls into. */\n  get level(): ContextLevel {\n    const ratio = this.ratio;\n    if (ratio >= this.criticalThreshold) return 'critical';\n    if (ratio >= this.warningThreshold) return 'warning';\n    return 'normal';\n  }\n\n  private push(): void {\n    this.service.setUsage({\n      used: this.used,\n      total: this.total,\n      inputTokens: this.inputTokens,\n      outputTokens: this.outputTokens,\n      cost: this.cost,\n      ratio: this.ratio,\n      level: this.level,\n    });\n  }\n\n  /**\n   * `tolle-hover-card` toggles its own visibility from a `setTimeout`, which\n   * never marks this OnPush view dirty — re-check once the delay has elapsed.\n   */\n  scheduleRefresh(delay: number): void {\n    clearTimeout(this.refreshTimer);\n    this.refreshTimer = setTimeout(() => this.cdr.markForCheck(), delay + 32);\n  }\n\n  ngOnDestroy(): void {\n    clearTimeout(this.refreshTimer);\n  }\n}\n\n/** The always-visible part of a `tolle-context`: percentage plus usage bar. */\n@Component({\n  selector: 'tolle-context-trigger',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <span\n      role=\"meter\"\n      [attr.aria-valuenow]=\"percent\"\n      aria-valuemin=\"0\"\n      aria-valuemax=\"100\"\n      [attr.aria-label]=\"'Context window ' + percent + '% used'\"\n      [attr.data-level]=\"usage.level\"\n      [class]=\"computedClass\"\n    >\n      <span class=\"h-1.5 w-10 overflow-hidden rounded-full bg-muted\">\n        <span [class]=\"barClass\" [style.width.%]=\"percent\"></span>\n      </span>\n      <span>{{ percent }}%</span>\n      <ng-content></ng-content>\n    </span>\n  `,\n})\nexport class ContextTriggerComponent implements OnChanges, OnInit, 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  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(ContextService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  usage: ContextUsage = this.service.usage;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.usage$.subscribe((usage) => {\n        this.usage = usage;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  /** Usage as a whole percentage. */\n  get percent(): number {\n    return Math.round(this.usage.ratio * 100);\n  }\n\n  get computedClass() {\n    return cn(contextTriggerVariants({ level: this.usage.level }), this.class);\n  }\n\n  get barClass() {\n    return cn('block', contextBarVariants({ level: this.usage.level }));\n  }\n}\n\n/** The hover breakdown of a `tolle-context`: used, total, input, output, cost. */\n@Component({\n  selector: 'tolle-context-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <div class=\"flex items-baseline justify-between gap-2\">\n        <span class=\"text-sm font-medium text-popover-foreground\">Context</span>\n        <span class=\"text-xs tabular-nums text-muted-foreground\">{{ tokens(usage.used) }} / {{ tokens(usage.total) }}</span>\n      </div>\n      <dl class=\"mt-2 flex flex-col gap-1 text-xs\">\n        <div *ngIf=\"usage.inputTokens !== null\" class=\"flex items-center justify-between gap-2\">\n          <dt class=\"text-muted-foreground\">Input</dt>\n          <dd class=\"tabular-nums text-popover-foreground\">{{ tokens(usage.inputTokens) }}</dd>\n        </div>\n        <div *ngIf=\"usage.outputTokens !== null\" class=\"flex items-center justify-between gap-2\">\n          <dt class=\"text-muted-foreground\">Output</dt>\n          <dd class=\"tabular-nums text-popover-foreground\">{{ tokens(usage.outputTokens) }}</dd>\n        </div>\n        <div *ngIf=\"usage.cost !== null\" class=\"flex items-center justify-between gap-2\">\n          <dt class=\"text-muted-foreground\">Cost</dt>\n          <dd class=\"tabular-nums text-popover-foreground\">{{ currency }}{{ usage.cost }}</dd>\n        </div>\n      </dl>\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class ContextContentComponent implements OnChanges, OnInit, 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  /** Symbol prefixed to the cost figure. @default '$' */\n  @Input() currency = '$';\n  /** Extra Tailwind classes merged onto the breakdown via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(ContextService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  usage: ContextUsage = this.service.usage;\n  protected tokens = formatTokens;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.usage$.subscribe((usage) => {\n        this.usage = usage;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn('flex flex-col p-3', this.class);\n  }\n}\n"]}