@nuraly/lumenui 0.2.1 → 0.2.2

package/dist/src/components/timepicker/controllers/selection.controller.js

@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { TimeUtils } from '../utils/time.utils.js';
+import { TIME_PICKER_EVENTS } from '../timepicker.types.js';
+/**
+ * Controller for handling time selection logic
+ */
+export class TimePickerSelectionController {
+    constructor(host) {
+        this.host = host;
+        this.selectedTime = null;
+    }
+    /**
+     * Select a time value
+     */
+    selectTime(time) {
+        if (!this.host.validateTime(time)) {
+            return;
+        }
+        const previousTime = this.selectedTime;
+        this.selectedTime = Object.assign({}, time);
+        // Dispatch time change event
+        this.dispatchTimeChangeEvent(time, previousTime);
+        // Request host update
+        this.host.requestUpdate();
+    }
+    /**
+     * Get currently selected time
+     */
+    getSelectedTime() {
+        return this.selectedTime ? Object.assign({}, this.selectedTime) : null;
+    }
+    /**
+     * Clear current selection
+     */
+    clearSelection() {
+        const previousTime = this.selectedTime;
+        this.selectedTime = null;
+        if (previousTime) {
+            this.dispatchTimeChangeEvent(null, previousTime);
+            this.host.requestUpdate();
+        }
+    }
+    /**
+     * Check if a time is currently selected
+     */
+    isTimeSelected(time) {
+        if (!this.selectedTime) {
+            return false;
+        }
+        return TimeUtils.isTimeEqual(time, this.selectedTime);
+    }
+    /**
+     * Set time without triggering events (for internal use)
+     */
+    setTimeInternal(time) {
+        this.selectedTime = time ? Object.assign({}, time) : null;
+    }
+    /**
+     * Update selected time with partial values
+     */
+    updateTime(updates) {
+        if (!this.selectedTime) {
+            // Create new time with current time as base
+            const currentTime = TimeUtils.getCurrentTime();
+            this.selectedTime = Object.assign(Object.assign({}, currentTime), updates);
+        }
+        else {
+            // Update existing time
+            this.selectedTime = Object.assign(Object.assign({}, this.selectedTime), updates);
+        }
+        if (this.host.validateTime(this.selectedTime)) {
+            this.dispatchTimeChangeEvent(this.selectedTime, null);
+            this.host.requestUpdate();
+        }
+    }
+    /**
+     * Increment time component
+     */
+    incrementTime(component, step = 1) {
+        if (!this.selectedTime) {
+            this.selectedTime = TimeUtils.getCurrentTime();
+        }
+        let newTime;
+        switch (component) {
+            case 'hours':
+                newTime = TimeUtils.addTime(this.selectedTime, step, 0, 0);
+                break;
+            case 'minutes':
+                newTime = TimeUtils.addTime(this.selectedTime, 0, step, 0);
+                break;
+            case 'seconds':
+                newTime = TimeUtils.addTime(this.selectedTime, 0, 0, step);
+                break;
+            default:
+                return;
+        }
+        this.selectTime(newTime);
+    }
+    /**
+     * Decrement time component
+     */
+    decrementTime(component, step = 1) {
+        this.incrementTime(component, -step);
+    }
+    /**
+     * Set time from formatted string
+     */
+    setTimeFromString(timeString) {
+        const config = this.host.getConfig();
+        const parsedTime = TimeUtils.parseTimeString(timeString, config.format);
+        if (parsedTime && this.host.validateTime(parsedTime)) {
+            this.selectTime(parsedTime);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get formatted time string
+     */
+    getFormattedTime() {
+        if (!this.selectedTime) {
+            return '';
+        }
+        return this.host.formatTime(this.selectedTime);
+    }
+    /**
+     * Dispatch time change event
+     */
+    dispatchTimeChangeEvent(newTime, previousTime) {
+        const hostElement = this.host;
+        if (!hostElement.dispatchEvent) {
+            return;
+        }
+        const detail = {
+            value: newTime ? this.host.formatTime(newTime) : '',
+            timeValue: newTime,
+            previousValue: previousTime ? this.host.formatTime(previousTime) : '',
+            previousTimeValue: previousTime,
+        };
+        const event = new CustomEvent(TIME_PICKER_EVENTS.TIME_CHANGE, {
+            detail,
+            bubbles: true,
+            composed: true,
+        });
+        hostElement.dispatchEvent(event);
+    }
+    /**
+     * Reset to initial/default time
+     */
+    reset() {
+        this.clearSelection();
+    }
+    /**
+     * Set time to current time
+     */
+    setToCurrentTime() {
+        const currentTime = TimeUtils.getCurrentTime();
+        this.selectTime(currentTime);
+    }
+    /**
+     * Round current time to nearest interval
+     */
+    roundToInterval(intervalMinutes) {
+        if (!this.selectedTime) {
+            return;
+        }
+        const roundedTime = TimeUtils.roundToInterval(this.selectedTime, intervalMinutes);
+        this.selectTime(roundedTime);
+    }
+}
+//# sourceMappingURL=selection.controller.js.map

package/dist/src/components/timepicker/controllers/validation.controller.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { TimeValue, TimeConstraints } from '../timepicker.types.js';
+import { TimePickerHost, TimeValidationController } from '../interfaces/timepicker.interface.js';
+/**
+ * Controller for handling time validation logic
+ */
+export declare class TimePickerValidationController implements TimeValidationController {
+    private host;
+    private constraints;
+    constructor(host: TimePickerHost);
+    /**
+     * Set validation constraints
+     */
+    setConstraints(constraints: TimeConstraints): void;
+    /**
+     * Get current constraints
+     */
+    getConstraints(): TimeConstraints;
+    /**
+     * Validate time against all constraints
+     */
+    validateConstraints(time: TimeValue): boolean;
+    /**
+     * Check if time is within min/max bounds
+     */
+    isTimeInBounds(time: TimeValue): boolean;
+    /**
+     * Check if time is explicitly disabled
+     */
+    isTimeDisabled(time: TimeValue): boolean;
+    /**
+     * Check if time is in enabled times list (if specified)
+     */
+    isTimeEnabled(time: TimeValue): boolean;
+    /**
+     * Get validation message for a time
+     */
+    getValidationMessage(time: TimeValue): string;
+    /**
+     * Get bounds validation message
+     */
+    private getBoundsValidationMessage;
+    /**
+     * Validate time format
+     */
+    validateTimeFormat(timeString: string): boolean;
+    /**
+     * Get validation result with details
+     */
+    getValidationResult(time: TimeValue): {
+        isValid: boolean;
+        message: string;
+        errors: string[];
+    };
+    /**
+     * Find nearest valid time
+     */
+    findNearestValidTime(time: TimeValue): TimeValue | null;
+    /**
+     * Check if current time selection is valid
+     */
+    isCurrentSelectionValid(): boolean;
+    /**
+     * Set min time constraint
+     */
+    setMinTime(minTime: string | null): void;
+    /**
+     * Set max time constraint
+     */
+    setMaxTime(maxTime: string | null): void;
+    /**
+     * Set disabled times
+     */
+    setDisabledTimes(disabledTimes: string[]): void;
+    /**
+     * Set enabled times
+     */
+    setEnabledTimes(enabledTimes: string[]): void;
+    /**
+     * Clear all constraints
+     */
+    clearConstraints(): void;
+}
+//# sourceMappingURL=validation.controller.d.ts.map

package/dist/src/components/timepicker/controllers/validation.controller.js

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { TimeUtils } from '../utils/time.utils.js';
+/**
+ * Controller for handling time validation logic
+ */
+export class TimePickerValidationController {
+    constructor(host) {
+        this.host = host;
+        this.constraints = {};
+    }
+    /**
+     * Set validation constraints
+     */
+    setConstraints(constraints) {
+        this.constraints = Object.assign({}, constraints);
+    }
+    /**
+     * Get current constraints
+     */
+    getConstraints() {
+        return Object.assign({}, this.constraints);
+    }
+    /**
+     * Validate time against all constraints
+     */
+    validateConstraints(time) {
+        return (this.isTimeInBounds(time) &&
+            !this.isTimeDisabled(time) &&
+            this.isTimeEnabled(time));
+    }
+    /**
+     * Check if time is within min/max bounds
+     */
+    isTimeInBounds(time) {
+        let minTime = null;
+        let maxTime = null;
+        // Parse min time constraint
+        if (this.constraints.minTime) {
+            const config = this.host.getConfig();
+            minTime = TimeUtils.parseTimeString(this.constraints.minTime, config.format);
+        }
+        // Parse max time constraint
+        if (this.constraints.maxTime) {
+            const config = this.host.getConfig();
+            maxTime = TimeUtils.parseTimeString(this.constraints.maxTime, config.format);
+        }
+        return TimeUtils.isTimeInRange(time, minTime, maxTime);
+    }
+    /**
+     * Check if time is explicitly disabled
+     */
+    isTimeDisabled(time) {
+        if (!this.constraints.disabledTimes || this.constraints.disabledTimes.length === 0) {
+            return false;
+        }
+        const timeString = this.host.formatTime(time);
+        return this.constraints.disabledTimes.includes(timeString);
+    }
+    /**
+     * Check if time is in enabled times list (if specified)
+     */
+    isTimeEnabled(time) {
+        // If no enabled times specified, all times are enabled (except disabled ones)
+        if (!this.constraints.enabledTimes || this.constraints.enabledTimes.length === 0) {
+            return true;
+        }
+        const timeString = this.host.formatTime(time);
+        return this.constraints.enabledTimes.includes(timeString);
+    }
+    /**
+     * Get validation message for a time
+     */
+    getValidationMessage(time) {
+        if (!this.isTimeInBounds(time)) {
+            return this.getBoundsValidationMessage(time);
+        }
+        if (this.isTimeDisabled(time)) {
+            return 'This time is not available';
+        }
+        if (!this.isTimeEnabled(time)) {
+            return 'This time is not in the allowed time range';
+        }
+        return '';
+    }
+    /**
+     * Get bounds validation message
+     */
+    getBoundsValidationMessage(time) {
+        const config = this.host.getConfig();
+        let message = '';
+        if (this.constraints.minTime && this.constraints.maxTime) {
+            message = `Time must be between ${this.constraints.minTime} and ${this.constraints.maxTime}`;
+        }
+        else if (this.constraints.minTime) {
+            const minTime = TimeUtils.parseTimeString(this.constraints.minTime, config.format);
+            if (minTime && TimeUtils.compareTime(time, minTime) < 0) {
+                message = `Time must be after ${this.constraints.minTime}`;
+            }
+        }
+        else if (this.constraints.maxTime) {
+            const maxTime = TimeUtils.parseTimeString(this.constraints.maxTime, config.format);
+            if (maxTime && TimeUtils.compareTime(time, maxTime) > 0) {
+                message = `Time must be before ${this.constraints.maxTime}`;
+            }
+        }
+        return message;
+    }
+    /**
+     * Validate time format
+     */
+    validateTimeFormat(timeString) {
+        const config = this.host.getConfig();
+        const parsedTime = TimeUtils.parseTimeString(timeString, config.format);
+        return parsedTime !== null;
+    }
+    /**
+     * Get validation result with details
+     */
+    getValidationResult(time) {
+        const errors = [];
+        if (!this.isTimeInBounds(time)) {
+            errors.push(this.getBoundsValidationMessage(time));
+        }
+        if (this.isTimeDisabled(time)) {
+            errors.push('This time is disabled');
+        }
+        if (!this.isTimeEnabled(time)) {
+            errors.push('This time is not in the allowed range');
+        }
+        return {
+            isValid: errors.length === 0,
+            message: errors.length > 0 ? errors[0] : '',
+            errors,
+        };
+    }
+    /**
+     * Find nearest valid time
+     */
+    findNearestValidTime(time) {
+        if (this.validateConstraints(time)) {
+            return time;
+        }
+        // Try nearby times (within 1 hour range)
+        for (let minuteOffset = 1; minuteOffset <= 60; minuteOffset++) {
+            // Try adding minutes
+            const laterTime = TimeUtils.addTime(time, 0, minuteOffset, 0);
+            if (this.validateConstraints(laterTime)) {
+                return laterTime;
+            }
+            // Try subtracting minutes
+            const earlierTime = TimeUtils.addTime(time, 0, -minuteOffset, 0);
+            if (this.validateConstraints(earlierTime)) {
+                return earlierTime;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if current time selection is valid
+     */
+    isCurrentSelectionValid() {
+        const selectedTime = this.host.getCurrentTime();
+        return this.validateConstraints(selectedTime);
+    }
+    /**
+     * Set min time constraint
+     */
+    setMinTime(minTime) {
+        this.constraints.minTime = minTime || undefined;
+    }
+    /**
+     * Set max time constraint
+     */
+    setMaxTime(maxTime) {
+        this.constraints.maxTime = maxTime || undefined;
+    }
+    /**
+     * Set disabled times
+     */
+    setDisabledTimes(disabledTimes) {
+        this.constraints.disabledTimes = [...disabledTimes];
+    }
+    /**
+     * Set enabled times
+     */
+    setEnabledTimes(enabledTimes) {
+        this.constraints.enabledTimes = [...enabledTimes];
+    }
+    /**
+     * Clear all constraints
+     */
+    clearConstraints() {
+        this.constraints = {};
+    }
+}
+//# sourceMappingURL=validation.controller.js.map

package/dist/src/components/timepicker/interfaces/timepicker.interface.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { TimeValue, TimePickerConfig } from '../timepicker.types.js';
+/**
+ * Base controller interface for time picker host
+ */
+export interface TimePickerHost {
+    /**
+     * Get current time value
+     */
+    getCurrentTime(): TimeValue;
+    /**
+     * Set time value
+     */
+    setTime(time: TimeValue): void;
+    /**
+     * Format time value to string
+     */
+    formatTime(time: TimeValue): string;
+    /**
+     * Parse time string to TimeValue
+     */
+    parseTime(timeString: string): TimeValue | null;
+    /**
+     * Get time picker configuration
+     */
+    getConfig(): TimePickerConfig;
+    /**
+     * Validate time value
+     */
+    validateTime(time: TimeValue): boolean;
+    /**
+     * Request component update
+     */
+    requestUpdate(): void;
+}
+/**
+ * Time selection controller interface
+ */
+export interface TimeSelectionController {
+    /**
+     * Select time value
+     */
+    selectTime(time: TimeValue): void;
+    /**
+     * Get selected time
+     */
+    getSelectedTime(): TimeValue | null;
+    /**
+     * Clear selection
+     */
+    clearSelection(): void;
+    /**
+     * Check if time is selected
+     */
+    isTimeSelected(time: TimeValue): boolean;
+}
+/**
+ * Time validation controller interface
+ */
+export interface TimeValidationController {
+    /**
+     * Validate time constraints
+     */
+    validateConstraints(time: TimeValue): boolean;
+    /**
+     * Check if time is within min/max bounds
+     */
+    isTimeInBounds(time: TimeValue): boolean;
+    /**
+     * Check if time is disabled
+     */
+    isTimeDisabled(time: TimeValue): boolean;
+    /**
+     * Get validation message
+     */
+    getValidationMessage(time: TimeValue): string;
+}
+/**
+ * Time formatting controller interface
+ */
+export interface TimeFormattingController {
+    /**
+     * Format time to display string
+     */
+    formatForDisplay(time: TimeValue): string;
+    /**
+     * Format time to input value
+     */
+    formatForInput(time: TimeValue): string;
+    /**
+     * Parse input value to time
+     */
+    parseInputValue(value: string): TimeValue | null;
+    /**
+     * Get time format pattern
+     */
+    getFormatPattern(): string;
+}
+//# sourceMappingURL=timepicker.interface.d.ts.map

package/dist/src/components/timepicker/interfaces/timepicker.interface.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export {};
+//# sourceMappingURL=timepicker.interface.js.map

package/dist/src/components/timepicker/test/timepicker_test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export {};
+//# sourceMappingURL=timepicker_test.d.ts.map