@tolle_/tolle-ui 0.0.1-beta

package/esm2022/lib/data-table.component.mjs

@@ -0,0 +1,332 @@
+import { Component, Input, ContentChildren } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { cn } from './utils/cn';
+import { PaginationComponent } from '@tolle/ui/pagination.component';
+import { InputComponent } from '@tolle/ui/input.component';
+import { TolleCellDirective } from '@tolle/ui/tolle-cell.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class DataTableComponent {
+    data = [];
+    columns = [];
+    searchable = true;
+    paginate = true;
+    pageSize = 10;
+    expandable = false;
+    size = 'default';
+    // Track which rows are open
+    expandedRows = new Set();
+    // Use ContentChildren to grab the tolleCell templates from the user's HTML
+    cellTemplates;
+    // Keep this as an Input for the main expansion slot
+    expandedTemplate;
+    filteredData = [];
+    pagedData = [];
+    searchTerm = '';
+    currentPage = 1;
+    sortKey = '';
+    sortDir = null;
+    // 2. Map Size to Padding for Cells
+    get cellPaddingClass() {
+        switch (this.size) {
+            case 'xs': return 'p-1 px-4'; // Ultra-compact
+            case 'sm': return 'p-2 px-4'; // Dense
+            case 'lg': return 'p-6 px-4'; // Spacious
+            default: return 'p-4'; // Standard (16px)
+        }
+    }
+    // 3. Map Size to Padding for Header (usually slightly shorter than cells)
+    get headerPaddingClass() {
+        switch (this.size) {
+            case 'xs': return 'h-7 px-4';
+            case 'sm': return 'h-9 px-4';
+            case 'lg': return 'h-14 px-4';
+            default: return 'h-12 px-4';
+        }
+    }
+    // 4. Map Size to Font Sizes
+    get fontSizeClass() {
+        switch (this.size) {
+            case 'xs': return 'text-[11px]';
+            case 'sm': return 'text-xs';
+            case 'lg': return 'text-base';
+            default: return 'text-sm';
+        }
+    }
+    cn = cn;
+    ngOnInit() { this.refreshTable(); }
+    ngOnChanges(changes) {
+        if (changes['data']) {
+            this.refreshTable();
+        }
+    }
+    // --- Search & Sort & Page Logic ---
+    // (Your existing implementation of applySearch, applySort, and updatePage goes here)
+    refreshTable() { this.applySearch(); this.applySort(); this.updatePage(); }
+    onSearch() { this.currentPage = 1; this.refreshTable(); }
+    applySearch() {
+        if (!this.searchTerm) {
+            this.filteredData = [...this.data];
+            return;
+        }
+        const q = this.searchTerm.toLowerCase();
+        this.filteredData = this.data.filter(row => Object.values(row).some(val => String(val).toLowerCase().includes(q)));
+    }
+    applySort() {
+        if (!this.sortKey || !this.sortDir)
+            return;
+        this.filteredData.sort((a, b) => {
+            const valA = a[this.sortKey];
+            const valB = b[this.sortKey];
+            if (valA < valB)
+                return this.sortDir === 'asc' ? -1 : 1;
+            if (valA > valB)
+                return this.sortDir === 'asc' ? 1 : -1;
+            return 0;
+        });
+    }
+    updatePage() {
+        if (!this.paginate) {
+            this.pagedData = this.filteredData;
+            return;
+        }
+        const start = (this.currentPage - 1) * this.pageSize;
+        const end = start + this.pageSize;
+        this.pagedData = this.filteredData.slice(start, end);
+    }
+    // --- Helpers ---
+    toggleSort(key) {
+        if (this.sortKey === key) {
+            this.sortDir = this.sortDir === 'asc' ? 'desc' : this.sortDir === 'desc' ? null : 'asc';
+        }
+        else {
+            this.sortKey = key;
+            this.sortDir = 'asc';
+        }
+        this.refreshTable();
+    }
+    getSortIcon(key) {
+        if (this.sortKey !== key || !this.sortDir)
+            return 'ri-arrow-up-down-line opacity-30';
+        return this.sortDir === 'asc' ? 'ri-arrow-up-line' : 'ri-arrow-down-line';
+    }
+    toggleRow(index) {
+        if (this.expandedRows.has(index))
+            this.expandedRows.delete(index);
+        else
+            this.expandedRows.add(index);
+    }
+    // Helper to find the right cell template
+    getTemplate(key) {
+        return this.cellTemplates?.find(t => t.name === key);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DataTableComponent, isStandalone: true, selector: "tolle-data-table", inputs: { data: "data", columns: "columns", searchable: "searchable", paginate: "paginate", pageSize: "pageSize", expandable: "expandable", size: "size", expandedTemplate: "expandedTemplate" }, queries: [{ propertyName: "cellTemplates", predicate: TolleCellDirective }], usesOnChanges: true, ngImport: i0, template: `
+    <div class="space-y-4">
+      <div *ngIf="searchable" class="flex items-center py-2">
+        <tolle-input
+          [size]="size === 'lg' ? 'default' : 'sm'"
+          class="max-w-sm"
+          placeholder="Filter records..."
+          [(ngModel)]="searchTerm"
+          (ngModelChange)="onSearch()">
+          <i prefix class="ri-search-line"></i>
+        </tolle-input>
+      </div>
+
+      <div class="rounded-md border border-border bg-background overflow-hidden shadow-sm">
+        <table class="w-full text-sm">
+          <thead class="border-b bg-muted/30">
+            <tr>
+              <th *ngIf="expandable" [class]="cn('px-4', size === 'xs' ? 'w-[32px]' : 'w-[48px]')"></th>
+              <th *ngFor="let col of columns"
+                  [class]="cn(
+                  'font-medium text-muted-foreground transition-all',
+                  headerPaddingClass,
+                  fontSizeClass,
+                  col.class
+                )">
+                <div *ngIf="col.sortable; else simpleHeader" (click)="toggleSort(col.key)" class="flex items-center gap-1 cursor-pointer hover:text-foreground">
+                  {{ col.label }}
+                  <i [class]="getSortIcon(col.key)"></i>
+                </div>
+                <ng-template #simpleHeader>{{ col.label }}</ng-template>
+              </th>
+            </tr>
+          </thead>
+          <tbody class="divide-y divide-border">
+            <ng-container *ngFor="let row of pagedData; let i = index">
+              <tr class="hover:bg-muted/50 transition-colors">
+                <td *ngIf="expandable" class="px-4">
+                  <button (click)="toggleRow(i)"
+                          [class]="cn(
+                      'flex items-center justify-center rounded-md hover:bg-accent text-muted-foreground hover:text-foreground',
+                      size === 'xs' ? 'h-6 w-6' : 'h-8 w-8'
+                    )">
+                    <i [class]="expandedRows.has(i) ? 'ri-arrow-down-s-line' : 'ri-arrow-right-s-line'"></i>
+                  </button>
+                </td>
+
+                <td *ngFor="let col of columns"
+                    [class]="cn(
+                    'align-middle transition-all',
+                    cellPaddingClass,
+                    fontSizeClass,
+                    col.class
+                  )">
+                  <ng-container *ngIf="getTemplate(col.key) as cell; else defaultValue">
+                    <ng-container *ngTemplateOutlet="cell.template; context: { $implicit: row[col.key], row: row }"></ng-container>
+                  </ng-container>
+                  <ng-template #defaultValue>
+                    <span class="text-foreground">{{ row[col.key] }}</span>
+                  </ng-template>
+                </td>
+              </tr>
+
+              <tr *ngIf="expandedRows.has(i)" class="bg-muted/10">
+                <td [attr.colspan]="columns.length + (expandable ? 1 : 0)" class="p-0">
+                   <div class="p-6 border-b border-dashed border-border">
+                      <ng-container *ngIf="expandedTemplate; else defaultExpanded">
+                        <ng-container *ngTemplateOutlet="expandedTemplate; context: { row: row }"></ng-container>
+                      </ng-container>
+                      <ng-template #defaultExpanded>
+                        <div class="text-xs text-muted-foreground italic">No details available.</div>
+                      </ng-template>
+                   </div>
+                </td>
+              </tr>
+            </ng-container>
+          </tbody>
+        </table>
+      </div>
+
+      <tolle-pagination
+        *ngIf="paginate"
+        [totalRecords]="filteredData.length"
+        [currentPage]="currentPage"
+        [currentPageSize]="pageSize"
+        (onPageNumberChange)="updatePage()"
+        (onPageSizeChange)="updatePage()"
+      ></tolle-pagination>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { 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: PaginationComponent, selector: "tolle-pagination", inputs: ["class", "showPageLinks", "showPageOptions", "showCurrentPageInfo", "currentPageInfoTemplate", "totalRecords", "currentPageSize", "currentPage", "pageSizeOptions"], outputs: ["onPageNumberChange", "onPageSizeChange"] }, { kind: "component", type: InputComponent, selector: "tolle-input", inputs: ["type", "placeholder", "disabled", "error", "size", "containerClass", "class"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataTableComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-data-table',
+                    standalone: true,
+                    imports: [CommonModule, FormsModule, PaginationComponent, InputComponent],
+                    template: `
+    <div class="space-y-4">
+      <div *ngIf="searchable" class="flex items-center py-2">
+        <tolle-input
+          [size]="size === 'lg' ? 'default' : 'sm'"
+          class="max-w-sm"
+          placeholder="Filter records..."
+          [(ngModel)]="searchTerm"
+          (ngModelChange)="onSearch()">
+          <i prefix class="ri-search-line"></i>
+        </tolle-input>
+      </div>
+
+      <div class="rounded-md border border-border bg-background overflow-hidden shadow-sm">
+        <table class="w-full text-sm">
+          <thead class="border-b bg-muted/30">
+            <tr>
+              <th *ngIf="expandable" [class]="cn('px-4', size === 'xs' ? 'w-[32px]' : 'w-[48px]')"></th>
+              <th *ngFor="let col of columns"
+                  [class]="cn(
+                  'font-medium text-muted-foreground transition-all',
+                  headerPaddingClass,
+                  fontSizeClass,
+                  col.class
+                )">
+                <div *ngIf="col.sortable; else simpleHeader" (click)="toggleSort(col.key)" class="flex items-center gap-1 cursor-pointer hover:text-foreground">
+                  {{ col.label }}
+                  <i [class]="getSortIcon(col.key)"></i>
+                </div>
+                <ng-template #simpleHeader>{{ col.label }}</ng-template>
+              </th>
+            </tr>
+          </thead>
+          <tbody class="divide-y divide-border">
+            <ng-container *ngFor="let row of pagedData; let i = index">
+              <tr class="hover:bg-muted/50 transition-colors">
+                <td *ngIf="expandable" class="px-4">
+                  <button (click)="toggleRow(i)"
+                          [class]="cn(
+                      'flex items-center justify-center rounded-md hover:bg-accent text-muted-foreground hover:text-foreground',
+                      size === 'xs' ? 'h-6 w-6' : 'h-8 w-8'
+                    )">
+                    <i [class]="expandedRows.has(i) ? 'ri-arrow-down-s-line' : 'ri-arrow-right-s-line'"></i>
+                  </button>
+                </td>
+
+                <td *ngFor="let col of columns"
+                    [class]="cn(
+                    'align-middle transition-all',
+                    cellPaddingClass,
+                    fontSizeClass,
+                    col.class
+                  )">
+                  <ng-container *ngIf="getTemplate(col.key) as cell; else defaultValue">
+                    <ng-container *ngTemplateOutlet="cell.template; context: { $implicit: row[col.key], row: row }"></ng-container>
+                  </ng-container>
+                  <ng-template #defaultValue>
+                    <span class="text-foreground">{{ row[col.key] }}</span>
+                  </ng-template>
+                </td>
+              </tr>
+
+              <tr *ngIf="expandedRows.has(i)" class="bg-muted/10">
+                <td [attr.colspan]="columns.length + (expandable ? 1 : 0)" class="p-0">
+                   <div class="p-6 border-b border-dashed border-border">
+                      <ng-container *ngIf="expandedTemplate; else defaultExpanded">
+                        <ng-container *ngTemplateOutlet="expandedTemplate; context: { row: row }"></ng-container>
+                      </ng-container>
+                      <ng-template #defaultExpanded>
+                        <div class="text-xs text-muted-foreground italic">No details available.</div>
+                      </ng-template>
+                   </div>
+                </td>
+              </tr>
+            </ng-container>
+          </tbody>
+        </table>
+      </div>
+
+      <tolle-pagination
+        *ngIf="paginate"
+        [totalRecords]="filteredData.length"
+        [currentPage]="currentPage"
+        [currentPageSize]="pageSize"
+        (onPageNumberChange)="updatePage()"
+        (onPageSizeChange)="updatePage()"
+      ></tolle-pagination>
+    </div>
+  `
+                }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], searchable: [{
+                type: Input
+            }], paginate: [{
+                type: Input
+            }], pageSize: [{
+                type: Input
+            }], expandable: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], cellTemplates: [{
+                type: ContentChildren,
+                args: [TolleCellDirective]
+            }], expandedTemplate: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/data-table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component, Input, OnInit, OnChanges, SimpleChanges,\n  TemplateRef, ContentChildren, QueryList\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { cn } from './utils/cn';\nimport {PaginationComponent} from '@tolle/ui/pagination.component';\nimport {InputComponent} from '@tolle/ui/input.component';\nimport {TolleCellDirective} from '@tolle/ui/tolle-cell.directive';\n\nexport interface TableColumn {\n  key: string;\n  label: string;\n  sortable?: boolean;\n  class?: string;\n}\n\n@Component({\n  selector: 'tolle-data-table',\n  standalone: true,\n  imports: [CommonModule, FormsModule, PaginationComponent, InputComponent],\n  template: `\n    <div class=\"space-y-4\">\n      <div *ngIf=\"searchable\" class=\"flex items-center py-2\">\n        <tolle-input\n          [size]=\"size === 'lg' ? 'default' : 'sm'\"\n          class=\"max-w-sm\"\n          placeholder=\"Filter records...\"\n          [(ngModel)]=\"searchTerm\"\n          (ngModelChange)=\"onSearch()\">\n          <i prefix class=\"ri-search-line\"></i>\n        </tolle-input>\n      </div>\n\n      <div class=\"rounded-md border border-border bg-background overflow-hidden shadow-sm\">\n        <table class=\"w-full text-sm\">\n          <thead class=\"border-b bg-muted/30\">\n            <tr>\n              <th *ngIf=\"expandable\" [class]=\"cn('px-4', size === 'xs' ? 'w-[32px]' : 'w-[48px]')\"></th>\n              <th *ngFor=\"let col of columns\"\n                  [class]=\"cn(\n                  'font-medium text-muted-foreground transition-all',\n                  headerPaddingClass,\n                  fontSizeClass,\n                  col.class\n                )\">\n                <div *ngIf=\"col.sortable; else simpleHeader\" (click)=\"toggleSort(col.key)\" class=\"flex items-center gap-1 cursor-pointer hover:text-foreground\">\n                  {{ col.label }}\n                  <i [class]=\"getSortIcon(col.key)\"></i>\n                </div>\n                <ng-template #simpleHeader>{{ col.label }}</ng-template>\n              </th>\n            </tr>\n          </thead>\n          <tbody class=\"divide-y divide-border\">\n            <ng-container *ngFor=\"let row of pagedData; let i = index\">\n              <tr class=\"hover:bg-muted/50 transition-colors\">\n                <td *ngIf=\"expandable\" class=\"px-4\">\n                  <button (click)=\"toggleRow(i)\"\n                          [class]=\"cn(\n                      'flex items-center justify-center rounded-md hover:bg-accent text-muted-foreground hover:text-foreground',\n                      size === 'xs' ? 'h-6 w-6' : 'h-8 w-8'\n                    )\">\n                    <i [class]=\"expandedRows.has(i) ? 'ri-arrow-down-s-line' : 'ri-arrow-right-s-line'\"></i>\n                  </button>\n                </td>\n\n                <td *ngFor=\"let col of columns\"\n                    [class]=\"cn(\n                    'align-middle transition-all',\n                    cellPaddingClass,\n                    fontSizeClass,\n                    col.class\n                  )\">\n                  <ng-container *ngIf=\"getTemplate(col.key) as cell; else defaultValue\">\n                    <ng-container *ngTemplateOutlet=\"cell.template; context: { $implicit: row[col.key], row: row }\"></ng-container>\n                  </ng-container>\n                  <ng-template #defaultValue>\n                    <span class=\"text-foreground\">{{ row[col.key] }}</span>\n                  </ng-template>\n                </td>\n              </tr>\n\n              <tr *ngIf=\"expandedRows.has(i)\" class=\"bg-muted/10\">\n                <td [attr.colspan]=\"columns.length + (expandable ? 1 : 0)\" class=\"p-0\">\n                   <div class=\"p-6 border-b border-dashed border-border\">\n                      <ng-container *ngIf=\"expandedTemplate; else defaultExpanded\">\n                        <ng-container *ngTemplateOutlet=\"expandedTemplate; context: { row: row }\"></ng-container>\n                      </ng-container>\n                      <ng-template #defaultExpanded>\n                        <div class=\"text-xs text-muted-foreground italic\">No details available.</div>\n                      </ng-template>\n                   </div>\n                </td>\n              </tr>\n            </ng-container>\n          </tbody>\n        </table>\n      </div>\n\n      <tolle-pagination\n        *ngIf=\"paginate\"\n        [totalRecords]=\"filteredData.length\"\n        [currentPage]=\"currentPage\"\n        [currentPageSize]=\"pageSize\"\n        (onPageNumberChange)=\"updatePage()\"\n        (onPageSizeChange)=\"updatePage()\"\n      ></tolle-pagination>\n    </div>\n  `\n})\nexport class DataTableComponent implements OnInit, OnChanges {\n  @Input() data: any[] = [];\n  @Input() columns: TableColumn[] = [];\n  @Input() searchable = true;\n  @Input() paginate = true;\n  @Input() pageSize = 10;\n  @Input() expandable = false;\n  @Input() size: 'xs' | 'sm' | 'default' | 'lg' = 'default';\n  // Track which rows are open\n  expandedRows = new Set<number>();\n\n  // Use ContentChildren to grab the tolleCell templates from the user's HTML\n  @ContentChildren(TolleCellDirective) cellTemplates!: QueryList<TolleCellDirective>;\n\n  // Keep this as an Input for the main expansion slot\n  @Input() expandedTemplate?: TemplateRef<any>;\n\n  filteredData: any[] = [];\n  pagedData: any[] = [];\n  searchTerm = '';\n  currentPage = 1;\n  sortKey = '';\n  sortDir: 'asc' | 'desc' | null = null;\n\n  // 2. Map Size to Padding for Cells\n  get cellPaddingClass(): string {\n    switch (this.size) {\n      case 'xs': return 'p-1 px-4';    // Ultra-compact\n      case 'sm': return 'p-2 px-4';    // Dense\n      case 'lg': return 'p-6 px-4';    // Spacious\n      default:   return 'p-4';         // Standard (16px)\n    }\n  }\n\n  // 3. Map Size to Padding for Header (usually slightly shorter than cells)\n  get headerPaddingClass(): string {\n    switch (this.size) {\n      case 'xs': return 'h-7 px-4';\n      case 'sm': return 'h-9 px-4';\n      case 'lg': return 'h-14 px-4';\n      default:   return 'h-12 px-4';\n    }\n  }\n\n  // 4. Map Size to Font Sizes\n  get fontSizeClass(): string {\n    switch (this.size) {\n      case 'xs': return 'text-[11px]';\n      case 'sm': return 'text-xs';\n      case 'lg': return 'text-base';\n      default:   return 'text-sm';\n    }\n  }\n\n  protected cn = cn;\n\n  ngOnInit() { this.refreshTable(); }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['data']) { this.refreshTable(); }\n  }\n\n  // --- Search & Sort & Page Logic ---\n  // (Your existing implementation of applySearch, applySort, and updatePage goes here)\n  refreshTable() { this.applySearch(); this.applySort(); this.updatePage(); }\n  onSearch() { this.currentPage = 1; this.refreshTable(); }\n\n  private applySearch() {\n    if (!this.searchTerm) { this.filteredData = [...this.data]; return; }\n    const q = this.searchTerm.toLowerCase();\n    this.filteredData = this.data.filter(row =>\n      Object.values(row).some(val => String(val).toLowerCase().includes(q))\n    );\n  }\n\n  private applySort() {\n    if (!this.sortKey || !this.sortDir) return;\n    this.filteredData.sort((a, b) => {\n      const valA = a[this.sortKey]; const valB = b[this.sortKey];\n      if (valA < valB) return this.sortDir === 'asc' ? -1 : 1;\n      if (valA > valB) return this.sortDir === 'asc' ? 1 : -1;\n      return 0;\n    });\n  }\n\n  updatePage() {\n    if (!this.paginate) { this.pagedData = this.filteredData; return; }\n    const start = (this.currentPage - 1) * this.pageSize;\n    const end = start + this.pageSize;\n    this.pagedData = this.filteredData.slice(start, end);\n  }\n\n  // --- Helpers ---\n  toggleSort(key: string) {\n    if (this.sortKey === key) {\n      this.sortDir = this.sortDir === 'asc' ? 'desc' : this.sortDir === 'desc' ? null : 'asc';\n    } else { this.sortKey = key; this.sortDir = 'asc'; }\n    this.refreshTable();\n  }\n\n  getSortIcon(key: string) {\n    if (this.sortKey !== key || !this.sortDir) return 'ri-arrow-up-down-line opacity-30';\n    return this.sortDir === 'asc' ? 'ri-arrow-up-line' : 'ri-arrow-down-line';\n  }\n\n  toggleRow(index: number) {\n    if (this.expandedRows.has(index)) this.expandedRows.delete(index);\n    else this.expandedRows.add(index);\n  }\n\n  // Helper to find the right cell template\n  getTemplate(key: string): TolleCellDirective | undefined {\n    return this.cellTemplates?.find(t => t.name === key);\n  }\n}\n"]}

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

@@ -0,0 +1,232 @@
+import { Component, Input, forwardRef, ViewChild, HostListener } 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 { format, parse, isValid, startOfDay } from 'date-fns';
+import { cn } from './utils/cn';
+import { MaskedInputComponent } from './masked-input.component';
+import { CalendarComponent } from './calendar.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class DatePickerComponent {
+    cdr;
+    placeholder = 'MM/DD/YYYY';
+    disabled = false;
+    class = '';
+    disablePastDates = false;
+    triggerContainer;
+    popover;
+    value = null;
+    inputValue = '';
+    isOpen = false;
+    cleanupAutoUpdate;
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    // --- Logic ---
+    onInputChange(str) {
+        if (str?.length === 10) {
+            const parsed = parse(str, 'MM/dd/yyyy', new Date());
+            if (isValid(parsed)) {
+                this.value = startOfDay(parsed);
+                this.onChange(this.value);
+            }
+        }
+        else if (!str) {
+            this.value = null;
+            this.onChange(null);
+        }
+    }
+    onCalendarChange(date) {
+        this.value = date;
+        this.inputValue = format(date, 'MM/dd/yyyy');
+        this.onChange(this.value);
+        this.close();
+    }
+    togglePopover(event) {
+        event.stopPropagation(); // Prevent bubbling to document
+        if (this.disabled)
+            return;
+        this.isOpen ? this.close() : this.open();
+    }
+    open() {
+        this.isOpen = true;
+        setTimeout(() => this.updatePosition());
+    }
+    close() {
+        this.isOpen = false;
+        if (this.cleanupAutoUpdate)
+            this.cleanupAutoUpdate();
+    }
+    clear(event) {
+        event.stopPropagation(); // CRITICAL: Stop the calendar from opening
+        this.value = null;
+        this.inputValue = '';
+        this.onChange(null);
+        this.cdr.markForCheck();
+    }
+    // --- Positioning ---
+    updatePosition() {
+        if (!this.triggerContainer || !this.popover)
+            return;
+        this.cleanupAutoUpdate = autoUpdate(this.triggerContainer.nativeElement, this.popover.nativeElement, () => {
+            computePosition(this.triggerContainer.nativeElement, this.popover.nativeElement, {
+                placement: 'bottom-end', // Aligned to the right where the icon is
+                middleware: [offset(4), flip(), shift({ padding: 8 })],
+            }).then(({ x, y }) => {
+                Object.assign(this.popover.nativeElement.style, {
+                    left: `${x}px`,
+                    top: `${y}px`,
+                    visibility: 'visible',
+                });
+            });
+        });
+    }
+    onClickOutside(event) {
+        if (this.isOpen &&
+            !this.triggerContainer.nativeElement.contains(event.target) &&
+            !this.popover.nativeElement.contains(event.target)) {
+            this.close();
+        }
+    }
+    // --- CVA ---
+    onChange = () => { };
+    onTouched = () => { };
+    writeValue(val) {
+        if (val) {
+            const date = new Date(val);
+            if (isValid(date)) {
+                this.value = startOfDay(date);
+                this.inputValue = format(this.value, 'MM/dd/yyyy');
+            }
+        }
+        else {
+            this.value = null;
+            this.inputValue = '';
+        }
+        this.cdr.markForCheck();
+    }
+    registerOnChange(fn) { this.onChange = fn; }
+    registerOnTouched(fn) { this.onTouched = fn; }
+    setDisabledState(isDisabled) { this.disabled = isDisabled; }
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatePickerComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DatePickerComponent, isStandalone: true, selector: "tolle-date-picker", inputs: { placeholder: "placeholder", disabled: "disabled", class: "class", disablePastDates: "disablePastDates" }, host: { listeners: { "document:mousedown": "onClickOutside($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => DatePickerComponent),
+                multi: true
+            }
+        ], viewQueries: [{ propertyName: "triggerContainer", first: true, predicate: ["triggerContainer"], descendants: true }, { propertyName: "popover", first: true, predicate: ["popover"], descendants: true }], ngImport: i0, template: `
+    <div class="relative w-full" #triggerContainer>
+      <tolle-masked-input
+        #maskInput
+        [mask]="'00/00/0000'"
+        [placeholder]="placeholder"
+        [disabled]="disabled"
+        [(ngModel)]="inputValue"
+        (ngModelChange)="onInputChange($event)"
+        [class]="cn(class)"
+      >
+        <div suffix class="flex items-center gap-1.5 cursor-pointer">
+          <i
+            *ngIf="value && !disabled"
+            (click)="clear($event)"
+            class="ri-close-line cursor-pointer text-muted-foreground hover:text-foreground transition-colors"
+          ></i>
+
+          <i
+            (click)="togglePopover($event)"
+            class="ri-calendar-line cursor-pointer text-muted-foreground hover:text-primary transition-colors"
+          ></i>
+        </div>
+      </tolle-masked-input>
+
+      <div
+        #popover
+        *ngIf="isOpen"
+        class="absolute bg-popover z-50 max-w-max left-0 right-0 overflow-hidden rounded-md border border-border text-popover-foreground bg-background shadow-md"
+        style="visibility: hidden; top: 0; left: 0;"
+      >
+        <tolle-calendar
+          [(ngModel)]="value"
+          (ngModelChange)="onCalendarChange($event)"
+          [disablePastDates]="disablePastDates"
+        ></tolle-calendar>
+      </div>
+    </div>
+  `, isInline: true, 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: MaskedInputComponent, selector: "tolle-masked-input", inputs: ["mask", "placeholder", "type", "disabled", "class", "error", "size", "returnRaw"] }, { kind: "component", type: CalendarComponent, selector: "tolle-calendar", inputs: ["class", "disablePastDates"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatePickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-date-picker',
+                    standalone: true,
+                    imports: [CommonModule, FormsModule, MaskedInputComponent, CalendarComponent],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => DatePickerComponent),
+                            multi: true
+                        }
+                    ],
+                    template: `
+    <div class="relative w-full" #triggerContainer>
+      <tolle-masked-input
+        #maskInput
+        [mask]="'00/00/0000'"
+        [placeholder]="placeholder"
+        [disabled]="disabled"
+        [(ngModel)]="inputValue"
+        (ngModelChange)="onInputChange($event)"
+        [class]="cn(class)"
+      >
+        <div suffix class="flex items-center gap-1.5 cursor-pointer">
+          <i
+            *ngIf="value && !disabled"
+            (click)="clear($event)"
+            class="ri-close-line cursor-pointer text-muted-foreground hover:text-foreground transition-colors"
+          ></i>
+
+          <i
+            (click)="togglePopover($event)"
+            class="ri-calendar-line cursor-pointer text-muted-foreground hover:text-primary transition-colors"
+          ></i>
+        </div>
+      </tolle-masked-input>
+
+      <div
+        #popover
+        *ngIf="isOpen"
+        class="absolute bg-popover z-50 max-w-max left-0 right-0 overflow-hidden rounded-md border border-border text-popover-foreground bg-background shadow-md"
+        style="visibility: hidden; top: 0; left: 0;"
+      >
+        <tolle-calendar
+          [(ngModel)]="value"
+          (ngModelChange)="onCalendarChange($event)"
+          [disablePastDates]="disablePastDates"
+        ></tolle-calendar>
+      </div>
+    </div>
+  `
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], disablePastDates: [{
+                type: Input
+            }], triggerContainer: [{
+                type: ViewChild,
+                args: ['triggerContainer']
+            }], popover: [{
+                type: ViewChild,
+                args: ['popover']
+            }], onClickOutside: [{
+                type: HostListener,
+                args: ['document:mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-picker.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/date-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component, Input, forwardRef, ElementRef, ViewChild, HostListener, ChangeDetectorRef\n} 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 { format, parse, isValid, startOfDay } from 'date-fns';\nimport { cn } from './utils/cn';\nimport { MaskedInputComponent } from './masked-input.component';\nimport { CalendarComponent } from './calendar.component';\n\n@Component({\n  selector: 'tolle-date-picker',\n  standalone: true,\n  imports: [CommonModule, FormsModule, MaskedInputComponent, CalendarComponent],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => DatePickerComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <div class=\"relative w-full\" #triggerContainer>\n      <tolle-masked-input\n        #maskInput\n        [mask]=\"'00/00/0000'\"\n        [placeholder]=\"placeholder\"\n        [disabled]=\"disabled\"\n        [(ngModel)]=\"inputValue\"\n        (ngModelChange)=\"onInputChange($event)\"\n        [class]=\"cn(class)\"\n      >\n        <div suffix class=\"flex items-center gap-1.5 cursor-pointer\">\n          <i\n            *ngIf=\"value && !disabled\"\n            (click)=\"clear($event)\"\n            class=\"ri-close-line cursor-pointer text-muted-foreground hover:text-foreground transition-colors\"\n          ></i>\n\n          <i\n            (click)=\"togglePopover($event)\"\n            class=\"ri-calendar-line cursor-pointer text-muted-foreground hover:text-primary transition-colors\"\n          ></i>\n        </div>\n      </tolle-masked-input>\n\n      <div\n        #popover\n        *ngIf=\"isOpen\"\n        class=\"absolute bg-popover z-50 max-w-max left-0 right-0 overflow-hidden rounded-md border border-border text-popover-foreground bg-background shadow-md\"\n        style=\"visibility: hidden; top: 0; left: 0;\"\n      >\n        <tolle-calendar\n          [(ngModel)]=\"value\"\n          (ngModelChange)=\"onCalendarChange($event)\"\n          [disablePastDates]=\"disablePastDates\"\n        ></tolle-calendar>\n      </div>\n    </div>\n  `\n})\nexport class DatePickerComponent implements ControlValueAccessor {\n  @Input() placeholder = 'MM/DD/YYYY';\n  @Input() disabled = false;\n  @Input() class = '';\n  @Input() disablePastDates = false;\n\n  @ViewChild('triggerContainer') triggerContainer!: ElementRef;\n  @ViewChild('popover') popover!: ElementRef;\n\n  value: Date | null = null;\n  inputValue: string = '';\n  isOpen = false;\n  cleanupAutoUpdate?: () => void;\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  // --- Logic ---\n\n  onInputChange(str: string) {\n    if (str?.length === 10) {\n      const parsed = parse(str, 'MM/dd/yyyy', new Date());\n      if (isValid(parsed)) {\n        this.value = startOfDay(parsed);\n        this.onChange(this.value);\n      }\n    } else if (!str) {\n      this.value = null;\n      this.onChange(null);\n    }\n  }\n\n  onCalendarChange(date: Date) {\n    this.value = date;\n    this.inputValue = format(date, 'MM/dd/yyyy');\n    this.onChange(this.value);\n    this.close();\n  }\n\n  togglePopover(event: MouseEvent) {\n    event.stopPropagation(); // Prevent bubbling to document\n    if (this.disabled) return;\n    this.isOpen ? this.close() : this.open();\n  }\n\n  open() {\n    this.isOpen = true;\n    setTimeout(() => this.updatePosition());\n  }\n\n  close() {\n    this.isOpen = false;\n    if (this.cleanupAutoUpdate) this.cleanupAutoUpdate();\n  }\n\n  clear(event: MouseEvent) {\n    event.stopPropagation(); // CRITICAL: Stop the calendar from opening\n    this.value = null;\n    this.inputValue = '';\n    this.onChange(null);\n    this.cdr.markForCheck();\n  }\n\n  // --- Positioning ---\n\n  private updatePosition() {\n    if (!this.triggerContainer || !this.popover) return;\n\n    this.cleanupAutoUpdate = autoUpdate(\n      this.triggerContainer.nativeElement,\n      this.popover.nativeElement,\n      () => {\n        computePosition(this.triggerContainer.nativeElement, this.popover.nativeElement, {\n          placement: 'bottom-end', // Aligned to the right where the icon is\n          middleware: [offset(4), flip(), shift({ padding: 8 })],\n        }).then(({ x, y }) => {\n          Object.assign(this.popover.nativeElement.style, {\n            left: `${x}px`,\n            top: `${y}px`,\n            visibility: 'visible',\n          });\n        });\n      }\n    );\n  }\n\n  @HostListener('document:mousedown', ['$event'])\n  onClickOutside(event: MouseEvent) {\n    if (this.isOpen &&\n      !this.triggerContainer.nativeElement.contains(event.target) &&\n      !this.popover.nativeElement.contains(event.target)) {\n      this.close();\n    }\n  }\n\n  // --- CVA ---\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  writeValue(val: any): void {\n    if (val) {\n      const date = new Date(val);\n      if (isValid(date)) {\n        this.value = startOfDay(date);\n        this.inputValue = format(this.value, 'MM/dd/yyyy');\n      }\n    } else {\n      this.value = null;\n      this.inputValue = '';\n    }\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n  setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; }\n  protected cn = cn;\n}\n"]}