@tolle_/tolle-ui 0.0.1-beta

package/esm2022/lib/pagination.component.mjs

@@ -0,0 +1,279 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, inject, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import { SelectItemComponent, SelectComponent } from '@tolle/ui';
+import { FormsModule } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class PaginationComponent {
+    class = '';
+    showPageLinks = true;
+    showPageOptions = true;
+    showCurrentPageInfo = true;
+    currentPageInfoTemplate;
+    totalRecords = 0;
+    currentPageSize = 10;
+    currentPage = 1;
+    pageSizeOptions = [10, 20, 30, 50];
+    onPageNumberChange = new EventEmitter();
+    onPageSizeChange = new EventEmitter();
+    totalPages = 0;
+    first = 0;
+    last = 0;
+    displayPageIndex = [];
+    pageReport = '';
+    initialized = false;
+    cd = inject(ChangeDetectorRef);
+    cn = cn;
+    navBtnClass = 'h-8 w-8 p-0 flex items-center justify-center rounded-md border border-input bg-background hover:bg-accent hover:text-accent-foreground disabled:opacity-50 disabled:cursor-not-allowed';
+    ngOnInit() {
+        this.initializePagination();
+    }
+    ngOnChanges(changes) {
+        // Only re-init if meaningful data changes
+        if (changes['totalRecords'] || changes['currentPage'] || changes['currentPageSize']) {
+            this.initializePagination();
+        }
+    }
+    initializePagination() {
+        this.calcPagination();
+        if (!this.initialized) {
+            this.initialized = true;
+        }
+        this.cd.detectChanges();
+    }
+    nextPage() {
+        if (this.totalPages > this.currentPage) {
+            this.currentPage++;
+            this.emitChange();
+        }
+    }
+    previousPage() {
+        if (this.currentPage > 1) {
+            this.currentPage--;
+            this.emitChange();
+        }
+    }
+    selectPage(page) {
+        if (this.currentPage === page)
+            return;
+        this.currentPage = page;
+        this.emitChange();
+    }
+    sizeChange(size) {
+        this.currentPageSize = size;
+        this.currentPage = 1; // Reset to page 1 on size change
+        this.emitChange();
+    }
+    emitChange() {
+        this.calcPagination();
+        this.onPageNumberChange.emit(this.currentPage);
+        this.onPageSizeChange.emit(this.currentPageSize);
+        this.cd.detectChanges();
+    }
+    calcPagination() {
+        this.totalPages = Math.ceil(this.totalRecords / this.currentPageSize) || 0;
+        // Bounds check
+        if (this.currentPage > this.totalPages && this.totalPages > 0) {
+            this.currentPage = this.totalPages;
+        }
+        this.first = this.totalRecords === 0 ? 0 : (this.currentPage - 1) * this.currentPageSize + 1;
+        this.last = Math.min(this.totalRecords, this.currentPage * this.currentPageSize);
+        // Calculate Sliding Window for Page Numbers (Max 5 visible)
+        const pages = Array.from({ length: this.totalPages }, (_, i) => i + 1);
+        if (this.totalPages <= 5) {
+            this.displayPageIndex = pages;
+        }
+        else {
+            let start = Math.max(0, this.currentPage - 3);
+            let end = start + 5;
+            if (end > this.totalPages) {
+                end = this.totalPages;
+                start = end - 5;
+            }
+            this.displayPageIndex = pages.slice(start, end);
+        }
+        // Template Parsing
+        if (this.currentPageInfoTemplate) {
+            this.pageReport = this.currentPageInfoTemplate.replace(/{first}|{last}|{totalRecords}|{currentPage}|{currentPageSize}|{totalPages}/g, (match) => {
+                switch (match) {
+                    case '{first}': return `${this.first}`;
+                    case '{last}': return `${this.last}`;
+                    case '{totalRecords}': return `${this.totalRecords}`;
+                    case '{totalPages}': return `${this.totalPages}`;
+                    case '{currentPage}': return `${this.currentPage}`;
+                    case '{currentPageSize}': return `${this.currentPageSize}`;
+                    default: return match;
+                }
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PaginationComponent, isStandalone: true, selector: "tolle-pagination", inputs: { class: "class", showPageLinks: "showPageLinks", showPageOptions: "showPageOptions", showCurrentPageInfo: "showCurrentPageInfo", currentPageInfoTemplate: "currentPageInfoTemplate", totalRecords: "totalRecords", currentPageSize: "currentPageSize", currentPage: "currentPage", pageSizeOptions: "pageSizeOptions" }, outputs: { onPageNumberChange: "onPageNumberChange", onPageSizeChange: "onPageSizeChange" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="cn('flex items-center justify-between px-2 py-4', class)">
+
+      <div *ngIf="showCurrentPageInfo" class="text-sm text-muted-foreground">
+        <ng-container *ngIf="currentPageInfoTemplate; else defaultReport">
+          {{ pageReport }}
+        </ng-container>
+        <ng-template #defaultReport>
+          Showing {{ first }} to {{ last }} of {{ totalRecords }} entries
+        </ng-template>
+      </div>
+
+      <div class="flex items-center space-x-6 lg:space-x-8">
+
+        <div *ngIf="showPageOptions" class="flex items-center space-x-2">
+          <p class="text-sm font-medium">Rows per page</p>
+          <tolle-select
+            class="w-[70px]"
+            size="sm"
+            [ngModel]="currentPageSize"
+            (ngModelChange)="sizeChange($event)"
+          >
+            <tolle-select-item *ngFor="let opt of pageSizeOptions" [value]="opt">
+              {{ opt }}
+            </tolle-select-item>
+          </tolle-select>
+        </div>
+
+        <div class="flex items-center space-x-2">
+          <div *ngIf="!showPageLinks" class="flex w-[100px] items-center justify-center text-sm font-medium">
+            Page {{ currentPage }} of {{ totalPages }}
+          </div>
+
+          <div *ngIf="showPageLinks" class="flex items-center space-x-1">
+            <button
+              (click)="previousPage()"
+              [disabled]="currentPage === 1"
+              [class]="navBtnClass"
+            >
+              <i class="ri-arrow-left-s-line"></i>
+            </button>
+
+            <button
+              *ngFor="let page of displayPageIndex"
+              (click)="selectPage(page)"
+              [class]="cn(
+                'h-8 w-8 text-sm rounded-md flex items-center justify-center transition-colors',
+                currentPage === page
+                  ? 'bg-primary text-primary-foreground font-medium'
+                  : 'hover:bg-accent hover:text-accent-foreground'
+              )"
+            >
+              {{ page }}
+            </button>
+
+            <button
+              (click)="nextPage()"
+              [disabled]="currentPage === totalPages || totalPages === 0"
+              [class]="navBtnClass"
+            >
+              <i class="ri-arrow-right-s-line"></i>
+            </button>
+          </div>
+        </div>
+      </div>
+    </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: "component", type: SelectComponent, selector: "tolle-select", inputs: ["placeholder", "class", "disabled", "searchable", "size"] }, { kind: "component", type: SelectItemComponent, selector: "tolle-select-item", inputs: ["value", "class", "selected"] }, { 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"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginationComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-pagination',
+                    standalone: true,
+                    imports: [CommonModule, SelectComponent, SelectItemComponent, FormsModule],
+                    template: `
+    <div [class]="cn('flex items-center justify-between px-2 py-4', class)">
+
+      <div *ngIf="showCurrentPageInfo" class="text-sm text-muted-foreground">
+        <ng-container *ngIf="currentPageInfoTemplate; else defaultReport">
+          {{ pageReport }}
+        </ng-container>
+        <ng-template #defaultReport>
+          Showing {{ first }} to {{ last }} of {{ totalRecords }} entries
+        </ng-template>
+      </div>
+
+      <div class="flex items-center space-x-6 lg:space-x-8">
+
+        <div *ngIf="showPageOptions" class="flex items-center space-x-2">
+          <p class="text-sm font-medium">Rows per page</p>
+          <tolle-select
+            class="w-[70px]"
+            size="sm"
+            [ngModel]="currentPageSize"
+            (ngModelChange)="sizeChange($event)"
+          >
+            <tolle-select-item *ngFor="let opt of pageSizeOptions" [value]="opt">
+              {{ opt }}
+            </tolle-select-item>
+          </tolle-select>
+        </div>
+
+        <div class="flex items-center space-x-2">
+          <div *ngIf="!showPageLinks" class="flex w-[100px] items-center justify-center text-sm font-medium">
+            Page {{ currentPage }} of {{ totalPages }}
+          </div>
+
+          <div *ngIf="showPageLinks" class="flex items-center space-x-1">
+            <button
+              (click)="previousPage()"
+              [disabled]="currentPage === 1"
+              [class]="navBtnClass"
+            >
+              <i class="ri-arrow-left-s-line"></i>
+            </button>
+
+            <button
+              *ngFor="let page of displayPageIndex"
+              (click)="selectPage(page)"
+              [class]="cn(
+                'h-8 w-8 text-sm rounded-md flex items-center justify-center transition-colors',
+                currentPage === page
+                  ? 'bg-primary text-primary-foreground font-medium'
+                  : 'hover:bg-accent hover:text-accent-foreground'
+              )"
+            >
+              {{ page }}
+            </button>
+
+            <button
+              (click)="nextPage()"
+              [disabled]="currentPage === totalPages || totalPages === 0"
+              [class]="navBtnClass"
+            >
+              <i class="ri-arrow-right-s-line"></i>
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }], showPageLinks: [{
+                type: Input
+            }], showPageOptions: [{
+                type: Input
+            }], showCurrentPageInfo: [{
+                type: Input
+            }], currentPageInfoTemplate: [{
+                type: Input
+            }], totalRecords: [{
+                type: Input
+            }], currentPageSize: [{
+                type: Input
+            }], currentPage: [{
+                type: Input
+            }], pageSizeOptions: [{
+                type: Input
+            }], onPageNumberChange: [{
+                type: Output
+            }], onPageSizeChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/pagination.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  inject,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cn } from './utils/cn';\nimport {SelectItemComponent, SelectComponent} from '@tolle/ui';\nimport {FormsModule} from '@angular/forms';\n\n@Component({\n  selector: 'tolle-pagination',\n  standalone: true,\n  imports: [CommonModule, SelectComponent, SelectItemComponent, FormsModule],\n  template: `\n    <div [class]=\"cn('flex items-center justify-between px-2 py-4', class)\">\n\n      <div *ngIf=\"showCurrentPageInfo\" class=\"text-sm text-muted-foreground\">\n        <ng-container *ngIf=\"currentPageInfoTemplate; else defaultReport\">\n          {{ pageReport }}\n        </ng-container>\n        <ng-template #defaultReport>\n          Showing {{ first }} to {{ last }} of {{ totalRecords }} entries\n        </ng-template>\n      </div>\n\n      <div class=\"flex items-center space-x-6 lg:space-x-8\">\n\n        <div *ngIf=\"showPageOptions\" class=\"flex items-center space-x-2\">\n          <p class=\"text-sm font-medium\">Rows per page</p>\n          <tolle-select\n            class=\"w-[70px]\"\n            size=\"sm\"\n            [ngModel]=\"currentPageSize\"\n            (ngModelChange)=\"sizeChange($event)\"\n          >\n            <tolle-select-item *ngFor=\"let opt of pageSizeOptions\" [value]=\"opt\">\n              {{ opt }}\n            </tolle-select-item>\n          </tolle-select>\n        </div>\n\n        <div class=\"flex items-center space-x-2\">\n          <div *ngIf=\"!showPageLinks\" class=\"flex w-[100px] items-center justify-center text-sm font-medium\">\n            Page {{ currentPage }} of {{ totalPages }}\n          </div>\n\n          <div *ngIf=\"showPageLinks\" class=\"flex items-center space-x-1\">\n            <button\n              (click)=\"previousPage()\"\n              [disabled]=\"currentPage === 1\"\n              [class]=\"navBtnClass\"\n            >\n              <i class=\"ri-arrow-left-s-line\"></i>\n            </button>\n\n            <button\n              *ngFor=\"let page of displayPageIndex\"\n              (click)=\"selectPage(page)\"\n              [class]=\"cn(\n                'h-8 w-8 text-sm rounded-md flex items-center justify-center transition-colors',\n                currentPage === page\n                  ? 'bg-primary text-primary-foreground font-medium'\n                  : 'hover:bg-accent hover:text-accent-foreground'\n              )\"\n            >\n              {{ page }}\n            </button>\n\n            <button\n              (click)=\"nextPage()\"\n              [disabled]=\"currentPage === totalPages || totalPages === 0\"\n              [class]=\"navBtnClass\"\n            >\n              <i class=\"ri-arrow-right-s-line\"></i>\n            </button>\n          </div>\n        </div>\n      </div>\n    </div>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PaginationComponent implements OnInit, OnChanges {\n  @Input() class = '';\n  @Input() showPageLinks = true;\n  @Input() showPageOptions = true;\n  @Input() showCurrentPageInfo = true;\n  @Input() currentPageInfoTemplate?: string;\n\n  @Input() totalRecords = 0;\n  @Input() currentPageSize = 10;\n  @Input() currentPage = 1;\n  @Input() pageSizeOptions: number[] = [10, 20, 30, 50];\n\n  @Output() onPageNumberChange = new EventEmitter<number>();\n  @Output() onPageSizeChange = new EventEmitter<number>();\n\n  totalPages = 0;\n  first = 0;\n  last = 0;\n  displayPageIndex: number[] = [];\n  pageReport = '';\n\n  private initialized = false;\n  private cd = inject(ChangeDetectorRef);\n  protected cn = cn;\n\n  navBtnClass = 'h-8 w-8 p-0 flex items-center justify-center rounded-md border border-input bg-background hover:bg-accent hover:text-accent-foreground disabled:opacity-50 disabled:cursor-not-allowed';\n\n  ngOnInit(): void {\n    this.initializePagination();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Only re-init if meaningful data changes\n    if (changes['totalRecords'] || changes['currentPage'] || changes['currentPageSize']) {\n      this.initializePagination();\n    }\n  }\n\n  private initializePagination(): void {\n    this.calcPagination();\n    if (!this.initialized) {\n      this.initialized = true;\n    }\n    this.cd.detectChanges();\n  }\n\n  nextPage() {\n    if (this.totalPages > this.currentPage) {\n      this.currentPage++;\n      this.emitChange();\n    }\n  }\n\n  previousPage() {\n    if (this.currentPage > 1) {\n      this.currentPage--;\n      this.emitChange();\n    }\n  }\n\n  selectPage(page: number) {\n    if (this.currentPage === page) return;\n    this.currentPage = page;\n    this.emitChange();\n  }\n\n  sizeChange(size: number) {\n    this.currentPageSize = size;\n    this.currentPage = 1; // Reset to page 1 on size change\n    this.emitChange();\n  }\n\n  private emitChange(): void {\n    this.calcPagination();\n    this.onPageNumberChange.emit(this.currentPage);\n    this.onPageSizeChange.emit(this.currentPageSize);\n    this.cd.detectChanges();\n  }\n\n  private calcPagination(): void {\n    this.totalPages = Math.ceil(this.totalRecords / this.currentPageSize) || 0;\n\n    // Bounds check\n    if (this.currentPage > this.totalPages && this.totalPages > 0) {\n      this.currentPage = this.totalPages;\n    }\n\n    this.first = this.totalRecords === 0 ? 0 : (this.currentPage - 1) * this.currentPageSize + 1;\n    this.last = Math.min(this.totalRecords, this.currentPage * this.currentPageSize);\n\n    // Calculate Sliding Window for Page Numbers (Max 5 visible)\n    const pages: number[] = Array.from({ length: this.totalPages }, (_, i) => i + 1);\n\n    if (this.totalPages <= 5) {\n      this.displayPageIndex = pages;\n    } else {\n      let start = Math.max(0, this.currentPage - 3);\n      let end = start + 5;\n\n      if (end > this.totalPages) {\n        end = this.totalPages;\n        start = end - 5;\n      }\n      this.displayPageIndex = pages.slice(start, end);\n    }\n\n    // Template Parsing\n    if (this.currentPageInfoTemplate) {\n      this.pageReport = this.currentPageInfoTemplate.replace(\n        /{first}|{last}|{totalRecords}|{currentPage}|{currentPageSize}|{totalPages}/g,\n        (match) => {\n          switch (match) {\n            case '{first}': return `${this.first}`;\n            case '{last}': return `${this.last}`;\n            case '{totalRecords}': return `${this.totalRecords}`;\n            case '{totalPages}': return `${this.totalPages}`;\n            case '{currentPage}': return `${this.currentPage}`;\n            case '{currentPageSize}': return `${this.currentPageSize}`;\n            default: return match;\n          }\n        }\n      );\n    }\n  }\n}\n"]}

package/esm2022/lib/range-calendar.component.mjs

@@ -0,0 +1,285 @@
+import { Component, Input, forwardRef, Output, EventEmitter } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { addMonths, subMonths, startOfMonth, endOfMonth, startOfWeek, endOfWeek, eachDayOfInterval, isSameMonth, isSameDay, isToday, setMonth, setYear, addYears, subYears, isBefore, startOfDay, isWithinInterval } from 'date-fns';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class RangeCalendarComponent {
+    class = '';
+    disablePastDates = false;
+    rangeSelect = new EventEmitter(); // Emits whenever selection changes
+    currentView = 'date';
+    viewDate = new Date();
+    // The Range Value
+    value = { start: null, end: null };
+    weekDays = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
+    daysInMonth = [];
+    months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    years = [];
+    navBtnClass = cn('h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100 border border-input rounded-md flex items-center justify-center hover:bg-accent hover:text-accent-foreground transition-all');
+    onTouched = () => { };
+    onChange = () => { };
+    cn = cn;
+    ngOnInit() {
+        this.generateDays();
+        this.generateYears();
+    }
+    // --- Date Generation Logic (Same as Calendar) ---
+    generateDays() {
+        const start = startOfWeek(startOfMonth(this.viewDate));
+        const end = endOfWeek(endOfMonth(this.viewDate));
+        this.daysInMonth = eachDayOfInterval({ start, end });
+    }
+    generateYears() {
+        const currentYear = this.viewDate.getFullYear();
+        this.years = Array.from({ length: 16 }, (_, i) => currentYear - 6 + i);
+    }
+    setView(view) {
+        this.currentView = view;
+        if (view === 'year')
+            this.generateYears();
+    }
+    prev() {
+        if (this.currentView === 'date') {
+            this.viewDate = subMonths(this.viewDate, 1);
+            this.generateDays();
+        }
+        else if (this.currentView === 'year') {
+            this.viewDate = subYears(this.viewDate, 16);
+            this.generateYears();
+        }
+        else if (this.currentView === 'month') {
+            this.viewDate = subYears(this.viewDate, 1);
+        }
+    }
+    next() {
+        if (this.currentView === 'date') {
+            this.viewDate = addMonths(this.viewDate, 1);
+            this.generateDays();
+        }
+        else if (this.currentView === 'year') {
+            this.viewDate = addYears(this.viewDate, 16);
+            this.generateYears();
+        }
+        else if (this.currentView === 'month') {
+            this.viewDate = addYears(this.viewDate, 1);
+        }
+    }
+    // --- Range Selection Logic ---
+    selectDate(date) {
+        if (this.isDateDisabled(date))
+            return;
+        const { start, end } = this.value;
+        // 1. If start exists but end doesn't
+        if (start && !end) {
+            if (isBefore(date, start)) {
+                // User clicked earlier date -> Reset start
+                this.value = { start: date, end: null };
+            }
+            else {
+                // User clicked later date -> Complete range
+                this.value = { start, end: date };
+            }
+        }
+        // 2. If neither exist OR both exist (reset)
+        else {
+            this.value = { start: date, end: null };
+        }
+        if (!isSameMonth(date, this.viewDate)) {
+            this.viewDate = date;
+            this.generateDays();
+        }
+        this.onChange(this.value);
+        this.rangeSelect.emit(this.value);
+        this.onTouched();
+    }
+    selectMonth(monthIndex) {
+        this.viewDate = setMonth(this.viewDate, monthIndex);
+        this.currentView = 'date';
+        this.generateDays();
+    }
+    selectYear(year) {
+        this.viewDate = setYear(this.viewDate, year);
+        this.currentView = 'date';
+        this.generateDays();
+    }
+    // --- Visual Styling for Range ---
+    getDayClass(date) {
+        const { start, end } = this.value;
+        const isOutside = !isSameMonth(date, this.viewDate);
+        const isDisabled = this.isDateDisabled(date);
+        // Range Checks
+        const isStart = start && isSameDay(date, start);
+        const isEnd = end && isSameDay(date, end);
+        const isInside = start && end && isWithinInterval(date, { start, end });
+        const isTodayDate = isToday(date);
+        return cn(
+        // Base: h-9 w-9, but we remove margins/rounding for the 'strip' effect
+        'h-9 w-9 p-0 font-normal text-sm transition-all flex items-center justify-center relative z-10', 
+        // Default State (Not selected, Not disabled)
+        !isInside && !isStart && !isEnd && !isDisabled && 'hover:bg-accent hover:text-accent-foreground rounded-md', 
+        // The "Caps": Start and End
+        (isStart || isEnd) && 'bg-primary text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground', 
+        // The "Strip": Dates between start and end
+        isInside && !isStart && !isEnd && 'bg-accent text-accent-foreground rounded-none', 
+        // Connecting the Caps to the Strip (Rectangular inside edges)
+        isStart && end && 'rounded-l-md rounded-r-none', isEnd && start && 'rounded-r-md rounded-l-none', 
+        // If no end date yet, Start should be fully rounded
+        isStart && !end && 'rounded-md', 
+        // Muted/Disabled logic
+        !isInside && isTodayDate && !isStart && !isEnd && 'bg-accent/50 text-accent-foreground rounded-md', (isOutside || isDisabled) && 'text-muted-foreground opacity-50', isDisabled && 'cursor-not-allowed');
+    }
+    isDateDisabled(date) {
+        return this.disablePastDates ? isBefore(date, startOfDay(new Date())) : false;
+    }
+    // --- CVA Implementation ---
+    writeValue(val) {
+        if (val) {
+            this.value = val;
+            if (val.start)
+                this.viewDate = val.start;
+            this.generateDays();
+            this.generateYears();
+        }
+    }
+    registerOnChange(fn) { this.onChange = fn; }
+    registerOnTouched(fn) { this.onTouched = fn; }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RangeCalendarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: RangeCalendarComponent, isStandalone: true, selector: "tolle-range-calendar", inputs: { class: "class", disablePastDates: "disablePastDates" }, outputs: { rangeSelect: "rangeSelect" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => RangeCalendarComponent),
+                multi: true
+            }
+        ], ngImport: i0, template: `
+    <div [class]="cn('p-3 border rounded-md bg-background text-popover-foreground shadow-sm inline-block min-w-fit', class)">
+
+      <div class="flex items-center justify-between pt-1 pb-4 gap-2">
+        <div class="flex items-center gap-1">
+          <button type="button" (click)="setView('month')"
+            [class]="cn('text-sm font-semibold px-2 py-1 rounded transition-colors', currentView === 'month' ? 'bg-secondary text-secondary-foreground' : 'hover:bg-accent hover:text-accent-foreground')">
+            {{ viewDate | date: 'MMMM' }}
+          </button>
+          <button type="button" (click)="setView('year')"
+            [class]="cn('text-sm font-semibold px-2 py-1 rounded transition-colors', currentView === 'year' ? 'bg-secondary text-secondary-foreground' : 'hover:bg-accent hover:text-accent-foreground')">
+            {{ viewDate | date: 'yyyy' }}
+          </button>
+        </div>
+        <div class="flex items-center space-x-1">
+          <button type="button" (click)="prev()" [class]="navBtnClass"><i class="ri-arrow-left-s-line text-lg"></i></button>
+          <button type="button" (click)="next()" [class]="navBtnClass"><i class="ri-arrow-right-s-line text-lg"></i></button>
+        </div>
+      </div>
+
+      <div *ngIf="currentView === 'date'" class="space-y-2 animate-in fade-in zoom-in-95 duration-200">
+        <div class="grid grid-cols-7 gap-y-1 w-full">
+          <span *ngFor="let day of weekDays" class="text-[0.8rem] text-muted-foreground font-normal text-center w-9">
+            {{ day }}
+          </span>
+        </div>
+        <div class="grid grid-cols-7 gap-y-1 w-full">
+          <button
+            *ngFor="let date of daysInMonth"
+            type="button"
+            (click)="selectDate(date)"
+            [disabled]="isDateDisabled(date)"
+            [class]="getDayClass(date)"
+          >
+            {{ date | date: 'd' }}
+          </button>
+        </div>
+      </div>
+
+      <div *ngIf="currentView === 'month'" class="grid grid-cols-3 gap-2 w-64 animate-in fade-in zoom-in-95 duration-200">
+        <button *ngFor="let month of months; let i = index" type="button" (click)="selectMonth(i)"
+          [class]="cn('text-sm py-2.5 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors', i === viewDate.getMonth() ? 'bg-primary text-primary-foreground' : '')">
+          {{ month }}
+        </button>
+      </div>
+
+      <div *ngIf="currentView === 'year'" class="grid grid-cols-4 gap-2 w-64 animate-in fade-in zoom-in-95 duration-200">
+        <button *ngFor="let year of years" type="button" (click)="selectYear(year)"
+          [class]="cn('text-sm py-2 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors', year === viewDate.getFullYear() ? 'bg-primary text-primary-foreground' : '')">
+          {{ year }}
+        </button>
+      </div>
+    </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: "pipe", type: i1.DatePipe, name: "date" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RangeCalendarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-range-calendar',
+                    standalone: true,
+                    imports: [CommonModule],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => RangeCalendarComponent),
+                            multi: true
+                        }
+                    ],
+                    template: `
+    <div [class]="cn('p-3 border rounded-md bg-background text-popover-foreground shadow-sm inline-block min-w-fit', class)">
+
+      <div class="flex items-center justify-between pt-1 pb-4 gap-2">
+        <div class="flex items-center gap-1">
+          <button type="button" (click)="setView('month')"
+            [class]="cn('text-sm font-semibold px-2 py-1 rounded transition-colors', currentView === 'month' ? 'bg-secondary text-secondary-foreground' : 'hover:bg-accent hover:text-accent-foreground')">
+            {{ viewDate | date: 'MMMM' }}
+          </button>
+          <button type="button" (click)="setView('year')"
+            [class]="cn('text-sm font-semibold px-2 py-1 rounded transition-colors', currentView === 'year' ? 'bg-secondary text-secondary-foreground' : 'hover:bg-accent hover:text-accent-foreground')">
+            {{ viewDate | date: 'yyyy' }}
+          </button>
+        </div>
+        <div class="flex items-center space-x-1">
+          <button type="button" (click)="prev()" [class]="navBtnClass"><i class="ri-arrow-left-s-line text-lg"></i></button>
+          <button type="button" (click)="next()" [class]="navBtnClass"><i class="ri-arrow-right-s-line text-lg"></i></button>
+        </div>
+      </div>
+
+      <div *ngIf="currentView === 'date'" class="space-y-2 animate-in fade-in zoom-in-95 duration-200">
+        <div class="grid grid-cols-7 gap-y-1 w-full">
+          <span *ngFor="let day of weekDays" class="text-[0.8rem] text-muted-foreground font-normal text-center w-9">
+            {{ day }}
+          </span>
+        </div>
+        <div class="grid grid-cols-7 gap-y-1 w-full">
+          <button
+            *ngFor="let date of daysInMonth"
+            type="button"
+            (click)="selectDate(date)"
+            [disabled]="isDateDisabled(date)"
+            [class]="getDayClass(date)"
+          >
+            {{ date | date: 'd' }}
+          </button>
+        </div>
+      </div>
+
+      <div *ngIf="currentView === 'month'" class="grid grid-cols-3 gap-2 w-64 animate-in fade-in zoom-in-95 duration-200">
+        <button *ngFor="let month of months; let i = index" type="button" (click)="selectMonth(i)"
+          [class]="cn('text-sm py-2.5 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors', i === viewDate.getMonth() ? 'bg-primary text-primary-foreground' : '')">
+          {{ month }}
+        </button>
+      </div>
+
+      <div *ngIf="currentView === 'year'" class="grid grid-cols-4 gap-2 w-64 animate-in fade-in zoom-in-95 duration-200">
+        <button *ngFor="let year of years" type="button" (click)="selectYear(year)"
+          [class]="cn('text-sm py-2 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors', year === viewDate.getFullYear() ? 'bg-primary text-primary-foreground' : '')">
+          {{ year }}
+        </button>
+      </div>
+    </div>
+  `
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }], disablePastDates: [{
+                type: Input
+            }], rangeSelect: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range-calendar.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/range-calendar.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, forwardRef, Output, EventEmitter } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport {\n  addMonths, subMonths, startOfMonth, endOfMonth,\n  startOfWeek, endOfWeek, eachDayOfInterval, isSameMonth,\n  isSameDay, isToday, setMonth, setYear, addYears, subYears,\n  isBefore, startOfDay, isWithinInterval, isAfter\n} from 'date-fns';\nimport { cn } from './utils/cn';\nimport {DateRange} from '@tolle/ui/types/date-range';\n\n@Component({\n  selector: 'tolle-range-calendar',\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => RangeCalendarComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <div [class]=\"cn('p-3 border rounded-md bg-background text-popover-foreground shadow-sm inline-block min-w-fit', class)\">\n\n      <div class=\"flex items-center justify-between pt-1 pb-4 gap-2\">\n        <div class=\"flex items-center gap-1\">\n          <button type=\"button\" (click)=\"setView('month')\"\n            [class]=\"cn('text-sm font-semibold px-2 py-1 rounded transition-colors', currentView === 'month' ? 'bg-secondary text-secondary-foreground' : 'hover:bg-accent hover:text-accent-foreground')\">\n            {{ viewDate | date: 'MMMM' }}\n          </button>\n          <button type=\"button\" (click)=\"setView('year')\"\n            [class]=\"cn('text-sm font-semibold px-2 py-1 rounded transition-colors', currentView === 'year' ? 'bg-secondary text-secondary-foreground' : 'hover:bg-accent hover:text-accent-foreground')\">\n            {{ viewDate | date: 'yyyy' }}\n          </button>\n        </div>\n        <div class=\"flex items-center space-x-1\">\n          <button type=\"button\" (click)=\"prev()\" [class]=\"navBtnClass\"><i class=\"ri-arrow-left-s-line text-lg\"></i></button>\n          <button type=\"button\" (click)=\"next()\" [class]=\"navBtnClass\"><i class=\"ri-arrow-right-s-line text-lg\"></i></button>\n        </div>\n      </div>\n\n      <div *ngIf=\"currentView === 'date'\" class=\"space-y-2 animate-in fade-in zoom-in-95 duration-200\">\n        <div class=\"grid grid-cols-7 gap-y-1 w-full\">\n          <span *ngFor=\"let day of weekDays\" class=\"text-[0.8rem] text-muted-foreground font-normal text-center w-9\">\n            {{ day }}\n          </span>\n        </div>\n        <div class=\"grid grid-cols-7 gap-y-1 w-full\">\n          <button\n            *ngFor=\"let date of daysInMonth\"\n            type=\"button\"\n            (click)=\"selectDate(date)\"\n            [disabled]=\"isDateDisabled(date)\"\n            [class]=\"getDayClass(date)\"\n          >\n            {{ date | date: 'd' }}\n          </button>\n        </div>\n      </div>\n\n      <div *ngIf=\"currentView === 'month'\" class=\"grid grid-cols-3 gap-2 w-64 animate-in fade-in zoom-in-95 duration-200\">\n        <button *ngFor=\"let month of months; let i = index\" type=\"button\" (click)=\"selectMonth(i)\"\n          [class]=\"cn('text-sm py-2.5 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors', i === viewDate.getMonth() ? 'bg-primary text-primary-foreground' : '')\">\n          {{ month }}\n        </button>\n      </div>\n\n      <div *ngIf=\"currentView === 'year'\" class=\"grid grid-cols-4 gap-2 w-64 animate-in fade-in zoom-in-95 duration-200\">\n        <button *ngFor=\"let year of years\" type=\"button\" (click)=\"selectYear(year)\"\n          [class]=\"cn('text-sm py-2 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors', year === viewDate.getFullYear() ? 'bg-primary text-primary-foreground' : '')\">\n          {{ year }}\n        </button>\n      </div>\n    </div>\n  `\n})\nexport class RangeCalendarComponent implements OnInit, ControlValueAccessor {\n  @Input() class = '';\n  @Input() disablePastDates = false;\n  @Output() rangeSelect = new EventEmitter<DateRange>(); // Emits whenever selection changes\n\n  currentView: 'date' | 'month' | 'year' = 'date';\n  viewDate: Date = new Date();\n\n  // The Range Value\n  value: DateRange = { start: null, end: null };\n\n  weekDays = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];\n  daysInMonth: Date[] = [];\n  months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n  years: number[] = [];\n\n  navBtnClass = cn('h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100 border border-input rounded-md flex items-center justify-center hover:bg-accent hover:text-accent-foreground transition-all');\n\n  onTouched: () => void = () => {};\n  onChange: (value: DateRange) => void = () => {};\n  protected cn = cn;\n\n  ngOnInit() {\n    this.generateDays();\n    this.generateYears();\n  }\n\n  // --- Date Generation Logic (Same as Calendar) ---\n  generateDays() {\n    const start = startOfWeek(startOfMonth(this.viewDate));\n    const end = endOfWeek(endOfMonth(this.viewDate));\n    this.daysInMonth = eachDayOfInterval({ start, end });\n  }\n\n  generateYears() {\n    const currentYear = this.viewDate.getFullYear();\n    this.years = Array.from({ length: 16 }, (_, i) => currentYear - 6 + i);\n  }\n\n  setView(view: 'date' | 'month' | 'year') {\n    this.currentView = view;\n    if (view === 'year') this.generateYears();\n  }\n\n  prev() {\n    if (this.currentView === 'date') {\n      this.viewDate = subMonths(this.viewDate, 1);\n      this.generateDays();\n    } else if (this.currentView === 'year') {\n      this.viewDate = subYears(this.viewDate, 16);\n      this.generateYears();\n    } else if (this.currentView === 'month') {\n      this.viewDate = subYears(this.viewDate, 1);\n    }\n  }\n\n  next() {\n    if (this.currentView === 'date') {\n      this.viewDate = addMonths(this.viewDate, 1);\n      this.generateDays();\n    } else if (this.currentView === 'year') {\n      this.viewDate = addYears(this.viewDate, 16);\n      this.generateYears();\n    } else if (this.currentView === 'month') {\n      this.viewDate = addYears(this.viewDate, 1);\n    }\n  }\n\n  // --- Range Selection Logic ---\n\n  selectDate(date: Date) {\n    if (this.isDateDisabled(date)) return;\n\n    const { start, end } = this.value;\n\n    // 1. If start exists but end doesn't\n    if (start && !end) {\n      if (isBefore(date, start)) {\n        // User clicked earlier date -> Reset start\n        this.value = { start: date, end: null };\n      } else {\n        // User clicked later date -> Complete range\n        this.value = { start, end: date };\n      }\n    }\n    // 2. If neither exist OR both exist (reset)\n    else {\n      this.value = { start: date, end: null };\n    }\n\n    if (!isSameMonth(date, this.viewDate)) {\n      this.viewDate = date;\n      this.generateDays();\n    }\n\n    this.onChange(this.value);\n    this.rangeSelect.emit(this.value);\n    this.onTouched();\n  }\n\n  selectMonth(monthIndex: number) {\n    this.viewDate = setMonth(this.viewDate, monthIndex);\n    this.currentView = 'date';\n    this.generateDays();\n  }\n\n  selectYear(year: number) {\n    this.viewDate = setYear(this.viewDate, year);\n    this.currentView = 'date';\n    this.generateDays();\n  }\n\n  // --- Visual Styling for Range ---\n\n  getDayClass(date: Date) {\n    const { start, end } = this.value;\n    const isOutside = !isSameMonth(date, this.viewDate);\n    const isDisabled = this.isDateDisabled(date);\n\n    // Range Checks\n    const isStart = start && isSameDay(date, start);\n    const isEnd = end && isSameDay(date, end);\n    const isInside = start && end && isWithinInterval(date, { start, end });\n    const isTodayDate = isToday(date);\n\n    return cn(\n      // Base: h-9 w-9, but we remove margins/rounding for the 'strip' effect\n      'h-9 w-9 p-0 font-normal text-sm transition-all flex items-center justify-center relative z-10',\n\n      // Default State (Not selected, Not disabled)\n      !isInside && !isStart && !isEnd && !isDisabled && 'hover:bg-accent hover:text-accent-foreground rounded-md',\n\n      // The \"Caps\": Start and End\n      (isStart || isEnd) && 'bg-primary text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground',\n\n      // The \"Strip\": Dates between start and end\n      isInside && !isStart && !isEnd && 'bg-accent text-accent-foreground rounded-none',\n\n      // Connecting the Caps to the Strip (Rectangular inside edges)\n      isStart && end && 'rounded-l-md rounded-r-none',\n      isEnd && start && 'rounded-r-md rounded-l-none',\n      // If no end date yet, Start should be fully rounded\n      isStart && !end && 'rounded-md',\n\n      // Muted/Disabled logic\n      !isInside && isTodayDate && !isStart && !isEnd && 'bg-accent/50 text-accent-foreground rounded-md',\n      (isOutside || isDisabled) && 'text-muted-foreground opacity-50',\n      isDisabled && 'cursor-not-allowed'\n    );\n  }\n\n  isDateDisabled(date: Date): boolean {\n    return this.disablePastDates ? isBefore(date, startOfDay(new Date())) : false;\n  }\n\n  // --- CVA Implementation ---\n  writeValue(val: DateRange | null): void {\n    if (val) {\n      this.value = val;\n      if (val.start) this.viewDate = val.start;\n      this.generateDays();\n      this.generateYears();\n    }\n  }\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n}\n"]}