@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/aspect-ratio.component.mjs

@@ -0,0 +1,119 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AspectRatioComponent {
+    cdr;
+    ratio = '16 / 9';
+    class = '';
+    container;
+    isLoading = true;
+    hasError = false;
+    cleanupListeners = [];
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    ngAfterViewInit() {
+        const el = this.container.nativeElement;
+        // Use capture phase because load/error do not bubble
+        const onLoad = (event) => {
+            // Check if the event target is inside our container
+            if (el.contains(event.target)) {
+                this.onLoad();
+            }
+        };
+        const onError = (event) => {
+            if (el.contains(event.target)) {
+                this.onError();
+            }
+        };
+        el.addEventListener('load', onLoad, true);
+        el.addEventListener('error', onError, true);
+        this.cleanupListeners.push(() => {
+            el.removeEventListener('load', onLoad, true);
+            el.removeEventListener('error', onError, true);
+        });
+        // Check if there are even any media elements. If not, don't show loader.
+        // Or if images were already cached/loaded before AfterViewInit
+        setTimeout(() => {
+            const media = el.querySelectorAll('img, video, iframe');
+            if (media.length === 0) {
+                this.onLoad();
+            }
+            else {
+                // Double check if all images are already complete (cached)
+                const allComplete = Array.from(media).every(m => {
+                    if (m instanceof HTMLImageElement)
+                        return m.complete;
+                    return false; // For video/iframe we wait for event
+                });
+                if (allComplete) {
+                    this.onLoad();
+                }
+            }
+        }, 50);
+    }
+    onLoad() {
+        this.isLoading = false;
+        this.hasError = false;
+        this.cdr.detectChanges();
+    }
+    onError() {
+        this.isLoading = false;
+        this.hasError = true;
+        this.cdr.detectChanges();
+    }
+    ngOnDestroy() {
+        this.cleanupListeners.forEach(cleanup => cleanup());
+    }
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AspectRatioComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AspectRatioComponent, isStandalone: true, selector: "tolle-aspect-ratio", inputs: { ratio: "ratio", class: "class" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], ngImport: i0, template: `
+    <div
+      #container
+      [class]="cn('relative w-full overflow-hidden bg-muted/20', class)"
+      [style.aspect-ratio]="ratio"
+    >
+      <div *ngIf="isLoading && !hasError" class="absolute inset-0 z-10 animate-pulse bg-muted flex items-center justify-center">
+        <i class="ri-image-line text-muted-foreground/40 text-3xl"></i>
+      </div>
+
+      <div *ngIf="hasError" class="absolute inset-0 z-20 bg-secondary flex flex-col items-center justify-center gap-2">
+        <i class="ri-image-warning-line text-destructive text-2xl"></i>
+        <span class="text-[10px] font-medium uppercase tracking-wider text-muted-foreground">Failed to load</span>
+      </div>
+
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block;width:100%}:host ::ng-deep img,:host ::ng-deep video,:host ::ng-deep iframe{position:absolute;height:100%;width:100%;inset:0;object-fit:cover;transition:opacity .3s ease-in-out}:host ::ng-deep .aspect-ratio-content{position:absolute;inset:0;display:flex;align-items:center;justify-content:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AspectRatioComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-aspect-ratio', standalone: true, imports: [CommonModule], template: `
+    <div
+      #container
+      [class]="cn('relative w-full overflow-hidden bg-muted/20', class)"
+      [style.aspect-ratio]="ratio"
+    >
+      <div *ngIf="isLoading && !hasError" class="absolute inset-0 z-10 animate-pulse bg-muted flex items-center justify-center">
+        <i class="ri-image-line text-muted-foreground/40 text-3xl"></i>
+      </div>
+
+      <div *ngIf="hasError" class="absolute inset-0 z-20 bg-secondary flex flex-col items-center justify-center gap-2">
+        <i class="ri-image-warning-line text-destructive text-2xl"></i>
+        <span class="text-[10px] font-medium uppercase tracking-wider text-muted-foreground">Failed to load</span>
+      </div>
+
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block;width:100%}:host ::ng-deep img,:host ::ng-deep video,:host ::ng-deep iframe{position:absolute;height:100%;width:100%;inset:0;object-fit:cover;transition:opacity .3s ease-in-out}:host ::ng-deep .aspect-ratio-content{position:absolute;inset:0;display:flex;align-items:center;justify-content:center}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { ratio: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aspect-ratio.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/aspect-ratio.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ViewChild, ElementRef, AfterViewInit, OnDestroy, ChangeDetectorRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cn } from './utils/cn';\n\n@Component({\n  selector: 'tolle-aspect-ratio',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      #container\n      [class]=\"cn('relative w-full overflow-hidden bg-muted/20', class)\"\n      [style.aspect-ratio]=\"ratio\"\n    >\n      <div *ngIf=\"isLoading && !hasError\" class=\"absolute inset-0 z-10 animate-pulse bg-muted flex items-center justify-center\">\n        <i class=\"ri-image-line text-muted-foreground/40 text-3xl\"></i>\n      </div>\n\n      <div *ngIf=\"hasError\" class=\"absolute inset-0 z-20 bg-secondary flex flex-col items-center justify-center gap-2\">\n        <i class=\"ri-image-warning-line text-destructive text-2xl\"></i>\n        <span class=\"text-[10px] font-medium uppercase tracking-wider text-muted-foreground\">Failed to load</span>\n      </div>\n\n      <ng-content></ng-content>\n    </div>\n  `,\n  styles: [`\n    :host {\n      display: block;\n      width: 100%;\n    }\n\n    /* Target elements projected into the ng-content */\n    :host ::ng-deep img,\n    :host ::ng-deep video,\n    :host ::ng-deep iframe {\n      position: absolute;\n      height: 100%;\n      width: 100%;\n      inset: 0;\n      object-fit: cover;\n      transition: opacity 0.3s ease-in-out;\n    }\n\n    /* Target direct div wrappers if needed */\n    :host ::ng-deep .aspect-ratio-content {\n      position: absolute;\n      inset: 0;\n      display: flex;\n      align-items: center;\n      justify-content: center;\n    }\n  `]\n})\nexport class AspectRatioComponent implements AfterViewInit, OnDestroy {\n  @Input() ratio: string | number = '16 / 9';\n  @Input() class: string = '';\n\n  @ViewChild('container') container!: ElementRef<HTMLElement>;\n\n  isLoading = true;\n  hasError = false;\n\n  private cleanupListeners: (() => void)[] = [];\n\n  constructor(private cdr: ChangeDetectorRef) { }\n\n  ngAfterViewInit() {\n    const el = this.container.nativeElement;\n\n    // Use capture phase because load/error do not bubble\n    const onLoad = (event: Event) => {\n      // Check if the event target is inside our container\n      if (el.contains(event.target as Node)) {\n        this.onLoad();\n      }\n    };\n\n    const onError = (event: Event) => {\n      if (el.contains(event.target as Node)) {\n        this.onError();\n      }\n    };\n\n    el.addEventListener('load', onLoad, true);\n    el.addEventListener('error', onError, true);\n\n    this.cleanupListeners.push(() => {\n      el.removeEventListener('load', onLoad, true);\n      el.removeEventListener('error', onError, true);\n    });\n\n    // Check if there are even any media elements. If not, don't show loader.\n    // Or if images were already cached/loaded before AfterViewInit\n    setTimeout(() => {\n      const media = el.querySelectorAll('img, video, iframe');\n      if (media.length === 0) {\n        this.onLoad();\n      } else {\n        // Double check if all images are already complete (cached)\n        const allComplete = Array.from(media).every(m => {\n          if (m instanceof HTMLImageElement) return m.complete;\n          return false; // For video/iframe we wait for event\n        });\n        if (allComplete) {\n          this.onLoad();\n        }\n      }\n    }, 50);\n  }\n\n  onLoad() {\n    this.isLoading = false;\n    this.hasError = false;\n    this.cdr.detectChanges();\n  }\n\n  onError() {\n    this.isLoading = false;\n    this.hasError = true;\n    this.cdr.detectChanges();\n  }\n\n  ngOnDestroy() {\n    this.cleanupListeners.forEach(cleanup => cleanup());\n  }\n\n  protected cn = cn;\n}\n"]}

package/esm2022/lib/attachment.component.mjs

@@ -0,0 +1,334 @@
+import { Component, Input, Output, EventEmitter, 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 attachmentVariants = cva('group/attachment relative flex w-full max-w-xs items-center gap-3 overflow-hidden rounded-lg border text-left transition-colors outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2', {
+    variants: {
+        state: {
+            idle: 'border-border bg-card text-card-foreground hover:bg-accent',
+            uploading: 'border-border bg-card text-card-foreground',
+            error: 'border-destructive bg-destructive/10 text-foreground',
+        },
+        size: {
+            sm: 'gap-2 p-1.5 text-xs',
+            default: 'gap-3 p-2 text-sm',
+        },
+    },
+    defaultVariants: { state: 'idle', size: 'default' },
+});
+/**
+ * A file or image attached to a chat message, with an upload state and an
+ * optional progress bar. Wrap several in `tolle-attachment-group`.
+ * @new
+ */
+export class AttachmentComponent {
+    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();
+    }
+    /** File name shown as the card's title. */
+    name = '';
+    /** File size in bytes; rendered as B / KB / MB. @default 0 */
+    size = 0;
+    /** MIME type, e.g. 'image/png'. Chooses the thumbnail or the file icon. */
+    type = '';
+    /** Source for the thumbnail and the target of `open`. */
+    url = '';
+    /** Upload lifecycle state of the attachment. @default 'idle' */
+    state = 'idle';
+    /** Upload progress from 0 to 100; only shown while uploading. @default 0 */
+    progress = 0;
+    /** Density of the card. @default 'default' */
+    density = 'default';
+    /** Shows a trailing remove button that emits `remove`. @default false */
+    removable = false;
+    /** Accessible label for the remove button. @default 'Remove attachment' */
+    removeLabel = 'Remove attachment';
+    /** Text shown in place of the size when the state is 'error'. @default 'Upload failed' */
+    errorLabel = 'Upload failed';
+    /** Extra Tailwind classes merged onto the card via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when the remove button is pressed. */
+    remove = new EventEmitter();
+    /** Emitted when the card is activated by click, Enter, or Space. */
+    open = new EventEmitter();
+    get computedClass() {
+        return cn(attachmentVariants({ state: this.state, size: this.density }), this.class);
+    }
+    /** Whether the attachment renders as an image thumbnail rather than a file icon. */
+    get isImage() {
+        return this.type.startsWith('image/') && !!this.url;
+    }
+    /** Remixicon class picked from the MIME type. */
+    get iconClass() {
+        return this.iconForType(this.type);
+    }
+    /** The `size` input rendered for display, e.g. 1536 becomes "1.5 KB". */
+    get formattedSize() {
+        return this.formatBytes(this.size);
+    }
+    /** `progress` constrained to the 0-100 the progress bar can render. */
+    get clampedProgress() {
+        if (!Number.isFinite(this.progress))
+            return 0;
+        return Math.min(100, Math.max(0, this.progress));
+    }
+    formatBytes(bytes) {
+        if (!Number.isFinite(bytes) || bytes < 0)
+            return '';
+        if (bytes < 1024)
+            return bytes + ' B';
+        const units = ['KB', 'MB', 'GB', 'TB'];
+        let value = bytes / 1024;
+        let unit = 0;
+        while (value >= 1024 && unit < units.length - 1) {
+            value /= 1024;
+            unit++;
+        }
+        // One decimal, with a trailing ".0" dropped: 1536 -> "1.5 KB", 2048 -> "2 KB".
+        return Math.round(value * 10) / 10 + ' ' + units[unit];
+    }
+    iconForType(type) {
+        if (type.startsWith('image/'))
+            return 'ri-image-line';
+        if (type.startsWith('video/'))
+            return 'ri-film-line';
+        if (type.startsWith('audio/'))
+            return 'ri-music-2-line';
+        if (type === 'application/pdf')
+            return 'ri-file-pdf-line';
+        if (type.startsWith('text/'))
+            return 'ri-file-text-line';
+        if (type.includes('zip') || type.includes('compressed') || type.includes('tar')) {
+            return 'ri-file-zip-line';
+        }
+        if (type.includes('spreadsheet') || type.includes('excel') || type.includes('csv')) {
+            return 'ri-file-excel-line';
+        }
+        return 'ri-file-line';
+    }
+    onRemove(event) {
+        // The card itself is a trigger; a remove click must not also open it.
+        event.stopPropagation();
+        this.remove.emit(event);
+    }
+    onOpen(event) {
+        if (event.type === 'keydown')
+            event.preventDefault();
+        this.open.emit(event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AttachmentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AttachmentComponent, isStandalone: true, selector: "tolle-attachment", inputs: { name: "name", size: "size", type: "type", url: "url", state: "state", progress: "progress", density: "density", removable: "removable", removeLabel: "removeLabel", errorLabel: "errorLabel", class: "class" }, outputs: { remove: "remove", open: "open" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      [class]="computedClass"
+      role="button"
+      tabindex="0"
+      [attr.aria-label]="name"
+      (click)="onOpen($event)"
+      (keydown.enter)="onOpen($event)"
+      (keydown.space)="onOpen($event)">
+      <img
+        *ngIf="isImage; else fileIcon"
+        [src]="url"
+        [alt]="name"
+        class="size-10 shrink-0 rounded-md object-cover" />
+
+      <ng-template #fileIcon>
+        <span class="flex size-10 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground">
+          <i [class]="iconClass" aria-hidden="true"></i>
+        </span>
+      </ng-template>
+
+      <span class="flex min-w-0 flex-1 flex-col gap-0.5">
+        <span class="truncate font-medium leading-none">{{ name }}</span>
+
+        <span class="truncate text-xs text-muted-foreground">
+          <ng-container *ngIf="state === 'error'; else metaText">{{ errorLabel }}</ng-container>
+          <ng-template #metaText>{{ formattedSize }}</ng-template>
+        </span>
+
+        <span
+          *ngIf="state === 'uploading'"
+          class="mt-1 block h-1 w-full overflow-hidden rounded-full bg-muted"
+          role="progressbar"
+          aria-valuemin="0"
+          aria-valuemax="100"
+          [attr.aria-valuenow]="clampedProgress">
+          <span
+            class="block h-full rounded-full bg-primary transition-all"
+            [style.width.%]="clampedProgress"></span>
+        </span>
+      </span>
+
+      <button
+        *ngIf="removable"
+        type="button"
+        [attr.aria-label]="removeLabel"
+        (click)="onRemove($event)"
+        class="shrink-0 rounded-md p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">
+        <i class="ri-close-line" aria-hidden="true"></i>
+      </button>
+
+      <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: AttachmentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-attachment', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      [class]="computedClass"
+      role="button"
+      tabindex="0"
+      [attr.aria-label]="name"
+      (click)="onOpen($event)"
+      (keydown.enter)="onOpen($event)"
+      (keydown.space)="onOpen($event)">
+      <img
+        *ngIf="isImage; else fileIcon"
+        [src]="url"
+        [alt]="name"
+        class="size-10 shrink-0 rounded-md object-cover" />
+
+      <ng-template #fileIcon>
+        <span class="flex size-10 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground">
+          <i [class]="iconClass" aria-hidden="true"></i>
+        </span>
+      </ng-template>
+
+      <span class="flex min-w-0 flex-1 flex-col gap-0.5">
+        <span class="truncate font-medium leading-none">{{ name }}</span>
+
+        <span class="truncate text-xs text-muted-foreground">
+          <ng-container *ngIf="state === 'error'; else metaText">{{ errorLabel }}</ng-container>
+          <ng-template #metaText>{{ formattedSize }}</ng-template>
+        </span>
+
+        <span
+          *ngIf="state === 'uploading'"
+          class="mt-1 block h-1 w-full overflow-hidden rounded-full bg-muted"
+          role="progressbar"
+          aria-valuemin="0"
+          aria-valuemax="100"
+          [attr.aria-valuenow]="clampedProgress">
+          <span
+            class="block h-full rounded-full bg-primary transition-all"
+            [style.width.%]="clampedProgress"></span>
+        </span>
+      </span>
+
+      <button
+        *ngIf="removable"
+        type="button"
+        [attr.aria-label]="removeLabel"
+        (click)="onRemove($event)"
+        class="shrink-0 rounded-md p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">
+        <i class="ri-close-line" aria-hidden="true"></i>
+      </button>
+
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { name: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], url: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], progress: [{
+                type: Input
+            }], density: [{
+                type: Input
+            }], removable: [{
+                type: Input
+            }], removeLabel: [{
+                type: Input
+            }], errorLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], remove: [{
+                type: Output
+            }], open: [{
+                type: Output
+            }] } });
+/** Wrapping row of attachment cards below or above a message. */
+export class AttachmentGroupComponent {
+    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 row via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AttachmentGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AttachmentGroupComponent, isStandalone: true, selector: "tolle-attachment-group", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div [class]="cn('flex flex-wrap items-start gap-2', 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: AttachmentGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-attachment-group', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="cn('flex flex-wrap items-start gap-2', class)"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/**
+ * Trailing slot for attachment controls — download, retry, remove. Clicks are
+ * kept inside the slot so the card's own trigger does not also fire.
+ */
+export class AttachmentActionsComponent {
+    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();
+    }
+    /** Keeps the actions visible instead of revealing them on hover or focus. @default false */
+    alwaysVisible = false;
+    /** Extra Tailwind classes merged onto the slot via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('flex shrink-0 items-center gap-1 transition-opacity', this.alwaysVisible
+            ? 'opacity-100'
+            : 'opacity-0 focus-within:opacity-100 group-hover/attachment:opacity-100', this.class);
+    }
+    onClick(event) {
+        event.stopPropagation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AttachmentActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AttachmentActionsComponent, isStandalone: true, selector: "tolle-attachment-actions", inputs: { alwaysVisible: "alwaysVisible", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass" (click)="onClick($event)">
+      <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: AttachmentActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-attachment-actions', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass" (click)="onClick($event)">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { alwaysVisible: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attachment.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/attachment.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, OnChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst attachmentVariants = cva(\n  'group/attachment relative flex w-full max-w-xs items-center gap-3 overflow-hidden rounded-lg border text-left transition-colors outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n  {\n    variants: {\n      state: {\n        idle: 'border-border bg-card text-card-foreground hover:bg-accent',\n        uploading: 'border-border bg-card text-card-foreground',\n        error: 'border-destructive bg-destructive/10 text-foreground',\n      },\n      size: {\n        sm: 'gap-2 p-1.5 text-xs',\n        default: 'gap-3 p-2 text-sm',\n      },\n    },\n    defaultVariants: { state: 'idle', size: 'default' },\n  }\n);\n\nexport type AttachmentProps = VariantProps<typeof attachmentVariants>;\n\n/**\n * A file or image attached to a chat message, with an upload state and an\n * optional progress bar. Wrap several in `tolle-attachment-group`.\n * @new\n */\n@Component({\n  selector: 'tolle-attachment',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      [class]=\"computedClass\"\n      role=\"button\"\n      tabindex=\"0\"\n      [attr.aria-label]=\"name\"\n      (click)=\"onOpen($event)\"\n      (keydown.enter)=\"onOpen($event)\"\n      (keydown.space)=\"onOpen($event)\">\n      <img\n        *ngIf=\"isImage; else fileIcon\"\n        [src]=\"url\"\n        [alt]=\"name\"\n        class=\"size-10 shrink-0 rounded-md object-cover\" />\n\n      <ng-template #fileIcon>\n        <span class=\"flex size-10 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground\">\n          <i [class]=\"iconClass\" aria-hidden=\"true\"></i>\n        </span>\n      </ng-template>\n\n      <span class=\"flex min-w-0 flex-1 flex-col gap-0.5\">\n        <span class=\"truncate font-medium leading-none\">{{ name }}</span>\n\n        <span class=\"truncate text-xs text-muted-foreground\">\n          <ng-container *ngIf=\"state === 'error'; else metaText\">{{ errorLabel }}</ng-container>\n          <ng-template #metaText>{{ formattedSize }}</ng-template>\n        </span>\n\n        <span\n          *ngIf=\"state === 'uploading'\"\n          class=\"mt-1 block h-1 w-full overflow-hidden rounded-full bg-muted\"\n          role=\"progressbar\"\n          aria-valuemin=\"0\"\n          aria-valuemax=\"100\"\n          [attr.aria-valuenow]=\"clampedProgress\">\n          <span\n            class=\"block h-full rounded-full bg-primary transition-all\"\n            [style.width.%]=\"clampedProgress\"></span>\n        </span>\n      </span>\n\n      <button\n        *ngIf=\"removable\"\n        type=\"button\"\n        [attr.aria-label]=\"removeLabel\"\n        (click)=\"onRemove($event)\"\n        class=\"shrink-0 rounded-md p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring\">\n        <i class=\"ri-close-line\" aria-hidden=\"true\"></i>\n      </button>\n\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class AttachmentComponent  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  /** File name shown as the card's title. */\n  @Input() name = '';\n  /** File size in bytes; rendered as B / KB / MB. @default 0 */\n  @Input() size = 0;\n  /** MIME type, e.g. 'image/png'. Chooses the thumbnail or the file icon. */\n  @Input() type = '';\n  /** Source for the thumbnail and the target of `open`. */\n  @Input() url = '';\n  /** Upload lifecycle state of the attachment. @default 'idle' */\n  @Input() state: AttachmentProps['state'] = 'idle';\n  /** Upload progress from 0 to 100; only shown while uploading. @default 0 */\n  @Input() progress = 0;\n  /** Density of the card. @default 'default' */\n  @Input() density: AttachmentProps['size'] = 'default';\n  /** Shows a trailing remove button that emits `remove`. @default false */\n  @Input() removable = false;\n  /** Accessible label for the remove button. @default 'Remove attachment' */\n  @Input() removeLabel = 'Remove attachment';\n  /** Text shown in place of the size when the state is 'error'. @default 'Upload failed' */\n  @Input() errorLabel = 'Upload failed';\n  /** Extra Tailwind classes merged onto the card via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when the remove button is pressed. */\n  @Output() remove = new EventEmitter<Event>();\n  /** Emitted when the card is activated by click, Enter, or Space. */\n  @Output() open = new EventEmitter<Event>();\n\n  get computedClass(): string {\n    return cn(attachmentVariants({ state: this.state, size: this.density }), this.class);\n  }\n\n  /** Whether the attachment renders as an image thumbnail rather than a file icon. */\n  get isImage(): boolean {\n    return this.type.startsWith('image/') && !!this.url;\n  }\n\n  /** Remixicon class picked from the MIME type. */\n  get iconClass(): string {\n    return this.iconForType(this.type);\n  }\n\n  /** The `size` input rendered for display, e.g. 1536 becomes \"1.5 KB\". */\n  get formattedSize(): string {\n    return this.formatBytes(this.size);\n  }\n\n  /** `progress` constrained to the 0-100 the progress bar can render. */\n  get clampedProgress(): number {\n    if (!Number.isFinite(this.progress)) return 0;\n    return Math.min(100, Math.max(0, this.progress));\n  }\n\n  private formatBytes(bytes: number): string {\n    if (!Number.isFinite(bytes) || bytes < 0) return '';\n    if (bytes < 1024) return bytes + ' B';\n\n    const units = ['KB', 'MB', 'GB', 'TB'];\n    let value = bytes / 1024;\n    let unit = 0;\n    while (value >= 1024 && unit < units.length - 1) {\n      value /= 1024;\n      unit++;\n    }\n\n    // One decimal, with a trailing \".0\" dropped: 1536 -> \"1.5 KB\", 2048 -> \"2 KB\".\n    return Math.round(value * 10) / 10 + ' ' + units[unit];\n  }\n\n  private iconForType(type: string): string {\n    if (type.startsWith('image/')) return 'ri-image-line';\n    if (type.startsWith('video/')) return 'ri-film-line';\n    if (type.startsWith('audio/')) return 'ri-music-2-line';\n    if (type === 'application/pdf') return 'ri-file-pdf-line';\n    if (type.startsWith('text/')) return 'ri-file-text-line';\n    if (type.includes('zip') || type.includes('compressed') || type.includes('tar')) {\n      return 'ri-file-zip-line';\n    }\n    if (type.includes('spreadsheet') || type.includes('excel') || type.includes('csv')) {\n      return 'ri-file-excel-line';\n    }\n    return 'ri-file-line';\n  }\n\n  protected onRemove(event: Event): void {\n    // The card itself is a trigger; a remove click must not also open it.\n    event.stopPropagation();\n    this.remove.emit(event);\n  }\n\n  protected onOpen(event: Event): void {\n    if (event.type === 'keydown') event.preventDefault();\n    this.open.emit(event);\n  }\n}\n\n/** Wrapping row of attachment cards below or above a message. */\n@Component({\n  selector: 'tolle-attachment-group',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"cn('flex flex-wrap items-start gap-2', class)\"><ng-content></ng-content></div>`,\n})\nexport class AttachmentGroupComponent  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 row via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/**\n * Trailing slot for attachment controls — download, retry, remove. Clicks are\n * kept inside the slot so the card's own trigger does not also fire.\n */\n@Component({\n  selector: 'tolle-attachment-actions',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\" (click)=\"onClick($event)\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class AttachmentActionsComponent  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  /** Keeps the actions visible instead of revealing them on hover or focus. @default false */\n  @Input() alwaysVisible = false;\n  /** Extra Tailwind classes merged onto the slot via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass(): string {\n    return cn(\n      'flex shrink-0 items-center gap-1 transition-opacity',\n      this.alwaysVisible\n        ? 'opacity-100'\n        : 'opacity-0 focus-within:opacity-100 group-hover/attachment:opacity-100',\n      this.class\n    );\n  }\n\n  protected onClick(event: Event): void {\n    event.stopPropagation();\n  }\n}\n"]}

package/esm2022/lib/avatar-fallback.component.mjs

@@ -6,7 +6,7 @@ export class AvatarFallbackComponent {
     <div class="flex h-full w-full items-center justify-center bg-muted text-muted-foreground font-medium uppercase">
       <ng-content></ng-content>
     </div>
-  `, isInline: true, styles: [""] });
+  `, isInline: true, styles: [":host{display:inline-flex}\n"] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AvatarFallbackComponent, decorators: [{
             type: Component,
@@ -14,6 +14,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
     <div class="flex h-full w-full items-center justify-center bg-muted text-muted-foreground font-medium uppercase">
       <ng-content></ng-content>
     </div>
-  ` }]
+  `, styles: [":host{display:inline-flex}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhdGFyLWZhbGxiYWNrLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3RvbGxlL3NyYy9saWIvYXZhdGFyLWZhbGxiYWNrLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQWExQyxNQUFNLE9BQU8sdUJBQXVCO3dHQUF2Qix1QkFBdUI7NEZBQXZCLHVCQUF1QixpRkFQeEI7Ozs7R0FJVDs7NEZBR1UsdUJBQXVCO2tCQVhuQyxTQUFTOytCQUNFLHVCQUF1QixjQUNyQixJQUFJLFdBQ1AsRUFBRSxZQUNEOzs7O0dBSVQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAndG9sbGUtYXZhdGFyLWZhbGxiYWNrJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgaW1wb3J0czogW10sXG4gIHRlbXBsYXRlOiBgXG4gICAgPGRpdiBjbGFzcz1cImZsZXggaC1mdWxsIHctZnVsbCBpdGVtcy1jZW50ZXIganVzdGlmeS1jZW50ZXIgYmctbXV0ZWQgdGV4dC1tdXRlZC1mb3JlZ3JvdW5kIGZvbnQtbWVkaXVtIHVwcGVyY2FzZVwiPlxuICAgICAgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuICAgIDwvZGl2PlxuICBgLFxuICBzdHlsZXM6IGBgXG59KVxuZXhwb3J0IGNsYXNzIEF2YXRhckZhbGxiYWNrQ29tcG9uZW50IHtcblxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhdGFyLWZhbGxiYWNrLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3RvbGxlL3NyYy9saWIvYXZhdGFyLWZhbGxiYWNrLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQWExQyxNQUFNLE9BQU8sdUJBQXVCO3dHQUF2Qix1QkFBdUI7NEZBQXZCLHVCQUF1QixpRkFQeEI7Ozs7R0FJVDs7NEZBR1UsdUJBQXVCO2tCQVhuQyxTQUFTOytCQUNFLHVCQUF1QixjQUNyQixJQUFJLFdBQ1AsRUFBRSxZQUNEOzs7O0dBSVQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAndG9sbGUtYXZhdGFyLWZhbGxiYWNrJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgaW1wb3J0czogW10sXG4gIHRlbXBsYXRlOiBgXG4gICAgPGRpdiBjbGFzcz1cImZsZXggaC1mdWxsIHctZnVsbCBpdGVtcy1jZW50ZXIganVzdGlmeS1jZW50ZXIgYmctbXV0ZWQgdGV4dC1tdXRlZC1mb3JlZ3JvdW5kIGZvbnQtbWVkaXVtIHVwcGVyY2FzZVwiPlxuICAgICAgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuICAgIDwvZGl2PlxuICBgLFxuICBzdHlsZXM6IGA6aG9zdCB7IGRpc3BsYXk6IGlubGluZS1mbGV4OyB9YFxufSlcbmV4cG9ydCBjbGFzcyBBdmF0YXJGYWxsYmFja0NvbXBvbmVudCB7XG5cbn1cbiJdfQ==

package/esm2022/lib/avatar.component.mjs

@@ -66,15 +66,11 @@ export class AvatarComponent {
     <div *ngIf="hasError || !src || isLoading" class="flex h-full w-full items-center justify-center bg-muted">
       <ng-content></ng-content>
     </div>
-  `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+  `, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AvatarComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-avatar',
-                    standalone: true,
-                    imports: [NgIf],
-                    template: `
+            args: [{ selector: 'tolle-avatar', standalone: true, imports: [NgIf], template: `
     <!-- Image Layer -->
     <img *ngIf="src && !hasError"
          [src]="src"
@@ -88,8 +84,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
     <div *ngIf="hasError || !src || isLoading" class="flex h-full w-full items-center justify-center bg-muted">
       <ng-content></ng-content>
     </div>
-  `
-                }]
+  `, styles: [":host{display:inline-flex}\n"] }]
         }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { src: [{
                 type: Input
             }], alt: [{
@@ -104,4 +99,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 type: HostBinding,
                 args: ['class']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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