@tolle_/tolle-ui 18.2.28 → 18.2.30

package/esm2022/lib/queue.component.mjs

@@ -0,0 +1,280 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, Output, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BehaviorSubject, 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";
+let queueItemId = 0;
+const queueVariants = cva('w-full rounded-lg border border-border bg-card text-card-foreground', {
+    variants: {
+        size: {
+            sm: 'p-2 text-xs',
+            default: 'p-3 text-sm',
+        },
+    },
+    defaultVariants: { size: 'default' },
+});
+const queueItemVariants = cva('group/queue-item flex items-center gap-2 rounded-md border px-2 py-1.5 text-sm transition-colors', {
+    variants: {
+        status: {
+            queued: 'border-border bg-background text-muted-foreground',
+            running: 'border-info/40 bg-info/5 text-foreground',
+            done: 'border-transparent bg-transparent text-muted-foreground',
+        },
+    },
+    defaultVariants: { status: 'queued' },
+});
+const queueItemIconVariants = cva('shrink-0 text-base leading-none', {
+    variants: {
+        status: {
+            queued: 'text-muted-foreground',
+            running: 'text-info',
+            done: 'text-success',
+        },
+    },
+    defaultVariants: { status: 'queued' },
+});
+/** Remixicon class shown for each queue item status. */
+const QUEUE_ICONS = {
+    queued: 'ri-time-line',
+    running: 'ri-loader-4-line animate-spin',
+    done: 'ri-check-line',
+};
+/**
+ * Counts the items of a single `tolle-queue`.
+ *
+ * The header is `OnPush` and the item count is not one of its inputs, so it is
+ * published as an observable and the subscriber calls `markForCheck()`.
+ */
+export class QueueService {
+    statuses = new Map();
+    countsSource = new BehaviorSubject({
+        total: 0,
+        queued: 0,
+        running: 0,
+        done: 0,
+    });
+    /** Emits the queue's tallies whenever an item is added, updated or removed. */
+    counts$ = this.countsSource.asObservable();
+    get counts() {
+        return this.countsSource.value;
+    }
+    register(id, status) {
+        this.statuses.set(id, status);
+        this.recompute();
+    }
+    setStatus(id, status) {
+        if (!this.statuses.has(id))
+            return;
+        if (this.statuses.get(id) === status)
+            return;
+        this.statuses.set(id, status);
+        this.recompute();
+    }
+    unregister(id) {
+        if (this.statuses.delete(id))
+            this.recompute();
+    }
+    recompute() {
+        const values = [...this.statuses.values()];
+        this.countsSource.next({
+            total: values.length,
+            queued: values.filter((status) => status === 'queued').length,
+            running: values.filter((status) => status === 'running').length,
+            done: values.filter((status) => status === 'done').length,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QueueService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QueueService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QueueService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Messages or tasks waiting their turn. The header counts the entries for you,
+ * so the host only has to render `tolle-queue-item` children.
+ *
+ * ```html
+ * <tolle-queue title="Queued">
+ *   <tolle-queue-item label="Summarise the thread" status="running"></tolle-queue-item>
+ *   <tolle-queue-item label="Draft a reply" (remove)="drop(1)"></tolle-queue-item>
+ * </tolle-queue>
+ * ```
+ * @new
+ */
+export class QueueComponent {
+    /**
+     * 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();
+    }
+    /** Heading shown above the queued items. @default 'Queue' */
+    title = 'Queue';
+    /** Text shown while the queue holds nothing. @default 'Nothing queued.' */
+    emptyMessage = 'Nothing queued.';
+    /** Padding and text scale of the queue. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the queue via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the queue's tallies whenever its items change. */
+    countsChange = new EventEmitter();
+    service = inject(QueueService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    counts = this.service.counts;
+    ngOnInit() {
+        this.sub.add(this.service.counts$.subscribe((counts) => {
+            this.counts = counts;
+            this.cdr.markForCheck();
+            this.countsChange.emit(counts);
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get computedClass() {
+        return cn(queueVariants({ size: this.size }), this.class);
+    }
+    get countClass() {
+        return cn('ml-auto shrink-0 rounded-full border border-border bg-muted px-2 py-0.5 text-xs font-medium tabular-nums text-muted-foreground');
+    }
+    get listClass() {
+        return cn(this.counts.total === 0 ? 'flex flex-col' : 'mt-2 flex flex-col gap-1');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QueueComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: QueueComponent, isStandalone: true, selector: "tolle-queue", inputs: { title: "title", emptyMessage: "emptyMessage", size: "size", class: "class" }, outputs: { countsChange: "countsChange" }, providers: [QueueService], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div class="flex items-center gap-2">
+        <i class="ri-stack-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+        <span class="truncate font-medium text-foreground">{{ title }}</span>
+        <span [class]="countClass" [attr.aria-label]="counts.total + ' items queued'">{{ counts.total }}</span>
+      </div>
+
+      <p *ngIf="counts.total === 0" class="mt-2 text-sm text-muted-foreground">{{ emptyMessage }}</p>
+
+      <div role="list" [class]="listClass">
+        <ng-content></ng-content>
+      </div>
+    </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: QueueComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-queue', standalone: true, imports: [CommonModule], providers: [QueueService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div class="flex items-center gap-2">
+        <i class="ri-stack-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+        <span class="truncate font-medium text-foreground">{{ title }}</span>
+        <span [class]="countClass" [attr.aria-label]="counts.total + ' items queued'">{{ counts.total }}</span>
+      </div>
+
+      <p *ngIf="counts.total === 0" class="mt-2 text-sm text-muted-foreground">{{ emptyMessage }}</p>
+
+      <div role="list" [class]="listClass">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], emptyMessage: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], countsChange: [{
+                type: Output
+            }] } });
+/** A single entry in a `tolle-queue`. */
+export class QueueItemComponent {
+    /** Text describing the queued work. @default '' */
+    label = '';
+    /** Lifecycle state of this entry. @default 'queued' */
+    status = 'queued';
+    /** Shows the trailing dismiss button that emits `remove`. @default true */
+    removable = true;
+    /** Accessible label for the dismiss button. @default 'Remove from queue' */
+    removeLabel = 'Remove from queue';
+    /** Extra Tailwind classes merged onto the entry via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when the user dismisses this entry. */
+    remove = new EventEmitter();
+    service = inject(QueueService);
+    id = 'tolle-queue-item-' + queueItemId++;
+    ngOnInit() {
+        this.service.register(this.id, this.status);
+    }
+    ngOnChanges() {
+        this.service.setStatus(this.id, this.status);
+    }
+    ngOnDestroy() {
+        this.service.unregister(this.id);
+    }
+    get computedClass() {
+        return cn(queueItemVariants({ status: this.status }), this.class);
+    }
+    get iconClass() {
+        return cn(queueItemIconVariants({ status: this.status }), QUEUE_ICONS[this.status]);
+    }
+    get labelClass() {
+        return cn('min-w-0 flex-1 truncate', this.status === 'done' && 'line-through');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QueueItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: QueueItemComponent, isStandalone: true, selector: "tolle-queue-item", inputs: { label: "label", status: "status", removable: "removable", removeLabel: "removeLabel", class: "class" }, outputs: { remove: "remove" }, usesOnChanges: true, ngImport: i0, template: `
+    <div role="listitem" [class]="computedClass" [attr.data-status]="status">
+      <i [class]="iconClass" aria-hidden="true"></i>
+
+      <span [class]="labelClass">{{ label }}</span>
+      <ng-content></ng-content>
+
+      <button
+        *ngIf="removable"
+        type="button"
+        [attr.aria-label]="removeLabel"
+        class="ml-auto shrink-0 rounded-md p-0.5 text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+        (click)="remove.emit()"
+      >
+        <i class="ri-close-line" aria-hidden="true"></i>
+      </button>
+    </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: QueueItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-queue-item', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div role="listitem" [class]="computedClass" [attr.data-status]="status">
+      <i [class]="iconClass" aria-hidden="true"></i>
+
+      <span [class]="labelClass">{{ label }}</span>
+      <ng-content></ng-content>
+
+      <button
+        *ngIf="removable"
+        type="button"
+        [attr.aria-label]="removeLabel"
+        class="ml-auto shrink-0 rounded-md p-0.5 text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+        (click)="remove.emit()"
+      >
+        <i class="ri-close-line" aria-hidden="true"></i>
+      </button>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], status: [{
+                type: Input
+            }], removable: [{
+                type: Input
+            }], removeLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], remove: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/queue.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/** Where a queued entry is in its lifecycle. */\nexport type QueueItemStatus = 'queued' | 'running' | 'done';\n\nlet queueItemId = 0;\n\n/** Tallies of the entries currently in a queue. */\nexport interface QueueCounts {\n  total: number;\n  queued: number;\n  running: number;\n  done: number;\n}\n\nconst queueVariants = cva('w-full rounded-lg border border-border bg-card text-card-foreground', {\n  variants: {\n    size: {\n      sm: 'p-2 text-xs',\n      default: 'p-3 text-sm',\n    },\n  },\n  defaultVariants: { size: 'default' },\n});\n\nexport type QueueProps = VariantProps<typeof queueVariants>;\n\nconst queueItemVariants = cva(\n  'group/queue-item flex items-center gap-2 rounded-md border px-2 py-1.5 text-sm transition-colors',\n  {\n    variants: {\n      status: {\n        queued: 'border-border bg-background text-muted-foreground',\n        running: 'border-info/40 bg-info/5 text-foreground',\n        done: 'border-transparent bg-transparent text-muted-foreground',\n      },\n    },\n    defaultVariants: { status: 'queued' },\n  }\n);\n\nconst queueItemIconVariants = cva('shrink-0 text-base leading-none', {\n  variants: {\n    status: {\n      queued: 'text-muted-foreground',\n      running: 'text-info',\n      done: 'text-success',\n    },\n  },\n  defaultVariants: { status: 'queued' },\n});\n\nexport type QueueItemProps = VariantProps<typeof queueItemVariants>;\n\n/** Remixicon class shown for each queue item status. */\nconst QUEUE_ICONS: Record<QueueItemStatus, string> = {\n  queued: 'ri-time-line',\n  running: 'ri-loader-4-line animate-spin',\n  done: 'ri-check-line',\n};\n\n/**\n * Counts the items of a single `tolle-queue`.\n *\n * The header is `OnPush` and the item count is not one of its inputs, so it is\n * published as an observable and the subscriber calls `markForCheck()`.\n */\n@Injectable()\nexport class QueueService {\n  private readonly statuses = new Map<string, QueueItemStatus>();\n\n  private readonly countsSource = new BehaviorSubject<QueueCounts>({\n    total: 0,\n    queued: 0,\n    running: 0,\n    done: 0,\n  });\n  /** Emits the queue's tallies whenever an item is added, updated or removed. */\n  readonly counts$ = this.countsSource.asObservable();\n\n  get counts(): QueueCounts {\n    return this.countsSource.value;\n  }\n\n  register(id: string, status: QueueItemStatus): void {\n    this.statuses.set(id, status);\n    this.recompute();\n  }\n\n  setStatus(id: string, status: QueueItemStatus): void {\n    if (!this.statuses.has(id)) return;\n    if (this.statuses.get(id) === status) return;\n    this.statuses.set(id, status);\n    this.recompute();\n  }\n\n  unregister(id: string): void {\n    if (this.statuses.delete(id)) this.recompute();\n  }\n\n  private recompute(): void {\n    const values = [...this.statuses.values()];\n    this.countsSource.next({\n      total: values.length,\n      queued: values.filter((status) => status === 'queued').length,\n      running: values.filter((status) => status === 'running').length,\n      done: values.filter((status) => status === 'done').length,\n    });\n  }\n}\n\n/**\n * Messages or tasks waiting their turn. The header counts the entries for you,\n * so the host only has to render `tolle-queue-item` children.\n *\n * ```html\n * <tolle-queue title=\"Queued\">\n *   <tolle-queue-item label=\"Summarise the thread\" status=\"running\"></tolle-queue-item>\n *   <tolle-queue-item label=\"Draft a reply\" (remove)=\"drop(1)\"></tolle-queue-item>\n * </tolle-queue>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-queue',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [QueueService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <div class=\"flex items-center gap-2\">\n        <i class=\"ri-stack-line shrink-0 text-muted-foreground\" aria-hidden=\"true\"></i>\n        <span class=\"truncate font-medium text-foreground\">{{ title }}</span>\n        <span [class]=\"countClass\" [attr.aria-label]=\"counts.total + ' items queued'\">{{ counts.total }}</span>\n      </div>\n\n      <p *ngIf=\"counts.total === 0\" class=\"mt-2 text-sm text-muted-foreground\">{{ emptyMessage }}</p>\n\n      <div role=\"list\" [class]=\"listClass\">\n        <ng-content></ng-content>\n      </div>\n    </div>\n  `,\n})\nexport class QueueComponent implements OnChanges, OnInit, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Heading shown above the queued items. @default 'Queue' */\n  @Input() title = 'Queue';\n  /** Text shown while the queue holds nothing. @default 'Nothing queued.' */\n  @Input() emptyMessage = 'Nothing queued.';\n  /** Padding and text scale of the queue. @default 'default' */\n  @Input() size: QueueProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the queue via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the queue's tallies whenever its items change. */\n  @Output() countsChange = new EventEmitter<QueueCounts>();\n\n  private readonly service = inject(QueueService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  counts: QueueCounts = this.service.counts;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.counts$.subscribe((counts) => {\n        this.counts = counts;\n        this.cdr.markForCheck();\n        this.countsChange.emit(counts);\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(queueVariants({ size: this.size }), this.class);\n  }\n\n  get countClass() {\n    return cn(\n      'ml-auto shrink-0 rounded-full border border-border bg-muted px-2 py-0.5 text-xs font-medium tabular-nums text-muted-foreground'\n    );\n  }\n\n  get listClass() {\n    return cn(this.counts.total === 0 ? 'flex flex-col' : 'mt-2 flex flex-col gap-1');\n  }\n}\n\n/** A single entry in a `tolle-queue`. */\n@Component({\n  selector: 'tolle-queue-item',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div role=\"listitem\" [class]=\"computedClass\" [attr.data-status]=\"status\">\n      <i [class]=\"iconClass\" aria-hidden=\"true\"></i>\n\n      <span [class]=\"labelClass\">{{ label }}</span>\n      <ng-content></ng-content>\n\n      <button\n        *ngIf=\"removable\"\n        type=\"button\"\n        [attr.aria-label]=\"removeLabel\"\n        class=\"ml-auto shrink-0 rounded-md p-0.5 text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring\"\n        (click)=\"remove.emit()\"\n      >\n        <i class=\"ri-close-line\" aria-hidden=\"true\"></i>\n      </button>\n    </div>\n  `,\n})\nexport class QueueItemComponent implements OnInit, OnChanges, OnDestroy {\n  /** Text describing the queued work. @default '' */\n  @Input() label = '';\n  /** Lifecycle state of this entry. @default 'queued' */\n  @Input() status: QueueItemStatus = 'queued';\n  /** Shows the trailing dismiss button that emits `remove`. @default true */\n  @Input() removable = true;\n  /** Accessible label for the dismiss button. @default 'Remove from queue' */\n  @Input() removeLabel = 'Remove from queue';\n  /** Extra Tailwind classes merged onto the entry via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when the user dismisses this entry. */\n  @Output() remove = new EventEmitter<void>();\n\n  private readonly service = inject(QueueService);\n  private readonly id = 'tolle-queue-item-' + queueItemId++;\n\n  ngOnInit(): void {\n    this.service.register(this.id, this.status);\n  }\n\n  ngOnChanges(): void {\n    this.service.setStatus(this.id, this.status);\n  }\n\n  ngOnDestroy(): void {\n    this.service.unregister(this.id);\n  }\n\n  get computedClass() {\n    return cn(queueItemVariants({ status: this.status }), this.class);\n  }\n\n  get iconClass() {\n    return cn(queueItemIconVariants({ status: this.status }), QUEUE_ICONS[this.status]);\n  }\n\n  get labelClass() {\n    return cn('min-w-0 flex-1 truncate', this.status === 'done' && 'line-through');\n  }\n}\n"]}

package/esm2022/lib/radio-group.component.mjs

@@ -91,31 +91,24 @@ export class RadioGroupComponent {
     <div [class]="cn('grid gap-2', class)" role="radiogroup">
       <ng-content></ng-content>
     </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioGroupComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-radio-group',
-                    standalone: true,
-                    imports: [CommonModule],
-                    providers: [
+            args: [{ selector: 'tolle-radio-group', standalone: true, imports: [CommonModule], providers: [
                         RadioService,
                         {
                             provide: NG_VALUE_ACCESSOR,
                             useExisting: forwardRef(() => RadioGroupComponent),
                             multi: true
                         }
-                    ],
-                    host: {
+                    ], host: {
                         '(keydown)': 'onKeydown($event)'
-                    },
-                    template: `
+                    }, template: `
     <div [class]="cn('grid gap-2', class)" role="radiogroup">
       <ng-content></ng-content>
     </div>
-  `
-                }]
+  `, styles: [":host{display:block}\n"] }]
         }], ctorParameters: () => [{ type: i1.RadioService }], propDecorators: { class: [{
                 type: Input
             }], disabled: [{
@@ -123,4 +116,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], name: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-group.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/radio-group.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, Input, forwardRef, AfterContentInit, OnChanges} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { cn } from './utils/cn';\nimport {RadioService} from './radio-service';\n\n@Component({\n  selector: 'tolle-radio-group',\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    RadioService,\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => RadioGroupComponent),\n      multi: true\n    }\n  ],\n  host: {\n    '(keydown)': 'onKeydown($event)'\n  },\n  template: `\n    <div [class]=\"cn('grid gap-2', class)\" role=\"radiogroup\">\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class RadioGroupComponent implements ControlValueAccessor, OnChanges {\n  @Input() class = '';\n  @Input() disabled = false;\n  @Input() name = `radio-group-${Math.random().toString(36).substring(2, 9)}`;\n\n  value: any;\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  /** Suppresses onChange while applying a programmatic writeValue(). */\n  private suppress = false;\n\n  constructor(private radioService: RadioService) {\n    this.radioService.selectedValue$.subscribe(val => {\n      this.value = val;\n      if (!this.suppress) {\n        this.onChange(val);\n        this.onTouched();\n      }\n    });\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.radioService.setDisabled(isDisabled);\n  }\n\n  ngOnChanges() {\n    this.radioService.setDisabled(this.disabled);\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    this.suppress = true;\n    this.radioService.select(value);\n    this.suppress = false;\n  }\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n\n  /**\n   * WAI-ARIA radio group keyboard nav: Arrow Down/Right select+focus the next\n   * enabled item, Arrow Up/Left the previous. Wraps around and skips disabled\n   * items; moving selection also moves focus.\n   */\n  onKeydown(event: KeyboardEvent): void {\n    if (this.disabled) return;\n\n    const key = event.key;\n    const forward = key === 'ArrowDown' || key === 'ArrowRight';\n    const backward = key === 'ArrowUp' || key === 'ArrowLeft';\n    if (!forward && !backward) return;\n\n    const items = this.radioService.getEnabledItems();\n    if (!items.length) return;\n\n    event.preventDefault();\n\n    const target = event.target as HTMLElement | null;\n    let current = target\n      ? items.findIndex(i => i.hostElement === target || i.hostElement.contains(target))\n      : -1;\n    if (current < 0) {\n      // Fall back to the currently selected item.\n      current = items.findIndex(i => i.value === this.value);\n    }\n\n    let next: number;\n    if (current < 0) {\n      next = forward ? 0 : items.length - 1;\n    } else {\n      next = forward\n        ? (current + 1) % items.length\n        : (current - 1 + items.length) % items.length;\n    }\n\n    const targetItem = items[next];\n    this.radioService.select(targetItem.value);\n    targetItem.focusItem();\n  }\n\n  protected readonly cn = cn;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-group.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/radio-group.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, Input, forwardRef, AfterContentInit, OnChanges} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { cn } from './utils/cn';\nimport {RadioService} from './radio-service';\n\n@Component({\n  selector: 'tolle-radio-group',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    RadioService,\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => RadioGroupComponent),\n      multi: true\n    }\n  ],\n  host: {\n    '(keydown)': 'onKeydown($event)'\n  },\n  template: `\n    <div [class]=\"cn('grid gap-2', class)\" role=\"radiogroup\">\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class RadioGroupComponent implements ControlValueAccessor, OnChanges {\n  @Input() class = '';\n  @Input() disabled = false;\n  @Input() name = `radio-group-${Math.random().toString(36).substring(2, 9)}`;\n\n  value: any;\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  /** Suppresses onChange while applying a programmatic writeValue(). */\n  private suppress = false;\n\n  constructor(private radioService: RadioService) {\n    this.radioService.selectedValue$.subscribe(val => {\n      this.value = val;\n      if (!this.suppress) {\n        this.onChange(val);\n        this.onTouched();\n      }\n    });\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.radioService.setDisabled(isDisabled);\n  }\n\n  ngOnChanges() {\n    this.radioService.setDisabled(this.disabled);\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    this.suppress = true;\n    this.radioService.select(value);\n    this.suppress = false;\n  }\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n\n  /**\n   * WAI-ARIA radio group keyboard nav: Arrow Down/Right select+focus the next\n   * enabled item, Arrow Up/Left the previous. Wraps around and skips disabled\n   * items; moving selection also moves focus.\n   */\n  onKeydown(event: KeyboardEvent): void {\n    if (this.disabled) return;\n\n    const key = event.key;\n    const forward = key === 'ArrowDown' || key === 'ArrowRight';\n    const backward = key === 'ArrowUp' || key === 'ArrowLeft';\n    if (!forward && !backward) return;\n\n    const items = this.radioService.getEnabledItems();\n    if (!items.length) return;\n\n    event.preventDefault();\n\n    const target = event.target as HTMLElement | null;\n    let current = target\n      ? items.findIndex(i => i.hostElement === target || i.hostElement.contains(target))\n      : -1;\n    if (current < 0) {\n      // Fall back to the currently selected item.\n      current = items.findIndex(i => i.value === this.value);\n    }\n\n    let next: number;\n    if (current < 0) {\n      next = forward ? 0 : items.length - 1;\n    } else {\n      next = forward\n        ? (current + 1) % items.length\n        : (current - 1 + items.length) % items.length;\n    }\n\n    const targetItem = items[next];\n    this.radioService.select(targetItem.value);\n    targetItem.focusItem();\n  }\n\n  protected readonly cn = cn;\n}\n"]}

package/esm2022/lib/radio-item.component.mjs

@@ -97,15 +97,11 @@ export class RadioItemComponent {
         <ng-content></ng-content>
       </label>
     </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioItemComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-radio-item',
-                    standalone: true,
-                    imports: [CommonModule],
-                    template: `
+            args: [{ selector: 'tolle-radio-item', standalone: true, imports: [CommonModule], template: `
     <div
       (click)="!isEffectiveDisabled && select()"
       [class]="cn(
@@ -138,8 +134,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         <ng-content></ng-content>
       </label>
     </div>
-  `
-                }]
+  `, styles: [":host{display:block}\n"] }]
         }], ctorParameters: () => [{ type: i1.RadioService }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }], propDecorators: { value: [{
                 type: Input
             }], disabled: [{
@@ -147,4 +142,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], class: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-item.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/radio-item.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnDestroy, ChangeDetectorRef, ElementRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cn } from './utils/cn';\nimport { RadioService, RovingRadioItem } from './radio-service';\nimport { Subscription } from 'rxjs';\n\n@Component({\n  selector: 'tolle-radio-item',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      (click)=\"!isEffectiveDisabled && select()\"\n      [class]=\"cn(\n        'flex items-center space-x-2 group py-1',\n        isEffectiveDisabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'\n      )\"\n    >\n      <div\n        role=\"radio\"\n        [attr.aria-checked]=\"isSelected\"\n        [attr.aria-disabled]=\"isEffectiveDisabled || null\"\n        [attr.data-state]=\"isSelected ? 'checked' : 'unchecked'\"\n        [attr.tabindex]=\"isEffectiveDisabled ? -1 : (isTabbable ? 0 : -1)\"\n        (keydown.enter)=\"isEffectiveDisabled ? null : select()\"\n        (keydown.space)=\"isEffectiveDisabled ? null : select(); $event.preventDefault()\"\n        [class]=\"cn(\n        'aspect-square h-4 w-4 rounded-full border border-primary text-primary transition-all flex items-center justify-center',\n        'outline-none ring-offset-background focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n        !isEffectiveDisabled && 'group-hover:border-primary/70',\n        isSelected ? 'bg-background' : 'bg-transparent',\n        class\n      )\">\n        <div\n          *ngIf=\"isSelected\"\n          class=\"h-2.5 w-2.5 rounded-full bg-primary animate-in zoom-in-50 duration-200\"\n        ></div>\n      </div>\n\n      <label class=\"text-sm font-medium leading-none select-none\" [class.cursor-pointer]=\"!isEffectiveDisabled\">\n        <ng-content></ng-content>\n      </label>\n    </div>\n  `\n})\nexport class RadioItemComponent implements OnInit, OnDestroy, RovingRadioItem {\n  @Input() value: any;\n  @Input() disabled = false;\n  @Input() class = '';\n\n  isSelected = false;\n  groupDisabled = false;\n  /** Whether this item is the single roving tab stop for the group. */\n  isTabbable = false;\n\n  private sub = new Subscription();\n\n  get isEffectiveDisabled(): boolean {\n    return this.disabled || this.groupDisabled;\n  }\n\n  // Inject ChangeDetectorRef to ensure UI updates when service emits\n  constructor(\n    private radioService: RadioService,\n    private cdr: ChangeDetectorRef,\n    private el: ElementRef<HTMLElement>\n  ) {}\n\n  // --- RovingRadioItem contract (used by the group/service for keyboard nav) ---\n  get hostElement(): HTMLElement {\n    return this.el.nativeElement;\n  }\n\n  isItemDisabled(): boolean {\n    return this.isEffectiveDisabled;\n  }\n\n  focusItem(): void {\n    const radioEl = this.el.nativeElement.querySelector('[role=\"radio\"]') as HTMLElement | null;\n    radioEl?.focus();\n  }\n\n  ngOnInit() {\n    // Listen for selection changes\n    this.sub.add(\n      this.radioService.selectedValue$.subscribe(val => {\n        this.isSelected = (val === this.value);\n        this.cdr.markForCheck(); // Trigger UI refresh\n      })\n    );\n\n    // Listen for group-level disabled state\n    this.sub.add(\n      this.radioService.disabled$.subscribe(dis => {\n        this.groupDisabled = dis;\n        this.cdr.markForCheck(); // Trigger UI refresh\n      })\n    );\n\n    // Listen for roving tabindex changes (which single item is tab-reachable)\n    this.sub.add(\n      this.radioService.tabbableValue$.subscribe(val => {\n        this.isTabbable = (val === this.value);\n        this.cdr.markForCheck(); // Trigger UI refresh\n      })\n    );\n\n    this.radioService.register(this);\n  }\n\n  select() {\n    this.radioService.select(this.value);\n  }\n\n  ngOnDestroy() {\n    this.radioService.unregister(this);\n    this.sub.unsubscribe(); // Clean up subscriptions\n  }\n\n  protected cn = cn;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-item.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/radio-item.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnDestroy, ChangeDetectorRef, ElementRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cn } from './utils/cn';\nimport { RadioService, RovingRadioItem } from './radio-service';\nimport { Subscription } from 'rxjs';\n\n@Component({\n  selector: 'tolle-radio-item',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      (click)=\"!isEffectiveDisabled && select()\"\n      [class]=\"cn(\n        'flex items-center space-x-2 group py-1',\n        isEffectiveDisabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'\n      )\"\n    >\n      <div\n        role=\"radio\"\n        [attr.aria-checked]=\"isSelected\"\n        [attr.aria-disabled]=\"isEffectiveDisabled || null\"\n        [attr.data-state]=\"isSelected ? 'checked' : 'unchecked'\"\n        [attr.tabindex]=\"isEffectiveDisabled ? -1 : (isTabbable ? 0 : -1)\"\n        (keydown.enter)=\"isEffectiveDisabled ? null : select()\"\n        (keydown.space)=\"isEffectiveDisabled ? null : select(); $event.preventDefault()\"\n        [class]=\"cn(\n        'aspect-square h-4 w-4 rounded-full border border-primary text-primary transition-all flex items-center justify-center',\n        'outline-none ring-offset-background focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n        !isEffectiveDisabled && 'group-hover:border-primary/70',\n        isSelected ? 'bg-background' : 'bg-transparent',\n        class\n      )\">\n        <div\n          *ngIf=\"isSelected\"\n          class=\"h-2.5 w-2.5 rounded-full bg-primary animate-in zoom-in-50 duration-200\"\n        ></div>\n      </div>\n\n      <label class=\"text-sm font-medium leading-none select-none\" [class.cursor-pointer]=\"!isEffectiveDisabled\">\n        <ng-content></ng-content>\n      </label>\n    </div>\n  `\n})\nexport class RadioItemComponent implements OnInit, OnDestroy, RovingRadioItem {\n  @Input() value: any;\n  @Input() disabled = false;\n  @Input() class = '';\n\n  isSelected = false;\n  groupDisabled = false;\n  /** Whether this item is the single roving tab stop for the group. */\n  isTabbable = false;\n\n  private sub = new Subscription();\n\n  get isEffectiveDisabled(): boolean {\n    return this.disabled || this.groupDisabled;\n  }\n\n  // Inject ChangeDetectorRef to ensure UI updates when service emits\n  constructor(\n    private radioService: RadioService,\n    private cdr: ChangeDetectorRef,\n    private el: ElementRef<HTMLElement>\n  ) {}\n\n  // --- RovingRadioItem contract (used by the group/service for keyboard nav) ---\n  get hostElement(): HTMLElement {\n    return this.el.nativeElement;\n  }\n\n  isItemDisabled(): boolean {\n    return this.isEffectiveDisabled;\n  }\n\n  focusItem(): void {\n    const radioEl = this.el.nativeElement.querySelector('[role=\"radio\"]') as HTMLElement | null;\n    radioEl?.focus();\n  }\n\n  ngOnInit() {\n    // Listen for selection changes\n    this.sub.add(\n      this.radioService.selectedValue$.subscribe(val => {\n        this.isSelected = (val === this.value);\n        this.cdr.markForCheck(); // Trigger UI refresh\n      })\n    );\n\n    // Listen for group-level disabled state\n    this.sub.add(\n      this.radioService.disabled$.subscribe(dis => {\n        this.groupDisabled = dis;\n        this.cdr.markForCheck(); // Trigger UI refresh\n      })\n    );\n\n    // Listen for roving tabindex changes (which single item is tab-reachable)\n    this.sub.add(\n      this.radioService.tabbableValue$.subscribe(val => {\n        this.isTabbable = (val === this.value);\n        this.cdr.markForCheck(); // Trigger UI refresh\n      })\n    );\n\n    this.radioService.register(this);\n  }\n\n  select() {\n    this.radioService.select(this.value);\n  }\n\n  ngOnDestroy() {\n    this.radioService.unregister(this);\n    this.sub.unsubscribe(); // Clean up subscriptions\n  }\n\n  protected cn = cn;\n}\n"]}