@tolle_/tolle-ui 18.2.28 → 18.2.30

package/esm2022/lib/sources.component.mjs

@@ -0,0 +1,452 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, Output, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { skip } from 'rxjs/operators';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+let sourceId = 0;
+/**
+ * Coordinates a `tolle-sources` with its trigger, content and sources.
+ *
+ * The trigger has to report how many sources were projected into a sibling
+ * component, so every `tolle-source` registers here and the trigger renders
+ * from the resulting count.
+ *
+ * Provided on `SourcesComponent`, so each citation list gets its own instance.
+ */
+export class SourcesService {
+    openSource = new BehaviorSubject(false);
+    /** Emits whether the citation list is expanded. */
+    open$ = this.openSource.asObservable();
+    idsSource = new BehaviorSubject([]);
+    /** Emits the ids of the registered sources, in registration (DOM) order. */
+    ids$ = this.idsSource.asObservable();
+    /** True while the citation list is expanded. */
+    get open() {
+        return this.openSource.value;
+    }
+    /** How many sources are currently registered. */
+    get count() {
+        return this.idsSource.value.length;
+    }
+    setOpen(value) {
+        if (this.openSource.value !== value)
+            this.openSource.next(value);
+    }
+    toggle() {
+        this.setOpen(!this.openSource.value);
+    }
+    register(id) {
+        if (this.idsSource.value.includes(id))
+            return;
+        this.idsSource.next([...this.idsSource.value, id]);
+    }
+    unregister(id) {
+        this.idsSource.next(this.idsSource.value.filter((existing) => existing !== id));
+    }
+    /** Zero-based position of a source, or -1 when it is not registered. */
+    indexOf(id) {
+        return this.idsSource.value.indexOf(id);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesService, decorators: [{
+            type: Injectable
+        }] });
+const sourcesVariants = cva('flex w-full flex-col gap-2 text-sm', {
+    variants: {
+        variant: {
+            default: '',
+            card: 'rounded-md border border-border bg-card p-3 text-card-foreground',
+            muted: 'rounded-md bg-muted p-3',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+    },
+});
+/**
+ * A collapsible list of the citations behind a response.
+ *
+ * Compose it from `tolle-sources-trigger`, `tolle-sources-content` and one
+ * `tolle-source` per citation — the trigger counts the sources for you.
+ * @new
+ */
+export class SourcesComponent {
+    /** Whether the citation list is expanded. @default false */
+    open = false;
+    /** Visual treatment of the list container. @default 'default' */
+    variant = 'default';
+    /** Extra Tailwind classes merged onto the list via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new state whenever the list is expanded or collapsed. */
+    openChange = new EventEmitter();
+    service = inject(SourcesService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    /** True while an `open` input is being pushed into the service. */
+    applyingInput = false;
+    ngOnInit() {
+        this.service.setOpen(this.open);
+        // `skip(1)` drops the BehaviorSubject's current value so mounting never
+        // emits a spurious `openChange`.
+        this.subscriptions.add(this.service.open$.pipe(skip(1)).subscribe((open) => {
+            this.open = open;
+            this.cdr.markForCheck();
+            // Only user-driven toggles are worth reporting; echoing a change the
+            // parent just made would fight a `[(open)]` binding.
+            if (!this.applyingInput)
+                this.openChange.emit(open);
+        }));
+    }
+    ngOnChanges(changes) {
+        if (changes['open'])
+            this.applyInput(this.open);
+        // A bound `class` input is written through Angular's styling path,
+        // which does not mark an OnPush view dirty on its own.
+        this.cdr.markForCheck();
+    }
+    applyInput(open) {
+        this.applyingInput = true;
+        try {
+            this.service.setOpen(open);
+        }
+        finally {
+            this.applyingInput = false;
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn(sourcesVariants({ variant: this.variant }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SourcesComponent, isStandalone: true, selector: "tolle-sources", inputs: { open: "open", variant: "variant", class: "class" }, outputs: { openChange: "openChange" }, providers: [SourcesService], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass" [attr.data-state]="open ? 'open' : 'closed'">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-sources', standalone: true, imports: [CommonModule], providers: [SourcesService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass" [attr.data-state]="open ? 'open' : 'closed'">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { open: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+/** Toggle for a `tolle-sources`, labelled with how many sources there are. */
+export class SourcesTriggerComponent {
+    /**
+     * 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();
+    }
+    /** Overrides the counted number of sources. @default null */
+    count = null;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class = '';
+    service = inject(SourcesService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    open = false;
+    registered = 0;
+    ngOnInit() {
+        this.subscriptions.add(this.service.open$.subscribe((open) => {
+            this.open = open;
+            this.cdr.markForCheck();
+        }));
+        this.subscriptions.add(this.service.ids$.subscribe((ids) => {
+            this.registered = ids.length;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** How many sources the trigger reports. */
+    get total() {
+        return this.count ?? this.registered;
+    }
+    get label() {
+        return 'Used ' + this.total + (this.total === 1 ? ' source' : ' sources');
+    }
+    get computedClass() {
+        return cn('flex w-fit items-center gap-1.5 rounded-md px-1.5 py-1 text-sm text-muted-foreground transition-colors', 'hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring', this.class);
+    }
+    onToggle() {
+        this.service.toggle();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesTriggerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SourcesTriggerComponent, isStandalone: true, selector: "tolle-sources-trigger", inputs: { count: "count", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      type="button"
+      data-sources-trigger
+      [attr.aria-expanded]="open"
+      [attr.data-state]="open ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onToggle()"
+    >
+      <i class="ri-links-line" aria-hidden="true"></i>
+
+      <span data-sources-label>{{ label }}</span>
+
+      <i
+        class="ri-arrow-down-s-line transition-transform duration-200"
+        [class.rotate-180]="open"
+        aria-hidden="true"
+      ></i>
+
+      <ng-content></ng-content>
+    </button>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesTriggerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-sources-trigger', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      type="button"
+      data-sources-trigger
+      [attr.aria-expanded]="open"
+      [attr.data-state]="open ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="onToggle()"
+    >
+      <i class="ri-links-line" aria-hidden="true"></i>
+
+      <span data-sources-label>{{ label }}</span>
+
+      <i
+        class="ri-arrow-down-s-line transition-transform duration-200"
+        [class.rotate-180]="open"
+        aria-hidden="true"
+      ></i>
+
+      <ng-content></ng-content>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { count: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/**
+ * Holds the `tolle-source` entries of a `tolle-sources`.
+ *
+ * Stays in the DOM while collapsed — hidden and `inert` rather than removed —
+ * so the sources inside it stay registered and the trigger's count is right
+ * before the list has ever been opened.
+ */
+export class SourcesContentComponent {
+    /**
+     * 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 content via `cn()` (last-wins). */
+    class = '';
+    service = inject(SourcesService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    open = false;
+    ngOnInit() {
+        this.subscriptions.add(this.service.open$.subscribe((open) => {
+            this.open = open;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn('flex flex-col gap-1.5', !this.open && 'hidden', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourcesContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SourcesContentComponent, isStandalone: true, selector: "tolle-sources-content", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      data-sources-content
+      [attr.data-state]="open ? 'open' : 'closed'"
+      [attr.inert]="open ? null : ''"
+      [attr.aria-hidden]="open ? null : 'true'"
+      [class]="computedClass"
+    >
+      <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: SourcesContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-sources-content', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      data-sources-content
+      [attr.data-state]="open ? 'open' : 'closed'"
+      [attr.inert]="open ? null : ''"
+      [attr.aria-hidden]="open ? null : 'true'"
+      [class]="computedClass"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+const sourceVariants = cva('group flex items-center gap-2 rounded-md px-2 py-1.5 transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring', {
+    variants: {
+        size: {
+            sm: 'text-xs',
+            default: 'text-sm',
+        },
+    },
+    defaultVariants: {
+        size: 'default',
+    },
+});
+/** A single citation inside a `tolle-sources-content`. */
+export class SourceComponent {
+    /**
+     * 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();
+    }
+    /** URL the citation points at. @default '' */
+    href = '';
+    /** Human-readable title; falls back to the href when empty. @default '' */
+    title = '';
+    /** URL of a favicon shown instead of the numbered chip. @default '' */
+    favicon = '';
+    /** Overrides the auto-numbered position chip. @default null */
+    index = null;
+    /** Text scale of the citation. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the citation via `cn()` (last-wins). */
+    class = '';
+    service = inject(SourcesService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    id = 'source-' + sourceId++;
+    order = 0;
+    ngOnInit() {
+        this.service.register(this.id);
+        this.subscriptions.add(this.service.ids$.subscribe(() => {
+            this.order = this.service.indexOf(this.id);
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.service.unregister(this.id);
+        this.subscriptions.unsubscribe();
+    }
+    /** One-based number shown in the chip. */
+    get position() {
+        return this.index ?? this.order + 1;
+    }
+    get computedClass() {
+        return cn(sourceVariants({ size: this.size }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SourceComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SourceComponent, isStandalone: true, selector: "tolle-source", inputs: { href: "href", title: "title", favicon: "favicon", index: "index", size: "size", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <a
+      data-source
+      [attr.href]="href || null"
+      target="_blank"
+      rel="noreferrer noopener"
+      [class]="computedClass"
+    >
+      <img
+        *ngIf="favicon; else chip"
+        [attr.src]="favicon"
+        alt=""
+        aria-hidden="true"
+        class="size-4 shrink-0 rounded-sm"
+      />
+
+      <ng-template #chip>
+        <span
+          class="flex size-4 shrink-0 items-center justify-center rounded-sm bg-muted text-[10px] font-medium text-muted-foreground"
+          aria-hidden="true"
+          >{{ position }}</span
+        >
+      </ng-template>
+
+      <span class="truncate text-foreground" data-source-title>{{ title || href }}</span>
+
+      <i
+        class="ri-external-link-line ml-auto shrink-0 text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100"
+        aria-hidden="true"
+      ></i>
+
+      <ng-content></ng-content>
+    </a>
+  `, 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: SourceComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-source', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <a
+      data-source
+      [attr.href]="href || null"
+      target="_blank"
+      rel="noreferrer noopener"
+      [class]="computedClass"
+    >
+      <img
+        *ngIf="favicon; else chip"
+        [attr.src]="favicon"
+        alt=""
+        aria-hidden="true"
+        class="size-4 shrink-0 rounded-sm"
+      />
+
+      <ng-template #chip>
+        <span
+          class="flex size-4 shrink-0 items-center justify-center rounded-sm bg-muted text-[10px] font-medium text-muted-foreground"
+          aria-hidden="true"
+          >{{ position }}</span
+        >
+      </ng-template>
+
+      <span class="truncate text-foreground" data-source-title>{{ title || href }}</span>
+
+      <i
+        class="ri-external-link-line ml-auto shrink-0 text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100"
+        aria-hidden="true"
+      ></i>
+
+      <ng-content></ng-content>
+    </a>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { href: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], favicon: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sources.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/sources.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { skip } from 'rxjs/operators';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nlet sourceId = 0;\n\n/**\n * Coordinates a `tolle-sources` with its trigger, content and sources.\n *\n * The trigger has to report how many sources were projected into a sibling\n * component, so every `tolle-source` registers here and the trigger renders\n * from the resulting count.\n *\n * Provided on `SourcesComponent`, so each citation list gets its own instance.\n */\n@Injectable()\nexport class SourcesService {\n  private readonly openSource = new BehaviorSubject<boolean>(false);\n  /** Emits whether the citation list is expanded. */\n  readonly open$ = this.openSource.asObservable();\n\n  private readonly idsSource = new BehaviorSubject<string[]>([]);\n  /** Emits the ids of the registered sources, in registration (DOM) order. */\n  readonly ids$ = this.idsSource.asObservable();\n\n  /** True while the citation list is expanded. */\n  get open(): boolean {\n    return this.openSource.value;\n  }\n\n  /** How many sources are currently registered. */\n  get count(): number {\n    return this.idsSource.value.length;\n  }\n\n  setOpen(value: boolean): void {\n    if (this.openSource.value !== value) this.openSource.next(value);\n  }\n\n  toggle(): void {\n    this.setOpen(!this.openSource.value);\n  }\n\n  register(id: string): void {\n    if (this.idsSource.value.includes(id)) return;\n    this.idsSource.next([...this.idsSource.value, id]);\n  }\n\n  unregister(id: string): void {\n    this.idsSource.next(this.idsSource.value.filter((existing) => existing !== id));\n  }\n\n  /** Zero-based position of a source, or -1 when it is not registered. */\n  indexOf(id: string): number {\n    return this.idsSource.value.indexOf(id);\n  }\n}\n\nconst sourcesVariants = cva('flex w-full flex-col gap-2 text-sm', {\n  variants: {\n    variant: {\n      default: '',\n      card: 'rounded-md border border-border bg-card p-3 text-card-foreground',\n      muted: 'rounded-md bg-muted p-3',\n    },\n  },\n  defaultVariants: {\n    variant: 'default',\n  },\n});\n\nexport type SourcesProps = VariantProps<typeof sourcesVariants>;\n\n/**\n * A collapsible list of the citations behind a response.\n *\n * Compose it from `tolle-sources-trigger`, `tolle-sources-content` and one\n * `tolle-source` per citation — the trigger counts the sources for you.\n * @new\n */\n@Component({\n  selector: 'tolle-sources',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [SourcesService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\" [attr.data-state]=\"open ? 'open' : 'closed'\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class SourcesComponent implements OnInit, OnChanges, OnDestroy {\n  /** Whether the citation list is expanded. @default false */\n  @Input() open = false;\n  /** Visual treatment of the list container. @default 'default' */\n  @Input() variant: SourcesProps['variant'] = 'default';\n  /** Extra Tailwind classes merged onto the list via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new state whenever the list is expanded or collapsed. */\n  @Output() openChange = new EventEmitter<boolean>();\n\n  private readonly service = inject(SourcesService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n  /** True while an `open` input is being pushed into the service. */\n  private applyingInput = false;\n\n  ngOnInit(): void {\n    this.service.setOpen(this.open);\n    // `skip(1)` drops the BehaviorSubject's current value so mounting never\n    // emits a spurious `openChange`.\n    this.subscriptions.add(\n      this.service.open$.pipe(skip(1)).subscribe((open) => {\n        this.open = open;\n        this.cdr.markForCheck();\n        // Only user-driven toggles are worth reporting; echoing a change the\n        // parent just made would fight a `[(open)]` binding.\n        if (!this.applyingInput) this.openChange.emit(open);\n      })\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['open']) this.applyInput(this.open);\n  \n    // A bound `class` input is written through Angular's styling path,\n    // which does not mark an OnPush view dirty on its own.\n    this.cdr.markForCheck();\n  }\n\n  private applyInput(open: boolean): void {\n    this.applyingInput = true;\n    try {\n      this.service.setOpen(open);\n    } finally {\n      this.applyingInput = false;\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(sourcesVariants({ variant: this.variant }), this.class);\n  }\n}\n\n/** Toggle for a `tolle-sources`, labelled with how many sources there are. */\n@Component({\n  selector: 'tolle-sources-trigger',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      type=\"button\"\n      data-sources-trigger\n      [attr.aria-expanded]=\"open\"\n      [attr.data-state]=\"open ? 'open' : 'closed'\"\n      [class]=\"computedClass\"\n      (click)=\"onToggle()\"\n    >\n      <i class=\"ri-links-line\" aria-hidden=\"true\"></i>\n\n      <span data-sources-label>{{ label }}</span>\n\n      <i\n        class=\"ri-arrow-down-s-line transition-transform duration-200\"\n        [class.rotate-180]=\"open\"\n        aria-hidden=\"true\"\n      ></i>\n\n      <ng-content></ng-content>\n    </button>\n  `,\n})\nexport class SourcesTriggerComponent 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  /** Overrides the counted number of sources. @default null */\n  @Input() count: number | null = null;\n  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(SourcesService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  open = false;\n  registered = 0;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.open$.subscribe((open) => {\n        this.open = open;\n        this.cdr.markForCheck();\n      })\n    );\n    this.subscriptions.add(\n      this.service.ids$.subscribe((ids) => {\n        this.registered = ids.length;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** How many sources the trigger reports. */\n  get total(): number {\n    return this.count ?? this.registered;\n  }\n\n  get label(): string {\n    return 'Used ' + this.total + (this.total === 1 ? ' source' : ' sources');\n  }\n\n  get computedClass() {\n    return cn(\n      'flex w-fit items-center gap-1.5 rounded-md px-1.5 py-1 text-sm text-muted-foreground transition-colors',\n      'hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',\n      this.class\n    );\n  }\n\n  onToggle(): void {\n    this.service.toggle();\n  }\n}\n\n/**\n * Holds the `tolle-source` entries of a `tolle-sources`.\n *\n * Stays in the DOM while collapsed — hidden and `inert` rather than removed —\n * so the sources inside it stay registered and the trigger's count is right\n * before the list has ever been opened.\n */\n@Component({\n  selector: 'tolle-sources-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      data-sources-content\n      [attr.data-state]=\"open ? 'open' : 'closed'\"\n      [attr.inert]=\"open ? null : ''\"\n      [attr.aria-hidden]=\"open ? null : 'true'\"\n      [class]=\"computedClass\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class SourcesContentComponent 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  /** Extra Tailwind classes merged onto the content via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(SourcesService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  open = false;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.open$.subscribe((open) => {\n        this.open = open;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn('flex flex-col gap-1.5', !this.open && 'hidden', this.class);\n  }\n}\n\nconst sourceVariants = cva(\n  'group flex items-center gap-2 rounded-md px-2 py-1.5 transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',\n  {\n    variants: {\n      size: {\n        sm: 'text-xs',\n        default: 'text-sm',\n      },\n    },\n    defaultVariants: {\n      size: 'default',\n    },\n  }\n);\n\nexport type SourceProps = VariantProps<typeof sourceVariants>;\n\n/** A single citation inside a `tolle-sources-content`. */\n@Component({\n  selector: 'tolle-source',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <a\n      data-source\n      [attr.href]=\"href || null\"\n      target=\"_blank\"\n      rel=\"noreferrer noopener\"\n      [class]=\"computedClass\"\n    >\n      <img\n        *ngIf=\"favicon; else chip\"\n        [attr.src]=\"favicon\"\n        alt=\"\"\n        aria-hidden=\"true\"\n        class=\"size-4 shrink-0 rounded-sm\"\n      />\n\n      <ng-template #chip>\n        <span\n          class=\"flex size-4 shrink-0 items-center justify-center rounded-sm bg-muted text-[10px] font-medium text-muted-foreground\"\n          aria-hidden=\"true\"\n          >{{ position }}</span\n        >\n      </ng-template>\n\n      <span class=\"truncate text-foreground\" data-source-title>{{ title || href }}</span>\n\n      <i\n        class=\"ri-external-link-line ml-auto shrink-0 text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100\"\n        aria-hidden=\"true\"\n      ></i>\n\n      <ng-content></ng-content>\n    </a>\n  `,\n})\nexport class SourceComponent 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  /** URL the citation points at. @default '' */\n  @Input() href = '';\n  /** Human-readable title; falls back to the href when empty. @default '' */\n  @Input() title = '';\n  /** URL of a favicon shown instead of the numbered chip. @default '' */\n  @Input() favicon = '';\n  /** Overrides the auto-numbered position chip. @default null */\n  @Input() index: number | null = null;\n  /** Text scale of the citation. @default 'default' */\n  @Input() size: SourceProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the citation via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(SourcesService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  private readonly id = 'source-' + sourceId++;\n\n  order = 0;\n\n  ngOnInit(): void {\n    this.service.register(this.id);\n    this.subscriptions.add(\n      this.service.ids$.subscribe(() => {\n        this.order = this.service.indexOf(this.id);\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.service.unregister(this.id);\n    this.subscriptions.unsubscribe();\n  }\n\n  /** One-based number shown in the chip. */\n  get position(): number {\n    return this.index ?? this.order + 1;\n  }\n\n  get computedClass() {\n    return cn(sourceVariants({ size: this.size }), this.class);\n  }\n}\n"]}

package/esm2022/lib/spinner.component.mjs

@@ -0,0 +1,68 @@
+import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+const spinnerVariants = cva('inline-block animate-spin rounded-full border-solid border-current border-r-transparent align-[-0.125em]', {
+    variants: {
+        size: {
+            xs: 'h-3 w-3 border-[1.5px]',
+            sm: 'h-4 w-4 border-2',
+            default: 'h-5 w-5 border-2',
+            lg: 'h-8 w-8 border-[3px]',
+            xl: 'h-12 w-12 border-4',
+        },
+        variant: {
+            default: 'text-foreground',
+            primary: 'text-primary',
+            muted: 'text-muted-foreground',
+            destructive: 'text-destructive',
+        },
+    },
+    defaultVariants: { size: 'default', variant: 'default' },
+});
+/**
+ * An indeterminate loading indicator. Renders as `role="status"` with a
+ * visually-hidden label so screen readers announce the loading state.
+ * @new
+ */
+export class SpinnerComponent {
+    cdr = inject(ChangeDetectorRef);
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Diameter of the spinner. @default 'default' */
+    size = 'default';
+    /** Colour of the spinner, inherited from the theme tokens. @default 'default' */
+    variant = 'default';
+    /** Accessible label announced while the spinner is visible. @default 'Loading' */
+    label = 'Loading';
+    /** Extra Tailwind classes merged onto the spinner via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn(spinnerVariants({ size: this.size, variant: this.variant }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpinnerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SpinnerComponent, isStandalone: true, selector: "tolle-spinner", inputs: { size: "size", variant: "variant", label: "label", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <span role="status" [attr.aria-label]="label" [class]="computedClass">
+      <span class="sr-only">{{ label }}</span>
+    </span>
+  `, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpinnerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-spinner', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <span role="status" [attr.aria-label]="label" [class]="computedClass">
+      <span class="sr-only">{{ label }}</span>
+    </span>
+  `, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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