@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/tool.component.mjs

@@ -0,0 +1,462 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Directive, 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 toolStateVariants = cva('inline-flex shrink-0 items-center gap-1 rounded-full px-2 py-0.5 text-xs font-medium', {
+    variants: {
+        state: {
+            pending: 'bg-muted text-muted-foreground',
+            running: 'bg-info/10 text-info',
+            success: 'bg-success/10 text-success',
+            error: 'bg-destructive/10 text-destructive',
+        },
+    },
+    defaultVariants: {
+        state: 'pending',
+    },
+});
+/** Remixicon class shown in the state chip for each state. */
+const TOOL_STATE_ICONS = {
+    pending: 'ri-time-line',
+    running: 'ri-loader-4-line animate-spin',
+    success: 'ri-check-line',
+    error: 'ri-error-warning-line',
+};
+/** Default chip text for each state. */
+const TOOL_STATE_LABELS = {
+    pending: 'Pending',
+    running: 'Running',
+    success: 'Completed',
+    error: 'Error',
+};
+/**
+ * Coordinates a `tolle-tool` with its header, input and output.
+ *
+ * Header/input/output are OnPush siblings projected into the tool, so the
+ * shared open + state they render from is published here.
+ *
+ * Provided on `ToolComponent`, so each tool call gets its own instance.
+ */
+export class ToolService {
+    openSource = new BehaviorSubject(false);
+    /** Emits whether the tool call is expanded. */
+    open$ = this.openSource.asObservable();
+    stateSource = new BehaviorSubject('pending');
+    /** Emits the tool call's lifecycle state. */
+    state$ = this.stateSource.asObservable();
+    /** True while the tool call is expanded. */
+    get open() {
+        return this.openSource.value;
+    }
+    /** The tool call's current state. */
+    get state() {
+        return this.stateSource.value;
+    }
+    setOpen(value) {
+        if (this.openSource.value !== value)
+            this.openSource.next(value);
+    }
+    toggle() {
+        this.setOpen(!this.openSource.value);
+    }
+    setState(state) {
+        if (this.stateSource.value !== state)
+            this.stateSource.next(state);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolService, decorators: [{
+            type: Injectable
+        }] });
+const toolVariants = cva('w-full overflow-hidden rounded-md border bg-card text-card-foreground', {
+    variants: {
+        state: {
+            pending: 'border-border',
+            running: 'border-info/40',
+            success: 'border-border',
+            error: 'border-destructive/40',
+        },
+    },
+    defaultVariants: {
+        state: 'pending',
+    },
+});
+/**
+ * A collapsible record of one tool/function call: what was invoked, the
+ * arguments it received and the result it returned.
+ *
+ * Compose it from `tolle-tool-header`, `tolle-tool-input` and
+ * `tolle-tool-output`.
+ * @new
+ */
+export class ToolComponent {
+    /** Lifecycle of the call, driving the header chip and border. @default 'pending' */
+    state = 'pending';
+    /** Whether the call's input and output are expanded. @default false */
+    open = false;
+    /** Extra Tailwind classes merged onto the tool via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new state whenever the call is expanded or collapsed. */
+    openChange = new EventEmitter();
+    service = inject(ToolService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    /** True while an `open` input is being pushed into the service. */
+    applyingInput = false;
+    ngOnInit() {
+        this.service.setOpen(this.open);
+        this.service.setState(this.state);
+        // `skip(1)` drops the BehaviorSubject's current value so mounting never
+        // emits a spurious `openChange`.
+        this.subscriptions.add(this.service.open$.pipe(skip(1)).subscribe((open) => {
+            this.open = open;
+            this.cdr.markForCheck();
+            // Only user-driven toggles are worth reporting; echoing a change the
+            // parent just made would fight a `[(open)]` binding.
+            if (!this.applyingInput)
+                this.openChange.emit(open);
+        }));
+    }
+    ngOnChanges(changes) {
+        if (changes['open'])
+            this.applyInput(this.open);
+        this.service.setState(this.state);
+        // 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();
+    }
+    applyInput(open) {
+        this.applyingInput = true;
+        try {
+            this.service.setOpen(open);
+        }
+        finally {
+            this.applyingInput = false;
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn(toolVariants({ state: this.state }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ToolComponent, isStandalone: true, selector: "tolle-tool", inputs: { state: "state", open: "open", class: "class" }, outputs: { openChange: "openChange" }, providers: [ToolService], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass" [attr.data-state]="open ? 'open' : 'closed'">
+      <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: ToolComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-tool', standalone: true, imports: [CommonModule], providers: [ToolService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass" [attr.data-state]="open ? 'open' : 'closed'">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { state: [{
+                type: Input
+            }], open: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+/** Clickable header of a `tolle-tool`: the tool's name plus its state chip. */
+export class ToolHeaderComponent {
+    /**
+     * 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();
+    }
+    /** Name of the tool that was called. @default '' */
+    name = '';
+    /** Remixicon class shown before the tool name. @default 'ri-tools-line' */
+    icon = 'ri-tools-line';
+    /** Overrides the chip text; defaults to a label derived from the state. @default '' */
+    stateLabelOverride = '';
+    /** Extra Tailwind classes merged onto the header via `cn()` (last-wins). */
+    class = '';
+    /** Extra Tailwind classes merged onto the state chip via `cn()` (last-wins). */
+    chipClassName = '';
+    service = inject(ToolService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    open = false;
+    state = 'pending';
+    ngOnInit() {
+        this.subscriptions.add(this.service.open$.subscribe((open) => {
+            this.open = open;
+            this.cdr.markForCheck();
+        }));
+        this.subscriptions.add(this.service.state$.subscribe((state) => {
+            this.state = state;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get stateIcon() {
+        return TOOL_STATE_ICONS[this.state];
+    }
+    get stateLabel() {
+        return this.stateLabelOverride || TOOL_STATE_LABELS[this.state];
+    }
+    get chipClass() {
+        return cn(toolStateVariants({ state: this.state }), this.chipClassName);
+    }
+    get computedClass() {
+        return cn('flex w-full items-center gap-2 px-3 py-2 text-left text-sm transition-colors', 'hover:bg-accent/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring', this.class);
+    }
+    onToggle() {
+        this.service.toggle();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ToolHeaderComponent, isStandalone: true, selector: "tolle-tool-header", inputs: { name: "name", icon: "icon", stateLabelOverride: "stateLabelOverride", class: "class", chipClassName: "chipClassName" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      type="button"
+      data-tool-header
+      [attr.aria-expanded]="open"
+      [attr.data-state]="open ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onToggle()"
+    >
+      <i [class]="icon" class="shrink-0 text-muted-foreground" aria-hidden="true"></i>
+
+      <span class="truncate font-medium text-foreground" data-tool-name>{{ name }}</span>
+
+      <span [class]="chipClass" data-tool-state>
+        <i [class]="stateIcon" aria-hidden="true"></i>
+        {{ stateLabel }}
+      </span>
+
+      <i
+        class="ri-arrow-down-s-line shrink-0 text-muted-foreground transition-transform duration-200"
+        [class.rotate-180]="open"
+        aria-hidden="true"
+      ></i>
+
+      <ng-content></ng-content>
+    </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: ToolHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-tool-header', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      type="button"
+      data-tool-header
+      [attr.aria-expanded]="open"
+      [attr.data-state]="open ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onToggle()"
+    >
+      <i [class]="icon" class="shrink-0 text-muted-foreground" aria-hidden="true"></i>
+
+      <span class="truncate font-medium text-foreground" data-tool-name>{{ name }}</span>
+
+      <span [class]="chipClass" data-tool-state>
+        <i [class]="stateIcon" aria-hidden="true"></i>
+        {{ stateLabel }}
+      </span>
+
+      <i
+        class="ri-arrow-down-s-line shrink-0 text-muted-foreground transition-transform duration-200"
+        [class.rotate-180]="open"
+        aria-hidden="true"
+      ></i>
+
+      <ng-content></ng-content>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { name: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], stateLabelOverride: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], chipClassName: [{
+                type: Input
+            }] } });
+/**
+ * Base for the two payload panels. Owns the shared "visible only while the
+ * tool is expanded" wiring and the payload-to-text formatting.
+ *
+ * Decorated with a selector-less `@Directive()` because it uses Angular
+ * features (DI and lifecycle hooks) on behalf of its subclasses.
+ */
+export class ToolPayloadBase {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook subclasses keep
+     * rendering the class they were born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Payload to render; objects are pretty-printed as JSON, strings are shown as-is. */
+    payload = null;
+    service = inject(ToolService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    open = false;
+    ngOnInit() {
+        this.subscriptions.add(this.service.open$.subscribe((open) => {
+            this.open = open;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** True once there is a payload worth rendering. */
+    get hasPayload() {
+        return this.payload !== null && this.payload !== undefined && this.payload !== '';
+    }
+    /** The payload as display text. Falls back to `String()` for cyclic values. */
+    get formatted() {
+        if (typeof this.payload === 'string')
+            return this.payload;
+        try {
+            return JSON.stringify(this.payload, null, 2) ?? String(this.payload);
+        }
+        catch {
+            return String(this.payload);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolPayloadBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ToolPayloadBase, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolPayloadBase, decorators: [{
+            type: Directive
+        }] });
+/** Arguments the tool was called with. Visible while the `tolle-tool` is expanded. */
+export class ToolInputComponent extends ToolPayloadBase {
+    /** Arguments passed to the tool; objects are pretty-printed as JSON. @default null */
+    payload = null;
+    /** Heading above the payload. @default 'Parameters' */
+    label = 'Parameters';
+    /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('flex flex-col gap-1.5 border-t border-border px-3 py-2', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolInputComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ToolInputComponent, isStandalone: true, selector: "tolle-tool-input", inputs: { payload: "payload", label: "label", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <div *ngIf="open" data-tool-input [class]="computedClass">
+      <p *ngIf="label" class="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+        {{ label }}
+      </p>
+
+      <pre
+        *ngIf="hasPayload; else projected"
+        class="max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground"
+      >{{ formatted }}</pre>
+
+      <ng-template #projected>
+        <div class="max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground">
+          <ng-content></ng-content>
+        </div>
+      </ng-template>
+    </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: ToolInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-tool-input', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div *ngIf="open" data-tool-input [class]="computedClass">
+      <p *ngIf="label" class="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+        {{ label }}
+      </p>
+
+      <pre
+        *ngIf="hasPayload; else projected"
+        class="max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground"
+      >{{ formatted }}</pre>
+
+      <ng-template #projected>
+        <div class="max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground">
+          <ng-content></ng-content>
+        </div>
+      </ng-template>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { payload: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Result the tool returned. Visible while the `tolle-tool` is expanded. */
+export class ToolOutputComponent extends ToolPayloadBase {
+    /** Result returned by the tool; objects are pretty-printed as JSON. @default null */
+    payload = null;
+    /** Heading above the payload. @default 'Result' */
+    label = 'Result';
+    /** Styles the payload as a failure. @default false */
+    error = false;
+    /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */
+    class = '';
+    get payloadClass() {
+        return cn('max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground', this.error && 'bg-destructive/10 text-destructive');
+    }
+    get computedClass() {
+        return cn('flex flex-col gap-1.5 border-t border-border px-3 py-2', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolOutputComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ToolOutputComponent, isStandalone: true, selector: "tolle-tool-output", inputs: { payload: "payload", label: "label", error: "error", class: "class" }, usesInheritance: true, ngImport: i0, template: `
+    <div *ngIf="open" data-tool-output [class]="computedClass">
+      <p *ngIf="label" class="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+        {{ label }}
+      </p>
+
+      <pre *ngIf="hasPayload; else projected" [class]="payloadClass">{{ formatted }}</pre>
+
+      <ng-template #projected>
+        <div [class]="payloadClass">
+          <ng-content></ng-content>
+        </div>
+      </ng-template>
+    </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: ToolOutputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-tool-output', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div *ngIf="open" data-tool-output [class]="computedClass">
+      <p *ngIf="label" class="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+        {{ label }}
+      </p>
+
+      <pre *ngIf="hasPayload; else projected" [class]="payloadClass">{{ formatted }}</pre>
+
+      <ng-template #projected>
+        <div [class]="payloadClass">
+          <ng-content></ng-content>
+        </div>
+      </ng-template>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { payload: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/tool.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Directive, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, 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\nconst toolStateVariants = cva(\n  'inline-flex shrink-0 items-center gap-1 rounded-full px-2 py-0.5 text-xs font-medium',\n  {\n    variants: {\n      state: {\n        pending: 'bg-muted text-muted-foreground',\n        running: 'bg-info/10 text-info',\n        success: 'bg-success/10 text-success',\n        error: 'bg-destructive/10 text-destructive',\n      },\n    },\n    defaultVariants: {\n      state: 'pending',\n    },\n  }\n);\n\nexport type ToolStateProps = VariantProps<typeof toolStateVariants>;\n\n/** Lifecycle of a tool call. */\nexport type ToolState = NonNullable<ToolStateProps['state']>;\n\n/** Remixicon class shown in the state chip for each state. */\nconst TOOL_STATE_ICONS: Record<ToolState, string> = {\n  pending: 'ri-time-line',\n  running: 'ri-loader-4-line animate-spin',\n  success: 'ri-check-line',\n  error: 'ri-error-warning-line',\n};\n\n/** Default chip text for each state. */\nconst TOOL_STATE_LABELS: Record<ToolState, string> = {\n  pending: 'Pending',\n  running: 'Running',\n  success: 'Completed',\n  error: 'Error',\n};\n\n/**\n * Coordinates a `tolle-tool` with its header, input and output.\n *\n * Header/input/output are OnPush siblings projected into the tool, so the\n * shared open + state they render from is published here.\n *\n * Provided on `ToolComponent`, so each tool call gets its own instance.\n */\n@Injectable()\nexport class ToolService {\n  private readonly openSource = new BehaviorSubject<boolean>(false);\n  /** Emits whether the tool call is expanded. */\n  readonly open$ = this.openSource.asObservable();\n\n  private readonly stateSource = new BehaviorSubject<ToolState>('pending');\n  /** Emits the tool call's lifecycle state. */\n  readonly state$ = this.stateSource.asObservable();\n\n  /** True while the tool call is expanded. */\n  get open(): boolean {\n    return this.openSource.value;\n  }\n\n  /** The tool call's current state. */\n  get state(): ToolState {\n    return this.stateSource.value;\n  }\n\n  setOpen(value: boolean): void {\n    if (this.openSource.value !== value) this.openSource.next(value);\n  }\n\n  toggle(): void {\n    this.setOpen(!this.openSource.value);\n  }\n\n  setState(state: ToolState): void {\n    if (this.stateSource.value !== state) this.stateSource.next(state);\n  }\n}\n\nconst toolVariants = cva('w-full overflow-hidden rounded-md border bg-card text-card-foreground', {\n  variants: {\n    state: {\n      pending: 'border-border',\n      running: 'border-info/40',\n      success: 'border-border',\n      error: 'border-destructive/40',\n    },\n  },\n  defaultVariants: {\n    state: 'pending',\n  },\n});\n\nexport type ToolProps = VariantProps<typeof toolVariants>;\n\n/**\n * A collapsible record of one tool/function call: what was invoked, the\n * arguments it received and the result it returned.\n *\n * Compose it from `tolle-tool-header`, `tolle-tool-input` and\n * `tolle-tool-output`.\n * @new\n */\n@Component({\n  selector: 'tolle-tool',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [ToolService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\" [attr.data-state]=\"open ? 'open' : 'closed'\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class ToolComponent implements OnInit, OnChanges, OnDestroy {\n  /** Lifecycle of the call, driving the header chip and border. @default 'pending' */\n  @Input() state: ToolState = 'pending';\n  /** Whether the call's input and output are expanded. @default false */\n  @Input() open = false;\n  /** Extra Tailwind classes merged onto the tool via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new state whenever the call is expanded or collapsed. */\n  @Output() openChange = new EventEmitter<boolean>();\n\n  private readonly service = inject(ToolService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n  /** True while an `open` input is being pushed into the service. */\n  private applyingInput = false;\n\n  ngOnInit(): void {\n    this.service.setOpen(this.open);\n    this.service.setState(this.state);\n    // `skip(1)` drops the BehaviorSubject's current value so mounting never\n    // emits a spurious `openChange`.\n    this.subscriptions.add(\n      this.service.open$.pipe(skip(1)).subscribe((open) => {\n        this.open = open;\n        this.cdr.markForCheck();\n        // Only user-driven toggles are worth reporting; echoing a change the\n        // parent just made would fight a `[(open)]` binding.\n        if (!this.applyingInput) this.openChange.emit(open);\n      })\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['open']) this.applyInput(this.open);\n    this.service.setState(this.state);\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  private applyInput(open: boolean): void {\n    this.applyingInput = true;\n    try {\n      this.service.setOpen(open);\n    } finally {\n      this.applyingInput = false;\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(toolVariants({ state: this.state }), this.class);\n  }\n}\n\n/** Clickable header of a `tolle-tool`: the tool's name plus its state chip. */\n@Component({\n  selector: 'tolle-tool-header',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      type=\"button\"\n      data-tool-header\n      [attr.aria-expanded]=\"open\"\n      [attr.data-state]=\"open ? 'open' : 'closed'\"\n      [class]=\"computedClass\"\n      (click)=\"onToggle()\"\n    >\n      <i [class]=\"icon\" class=\"shrink-0 text-muted-foreground\" aria-hidden=\"true\"></i>\n\n      <span class=\"truncate font-medium text-foreground\" data-tool-name>{{ name }}</span>\n\n      <span [class]=\"chipClass\" data-tool-state>\n        <i [class]=\"stateIcon\" aria-hidden=\"true\"></i>\n        {{ stateLabel }}\n      </span>\n\n      <i\n        class=\"ri-arrow-down-s-line shrink-0 text-muted-foreground transition-transform duration-200\"\n        [class.rotate-180]=\"open\"\n        aria-hidden=\"true\"\n      ></i>\n\n      <ng-content></ng-content>\n    </button>\n  `,\n})\nexport class ToolHeaderComponent 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  /** Name of the tool that was called. @default '' */\n  @Input() name = '';\n  /** Remixicon class shown before the tool name. @default 'ri-tools-line' */\n  @Input() icon = 'ri-tools-line';\n  /** Overrides the chip text; defaults to a label derived from the state. @default '' */\n  @Input() stateLabelOverride = '';\n  /** Extra Tailwind classes merged onto the header via `cn()` (last-wins). */\n  @Input() class = '';\n  /** Extra Tailwind classes merged onto the state chip via `cn()` (last-wins). */\n  @Input() chipClassName = '';\n\n  private readonly service = inject(ToolService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  open = false;\n  state: ToolState = 'pending';\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.open$.subscribe((open) => {\n        this.open = open;\n        this.cdr.markForCheck();\n      })\n    );\n    this.subscriptions.add(\n      this.service.state$.subscribe((state) => {\n        this.state = state;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get stateIcon(): string {\n    return TOOL_STATE_ICONS[this.state];\n  }\n\n  get stateLabel(): string {\n    return this.stateLabelOverride || TOOL_STATE_LABELS[this.state];\n  }\n\n  get chipClass() {\n    return cn(toolStateVariants({ state: this.state }), this.chipClassName);\n  }\n\n  get computedClass() {\n    return cn(\n      'flex w-full items-center gap-2 px-3 py-2 text-left text-sm transition-colors',\n      'hover:bg-accent/50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring',\n      this.class\n    );\n  }\n\n  onToggle(): void {\n    this.service.toggle();\n  }\n}\n\n/**\n * Base for the two payload panels. Owns the shared \"visible only while the\n * tool is expanded\" wiring and the payload-to-text formatting.\n *\n * Decorated with a selector-less `@Directive()` because it uses Angular\n * features (DI and lifecycle hooks) on behalf of its subclasses.\n */\n@Directive()\nexport abstract class ToolPayloadBase 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 subclasses keep\n   * rendering the class they were born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Payload to render; objects are pretty-printed as JSON, strings are shown as-is. */\n  payload: unknown = null;\n\n  protected readonly service = inject(ToolService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  open = false;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.open$.subscribe((open) => {\n        this.open = open;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** True once there is a payload worth rendering. */\n  get hasPayload(): boolean {\n    return this.payload !== null && this.payload !== undefined && this.payload !== '';\n  }\n\n  /** The payload as display text. Falls back to `String()` for cyclic values. */\n  get formatted(): string {\n    if (typeof this.payload === 'string') return this.payload;\n    try {\n      return JSON.stringify(this.payload, null, 2) ?? String(this.payload);\n    } catch {\n      return String(this.payload);\n    }\n  }\n}\n\n/** Arguments the tool was called with. Visible while the `tolle-tool` is expanded. */\n@Component({\n  selector: 'tolle-tool-input',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div *ngIf=\"open\" data-tool-input [class]=\"computedClass\">\n      <p *ngIf=\"label\" class=\"text-xs font-medium uppercase tracking-wide text-muted-foreground\">\n        {{ label }}\n      </p>\n\n      <pre\n        *ngIf=\"hasPayload; else projected\"\n        class=\"max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground\"\n      >{{ formatted }}</pre>\n\n      <ng-template #projected>\n        <div class=\"max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground\">\n          <ng-content></ng-content>\n        </div>\n      </ng-template>\n    </div>\n  `,\n})\nexport class ToolInputComponent extends ToolPayloadBase {\n  /** Arguments passed to the tool; objects are pretty-printed as JSON. @default null */\n  @Input() override payload: unknown = null;\n  /** Heading above the payload. @default 'Parameters' */\n  @Input() label = 'Parameters';\n  /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn('flex flex-col gap-1.5 border-t border-border px-3 py-2', this.class);\n  }\n}\n\n/** Result the tool returned. Visible while the `tolle-tool` is expanded. */\n@Component({\n  selector: 'tolle-tool-output',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div *ngIf=\"open\" data-tool-output [class]=\"computedClass\">\n      <p *ngIf=\"label\" class=\"text-xs font-medium uppercase tracking-wide text-muted-foreground\">\n        {{ label }}\n      </p>\n\n      <pre *ngIf=\"hasPayload; else projected\" [class]=\"payloadClass\">{{ formatted }}</pre>\n\n      <ng-template #projected>\n        <div [class]=\"payloadClass\">\n          <ng-content></ng-content>\n        </div>\n      </ng-template>\n    </div>\n  `,\n})\nexport class ToolOutputComponent extends ToolPayloadBase {\n  /** Result returned by the tool; objects are pretty-printed as JSON. @default null */\n  @Input() override payload: unknown = null;\n  /** Heading above the payload. @default 'Result' */\n  @Input() label = 'Result';\n  /** Styles the payload as a failure. @default false */\n  @Input() error = false;\n  /** Extra Tailwind classes merged onto the panel via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get payloadClass() {\n    return cn(\n      'max-h-64 overflow-auto rounded-md bg-muted p-3 font-mono text-xs text-foreground',\n      this.error && 'bg-destructive/10 text-destructive'\n    );\n  }\n\n  get computedClass() {\n    return cn('flex flex-col gap-1.5 border-t border-border px-3 py-2', this.class);\n  }\n}\n"]}

package/esm2022/lib/typography.component.mjs

@@ -0,0 +1,83 @@
+import { Component, Input, ChangeDetectionStrategy, 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 typographyVariants = cva('', {
+    variants: {
+        variant: {
+            h1: 'scroll-m-20 text-4xl font-extrabold tracking-tight lg:text-5xl',
+            h2: 'scroll-m-20 border-b border-border pb-2 text-3xl font-semibold tracking-tight first:mt-0',
+            h3: 'scroll-m-20 text-2xl font-semibold tracking-tight',
+            h4: 'scroll-m-20 text-xl font-semibold tracking-tight',
+            p: 'leading-7 [&:not(:first-child)]:mt-6',
+            blockquote: 'mt-6 border-l-2 border-border pl-6 italic',
+            lead: 'text-xl text-muted-foreground',
+            large: 'text-lg font-semibold',
+            small: 'text-sm font-medium leading-none',
+            muted: 'text-sm text-muted-foreground',
+            code: 'relative rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-sm font-semibold',
+        },
+    },
+    defaultVariants: { variant: 'p' },
+});
+/**
+ * Applies the theme's type scale to projected content. Renders the semantically
+ * correct host tag for the chosen `variant` (`h1`–`h4`, `blockquote`, `code`,
+ * otherwise `p`), so headings stay real headings for assistive tech.
+ * @new
+ */
+export class TypographyComponent {
+    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();
+    }
+    /** Type scale step; also selects the rendered HTML tag. @default 'p' */
+    variant = 'p';
+    /** Extra Tailwind classes merged onto the element via `cn()` (last-wins). */
+    class = '';
+    /** True for the variants that have no dedicated tag and render as `<p>`. */
+    get isParagraph() {
+        return !['h1', 'h2', 'h3', 'h4', 'blockquote', 'code'].includes(this.variant ?? 'p');
+    }
+    get computedClass() {
+        return cn(typographyVariants({ variant: this.variant }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TypographyComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TypographyComponent, isStandalone: true, selector: "tolle-typography", inputs: { variant: "variant", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <ng-template #body><ng-content></ng-content></ng-template>
+
+    <h1 *ngIf="variant === 'h1'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h1>
+    <h2 *ngIf="variant === 'h2'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h2>
+    <h3 *ngIf="variant === 'h3'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h3>
+    <h4 *ngIf="variant === 'h4'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h4>
+    <blockquote *ngIf="variant === 'blockquote'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></blockquote>
+    <code *ngIf="variant === 'code'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></code>
+    <p *ngIf="isParagraph" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></p>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TypographyComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-typography', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <ng-template #body><ng-content></ng-content></ng-template>
+
+    <h1 *ngIf="variant === 'h1'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h1>
+    <h2 *ngIf="variant === 'h2'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h2>
+    <h3 *ngIf="variant === 'h3'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h3>
+    <h4 *ngIf="variant === 'h4'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></h4>
+    <blockquote *ngIf="variant === 'blockquote'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></blockquote>
+    <code *ngIf="variant === 'code'" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></code>
+    <p *ngIf="isParagraph" [class]="computedClass"><ng-container *ngTemplateOutlet="body"></ng-container></p>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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