@tolle_/tolle-ui 18.2.29 → 18.3.0

package/esm2022/lib/bubble.component.mjs

@@ -0,0 +1,301 @@
+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 bubbleVariants = cva('group/bubble relative w-fit max-w-full whitespace-pre-wrap break-words rounded-lg px-3 py-2 text-sm leading-relaxed transition-colors', {
+    variants: {
+        variant: {
+            default: 'border border-border bg-card text-card-foreground',
+            primary: 'border border-transparent bg-primary text-primary-foreground',
+            muted: 'border border-transparent bg-muted text-foreground',
+            outline: 'border border-border bg-transparent text-foreground',
+        },
+        align: {
+            // The corner nearest the sender is squared off to read as a tail.
+            start: 'rounded-bl-sm',
+            end: 'rounded-br-sm',
+        },
+        size: {
+            sm: 'px-2.5 py-1.5 text-xs',
+            default: 'px-3 py-2 text-sm',
+            lg: 'px-4 py-3 text-base',
+        },
+    },
+    defaultVariants: { variant: 'default', align: 'start', size: 'default' },
+});
+/**
+ * The visible surface of a chat message — the rounded panel the text sits in.
+ * Place it inside `tolle-message-content` and match its `align` to the message.
+ * @new
+ */
+export class BubbleComponent {
+    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();
+    }
+    /** Visual style of the surface. @default 'default' */
+    variant = 'default';
+    /** Which edge the bubble hangs off; squares the matching bottom corner. @default 'start' */
+    align = 'start';
+    /** Padding and text scale of the surface. @default 'default' */
+    size = 'default';
+    /** Shows a show-more / show-less toggle for long content. @default false */
+    collapsible = false;
+    /** Whether the content is currently clamped. Only has an effect with `collapsible`. @default true */
+    collapsed = true;
+    /** Max height of the clamped content, as a CSS length. @default '6rem' */
+    collapsedHeight = '6rem';
+    /** Label of the toggle while the content is clamped. @default 'Show more' */
+    expandLabel = 'Show more';
+    /** Label of the toggle while the content is expanded. @default 'Show less' */
+    collapseLabel = 'Show less';
+    /** Makes the whole surface a keyboard-focusable trigger that emits `bubbleClick`. @default false */
+    interactive = false;
+    /** Extra Tailwind classes merged onto the surface via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new collapsed state when the show-more toggle is pressed. */
+    collapsedChange = new EventEmitter();
+    /** Emitted when an interactive bubble is activated by click, Enter, or Space. */
+    bubbleClick = new EventEmitter();
+    get computedClass() {
+        return cn(bubbleVariants({ variant: this.variant, align: this.align, size: this.size }), this.interactive &&
+            'cursor-pointer outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2', this.class);
+    }
+    /** Classes for the content wrapper — clamped only while collapsible and collapsed. */
+    get contentClass() {
+        return cn(this.isClamped && 'overflow-hidden');
+    }
+    /** Inline max-height applied while the content is clamped. */
+    get contentStyle() {
+        return this.isClamped ? this.collapsedHeight : null;
+    }
+    /** Whether the projected content is currently clamped. */
+    get isClamped() {
+        return this.collapsible && this.collapsed;
+    }
+    toggle(event) {
+        // The toggle lives inside the trigger surface; don't fire both.
+        event.stopPropagation();
+        this.collapsed = !this.collapsed;
+        this.collapsedChange.emit(this.collapsed);
+    }
+    onTrigger(event) {
+        if (!this.interactive)
+            return;
+        if (event.type === 'keydown')
+            event.preventDefault();
+        this.bubbleClick.emit(event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BubbleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BubbleComponent, isStandalone: true, selector: "tolle-bubble", inputs: { variant: "variant", align: "align", size: "size", collapsible: "collapsible", collapsed: "collapsed", collapsedHeight: "collapsedHeight", expandLabel: "expandLabel", collapseLabel: "collapseLabel", interactive: "interactive", class: "class" }, outputs: { collapsedChange: "collapsedChange", bubbleClick: "bubbleClick" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      [class]="computedClass"
+      [attr.role]="interactive ? 'button' : null"
+      [attr.tabindex]="interactive ? 0 : null"
+      (click)="onTrigger($event)"
+      (keydown.enter)="onTrigger($event)"
+      (keydown.space)="onTrigger($event)">
+      <!-- Single content slot: collapsing only swaps the wrapper's classes so the
+           projected nodes are never re-created (and never render empty). -->
+      <div [class]="contentClass" [style.max-height]="contentStyle">
+        <ng-content></ng-content>
+      </div>
+
+      <button
+        *ngIf="collapsible"
+        type="button"
+        [attr.aria-expanded]="!collapsed"
+        (click)="toggle($event)"
+        class="mt-1 inline-flex items-center gap-1 rounded-sm text-xs font-medium underline underline-offset-2 opacity-80 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">
+        {{ collapsed ? expandLabel : collapseLabel }}
+        <i [class]="collapsed ? 'ri-arrow-down-s-line' : 'ri-arrow-up-s-line'" aria-hidden="true"></i>
+      </button>
+
+      <ng-content select="[bubbleFooter]"></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: BubbleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-bubble', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      [class]="computedClass"
+      [attr.role]="interactive ? 'button' : null"
+      [attr.tabindex]="interactive ? 0 : null"
+      (click)="onTrigger($event)"
+      (keydown.enter)="onTrigger($event)"
+      (keydown.space)="onTrigger($event)">
+      <!-- Single content slot: collapsing only swaps the wrapper's classes so the
+           projected nodes are never re-created (and never render empty). -->
+      <div [class]="contentClass" [style.max-height]="contentStyle">
+        <ng-content></ng-content>
+      </div>
+
+      <button
+        *ngIf="collapsible"
+        type="button"
+        [attr.aria-expanded]="!collapsed"
+        (click)="toggle($event)"
+        class="mt-1 inline-flex items-center gap-1 rounded-sm text-xs font-medium underline underline-offset-2 opacity-80 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">
+        {{ collapsed ? expandLabel : collapseLabel }}
+        <i [class]="collapsed ? 'ri-arrow-down-s-line' : 'ri-arrow-up-s-line'" aria-hidden="true"></i>
+      </button>
+
+      <ng-content select="[bubbleFooter]"></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], collapsible: [{
+                type: Input
+            }], collapsed: [{
+                type: Input
+            }], collapsedHeight: [{
+                type: Input
+            }], expandLabel: [{
+                type: Input
+            }], collapseLabel: [{
+                type: Input
+            }], interactive: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], collapsedChange: [{
+                type: Output
+            }], bubbleClick: [{
+                type: Output
+            }] } });
+/**
+ * Hover-revealed row of actions for a bubble — copy, retry, react. Clicks are
+ * kept inside the row so an interactive bubble does not also fire.
+ */
+export class BubbleActionsComponent {
+    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 row permanently visible instead of revealing it on hover or focus. @default false */
+    alwaysVisible = false;
+    /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('mt-1 flex items-center gap-1 transition-opacity', this.alwaysVisible
+            ? 'opacity-100'
+            : 'opacity-0 focus-within:opacity-100 group-hover/bubble:opacity-100', this.class);
+    }
+    onClick(event) {
+        // Actions stay independently clickable even when the bubble is a trigger.
+        event.stopPropagation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BubbleActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BubbleActionsComponent, isStandalone: true, selector: "tolle-bubble-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: BubbleActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-bubble-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
+            }] } });
+/** Row of emoji reaction chips attached to a bubble. */
+export class BubbleReactionsComponent {
+    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();
+    }
+    /** Reaction chips to render, in display order. @default [] */
+    reactions = [];
+    /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the reaction whose chip was clicked. */
+    react = new EventEmitter();
+    get computedClass() {
+        return cn('mt-1 flex flex-wrap items-center gap-1', this.class);
+    }
+    chipClass(reaction) {
+        return cn('inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-xs leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring', reaction.reacted
+            ? 'border-primary bg-primary/10 text-primary'
+            : 'border-border bg-muted text-muted-foreground hover:bg-accent');
+    }
+    trackByEmoji(_index, reaction) {
+        return reaction.emoji;
+    }
+    onReact(reaction, event) {
+        event.stopPropagation();
+        this.react.emit(reaction);
+    }
+    stop(event) {
+        event.stopPropagation();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BubbleReactionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BubbleReactionsComponent, isStandalone: true, selector: "tolle-bubble-reactions", inputs: { reactions: "reactions", class: "class" }, outputs: { react: "react" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass" (click)="stop($event)">
+      <button
+        *ngFor="let reaction of reactions; trackBy: trackByEmoji"
+        type="button"
+        [attr.aria-pressed]="!!reaction.reacted"
+        [class]="chipClass(reaction)"
+        (click)="onReact(reaction, $event)">
+        <span aria-hidden="true">{{ reaction.emoji }}</span>
+        <span *ngIf="reaction.count" class="tabular-nums">{{ reaction.count }}</span>
+      </button>
+
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { 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: BubbleReactionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-bubble-reactions', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass" (click)="stop($event)">
+      <button
+        *ngFor="let reaction of reactions; trackBy: trackByEmoji"
+        type="button"
+        [attr.aria-pressed]="!!reaction.reacted"
+        [class]="chipClass(reaction)"
+        (click)="onReact(reaction, $event)">
+        <span aria-hidden="true">{{ reaction.emoji }}</span>
+        <span *ngIf="reaction.count" class="tabular-nums">{{ reaction.count }}</span>
+      </button>
+
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { reactions: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], react: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bubble.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/bubble.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 bubbleVariants = cva(\n  'group/bubble relative w-fit max-w-full whitespace-pre-wrap break-words rounded-lg px-3 py-2 text-sm leading-relaxed transition-colors',\n  {\n    variants: {\n      variant: {\n        default: 'border border-border bg-card text-card-foreground',\n        primary: 'border border-transparent bg-primary text-primary-foreground',\n        muted: 'border border-transparent bg-muted text-foreground',\n        outline: 'border border-border bg-transparent text-foreground',\n      },\n      align: {\n        // The corner nearest the sender is squared off to read as a tail.\n        start: 'rounded-bl-sm',\n        end: 'rounded-br-sm',\n      },\n      size: {\n        sm: 'px-2.5 py-1.5 text-xs',\n        default: 'px-3 py-2 text-sm',\n        lg: 'px-4 py-3 text-base',\n      },\n    },\n    defaultVariants: { variant: 'default', align: 'start', size: 'default' },\n  }\n);\n\nexport type BubbleProps = VariantProps<typeof bubbleVariants>;\n\n/** A single emoji reaction chip and its tally. */\nexport interface BubbleReaction {\n  /** The emoji character to display, e.g. a thumbs-up. */\n  emoji: string;\n  /** How many people reacted with it. */\n  count?: number;\n  /** Whether the current user is one of them. */\n  reacted?: boolean;\n}\n\n/**\n * The visible surface of a chat message — the rounded panel the text sits in.\n * Place it inside `tolle-message-content` and match its `align` to the message.\n * @new\n */\n@Component({\n  selector: 'tolle-bubble',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      [class]=\"computedClass\"\n      [attr.role]=\"interactive ? 'button' : null\"\n      [attr.tabindex]=\"interactive ? 0 : null\"\n      (click)=\"onTrigger($event)\"\n      (keydown.enter)=\"onTrigger($event)\"\n      (keydown.space)=\"onTrigger($event)\">\n      <!-- Single content slot: collapsing only swaps the wrapper's classes so the\n           projected nodes are never re-created (and never render empty). -->\n      <div [class]=\"contentClass\" [style.max-height]=\"contentStyle\">\n        <ng-content></ng-content>\n      </div>\n\n      <button\n        *ngIf=\"collapsible\"\n        type=\"button\"\n        [attr.aria-expanded]=\"!collapsed\"\n        (click)=\"toggle($event)\"\n        class=\"mt-1 inline-flex items-center gap-1 rounded-sm text-xs font-medium underline underline-offset-2 opacity-80 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring\">\n        {{ collapsed ? expandLabel : collapseLabel }}\n        <i [class]=\"collapsed ? 'ri-arrow-down-s-line' : 'ri-arrow-up-s-line'\" aria-hidden=\"true\"></i>\n      </button>\n\n      <ng-content select=\"[bubbleFooter]\"></ng-content>\n    </div>\n  `,\n})\nexport class BubbleComponent  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  /** Visual style of the surface. @default 'default' */\n  @Input() variant: BubbleProps['variant'] = 'default';\n  /** Which edge the bubble hangs off; squares the matching bottom corner. @default 'start' */\n  @Input() align: BubbleProps['align'] = 'start';\n  /** Padding and text scale of the surface. @default 'default' */\n  @Input() size: BubbleProps['size'] = 'default';\n  /** Shows a show-more / show-less toggle for long content. @default false */\n  @Input() collapsible = false;\n  /** Whether the content is currently clamped. Only has an effect with `collapsible`. @default true */\n  @Input() collapsed = true;\n  /** Max height of the clamped content, as a CSS length. @default '6rem' */\n  @Input() collapsedHeight = '6rem';\n  /** Label of the toggle while the content is clamped. @default 'Show more' */\n  @Input() expandLabel = 'Show more';\n  /** Label of the toggle while the content is expanded. @default 'Show less' */\n  @Input() collapseLabel = 'Show less';\n  /** Makes the whole surface a keyboard-focusable trigger that emits `bubbleClick`. @default false */\n  @Input() interactive = false;\n  /** Extra Tailwind classes merged onto the surface via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new collapsed state when the show-more toggle is pressed. */\n  @Output() collapsedChange = new EventEmitter<boolean>();\n  /** Emitted when an interactive bubble is activated by click, Enter, or Space. */\n  @Output() bubbleClick = new EventEmitter<Event>();\n\n  get computedClass(): string {\n    return cn(\n      bubbleVariants({ variant: this.variant, align: this.align, size: this.size }),\n      this.interactive &&\n        'cursor-pointer outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n      this.class\n    );\n  }\n\n  /** Classes for the content wrapper — clamped only while collapsible and collapsed. */\n  get contentClass(): string {\n    return cn(this.isClamped && 'overflow-hidden');\n  }\n\n  /** Inline max-height applied while the content is clamped. */\n  get contentStyle(): string | null {\n    return this.isClamped ? this.collapsedHeight : null;\n  }\n\n  /** Whether the projected content is currently clamped. */\n  get isClamped(): boolean {\n    return this.collapsible && this.collapsed;\n  }\n\n  protected toggle(event: Event): void {\n    // The toggle lives inside the trigger surface; don't fire both.\n    event.stopPropagation();\n    this.collapsed = !this.collapsed;\n    this.collapsedChange.emit(this.collapsed);\n  }\n\n  protected onTrigger(event: Event): void {\n    if (!this.interactive) return;\n    if (event.type === 'keydown') event.preventDefault();\n    this.bubbleClick.emit(event);\n  }\n}\n\n/**\n * Hover-revealed row of actions for a bubble — copy, retry, react. Clicks are\n * kept inside the row so an interactive bubble does not also fire.\n */\n@Component({\n  selector: 'tolle-bubble-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 BubbleActionsComponent  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 row permanently visible instead of revealing it on hover or focus. @default false */\n  @Input() alwaysVisible = false;\n  /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass(): string {\n    return cn(\n      'mt-1 flex items-center gap-1 transition-opacity',\n      this.alwaysVisible\n        ? 'opacity-100'\n        : 'opacity-0 focus-within:opacity-100 group-hover/bubble:opacity-100',\n      this.class\n    );\n  }\n\n  protected onClick(event: Event): void {\n    // Actions stay independently clickable even when the bubble is a trigger.\n    event.stopPropagation();\n  }\n}\n\n/** Row of emoji reaction chips attached to a bubble. */\n@Component({\n  selector: 'tolle-bubble-reactions',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\" (click)=\"stop($event)\">\n      <button\n        *ngFor=\"let reaction of reactions; trackBy: trackByEmoji\"\n        type=\"button\"\n        [attr.aria-pressed]=\"!!reaction.reacted\"\n        [class]=\"chipClass(reaction)\"\n        (click)=\"onReact(reaction, $event)\">\n        <span aria-hidden=\"true\">{{ reaction.emoji }}</span>\n        <span *ngIf=\"reaction.count\" class=\"tabular-nums\">{{ reaction.count }}</span>\n      </button>\n\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class BubbleReactionsComponent  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  /** Reaction chips to render, in display order. @default [] */\n  @Input() reactions: BubbleReaction[] = [];\n  /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the reaction whose chip was clicked. */\n  @Output() react = new EventEmitter<BubbleReaction>();\n\n  get computedClass(): string {\n    return cn('mt-1 flex flex-wrap items-center gap-1', this.class);\n  }\n\n  protected chipClass(reaction: BubbleReaction): string {\n    return cn(\n      'inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-xs leading-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',\n      reaction.reacted\n        ? 'border-primary bg-primary/10 text-primary'\n        : 'border-border bg-muted text-muted-foreground hover:bg-accent'\n    );\n  }\n\n  protected trackByEmoji(_index: number, reaction: BubbleReaction): string {\n    return reaction.emoji;\n  }\n\n  protected onReact(reaction: BubbleReaction, event: Event): void {\n    event.stopPropagation();\n    this.react.emit(reaction);\n  }\n\n  protected stop(event: Event): void {\n    event.stopPropagation();\n  }\n}\n"]}

package/esm2022/lib/button.component.mjs

@@ -70,15 +70,11 @@ export class ButtonComponent {
         <ng-content></ng-content>
       </span>
     </button>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+  `, isInline: true, styles: [":host{display:inline-flex}\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: ButtonComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-button',
-                    standalone: true,
-                    imports: [CommonModule],
-                    template: `
+            args: [{ selector: 'tolle-button', standalone: true, imports: [CommonModule], template: `
     <button
       [type]="type"
       [class]="computedClass"
@@ -96,11 +92,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         <ng-content></ng-content>
       </span>
     </button>
-  `,
-                    host: {
+  `, host: {
                         'class': 'tolle-button-wrapper inline-block align-middle'
-                    }
-                }]
+                    }, styles: [":host{display:inline-flex}\n"] }]
         }], propDecorators: { class: [{
                 type: Input
             }], variant: [{
@@ -114,4 +108,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], busy: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnV0dG9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3RvbGxlL3NyYy9saWIvYnV0dG9uLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNqRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLEdBQUcsRUFBcUIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsRSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sWUFBWSxDQUFDOzs7QUFFaEMsTUFBTSxjQUFjLEdBQUcsR0FBRyxDQUN4Qix5U0FBeVMsRUFDelM7SUFDRSxRQUFRLEVBQUU7UUFDUixPQUFPLEVBQUU7WUFDUCxPQUFPLEVBQUUsd0RBQXdEO1lBQ2pFLFdBQVcsRUFBRSxvRUFBb0U7WUFDakYsT0FBTyxFQUFFLGlHQUFpRztZQUMxRyxTQUFTLEVBQUUsOERBQThEO1lBQ3pFLEtBQUssRUFBRSw4Q0FBOEM7WUFDckQsSUFBSSxFQUFFLGlEQUFpRDtTQUN4RDtRQUNELElBQUksRUFBRTtZQUNKLE9BQU8sRUFBRSxnQkFBZ0I7WUFDekIsRUFBRSxFQUFFLHVCQUF1QjtZQUMzQixFQUFFLEVBQUUscUJBQXFCO1lBQ3pCLEVBQUUsRUFBRSxzQkFBc0I7WUFDMUIsU0FBUyxFQUFFLFNBQVM7WUFDcEIsU0FBUyxFQUFFLFNBQVM7WUFDcEIsSUFBSSxFQUFFLFdBQVc7WUFDakIsU0FBUyxFQUFFLFdBQVc7U0FDdkI7UUFDRCxJQUFJLEVBQUUsRUFBRSxJQUFJLEVBQUUsK0RBQStELEVBQUU7S0FDaEY7SUFDRCxlQUFlLEVBQUU7UUFDZixPQUFPLEVBQUUsU0FBUztRQUNsQixJQUFJLEVBQUUsU0FBUztLQUNoQjtDQUNGLENBQ0YsQ0FBQztBQWdDRixNQUFNLE9BQU8sZUFBZTtJQUMxQiw0RUFBNEU7SUFDbkUsS0FBSyxHQUFXLEVBQUUsQ0FBQztJQUM1QixxREFBcUQ7SUFDNUMsT0FBTyxHQUEyQixTQUFTLENBQUM7SUFDckQsd0VBQXdFO0lBQy9ELElBQUksR0FBd0IsU0FBUyxDQUFDO0lBQy9DLDBHQUEwRztJQUNqRyxJQUFJLEdBQWtDLFFBQVEsQ0FBQztJQUN4RCxvRUFBb0U7SUFDM0QsUUFBUSxHQUFZLEtBQUssQ0FBQztJQUNuQyxvR0FBb0c7SUFDM0YsSUFBSSxHQUFZLEtBQUssQ0FBQztJQUUvQixJQUFJLGFBQWE7UUFDZixPQUFPLEVBQUUsQ0FDUCxjQUFjLENBQUM7WUFDYixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87WUFDckIsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1NBQ2hCLENBQUMsRUFDRixJQUFJLENBQUMsS0FBSyxDQUNYLENBQUM7SUFDSixDQUFDO3dHQXZCVSxlQUFlOzRGQUFmLGVBQWUsb1FBdkJoQjs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBa0JULHFHQW5CUyxZQUFZOzs0RkF3QlgsZUFBZTtrQkE1QjNCLFNBQVM7K0JBQ0UsY0FBYyxjQUVaLElBQUksV0FDUCxDQUFDLFlBQVksQ0FBQyxZQUNiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FrQlQsUUFDSzt3QkFDSixPQUFPLEVBQUUsZ0RBQWdEO3FCQUMxRDs4QkFJUSxLQUFLO3NCQUFiLEtBQUs7Z0JBRUcsT0FBTztzQkFBZixLQUFLO2dCQUVHLElBQUk7c0JBQVosS0FBSztnQkFFRyxJQUFJO3NCQUFaLEtBQUs7Z0JBRUcsUUFBUTtzQkFBaEIsS0FBSztnQkFFRyxJQUFJO3NCQUFaLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgY3ZhLCB0eXBlIFZhcmlhbnRQcm9wcyB9IGZyb20gJ2NsYXNzLXZhcmlhbmNlLWF1dGhvcml0eSc7XG5pbXBvcnQgeyBjbiB9IGZyb20gJy4vdXRpbHMvY24nO1xuXG5jb25zdCBidXR0b25WYXJpYW50cyA9IGN2YShcbiAgXCJ0b2xsZS1idXR0b24tYmFzZSBpbmxpbmUtZmxleCBpdGVtcy1jZW50ZXIganVzdGlmeS1jZW50ZXIgcm91bmRlZC1tZCB0ZXh0LXNtIGZvbnQtbWVkaXVtIHRyYW5zaXRpb24tYWxsIGZvY3VzLXZpc2libGU6b3V0bGluZS1ub25lIGZvY3VzLXZpc2libGU6cmluZy0yIGZvY3VzLXZpc2libGU6cmluZy1yaW5nIGZvY3VzLXZpc2libGU6cmluZy1vZmZzZXQtMiBkaXNhYmxlZDpvcGFjaXR5LTUwIGRpc2FibGVkOnBvaW50ZXItZXZlbnRzLW5vbmUgcmluZy1vZmZzZXQtYmFja2dyb3VuZCBhY3RpdmU6c2NhbGUtWzAuOThdXCIsXG4gIHtcbiAgICB2YXJpYW50czoge1xuICAgICAgdmFyaWFudDoge1xuICAgICAgICBkZWZhdWx0OiBcImJnLXByaW1hcnkgdGV4dC1wcmltYXJ5LWZvcmVncm91bmQgaG92ZXI6YmctcHJpbWFyeS85MFwiLFxuICAgICAgICBkZXN0cnVjdGl2ZTogXCJiZy1kZXN0cnVjdGl2ZSB0ZXh0LWRlc3RydWN0aXZlLWZvcmVncm91bmQgaG92ZXI6YmctZGVzdHJ1Y3RpdmUvOTBcIixcbiAgICAgICAgb3V0bGluZTogXCJib3JkZXIgYm9yZGVyLWlucHV0IGJnLXRyYW5zcGFyZW50IGhvdmVyOmJnLWFjY2VudCBob3Zlcjp0ZXh0LWFjY2VudC1mb3JlZ3JvdW5kIHRleHQtZm9yZWdyb3VuZFwiLFxuICAgICAgICBzZWNvbmRhcnk6IFwiYmctc2Vjb25kYXJ5IHRleHQtc2Vjb25kYXJ5LWZvcmVncm91bmQgaG92ZXI6Ymctc2Vjb25kYXJ5LzgwXCIsXG4gICAgICAgIGdob3N0OiBcImhvdmVyOmJnLWFjY2VudCBob3Zlcjp0ZXh0LWFjY2VudC1mb3JlZ3JvdW5kXCIsXG4gICAgICAgIGxpbms6IFwidGV4dC1wcmltYXJ5IHVuZGVybGluZS1vZmZzZXQtNCBob3Zlcjp1bmRlcmxpbmVcIixcbiAgICAgIH0sXG4gICAgICBzaXplOiB7XG4gICAgICAgIGRlZmF1bHQ6IFwiaC0xMCBweC00IHB5LTJcIixcbiAgICAgICAgeHM6IFwiaC04IHB4LTIgcHktMSB0ZXh0LXhzXCIsXG4gICAgICAgIHNtOiBcImgtOSByb3VuZGVkLW1kIHB4LTNcIixcbiAgICAgICAgbGc6IFwiaC0xMSByb3VuZGVkLW1kIHB4LThcIixcbiAgICAgICAgXCJpY29uLXhzXCI6IFwiaC04IHctOFwiLFxuICAgICAgICBcImljb24tc21cIjogXCJoLTkgdy05XCIsXG4gICAgICAgIGljb246IFwiaC0xMCB3LTEwXCIsXG4gICAgICAgIFwiaWNvbi1sZ1wiOiBcImgtMTEgdy0xMVwiLFxuICAgICAgfSxcbiAgICAgIGJ1c3k6IHsgdHJ1ZTogXCJ0b2xsZS1idXR0b24tLWJ1c3kgcmVsYXRpdmUgIWN1cnNvci13YWl0ICFwb2ludGVyLWV2ZW50cy1ub25lXCIgfVxuICAgIH0sXG4gICAgZGVmYXVsdFZhcmlhbnRzOiB7XG4gICAgICB2YXJpYW50OiBcImRlZmF1bHRcIixcbiAgICAgIHNpemU6IFwiZGVmYXVsdFwiLFxuICAgIH0sXG4gIH1cbik7XG5cbmV4cG9ydCB0eXBlIEJ1dHRvblByb3BzID0gVmFyaWFudFByb3BzPHR5cGVvZiBidXR0b25WYXJpYW50cz47XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3RvbGxlLWJ1dHRvbicsXG4gIHN0eWxlczogWyc6aG9zdCB7IGRpc3BsYXk6IGlubGluZS1mbGV4OyB9J10sXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxidXR0b25cbiAgICAgIFt0eXBlXT1cInR5cGVcIlxuICAgICAgW2NsYXNzXT1cImNvbXB1dGVkQ2xhc3NcIlxuICAgICAgW2Rpc2FibGVkXT1cImRpc2FibGVkIHx8IGJ1c3lcIlxuICAgICAgW2F0dHIuYXJpYS1idXN5XT1cImJ1c3lcIlxuICAgID5cbiAgICAgIDxkaXYgKm5nSWY9XCJidXN5XCIgY2xhc3M9XCJhYnNvbHV0ZSBpbnNldC0wIGZsZXggaXRlbXMtY2VudGVyIGp1c3RpZnktY2VudGVyXCI+XG4gICAgICAgIDxzdmcgY2xhc3M9XCJhbmltYXRlLXNwaW4gaC01IHctNSB0ZXh0LWN1cnJlbnRcIiB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgZmlsbD1cIm5vbmVcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCI+XG4gICAgICAgICAgPGNpcmNsZSBjbGFzcz1cIm9wYWNpdHktMjVcIiBjeD1cIjEyXCIgY3k9XCIxMlwiIHI9XCIxMFwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjRcIj48L2NpcmNsZT5cbiAgICAgICAgICA8cGF0aCBjbGFzcz1cIm9wYWNpdHktNzVcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgZD1cIk00IDEyYTggOCAwIDAxOC04VjBDNS4zNzMgMCAwIDUuMzczIDAgMTJoNHptMiA1LjI5MUE3Ljk2MiA3Ljk2MiAwIDAxNCAxMkgwYzAgMy4wNDIgMS4xMzUgNS44MjQgMyA3LjkzOGwzLTIuNjQ3elwiPjwvcGF0aD5cbiAgICAgICAgPC9zdmc+XG4gICAgICA8L2Rpdj5cblxuICAgICAgPHNwYW4gY2xhc3M9XCJmbGV4IGl0ZW1zLWNlbnRlciBqdXN0aWZ5LWNlbnRlciB3LWZ1bGwgaC1mdWxsIHBvaW50ZXItZXZlbnRzLW5vbmVcIiBbY2xhc3MuaW52aXNpYmxlXT1cImJ1c3lcIj5cbiAgICAgICAgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuICAgICAgPC9zcGFuPlxuICAgIDwvYnV0dG9uPlxuICBgLFxuICBob3N0OiB7XG4gICAgJ2NsYXNzJzogJ3RvbGxlLWJ1dHRvbi13cmFwcGVyIGlubGluZS1ibG9jayBhbGlnbi1taWRkbGUnXG4gIH1cbn0pXG5leHBvcnQgY2xhc3MgQnV0dG9uQ29tcG9uZW50IHtcbiAgLyoqIEV4dHJhIFRhaWx3aW5kIGNsYXNzZXMgbWVyZ2VkIG9udG8gdGhlIGJ1dHRvbiB2aWEgYGNuKClgIChsYXN0LXdpbnMpLiAqL1xuICBASW5wdXQoKSBjbGFzczogc3RyaW5nID0gJyc7XG4gIC8qKiBWaXN1YWwgc3R5bGUgb2YgdGhlIGJ1dHRvbi4gQGRlZmF1bHQgJ2RlZmF1bHQnICovXG4gIEBJbnB1dCgpIHZhcmlhbnQ6IEJ1dHRvblByb3BzWyd2YXJpYW50J10gPSAnZGVmYXVsdCc7XG4gIC8qKiBTaXplIG9mIHRoZSBidXR0b24sIGluY2x1ZGluZyBpY29uLW9ubHkgc2l6ZXMuIEBkZWZhdWx0ICdkZWZhdWx0JyAqL1xuICBASW5wdXQoKSBzaXplOiBCdXR0b25Qcm9wc1snc2l6ZSddID0gJ2RlZmF1bHQnO1xuICAvKiogTmF0aXZlIGJ1dHRvbiB0eXBlLiBEZWZhdWx0cyB0byAnYnV0dG9uJyBzbyBpdCBuZXZlciBzdWJtaXRzIGEgZm9ybSB1bmV4cGVjdGVkbHkuIEBkZWZhdWx0ICdidXR0b24nICovXG4gIEBJbnB1dCgpIHR5cGU6ICdidXR0b24nIHwgJ3N1Ym1pdCcgfCAncmVzZXQnID0gJ2J1dHRvbic7XG4gIC8qKiBEaXNhYmxlcyB0aGUgYnV0dG9uIGFuZCBibG9ja3MgcG9pbnRlciBldmVudHMuIEBkZWZhdWx0IGZhbHNlICovXG4gIEBJbnB1dCgpIGRpc2FibGVkOiBib29sZWFuID0gZmFsc2U7XG4gIC8qKiBTaG93cyBhIHNwaW5uZXIsIHNldHMgYGFyaWEtYnVzeWAsIGFuZCBwcmV2ZW50cyBpbnRlcmFjdGlvbiB3aGlsZSBhIHRhc2sgcnVucy4gQGRlZmF1bHQgZmFsc2UgKi9cbiAgQElucHV0KCkgYnVzeTogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIGdldCBjb21wdXRlZENsYXNzKCkge1xuICAgIHJldHVybiBjbihcbiAgICAgIGJ1dHRvblZhcmlhbnRzKHtcbiAgICAgICAgdmFyaWFudDogdGhpcy52YXJpYW50LFxuICAgICAgICBzaXplOiB0aGlzLnNpemUsXG4gICAgICAgIGJ1c3k6IHRoaXMuYnVzeVxuICAgICAgfSksXG4gICAgICB0aGlzLmNsYXNzXG4gICAgKTtcbiAgfVxufVxuIl19