@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/time-picker.component.mjs

@@ -0,0 +1,923 @@
+import { Component, Input, Output, EventEmitter, forwardRef, ViewChild, ViewChildren, ChangeDetectionStrategy } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const pad2 = (n) => (n < 10 ? '0' + n : String(n));
+/** Seconds elapsed since midnight for a wall-clock time. */
+export function timePartsToSeconds(parts) {
+    return parts.hour * 3600 + parts.minute * 60 + parts.second;
+}
+/**
+ * Parses `HH:mm` or `HH:mm:ss` (24-hour). Returns `null` for anything that
+ * is not a well-formed, in-range time — callers treat that as "no value".
+ */
+export function parseTimeString(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = /^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/.exec(value.trim());
+    if (!match)
+        return null;
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    const second = match[3] === undefined ? 0 : Number(match[3]);
+    if (hour > 23 || minute > 59 || second > 59)
+        return null;
+    return { hour, minute, second };
+}
+/** Renders a wall-clock time as `HH:mm`, or `HH:mm:ss` when `withSeconds`. */
+export function formatTimeString(parts, withSeconds = false) {
+    const base = pad2(parts.hour) + ':' + pad2(parts.minute);
+    return withSeconds ? base + ':' + pad2(parts.second) : base;
+}
+/**
+ * 24-hour hour to its 12-hour clock face. Midnight is `12 AM` and noon is
+ * `12 PM` — the two values that a naive `hour % 12` gets wrong.
+ */
+export function to12Hour(hour24) {
+    const meridiem = hour24 < 12 ? 'AM' : 'PM';
+    const hour12 = hour24 % 12 === 0 ? 12 : hour24 % 12;
+    return { hour12, meridiem };
+}
+/** 12-hour clock face back to a 24-hour hour. `12 AM` is 0, `12 PM` is 12. */
+export function from12Hour(hour12, meridiem) {
+    const base = hour12 % 12; // 12 -> 0, leaves 1..11 alone
+    return meridiem === 'PM' ? base + 12 : base;
+}
+const SECONDS_PER_DAY = 24 * 3600;
+const timeOptionVariants = cva('flex w-full shrink-0 cursor-pointer select-none items-center justify-center rounded-md tabular-nums ' +
+    'transition-colors focus:outline-none disabled:pointer-events-none disabled:opacity-40', {
+    variants: {
+        size: {
+            xs: 'h-6 px-2 text-[11px]',
+            sm: 'h-7 px-2 text-xs',
+            default: 'h-8 px-2.5 text-sm',
+            lg: 'h-9 px-3 text-base',
+        },
+        selected: {
+            true: 'bg-primary text-primary-foreground hover:bg-primary',
+            false: 'text-foreground hover:bg-accent hover:text-accent-foreground',
+        },
+    },
+    defaultVariants: { size: 'default', selected: false },
+});
+/**
+ * The bare scrollable hour / minute / second / AM-PM columns, with no trigger
+ * and no popover of its own.
+ *
+ * `tolle-time-picker` wraps this in a floating panel, and
+ * `tolle-date-time-picker` sits it beside a calendar — so the option
+ * generation, the min/max disabling and the roving keyboard model live here
+ * once instead of in both.
+ */
+export class TimeColumnsComponent {
+    cdr;
+    /** Selected hour in 24-hour form, or `null` when nothing is chosen yet. @default null */
+    hour = null;
+    /** Selected minute, or `null` when nothing is chosen yet. @default null */
+    minute = null;
+    /** Selected second, or `null` when nothing is chosen yet. @default null */
+    second = null;
+    /** Renders a 12-hour clock face with an AM/PM column. @default false */
+    use12Hours = false;
+    /** Adds the seconds column. @default false */
+    showSeconds = false;
+    /** Interval between minute entries, in minutes. @default 1 */
+    minuteStep = 1;
+    /** Interval between second entries, in seconds. @default 1 */
+    secondStep = 1;
+    /** Earliest selectable time, as seconds since midnight. @default 0 */
+    minSeconds = 0;
+    /** Latest selectable time, as seconds since midnight. @default 86399 */
+    maxSeconds = SECONDS_PER_DAY - 1;
+    /** Row height and text size of the entries. @default 'default' */
+    size = 'default';
+    /** Extra Tailwind classes merged onto the column strip via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the full wall-clock time whenever an entry is chosen. */
+    timeChange = new EventEmitter();
+    listboxes;
+    columnsId = 'time-col-' + Math.random().toString(36).slice(2, 11);
+    /**
+     * Built once per input change rather than read from a getter: a getter would
+     * hand `*ngFor` a fresh array on every change-detection pass, so every row —
+     * each carrying a click handler — would be torn down and rebuilt on every
+     * pass.
+     */
+    columns = [];
+    /** Roving active entry per column, for `aria-activedescendant`. */
+    activeIndex = [];
+    cn = cn;
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    ngOnInit() {
+        if (!this.columns.length)
+            this.rebuild();
+    }
+    ngOnChanges() {
+        this.rebuild();
+        // 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();
+    }
+    get heightClass() {
+        switch (this.size) {
+            case 'xs':
+                return 'max-h-[144px]';
+            case 'sm':
+                return 'max-h-[168px]';
+            case 'lg':
+                return 'max-h-[216px]';
+            default:
+                return 'max-h-[192px]';
+        }
+    }
+    /* ---------------- option generation ---------------- */
+    rebuild() {
+        const step = (value, fallback) => Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
+        const minuteStep = step(this.minuteStep, 1);
+        const secondStep = step(this.secondStep, 1);
+        const effectiveHour = this.hour ?? 0;
+        const effectiveMinute = this.minute ?? 0;
+        const meridiem = to12Hour(effectiveHour).meridiem;
+        // How far a partially-specified time can stretch. With no seconds column
+        // the seconds are pinned to :00, so an hour only reaches :59:00.
+        const hourSpan = this.showSeconds ? 3599 : 3540;
+        const minuteSpan = this.showSeconds ? 59 : 0;
+        const columns = [];
+        // Hours
+        const hourOptions = [];
+        if (this.use12Hours) {
+            // Clock-face order: 12, 1, 2 … 11.
+            const faces = [12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+            for (const face of faces) {
+                const raw = from12Hour(face, meridiem);
+                hourOptions.push({
+                    id: this.columnsId + '-hour-' + face,
+                    label: pad2(face),
+                    raw,
+                    face,
+                    disabled: this.rangeDisabled(raw * 3600, hourSpan),
+                });
+            }
+        }
+        else {
+            for (let h = 0; h < 24; h++) {
+                hourOptions.push({
+                    id: this.columnsId + '-hour-' + h,
+                    label: pad2(h),
+                    raw: h,
+                    face: h,
+                    disabled: this.rangeDisabled(h * 3600, hourSpan),
+                });
+            }
+        }
+        columns.push({ kind: 'hour', label: 'Hour', options: hourOptions });
+        // Minutes
+        const minuteOptions = [];
+        for (let m = 0; m < 60; m += minuteStep) {
+            const start = effectiveHour * 3600 + m * 60;
+            minuteOptions.push({
+                id: this.columnsId + '-minute-' + m,
+                label: pad2(m),
+                raw: m,
+                face: m,
+                disabled: this.rangeDisabled(start, minuteSpan),
+            });
+        }
+        columns.push({ kind: 'minute', label: 'Min', options: minuteOptions });
+        // Seconds
+        if (this.showSeconds) {
+            const secondOptions = [];
+            for (let s = 0; s < 60; s += secondStep) {
+                const at = effectiveHour * 3600 + effectiveMinute * 60 + s;
+                secondOptions.push({
+                    id: this.columnsId + '-second-' + s,
+                    label: pad2(s),
+                    raw: s,
+                    face: s,
+                    disabled: this.rangeDisabled(at, 0),
+                });
+            }
+            columns.push({ kind: 'second', label: 'Sec', options: secondOptions });
+        }
+        // Meridiem
+        if (this.use12Hours) {
+            const face12 = to12Hour(effectiveHour).hour12;
+            const meridiemOptions = ['AM', 'PM'].map((m, i) => {
+                const raw = from12Hour(face12, m);
+                const halfStart = m === 'AM' ? 0 : 12 * 3600;
+                return {
+                    id: this.columnsId + '-meridiem-' + m,
+                    label: m,
+                    raw,
+                    face: i, // 0 = AM, 1 = PM
+                    disabled: this.rangeDisabled(halfStart, 12 * 3600 - 1),
+                };
+            });
+            columns.push({ kind: 'meridiem', label: 'AM/PM', options: meridiemOptions });
+        }
+        this.columns = columns;
+        this.syncActiveToSelection();
+    }
+    /**
+     * True when nothing in `[start, start + span]` falls inside the allowed
+     * window — i.e. picking this entry could not produce a legal time.
+     */
+    rangeDisabled(start, span) {
+        return start + span < this.minSeconds || start > this.maxSeconds;
+    }
+    syncActiveToSelection() {
+        this.activeIndex = this.columns.map((column) => {
+            const idx = column.options.findIndex((o) => this.isSelected(column, o));
+            if (idx >= 0)
+                return idx;
+            const firstEnabled = column.options.findIndex((o) => !o.disabled);
+            return firstEnabled >= 0 ? firstEnabled : 0;
+        });
+    }
+    /* ---------------- selection ---------------- */
+    isSelected(column, option) {
+        switch (column.kind) {
+            case 'hour':
+                if (this.hour === null)
+                    return false;
+                return this.use12Hours ? to12Hour(this.hour).hour12 === option.face : this.hour === option.face;
+            case 'minute':
+                return this.minute !== null && this.minute === option.face;
+            case 'second':
+                return this.second !== null && this.second === option.face;
+            case 'meridiem':
+                if (this.hour === null)
+                    return false;
+                return (to12Hour(this.hour).meridiem === 'AM' ? 0 : 1) === option.face;
+        }
+    }
+    isActive(columnIndex, option) {
+        const column = this.columns[columnIndex];
+        if (!column)
+            return false;
+        return column.options[this.activeIndex[columnIndex]] === option;
+    }
+    activeDescendantFor(columnIndex) {
+        const column = this.columns[columnIndex];
+        return column?.options[this.activeIndex[columnIndex]]?.id ?? null;
+    }
+    optionClass(column, option, columnIndex) {
+        const selected = this.isSelected(column, option);
+        return cn(timeOptionVariants({ size: this.size, selected }), 
+        // The roving highlight has to read as distinct from the committed value,
+        // otherwise arrowing around looks like it is already selecting.
+        !selected && this.isActive(columnIndex, option) && 'bg-accent text-accent-foreground');
+    }
+    /** Commits `option` in its column and emits the resulting whole time. */
+    choose(column, option, columnIndex) {
+        if (option.disabled)
+            return;
+        const next = {
+            hour: this.hour ?? 0,
+            minute: this.minute ?? 0,
+            second: this.second ?? 0,
+        };
+        switch (column.kind) {
+            case 'hour':
+            case 'meridiem':
+                next.hour = option.raw;
+                break;
+            case 'minute':
+                next.minute = option.raw;
+                break;
+            case 'second':
+                next.second = option.raw;
+                break;
+        }
+        this.activeIndex[columnIndex] = column.options.indexOf(option);
+        this.timeChange.emit(next);
+        this.cdr.markForCheck();
+    }
+    /* ---------------- keyboard ---------------- */
+    onColumnKeydown(event, columnIndex) {
+        const column = this.columns[columnIndex];
+        if (!column)
+            return;
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                this.moveActive(columnIndex, 1);
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                this.moveActive(columnIndex, -1);
+                break;
+            case 'Home':
+                event.preventDefault();
+                this.setActive(columnIndex, 0, 1);
+                break;
+            case 'End':
+                event.preventDefault();
+                this.setActive(columnIndex, column.options.length - 1, -1);
+                break;
+            case 'ArrowLeft':
+                event.preventDefault();
+                this.focusColumn(columnIndex - 1);
+                break;
+            case 'ArrowRight':
+                event.preventDefault();
+                this.focusColumn(columnIndex + 1);
+                break;
+            case 'Enter':
+            case ' ':
+                event.preventDefault();
+                {
+                    const option = column.options[this.activeIndex[columnIndex]];
+                    if (option)
+                        this.choose(column, option, columnIndex);
+                }
+                break;
+            default:
+                return;
+        }
+    }
+    moveActive(columnIndex, delta) {
+        const current = this.activeIndex[columnIndex] ?? 0;
+        this.setActive(columnIndex, current + delta, delta);
+    }
+    /** Lands on the first enabled entry at or past `index`, walking `direction`. */
+    setActive(columnIndex, index, direction) {
+        const column = this.columns[columnIndex];
+        if (!column)
+            return;
+        let i = Math.max(0, Math.min(index, column.options.length - 1));
+        while (column.options[i]?.disabled) {
+            i += direction;
+            if (i < 0 || i >= column.options.length)
+                return; // no enabled entry that way
+        }
+        this.activeIndex[columnIndex] = i;
+        this.scrollOptionIntoView(columnIndex, i);
+        this.cdr.markForCheck();
+    }
+    focusColumn(columnIndex) {
+        if (columnIndex < 0 || columnIndex >= this.columns.length)
+            return;
+        this.listboxes?.get(columnIndex)?.nativeElement.focus();
+    }
+    /** Focuses the first column — used when the panel opens. */
+    focusFirstColumn() {
+        this.focusColumn(0);
+    }
+    /**
+     * Centres each column on its selected entry. Scrolls the listbox directly
+     * rather than calling `scrollIntoView`, which would also scroll the page
+     * behind a fixed-position panel.
+     */
+    scrollSelectedIntoView() {
+        this.listboxes?.forEach((ref) => {
+            const list = ref.nativeElement;
+            const selected = list.querySelector('[data-selected="true"]');
+            if (!selected)
+                return;
+            list.scrollTop = selected.offsetTop - list.clientHeight / 2 + selected.clientHeight / 2;
+        });
+    }
+    scrollOptionIntoView(columnIndex, optionIndex) {
+        const list = this.listboxes?.get(columnIndex)?.nativeElement;
+        if (!list)
+            return;
+        const el = list.children[optionIndex];
+        if (!el)
+            return;
+        if (el.offsetTop < list.scrollTop) {
+            list.scrollTop = el.offsetTop;
+        }
+        else if (el.offsetTop + el.clientHeight > list.scrollTop + list.clientHeight) {
+            list.scrollTop = el.offsetTop + el.clientHeight - list.clientHeight;
+        }
+    }
+    trackColumn = (_, column) => column.kind;
+    trackOption = (_, option) => option.id;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TimeColumnsComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TimeColumnsComponent, isStandalone: true, selector: "tolle-time-columns", inputs: { hour: "hour", minute: "minute", second: "second", use12Hours: "use12Hours", showSeconds: "showSeconds", minuteStep: "minuteStep", secondStep: "secondStep", minSeconds: "minSeconds", maxSeconds: "maxSeconds", size: "size", class: "class" }, outputs: { timeChange: "timeChange" }, viewQueries: [{ propertyName: "listboxes", predicate: ["listbox"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="cn('flex items-stretch gap-1', class)">
+      <div
+        *ngFor="let column of columns; let ci = index; trackBy: trackColumn"
+        class="flex flex-col"
+      >
+        <div class="px-1 pb-1 text-center text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
+          {{ column.label }}
+        </div>
+        <div
+          #listbox
+          role="listbox"
+          tabindex="0"
+          [attr.aria-label]="column.label"
+          [attr.aria-activedescendant]="activeDescendantFor(ci)"
+          (keydown)="onColumnKeydown($event, ci)"
+          [class]="cn(
+            'flex flex-col gap-0.5 overflow-y-auto scroll-smooth rounded-md p-1',
+            'focus:outline-none focus-visible:ring-2 focus-visible:ring-ring',
+            column.kind === 'meridiem' ? 'w-14' : 'w-14',
+            heightClass
+          )"
+        >
+          <button
+            *ngFor="let option of column.options; trackBy: trackOption"
+            type="button"
+            role="option"
+            tabindex="-1"
+            [id]="option.id"
+            [attr.aria-selected]="isSelected(column, option)"
+            [attr.aria-disabled]="option.disabled"
+            [attr.data-selected]="isSelected(column, option)"
+            [attr.data-active]="isActive(ci, option)"
+            [disabled]="option.disabled"
+            [class]="optionClass(column, option, ci)"
+            (click)="choose(column, option, ci)"
+          >
+            {{ option.label }}
+          </button>
+        </div>
+      </div>
+    </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"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TimeColumnsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-time-columns', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="cn('flex items-stretch gap-1', class)">
+      <div
+        *ngFor="let column of columns; let ci = index; trackBy: trackColumn"
+        class="flex flex-col"
+      >
+        <div class="px-1 pb-1 text-center text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
+          {{ column.label }}
+        </div>
+        <div
+          #listbox
+          role="listbox"
+          tabindex="0"
+          [attr.aria-label]="column.label"
+          [attr.aria-activedescendant]="activeDescendantFor(ci)"
+          (keydown)="onColumnKeydown($event, ci)"
+          [class]="cn(
+            'flex flex-col gap-0.5 overflow-y-auto scroll-smooth rounded-md p-1',
+            'focus:outline-none focus-visible:ring-2 focus-visible:ring-ring',
+            column.kind === 'meridiem' ? 'w-14' : 'w-14',
+            heightClass
+          )"
+        >
+          <button
+            *ngFor="let option of column.options; trackBy: trackOption"
+            type="button"
+            role="option"
+            tabindex="-1"
+            [id]="option.id"
+            [attr.aria-selected]="isSelected(column, option)"
+            [attr.aria-disabled]="option.disabled"
+            [attr.data-selected]="isSelected(column, option)"
+            [attr.data-active]="isActive(ci, option)"
+            [disabled]="option.disabled"
+            [class]="optionClass(column, option, ci)"
+            (click)="choose(column, option, ci)"
+          >
+            {{ option.label }}
+          </button>
+        </div>
+      </div>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { hour: [{
+                type: Input
+            }], minute: [{
+                type: Input
+            }], second: [{
+                type: Input
+            }], use12Hours: [{
+                type: Input
+            }], showSeconds: [{
+                type: Input
+            }], minuteStep: [{
+                type: Input
+            }], secondStep: [{
+                type: Input
+            }], minSeconds: [{
+                type: Input
+            }], maxSeconds: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], timeChange: [{
+                type: Output
+            }], listboxes: [{
+                type: ViewChildren,
+                args: ['listbox']
+            }] } });
+/* ------------------------------------------------------------------ *
+ * The picker
+ * ------------------------------------------------------------------ */
+const timePickerTriggerVariants = cva('flex w-full items-center justify-between gap-2 rounded-md border border-input bg-background text-foreground shadow-sm transition-colors ' +
+    'focus:outline-none focus-visible:border-primary/80 focus-visible:ring-4 focus-visible:ring-ring/30 ' +
+    'disabled:cursor-not-allowed disabled:opacity-50', {
+    variants: {
+        size: {
+            xs: 'h-8 px-2 text-xs',
+            sm: 'h-9 px-3 text-sm',
+            default: 'h-10 px-3 text-sm',
+            lg: 'h-11 px-4 text-base',
+        },
+        invalid: {
+            true: 'border-destructive focus-visible:border-destructive/80 focus-visible:ring-destructive/30',
+            false: '',
+        },
+    },
+    defaultVariants: { size: 'default', invalid: false },
+});
+/**
+ * A trigger that opens scrollable hour / minute / second columns in a floating
+ * panel.
+ *
+ * The value is a **24-hour `HH:mm` string** (or `HH:mm:ss` when `showSeconds`),
+ * regardless of whether the face is rendered as 12-hour — a wall-clock time has
+ * no date and no timezone, and a `Date` would invent both. Set
+ * `valueType="date"` to exchange `Date` objects instead, in which case the time
+ * is written onto today's date (or onto the date already held by the control).
+ *
+ * Implements `ControlValueAccessor`, so it works with `ngModel` and reactive
+ * forms. Use `tolle-date-time-picker` when a date is needed alongside.
+ * @new
+ */
+export class TimePickerComponent {
+    cdr;
+    /**
+     * 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();
+    }
+    /** Text shown on the trigger when no time is selected. @default 'Select a time' */
+    placeholder = 'Select a time';
+    /** Disables the control. @default false */
+    disabled = false;
+    /** Renders a 12-hour face with an AM/PM column. The emitted value stays 24-hour. @default false */
+    use12Hours = false;
+    /** Adds a seconds column and emits `HH:mm:ss`. @default false */
+    showSeconds = false;
+    /** Interval between minute entries, in minutes. @default 1 */
+    minuteStep = 1;
+    /** Interval between second entries, in seconds. @default 1 */
+    secondStep = 1;
+    /** Earliest selectable time as a 24-hour `HH:mm` string; earlier entries are disabled. */
+    min;
+    /** Latest selectable time as a 24-hour `HH:mm` string; later entries are disabled. */
+    max;
+    /** Height and text size of the trigger and entries. @default 'default' */
+    size = 'default';
+    /** Applies the destructive border and focus ring. @default false */
+    invalid = false;
+    /** Accessible name when there is no associated visible label. @default '' */
+    ariaLabel = '';
+    /** Exchange `Date` objects instead of `HH:mm` strings through the form control. @default 'string' */
+    valueType = 'string';
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the chosen time whenever it changes. */
+    valueChange = new EventEmitter();
+    /** Emitted when the panel opens. */
+    opened = new EventEmitter();
+    /** Emitted when the panel closes. */
+    closed = new EventEmitter();
+    triggerEl;
+    panelEl;
+    columnsCmp;
+    panelId = 'time-picker-panel-' + Math.random().toString(36).slice(2, 11);
+    hour = null;
+    minute = null;
+    second = null;
+    isOpen = false;
+    cn = cn;
+    cleanup;
+    /** The date half of a `Date` value, kept so round-tripping does not move the day. */
+    dateAnchor = null;
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    outsideClickHandler = (event) => {
+        const target = event.target;
+        if (!this.triggerEl?.nativeElement.contains(target) &&
+            !this.panelEl?.nativeElement.contains(target)) {
+            this.close();
+        }
+    };
+    escapeHandler = (event) => {
+        if (event.key === 'Escape' && this.isOpen) {
+            event.preventDefault();
+            this.close();
+            this.triggerEl?.nativeElement.focus();
+        }
+    };
+    /* ---------------- derived ---------------- */
+    /** The current selection as wall-clock parts, or `null` when incomplete. */
+    get parts() {
+        if (this.hour === null || this.minute === null)
+            return null;
+        return { hour: this.hour, minute: this.minute, second: this.second ?? 0 };
+    }
+    get displayValue() {
+        const parts = this.parts;
+        if (!parts)
+            return '';
+        if (this.use12Hours) {
+            const { hour12, meridiem } = to12Hour(parts.hour);
+            const body = String(hour12) +
+                ':' +
+                pad2(parts.minute) +
+                (this.showSeconds ? ':' + pad2(parts.second) : '');
+            return body + ' ' + meridiem;
+        }
+        return formatTimeString(parts, this.showSeconds);
+    }
+    get minSeconds() {
+        const parsed = parseTimeString(this.min);
+        return parsed ? timePartsToSeconds(parsed) : 0;
+    }
+    get maxSeconds() {
+        const parsed = parseTimeString(this.max);
+        return parsed ? timePartsToSeconds(parsed) : SECONDS_PER_DAY - 1;
+    }
+    get computedTriggerClass() {
+        return cn(timePickerTriggerVariants({ size: this.size, invalid: this.invalid }), this.class);
+    }
+    /* ---------------- open / close ---------------- */
+    toggle() {
+        this.isOpen ? this.close() : this.open();
+    }
+    open() {
+        if (this.disabled || this.isOpen)
+            return;
+        this.isOpen = true;
+        this.opened.emit();
+        this.cdr.markForCheck();
+        setTimeout(() => {
+            this.updatePosition();
+            this.columnsCmp?.scrollSelectedIntoView();
+            this.columnsCmp?.focusFirstColumn();
+            document.addEventListener('pointerdown', this.outsideClickHandler, true);
+            document.addEventListener('keydown', this.escapeHandler, true);
+        });
+    }
+    close() {
+        if (!this.isOpen)
+            return;
+        this.isOpen = false;
+        this.closed.emit();
+        this.onTouched();
+        this.teardown();
+        this.cdr.markForCheck();
+    }
+    onTriggerKeyDown(event) {
+        if (['ArrowDown', 'ArrowUp', 'Enter', ' '].includes(event.key) && !this.isOpen) {
+            event.preventDefault();
+            this.open();
+        }
+    }
+    /* ---------------- value ---------------- */
+    onTimeChange(parts) {
+        this.hour = parts.hour;
+        this.minute = parts.minute;
+        this.second = parts.second;
+        this.emit();
+        this.cdr.markForCheck();
+    }
+    emit() {
+        const value = this.currentValue();
+        this.onChange(value);
+        this.valueChange.emit(value);
+    }
+    currentValue() {
+        const parts = this.parts;
+        if (!parts)
+            return null;
+        if (this.valueType === 'date') {
+            const base = this.dateAnchor ?? new Date();
+            return new Date(base.getFullYear(), base.getMonth(), base.getDate(), parts.hour, parts.minute, parts.second, 0);
+        }
+        return formatTimeString(parts, this.showSeconds);
+    }
+    updatePosition() {
+        const trigger = this.triggerEl?.nativeElement;
+        const panel = this.panelEl?.nativeElement;
+        if (!trigger || !panel)
+            return;
+        this.cleanup = autoUpdate(trigger, panel, () => {
+            computePosition(trigger, panel, {
+                strategy: 'fixed',
+                placement: 'bottom-start',
+                middleware: [offset(4), flip(), shift({ padding: 8 })],
+            }).then(({ x, y }) => {
+                Object.assign(panel.style, {
+                    left: x + 'px',
+                    top: y + 'px',
+                    visibility: 'visible',
+                });
+            });
+        });
+    }
+    teardown() {
+        this.cleanup?.();
+        this.cleanup = undefined;
+        document.removeEventListener('pointerdown', this.outsideClickHandler, true);
+        document.removeEventListener('keydown', this.escapeHandler, true);
+    }
+    ngOnDestroy() {
+        this.teardown();
+    }
+    /* ---------------- ControlValueAccessor ---------------- */
+    writeValue(value) {
+        let parts = null;
+        if (value instanceof Date && !isNaN(value.getTime())) {
+            this.dateAnchor = value;
+            parts = { hour: value.getHours(), minute: value.getMinutes(), second: value.getSeconds() };
+        }
+        else if (typeof value === 'string') {
+            parts = parseTimeString(value);
+        }
+        this.hour = parts ? parts.hour : null;
+        this.minute = parts ? parts.minute : null;
+        this.second = parts ? parts.second : null;
+        this.cdr.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        if (isDisabled)
+            this.close();
+        this.cdr.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TimePickerComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TimePickerComponent, isStandalone: true, selector: "tolle-time-picker", inputs: { placeholder: "placeholder", disabled: "disabled", use12Hours: "use12Hours", showSeconds: "showSeconds", minuteStep: "minuteStep", secondStep: "secondStep", min: "min", max: "max", size: "size", invalid: "invalid", ariaLabel: "ariaLabel", valueType: "valueType", class: "class" }, outputs: { valueChange: "valueChange", opened: "opened", closed: "closed" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => TimePickerComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "triggerEl", first: true, predicate: ["trigger"], descendants: true }, { propertyName: "panelEl", first: true, predicate: ["panel"], descendants: true }, { propertyName: "columnsCmp", first: true, predicate: ["columns"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <button
+      #trigger
+      type="button"
+      aria-haspopup="dialog"
+      [attr.aria-expanded]="isOpen"
+      [attr.aria-controls]="isOpen ? panelId : null"
+      [attr.aria-label]="ariaLabel || null"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [disabled]="disabled"
+      [class]="computedTriggerClass"
+      (click)="toggle()"
+      (keydown)="onTriggerKeyDown($event)"
+    >
+      <span [class]="cn('truncate', displayValue ? 'text-foreground' : 'text-muted-foreground')">
+        {{ displayValue || placeholder }}
+      </span>
+      <i class="ri-time-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+    </button>
+
+    <div
+      *ngIf="isOpen"
+      #panel
+      role="dialog"
+      [id]="panelId"
+      [attr.aria-label]="ariaLabel || 'Choose a time'"
+      class="fixed left-0 top-0 z-[9999]"
+      style="visibility: hidden"
+    >
+      <div class="rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md">
+        <tolle-time-columns
+          #columns
+          [hour]="hour"
+          [minute]="minute"
+          [second]="second"
+          [use12Hours]="use12Hours"
+          [showSeconds]="showSeconds"
+          [minuteStep]="minuteStep"
+          [secondStep]="secondStep"
+          [minSeconds]="minSeconds"
+          [maxSeconds]="maxSeconds"
+          [size]="size"
+          (timeChange)="onTimeChange($event)"
+        ></tolle-time-columns>
+      </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"] }, { kind: "component", type: TimeColumnsComponent, selector: "tolle-time-columns", inputs: ["hour", "minute", "second", "use12Hours", "showSeconds", "minuteStep", "secondStep", "minSeconds", "maxSeconds", "size", "class"], outputs: ["timeChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TimePickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-time-picker', standalone: true, imports: [CommonModule, TimeColumnsComponent], changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => TimePickerComponent),
+                            multi: true,
+                        },
+                    ], template: `
+    <button
+      #trigger
+      type="button"
+      aria-haspopup="dialog"
+      [attr.aria-expanded]="isOpen"
+      [attr.aria-controls]="isOpen ? panelId : null"
+      [attr.aria-label]="ariaLabel || null"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [disabled]="disabled"
+      [class]="computedTriggerClass"
+      (click)="toggle()"
+      (keydown)="onTriggerKeyDown($event)"
+    >
+      <span [class]="cn('truncate', displayValue ? 'text-foreground' : 'text-muted-foreground')">
+        {{ displayValue || placeholder }}
+      </span>
+      <i class="ri-time-line shrink-0 text-muted-foreground" aria-hidden="true"></i>
+    </button>
+
+    <div
+      *ngIf="isOpen"
+      #panel
+      role="dialog"
+      [id]="panelId"
+      [attr.aria-label]="ariaLabel || 'Choose a time'"
+      class="fixed left-0 top-0 z-[9999]"
+      style="visibility: hidden"
+    >
+      <div class="rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md">
+        <tolle-time-columns
+          #columns
+          [hour]="hour"
+          [minute]="minute"
+          [second]="second"
+          [use12Hours]="use12Hours"
+          [showSeconds]="showSeconds"
+          [minuteStep]="minuteStep"
+          [secondStep]="secondStep"
+          [minSeconds]="minSeconds"
+          [maxSeconds]="maxSeconds"
+          [size]="size"
+          (timeChange)="onTimeChange($event)"
+        ></tolle-time-columns>
+      </div>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], use12Hours: [{
+                type: Input
+            }], showSeconds: [{
+                type: Input
+            }], minuteStep: [{
+                type: Input
+            }], secondStep: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], valueType: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], opened: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], triggerEl: [{
+                type: ViewChild,
+                args: ['trigger']
+            }], panelEl: [{
+                type: ViewChild,
+                args: ['panel']
+            }], columnsCmp: [{
+                type: ViewChild,
+                args: ['columns']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-picker.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/time-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, forwardRef, ElementRef, ViewChild, ViewChildren, QueryList, ChangeDetectorRef, ChangeDetectionStrategy, OnDestroy, OnInit, OnChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/* ------------------------------------------------------------------ *\n * Pure time helpers\n *\n * The wire format is a 24-hour `HH:mm` / `HH:mm:ss` string. It is\n * timezone-free and stable across serialisation, which a `Date` is not:\n * a `Date` carries a calendar day and a UTC offset that nobody chose when\n * all the user did was pick \"2:30 PM\".\n * ------------------------------------------------------------------ */\n\n/** A wall-clock time with no date and no timezone attached. */\nexport interface TimeParts {\n  hour: number;\n  minute: number;\n  second: number;\n}\n\nconst pad2 = (n: number): string => (n < 10 ? '0' + n : String(n));\n\n/** Seconds elapsed since midnight for a wall-clock time. */\nexport function timePartsToSeconds(parts: TimeParts): number {\n  return parts.hour * 3600 + parts.minute * 60 + parts.second;\n}\n\n/**\n * Parses `HH:mm` or `HH:mm:ss` (24-hour). Returns `null` for anything that\n * is not a well-formed, in-range time — callers treat that as \"no value\".\n */\nexport function parseTimeString(value: string | null | undefined): TimeParts | null {\n  if (typeof value !== 'string') return null;\n  const match = /^(\\d{1,2}):(\\d{1,2})(?::(\\d{1,2}))?$/.exec(value.trim());\n  if (!match) return null;\n\n  const hour = Number(match[1]);\n  const minute = Number(match[2]);\n  const second = match[3] === undefined ? 0 : Number(match[3]);\n\n  if (hour > 23 || minute > 59 || second > 59) return null;\n  return { hour, minute, second };\n}\n\n/** Renders a wall-clock time as `HH:mm`, or `HH:mm:ss` when `withSeconds`. */\nexport function formatTimeString(parts: TimeParts, withSeconds = false): string {\n  const base = pad2(parts.hour) + ':' + pad2(parts.minute);\n  return withSeconds ? base + ':' + pad2(parts.second) : base;\n}\n\n/**\n * 24-hour hour to its 12-hour clock face. Midnight is `12 AM` and noon is\n * `12 PM` — the two values that a naive `hour % 12` gets wrong.\n */\nexport function to12Hour(hour24: number): { hour12: number; meridiem: 'AM' | 'PM' } {\n  const meridiem: 'AM' | 'PM' = hour24 < 12 ? 'AM' : 'PM';\n  const hour12 = hour24 % 12 === 0 ? 12 : hour24 % 12;\n  return { hour12, meridiem };\n}\n\n/** 12-hour clock face back to a 24-hour hour. `12 AM` is 0, `12 PM` is 12. */\nexport function from12Hour(hour12: number, meridiem: 'AM' | 'PM'): number {\n  const base = hour12 % 12; // 12 -> 0, leaves 1..11 alone\n  return meridiem === 'PM' ? base + 12 : base;\n}\n\n/* ------------------------------------------------------------------ *\n * Column model\n * ------------------------------------------------------------------ */\n\n/** Which unit a column of the picker scrolls through. */\nexport type TimeColumnKind = 'hour' | 'minute' | 'second' | 'meridiem';\n\n/** One entry inside a time column. */\nexport interface TimeOption {\n  /** Stable identity for `trackBy` and `aria-activedescendant`. */\n  id: string;\n  /** Text shown to the user. */\n  label: string;\n  /**\n   * The 24-hour value this entry commits for its column. For a `meridiem`\n   * column this is the resulting 24-hour *hour*.\n   */\n  raw: number;\n  /** Value used for the selected comparison (clock-face value for hours). */\n  face: number;\n  disabled: boolean;\n}\n\n/** A scrollable column of the picker. */\nexport interface TimeColumn {\n  kind: TimeColumnKind;\n  label: string;\n  options: TimeOption[];\n}\n\nconst SECONDS_PER_DAY = 24 * 3600;\n\nconst timeOptionVariants = cva(\n  'flex w-full shrink-0 cursor-pointer select-none items-center justify-center rounded-md tabular-nums ' +\n    'transition-colors focus:outline-none disabled:pointer-events-none disabled:opacity-40',\n  {\n    variants: {\n      size: {\n        xs: 'h-6 px-2 text-[11px]',\n        sm: 'h-7 px-2 text-xs',\n        default: 'h-8 px-2.5 text-sm',\n        lg: 'h-9 px-3 text-base',\n      },\n      selected: {\n        true: 'bg-primary text-primary-foreground hover:bg-primary',\n        false: 'text-foreground hover:bg-accent hover:text-accent-foreground',\n      },\n    },\n    defaultVariants: { size: 'default', selected: false },\n  }\n);\n\n/** Variant props for the option rows inside a time column. */\nexport type TimeColumnsProps = VariantProps<typeof timeOptionVariants>;\n\n/**\n * The bare scrollable hour / minute / second / AM-PM columns, with no trigger\n * and no popover of its own.\n *\n * `tolle-time-picker` wraps this in a floating panel, and\n * `tolle-date-time-picker` sits it beside a calendar — so the option\n * generation, the min/max disabling and the roving keyboard model live here\n * once instead of in both.\n */\n@Component({\n  selector: 'tolle-time-columns',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"cn('flex items-stretch gap-1', class)\">\n      <div\n        *ngFor=\"let column of columns; let ci = index; trackBy: trackColumn\"\n        class=\"flex flex-col\"\n      >\n        <div class=\"px-1 pb-1 text-center text-[10px] font-medium uppercase tracking-wide text-muted-foreground\">\n          {{ column.label }}\n        </div>\n        <div\n          #listbox\n          role=\"listbox\"\n          tabindex=\"0\"\n          [attr.aria-label]=\"column.label\"\n          [attr.aria-activedescendant]=\"activeDescendantFor(ci)\"\n          (keydown)=\"onColumnKeydown($event, ci)\"\n          [class]=\"cn(\n            'flex flex-col gap-0.5 overflow-y-auto scroll-smooth rounded-md p-1',\n            'focus:outline-none focus-visible:ring-2 focus-visible:ring-ring',\n            column.kind === 'meridiem' ? 'w-14' : 'w-14',\n            heightClass\n          )\"\n        >\n          <button\n            *ngFor=\"let option of column.options; trackBy: trackOption\"\n            type=\"button\"\n            role=\"option\"\n            tabindex=\"-1\"\n            [id]=\"option.id\"\n            [attr.aria-selected]=\"isSelected(column, option)\"\n            [attr.aria-disabled]=\"option.disabled\"\n            [attr.data-selected]=\"isSelected(column, option)\"\n            [attr.data-active]=\"isActive(ci, option)\"\n            [disabled]=\"option.disabled\"\n            [class]=\"optionClass(column, option, ci)\"\n            (click)=\"choose(column, option, ci)\"\n          >\n            {{ option.label }}\n          </button>\n        </div>\n      </div>\n    </div>\n  `,\n})\nexport class TimeColumnsComponent implements OnInit, OnChanges {\n  /** Selected hour in 24-hour form, or `null` when nothing is chosen yet. @default null */\n  @Input() hour: number | null = null;\n  /** Selected minute, or `null` when nothing is chosen yet. @default null */\n  @Input() minute: number | null = null;\n  /** Selected second, or `null` when nothing is chosen yet. @default null */\n  @Input() second: number | null = null;\n  /** Renders a 12-hour clock face with an AM/PM column. @default false */\n  @Input() use12Hours = false;\n  /** Adds the seconds column. @default false */\n  @Input() showSeconds = false;\n  /** Interval between minute entries, in minutes. @default 1 */\n  @Input() minuteStep = 1;\n  /** Interval between second entries, in seconds. @default 1 */\n  @Input() secondStep = 1;\n  /** Earliest selectable time, as seconds since midnight. @default 0 */\n  @Input() minSeconds = 0;\n  /** Latest selectable time, as seconds since midnight. @default 86399 */\n  @Input() maxSeconds = SECONDS_PER_DAY - 1;\n  /** Row height and text size of the entries. @default 'default' */\n  @Input() size: TimeColumnsProps['size'] = 'default';\n  /** Extra Tailwind classes merged onto the column strip via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the full wall-clock time whenever an entry is chosen. */\n  @Output() timeChange = new EventEmitter<TimeParts>();\n\n  @ViewChildren('listbox') listboxes?: QueryList<ElementRef<HTMLElement>>;\n\n  readonly columnsId = 'time-col-' + Math.random().toString(36).slice(2, 11);\n\n  /**\n   * Built once per input change rather than read from a getter: a getter would\n   * hand `*ngFor` a fresh array on every change-detection pass, so every row —\n   * each carrying a click handler — would be torn down and rebuilt on every\n   * pass.\n   */\n  columns: TimeColumn[] = [];\n  /** Roving active entry per column, for `aria-activedescendant`. */\n  activeIndex: number[] = [];\n\n  protected cn = cn;\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  ngOnInit(): void {\n    if (!this.columns.length) this.rebuild();\n  }\n\n  ngOnChanges(): void {\n    this.rebuild();\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  get heightClass(): string {\n    switch (this.size) {\n      case 'xs':\n        return 'max-h-[144px]';\n      case 'sm':\n        return 'max-h-[168px]';\n      case 'lg':\n        return 'max-h-[216px]';\n      default:\n        return 'max-h-[192px]';\n    }\n  }\n\n  /* ---------------- option generation ---------------- */\n\n  private rebuild(): void {\n    const step = (value: number, fallback: number) =>\n      Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;\n\n    const minuteStep = step(this.minuteStep, 1);\n    const secondStep = step(this.secondStep, 1);\n    const effectiveHour = this.hour ?? 0;\n    const effectiveMinute = this.minute ?? 0;\n    const meridiem = to12Hour(effectiveHour).meridiem;\n\n    // How far a partially-specified time can stretch. With no seconds column\n    // the seconds are pinned to :00, so an hour only reaches :59:00.\n    const hourSpan = this.showSeconds ? 3599 : 3540;\n    const minuteSpan = this.showSeconds ? 59 : 0;\n\n    const columns: TimeColumn[] = [];\n\n    // Hours\n    const hourOptions: TimeOption[] = [];\n    if (this.use12Hours) {\n      // Clock-face order: 12, 1, 2 … 11.\n      const faces = [12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];\n      for (const face of faces) {\n        const raw = from12Hour(face, meridiem);\n        hourOptions.push({\n          id: this.columnsId + '-hour-' + face,\n          label: pad2(face),\n          raw,\n          face,\n          disabled: this.rangeDisabled(raw * 3600, hourSpan),\n        });\n      }\n    } else {\n      for (let h = 0; h < 24; h++) {\n        hourOptions.push({\n          id: this.columnsId + '-hour-' + h,\n          label: pad2(h),\n          raw: h,\n          face: h,\n          disabled: this.rangeDisabled(h * 3600, hourSpan),\n        });\n      }\n    }\n    columns.push({ kind: 'hour', label: 'Hour', options: hourOptions });\n\n    // Minutes\n    const minuteOptions: TimeOption[] = [];\n    for (let m = 0; m < 60; m += minuteStep) {\n      const start = effectiveHour * 3600 + m * 60;\n      minuteOptions.push({\n        id: this.columnsId + '-minute-' + m,\n        label: pad2(m),\n        raw: m,\n        face: m,\n        disabled: this.rangeDisabled(start, minuteSpan),\n      });\n    }\n    columns.push({ kind: 'minute', label: 'Min', options: minuteOptions });\n\n    // Seconds\n    if (this.showSeconds) {\n      const secondOptions: TimeOption[] = [];\n      for (let s = 0; s < 60; s += secondStep) {\n        const at = effectiveHour * 3600 + effectiveMinute * 60 + s;\n        secondOptions.push({\n          id: this.columnsId + '-second-' + s,\n          label: pad2(s),\n          raw: s,\n          face: s,\n          disabled: this.rangeDisabled(at, 0),\n        });\n      }\n      columns.push({ kind: 'second', label: 'Sec', options: secondOptions });\n    }\n\n    // Meridiem\n    if (this.use12Hours) {\n      const face12 = to12Hour(effectiveHour).hour12;\n      const meridiemOptions: TimeOption[] = (['AM', 'PM'] as const).map((m, i) => {\n        const raw = from12Hour(face12, m);\n        const halfStart = m === 'AM' ? 0 : 12 * 3600;\n        return {\n          id: this.columnsId + '-meridiem-' + m,\n          label: m,\n          raw,\n          face: i, // 0 = AM, 1 = PM\n          disabled: this.rangeDisabled(halfStart, 12 * 3600 - 1),\n        };\n      });\n      columns.push({ kind: 'meridiem', label: 'AM/PM', options: meridiemOptions });\n    }\n\n    this.columns = columns;\n    this.syncActiveToSelection();\n  }\n\n  /**\n   * True when nothing in `[start, start + span]` falls inside the allowed\n   * window — i.e. picking this entry could not produce a legal time.\n   */\n  private rangeDisabled(start: number, span: number): boolean {\n    return start + span < this.minSeconds || start > this.maxSeconds;\n  }\n\n  private syncActiveToSelection(): void {\n    this.activeIndex = this.columns.map((column) => {\n      const idx = column.options.findIndex((o) => this.isSelected(column, o));\n      if (idx >= 0) return idx;\n      const firstEnabled = column.options.findIndex((o) => !o.disabled);\n      return firstEnabled >= 0 ? firstEnabled : 0;\n    });\n  }\n\n  /* ---------------- selection ---------------- */\n\n  isSelected(column: TimeColumn, option: TimeOption): boolean {\n    switch (column.kind) {\n      case 'hour':\n        if (this.hour === null) return false;\n        return this.use12Hours ? to12Hour(this.hour).hour12 === option.face : this.hour === option.face;\n      case 'minute':\n        return this.minute !== null && this.minute === option.face;\n      case 'second':\n        return this.second !== null && this.second === option.face;\n      case 'meridiem':\n        if (this.hour === null) return false;\n        return (to12Hour(this.hour).meridiem === 'AM' ? 0 : 1) === option.face;\n    }\n  }\n\n  isActive(columnIndex: number, option: TimeOption): boolean {\n    const column = this.columns[columnIndex];\n    if (!column) return false;\n    return column.options[this.activeIndex[columnIndex]] === option;\n  }\n\n  activeDescendantFor(columnIndex: number): string | null {\n    const column = this.columns[columnIndex];\n    return column?.options[this.activeIndex[columnIndex]]?.id ?? null;\n  }\n\n  optionClass(column: TimeColumn, option: TimeOption, columnIndex: number): string {\n    const selected = this.isSelected(column, option);\n    return cn(\n      timeOptionVariants({ size: this.size, selected }),\n      // The roving highlight has to read as distinct from the committed value,\n      // otherwise arrowing around looks like it is already selecting.\n      !selected && this.isActive(columnIndex, option) && 'bg-accent text-accent-foreground'\n    );\n  }\n\n  /** Commits `option` in its column and emits the resulting whole time. */\n  choose(column: TimeColumn, option: TimeOption, columnIndex: number): void {\n    if (option.disabled) return;\n\n    const next: TimeParts = {\n      hour: this.hour ?? 0,\n      minute: this.minute ?? 0,\n      second: this.second ?? 0,\n    };\n\n    switch (column.kind) {\n      case 'hour':\n      case 'meridiem':\n        next.hour = option.raw;\n        break;\n      case 'minute':\n        next.minute = option.raw;\n        break;\n      case 'second':\n        next.second = option.raw;\n        break;\n    }\n\n    this.activeIndex[columnIndex] = column.options.indexOf(option);\n    this.timeChange.emit(next);\n    this.cdr.markForCheck();\n  }\n\n  /* ---------------- keyboard ---------------- */\n\n  onColumnKeydown(event: KeyboardEvent, columnIndex: number): void {\n    const column = this.columns[columnIndex];\n    if (!column) return;\n\n    switch (event.key) {\n      case 'ArrowDown':\n        event.preventDefault();\n        this.moveActive(columnIndex, 1);\n        break;\n      case 'ArrowUp':\n        event.preventDefault();\n        this.moveActive(columnIndex, -1);\n        break;\n      case 'Home':\n        event.preventDefault();\n        this.setActive(columnIndex, 0, 1);\n        break;\n      case 'End':\n        event.preventDefault();\n        this.setActive(columnIndex, column.options.length - 1, -1);\n        break;\n      case 'ArrowLeft':\n        event.preventDefault();\n        this.focusColumn(columnIndex - 1);\n        break;\n      case 'ArrowRight':\n        event.preventDefault();\n        this.focusColumn(columnIndex + 1);\n        break;\n      case 'Enter':\n      case ' ':\n        event.preventDefault();\n        {\n          const option = column.options[this.activeIndex[columnIndex]];\n          if (option) this.choose(column, option, columnIndex);\n        }\n        break;\n      default:\n        return;\n    }\n  }\n\n  private moveActive(columnIndex: number, delta: number): void {\n    const current = this.activeIndex[columnIndex] ?? 0;\n    this.setActive(columnIndex, current + delta, delta);\n  }\n\n  /** Lands on the first enabled entry at or past `index`, walking `direction`. */\n  private setActive(columnIndex: number, index: number, direction: number): void {\n    const column = this.columns[columnIndex];\n    if (!column) return;\n\n    let i = Math.max(0, Math.min(index, column.options.length - 1));\n    while (column.options[i]?.disabled) {\n      i += direction;\n      if (i < 0 || i >= column.options.length) return; // no enabled entry that way\n    }\n\n    this.activeIndex[columnIndex] = i;\n    this.scrollOptionIntoView(columnIndex, i);\n    this.cdr.markForCheck();\n  }\n\n  private focusColumn(columnIndex: number): void {\n    if (columnIndex < 0 || columnIndex >= this.columns.length) return;\n    this.listboxes?.get(columnIndex)?.nativeElement.focus();\n  }\n\n  /** Focuses the first column — used when the panel opens. */\n  focusFirstColumn(): void {\n    this.focusColumn(0);\n  }\n\n  /**\n   * Centres each column on its selected entry. Scrolls the listbox directly\n   * rather than calling `scrollIntoView`, which would also scroll the page\n   * behind a fixed-position panel.\n   */\n  scrollSelectedIntoView(): void {\n    this.listboxes?.forEach((ref) => {\n      const list = ref.nativeElement;\n      const selected = list.querySelector('[data-selected=\"true\"]') as HTMLElement | null;\n      if (!selected) return;\n      list.scrollTop = selected.offsetTop - list.clientHeight / 2 + selected.clientHeight / 2;\n    });\n  }\n\n  private scrollOptionIntoView(columnIndex: number, optionIndex: number): void {\n    const list = this.listboxes?.get(columnIndex)?.nativeElement;\n    if (!list) return;\n    const el = list.children[optionIndex] as HTMLElement | undefined;\n    if (!el) return;\n\n    if (el.offsetTop < list.scrollTop) {\n      list.scrollTop = el.offsetTop;\n    } else if (el.offsetTop + el.clientHeight > list.scrollTop + list.clientHeight) {\n      list.scrollTop = el.offsetTop + el.clientHeight - list.clientHeight;\n    }\n  }\n\n  trackColumn = (_: number, column: TimeColumn) => column.kind;\n  trackOption = (_: number, option: TimeOption) => option.id;\n}\n\n/* ------------------------------------------------------------------ *\n * The picker\n * ------------------------------------------------------------------ */\n\nconst timePickerTriggerVariants = cva(\n  'flex w-full items-center justify-between gap-2 rounded-md border border-input bg-background text-foreground shadow-sm transition-colors ' +\n    'focus:outline-none focus-visible:border-primary/80 focus-visible:ring-4 focus-visible:ring-ring/30 ' +\n    'disabled:cursor-not-allowed disabled:opacity-50',\n  {\n    variants: {\n      size: {\n        xs: 'h-8 px-2 text-xs',\n        sm: 'h-9 px-3 text-sm',\n        default: 'h-10 px-3 text-sm',\n        lg: 'h-11 px-4 text-base',\n      },\n      invalid: {\n        true: 'border-destructive focus-visible:border-destructive/80 focus-visible:ring-destructive/30',\n        false: '',\n      },\n    },\n    defaultVariants: { size: 'default', invalid: false },\n  }\n);\n\n/** Variant props for the time picker trigger. */\nexport type TimePickerProps = VariantProps<typeof timePickerTriggerVariants>;\n\n/**\n * A trigger that opens scrollable hour / minute / second columns in a floating\n * panel.\n *\n * The value is a **24-hour `HH:mm` string** (or `HH:mm:ss` when `showSeconds`),\n * regardless of whether the face is rendered as 12-hour — a wall-clock time has\n * no date and no timezone, and a `Date` would invent both. Set\n * `valueType=\"date\"` to exchange `Date` objects instead, in which case the time\n * is written onto today's date (or onto the date already held by the control).\n *\n * Implements `ControlValueAccessor`, so it works with `ngModel` and reactive\n * forms. Use `tolle-date-time-picker` when a date is needed alongside.\n * @new\n */\n@Component({\n  selector: 'tolle-time-picker',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, TimeColumnsComponent],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => TimePickerComponent),\n      multi: true,\n    },\n  ],\n  template: `\n    <button\n      #trigger\n      type=\"button\"\n      aria-haspopup=\"dialog\"\n      [attr.aria-expanded]=\"isOpen\"\n      [attr.aria-controls]=\"isOpen ? panelId : null\"\n      [attr.aria-label]=\"ariaLabel || null\"\n      [attr.data-state]=\"isOpen ? 'open' : 'closed'\"\n      [disabled]=\"disabled\"\n      [class]=\"computedTriggerClass\"\n      (click)=\"toggle()\"\n      (keydown)=\"onTriggerKeyDown($event)\"\n    >\n      <span [class]=\"cn('truncate', displayValue ? 'text-foreground' : 'text-muted-foreground')\">\n        {{ displayValue || placeholder }}\n      </span>\n      <i class=\"ri-time-line shrink-0 text-muted-foreground\" aria-hidden=\"true\"></i>\n    </button>\n\n    <div\n      *ngIf=\"isOpen\"\n      #panel\n      role=\"dialog\"\n      [id]=\"panelId\"\n      [attr.aria-label]=\"ariaLabel || 'Choose a time'\"\n      class=\"fixed left-0 top-0 z-[9999]\"\n      style=\"visibility: hidden\"\n    >\n      <div class=\"rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md\">\n        <tolle-time-columns\n          #columns\n          [hour]=\"hour\"\n          [minute]=\"minute\"\n          [second]=\"second\"\n          [use12Hours]=\"use12Hours\"\n          [showSeconds]=\"showSeconds\"\n          [minuteStep]=\"minuteStep\"\n          [secondStep]=\"secondStep\"\n          [minSeconds]=\"minSeconds\"\n          [maxSeconds]=\"maxSeconds\"\n          [size]=\"size\"\n          (timeChange)=\"onTimeChange($event)\"\n        ></tolle-time-columns>\n      </div>\n    </div>\n  `,\n})\nexport class TimePickerComponent implements OnChanges, ControlValueAccessor, 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  /** Text shown on the trigger when no time is selected. @default 'Select a time' */\n  @Input() placeholder = 'Select a time';\n  /** Disables the control. @default false */\n  @Input() disabled = false;\n  /** Renders a 12-hour face with an AM/PM column. The emitted value stays 24-hour. @default false */\n  @Input() use12Hours = false;\n  /** Adds a seconds column and emits `HH:mm:ss`. @default false */\n  @Input() showSeconds = false;\n  /** Interval between minute entries, in minutes. @default 1 */\n  @Input() minuteStep = 1;\n  /** Interval between second entries, in seconds. @default 1 */\n  @Input() secondStep = 1;\n  /** Earliest selectable time as a 24-hour `HH:mm` string; earlier entries are disabled. */\n  @Input() min?: string;\n  /** Latest selectable time as a 24-hour `HH:mm` string; later entries are disabled. */\n  @Input() max?: string;\n  /** Height and text size of the trigger and entries. @default 'default' */\n  @Input() size: TimePickerProps['size'] = 'default';\n  /** Applies the destructive border and focus ring. @default false */\n  @Input() invalid = false;\n  /** Accessible name when there is no associated visible label. @default '' */\n  @Input() ariaLabel = '';\n  /** Exchange `Date` objects instead of `HH:mm` strings through the form control. @default 'string' */\n  @Input() valueType: 'string' | 'date' = 'string';\n  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the chosen time whenever it changes. */\n  @Output() valueChange = new EventEmitter<string | Date | null>();\n  /** Emitted when the panel opens. */\n  @Output() opened = new EventEmitter<void>();\n  /** Emitted when the panel closes. */\n  @Output() closed = new EventEmitter<void>();\n\n  @ViewChild('trigger') triggerEl?: ElementRef<HTMLElement>;\n  @ViewChild('panel') panelEl?: ElementRef<HTMLElement>;\n  @ViewChild('columns') columnsCmp?: TimeColumnsComponent;\n\n  readonly panelId = 'time-picker-panel-' + Math.random().toString(36).slice(2, 11);\n\n  hour: number | null = null;\n  minute: number | null = null;\n  second: number | null = null;\n  isOpen = false;\n\n  protected cn = cn;\n\n  private cleanup?: () => void;\n  /** The date half of a `Date` value, kept so round-tripping does not move the day. */\n  private dateAnchor: Date | null = null;\n  private onChange: (value: string | Date | null) => void = () => {};\n  private onTouched: () => void = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  private readonly outsideClickHandler = (event: MouseEvent) => {\n    const target = event.target as Node;\n    if (\n      !this.triggerEl?.nativeElement.contains(target) &&\n      !this.panelEl?.nativeElement.contains(target)\n    ) {\n      this.close();\n    }\n  };\n\n  private readonly escapeHandler = (event: KeyboardEvent) => {\n    if (event.key === 'Escape' && this.isOpen) {\n      event.preventDefault();\n      this.close();\n      this.triggerEl?.nativeElement.focus();\n    }\n  };\n\n  /* ---------------- derived ---------------- */\n\n  /** The current selection as wall-clock parts, or `null` when incomplete. */\n  get parts(): TimeParts | null {\n    if (this.hour === null || this.minute === null) return null;\n    return { hour: this.hour, minute: this.minute, second: this.second ?? 0 };\n  }\n\n  get displayValue(): string {\n    const parts = this.parts;\n    if (!parts) return '';\n\n    if (this.use12Hours) {\n      const { hour12, meridiem } = to12Hour(parts.hour);\n      const body =\n        String(hour12) +\n        ':' +\n        pad2(parts.minute) +\n        (this.showSeconds ? ':' + pad2(parts.second) : '');\n      return body + ' ' + meridiem;\n    }\n    return formatTimeString(parts, this.showSeconds);\n  }\n\n  get minSeconds(): number {\n    const parsed = parseTimeString(this.min);\n    return parsed ? timePartsToSeconds(parsed) : 0;\n  }\n\n  get maxSeconds(): number {\n    const parsed = parseTimeString(this.max);\n    return parsed ? timePartsToSeconds(parsed) : SECONDS_PER_DAY - 1;\n  }\n\n  get computedTriggerClass(): string {\n    return cn(timePickerTriggerVariants({ size: this.size, invalid: this.invalid }), this.class);\n  }\n\n  /* ---------------- open / close ---------------- */\n\n  toggle(): void {\n    this.isOpen ? this.close() : this.open();\n  }\n\n  open(): void {\n    if (this.disabled || this.isOpen) return;\n    this.isOpen = true;\n    this.opened.emit();\n    this.cdr.markForCheck();\n\n    setTimeout(() => {\n      this.updatePosition();\n      this.columnsCmp?.scrollSelectedIntoView();\n      this.columnsCmp?.focusFirstColumn();\n      document.addEventListener('pointerdown', this.outsideClickHandler, true);\n      document.addEventListener('keydown', this.escapeHandler, true);\n    });\n  }\n\n  close(): void {\n    if (!this.isOpen) return;\n    this.isOpen = false;\n    this.closed.emit();\n    this.onTouched();\n    this.teardown();\n    this.cdr.markForCheck();\n  }\n\n  onTriggerKeyDown(event: KeyboardEvent): void {\n    if (['ArrowDown', 'ArrowUp', 'Enter', ' '].includes(event.key) && !this.isOpen) {\n      event.preventDefault();\n      this.open();\n    }\n  }\n\n  /* ---------------- value ---------------- */\n\n  onTimeChange(parts: TimeParts): void {\n    this.hour = parts.hour;\n    this.minute = parts.minute;\n    this.second = parts.second;\n    this.emit();\n    this.cdr.markForCheck();\n  }\n\n  private emit(): void {\n    const value = this.currentValue();\n    this.onChange(value);\n    this.valueChange.emit(value);\n  }\n\n  private currentValue(): string | Date | null {\n    const parts = this.parts;\n    if (!parts) return null;\n    if (this.valueType === 'date') {\n      const base = this.dateAnchor ?? new Date();\n      return new Date(\n        base.getFullYear(),\n        base.getMonth(),\n        base.getDate(),\n        parts.hour,\n        parts.minute,\n        parts.second,\n        0\n      );\n    }\n    return formatTimeString(parts, this.showSeconds);\n  }\n\n  private updatePosition(): void {\n    const trigger = this.triggerEl?.nativeElement;\n    const panel = this.panelEl?.nativeElement;\n    if (!trigger || !panel) return;\n\n    this.cleanup = autoUpdate(trigger, panel, () => {\n      computePosition(trigger, panel, {\n        strategy: 'fixed',\n        placement: 'bottom-start',\n        middleware: [offset(4), flip(), shift({ padding: 8 })],\n      }).then(({ x, y }) => {\n        Object.assign(panel.style, {\n          left: x + 'px',\n          top: y + 'px',\n          visibility: 'visible',\n        });\n      });\n    });\n  }\n\n  private teardown(): void {\n    this.cleanup?.();\n    this.cleanup = undefined;\n    document.removeEventListener('pointerdown', this.outsideClickHandler, true);\n    document.removeEventListener('keydown', this.escapeHandler, true);\n  }\n\n  ngOnDestroy(): void {\n    this.teardown();\n  }\n\n  /* ---------------- ControlValueAccessor ---------------- */\n\n  writeValue(value: string | Date | null | undefined): void {\n    let parts: TimeParts | null = null;\n\n    if (value instanceof Date && !isNaN(value.getTime())) {\n      this.dateAnchor = value;\n      parts = { hour: value.getHours(), minute: value.getMinutes(), second: value.getSeconds() };\n    } else if (typeof value === 'string') {\n      parts = parseTimeString(value);\n    }\n\n    this.hour = parts ? parts.hour : null;\n    this.minute = parts ? parts.minute : null;\n    this.second = parts ? parts.second : null;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: (value: string | Date | null) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    if (isDisabled) this.close();\n    this.cdr.markForCheck();\n  }\n}\n"]}