@tolle_/tolle-ui 18.2.29 → 18.3.0

package/esm2022/lib/field.component.mjs

@@ -0,0 +1,394 @@
+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";
+import * as i1 from "@angular/common";
+const fieldVariants = cva('group/field flex w-full gap-2 data-[invalid=true]:text-destructive', {
+    variants: {
+        orientation: {
+            vertical: 'flex-col',
+            horizontal: 'flex-row items-center justify-between',
+            // shadcn uses container queries here, but this preset is Tailwind 3.4 with no
+            // container-queries plugin — `@md/...` classes would be silently dropped and the
+            // field would never go horizontal. Viewport breakpoints work with the stack we have.
+            responsive: 'flex-col md:flex-row md:items-center md:justify-between',
+        },
+    },
+    defaultVariants: { orientation: 'vertical' },
+});
+/**
+ * Wraps a label, a control and its help/error text into one accessible form
+ * field. Composes *around* the existing controls (`tolle-input`,
+ * `tolle-select`, …) — it does not replace them.
+ *
+ * Use `tolle-item` instead when displaying content rather than a form control.
+ * @new
+ */
+export class FieldComponent {
+    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();
+    }
+    /** Layout direction; `responsive` goes horizontal at the `@md` container width. @default 'vertical' */
+    orientation = 'vertical';
+    /** Marks the field invalid, turning on the destructive styling for descendants. @default false */
+    invalid = false;
+    /** Extra Tailwind classes merged onto the field via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn(fieldVariants({ orientation: this.orientation }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldComponent, isStandalone: true, selector: "tolle-field", inputs: { orientation: "orientation", invalid: "invalid", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div role="group" [attr.data-invalid]="invalid || null" [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: FieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div role="group" [attr.data-invalid]="invalid || null" [class]="computedClass">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { orientation: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/**
+ * Label for a field's control. Set `for` to the control's `id` so clicking the
+ * label focuses it.
+ */
+export class FieldLabelComponent {
+    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();
+    }
+    /** Id of the control this label describes; wire it to the control's `id`. @default '' */
+    for = '';
+    /** Appends a required marker (*) after the label text. @default false */
+    required = false;
+    /** Extra Tailwind classes merged onto the label via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldLabelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldLabelComponent, isStandalone: true, selector: "tolle-field-label", inputs: { for: "for", required: "required", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <label
+      [attr.for]="for || null"
+      [class]="cn(
+        'flex items-center gap-2 text-sm font-medium leading-none text-foreground',
+        'group-data-[invalid=true]/field:text-destructive',
+        'peer-disabled:cursor-not-allowed peer-disabled:opacity-50',
+        class
+      )"
+    >
+      <ng-content></ng-content>
+      <span *ngIf="required" class="text-destructive" aria-hidden="true">*</span>
+    </label>
+  `, 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: FieldLabelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-label', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <label
+      [attr.for]="for || null"
+      [class]="cn(
+        'flex items-center gap-2 text-sm font-medium leading-none text-foreground',
+        'group-data-[invalid=true]/field:text-destructive',
+        'peer-disabled:cursor-not-allowed peer-disabled:opacity-50',
+        class
+      )"
+    >
+      <ng-content></ng-content>
+      <span *ngIf="required" class="text-destructive" aria-hidden="true">*</span>
+    </label>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { for: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Column that groups the control with its description and error text. */
+export class FieldContentComponent {
+    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 content column via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldContentComponent, isStandalone: true, selector: "tolle-field-content", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div [class]="cn('flex flex-1 flex-col gap-1.5', class)"><ng-content></ng-content></div>`, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-content', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="cn('flex flex-1 flex-col gap-1.5', class)"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/**
+ * Helper text below a control. Give it an `id` and point the control's
+ * `aria-describedby` at it.
+ */
+export class FieldDescriptionComponent {
+    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();
+    }
+    /** Id to reference from the control's `aria-describedby`. @default '' */
+    id = '';
+    /** Extra Tailwind classes merged onto the description via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldDescriptionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldDescriptionComponent, isStandalone: true, selector: "tolle-field-description", inputs: { id: "id", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <p [id]="id || null" [class]="cn('text-balance text-xs text-muted-foreground', class)">
+      <ng-content></ng-content>
+    </p>
+  `, 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: FieldDescriptionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-description', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <p [id]="id || null" [class]="cn('text-balance text-xs text-muted-foreground', class)">
+      <ng-content></ng-content>
+    </p>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/**
+ * Error text for a field. Renders nothing when there is no error, so it is safe
+ * to leave in the template permanently. Announces via `role="alert"`.
+ */
+export class FieldErrorComponent {
+    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();
+    }
+    /**
+     * Validation message(s). Accepts a single string, an array of strings, or an
+     * Angular `ValidationErrors`-style object whose values are messages.
+     * @default ''
+     */
+    errors = '';
+    /** Id to reference from the control's `aria-describedby`. @default '' */
+    id = '';
+    /** Extra Tailwind classes merged onto the error text via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    /** Normalises the three accepted `errors` shapes to a flat list of strings. */
+    get messages() {
+        const e = this.errors;
+        if (!e)
+            return [];
+        if (typeof e === 'string')
+            return e ? [e] : [];
+        if (Array.isArray(e))
+            return e.filter(Boolean).map(String);
+        return Object.values(e)
+            .filter((v) => v !== false && v !== null && v !== undefined)
+            .map((v) => (typeof v === 'string' ? v : String(v)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldErrorComponent, isStandalone: true, selector: "tolle-field-error", inputs: { errors: "errors", id: "id", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      *ngIf="messages.length"
+      [id]="id || null"
+      role="alert"
+      [class]="cn('text-xs font-medium text-destructive', class)"
+    >
+      <ng-container *ngIf="messages.length === 1">{{ messages[0] }}</ng-container>
+      <ul *ngIf="messages.length > 1" class="ml-4 list-disc space-y-0.5">
+        <li *ngFor="let message of messages">{{ message }}</li>
+      </ul>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldErrorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-error', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      *ngIf="messages.length"
+      [id]="id || null"
+      role="alert"
+      [class]="cn('text-xs font-medium text-destructive', class)"
+    >
+      <ng-container *ngIf="messages.length === 1">{{ messages[0] }}</ng-container>
+      <ul *ngIf="messages.length > 1" class="ml-4 list-disc space-y-0.5">
+        <li *ngFor="let message of messages">{{ message }}</li>
+      </ul>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { errors: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Stacks several fields with consistent spacing. */
+export class FieldGroupComponent {
+    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 group via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldGroupComponent, isStandalone: true, selector: "tolle-field-group", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div [class]="cn('flex w-full flex-col gap-6', class)"><ng-content></ng-content></div>`, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-group', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="cn('flex w-full flex-col gap-6', class)"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Semantic `<fieldset>` grouping related fields under a legend. */
+export class FieldSetComponent {
+    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 fieldset via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldSetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldSetComponent, isStandalone: true, selector: "tolle-field-set", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<fieldset [class]="cn('flex w-full flex-col gap-4 border-0 p-0', class)"><ng-content></ng-content></fieldset>`, 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: FieldSetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-set', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<fieldset [class]="cn('flex w-full flex-col gap-4 border-0 p-0', class)"><ng-content></ng-content></fieldset>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+const fieldLegendVariants = cva('mb-1 font-medium text-foreground', {
+    variants: {
+        variant: {
+            legend: 'text-base',
+            label: 'text-sm leading-none',
+        },
+    },
+    defaultVariants: { variant: 'legend' },
+});
+/** `<legend>` for a `tolle-field-set`. */
+export class FieldLegendComponent {
+    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();
+    }
+    /** Type scale of the legend. @default 'legend' */
+    variant = 'legend';
+    /** Extra Tailwind classes merged onto the legend via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn(fieldLegendVariants({ variant: this.variant }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldLegendComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldLegendComponent, isStandalone: true, selector: "tolle-field-legend", inputs: { variant: "variant", class: "class" }, usesOnChanges: true, ngImport: i0, template: `<legend [class]="computedClass"><ng-content></ng-content></legend>`, 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: FieldLegendComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-legend', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<legend [class]="computedClass"><ng-content></ng-content></legend>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+/** Divider between sections of a form. */
+export class FieldSeparatorComponent {
+    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 separator via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldSeparatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldSeparatorComponent, isStandalone: true, selector: "tolle-field-separator", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div role="separator" [class]="cn('h-px w-full bg-border', class)"></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: FieldSeparatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-separator', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div role="separator" [class]="cn('h-px w-full bg-border', class)"></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Title for a group of fields that is not a `<legend>`. */
+export class FieldTitleComponent {
+    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 title via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldTitleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FieldTitleComponent, isStandalone: true, selector: "tolle-field-title", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `<div [class]="cn('text-sm font-medium leading-none text-foreground', class)"><ng-content></ng-content></div>`, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldTitleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-field-title', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="cn('text-sm font-medium leading-none text-foreground', class)"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/field.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ChangeDetectionStrategy, ChangeDetectorRef, OnChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst fieldVariants = cva('group/field flex w-full gap-2 data-[invalid=true]:text-destructive', {\n  variants: {\n    orientation: {\n      vertical: 'flex-col',\n      horizontal: 'flex-row items-center justify-between',\n      // shadcn uses container queries here, but this preset is Tailwind 3.4 with no\n      // container-queries plugin — `@md/...` classes would be silently dropped and the\n      // field would never go horizontal. Viewport breakpoints work with the stack we have.\n      responsive: 'flex-col md:flex-row md:items-center md:justify-between',\n    },\n  },\n  defaultVariants: { orientation: 'vertical' },\n});\n\nexport type FieldProps = VariantProps<typeof fieldVariants>;\n\n/**\n * Wraps a label, a control and its help/error text into one accessible form\n * field. Composes *around* the existing controls (`tolle-input`,\n * `tolle-select`, …) — it does not replace them.\n *\n * Use `tolle-item` instead when displaying content rather than a form control.\n * @new\n */\n@Component({\n  selector: 'tolle-field',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div role=\"group\" [attr.data-invalid]=\"invalid || null\" [class]=\"computedClass\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class FieldComponent  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  /** Layout direction; `responsive` goes horizontal at the `@md` container width. @default 'vertical' */\n  @Input() orientation: FieldProps['orientation'] = 'vertical';\n  /** Marks the field invalid, turning on the destructive styling for descendants. @default false */\n  @Input() invalid = false;\n  /** Extra Tailwind classes merged onto the field via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(fieldVariants({ orientation: this.orientation }), this.class);\n  }\n}\n\n/**\n * Label for a field's control. Set `for` to the control's `id` so clicking the\n * label focuses it.\n */\n@Component({\n  selector: 'tolle-field-label',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <label\n      [attr.for]=\"for || null\"\n      [class]=\"cn(\n        'flex items-center gap-2 text-sm font-medium leading-none text-foreground',\n        'group-data-[invalid=true]/field:text-destructive',\n        'peer-disabled:cursor-not-allowed peer-disabled:opacity-50',\n        class\n      )\"\n    >\n      <ng-content></ng-content>\n      <span *ngIf=\"required\" class=\"text-destructive\" aria-hidden=\"true\">*</span>\n    </label>\n  `,\n})\nexport class FieldLabelComponent  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  /** Id of the control this label describes; wire it to the control's `id`. @default '' */\n  @Input() for = '';\n  /** Appends a required marker (*) after the label text. @default false */\n  @Input() required = false;\n  /** Extra Tailwind classes merged onto the label via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Column that groups the control with its description and error text. */\n@Component({\n  selector: 'tolle-field-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"cn('flex flex-1 flex-col gap-1.5', class)\"><ng-content></ng-content></div>`,\n})\nexport class FieldContentComponent  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 content column via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/**\n * Helper text below a control. Give it an `id` and point the control's\n * `aria-describedby` at it.\n */\n@Component({\n  selector: 'tolle-field-description',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <p [id]=\"id || null\" [class]=\"cn('text-balance text-xs text-muted-foreground', class)\">\n      <ng-content></ng-content>\n    </p>\n  `,\n})\nexport class FieldDescriptionComponent  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  /** Id to reference from the control's `aria-describedby`. @default '' */\n  @Input() id = '';\n  /** Extra Tailwind classes merged onto the description via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/**\n * Error text for a field. Renders nothing when there is no error, so it is safe\n * to leave in the template permanently. Announces via `role=\"alert\"`.\n */\n@Component({\n  selector: 'tolle-field-error',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      *ngIf=\"messages.length\"\n      [id]=\"id || null\"\n      role=\"alert\"\n      [class]=\"cn('text-xs font-medium text-destructive', class)\"\n    >\n      <ng-container *ngIf=\"messages.length === 1\">{{ messages[0] }}</ng-container>\n      <ul *ngIf=\"messages.length > 1\" class=\"ml-4 list-disc space-y-0.5\">\n        <li *ngFor=\"let message of messages\">{{ message }}</li>\n      </ul>\n    </div>\n  `,\n})\nexport class FieldErrorComponent  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  /**\n   * Validation message(s). Accepts a single string, an array of strings, or an\n   * Angular `ValidationErrors`-style object whose values are messages.\n   * @default ''\n   */\n  @Input() errors: string | string[] | Record<string, any> | null = '';\n  /** Id to reference from the control's `aria-describedby`. @default '' */\n  @Input() id = '';\n  /** Extra Tailwind classes merged onto the error text via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n\n  /** Normalises the three accepted `errors` shapes to a flat list of strings. */\n  get messages(): string[] {\n    const e = this.errors;\n    if (!e) return [];\n    if (typeof e === 'string') return e ? [e] : [];\n    if (Array.isArray(e)) return e.filter(Boolean).map(String);\n    return Object.values(e)\n      .filter((v) => v !== false && v !== null && v !== undefined)\n      .map((v) => (typeof v === 'string' ? v : String(v)));\n  }\n}\n\n/** Stacks several fields with consistent spacing. */\n@Component({\n  selector: 'tolle-field-group',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"cn('flex w-full flex-col gap-6', class)\"><ng-content></ng-content></div>`,\n})\nexport class FieldGroupComponent  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 group via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Semantic `<fieldset>` grouping related fields under a legend. */\n@Component({\n  selector: 'tolle-field-set',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<fieldset [class]=\"cn('flex w-full flex-col gap-4 border-0 p-0', class)\"><ng-content></ng-content></fieldset>`,\n})\nexport class FieldSetComponent  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 fieldset via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\nconst fieldLegendVariants = cva('mb-1 font-medium text-foreground', {\n  variants: {\n    variant: {\n      legend: 'text-base',\n      label: 'text-sm leading-none',\n    },\n  },\n  defaultVariants: { variant: 'legend' },\n});\n\nexport type FieldLegendProps = VariantProps<typeof fieldLegendVariants>;\n\n/** `<legend>` for a `tolle-field-set`. */\n@Component({\n  selector: 'tolle-field-legend',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<legend [class]=\"computedClass\"><ng-content></ng-content></legend>`,\n})\nexport class FieldLegendComponent  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  /** Type scale of the legend. @default 'legend' */\n  @Input() variant: FieldLegendProps['variant'] = 'legend';\n  /** Extra Tailwind classes merged onto the legend via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(fieldLegendVariants({ variant: this.variant }), this.class);\n  }\n}\n\n/** Divider between sections of a form. */\n@Component({\n  selector: 'tolle-field-separator',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div role=\"separator\" [class]=\"cn('h-px w-full bg-border', class)\"></div>`,\n})\nexport class FieldSeparatorComponent  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 separator via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/** Title for a group of fields that is not a `<legend>`. */\n@Component({\n  selector: 'tolle-field-title',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"cn('text-sm font-medium leading-none text-foreground', class)\"><ng-content></ng-content></div>`,\n})\nexport class FieldTitleComponent  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 title via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n"]}

package/esm2022/lib/hover-card.component.mjs

@@ -54,16 +54,11 @@ export class HoverCardComponent {
             clearTimeout(this.closeTimeout);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoverCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: HoverCardComponent, isStandalone: true, selector: "tolle-hover-card", inputs: { openDelay: "openDelay", closeDelay: "closeDelay", placement: "placement" }, queries: [{ propertyName: "contentComponent", first: true, predicate: i0.forwardRef(() => HoverCardContentComponent), descendants: true }], ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: HoverCardComponent, isStandalone: true, selector: "tolle-hover-card", inputs: { openDelay: "openDelay", closeDelay: "closeDelay", placement: "placement" }, queries: [{ propertyName: "contentComponent", first: true, predicate: i0.forwardRef(() => HoverCardContentComponent), descendants: true }], ngImport: i0, template: `<ng-content></ng-content>`, 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: HoverCardComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-hover-card',
-                    standalone: true,
-                    imports: [CommonModule],
-                    template: `<ng-content></ng-content>`
-                }]
+            args: [{ selector: 'tolle-hover-card', standalone: true, imports: [CommonModule], template: `<ng-content></ng-content>`, styles: [":host{display:block}\n"] }]
         }], propDecorators: { openDelay: [{
                 type: Input
             }], closeDelay: [{
@@ -160,15 +155,11 @@ export class HoverCardContentComponent {
          (mouseleave)="onMouseLeave()">
       <ng-content></ng-content>
     </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoverCardContentComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-hover-card-content',
-                    standalone: true,
-                    imports: [CommonModule],
-                    template: `
+            args: [{ selector: 'tolle-hover-card-content', standalone: true, imports: [CommonModule], template: `
     <div *ngIf="isVisible"
          #content
          [class]="computedClass"
@@ -176,12 +167,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
          (mouseleave)="onMouseLeave()">
       <ng-content></ng-content>
     </div>
-  `
-                }]
+  `, styles: [":host{display:block}\n"] }]
         }], propDecorators: { class: [{
                 type: Input
             }], contentEl: [{
                 type: ViewChild,
                 args: ['content']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hover-card.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/hover-card.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, inject, TemplateRef, ViewChild, ViewContainerRef, OnDestroy, ContentChild, forwardRef, ElementRef, AfterViewInit } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';\nimport { cn } from './utils/cn';\n\n@Component({\n    selector: 'tolle-hover-card',\n    standalone: true,\n    imports: [CommonModule],\n    template: `<ng-content></ng-content>`\n})\nexport class HoverCardComponent implements OnDestroy {\n    @Input() openDelay = 700;\n    @Input() closeDelay = 300;\n    @Input() placement: 'top' | 'bottom' | 'left' | 'right' = 'bottom';\n\n    private openTimeout?: any;\n    private closeTimeout?: any;\n\n    isOpen = false;\n\n    @ContentChild(forwardRef(() => HoverCardContentComponent)) contentComponent?: HoverCardContentComponent;\n\n    open(triggerElement: HTMLElement) {\n        if (this.closeTimeout) {\n            clearTimeout(this.closeTimeout);\n            this.closeTimeout = undefined;\n        }\n\n        if (this.isOpen) return;\n\n        this.openTimeout = setTimeout(() => {\n            this.show(triggerElement);\n        }, this.openDelay);\n    }\n\n    close() {\n        if (this.openTimeout) {\n            clearTimeout(this.openTimeout);\n            this.openTimeout = undefined;\n        }\n\n        this.closeTimeout = setTimeout(() => {\n            this.hide();\n        }, this.closeDelay);\n    }\n\n    private show(triggerElement: HTMLElement) {\n        this.isOpen = true;\n        setTimeout(() => {\n            if (this.contentComponent) {\n                this.contentComponent.show(triggerElement, this.placement);\n            }\n        });\n    }\n\n    private hide() {\n        this.isOpen = false;\n        if (this.contentComponent) {\n            this.contentComponent.hide();\n        }\n    }\n\n    ngOnDestroy() {\n        this.hide();\n        if (this.openTimeout) clearTimeout(this.openTimeout);\n        if (this.closeTimeout) clearTimeout(this.closeTimeout);\n    }\n}\n\n@Component({\n    selector: 'tolle-hover-card-trigger',\n    standalone: true,\n    imports: [CommonModule],\n    template: `<ng-content></ng-content>`,\n    host: {\n        '(mouseenter)': 'onMouseEnter()',\n        '(mouseleave)': 'onMouseLeave()',\n        '(focusin)': 'onMouseEnter()',\n        '(focusout)': 'onMouseLeave()',\n        '[class]': '\"cursor-default inline-block\"'\n    }\n})\nexport class HoverCardTriggerComponent {\n    private hoverCard = inject(HoverCardComponent);\n    private elementRef = inject(ElementRef);\n\n    onMouseEnter() {\n        this.hoverCard.open(this.elementRef.nativeElement);\n    }\n\n    onMouseLeave() {\n        this.hoverCard.close();\n    }\n}\n\n@Component({\n    selector: 'tolle-hover-card-content',\n    standalone: true,\n    imports: [CommonModule],\n    template: `\n    <div *ngIf=\"isVisible\"\n         #content\n         [class]=\"computedClass\"\n         (mouseenter)=\"onMouseEnter()\"\n         (mouseleave)=\"onMouseLeave()\">\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class HoverCardContentComponent implements OnDestroy {\n    @Input() class: string = '';\n    @ViewChild('content') contentEl?: ElementRef;\n\n    isVisible = false;\n    private cleanup?: () => void;\n    private hoverCard = inject(HoverCardComponent);\n\n    show(triggerElement: HTMLElement, placement: any) {\n        this.isVisible = true;\n        setTimeout(() => {\n            if (this.contentEl) {\n                this.updatePosition(triggerElement, this.contentEl.nativeElement, placement);\n            }\n        });\n    }\n\n    hide() {\n        this.isVisible = false;\n        if (this.cleanup) {\n            this.cleanup();\n            this.cleanup = undefined;\n        }\n    }\n\n    private updatePosition(trigger: HTMLElement, content: HTMLElement, placement: any) {\n        this.cleanup = autoUpdate(trigger, content, () => {\n            computePosition(trigger, content, {\n                placement,\n                middleware: [offset(8), flip(), shift({ padding: 8 })],\n            }).then(({ x, y }) => {\n                Object.assign(content.style, {\n                    position: 'fixed',\n                    left: `${x}px`,\n                    top: `${y}px`,\n                    zIndex: '9999'\n                });\n            });\n        });\n    }\n\n    onMouseEnter() {\n        this.hoverCard.open(null as any);\n    }\n\n    onMouseLeave() {\n        this.hoverCard.close();\n    }\n\n    get computedClass() {\n        return cn(\n            \"w-64 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95\",\n            this.class\n        );\n    }\n\n    ngOnDestroy() {\n        if (this.cleanup) this.cleanup();\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hover-card.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/hover-card.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, inject, TemplateRef, ViewChild, ViewContainerRef, OnDestroy, ContentChild, forwardRef, ElementRef, AfterViewInit } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';\nimport { cn } from './utils/cn';\n\n@Component({\n    selector: 'tolle-hover-card',\n  styles: [':host { display: block; }'],\n    standalone: true,\n    imports: [CommonModule],\n    template: `<ng-content></ng-content>`\n})\nexport class HoverCardComponent implements OnDestroy {\n    @Input() openDelay = 700;\n    @Input() closeDelay = 300;\n    @Input() placement: 'top' | 'bottom' | 'left' | 'right' = 'bottom';\n\n    private openTimeout?: any;\n    private closeTimeout?: any;\n\n    isOpen = false;\n\n    @ContentChild(forwardRef(() => HoverCardContentComponent)) contentComponent?: HoverCardContentComponent;\n\n    open(triggerElement: HTMLElement) {\n        if (this.closeTimeout) {\n            clearTimeout(this.closeTimeout);\n            this.closeTimeout = undefined;\n        }\n\n        if (this.isOpen) return;\n\n        this.openTimeout = setTimeout(() => {\n            this.show(triggerElement);\n        }, this.openDelay);\n    }\n\n    close() {\n        if (this.openTimeout) {\n            clearTimeout(this.openTimeout);\n            this.openTimeout = undefined;\n        }\n\n        this.closeTimeout = setTimeout(() => {\n            this.hide();\n        }, this.closeDelay);\n    }\n\n    private show(triggerElement: HTMLElement) {\n        this.isOpen = true;\n        setTimeout(() => {\n            if (this.contentComponent) {\n                this.contentComponent.show(triggerElement, this.placement);\n            }\n        });\n    }\n\n    private hide() {\n        this.isOpen = false;\n        if (this.contentComponent) {\n            this.contentComponent.hide();\n        }\n    }\n\n    ngOnDestroy() {\n        this.hide();\n        if (this.openTimeout) clearTimeout(this.openTimeout);\n        if (this.closeTimeout) clearTimeout(this.closeTimeout);\n    }\n}\n\n@Component({\n    selector: 'tolle-hover-card-trigger',\n    standalone: true,\n    imports: [CommonModule],\n    template: `<ng-content></ng-content>`,\n    host: {\n        '(mouseenter)': 'onMouseEnter()',\n        '(mouseleave)': 'onMouseLeave()',\n        '(focusin)': 'onMouseEnter()',\n        '(focusout)': 'onMouseLeave()',\n        '[class]': '\"cursor-default inline-block\"'\n    }\n})\nexport class HoverCardTriggerComponent {\n    private hoverCard = inject(HoverCardComponent);\n    private elementRef = inject(ElementRef);\n\n    onMouseEnter() {\n        this.hoverCard.open(this.elementRef.nativeElement);\n    }\n\n    onMouseLeave() {\n        this.hoverCard.close();\n    }\n}\n\n@Component({\n    selector: 'tolle-hover-card-content',\n  styles: [':host { display: block; }'],\n    standalone: true,\n    imports: [CommonModule],\n    template: `\n    <div *ngIf=\"isVisible\"\n         #content\n         [class]=\"computedClass\"\n         (mouseenter)=\"onMouseEnter()\"\n         (mouseleave)=\"onMouseLeave()\">\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class HoverCardContentComponent implements OnDestroy {\n    @Input() class: string = '';\n    @ViewChild('content') contentEl?: ElementRef;\n\n    isVisible = false;\n    private cleanup?: () => void;\n    private hoverCard = inject(HoverCardComponent);\n\n    show(triggerElement: HTMLElement, placement: any) {\n        this.isVisible = true;\n        setTimeout(() => {\n            if (this.contentEl) {\n                this.updatePosition(triggerElement, this.contentEl.nativeElement, placement);\n            }\n        });\n    }\n\n    hide() {\n        this.isVisible = false;\n        if (this.cleanup) {\n            this.cleanup();\n            this.cleanup = undefined;\n        }\n    }\n\n    private updatePosition(trigger: HTMLElement, content: HTMLElement, placement: any) {\n        this.cleanup = autoUpdate(trigger, content, () => {\n            computePosition(trigger, content, {\n                placement,\n                middleware: [offset(8), flip(), shift({ padding: 8 })],\n            }).then(({ x, y }) => {\n                Object.assign(content.style, {\n                    position: 'fixed',\n                    left: `${x}px`,\n                    top: `${y}px`,\n                    zIndex: '9999'\n                });\n            });\n        });\n    }\n\n    onMouseEnter() {\n        this.hoverCard.open(null as any);\n    }\n\n    onMouseLeave() {\n        this.hoverCard.close();\n    }\n\n    get computedClass() {\n        return cn(\n            \"w-64 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95\",\n            this.class\n        );\n    }\n\n    ngOnDestroy() {\n        if (this.cleanup) this.cleanup();\n    }\n}\n"]}