@tolle_/tolle-ui 18.2.29 → 18.3.0

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

@@ -0,0 +1,506 @@
+import { Component, Input, Output, EventEmitter, forwardRef, ViewChild, ChangeDetectionStrategy } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
+import { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';
+import { cva } from 'class-variance-authority';
+import { format, isSameDay, isValid, startOfDay } from 'date-fns';
+import { cn } from './utils/cn';
+import { CalendarComponent } from './calendar.component';
+import { TimeColumnsComponent, to12Hour } from './time-picker.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+const SECONDS_PER_DAY = 24 * 3600;
+const dateTimePickerTriggerVariants = 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 },
+});
+/**
+ * One control for a date *and* a time: `tolle-calendar` on the left, the
+ * `tolle-time-columns` strip on the right, in a single floating panel with a
+ * Clear / Done footer.
+ *
+ * The value is a `Date`, because a date-time genuinely is a moment. Changing
+ * the date preserves the chosen time and changing the time preserves the
+ * chosen date — the two halves are only ever recombined, never reset.
+ *
+ * Implements `ControlValueAccessor`, so it works with `ngModel` and reactive
+ * forms. Use `tolle-date-picker` for a date alone and `tolle-time-picker` for a
+ * time alone.
+ * @new
+ */
+export class DateTimePickerComponent {
+    cdr;
+    /** Text shown on the trigger when nothing is selected. @default 'Select date and time' */
+    placeholder = 'Select date and time';
+    /** Disables the control. @default false */
+    disabled = false;
+    /** Renders a 12-hour face with an AM/PM column. @default false */
+    use12Hours = false;
+    /** Adds a seconds column. @default false */
+    showSeconds = false;
+    /** Interval between minute entries, in minutes. @default 1 */
+    minuteStep = 1;
+    /** Earliest selectable moment; earlier days and times are disabled. */
+    min;
+    /** Latest selectable moment; later days and times are disabled. */
+    max;
+    /** date-fns pattern used to render the value on the trigger. @default 'MMM d, yyyy h:mm a' */
+    displayFormat = 'MMM d, yyyy h:mm a';
+    /** 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 = '';
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the chosen moment, or `null` when the value is cleared. */
+    valueChange = new EventEmitter();
+    /** Emitted when the panel opens. */
+    opened = new EventEmitter();
+    /** Emitted when the panel closes. */
+    closed = new EventEmitter();
+    triggerEl;
+    panelEl;
+    columnsCmp;
+    panelId = 'date-time-picker-panel-' + Math.random().toString(36).slice(2, 11);
+    value = null;
+    isOpen = false;
+    /**
+     * Day-only copies of `min` / `max` for the calendar. The calendar compares
+     * whole `Date`s, so passing a bound that carries a time would disable its own
+     * day — 09:00 on the min day would look "before" a 09:30 minimum.
+     */
+    calendarMin;
+    calendarMax;
+    footerButtonClass = cn('rounded-md px-3 py-1.5 text-sm font-medium text-muted-foreground transition-colors', 'hover:bg-accent hover:text-accent-foreground', 'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring');
+    cn = cn;
+    cleanup;
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    ngOnChanges() {
+        this.calendarMin = this.min ? startOfDay(this.min) : undefined;
+        this.calendarMax = this.max ? startOfDay(this.max) : undefined;
+        // 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();
+    }
+    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 ---------------- */
+    get hour() {
+        return this.value ? this.value.getHours() : null;
+    }
+    get minute() {
+        return this.value ? this.value.getMinutes() : null;
+    }
+    get second() {
+        return this.value ? this.value.getSeconds() : null;
+    }
+    get displayValue() {
+        if (!this.value)
+            return '';
+        try {
+            return format(this.value, this.displayFormat);
+        }
+        catch {
+            // A bad pattern should not blank the control; fall back to something readable.
+            const { hour12, meridiem } = to12Hour(this.value.getHours());
+            return (format(this.value, 'MMM d, yyyy') +
+                ' ' +
+                hour12 +
+                ':' +
+                String(this.value.getMinutes()).padStart(2, '0') +
+                ' ' +
+                meridiem);
+        }
+    }
+    /**
+     * The time bound only bites on the boundary day itself: on the min day the
+     * columns start at the min time, on any later day they start at midnight.
+     */
+    get minSeconds() {
+        if (!this.min)
+            return 0;
+        const day = this.value ?? this.min;
+        if (!isSameDay(day, this.min))
+            return 0;
+        return this.min.getHours() * 3600 + this.min.getMinutes() * 60 + this.min.getSeconds();
+    }
+    get maxSeconds() {
+        if (!this.max)
+            return SECONDS_PER_DAY - 1;
+        const day = this.value ?? this.max;
+        if (!isSameDay(day, this.max))
+            return SECONDS_PER_DAY - 1;
+        return this.max.getHours() * 3600 + this.max.getMinutes() * 60 + this.max.getSeconds();
+    }
+    get computedTriggerClass() {
+        return cn(dateTimePickerTriggerVariants({ 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();
+            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 ---------------- */
+    /**
+     * Applies a newly picked day, carrying the existing time across. With no
+     * time chosen yet the day starts at midnight.
+     */
+    onDateSelect(date) {
+        if (!date) {
+            this.clear();
+            return;
+        }
+        const previous = this.value;
+        this.commit(new Date(date.getFullYear(), date.getMonth(), date.getDate(), previous ? previous.getHours() : 0, previous ? previous.getMinutes() : 0, previous ? previous.getSeconds() : 0, 0));
+    }
+    /**
+     * Applies a newly picked time, carrying the existing day across. With no day
+     * chosen yet the time lands on today.
+     */
+    onTimeChange(parts) {
+        const base = this.value ?? new Date();
+        this.commit(new Date(base.getFullYear(), base.getMonth(), base.getDate(), parts.hour, parts.minute, parts.second, 0));
+    }
+    clear() {
+        this.commit(null);
+        // The calendar keeps its own selection and ignores a null written through
+        // the CVA, so closing is what actually returns it to a clean state — it is
+        // rebuilt from scratch the next time the panel opens.
+        this.close();
+    }
+    done() {
+        this.close();
+        this.triggerEl?.nativeElement.focus();
+    }
+    commit(next) {
+        this.value = next;
+        this.onChange(next);
+        this.valueChange.emit(next);
+        this.cdr.markForCheck();
+    }
+    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) {
+        if (value instanceof Date && isValid(value)) {
+            this.value = value;
+        }
+        else if (typeof value === 'string' && value) {
+            const parsed = new Date(value);
+            this.value = isValid(parsed) ? parsed : null;
+        }
+        else {
+            this.value = 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: DateTimePickerComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DateTimePickerComponent, isStandalone: true, selector: "tolle-date-time-picker", inputs: { placeholder: "placeholder", disabled: "disabled", use12Hours: "use12Hours", showSeconds: "showSeconds", minuteStep: "minuteStep", min: "min", max: "max", displayFormat: "displayFormat", size: "size", invalid: "invalid", ariaLabel: "ariaLabel", class: "class" }, outputs: { valueChange: "valueChange", opened: "opened", closed: "closed" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => DateTimePickerComponent),
+                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-calendar-schedule-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 date and time'"
+      class="fixed left-0 top-0 z-[9999]"
+      style="visibility: hidden"
+    >
+      <div class="rounded-md border border-border bg-popover text-popover-foreground shadow-md">
+        <div class="flex flex-col sm:flex-row">
+          <div class="p-3">
+            <tolle-calendar
+              [bordered]="false"
+              [showQuickActions]="false"
+              [minDate]="calendarMin"
+              [maxDate]="calendarMax"
+              [ngModel]="value"
+              (dateSelect)="onDateSelect($event)"
+            ></tolle-calendar>
+          </div>
+
+          <div class="border-t border-border p-3 sm:border-l sm:border-t-0">
+            <tolle-time-columns
+              #columns
+              [hour]="hour"
+              [minute]="minute"
+              [second]="second"
+              [use12Hours]="use12Hours"
+              [showSeconds]="showSeconds"
+              [minuteStep]="minuteStep"
+              [minSeconds]="minSeconds"
+              [maxSeconds]="maxSeconds"
+              [size]="size"
+              (timeChange)="onTimeChange($event)"
+            ></tolle-time-columns>
+          </div>
+        </div>
+
+        <div class="flex items-center justify-between gap-2 border-t border-border px-3 py-2">
+          <button
+            type="button"
+            [class]="footerButtonClass"
+            (click)="clear()"
+          >
+            Clear
+          </button>
+          <button
+            type="button"
+            [class]="cn(footerButtonClass, 'bg-primary text-primary-foreground hover:bg-primary/90 hover:text-primary-foreground')"
+            (click)="done()"
+          >
+            Done
+          </button>
+        </div>
+      </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: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: CalendarComponent, selector: "tolle-calendar", inputs: ["class", "bordered", "mode", "disablePastDates", "showQuickActions", "minDate", "maxDate", "formatMonthFn", "formatYearFn", "formatDateFn"], outputs: ["dateSelect"] }, { 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: DateTimePickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-date-time-picker', standalone: true, imports: [CommonModule, FormsModule, CalendarComponent, TimeColumnsComponent], changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => DateTimePickerComponent),
+                            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-calendar-schedule-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 date and time'"
+      class="fixed left-0 top-0 z-[9999]"
+      style="visibility: hidden"
+    >
+      <div class="rounded-md border border-border bg-popover text-popover-foreground shadow-md">
+        <div class="flex flex-col sm:flex-row">
+          <div class="p-3">
+            <tolle-calendar
+              [bordered]="false"
+              [showQuickActions]="false"
+              [minDate]="calendarMin"
+              [maxDate]="calendarMax"
+              [ngModel]="value"
+              (dateSelect)="onDateSelect($event)"
+            ></tolle-calendar>
+          </div>
+
+          <div class="border-t border-border p-3 sm:border-l sm:border-t-0">
+            <tolle-time-columns
+              #columns
+              [hour]="hour"
+              [minute]="minute"
+              [second]="second"
+              [use12Hours]="use12Hours"
+              [showSeconds]="showSeconds"
+              [minuteStep]="minuteStep"
+              [minSeconds]="minSeconds"
+              [maxSeconds]="maxSeconds"
+              [size]="size"
+              (timeChange)="onTimeChange($event)"
+            ></tolle-time-columns>
+          </div>
+        </div>
+
+        <div class="flex items-center justify-between gap-2 border-t border-border px-3 py-2">
+          <button
+            type="button"
+            [class]="footerButtonClass"
+            (click)="clear()"
+          >
+            Clear
+          </button>
+          <button
+            type="button"
+            [class]="cn(footerButtonClass, 'bg-primary text-primary-foreground hover:bg-primary/90 hover:text-primary-foreground')"
+            (click)="done()"
+          >
+            Done
+          </button>
+        </div>
+      </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
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], displayFormat: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], ariaLabel: [{
+                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":"date-time-picker.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/date-time-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, forwardRef, ElementRef, ViewChild, ChangeDetectorRef, ChangeDetectionStrategy, OnChanges, OnDestroy, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';\nimport { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { format, isSameDay, isValid, startOfDay } from 'date-fns';\nimport { cn } from './utils/cn';\nimport { CalendarComponent } from './calendar.component';\nimport { TimeColumnsComponent, TimeParts, to12Hour } from './time-picker.component';\n\nconst SECONDS_PER_DAY = 24 * 3600;\n\nconst dateTimePickerTriggerVariants = 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 date-time picker trigger. */\nexport type DateTimePickerProps = VariantProps<typeof dateTimePickerTriggerVariants>;\n\n/**\n * One control for a date *and* a time: `tolle-calendar` on the left, the\n * `tolle-time-columns` strip on the right, in a single floating panel with a\n * Clear / Done footer.\n *\n * The value is a `Date`, because a date-time genuinely is a moment. Changing\n * the date preserves the chosen time and changing the time preserves the\n * chosen date — the two halves are only ever recombined, never reset.\n *\n * Implements `ControlValueAccessor`, so it works with `ngModel` and reactive\n * forms. Use `tolle-date-picker` for a date alone and `tolle-time-picker` for a\n * time alone.\n * @new\n */\n@Component({\n  selector: 'tolle-date-time-picker',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, FormsModule, CalendarComponent, TimeColumnsComponent],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => DateTimePickerComponent),\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-calendar-schedule-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 date and 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 text-popover-foreground shadow-md\">\n        <div class=\"flex flex-col sm:flex-row\">\n          <div class=\"p-3\">\n            <tolle-calendar\n              [bordered]=\"false\"\n              [showQuickActions]=\"false\"\n              [minDate]=\"calendarMin\"\n              [maxDate]=\"calendarMax\"\n              [ngModel]=\"value\"\n              (dateSelect)=\"onDateSelect($event)\"\n            ></tolle-calendar>\n          </div>\n\n          <div class=\"border-t border-border p-3 sm:border-l sm:border-t-0\">\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              [minSeconds]=\"minSeconds\"\n              [maxSeconds]=\"maxSeconds\"\n              [size]=\"size\"\n              (timeChange)=\"onTimeChange($event)\"\n            ></tolle-time-columns>\n          </div>\n        </div>\n\n        <div class=\"flex items-center justify-between gap-2 border-t border-border px-3 py-2\">\n          <button\n            type=\"button\"\n            [class]=\"footerButtonClass\"\n            (click)=\"clear()\"\n          >\n            Clear\n          </button>\n          <button\n            type=\"button\"\n            [class]=\"cn(footerButtonClass, 'bg-primary text-primary-foreground hover:bg-primary/90 hover:text-primary-foreground')\"\n            (click)=\"done()\"\n          >\n            Done\n          </button>\n        </div>\n      </div>\n    </div>\n  `,\n})\nexport class DateTimePickerComponent implements ControlValueAccessor, OnChanges, OnDestroy {\n  /** Text shown on the trigger when nothing is selected. @default 'Select date and time' */\n  @Input() placeholder = 'Select date and time';\n  /** Disables the control. @default false */\n  @Input() disabled = false;\n  /** Renders a 12-hour face with an AM/PM column. @default false */\n  @Input() use12Hours = false;\n  /** Adds a seconds column. @default false */\n  @Input() showSeconds = false;\n  /** Interval between minute entries, in minutes. @default 1 */\n  @Input() minuteStep = 1;\n  /** Earliest selectable moment; earlier days and times are disabled. */\n  @Input() min?: Date;\n  /** Latest selectable moment; later days and times are disabled. */\n  @Input() max?: Date;\n  /** date-fns pattern used to render the value on the trigger. @default 'MMM d, yyyy h:mm a' */\n  @Input() displayFormat = 'MMM d, yyyy h:mm a';\n  /** Height and text size of the trigger and entries. @default 'default' */\n  @Input() size: DateTimePickerProps['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  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the chosen moment, or `null` when the value is cleared. */\n  @Output() valueChange = new EventEmitter<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 = 'date-time-picker-panel-' + Math.random().toString(36).slice(2, 11);\n\n  value: Date | null = null;\n  isOpen = false;\n\n  /**\n   * Day-only copies of `min` / `max` for the calendar. The calendar compares\n   * whole `Date`s, so passing a bound that carries a time would disable its own\n   * day — 09:00 on the min day would look \"before\" a 09:30 minimum.\n   */\n  calendarMin?: Date;\n  calendarMax?: Date;\n\n  readonly footerButtonClass = cn(\n    'rounded-md px-3 py-1.5 text-sm font-medium text-muted-foreground transition-colors',\n    'hover:bg-accent hover:text-accent-foreground',\n    'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring'\n  );\n\n  protected cn = cn;\n\n  private cleanup?: () => void;\n  private onChange: (value: Date | null) => void = () => {};\n  private onTouched: () => void = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  ngOnChanges(): void {\n    this.calendarMin = this.min ? startOfDay(this.min) : undefined;\n    this.calendarMax = this.max ? startOfDay(this.max) : undefined;\n  \n    // A bound `class` input is written through Angular's styling path,\n    // which does not mark an OnPush view dirty on its own.\n    this.cdr.markForCheck();\n  }\n\n  private 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  get hour(): number | null {\n    return this.value ? this.value.getHours() : null;\n  }\n\n  get minute(): number | null {\n    return this.value ? this.value.getMinutes() : null;\n  }\n\n  get second(): number | null {\n    return this.value ? this.value.getSeconds() : null;\n  }\n\n  get displayValue(): string {\n    if (!this.value) return '';\n    try {\n      return format(this.value, this.displayFormat);\n    } catch {\n      // A bad pattern should not blank the control; fall back to something readable.\n      const { hour12, meridiem } = to12Hour(this.value.getHours());\n      return (\n        format(this.value, 'MMM d, yyyy') +\n        ' ' +\n        hour12 +\n        ':' +\n        String(this.value.getMinutes()).padStart(2, '0') +\n        ' ' +\n        meridiem\n      );\n    }\n  }\n\n  /**\n   * The time bound only bites on the boundary day itself: on the min day the\n   * columns start at the min time, on any later day they start at midnight.\n   */\n  get minSeconds(): number {\n    if (!this.min) return 0;\n    const day = this.value ?? this.min;\n    if (!isSameDay(day, this.min)) return 0;\n    return this.min.getHours() * 3600 + this.min.getMinutes() * 60 + this.min.getSeconds();\n  }\n\n  get maxSeconds(): number {\n    if (!this.max) return SECONDS_PER_DAY - 1;\n    const day = this.value ?? this.max;\n    if (!isSameDay(day, this.max)) return SECONDS_PER_DAY - 1;\n    return this.max.getHours() * 3600 + this.max.getMinutes() * 60 + this.max.getSeconds();\n  }\n\n  get computedTriggerClass(): string {\n    return cn(\n      dateTimePickerTriggerVariants({ size: this.size, invalid: this.invalid }),\n      this.class\n    );\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      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  /**\n   * Applies a newly picked day, carrying the existing time across. With no\n   * time chosen yet the day starts at midnight.\n   */\n  onDateSelect(date: Date | null): void {\n    if (!date) {\n      this.clear();\n      return;\n    }\n\n    const previous = this.value;\n    this.commit(\n      new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate(),\n        previous ? previous.getHours() : 0,\n        previous ? previous.getMinutes() : 0,\n        previous ? previous.getSeconds() : 0,\n        0\n      )\n    );\n  }\n\n  /**\n   * Applies a newly picked time, carrying the existing day across. With no day\n   * chosen yet the time lands on today.\n   */\n  onTimeChange(parts: TimeParts): void {\n    const base = this.value ?? new Date();\n    this.commit(\n      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  }\n\n  clear(): void {\n    this.commit(null);\n    // The calendar keeps its own selection and ignores a null written through\n    // the CVA, so closing is what actually returns it to a clean state — it is\n    // rebuilt from scratch the next time the panel opens.\n    this.close();\n  }\n\n  done(): void {\n    this.close();\n    this.triggerEl?.nativeElement.focus();\n  }\n\n  private commit(next: Date | null): void {\n    this.value = next;\n    this.onChange(next);\n    this.valueChange.emit(next);\n    this.cdr.markForCheck();\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: Date | string | null | undefined): void {\n    if (value instanceof Date && isValid(value)) {\n      this.value = value;\n    } else if (typeof value === 'string' && value) {\n      const parsed = new Date(value);\n      this.value = isValid(parsed) ? parsed : null;\n    } else {\n      this.value = null;\n    }\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: (value: 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"]}

package/esm2022/lib/direction.component.mjs

@@ -0,0 +1,79 @@
+import { Directive, Injectable, Input, Output, EventEmitter, HostBinding, inject, } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Publishes the application's current writing direction so components can adapt
+ * without reading the DOM.
+ *
+ * Direction is not an input of most components, so an OnPush view would never be
+ * marked dirty by a change. Subscribe to `direction$` and call `markForCheck()`
+ * on emission wherever the rendered output depends on it.
+ */
+export class DirectionService {
+    directionSource = new BehaviorSubject('ltr');
+    /** Emits the current writing direction, starting with the present value. */
+    direction$ = this.directionSource.asObservable();
+    /** The current writing direction. */
+    get direction() {
+        return this.directionSource.value;
+    }
+    /** Whether the current direction is explicitly right-to-left. */
+    get isRtl() {
+        return this.directionSource.value === 'rtl';
+    }
+    /** Sets the current direction, emitting only when it actually changes. */
+    setDirection(direction) {
+        if (this.directionSource.value !== direction)
+            this.directionSource.next(direction);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DirectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DirectionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DirectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Sets the `dir` attribute on its host and publishes that direction to
+ * `DirectionService`, so a whole chat surface can be flipped to RTL from one
+ * place. Put it on the outermost element of the subtree you want to flip.
+ * @new
+ */
+export class DirectionDirective {
+    /** Writing direction applied to the host's `dir` attribute. @default 'ltr' */
+    tolleDirection = 'ltr';
+    /** Whether to publish this direction to the app-wide `DirectionService`. @default true */
+    tolleDirectionPublish = true;
+    /** Emitted with the direction whenever it changes. */
+    directionChange = new EventEmitter();
+    service = inject(DirectionService);
+    /** The resolved `dir` attribute value written onto the host. */
+    get dir() {
+        return this.tolleDirection ?? 'ltr';
+    }
+    ngOnChanges() {
+        const direction = this.dir;
+        if (this.tolleDirectionPublish)
+            this.service.setDirection(direction);
+        this.directionChange.emit(direction);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DirectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DirectionDirective, isStandalone: true, selector: "[tolleDirection]", inputs: { tolleDirection: "tolleDirection", tolleDirectionPublish: "tolleDirectionPublish" }, outputs: { directionChange: "directionChange" }, host: { properties: { "attr.dir": "this.dir" } }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DirectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleDirection]',
+                    standalone: true,
+                }]
+        }], propDecorators: { tolleDirection: [{
+                type: Input
+            }], tolleDirectionPublish: [{
+                type: Input
+            }], directionChange: [{
+                type: Output
+            }], dir: [{
+                type: HostBinding,
+                args: ['attr.dir']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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