@tolle_/tolle-ui 18.2.28 → 18.2.30

package/esm2022/lib/chain-of-thought.component.mjs

@@ -0,0 +1,380 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, Output, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { skip } from 'rxjs/operators';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const chainOfThoughtVariants = cva('w-full text-sm', {
+    variants: {
+        size: {
+            sm: 'text-xs',
+            default: 'text-sm',
+        },
+    },
+    defaultVariants: { size: 'default' },
+});
+const chainOfThoughtStepVariants = cva(
+// The rail is hidden on the final step so the line stops at the last marker
+// instead of trailing off the bottom of the list.
+'relative flex gap-3 pb-4 last:pb-0 [&:last-child_.tolle-cot-rail]:hidden', {
+    variants: {
+        status: {
+            pending: 'text-muted-foreground',
+            active: 'text-foreground',
+            complete: 'text-muted-foreground',
+        },
+    },
+    defaultVariants: { status: 'complete' },
+});
+const chainOfThoughtMarkerVariants = cva('relative z-[1] flex h-6 w-6 shrink-0 items-center justify-center rounded-full border text-[11px]', {
+    variants: {
+        status: {
+            pending: 'border-border bg-background text-muted-foreground',
+            active: 'border-info bg-info/10 text-info',
+            complete: 'border-success/50 bg-success/10 text-success',
+        },
+    },
+    defaultVariants: { status: 'complete' },
+});
+/**
+ * Coordinates a `tolle-chain-of-thought` and its header/content children.
+ *
+ * The children are `OnPush` and receive none of this state as inputs, so it
+ * travels as observables and each subscriber calls `markForCheck()`.
+ */
+export class ChainOfThoughtService {
+    openSource = new BehaviorSubject(false);
+    /** Emits whether the reasoning trace is expanded. */
+    open$ = this.openSource.asObservable();
+    get open() {
+        return this.openSource.value;
+    }
+    setOpen(open) {
+        if (this.openSource.value !== open)
+            this.openSource.next(open);
+    }
+    toggle() {
+        this.openSource.next(!this.openSource.value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * A collapsible reasoning trace — the numbered steps an agent worked through
+ * before answering, connected by a vertical rail.
+ *
+ * ```html
+ * <tolle-chain-of-thought [open]="true">
+ *   <tolle-chain-of-thought-header label="Thought for 4s"></tolle-chain-of-thought-header>
+ *   <tolle-chain-of-thought-content>
+ *     <tolle-chain-of-thought-step label="Searched the docs" status="complete" icon="ri-search-line">
+ *       <tolle-chain-of-thought-search-results>
+ *         <tolle-chain-of-thought-search-result>tailwind.config</tolle-chain-of-thought-search-result>
+ *       </tolle-chain-of-thought-search-results>
+ *     </tolle-chain-of-thought-step>
+ *   </tolle-chain-of-thought-content>
+ * </tolle-chain-of-thought>
+ * ```
+ * @new
+ */
+export class ChainOfThoughtComponent {
+    cdr = inject(ChangeDetectorRef);
+    /** Whether the reasoning steps are expanded. @default false */
+    open = false;
+    /** Text scale of the whole trace. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the trace via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new expanded state whenever the trace opens or closes. */
+    openChange = new EventEmitter();
+    service = inject(ChainOfThoughtService);
+    sub = new Subscription();
+    ngOnInit() {
+        this.service.setOpen(this.open);
+        // skip(1) drops the replayed initial value so no `openChange` fires on init.
+        this.sub.add(this.service.open$.pipe(skip(1)).subscribe((open) => this.openChange.emit(open)));
+    }
+    ngOnChanges() {
+        this.service.setOpen(this.open);
+        // 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();
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get computedClass() {
+        return cn(chainOfThoughtVariants({ size: this.size }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChainOfThoughtComponent, isStandalone: true, selector: "tolle-chain-of-thought", inputs: { open: "open", size: "size", class: "class" }, outputs: { openChange: "openChange" }, providers: [ChainOfThoughtService], usesOnChanges: true, ngImport: i0, template: `<div [class]="computedClass"><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: ChainOfThoughtComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chain-of-thought', standalone: true, imports: [CommonModule], providers: [ChainOfThoughtService], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="computedClass"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { open: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+/** Clickable header that expands and collapses the reasoning steps. */
+export class ChainOfThoughtHeaderComponent {
+    /**
+     * 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();
+    }
+    /** Text shown in the header. @default 'Chain of Thought' */
+    label = 'Chain of Thought';
+    /** Extra Tailwind classes merged onto the header via `cn()` (last-wins). */
+    class = '';
+    service = inject(ChainOfThoughtService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    isOpen = false;
+    ngOnInit() {
+        this.sub.add(this.service.open$.subscribe((open) => {
+            this.isOpen = open;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get computedClass() {
+        return cn('flex w-full items-center gap-2 rounded-md py-1 text-sm font-medium text-muted-foreground outline-none transition-colors', 'hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring', this.class);
+    }
+    toggle() {
+        this.service.toggle();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChainOfThoughtHeaderComponent, isStandalone: true, selector: "tolle-chain-of-thought-header", inputs: { label: "label", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      type="button"
+      [attr.aria-expanded]="isOpen"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="toggle()"
+    >
+      <i class="ri-brain-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+      <span class="truncate">{{ label }}</span>
+      <ng-content></ng-content>
+      <i
+        [class]="isOpen ? 'ri-arrow-down-s-line shrink-0' : 'ri-arrow-right-s-line shrink-0'"
+        aria-hidden="true"
+      ></i>
+    </button>
+  `, 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: ChainOfThoughtHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chain-of-thought-header', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      type="button"
+      [attr.aria-expanded]="isOpen"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="toggle()"
+    >
+      <i class="ri-brain-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+      <span class="truncate">{{ label }}</span>
+      <ng-content></ng-content>
+      <i
+        [class]="isOpen ? 'ri-arrow-down-s-line shrink-0' : 'ri-arrow-right-s-line shrink-0'"
+        aria-hidden="true"
+      ></i>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Holds the steps; rendered only while the trace is expanded. */
+export class ChainOfThoughtContentComponent {
+    /**
+     * 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 content via `cn()` (last-wins). */
+    class = '';
+    service = inject(ChainOfThoughtService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    isOpen = false;
+    ngOnInit() {
+        this.sub.add(this.service.open$.subscribe((open) => {
+            this.isOpen = open;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get computedClass() {
+        return cn('mt-2 flex flex-col', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChainOfThoughtContentComponent, isStandalone: true, selector: "tolle-chain-of-thought-content", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div *ngIf="isOpen" data-state="open" [class]="computedClass">
+      <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: ChainOfThoughtContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chain-of-thought-content', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div *ngIf="isOpen" data-state="open" [class]="computedClass">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** One reasoning step: a marker on the rail, a label, and any projected detail. */
+export class ChainOfThoughtStepComponent {
+    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();
+    }
+    /** Text describing what happened in this step. @default '' */
+    label = '';
+    /** Progress of this step; drives the marker colour. @default 'complete' */
+    status = 'complete';
+    /** Remixicon class shown inside the step marker. @default 'ri-checkbox-blank-circle-fill' */
+    icon = 'ri-checkbox-blank-circle-fill';
+    /** Extra Tailwind classes merged onto the step via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn(chainOfThoughtStepVariants({ status: this.status }), this.class);
+    }
+    get markerClass() {
+        return cn(chainOfThoughtMarkerVariants({ status: this.status }));
+    }
+    get labelClass() {
+        return cn('truncate text-sm', this.status === 'active' ? 'font-medium text-foreground' : 'text-muted-foreground');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtStepComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChainOfThoughtStepComponent, isStandalone: true, selector: "tolle-chain-of-thought-step", inputs: { label: "label", status: "status", icon: "icon", class: "class" }, host: { properties: { "class": "computedClass", "attr.data-status": "status" } }, usesOnChanges: true, ngImport: i0, template: `
+    <span class="tolle-cot-rail absolute bottom-0 left-3 top-6 w-px -translate-x-1/2 bg-border" aria-hidden="true"></span>
+    <span [class]="markerClass">
+      <i [class]="icon" aria-hidden="true"></i>
+    </span>
+    <div class="min-w-0 flex-1 pt-0.5">
+      <p [class]="labelClass">{{ label }}</p>
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtStepComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-chain-of-thought-step',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { '[class]': 'computedClass', '[attr.data-status]': 'status' },
+                    template: `
+    <span class="tolle-cot-rail absolute bottom-0 left-3 top-6 w-px -translate-x-1/2 bg-border" aria-hidden="true"></span>
+    <span [class]="markerClass">
+      <i [class]="icon" aria-hidden="true"></i>
+    </span>
+    <div class="min-w-0 flex-1 pt-0.5">
+      <p [class]="labelClass">{{ label }}</p>
+      <ng-content></ng-content>
+    </div>
+  `,
+                }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], status: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Wraps the result chips produced by a search step. */
+export class ChainOfThoughtSearchResultsComponent {
+    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 results row via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtSearchResultsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChainOfThoughtSearchResultsComponent, isStandalone: true, selector: "tolle-chain-of-thought-search-results", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div [class]="cn('mt-1.5 flex flex-wrap items-center gap-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: ChainOfThoughtSearchResultsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chain-of-thought-search-results', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="cn('mt-1.5 flex flex-wrap items-center gap-1', class)"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** A single search result rendered as a small chip. */
+export class ChainOfThoughtSearchResultComponent {
+    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();
+    }
+    /** Optional remixicon class shown before the label. @default '' */
+    icon = '';
+    /** Extra Tailwind classes merged onto the chip via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('inline-flex max-w-full items-center gap-1 truncate rounded-full border border-border bg-muted px-2 py-0.5 text-xs text-muted-foreground', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChainOfThoughtSearchResultComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChainOfThoughtSearchResultComponent, isStandalone: true, selector: "tolle-chain-of-thought-search-result", inputs: { icon: "icon", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <span [class]="computedClass">
+      <i *ngIf="icon" [class]="icon + ' shrink-0'" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </span>
+  `, isInline: true, styles: [":host{display:inline-flex}\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: ChainOfThoughtSearchResultComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chain-of-thought-search-result', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <span [class]="computedClass">
+      <i *ngIf="icon" [class]="icon + ' shrink-0'" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </span>
+  `, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { icon: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chain-of-thought.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/chain-of-thought.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { skip } from 'rxjs/operators';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/** Progress of a single reasoning step. */\nexport type ChainOfThoughtStepStatus = 'pending' | 'active' | 'complete';\n\nconst chainOfThoughtVariants = cva('w-full text-sm', {\n  variants: {\n    size: {\n      sm: 'text-xs',\n      default: 'text-sm',\n    },\n  },\n  defaultVariants: { size: 'default' },\n});\n\nexport type ChainOfThoughtProps = VariantProps<typeof chainOfThoughtVariants>;\n\nconst chainOfThoughtStepVariants = cva(\n  // The rail is hidden on the final step so the line stops at the last marker\n  // instead of trailing off the bottom of the list.\n  'relative flex gap-3 pb-4 last:pb-0 [&:last-child_.tolle-cot-rail]:hidden',\n  {\n    variants: {\n      status: {\n        pending: 'text-muted-foreground',\n        active: 'text-foreground',\n        complete: 'text-muted-foreground',\n      },\n    },\n    defaultVariants: { status: 'complete' },\n  }\n);\n\nconst chainOfThoughtMarkerVariants = cva(\n  'relative z-[1] flex h-6 w-6 shrink-0 items-center justify-center rounded-full border text-[11px]',\n  {\n    variants: {\n      status: {\n        pending: 'border-border bg-background text-muted-foreground',\n        active: 'border-info bg-info/10 text-info',\n        complete: 'border-success/50 bg-success/10 text-success',\n      },\n    },\n    defaultVariants: { status: 'complete' },\n  }\n);\n\nexport type ChainOfThoughtStepProps = VariantProps<typeof chainOfThoughtStepVariants>;\n\n/**\n * Coordinates a `tolle-chain-of-thought` and its header/content children.\n *\n * The children are `OnPush` and receive none of this state as inputs, so it\n * travels as observables and each subscriber calls `markForCheck()`.\n */\n@Injectable()\nexport class ChainOfThoughtService {\n  private readonly openSource = new BehaviorSubject<boolean>(false);\n  /** Emits whether the reasoning trace is expanded. */\n  readonly open$ = this.openSource.asObservable();\n\n  get open(): boolean {\n    return this.openSource.value;\n  }\n\n  setOpen(open: boolean): void {\n    if (this.openSource.value !== open) this.openSource.next(open);\n  }\n\n  toggle(): void {\n    this.openSource.next(!this.openSource.value);\n  }\n}\n\n/**\n * A collapsible reasoning trace — the numbered steps an agent worked through\n * before answering, connected by a vertical rail.\n *\n * ```html\n * <tolle-chain-of-thought [open]=\"true\">\n *   <tolle-chain-of-thought-header label=\"Thought for 4s\"></tolle-chain-of-thought-header>\n *   <tolle-chain-of-thought-content>\n *     <tolle-chain-of-thought-step label=\"Searched the docs\" status=\"complete\" icon=\"ri-search-line\">\n *       <tolle-chain-of-thought-search-results>\n *         <tolle-chain-of-thought-search-result>tailwind.config</tolle-chain-of-thought-search-result>\n *       </tolle-chain-of-thought-search-results>\n *     </tolle-chain-of-thought-step>\n *   </tolle-chain-of-thought-content>\n * </tolle-chain-of-thought>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-chain-of-thought',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [ChainOfThoughtService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"computedClass\"><ng-content></ng-content></div>`,\n})\nexport class ChainOfThoughtComponent implements OnInit, OnChanges, OnDestroy {\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /** Whether the reasoning steps are expanded. @default false */\n  @Input() open = false;\n  /** Text scale of the whole trace. @default 'default' */\n  @Input() size: ChainOfThoughtProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the trace via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new expanded state whenever the trace opens or closes. */\n  @Output() openChange = new EventEmitter<boolean>();\n\n  private readonly service = inject(ChainOfThoughtService);\n  private readonly sub = new Subscription();\n\n  ngOnInit(): void {\n    this.service.setOpen(this.open);\n    // skip(1) drops the replayed initial value so no `openChange` fires on init.\n    this.sub.add(this.service.open$.pipe(skip(1)).subscribe((open) => this.openChange.emit(open)));\n  }\n\n  ngOnChanges(): void {\n    this.service.setOpen(this.open);\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  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(chainOfThoughtVariants({ size: this.size }), this.class);\n  }\n}\n\n/** Clickable header that expands and collapses the reasoning steps. */\n@Component({\n  selector: 'tolle-chain-of-thought-header',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      type=\"button\"\n      [attr.aria-expanded]=\"isOpen\"\n      [attr.data-state]=\"isOpen ? 'open' : 'closed'\"\n      [class]=\"computedClass\"\n      (click)=\"toggle()\"\n    >\n      <i class=\"ri-brain-line shrink-0 text-muted-foreground\" aria-hidden=\"true\"></i>\n      <span class=\"truncate\">{{ label }}</span>\n      <ng-content></ng-content>\n      <i\n        [class]=\"isOpen ? 'ri-arrow-down-s-line shrink-0' : 'ri-arrow-right-s-line shrink-0'\"\n        aria-hidden=\"true\"\n      ></i>\n    </button>\n  `,\n})\nexport class ChainOfThoughtHeaderComponent 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  /** Text shown in the header. @default 'Chain of Thought' */\n  @Input() label = 'Chain of Thought';\n  /** Extra Tailwind classes merged onto the header via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(ChainOfThoughtService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  isOpen = false;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.open$.subscribe((open) => {\n        this.isOpen = open;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(\n      'flex w-full items-center gap-2 rounded-md py-1 text-sm font-medium text-muted-foreground outline-none transition-colors',\n      'hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring',\n      this.class\n    );\n  }\n\n  toggle(): void {\n    this.service.toggle();\n  }\n}\n\n/** Holds the steps; rendered only while the trace is expanded. */\n@Component({\n  selector: 'tolle-chain-of-thought-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div *ngIf=\"isOpen\" data-state=\"open\" [class]=\"computedClass\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class ChainOfThoughtContentComponent 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 content via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(ChainOfThoughtService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  isOpen = false;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.open$.subscribe((open) => {\n        this.isOpen = open;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn('mt-2 flex flex-col', this.class);\n  }\n}\n\n/** One reasoning step: a marker on the rail, a label, and any projected detail. */\n@Component({\n  selector: 'tolle-chain-of-thought-step',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { '[class]': 'computedClass', '[attr.data-status]': 'status' },\n  template: `\n    <span class=\"tolle-cot-rail absolute bottom-0 left-3 top-6 w-px -translate-x-1/2 bg-border\" aria-hidden=\"true\"></span>\n    <span [class]=\"markerClass\">\n      <i [class]=\"icon\" aria-hidden=\"true\"></i>\n    </span>\n    <div class=\"min-w-0 flex-1 pt-0.5\">\n      <p [class]=\"labelClass\">{{ label }}</p>\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class ChainOfThoughtStepComponent  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  /** Text describing what happened in this step. @default '' */\n  @Input() label = '';\n  /** Progress of this step; drives the marker colour. @default 'complete' */\n  @Input() status: ChainOfThoughtStepStatus = 'complete';\n  /** Remixicon class shown inside the step marker. @default 'ri-checkbox-blank-circle-fill' */\n  @Input() icon = 'ri-checkbox-blank-circle-fill';\n  /** Extra Tailwind classes merged onto the step via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(chainOfThoughtStepVariants({ status: this.status }), this.class);\n  }\n\n  get markerClass() {\n    return cn(chainOfThoughtMarkerVariants({ status: this.status }));\n  }\n\n  get labelClass() {\n    return cn('truncate text-sm', this.status === 'active' ? 'font-medium text-foreground' : 'text-muted-foreground');\n  }\n}\n\n/** Wraps the result chips produced by a search step. */\n@Component({\n  selector: 'tolle-chain-of-thought-search-results',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"cn('mt-1.5 flex flex-wrap items-center gap-1', class)\"><ng-content></ng-content></div>`,\n})\nexport class ChainOfThoughtSearchResultsComponent  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 results row via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** A single search result rendered as a small chip. */\n@Component({\n  selector: 'tolle-chain-of-thought-search-result',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <span [class]=\"computedClass\">\n      <i *ngIf=\"icon\" [class]=\"icon + ' shrink-0'\" aria-hidden=\"true\"></i>\n      <ng-content></ng-content>\n    </span>\n  `,\n})\nexport class ChainOfThoughtSearchResultComponent  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  /** Optional remixicon class shown before the label. @default '' */\n  @Input() icon = '';\n  /** Extra Tailwind classes merged onto the chip via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(\n      'inline-flex max-w-full items-center gap-1 truncate rounded-full border border-border bg-muted px-2 py-0.5 text-xs text-muted-foreground',\n      this.class\n    );\n  }\n}\n"]}