@tolle_/tolle-ui 18.2.29 → 18.3.0

package/esm2022/lib/suggestion.component.mjs

@@ -0,0 +1,207 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Injectable, Input, Output, inject, ChangeDetectorRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Subject, Subscription } from 'rxjs';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Relays a chosen suggestion from a `tolle-suggestion` up to the
+ * `tolle-suggestions` row that contains it, so consumers can listen in one
+ * place instead of binding every pill.
+ *
+ * Provided on `SuggestionsComponent`; injected optionally, since a pill is
+ * perfectly usable on its own.
+ */
+export class SuggestionsService {
+    selectedSource = new Subject();
+    /** Emits the value of whichever suggestion the user picked. */
+    selected$ = this.selectedSource.asObservable();
+    select(value) {
+        this.selectedSource.next(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuggestionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuggestionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuggestionsService, decorators: [{
+            type: Injectable
+        }] });
+const suggestionsVariants = cva('flex w-full items-center overflow-x-auto scroll-fade-x', {
+    variants: {
+        gap: {
+            sm: 'gap-1',
+            default: 'gap-2',
+            lg: 'gap-3',
+        },
+    },
+    defaultVariants: {
+        gap: 'default',
+    },
+});
+/**
+ * A horizontally scrollable row of suggested follow-up prompts.
+ *
+ * Fill it with `tolle-suggestion` pills and listen to this component's
+ * `selected` output to react to any of them.
+ */
+export class SuggestionsComponent {
+    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();
+    }
+    /** Spacing between the pills. @default 'default' */
+    gap = 'default';
+    /** Accessible name for the row. @default 'Suggestions' */
+    ariaLabel = 'Suggestions';
+    /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the `value` of whichever suggestion in the row was picked. */
+    selected = new EventEmitter();
+    service = inject(SuggestionsService);
+    subscriptions = new Subscription();
+    ngOnInit() {
+        this.subscriptions.add(this.service.selected$.subscribe((value) => this.selected.emit(value)));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn(suggestionsVariants({ gap: this.gap }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuggestionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SuggestionsComponent, isStandalone: true, selector: "tolle-suggestions", inputs: { gap: "gap", ariaLabel: "ariaLabel", class: "class" }, outputs: { selected: "selected" }, providers: [SuggestionsService], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass" role="group" [attr.aria-label]="ariaLabel || null">
+      <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: SuggestionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-suggestions', standalone: true, imports: [CommonModule], providers: [SuggestionsService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass" role="group" [attr.aria-label]="ariaLabel || null">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { gap: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], selected: [{
+                type: Output
+            }] } });
+const suggestionVariants = cva('inline-flex shrink-0 items-center gap-1.5 whitespace-nowrap rounded-full border transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:pointer-events-none disabled:opacity-50', {
+    variants: {
+        variant: {
+            outline: 'border-border bg-background text-foreground hover:bg-accent hover:text-accent-foreground',
+            secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            ghost: 'border-transparent bg-transparent text-muted-foreground hover:bg-accent hover:text-accent-foreground',
+        },
+        size: {
+            sm: 'h-7 px-2.5 text-xs',
+            default: 'h-8 px-3 text-sm',
+            lg: 'h-10 px-4 text-sm',
+        },
+    },
+    defaultVariants: {
+        variant: 'outline',
+        size: 'default',
+    },
+});
+/**
+ * A single suggested follow-up prompt, rendered as a pill button.
+ *
+ * Projected content is the label; `value` is what gets emitted when it is
+ * picked, so the two can differ.
+ * @new
+ */
+export class SuggestionComponent {
+    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();
+    }
+    /** Value emitted when the pill is picked. @default '' */
+    value = '';
+    /** Visual style of the pill. @default 'outline' */
+    variant = 'outline';
+    /** Size of the pill. @default 'default' */
+    size = 'default';
+    /** Remixicon class shown before the label. @default '' */
+    icon = '';
+    /** Blocks interaction with the pill. @default false */
+    disabled = false;
+    /** Accessible name, when the projected label is not descriptive enough. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the pill via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with this pill's `value` when it is picked. */
+    selected = new EventEmitter();
+    parent = inject(SuggestionsService, { optional: true });
+    get computedClass() {
+        return cn(suggestionVariants({ variant: this.variant, size: this.size }), this.class);
+    }
+    onClick() {
+        if (this.disabled)
+            return;
+        this.selected.emit(this.value);
+        this.parent?.select(this.value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuggestionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SuggestionComponent, isStandalone: true, selector: "tolle-suggestion", inputs: { value: "value", variant: "variant", size: "size", icon: "icon", disabled: "disabled", ariaLabel: "ariaLabel", class: "class" }, outputs: { selected: "selected" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      type="button"
+      data-suggestion
+      [disabled]="disabled"
+      [attr.aria-label]="ariaLabel || null"
+      [class]="computedClass"
+      (click)="onClick()"
+    >
+      <i *ngIf="icon" [class]="icon" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </button>
+  `, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuggestionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-suggestion', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      type="button"
+      data-suggestion
+      [disabled]="disabled"
+      [attr.aria-label]="ariaLabel || null"
+      [class]="computedClass"
+      (click)="onClick()"
+    >
+      <i *ngIf="icon" [class]="icon" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </button>
+  `, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], selected: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suggestion.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/suggestion.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Injectable, Input, OnDestroy, OnInit, Output, inject, ChangeDetectorRef, OnChanges } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { Subject, Subscription } from 'rxjs';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/**\n * Relays a chosen suggestion from a `tolle-suggestion` up to the\n * `tolle-suggestions` row that contains it, so consumers can listen in one\n * place instead of binding every pill.\n *\n * Provided on `SuggestionsComponent`; injected optionally, since a pill is\n * perfectly usable on its own.\n */\n@Injectable()\nexport class SuggestionsService {\n  private readonly selectedSource = new Subject<string>();\n  /** Emits the value of whichever suggestion the user picked. */\n  readonly selected$ = this.selectedSource.asObservable();\n\n  select(value: string): void {\n    this.selectedSource.next(value);\n  }\n}\n\nconst suggestionsVariants = cva('flex w-full items-center overflow-x-auto scroll-fade-x', {\n  variants: {\n    gap: {\n      sm: 'gap-1',\n      default: 'gap-2',\n      lg: 'gap-3',\n    },\n  },\n  defaultVariants: {\n    gap: 'default',\n  },\n});\n\nexport type SuggestionsProps = VariantProps<typeof suggestionsVariants>;\n\n/**\n * A horizontally scrollable row of suggested follow-up prompts.\n *\n * Fill it with `tolle-suggestion` pills and listen to this component's\n * `selected` output to react to any of them.\n */\n@Component({\n  selector: 'tolle-suggestions',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [SuggestionsService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\" role=\"group\" [attr.aria-label]=\"ariaLabel || null\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class SuggestionsComponent implements OnChanges, OnInit, OnDestroy {\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  /** Spacing between the pills. @default 'default' */\n  @Input() gap: SuggestionsProps['gap'] = 'default';\n  /** Accessible name for the row. @default 'Suggestions' */\n  @Input() ariaLabel = 'Suggestions';\n  /** Extra Tailwind classes merged onto the row via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the `value` of whichever suggestion in the row was picked. */\n  @Output() selected = new EventEmitter<string>();\n\n  private readonly service = inject(SuggestionsService);\n  private readonly subscriptions = new Subscription();\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.selected$.subscribe((value) => this.selected.emit(value))\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(suggestionsVariants({ gap: this.gap }), this.class);\n  }\n}\n\nconst suggestionVariants = cva(\n  'inline-flex shrink-0 items-center gap-1.5 whitespace-nowrap rounded-full border transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:pointer-events-none disabled:opacity-50',\n  {\n    variants: {\n      variant: {\n        outline: 'border-border bg-background text-foreground hover:bg-accent hover:text-accent-foreground',\n        secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',\n        ghost: 'border-transparent bg-transparent text-muted-foreground hover:bg-accent hover:text-accent-foreground',\n      },\n      size: {\n        sm: 'h-7 px-2.5 text-xs',\n        default: 'h-8 px-3 text-sm',\n        lg: 'h-10 px-4 text-sm',\n      },\n    },\n    defaultVariants: {\n      variant: 'outline',\n      size: 'default',\n    },\n  }\n);\n\nexport type SuggestionProps = VariantProps<typeof suggestionVariants>;\n\n/**\n * A single suggested follow-up prompt, rendered as a pill button.\n *\n * Projected content is the label; `value` is what gets emitted when it is\n * picked, so the two can differ.\n * @new\n */\n@Component({\n  selector: 'tolle-suggestion',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      type=\"button\"\n      data-suggestion\n      [disabled]=\"disabled\"\n      [attr.aria-label]=\"ariaLabel || null\"\n      [class]=\"computedClass\"\n      (click)=\"onClick()\"\n    >\n      <i *ngIf=\"icon\" [class]=\"icon\" aria-hidden=\"true\"></i>\n      <ng-content></ng-content>\n    </button>\n  `,\n})\nexport class SuggestionComponent  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  /** Value emitted when the pill is picked. @default '' */\n  @Input() value = '';\n  /** Visual style of the pill. @default 'outline' */\n  @Input() variant: SuggestionProps['variant'] = 'outline';\n  /** Size of the pill. @default 'default' */\n  @Input() size: SuggestionProps['size'] = 'default';\n  /** Remixicon class shown before the label. @default '' */\n  @Input() icon = '';\n  /** Blocks interaction with the pill. @default false */\n  @Input() disabled = false;\n  /** Accessible name, when the projected label is not descriptive enough. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the pill via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with this pill's `value` when it is picked. */\n  @Output() selected = new EventEmitter<string>();\n\n  private readonly parent = inject(SuggestionsService, { optional: true });\n\n  get computedClass() {\n    return cn(suggestionVariants({ variant: this.variant, size: this.size }), this.class);\n  }\n\n  onClick(): void {\n    if (this.disabled) return;\n    this.selected.emit(this.value);\n    this.parent?.select(this.value);\n  }\n}\n"]}

package/esm2022/lib/switch.component.mjs

@@ -100,22 +100,17 @@ export class SwitchComponent {
     >
       <span [class]="thumbClass"></span>
     </button>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+  `, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SwitchComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-switch',
-                    standalone: true,
-                    imports: [CommonModule],
-                    providers: [
+            args: [{ selector: 'tolle-switch', standalone: true, imports: [CommonModule], providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
                             useExisting: forwardRef(() => SwitchComponent),
                             multi: true
                         }
-                    ],
-                    template: `
+                    ], template: `
     <button
       type="button"
       role="switch"
@@ -127,8 +122,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
     >
       <span [class]="thumbClass"></span>
     </button>
-  `
-                }]
+  `, styles: [":host{display:inline-flex}\n"] }]
         }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { class: [{
                 type: Input
             }], disabled: [{
@@ -136,4 +130,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], size: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/switch.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, forwardRef, ChangeDetectorRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst switchTrackVariants = cva(\n  'peer inline-flex shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50',\n  {\n    variants: {\n      size: {\n        xs: 'h-4 w-7',\n        sm: 'h-5 w-9',\n        default: 'h-6 w-11',\n        lg: 'h-7 w-[3.25rem]',\n      },\n      checked: {\n        true: 'bg-primary',\n        false: 'bg-input',\n      },\n    },\n    defaultVariants: {\n      size: 'default',\n      checked: false,\n    },\n  }\n);\n\nconst switchThumbVariants = cva(\n  'pointer-events-none block rounded-full bg-background shadow-lg ring-0 transition-transform',\n  {\n    variants: {\n      size: {\n        xs: 'h-3 w-3',\n        sm: 'h-4 w-4',\n        default: 'h-5 w-5',\n        lg: 'h-6 w-6',\n      },\n      checked: {\n        true: '',\n        false: 'translate-x-0',\n      },\n    },\n    compoundVariants: [\n      { size: 'xs', checked: true, class: 'translate-x-3' },\n      { size: 'sm', checked: true, class: 'translate-x-4' },\n      { size: 'default', checked: true, class: 'translate-x-5' },\n      { size: 'lg', checked: true, class: 'translate-x-6' },\n    ],\n    defaultVariants: {\n      size: 'default',\n      checked: false,\n    },\n  }\n);\n\nexport type SwitchProps = VariantProps<typeof switchTrackVariants>;\n\n@Component({\n  selector: 'tolle-switch',\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => SwitchComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <button\n      type=\"button\"\n      role=\"switch\"\n      [attr.aria-checked]=\"checked\"\n      [attr.data-state]=\"checked ? 'checked' : 'unchecked'\"\n      [disabled]=\"disabled\"\n      (click)=\"toggle()\"\n      [class]=\"trackClass\"\n    >\n      <span [class]=\"thumbClass\"></span>\n    </button>\n  `\n})\nexport class SwitchComponent implements ControlValueAccessor {\n  /** Extra Tailwind classes merged onto the switch track via `cn()` (last-wins). */\n  @Input() class = '';\n  /** Disables the switch and blocks toggling. @default false */\n  @Input() disabled = false;\n  /** Size of the switch. @default 'default' */\n  @Input() size: SwitchProps['size'] = 'default';\n\n  checked = false;\n\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  get trackClass() {\n    return cn(\n      switchTrackVariants({ size: this.size, checked: this.checked }),\n      this.class\n    );\n  }\n\n  get thumbClass() {\n    return cn(switchThumbVariants({ size: this.size, checked: this.checked }));\n  }\n\n  toggle() {\n    if (this.disabled) return;\n    this.checked = !this.checked;\n    this.onChange(this.checked);\n    this.onTouched();\n  }\n\n  // --- ControlValueAccessor ---\n  writeValue(value: boolean): void {\n    this.checked = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n  setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; this.cdr.markForCheck(); }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/switch.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, forwardRef, ChangeDetectorRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst switchTrackVariants = cva(\n  'peer inline-flex shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50',\n  {\n    variants: {\n      size: {\n        xs: 'h-4 w-7',\n        sm: 'h-5 w-9',\n        default: 'h-6 w-11',\n        lg: 'h-7 w-[3.25rem]',\n      },\n      checked: {\n        true: 'bg-primary',\n        false: 'bg-input',\n      },\n    },\n    defaultVariants: {\n      size: 'default',\n      checked: false,\n    },\n  }\n);\n\nconst switchThumbVariants = cva(\n  'pointer-events-none block rounded-full bg-background shadow-lg ring-0 transition-transform',\n  {\n    variants: {\n      size: {\n        xs: 'h-3 w-3',\n        sm: 'h-4 w-4',\n        default: 'h-5 w-5',\n        lg: 'h-6 w-6',\n      },\n      checked: {\n        true: '',\n        false: 'translate-x-0',\n      },\n    },\n    compoundVariants: [\n      { size: 'xs', checked: true, class: 'translate-x-3' },\n      { size: 'sm', checked: true, class: 'translate-x-4' },\n      { size: 'default', checked: true, class: 'translate-x-5' },\n      { size: 'lg', checked: true, class: 'translate-x-6' },\n    ],\n    defaultVariants: {\n      size: 'default',\n      checked: false,\n    },\n  }\n);\n\nexport type SwitchProps = VariantProps<typeof switchTrackVariants>;\n\n@Component({\n  selector: 'tolle-switch',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => SwitchComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <button\n      type=\"button\"\n      role=\"switch\"\n      [attr.aria-checked]=\"checked\"\n      [attr.data-state]=\"checked ? 'checked' : 'unchecked'\"\n      [disabled]=\"disabled\"\n      (click)=\"toggle()\"\n      [class]=\"trackClass\"\n    >\n      <span [class]=\"thumbClass\"></span>\n    </button>\n  `\n})\nexport class SwitchComponent implements ControlValueAccessor {\n  /** Extra Tailwind classes merged onto the switch track via `cn()` (last-wins). */\n  @Input() class = '';\n  /** Disables the switch and blocks toggling. @default false */\n  @Input() disabled = false;\n  /** Size of the switch. @default 'default' */\n  @Input() size: SwitchProps['size'] = 'default';\n\n  checked = false;\n\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  get trackClass() {\n    return cn(\n      switchTrackVariants({ size: this.size, checked: this.checked }),\n      this.class\n    );\n  }\n\n  get thumbClass() {\n    return cn(switchThumbVariants({ size: this.size, checked: this.checked }));\n  }\n\n  toggle() {\n    if (this.disabled) return;\n    this.checked = !this.checked;\n    this.onChange(this.checked);\n    this.onTouched();\n  }\n\n  // --- ControlValueAccessor ---\n  writeValue(value: boolean): void {\n    this.checked = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n  setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; this.cdr.markForCheck(); }\n}\n"]}

package/esm2022/lib/table.component.mjs

@@ -0,0 +1,213 @@
+import { Component, Directive, Input, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+/**
+ * Unstyled table primitives you compose yourself, for when you need full
+ * control over the markup.
+ *
+ * For sorting, paging, selection and column definitions out of the box, use
+ * `tolle-data-table` instead — this is the lower-level building block.
+ *
+ * Everything below the `<table>` is a **directive on the native element**
+ * (`<thead tolleTableHeader>`, `<tr tolleTableRow>`, …) rather than a custom
+ * element. A `<tolle-table-row>` wrapper would sit between `<tbody>` and `<tr>`
+ * and break the CSS table layout, so the directives style the real elements in
+ * place and add no DOM of their own.
+ *
+ * ```html
+ * <tolle-table>
+ *   <thead tolleTableHeader>
+ *     <tr tolleTableRow><th tolleTableHead>Name</th></tr>
+ *   </thead>
+ *   <tbody tolleTableBody>
+ *     <tr tolleTableRow><td tolleTableCell>Ada</td></tr>
+ *   </tbody>
+ * </tolle-table>
+ * ```
+ * @new
+ */
+export class TableComponent {
+    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 scrolling container via `cn()` (last-wins). */
+    containerClass = '';
+    /** Extra Tailwind classes merged onto the `<table>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TableComponent, isStandalone: true, selector: "tolle-table", inputs: { containerClass: "containerClass", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="cn('relative w-full overflow-x-auto', containerClass)">
+      <table [class]="cn('w-full caption-bottom border-collapse text-sm', class)">
+        <ng-content></ng-content>
+      </table>
+    </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: TableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-table', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="cn('relative w-full overflow-x-auto', containerClass)">
+      <table [class]="cn('w-full caption-bottom border-collapse text-sm', class)">
+        <ng-content></ng-content>
+      </table>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { containerClass: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Styles a native `<thead>`. */
+export class TableHeaderDirective {
+    /** Extra Tailwind classes merged onto the `<thead>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableHeaderDirective, isStandalone: true, selector: "[tolleTableHeader]", inputs: { class: "class" }, host: { properties: { "class": "cn('[&_tr]:border-b [&_tr]:border-border', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableHeader]',
+                    standalone: true,
+                    host: { '[class]': `cn('[&_tr]:border-b [&_tr]:border-border', class)` },
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Styles a native `<tbody>`. */
+export class TableBodyDirective {
+    /** Extra Tailwind classes merged onto the `<tbody>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableBodyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableBodyDirective, isStandalone: true, selector: "[tolleTableBody]", inputs: { class: "class" }, host: { properties: { "class": "cn('[&_tr:last-child]:border-0', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableBodyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableBody]',
+                    standalone: true,
+                    host: { '[class]': `cn('[&_tr:last-child]:border-0', class)` },
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Styles a native `<tfoot>` for summary or total rows. */
+export class TableFooterDirective {
+    /** Extra Tailwind classes merged onto the `<tfoot>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableFooterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableFooterDirective, isStandalone: true, selector: "[tolleTableFooter]", inputs: { class: "class" }, host: { properties: { "class": "cn('border-t border-border bg-muted/50 font-medium [&>tr]:last:border-b-0', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableFooterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableFooter]',
+                    standalone: true,
+                    host: { '[class]': `cn('border-t border-border bg-muted/50 font-medium [&>tr]:last:border-b-0', class)` },
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Styles a native `<tr>`, with an optional selected state. */
+export class TableRowDirective {
+    /** Applies the selected background and sets `data-state="selected"`. @default false */
+    selected = false;
+    /** Extra Tailwind classes merged onto the `<tr>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableRowDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableRowDirective, isStandalone: true, selector: "[tolleTableRow]", inputs: { selected: "selected", class: "class" }, host: { properties: { "attr.data-state": "selected ? 'selected' : null", "class": "cn('border-b border-border transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableRowDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableRow]',
+                    standalone: true,
+                    host: {
+                        '[attr.data-state]': `selected ? 'selected' : null`,
+                        '[class]': `cn('border-b border-border transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted', class)`,
+                    },
+                }]
+        }], propDecorators: { selected: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Styles a native `<th>` header cell. */
+export class TableHeadDirective {
+    /** Scope of the header cell for assistive tech. @default 'col' */
+    scope = 'col';
+    /** Current sort direction, surfaced as `aria-sort`. @default null */
+    sort = null;
+    /** Extra Tailwind classes merged onto the `<th>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableHeadDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableHeadDirective, isStandalone: true, selector: "[tolleTableHead]", inputs: { scope: "scope", sort: "sort", class: "class" }, host: { properties: { "attr.scope": "scope", "attr.aria-sort": "sort", "class": "cn('h-10 whitespace-nowrap px-3 text-left align-middle font-medium text-muted-foreground', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableHeadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableHead]',
+                    standalone: true,
+                    host: {
+                        '[attr.scope]': 'scope',
+                        '[attr.aria-sort]': 'sort',
+                        '[class]': `cn('h-10 whitespace-nowrap px-3 text-left align-middle font-medium text-muted-foreground', class)`,
+                    },
+                }]
+        }], propDecorators: { scope: [{
+                type: Input
+            }], sort: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Styles a native `<td>` data cell. */
+export class TableCellDirective {
+    /** Extra Tailwind classes merged onto the `<td>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableCellDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableCellDirective, isStandalone: true, selector: "[tolleTableCell]", inputs: { class: "class" }, host: { properties: { "class": "cn('p-3 align-middle', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableCellDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableCell]',
+                    standalone: true,
+                    host: { '[class]': `cn('p-3 align-middle', class)` },
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Styles a native `<caption>`, rendered below the table. */
+export class TableCaptionDirective {
+    /** Extra Tailwind classes merged onto the `<caption>` via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableCaptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableCaptionDirective, isStandalone: true, selector: "[tolleTableCaption]", inputs: { class: "class" }, host: { properties: { "class": "cn('mt-4 text-sm text-muted-foreground', class)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableCaptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleTableCaption]',
+                    standalone: true,
+                    host: { '[class]': `cn('mt-4 text-sm text-muted-foreground', class)` },
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Directive, Input, ChangeDetectionStrategy, ChangeDetectorRef, OnChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cn } from './utils/cn';\n\n/**\n * Unstyled table primitives you compose yourself, for when you need full\n * control over the markup.\n *\n * For sorting, paging, selection and column definitions out of the box, use\n * `tolle-data-table` instead — this is the lower-level building block.\n *\n * Everything below the `<table>` is a **directive on the native element**\n * (`<thead tolleTableHeader>`, `<tr tolleTableRow>`, …) rather than a custom\n * element. A `<tolle-table-row>` wrapper would sit between `<tbody>` and `<tr>`\n * and break the CSS table layout, so the directives style the real elements in\n * place and add no DOM of their own.\n *\n * ```html\n * <tolle-table>\n *   <thead tolleTableHeader>\n *     <tr tolleTableRow><th tolleTableHead>Name</th></tr>\n *   </thead>\n *   <tbody tolleTableBody>\n *     <tr tolleTableRow><td tolleTableCell>Ada</td></tr>\n *   </tbody>\n * </tolle-table>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-table',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"cn('relative w-full overflow-x-auto', containerClass)\">\n      <table [class]=\"cn('w-full caption-bottom border-collapse text-sm', class)\">\n        <ng-content></ng-content>\n      </table>\n    </div>\n  `,\n})\nexport class TableComponent  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 scrolling container via `cn()` (last-wins). */\n  @Input() containerClass = '';\n  /** Extra Tailwind classes merged onto the `<table>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<thead>`. */\n@Directive({\n  selector: '[tolleTableHeader]',\n  standalone: true,\n  host: { '[class]': `cn('[&_tr]:border-b [&_tr]:border-border', class)` },\n})\nexport class TableHeaderDirective {\n  /** Extra Tailwind classes merged onto the `<thead>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<tbody>`. */\n@Directive({\n  selector: '[tolleTableBody]',\n  standalone: true,\n  host: { '[class]': `cn('[&_tr:last-child]:border-0', class)` },\n})\nexport class TableBodyDirective {\n  /** Extra Tailwind classes merged onto the `<tbody>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<tfoot>` for summary or total rows. */\n@Directive({\n  selector: '[tolleTableFooter]',\n  standalone: true,\n  host: { '[class]': `cn('border-t border-border bg-muted/50 font-medium [&>tr]:last:border-b-0', class)` },\n})\nexport class TableFooterDirective {\n  /** Extra Tailwind classes merged onto the `<tfoot>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<tr>`, with an optional selected state. */\n@Directive({\n  selector: '[tolleTableRow]',\n  standalone: true,\n  host: {\n    '[attr.data-state]': `selected ? 'selected' : null`,\n    '[class]': `cn('border-b border-border transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted', class)`,\n  },\n})\nexport class TableRowDirective {\n  /** Applies the selected background and sets `data-state=\"selected\"`. @default false */\n  @Input() selected = false;\n  /** Extra Tailwind classes merged onto the `<tr>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<th>` header cell. */\n@Directive({\n  selector: '[tolleTableHead]',\n  standalone: true,\n  host: {\n    '[attr.scope]': 'scope',\n    '[attr.aria-sort]': 'sort',\n    '[class]': `cn('h-10 whitespace-nowrap px-3 text-left align-middle font-medium text-muted-foreground', class)`,\n  },\n})\nexport class TableHeadDirective {\n  /** Scope of the header cell for assistive tech. @default 'col' */\n  @Input() scope: 'col' | 'row' | 'colgroup' | 'rowgroup' = 'col';\n  /** Current sort direction, surfaced as `aria-sort`. @default null */\n  @Input() sort: 'ascending' | 'descending' | 'none' | null = null;\n  /** Extra Tailwind classes merged onto the `<th>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<td>` data cell. */\n@Directive({\n  selector: '[tolleTableCell]',\n  standalone: true,\n  host: { '[class]': `cn('p-3 align-middle', class)` },\n})\nexport class TableCellDirective {\n  /** Extra Tailwind classes merged onto the `<td>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Styles a native `<caption>`, rendered below the table. */\n@Directive({\n  selector: '[tolleTableCaption]',\n  standalone: true,\n  host: { '[class]': `cn('mt-4 text-sm text-muted-foreground', class)` },\n})\nexport class TableCaptionDirective {\n  /** Extra Tailwind classes merged onto the `<caption>` via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n"]}