@nova-design-system/nova-webcomponents 3.18.0-beta.0 → 3.19.0

package/dist/cjs/nv-fieldtime.cjs.entry.js

@@ -3,11 +3,245 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-93d3b2f8.js');
-const string_utils = require('./string.utils-9c581350.js');
 const constants = require('./constants-f5633903.js');
 const v4 = require('./v4-7014b8b0.js');
 
-const nvFieldtimeCss = "nv-fieldslider .slider-container .track-container:has(.thumb:hover) .track-range{background:var(--components-slider-track-filled-hover)}nv-fieldslider .slider-container .track-container:has(.thumb:hover) .thumb{border-color:var(--components-slider-track-filled-hover)}nv-fieldslider .slider-container .track-container:has(.thumb:focus) .track-range{background:var(--components-slider-track-filled-focus)}nv-fieldslider .slider-container .track-container:has(.thumb:focus) .thumb{border-color:var(--components-slider-track-filled-focus)}nv-fieldslider[error] .slider-container .track-container .track .track-range{background:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container .track .thumb{border-color:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container .track .thumb:hover{border-color:var(--components-slider-track-filled-error);outline:calc(var(--focus-outline-stroke) * 1) solid var(--components-slider-track-filled-error);outline-offset:calc(var(--focus-outline-offset) * 1);background-color:var(--components-slider-handler-background-error)}nv-fieldslider[error] .slider-container .track-container .track .thumb:focus{border-color:var(--components-slider-track-filled-error);outline:calc(var(--focus-outline-stroke) * 1) solid var(--components-slider-track-filled-error);outline-offset:calc(var(--focus-outline-offset) * 1);background-color:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container:has(.thumb:hover) .track-range{background:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container:has(.thumb:hover) .thumb{border-color:var(--components-slider-track-filled-error)}nv-fieldtime{--nv-field-border-default:var(--components-form-field-border-default);--nv-field-border-hover:var(--components-form-field-border-hover);--nv-field-border-focus:var(--components-form-field-border-focus);--nv-field-border-disabled:var(--components-form-field-border-default);--nv-field-border-readonly:var(--components-form-field-border-default);--nv-field-focus-box-shadow:var(--color-focus-brand);--nv-field-background:var(--components-form-field-background-default);display:flex;flex-direction:column;align-items:flex-start;gap:var(--form-gap-y);box-sizing:border-box;max-width:480px}nv-fieldtime[readonly]:not([readonly=false]){--nv-field-border-default:var(--components-form-field-border-readonly);--nv-field-border-hover:var(--nv-field-border-default);--nv-field-border-focus:var(--components-form-field-border-focus);--nv-field-border-disabled:var(--nv-field-border-default);--nv-field-border-readonly:var(--nv-field-border-default);--nv-field-background:var(--components-form-field-background-readonly)}nv-fieldtime[error]:not([error=false]){--nv-field-border-default:var(--components-form-field-border-error);--nv-field-border-hover:var(--nv-field-border-default);--nv-field-border-focus:var(--nv-field-border-default);--nv-field-border-disabled:var(--nv-field-border-default);--nv-field-border-readonly:var(--nv-field-border-default);--nv-field-focus-box-shadow:var(--color-focus-destructive-in-field)}nv-fieldtime[success]:not([success=false]){--nv-field-border-default:var(--components-form-field-border-success);--nv-field-border-hover:var(--nv-field-border-default);--nv-field-border-focus:var(--nv-field-border-default);--nv-field-border-disabled:var(--nv-field-border-default);--nv-field-border-readonly:var(--nv-field-border-default);--nv-field-focus-box-shadow:var(--color-focus-success)}nv-fieldtime[required]:not([required=false]) label::after{content:\"*\";color:var(--components-form-text-required);font-weight:var(--font-weight-high-emphasis)}nv-fieldtime label{display:flex;align-items:center;gap:var(--form-label-gap);align-self:stretch;color:var(--components-form-text-label-default);font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-label-font-size);font-style:normal;font-weight:var(--font-weight-medium-emphasis);line-height:var(--form-label-line-height)}nv-fieldtime nv-popover{width:100%;display:block}nv-fieldtime nv-popover [data-scope=popover]{padding:var(--list-dropdown-padding);background-color:var(--components-list-dropdown-background);border:1px solid var(--components-list-dropdown-border);width:100%}nv-fieldtime .input-wrapper{display:flex;flex-wrap:wrap;gap:var(--form-gap-x);align-items:stretch;align-self:stretch;width:100%}nv-fieldtime .input-container{display:flex;flex-grow:1;justify-content:center;align-items:center;align-self:stretch;border-radius:var(--form-field-radius);border-width:1px;border-style:solid;border-color:var(--nv-field-border-default);opacity:var(--components-form-opacity-default, 1);background:var(--nv-field-background);transition:all 150ms ease-out;display:flex;justify-content:flex-start;align-items:center;position:relative;width:100%;min-height:40px;gap:0;padding-left:var(--form-field-padding-x)}nv-fieldtime .input-container:hover{border-color:var(--nv-field-border-hover)}nv-fieldtime .input-container:focus-within,nv-fieldtime .input-container:focus-within:hover,nv-fieldtime .input-container:focus,nv-fieldtime .input-container:focus:hover{border-color:var(--nv-field-border-focus);box-shadow:0px 0px 0px var(--focus-field-stroke) var(--nv-field-focus-box-shadow)}nv-fieldtime .input-container:has(input:read-only){opacity:0.5;background-color:var(--components-form-field-background-readonly);border-color:var(--nv-field-border-readonly)}nv-fieldtime .input-container:has(input:disabled){opacity:0.5;background-color:var(--components-form-field-background-disabled);border-color:var(--nv-field-border-disabled)}nv-fieldtime .input-container input.time-input{display:flex;align-items:center;flex:1 0 0;overflow:hidden;background-color:transparent;color:var(--components-form-field-content-text);padding:var(--form-field-padding-y) var(--form-field-padding-x);font-size:var(--form-field-font-size);font-style:normal;font-weight:var(--font-weight-medium-emphasis);line-height:var(--form-field-line-height);width:100%;width:100%;min-width:24px;flex:0 0 24px;text-align:center;padding:0;margin:0}nv-fieldtime .input-container input.time-input:focus{outline:none}nv-fieldtime .input-container input.time-input::placeholder{overflow:hidden;color:var(--components-form-field-content-placeholder);text-overflow:ellipsis;font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-field-font-size);font-style:normal;font-weight:var(--font-weight-low-emphasis);line-height:var(--form-field-line-height)}nv-fieldtime .input-container input.time-input[type=password]::-ms-clear,nv-fieldtime .input-container input.time-input[type=password]::-ms-reveal{display:none;width:0;height:0}nv-fieldtime .input-container input.time-input::-webkit-inner-spin-button,nv-fieldtime .input-container input.time-input::-webkit-outer-spin-button{-webkit-appearance:none;margin:0}nv-fieldtime .input-container span{width:100%;text-align:center;min-width:24px;flex:0 0 24px;padding:0 4px;color:var(--components-form-field-content-text)}nv-fieldtime .input-container>nv-iconbutton{border:0px;border-radius:0px;margin-left:auto}nv-fieldtime .input-container>nv-iconbutton:focus-visible{border-radius:var(--button-md-border-radius);outline-offset:-3px}nv-fieldtime .input-container>nv-iconbutton:last-of-type{border-top-right-radius:var(--form-field-radius);border-bottom-right-radius:var(--form-field-radius)}nv-fieldtime .input-container nv-icon.validation{color:var(--nv-field-border-default);position:absolute;right:50px;top:50%;transform:translateY(-50%)}nv-fieldtime .input-container:focus,nv-fieldtime .input-container:focus-within{border-color:var(--color-focus-brand);box-shadow:0px 0px 0px var(--focus-field-stroke) var(--color-focus-brand)}nv-fieldtime .description{display:flex;align-items:center;align-self:stretch;gap:var(--spacing-1);color:var(--components-form-text-description-default);font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-description-font-size);font-style:normal;line-height:var(--form-description-line-height)}nv-fieldtime .error-description{display:flex;align-items:center;align-self:stretch;gap:var(--spacing-1);color:var(--components-form-text-description-default);font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-description-font-size);font-style:normal;line-height:var(--form-description-line-height);color:var(--components-form-text-description-error)}nv-fieldtime hr{border:none;border-top:1px solid var(--dropdown-divider-color, #ccc);margin:0.5rem 0}nv-fieldtime .time-dropdown{width:100%}nv-fieldtime .time-dropdown .time-columns{display:flex;justify-content:flex-start;align-items:center}nv-fieldtime .time-dropdown .time-columns .time-column{flex:1;text-align:center;max-height:200px;overflow-y:auto;scroll-behavior:smooth;scrollbar-gutter:stable both-edges;scrollbar-gutter:auto}nv-fieldtime .time-dropdown .time-columns .time-column::-webkit-scrollbar{width:6px;height:6px}nv-fieldtime .time-dropdown .time-columns .time-column::-webkit-scrollbar-track{background-color:var(--color-level-10-background);border-radius:9999px}nv-fieldtime .time-dropdown .time-columns .time-column::-webkit-scrollbar-thumb{background-color:var(--color-gray-200);border-radius:9999px}nv-fieldtime .time-dropdown .time-columns .time-column:last-child{border-right:none}nv-fieldtime .time-dropdown .time-columns .time-column .time-option{padding:var(--calendar-padding);text-align:center;cursor:pointer;transition:background-color 0.2s;border-radius:var(--list-dropdown-item-radius);color:var(--components-calendar-cell-text);font-size:var(--font-size-sm);display:flex;justify-content:center;align-items:center}nv-fieldtime .time-dropdown .time-columns .time-column .time-option:hover{background-color:var(--components-calendar-cell-background-hover);color:var(--components-calendar-cell-text-hover)}nv-fieldtime .time-dropdown .time-columns .time-column .time-option:focus,nv-fieldtime .time-dropdown .time-columns .time-column .time-option:focus-within{background-color:var(--components-calendar-cell-background-hover);color:var(--components-calendar-cell-text-hover)}nv-fieldtime .time-dropdown .time-columns .time-column .time-option.selected{background-color:var(--components-calendar-cell-background-selected);color:var(--components-calendar-cell-text-selected)}nv-fieldtime .time-dropdown .time-columns .time-column .time-option.highlighted{background-color:var(--components-calendar-cell-background-hover);color:var(--components-menu-contextual-item-content-hover)}";
+/**
+ * Format configurations for all supported time formats
+ */
+const FORMAT_CONFIGS = {
+    'HH': {
+        pattern: /^([0-1]?[0-9]|2[0-3])$/,
+        parts: [constants.TimeType.Hours],
+        defaultValue: '00',
+        maxLength: 2,
+    },
+    'HH:mm': {
+        pattern: /^([0-1]?[0-9]|2[0-3]):([0-5]?[0-9])$/,
+        parts: [constants.TimeType.Hours, constants.TimeType.Minutes],
+        defaultValue: '00:00',
+        maxLength: 5,
+    },
+    'HH:mm:ss': {
+        pattern: /^([0-1]?[0-9]|2[0-3]):([0-5]?[0-9]):([0-5]?[0-9])$/,
+        parts: [constants.TimeType.Hours, constants.TimeType.Minutes, constants.TimeType.Seconds],
+        defaultValue: '00:00:00',
+        maxLength: 8,
+    },
+    'hh': {
+        pattern: /^(0?[1-9]|1[0-2])$/,
+        parts: [constants.TimeType.Hours],
+        defaultValue: '01',
+        maxLength: 2,
+    },
+    'hh:mm': {
+        pattern: /^(0?[1-9]|1[0-2]):([0-5]?[0-9])$/,
+        parts: [constants.TimeType.Hours, constants.TimeType.Minutes],
+        defaultValue: '01:00',
+        maxLength: 5,
+    },
+    'hh:mm:ss': {
+        pattern: /^(0?[1-9]|1[0-2]):([0-5]?[0-9]):([0-5]?[0-9])$/,
+        parts: [constants.TimeType.Hours, constants.TimeType.Minutes, constants.TimeType.Seconds],
+        defaultValue: '01:00:00',
+        maxLength: 8,
+    },
+};
+/**
+ * Returns the visible time types for a given format
+ * @param {string} format - The time format string
+ * @returns {TimeType[]} Array of TimeType values that should be visible
+ */
+function getVisibleTimeTypes(format) {
+    const config = FORMAT_CONFIGS[format];
+    if (!config) {
+        // Fallback for unknown formats
+        return [constants.TimeType.Hours, constants.TimeType.Minutes, constants.TimeType.Seconds];
+    }
+    return config.parts;
+}
+/**
+ * Validates if a given value string matches the expected format pattern
+ * @param {string} value - The time value string to validate
+ * @param {string} format - The expected time format
+ * @returns {boolean} True if the value matches the format, false otherwise
+ */
+function isValidFormatValue(value, format) {
+    if (!value || !format) {
+        return false;
+    }
+    const config = FORMAT_CONFIGS[format];
+    if (!config) {
+        return false;
+    }
+    return config.pattern.test(value);
+}
+/**
+ * Parses a time value string according to the specified format
+ * Handles both full and partial time strings with backward compatibility
+ * @param {string} value - The time value string to parse
+ * @param {string} format - The target time format
+ * @returns {TimeComponents} TimeComponents object with parsed hours, minutes, and seconds
+ */
+function parseValueByFormat(value, format) {
+    const config = FORMAT_CONFIGS[format];
+    const defaultComponents = {
+        hours: format.startsWith('hh') ? '01' : '00',
+        minutes: '00',
+        seconds: '00',
+    };
+    if (!value || !config) {
+        return defaultComponents;
+    }
+    // Clean the input value - remove non-numeric characters except colons
+    const cleanValue = value.replace(/[^0-9:]/g, '');
+    // Try to match the exact format first
+    const exactMatch = cleanValue.match(config.pattern);
+    if (exactMatch) {
+        return extractComponentsFromMatch(exactMatch, format);
+    }
+    // Handle backward compatibility - parse full format values when format is shorter
+    const fullFormatPattern = /^([0-1]?[0-9]|2[0-3]):([0-5]?[0-9]):([0-5]?[0-9])$/;
+    const fullMatch = cleanValue.match(fullFormatPattern);
+    if (fullMatch) {
+        const fullComponents = extractComponentsFromMatch(fullMatch, 'HH:mm:ss');
+        return extractRelevantComponents(fullComponents, format);
+    }
+    // Handle partial format values - try to parse what we can
+    const parts = cleanValue.split(':');
+    const result = Object.assign({}, defaultComponents);
+    if (parts.length >= 1 && parts[0]) {
+        const hours = parseInt(parts[0], 10);
+        if (!isNaN(hours)) {
+            if (format.startsWith('hh')) {
+                // 12-hour format validation
+                if (hours >= 1 && hours <= 12) {
+                    result.hours = hours.toString().padStart(2, '0');
+                }
+                else {
+                    // Invalid hour for 12-hour format, keep default
+                    result.hours = defaultComponents.hours;
+                }
+            }
+            else {
+                // 24-hour format validation
+                if (hours >= 0 && hours <= 23) {
+                    result.hours = hours.toString().padStart(2, '0');
+                }
+                else {
+                    // Invalid hour for 24-hour format, keep default
+                    result.hours = defaultComponents.hours;
+                }
+            }
+        }
+    }
+    if (parts.length >= 2 &&
+        parts[1] &&
+        config.parts.includes(constants.TimeType.Minutes)) {
+        const minutes = parseInt(parts[1], 10);
+        if (!isNaN(minutes) && minutes >= 0 && minutes <= 59) {
+            result.minutes = minutes.toString().padStart(2, '0');
+        }
+    }
+    if (parts.length >= 3 &&
+        parts[2] &&
+        config.parts.includes(constants.TimeType.Seconds)) {
+        const seconds = parseInt(parts[2], 10);
+        if (!isNaN(seconds) && seconds >= 0 && seconds <= 59) {
+            result.seconds = seconds.toString().padStart(2, '0');
+        }
+    }
+    return result;
+}
+/**
+ * Extracts time components from a regex match result
+ * @param {RegExpMatchArray} match - The regex match result
+ * @param {string} format - The format that was matched
+ * @returns {TimeComponents} TimeComponents object
+ */
+function extractComponentsFromMatch(match, format) {
+    const result = {
+        hours: format.startsWith('hh') ? '01' : '00',
+        minutes: '00',
+        seconds: '00',
+    };
+    if (match[1]) {
+        result.hours = parseInt(match[1], 10).toString().padStart(2, '0');
+    }
+    if (match[2]) {
+        result.minutes = parseInt(match[2], 10).toString().padStart(2, '0');
+    }
+    if (match[3]) {
+        result.seconds = parseInt(match[3], 10).toString().padStart(2, '0');
+    }
+    return result;
+}
+/**
+ * Extracts only the relevant components based on the target format
+ * @param {TimeComponents} components - Full time components
+ * @param {string} format - Target format to extract components for
+ * @returns {TimeComponents} TimeComponents with only relevant parts
+ */
+function extractRelevantComponents(components, format) {
+    const config = FORMAT_CONFIGS[format];
+    const result = {
+        hours: format.startsWith('hh') ? '01' : '00',
+        minutes: '00',
+        seconds: '00',
+    };
+    if (config.parts.includes(constants.TimeType.Hours)) {
+        // Validate hours for the target format
+        const hours = parseInt(components.hours, 10);
+        if (format.startsWith('hh')) {
+            // 12-hour format validation
+            if (hours >= 1 && hours <= 12) {
+                result.hours = components.hours;
+            }
+            // If invalid, keep the default '01'
+        }
+        else {
+            // 24-hour format validation
+            if (hours >= 0 && hours <= 23) {
+                result.hours = components.hours;
+            }
+            // If invalid, keep the default '00'
+        }
+    }
+    if (config.parts.includes(constants.TimeType.Minutes)) {
+        result.minutes = components.minutes;
+    }
+    if (config.parts.includes(constants.TimeType.Seconds)) {
+        result.seconds = components.seconds;
+    }
+    return result;
+}
+/**
+ * Reconstructs a time string from components according to the specified format
+ * @param {TimeComponents} components - Time components to reconstruct
+ * @param {string} format - Target format for reconstruction
+ * @returns {string} Formatted time string
+ */
+function reconstructTimeByFormat(components, format) {
+    const config = FORMAT_CONFIGS[format];
+    if (!config) {
+        return `${components.hours}:${components.minutes}:${components.seconds}`;
+    }
+    switch (format) {
+        case 'HH':
+        case 'hh':
+            return components.hours;
+        case 'HH:mm':
+        case 'hh:mm':
+            return `${components.hours}:${components.minutes}`;
+        case 'HH:mm:ss':
+        case 'hh:mm:ss':
+            return `${components.hours}:${components.minutes}:${components.seconds}`;
+        default:
+            return `${components.hours}:${components.minutes}:${components.seconds}`;
+    }
+}
+
+const nvFieldtimeCss = "nv-fieldslider .slider-container .track-container:has(.thumb:hover) .track-range{background:var(--components-slider-track-filled-hover)}nv-fieldslider .slider-container .track-container:has(.thumb:hover) .thumb{border-color:var(--components-slider-track-filled-hover)}nv-fieldslider .slider-container .track-container:has(.thumb:focus) .track-range{background:var(--components-slider-track-filled-focus)}nv-fieldslider .slider-container .track-container:has(.thumb:focus) .thumb{border-color:var(--components-slider-track-filled-focus)}nv-fieldslider[error] .slider-container .track-container .track .track-range{background:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container .track .thumb{border-color:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container .track .thumb:hover{border-color:var(--components-slider-track-filled-error);outline:calc(var(--focus-outline-stroke) * 1) solid var(--components-slider-track-filled-error);outline-offset:calc(var(--focus-outline-offset) * 1);background-color:var(--components-slider-handler-background-error)}nv-fieldslider[error] .slider-container .track-container .track .thumb:focus{border-color:var(--components-slider-track-filled-error);outline:calc(var(--focus-outline-stroke) * 1) solid var(--components-slider-track-filled-error);outline-offset:calc(var(--focus-outline-offset) * 1);background-color:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container:has(.thumb:hover) .track-range{background:var(--components-slider-track-filled-error)}nv-fieldslider[error] .slider-container .track-container:has(.thumb:hover) .thumb{border-color:var(--components-slider-track-filled-error)}nv-fieldtime{--nv-field-border-default:var(--components-form-field-border-default);--nv-field-border-hover:var(--components-form-field-border-hover);--nv-field-border-focus:var(--components-form-field-border-focus);--nv-field-border-disabled:var(--components-form-field-border-default);--nv-field-border-readonly:var(--components-form-field-border-default);--nv-field-focus-box-shadow:var(--color-focus-brand);--nv-field-background:var(--components-form-field-background-default);display:flex;flex-direction:column;align-items:flex-start;gap:var(--form-gap-y);box-sizing:border-box;max-width:480px}nv-fieldtime[readonly]:not([readonly=false]){--nv-field-border-default:var(--components-form-field-border-readonly);--nv-field-border-hover:var(--nv-field-border-default);--nv-field-border-focus:var(--components-form-field-border-focus);--nv-field-border-disabled:var(--nv-field-border-default);--nv-field-border-readonly:var(--nv-field-border-default);--nv-field-background:var(--components-form-field-background-readonly)}nv-fieldtime[error]:not([error=false]){--nv-field-border-default:var(--components-form-field-border-error);--nv-field-border-hover:var(--nv-field-border-default);--nv-field-border-focus:var(--nv-field-border-default);--nv-field-border-disabled:var(--nv-field-border-default);--nv-field-border-readonly:var(--nv-field-border-default);--nv-field-focus-box-shadow:var(--color-focus-destructive-in-field)}nv-fieldtime[success]:not([success=false]){--nv-field-border-default:var(--components-form-field-border-success);--nv-field-border-hover:var(--nv-field-border-default);--nv-field-border-focus:var(--nv-field-border-default);--nv-field-border-disabled:var(--nv-field-border-default);--nv-field-border-readonly:var(--nv-field-border-default);--nv-field-focus-box-shadow:var(--color-focus-success)}nv-fieldtime[required]:not([required=false]) label::after{content:\"*\";color:var(--components-form-text-required);font-weight:var(--font-weight-high-emphasis)}nv-fieldtime label{display:flex;align-items:center;gap:var(--form-label-gap);align-self:stretch;color:var(--components-form-text-label-default);font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-label-font-size);font-style:normal;font-weight:var(--font-weight-medium-emphasis);line-height:var(--form-label-line-height)}nv-fieldtime nv-popover{width:100%;display:block;z-index:9999}nv-fieldtime nv-popover [data-scope=popover]{padding:var(--list-dropdown-padding);background-color:var(--components-list-dropdown-background);border:1px solid var(--components-list-dropdown-border);width:100%}nv-fieldtime .input-wrapper{display:flex;flex-wrap:wrap;gap:var(--form-gap-x);align-items:stretch;align-self:stretch;width:100%}nv-fieldtime .input-container{display:flex;flex-grow:1;justify-content:center;align-items:center;align-self:stretch;border-radius:var(--form-field-radius);border-width:1px;border-style:solid;border-color:var(--nv-field-border-default);opacity:var(--components-form-opacity-default, 1);background:var(--nv-field-background);transition:all 150ms ease-out;display:flex;justify-content:flex-start;align-items:center;position:relative;width:100%;min-height:40px;gap:0;padding-left:var(--form-field-padding-x)}nv-fieldtime .input-container:hover{border-color:var(--nv-field-border-hover)}nv-fieldtime .input-container:focus-within,nv-fieldtime .input-container:focus-within:hover,nv-fieldtime .input-container:focus,nv-fieldtime .input-container:focus:hover{border-color:var(--nv-field-border-focus);box-shadow:0px 0px 0px var(--focus-field-stroke) var(--nv-field-focus-box-shadow)}nv-fieldtime .input-container:has(input:read-only){opacity:0.5;background-color:var(--components-form-field-background-readonly);border-color:var(--nv-field-border-readonly)}nv-fieldtime .input-container:has(input:disabled){opacity:0.5;background-color:var(--components-form-field-background-disabled);border-color:var(--nv-field-border-disabled)}nv-fieldtime .input-container input.time-input{display:flex;align-items:center;flex:1 0 0;overflow:hidden;background-color:transparent;color:var(--components-form-field-content-text);padding:var(--form-field-padding-y) var(--form-field-padding-x);font-size:var(--form-field-font-size);font-style:normal;font-weight:var(--font-weight-medium-emphasis);line-height:var(--form-field-line-height);width:100%;width:100%;min-width:24px;flex:0 0 24px;text-align:center;padding:0;margin:0}nv-fieldtime .input-container input.time-input:focus{outline:none}nv-fieldtime .input-container input.time-input::placeholder{overflow:hidden;color:var(--components-form-field-content-placeholder);text-overflow:ellipsis;font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-field-font-size);font-style:normal;font-weight:var(--font-weight-low-emphasis);line-height:var(--form-field-line-height)}nv-fieldtime .input-container input.time-input[type=password]::-ms-clear,nv-fieldtime .input-container input.time-input[type=password]::-ms-reveal{display:none;width:0;height:0}nv-fieldtime .input-container input.time-input::-webkit-inner-spin-button,nv-fieldtime .input-container input.time-input::-webkit-outer-spin-button{-webkit-appearance:none;margin:0}nv-fieldtime .input-container span{width:100%;text-align:center;min-width:24px;flex:0 0 24px;padding:0 4px;color:var(--components-form-field-content-text)}nv-fieldtime .input-container>nv-iconbutton{border:0px;border-radius:0px;margin-left:auto}nv-fieldtime .input-container>nv-iconbutton:focus-visible{border-radius:var(--button-md-border-radius);outline-offset:-3px}nv-fieldtime .input-container>nv-iconbutton:last-of-type{border-top-right-radius:var(--form-field-radius);border-bottom-right-radius:var(--form-field-radius)}nv-fieldtime .input-container nv-icon.validation{color:var(--nv-field-border-default);position:absolute;right:50px;top:50%;transform:translateY(-50%)}nv-fieldtime .input-container:focus,nv-fieldtime .input-container:focus-within{border-color:var(--color-focus-brand);box-shadow:0px 0px 0px var(--focus-field-stroke) var(--color-focus-brand)}nv-fieldtime .description{display:flex;align-items:center;align-self:stretch;gap:var(--spacing-1);color:var(--components-form-text-description-default);font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-description-font-size);font-style:normal;line-height:var(--form-description-line-height)}nv-fieldtime .error-description{display:flex;align-items:center;align-self:stretch;gap:var(--spacing-1);color:var(--components-form-text-description-default);font-family:var(--font-family-default), var(--font-family-fallback), sans-serif;font-size:var(--form-description-font-size);font-style:normal;line-height:var(--form-description-line-height);color:var(--components-form-text-description-error)}nv-fieldtime hr{border:none;border-top:1px solid var(--dropdown-divider-color, #ccc);margin:0.5rem 0}nv-fieldtime .time-dropdown{width:100%}nv-fieldtime .time-dropdown .time-columns{display:flex;justify-content:flex-start;align-items:center}nv-fieldtime .time-dropdown .time-columns .time-column{flex:1;text-align:center;max-height:200px;overflow-y:auto;scroll-behavior:smooth;scrollbar-gutter:stable both-edges;scrollbar-gutter:auto}nv-fieldtime .time-dropdown .time-columns .time-column::-webkit-scrollbar{width:6px;height:6px}nv-fieldtime .time-dropdown .time-columns .time-column::-webkit-scrollbar-track{background-color:var(--color-level-10-background);border-radius:9999px}nv-fieldtime .time-dropdown .time-columns .time-column::-webkit-scrollbar-thumb{background-color:var(--color-gray-200);border-radius:9999px}nv-fieldtime .time-dropdown .time-columns .time-column:last-child{border-right:none}nv-fieldtime .time-dropdown .time-columns .time-column .time-option{padding:var(--calendar-padding);text-align:center;cursor:pointer;transition:background-color 0.2s;border-radius:var(--list-dropdown-item-radius);color:var(--components-calendar-cell-text);font-size:var(--font-size-sm);display:flex;justify-content:center;align-items:center}nv-fieldtime .time-dropdown .time-columns .time-column .time-option:hover{background-color:var(--components-calendar-cell-background-hover);color:var(--components-calendar-cell-text-hover)}nv-fieldtime .time-dropdown .time-columns .time-column .time-option:focus,nv-fieldtime .time-dropdown .time-columns .time-column .time-option:focus-within{background-color:var(--components-calendar-cell-background-hover);color:var(--components-calendar-cell-text-hover)}nv-fieldtime .time-dropdown .time-columns .time-column .time-option.selected{background-color:var(--components-calendar-cell-background-selected);color:var(--components-calendar-cell-text-selected)}nv-fieldtime .time-dropdown .time-columns .time-column .time-option.highlighted{background-color:var(--components-calendar-cell-background-hover);color:var(--components-menu-contextual-item-content-hover)}";
 const NvFieldtimeStyle0 = nvFieldtimeCss;
 
 const NvFieldtime = class {
@@ -67,6 +301,10 @@ const NvFieldtime = class {
          * - hh: 12-hour format (01-12)
          * - hh:mm: 12-hour format with minutes (01:00-12:59)
          * - hh:mm:ss: 12-hour format with minutes and seconds (01:00:00-12:59:59)
+         *
+         * The component automatically shows only the relevant input fields based on the selected format.
+         * When the format changes dynamically, the component re-parses the current value and updates
+         * the visible fields accordingly.
          */
         this.format = 'HH:mm:ss';
         /**
@@ -95,7 +333,7 @@ const NvFieldtime = class {
         this.open = event.detail;
     }
     handleKeyDown(event) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         if (!this.open) {
             if (event.key === 'ArrowDown') {
                 this.open = true;
@@ -130,27 +368,42 @@ const NvFieldtime = class {
         else if (event.key === 'Enter' && currentIndex >= 0) {
             event.preventDefault();
             items[currentIndex].click();
-            if (this.typeFocused === constants.TimeType.Hours) {
-                (_a = this.inputElements[constants.TimeType.Minutes]) === null || _a === void 0 ? void 0 : _a.focus();
-                (_b = this.inputElements[constants.TimeType.Minutes]) === null || _b === void 0 ? void 0 : _b.select();
-            }
-            else if (this.typeFocused === constants.TimeType.Minutes ||
-                this.typeFocused === constants.TimeType.Seconds) {
-                (_c = this.inputElements[constants.TimeType.Seconds]) === null || _c === void 0 ? void 0 : _c.focus();
-                (_d = this.inputElements[constants.TimeType.Seconds]) === null || _d === void 0 ? void 0 : _d.select();
+            // Navigate to the next visible field
+            const visibleTypes = getVisibleTimeTypes(this.format);
+            const currentTypeIndex = visibleTypes.indexOf(this.typeFocused);
+            const nextTypeIndex = currentTypeIndex + 1;
+            if (nextTypeIndex < visibleTypes.length) {
+                const nextType = visibleTypes[nextTypeIndex];
+                (_a = this.inputElements[nextType]) === null || _a === void 0 ? void 0 : _a.focus();
+                (_b = this.inputElements[nextType]) === null || _b === void 0 ? void 0 : _b.select();
             }
         }
         else if (event.key === 'Escape') {
             event.preventDefault();
-            if (this.inputElements[constants.TimeType.Hours]) {
-                this.inputElements[constants.TimeType.Hours].blur();
+            const visibleTypes = getVisibleTimeTypes(this.format);
+            const firstVisibleType = visibleTypes[0];
+            if (firstVisibleType && this.inputElements[firstVisibleType]) {
+                this.inputElements[firstVisibleType].blur();
             }
+            this.open = false;
         }
     }
     //#endregion LISTENERS
     /****************************************************************************/
     //#region WATCHERS
     handleValueChange(newValue) {
+        // Parse the new value and ensure it's in the correct format
+        if (newValue) {
+            const components = parseValueByFormat(newValue, this.format);
+            const formattedValue = reconstructTimeByFormat(components, this.format);
+            // Only emit if the formatted value is different from what we received
+            // This prevents infinite loops while ensuring format consistency
+            if (formattedValue !== newValue) {
+                this.value = formattedValue;
+                return; // The watcher will be called again with the formatted value
+            }
+        }
+        // Emit the value in the correct format
         this.valueChanged.emit(newValue);
     }
     handleOpenChange(newOpen) {
@@ -165,12 +418,36 @@ const NvFieldtime = class {
             this.updateColumnHighlight(secondsSelector, this.seconds);
         }
     }
+    handleFormatChange(newFormat, oldFormat) {
+        if (newFormat === oldFormat) {
+            return; // No change, nothing to do
+        }
+        // Re-parse the current value with the new format
+        const currentValue = this.value || this.reconstructTime();
+        // Parse the current value using the old format to get the time components
+        const components = parseValueByFormat(currentValue, oldFormat || 'HH:mm:ss');
+        // Update the component state with the parsed components
+        this.hours = components.hours;
+        this.minutes = components.minutes;
+        this.seconds = components.seconds;
+        // Reconstruct the time value in the new format
+        const newValue = reconstructTimeByFormat(components, newFormat);
+        // Update the value, which will trigger the value watcher and emit the event
+        this.value = newValue;
+        // Force a re-render to update the visible input fields
+        index.forceUpdate(this.el);
+    }
     //#endregion WATCHERS
     /****************************************************************************/
     //#region METHODS
     handleInputChange(e, type) {
         const inputElement = e.target;
         const inputValue = inputElement.value.replace(/[^0-9]/g, ''); // Only keep numeric input
+        // Check if this field is visible for the current format
+        const visibleTypes = getVisibleTimeTypes(this.format);
+        if (!visibleTypes.includes(type)) {
+            return; // Don't process input for non-visible fields
+        }
         // Update the time value based on the type
         switch (type) {
             case constants.TimeType.Hours:
@@ -183,489 +460,230 @@ const NvFieldtime = class {
                 this.handleSecondsChange(inputValue, type);
                 break;
         }
-        // Reconstruct time from inputs
-        const currentValue = this.reconstructTime();
-        this.value = currentValue;
+        // Reconstruct time from inputs in the correct format
+        const reconstructedValue = this.reconstructTime();
+        // Update the value, which will trigger the watcher and emit the event
+        this.value = reconstructedValue;
     }
     handleHoursChange(inputValue, type) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         const isHHFormat = this.format.startsWith('HH');
         const maxHours = isHHFormat ? 24 : 12;
-        let reputedToZero = false;
-        const maxHour = this.parseHour(this.max, this.format) ||
-            (this.format.startsWith('hh') ? '12' : '24');
-        const minHour = this.parseHour(this.min, this.format) || '00';
+        // Handle empty input
+        if (inputValue.length === 0) {
+            this.hours = '00';
+            return;
+        }
         if (inputValue.length === 1) {
             this.inputZeroAdded[type] = true;
             const newInputValue = inputValue.padStart(2, '0');
-            if (maxHour && parseInt(newInputValue, 10) > parseInt(maxHour, 10)) {
-                if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                    this.hours = minHour;
-                }
-                else {
-                    this.hours = '00';
-                    reputedToZero = true;
-                }
-            }
-            else {
-                if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                    this.hours = minHour;
-                }
-                else {
-                    this.hours = newInputValue;
-                }
-            }
+            this.hours = newInputValue;
         }
         else if (this.inputZeroAdded[type]) {
             this.inputZeroAdded[type] = false;
             const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
             const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxHours) {
-                if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                    this.hours = minHour;
-                }
-                else {
-                    this.hours = '00';
-                    reputedToZero = true;
-                }
+                this.hours = '00';
             }
             else {
-                if (maxHour && parseInt(newInputValue, 10) > parseInt(maxHour, 10)) {
-                    if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                        this.hours = minHour;
-                    }
-                    else {
-                        this.hours = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                        this.hours = minHour;
-                    }
-                    else {
-                        this.hours = newInputValue;
-                    }
-                }
+                this.hours = newInputValue;
             }
         }
         else if (inputValue.length > 2) {
             if (inputValue.startsWith('00')) {
                 this.inputZeroAdded[type] = true;
                 const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
-                if (maxHour && parseInt(newInputValue, 10) > parseInt(maxHour, 10)) {
-                    if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                        this.hours = minHour;
-                    }
-                    else {
-                        this.hours = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                        this.hours = minHour;
-                    }
-                    else {
-                        this.hours = newInputValue;
-                    }
-                }
+                this.hours = newInputValue;
             }
             else {
                 const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
                 const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+                // Only apply format validation (not min/max constraints)
                 if (parsedNewInputValue >= maxHours) {
-                    if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                        this.hours = minHour;
-                        reputedToZero = true;
-                    }
-                    else {
-                        this.hours = '00';
-                        reputedToZero = true;
-                    }
+                    this.hours = '00';
                 }
                 else {
-                    if (maxHour && parsedNewInputValue > parseInt(maxHour, 10)) {
-                        if (minHour &&
-                            parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                            this.hours = minHour;
-                        }
-                        else {
-                            this.hours = '00';
-                            reputedToZero = true;
-                        }
-                    }
-                    else {
-                        if (minHour && parsedNewInputValue < parseInt(minHour, 10)) {
-                            this.hours = minHour;
-                        }
-                        else {
-                            this.hours = parsedNewInputValue.toString();
-                        }
-                    }
+                    this.hours = parsedNewInputValue.toString();
                 }
             }
         }
         else {
-            const newInputValue = inputValue.padStart(2, '0');
-            const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            const parsedNewInputValue = parseInt(inputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxHours) {
-                if (minHour && parseInt(newInputValue, 10) < parseInt(minHour, 10)) {
-                    this.hours = minHour;
-                }
-                else {
-                    this.hours = '00';
-                    reputedToZero = true;
-                }
+                this.hours = '00';
             }
             else {
-                if (maxHour && parsedNewInputValue > parseInt(maxHour, 10)) {
-                    this.hours = '00';
-                    reputedToZero = true;
-                }
-                else {
-                    if (minHour && parsedNewInputValue < parseInt(minHour, 10)) {
-                        this.hours = minHour;
-                    }
-                    else {
-                        this.hours = parsedNewInputValue.toString();
-                    }
-                }
+                // For direct input, remove unnecessary leading zeros (e.g., '01' becomes '1')
+                this.hours = parsedNewInputValue.toString();
             }
         }
-        if (this.hours.length === 2 &&
-            !this.inputZeroAdded[type] &&
-            !reputedToZero) {
-            (_a = this.inputElements[constants.TimeType.Minutes]) === null || _a === void 0 ? void 0 : _a.focus();
-            (_b = this.inputElements[constants.TimeType.Minutes]) === null || _b === void 0 ? void 0 : _b.select();
-        }
-        else if (reputedToZero) {
-            (_c = this.inputElements[constants.TimeType.Hours]) === null || _c === void 0 ? void 0 : _c.focus();
-            (_d = this.inputElements[constants.TimeType.Hours]) === null || _d === void 0 ? void 0 : _d.select();
+        // Auto-navigation to next field when input is complete
+        if (this.hours.length >= 1 && !this.inputZeroAdded[type]) {
+            const visibleTypes = getVisibleTimeTypes(this.format);
+            const currentTypeIndex = visibleTypes.indexOf(constants.TimeType.Hours);
+            const nextTypeIndex = currentTypeIndex + 1;
+            if (nextTypeIndex < visibleTypes.length) {
+                const nextType = visibleTypes[nextTypeIndex];
+                (_a = this.inputElements[nextType]) === null || _a === void 0 ? void 0 : _a.focus();
+                (_b = this.inputElements[nextType]) === null || _b === void 0 ? void 0 : _b.select();
+            }
         }
     }
     handleMinutesChange(inputValue, type) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b;
         const maxMinutes = 60;
-        let reputedToZero = false;
-        const minMinute = (_a = this.parseMinute(this.min)) !== null && _a !== void 0 ? _a : 0;
-        const maxMinute = (_b = this.parseMinute(this.max)) !== null && _b !== void 0 ? _b : 59;
+        // Handle empty input
+        if (inputValue.length === 0) {
+            this.minutes = '00';
+            return;
+        }
         if (inputValue.length === 1) {
             this.inputZeroAdded[type] = true;
             const newInputValue = inputValue.padStart(2, '0');
-            if (maxMinute && parseInt(newInputValue, 10) > maxMinute) {
-                if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                    this.minutes = minMinute.toString().padStart(2, '0');
-                }
-                else {
-                    this.minutes = '00';
-                    reputedToZero = true;
-                }
-            }
-            else {
-                if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                    this.minutes = minMinute.toString().padStart(2, '0');
-                }
-                else {
-                    this.minutes = newInputValue;
-                }
-            }
+            this.minutes = newInputValue;
         }
         else if (this.inputZeroAdded[type]) {
             this.inputZeroAdded[type] = false;
             const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
             const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxMinutes) {
-                if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                    this.minutes = minMinute.toString().padStart(2, '0');
-                }
-                else {
-                    this.minutes = '00';
-                    reputedToZero = true;
-                }
+                this.minutes = '00';
             }
             else {
-                if (maxMinute && parsedNewInputValue > maxMinute) {
-                    if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minMinute && parsedNewInputValue < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = newInputValue;
-                    }
-                }
+                this.minutes = newInputValue;
             }
         }
         else if (inputValue.length > 2) {
             if (inputValue.startsWith('00')) {
                 this.inputZeroAdded[type] = true;
                 const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
-                if (maxMinute && parseInt(newInputValue, 10) > maxMinute) {
-                    if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = newInputValue;
-                    }
-                }
+                this.minutes = newInputValue;
             }
             else {
                 const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
                 const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+                // Only apply format validation (not min/max constraints)
                 if (parsedNewInputValue >= maxMinutes) {
-                    if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = '00';
-                        reputedToZero = true;
-                    }
+                    this.minutes = '00';
                 }
                 else {
-                    if (maxMinute && parsedNewInputValue > maxMinute) {
-                        if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                            this.minutes = minMinute.toString().padStart(2, '0');
-                        }
-                        else {
-                            this.minutes = '00';
-                            reputedToZero = true;
-                        }
-                    }
-                    else {
-                        if (minMinute && parsedNewInputValue < minMinute) {
-                            this.minutes = minMinute.toString().padStart(2, '0');
-                        }
-                        else {
-                            this.minutes = parsedNewInputValue.toString();
-                        }
-                    }
+                    this.minutes = parsedNewInputValue.toString();
                 }
             }
         }
         else {
-            const newInputValue = inputValue.padStart(2, '0');
-            const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            const parsedNewInputValue = parseInt(inputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxMinutes) {
-                if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                    this.minutes = minMinute.toString().padStart(2, '0');
-                }
-                else {
-                    this.minutes = '00';
-                    reputedToZero = true;
-                }
+                this.minutes = '00';
             }
             else {
-                if (maxMinute && parsedNewInputValue > maxMinute) {
-                    if (minMinute && parseInt(newInputValue, 10) < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minMinute && parsedNewInputValue < minMinute) {
-                        this.minutes = minMinute.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.minutes = parsedNewInputValue.toString();
-                    }
-                }
+                // For direct input, remove unnecessary leading zeros (e.g., '01' becomes '1')
+                this.minutes = parsedNewInputValue.toString();
             }
         }
-        if (this.minutes.length === 2 &&
-            !this.inputZeroAdded[type] &&
-            !reputedToZero) {
-            (_c = this.inputElements[constants.TimeType.Seconds]) === null || _c === void 0 ? void 0 : _c.focus();
-            (_d = this.inputElements[constants.TimeType.Seconds]) === null || _d === void 0 ? void 0 : _d.select();
-        }
-        else if (reputedToZero) {
-            (_e = this.inputElements[constants.TimeType.Minutes]) === null || _e === void 0 ? void 0 : _e.focus();
-            (_f = this.inputElements[constants.TimeType.Minutes]) === null || _f === void 0 ? void 0 : _f.select();
+        // Auto-navigation to next field when input is complete
+        if (this.minutes.length >= 1 && !this.inputZeroAdded[type]) {
+            const visibleTypes = getVisibleTimeTypes(this.format);
+            const currentTypeIndex = visibleTypes.indexOf(constants.TimeType.Minutes);
+            const nextTypeIndex = currentTypeIndex + 1;
+            if (nextTypeIndex < visibleTypes.length) {
+                const nextType = visibleTypes[nextTypeIndex];
+                (_a = this.inputElements[nextType]) === null || _a === void 0 ? void 0 : _a.focus();
+                (_b = this.inputElements[nextType]) === null || _b === void 0 ? void 0 : _b.select();
+            }
         }
     }
     handleSecondsChange(inputValue, type) {
-        var _a, _b, _c, _d;
         const maxSeconds = 60;
-        let reputedToZero = false;
-        const minSecond = (_a = this.parseSecond(this.min)) !== null && _a !== void 0 ? _a : 0;
-        const maxSecond = (_b = this.parseSecond(this.max)) !== null && _b !== void 0 ? _b : 59;
+        // Handle empty input
+        if (inputValue.length === 0) {
+            this.seconds = '00';
+            return;
+        }
         if (inputValue.length === 1) {
             this.inputZeroAdded[type] = true;
             const newInputValue = inputValue.padStart(2, '0');
-            if (maxSecond && parseInt(newInputValue, 10) > maxSecond) {
-                if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                    this.seconds = minSecond.toString().padStart(2, '0');
-                }
-                else {
-                    this.seconds = '00';
-                    reputedToZero = true;
-                }
-            }
-            else {
-                if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                    this.seconds = minSecond.toString().padStart(2, '0');
-                }
-                else {
-                    this.seconds = newInputValue;
-                }
-            }
+            this.seconds = newInputValue;
         }
         else if (this.inputZeroAdded[type]) {
             this.inputZeroAdded[type] = false;
             const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
             const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxSeconds) {
-                if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                    this.seconds = minSecond.toString().padStart(2, '0');
-                }
-                else {
-                    this.seconds = '00';
-                    reputedToZero = true;
-                }
+                this.seconds = '00';
             }
             else {
-                if (maxSecond && parsedNewInputValue > maxSecond) {
-                    if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                        this.seconds = minSecond.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.seconds = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minSecond && parsedNewInputValue < minSecond) {
-                        this.seconds = minSecond.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.seconds = newInputValue;
-                    }
-                }
+                this.seconds = newInputValue;
             }
         }
         else if (inputValue.length > 2) {
             const newInputValue = inputValue.slice(1, 3).padStart(2, '0');
             const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxSeconds) {
-                if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                    this.seconds = minSecond.toString().padStart(2, '0');
-                }
-                else {
-                    this.seconds = '00';
-                    reputedToZero = true;
-                }
+                this.seconds = '00';
             }
             else {
-                if (maxSecond && parsedNewInputValue > maxSecond) {
-                    if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                        this.seconds = minSecond.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.seconds = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minSecond && parsedNewInputValue < minSecond) {
-                        this.seconds = minSecond.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.seconds = parsedNewInputValue.toString();
-                    }
-                }
+                this.seconds = parsedNewInputValue.toString();
             }
         }
         else {
-            const newInputValue = inputValue.padStart(2, '0');
-            const parsedNewInputValue = parseInt(newInputValue, 10) || 0;
+            const parsedNewInputValue = parseInt(inputValue, 10) || 0;
+            // Only apply format validation (not min/max constraints)
             if (parsedNewInputValue >= maxSeconds) {
-                if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                    this.seconds = minSecond.toString().padStart(2, '0');
-                }
-                else {
-                    this.seconds = '00';
-                    reputedToZero = true;
-                }
+                this.seconds = '00';
             }
             else {
-                if (maxSecond && parsedNewInputValue > maxSecond) {
-                    if (minSecond && parseInt(newInputValue, 10) < minSecond) {
-                        this.seconds = minSecond.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.seconds = '00';
-                        reputedToZero = true;
-                    }
-                }
-                else {
-                    if (minSecond && parsedNewInputValue < minSecond) {
-                        this.seconds = minSecond.toString().padStart(2, '0');
-                    }
-                    else {
-                        this.seconds = parsedNewInputValue.toString();
-                    }
-                }
+                // For direct input, remove unnecessary leading zeros (e.g., '01' becomes '1')
+                this.seconds = parsedNewInputValue.toString();
             }
         }
-        if (reputedToZero) {
-            (_c = this.inputElements[constants.TimeType.Seconds]) === null || _c === void 0 ? void 0 : _c.focus();
-            (_d = this.inputElements[constants.TimeType.Seconds]) === null || _d === void 0 ? void 0 : _d.select();
-        }
+        // No auto-navigation for seconds field as it's typically the last field
     }
-    // Parse a continuous time string (e.g., "123456") into hours, minutes, and seconds
+    // Parse a time string according to the current format
     parseTime(timeString) {
         if (!timeString) {
             return;
         }
-        const cleanedTime = timeString.replace(/[^0-9]/g, '').padStart(6, '0');
-        const hour = cleanedTime.slice(0, 2);
-        const minute = cleanedTime.slice(2, 4);
-        const second = cleanedTime.slice(4, 6);
-        const minHour = this.parseHour(this.min, this.format) || hour;
-        const minMinute = this.parseMinute(this.min) || minute;
-        const minSecond = this.parseSecond(this.min) || second;
-        this.hours = minHour.padStart(2, '0');
-        this.minutes = minMinute.toString().padStart(2, '0');
-        this.seconds = minSecond.toString().padStart(2, '0');
+        // Use format-aware parsing without constraint application
+        const components = parseValueByFormat(timeString, this.format);
+        // Set the parsed values without applying min/max constraints
+        this.hours = components.hours;
+        this.minutes = components.minutes;
+        this.seconds = components.seconds;
     }
     reconstructTime() {
-        if (this.format === 'HH' || this.format === 'hh') {
-            return this.hours;
-        }
-        else if (this.format === 'HH:mm' || this.format === 'hh:mm') {
-            return `${this.hours}:${this.minutes}`;
-        }
-        else if (this.format === 'HH:mm:ss' || this.format === 'hh:mm:ss') {
-            return `${this.hours}:${this.minutes}:${this.seconds}`;
-        }
-        else {
-            return `${this.hours}:${this.minutes}:${this.seconds}`;
+        const components = {
+            hours: this.hours,
+            minutes: this.minutes,
+            seconds: this.seconds,
+        };
+        // Ensure the reconstructed time is in the correct format
+        const reconstructedTime = reconstructTimeByFormat(components, this.format);
+        // Validate that the reconstructed time matches the expected format
+        if (!isValidFormatValue(reconstructedTime, this.format)) {
+            // If invalid, return the default value for this format
+            const config = FORMAT_CONFIGS[this.format];
+            return config ? config.defaultValue : reconstructedTime;
         }
+        return reconstructedTime;
     }
     handleFocus(type) {
         var _a, _b, _c, _d;
         if (this.readonly || this.disabled) {
             return;
         }
+        // Check if this field is visible for the current format
+        const visibleTypes = getVisibleTimeTypes(this.format);
+        if (!visibleTypes.includes(type)) {
+            return; // Don't handle focus for non-visible fields
+        }
         if (!this.open) {
             this.open = true; // Force the popover to open
         }
@@ -678,33 +696,23 @@ const NvFieldtime = class {
         this.typeFocused = type;
     }
     HandleDropdownIconClick() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b;
         if (this.disabled || this.readonly) {
             return; // Do not toggle if disabled or read-only
         }
-        if (this.open && this.inputElements[constants.TimeType.Hours]) {
-            this.open = false; // Close the popover if it is open
-        }
-        else if (this.open && this.inputElements[constants.TimeType.Minutes]) {
-            this.open = false; // Close the popover if it is open
-        }
-        else if (this.open && this.inputElements[constants.TimeType.Seconds]) {
+        const visibleTypes = getVisibleTimeTypes(this.format);
+        const firstVisibleType = visibleTypes[0];
+        if (this.open) {
             this.open = false; // Close the popover if it is open
         }
-        else if (!this.open && this.inputElements[constants.TimeType.Hours]) {
-            (_a = this.inputElements[constants.TimeType.Hours]) === null || _a === void 0 ? void 0 : _a.focus(); // Focus will open the popover
-            (_b = this.inputElements[constants.TimeType.Hours]) === null || _b === void 0 ? void 0 : _b.select();
-        }
-        else if (!this.open && this.inputElements[constants.TimeType.Minutes]) {
-            (_c = this.inputElements[constants.TimeType.Minutes]) === null || _c === void 0 ? void 0 : _c.focus(); // Focus will open the popover
-            (_d = this.inputElements[constants.TimeType.Minutes]) === null || _d === void 0 ? void 0 : _d.select();
-        }
-        else if (!this.open && this.inputElements[constants.TimeType.Seconds]) {
-            (_e = this.inputElements[constants.TimeType.Seconds]) === null || _e === void 0 ? void 0 : _e.focus(); // Focus will open the popover
-            (_f = this.inputElements[constants.TimeType.Seconds]) === null || _f === void 0 ? void 0 : _f.select();
+        else if (!this.open &&
+            firstVisibleType &&
+            this.inputElements[firstVisibleType]) {
+            (_a = this.inputElements[firstVisibleType]) === null || _a === void 0 ? void 0 : _a.focus(); // Focus will open the popover
+            (_b = this.inputElements[firstVisibleType]) === null || _b === void 0 ? void 0 : _b.select();
         }
         else {
-            console.warn('nv-fieldtime -> No input elements found to focus or to blur');
+            console.warn('nv-fieldtime -> No visible input elements found to focus');
         }
     }
     updateHighlightedItem(items, index) {
@@ -723,6 +731,8 @@ const NvFieldtime = class {
     }
     handleTimeOptionClick(event, type) {
         const option = parseInt(event.target.textContent || '0', 10);
+        // Update the time component directly without constraint validation
+        // Dropdown options are already filtered by constraints during generation
         if (type === constants.TimeType.Hours) {
             this.hours = option.toString().padStart(2, '0');
         }
@@ -732,8 +742,9 @@ const NvFieldtime = class {
         else if (type === constants.TimeType.Seconds) {
             this.seconds = option.toString().padStart(2, '0');
         }
-        const reconstructTime = this.reconstructTime();
-        this.value = reconstructTime;
+        // Reconstruct time in the correct format and update value
+        const reconstructedTime = this.reconstructTime();
+        this.value = reconstructedTime;
     }
     handleInputBlur() {
         // Use a delay to check if the focus is still within the popover
@@ -792,17 +803,29 @@ const NvFieldtime = class {
     }
     generateHourOptions(stepInSeconds) {
         const hourStep = Math.max(1, Math.floor(stepInSeconds / 3600)); // Prevent step < 1
-        const maxHour = this.parseHour(this.max, this.format) ||
-            (this.format.startsWith('hh') ? '12' : '24');
-        const minHour = this.parseHour(this.min, this.format) || '00';
-        const maxHourValue = parseInt(maxHour, 10);
-        const minHourValue = parseInt(minHour, 10);
+        const is12HourFormat = this.format.startsWith('hh');
+        // Set proper hour ranges based on format
+        const defaultMaxHour = is12HourFormat ? 12 : 23;
+        const defaultMinHour = is12HourFormat ? 1 : 0;
+        const maxHour = this.parseHour(this.max, this.format);
+        const minHour = this.parseHour(this.min, this.format);
+        const maxHourValue = maxHour ? parseInt(maxHour, 10) : defaultMaxHour;
+        const minHourValue = minHour ? parseInt(minHour, 10) : defaultMinHour;
         const values = [];
-        for (let i = minHourValue; i < maxHourValue; i += hourStep) {
-            values.push(i.toString().padStart(2, '0'));
+        for (let i = minHourValue; i <= maxHourValue; i += hourStep) {
+            const hourStr = i.toString().padStart(2, '0');
+            values.push(hourStr);
         }
         return values;
     }
+    /**
+     * Parse hour value from min/max constraint strings for dropdown generation only.
+     * This method is used exclusively for filtering dropdown options and should not
+     * affect input values or validation.
+     * @param {string} value - The time string to parse (e.g., "14:30" or "02:30")
+     * @param {string} format - The time format string (e.g., "HH:mm" or "hh:mm")
+     * @returns {string} The parsed hour string or null if invalid
+     */
     parseHour(value, format) {
         if (!value)
             return null;
@@ -820,13 +843,21 @@ const NvFieldtime = class {
         const minMinute = (_a = this.parseMinute(this.min)) !== null && _a !== void 0 ? _a : 0;
         const maxMinute = (_b = this.parseMinute(this.max)) !== null && _b !== void 0 ? _b : 59;
         if (minMinute === 0 && maxMinute === 0)
-            return ['00']; // Handle edge case for zero seconds
+            return ['00']; // Handle edge case for zero minutes
         const values = [];
         for (let i = minMinute; i <= maxMinute; i += minuteStep) {
-            values.push(i.toString().padStart(2, '0'));
+            const minuteStr = i.toString().padStart(2, '0');
+            values.push(minuteStr);
         }
         return values;
     }
+    /**
+     * Parse minute value from min/max constraint strings for dropdown generation only.
+     * This method is used exclusively for filtering dropdown options and should not
+     * affect input values or validation.
+     * @param {string} value - The time string to parse (e.g., "14:30" or "02:30")
+     * @returns {number} The parsed minute number or null if invalid
+     */
     parseMinute(value) {
         if (!value)
             return null;
@@ -845,10 +876,18 @@ const NvFieldtime = class {
             return ['00']; // Handle edge case for zero seconds
         const values = [];
         for (let i = minSecond; i <= maxSecond; i += secondStep) {
-            values.push(i.toString().padStart(2, '0'));
+            const secondStr = i.toString().padStart(2, '0');
+            values.push(secondStr);
         }
         return values;
     }
+    /**
+     * Parse second value from min/max constraint strings for dropdown generation only.
+     * This method is used exclusively for filtering dropdown options and should not
+     * affect input values or validation.
+     * @param {string} value - The time string to parse (e.g., "14:30:45" or "02:30:45")
+     * @returns {number} The parsed second number or null if invalid
+     */
     parseSecond(value) {
         if (!value)
             return null;
@@ -865,10 +904,6 @@ const NvFieldtime = class {
         const repetitions = Math.ceil(300 / totalOptions);
         return Array(repetitions).fill(options).flat();
     }
-    getCurrentTime() {
-        const currentTime = new Date();
-        return currentTime.toLocaleTimeString(); // Returns the time in the locale's format
-    }
     updateColumnHighlight(selector, value) {
         const items = Array.from(this.el.querySelectorAll(selector));
         const index = items.findIndex(x => x.textContent === value);
@@ -886,8 +921,13 @@ const NvFieldtime = class {
         }
         if (!this.open) {
             if (this.inputElements) {
-                (_a = this.inputElements[constants.TimeType.Hours]) === null || _a === void 0 ? void 0 : _a.focus();
-                (_b = this.inputElements[constants.TimeType.Hours]) === null || _b === void 0 ? void 0 : _b.select();
+                // Focus on the first visible field based on format
+                const visibleTypes = getVisibleTimeTypes(this.format);
+                const firstVisibleType = visibleTypes[0];
+                if (firstVisibleType && this.inputElements[firstVisibleType]) {
+                    (_a = this.inputElements[firstVisibleType]) === null || _a === void 0 ? void 0 : _a.focus();
+                    (_b = this.inputElements[firstVisibleType]) === null || _b === void 0 ? void 0 : _b.select();
+                }
             }
             event.preventDefault();
         }
@@ -897,17 +937,23 @@ const NvFieldtime = class {
     //#region LIFECYCLE
     componentWillLoad() {
         document.addEventListener('click', this.handleClickOutside.bind(this));
-        // If an initial value is passed, parse it
+        // Initialize component state based on format and value
         if (this.value) {
+            // Parse the provided value using format-aware parsing without constraint application
             this.parseTime(this.value);
         }
         else {
-            const minHour = this.parseHour(this.min, this.format) || '00';
-            const minMinute = this.parseMinute(this.min) || 0;
-            const minSecond = this.parseSecond(this.min) || 0;
-            this.hours = minHour.padStart(2, '0');
-            this.minutes = minMinute.toString().padStart(2, '0');
-            this.seconds = minSecond.toString().padStart(2, '0');
+            // Initialize with format-appropriate default values without any constraint application
+            // Use format-specific defaults: '01' for 12-hour formats, '00' for 24-hour formats
+            const defaultComponents = parseValueByFormat('', this.format);
+            // Set default values directly without any min/max constraint validation
+            this.hours = defaultComponents.hours;
+            this.minutes = defaultComponents.minutes;
+            this.seconds = defaultComponents.seconds;
+            // Set the initial value in the correct format without constraint validation
+            // This ensures the component has a proper initial state for the value watcher
+            const initialValue = reconstructTimeByFormat(defaultComponents, this.format);
+            this.value = initialValue;
         }
     }
     connectedCallback() {
@@ -917,63 +963,94 @@ const NvFieldtime = class {
         document.removeEventListener('click', this.handleClickOutside.bind(this));
     }
     componentDidLoad() {
-        if (!this.value) {
-            const currentTime = this.getCurrentTime();
-            // Split time into components
-            // eslint-disable-next-line prefer-const
-            let [hour, minute, secondAmPm] = currentTime.split(':');
-            let second, amPm;
-            // Check if AM/PM is present and split accordingly
-            if (secondAmPm.includes(' ')) {
-                [second, amPm] = secondAmPm.split(' ');
-            }
-            else {
-                second = secondAmPm;
-            }
-            // Parse hour as integer for calculations
-            let parsedHour = parseInt(hour, 10);
-            // Convert hour to 24-hour format based on AM/PM (if present)
-            if (amPm) {
-                if (amPm === 'PM' && parsedHour < 12) {
-                    parsedHour += 12; // Convert PM to 24-hour
-                }
-                else if (amPm === 'AM' && parsedHour === 12) {
-                    parsedHour = 0; // Midnight in 24-hour format
-                }
-            }
-            // Adjust for 12-hour format if necessary
-            if (this.format.startsWith('hh')) {
-                if (parsedHour === 0) {
-                    hour = '12'; // Midnight in 12-hour format
-                }
-                else if (parsedHour > 12) {
-                    hour = (parsedHour - 12).toString(); // Convert 24-hour to 12-hour
-                }
-                else {
-                    hour = parsedHour.toString();
-                }
-            }
-            else {
-                hour = parsedHour.toString(); // Use 24-hour format directly
-            }
-            // Pad hour, minute, and second to ensure two digits
-            hour = hour.padStart(2, '0');
-            minute = minute.padStart(2, '0');
-            second = second.padStart(2, '0');
-            // Update highlighted items for hours
-            const hourSelector = `.time-column.time-column-hours div`;
-            this.updateColumnHighlight(hourSelector, hour);
-            // Update highlighted items for minutes
-            const minuteSelector = `.time-column.time-column-minutes div`;
-            this.updateColumnHighlight(minuteSelector, minute);
-            // Update highlighted items for seconds
-            const secondSelector = `.time-column.time-column-seconds div`;
-            this.updateColumnHighlight(secondSelector, second);
-        }
+        // Initialize dropdown highlighting based on current component state
+        // This ensures proper visual feedback without applying any constraints
+        // Update highlighted items for hours based on current state
+        const hourSelector = `.time-column.time-column-hours div`;
+        this.updateColumnHighlight(hourSelector, this.hours);
+        // Update highlighted items for minutes based on current state
+        const minuteSelector = `.time-column.time-column-minutes div`;
+        this.updateColumnHighlight(minuteSelector, this.minutes);
+        // Update highlighted items for seconds based on current state
+        const secondSelector = `.time-column.time-column-seconds div`;
+        this.updateColumnHighlight(secondSelector, this.seconds);
     }
     //#endregion LIFECYCLE
     /****************************************************************************/
     //#region RENDER
+    /**
+     * Renders input fields based on the current format
+     * Only shows fields that are relevant to the selected format
+     * @returns {HTMLElement[]} Array of HTML elements for time input fields
+     */
+    renderTimeInputFields() {
+        const visibleTypes = getVisibleTimeTypes(this.format);
+        const elements = [];
+        visibleTypes.forEach((type, index$1) => {
+            // Add separator colon before minutes and seconds (but not before the first field)
+            if (index$1 > 0) {
+                elements.push(index.h("span", null, ":"));
+            }
+            // Add the input field for this time type
+            elements.push(this.renderTimeInputField(type));
+        });
+        return elements;
+    }
+    /**
+     * Renders a single time input field for the specified type
+     * @param {TimeType} type - The time type to render input for
+     * @returns {HTMLInputElement} HTML input element for the specified time type
+     */
+    renderTimeInputField(type) {
+        const getValue = () => {
+            switch (type) {
+                case constants.TimeType.Hours:
+                    return this.hours;
+                case constants.TimeType.Minutes:
+                    return this.minutes;
+                case constants.TimeType.Seconds:
+                    return this.seconds;
+                default:
+                    return '00';
+            }
+        };
+        const getPlaceholder = () => {
+            switch (type) {
+                case constants.TimeType.Hours:
+                    return this.format.includes('hh') ? 'hh' : 'HH';
+                case constants.TimeType.Minutes:
+                    return 'mm';
+                case constants.TimeType.Seconds:
+                    return 'ss';
+                default:
+                    return '';
+            }
+        };
+        const getId = () => {
+            switch (type) {
+                case constants.TimeType.Hours:
+                    return this.inputId;
+                case constants.TimeType.Minutes:
+                    return `${this.inputId}-minutes`;
+                case constants.TimeType.Seconds:
+                    return `${this.inputId}-seconds`;
+                default:
+                    return this.inputId;
+            }
+        };
+        // Remove min/max constraints from input elements to allow native stepper behavior
+        // Constraints are only applied to dropdown options, not input steppers
+        return (index.h("input", { ref: el => (this.inputElements[type] = el), type: "number", autofocus: this.autofocus && type === getVisibleTimeTypes(this.format)[0], class: "time-input", pattern: "[0-9]*", maxlength: "3", value: getValue(), onInput: e => this.handleInputChange(e, type), placeholder: getPlaceholder(), inputMode: "numeric", onFocus: () => this.handleFocus(type), name: this.name ? `${type}-${this.name}` : type, id: getId(), readonly: this.readonly, disabled: this.disabled, required: this.required, onKeyDown: e => this.handleKeyDown(e), onBlur: () => this.handleInputBlur() }));
+    }
+    /**
+     * Renders dropdown columns based on the current format
+     * Only shows columns that are relevant to the selected format
+     * @returns {HTMLElement[]} Array of HTML elements for time dropdown columns
+     */
+    renderTimeDropdownColumns() {
+        const visibleTypes = getVisibleTimeTypes(this.format);
+        return visibleTypes.map(type => this.RenderTimeOptionsColumn(type));
+    }
     RenderTimeOptionsColumn(type) {
         return (index.h("div", { class: `time-column time-column-${type}`, onScroll: e => this.handleScroll(e, type) }, this.generateInfiniteTimeOptions(type).map((option, index$1) => (index.h("div", { class: {
                 'time-option': true,
@@ -983,32 +1060,16 @@ const NvFieldtime = class {
             }, key: `${option}-${index$1}`, onClick: e => this.handleTimeOptionClick(e, type) }, option)))));
     }
     render() {
-        return (index.h(index.Host, { key: 'ef5f12cdbd62c18033f57ff176775b5ee62ebb85', onclick: e => this.handleHostClick(e) }, (this.label || this.el.querySelector('[slot="label"]')) && (index.h("label", { key: '64e20904debf287e69e5717f2d28ac4a700b7f15', htmlFor: this.inputId }, index.h("slot", { key: 'e0644a80e23854ca06baf8b52b00649a0e6f1ed9', name: "label" }, this.label))), index.h("nv-popover", { key: '98d71eeb73ce93c16c488e80f79bbe269a44ddc3', ref: el => (this.popoverElement = el), triggerMode: "controlled", placement: "bottom-start", open: this.open }, index.h("div", { key: '9a7d256f3c64aed3314338c8306540d92dddaad0', class: "input-wrapper", slot: "trigger" }, index.h("slot", { key: 'ac0e04737b86e4767e4c249ee95e4b69a41ea387', name: "before-input" }), index.h("div", { key: '1f04ff2f539048eb00500b2fbbeaf86ce1698065', class: "input-container" }, index.h("slot", { key: '60ee3a49ea9ca9509224c57dc64f3ccab7f89312', name: "leading-input" }), string_utils.startsWithIgnoreCase(this.format, 'HH') && [
-            index.h("input", { key: 'cb8a979ce6e4d83074e0c9046bbf3a60821e5262', ref: el => (this.inputElements[constants.TimeType.Hours] = el), type: "number", autofocus: this.autofocus, class: "time-input", pattern: "[0-9]*", maxlength: "3", value: this.hours, onInput: e => this.handleInputChange(e, constants.TimeType.Hours), placeholder: this.format.includes('hh') ? 'hh' : 'HH', inputMode: "numeric", onFocus: () => this.handleFocus(constants.TimeType.Hours), name: this.name
-                    ? `${constants.TimeType.Hours}-${this.name}`
-                    : constants.TimeType.Hours, id: this.inputId, readonly: this.readonly, disabled: this.disabled, required: this.required, onKeyDown: e => this.handleKeyDown(e), onBlur: () => this.handleInputBlur() }),
-        ], this.format.includes('mm') && [
-            index.h("span", { key: '74f9604ffd54e0c0bbd88996e32fdcb08f2c3645' }, ":"),
-            index.h("input", { key: '52f9b637bba804cac6fadff06e8b077bb2f5748a', ref: el => (this.inputElements[constants.TimeType.Minutes] = el), type: "number", autofocus: this.autofocus, class: "time-input", pattern: "[0-9]*", maxlength: "3", value: this.minutes, onInput: e => this.handleInputChange(e, constants.TimeType.Minutes), placeholder: "mm", inputMode: "numeric", onFocus: () => this.handleFocus(constants.TimeType.Minutes), name: this.name
-                    ? `${constants.TimeType.Minutes}-${this.name}`
-                    : constants.TimeType.Minutes, id: `${this.inputId}-minutes`, readonly: this.readonly, disabled: this.disabled, required: this.required, onKeyDown: e => this.handleKeyDown(e), onBlur: () => this.handleInputBlur() }),
-        ], this.format.includes('ss') && [
-            index.h("span", { key: '878bc9ce7557e9cf9471803a86956a9184d0ccb5' }, ":"),
-            index.h("input", { key: 'b074d4d3ef80f66e7dbe051b6bc53f151661f409', ref: el => (this.inputElements[constants.TimeType.Seconds] = el), type: "number", autofocus: this.autofocus, class: "time-input", pattern: "[0-9]*", maxlength: "3", value: this.seconds, onInput: e => this.handleInputChange(e, constants.TimeType.Seconds), placeholder: "ss", inputMode: "numeric", onFocus: () => this.handleFocus(constants.TimeType.Seconds), name: this.name
-                    ? `${constants.TimeType.Seconds}-${this.name}`
-                    : constants.TimeType.Seconds, id: `${this.inputId}-seconds`, readonly: this.readonly, disabled: this.disabled, required: this.required, onKeyDown: e => this.handleKeyDown(e), onBlur: () => this.handleInputBlur() }),
-        ], index.h("nv-iconbutton", { key: '3f5d78116ee60d1874a4629d9cf36a06d52b7df4', name: 'clock', size: "md", emphasis: "lower", "aria-label": this.open ? 'Hide time picker' : 'Show time picker', onClick: () => this.HandleDropdownIconClick() }), this.error && (index.h("nv-icon", { key: '4b2356cf95131af213a4e98feede16fc8c4963db', name: "alert-circle", class: "validation", size: "sm" })), this.success && (index.h("nv-icon", { key: 'f9b0e61037049a36ac900d1af9ecc71b211ebd88', name: "circle-check", class: "validation", size: "sm" }))), index.h("slot", { key: '6177abde559c57f2b0586368ead1a61d7b543838', name: "after-input" })), index.h("div", { key: 'f6d5205a5011411550179f9337143163cb547fb1', class: "time-dropdown", slot: "content" }, index.h("div", { key: '9f0b3e1423bef197b269c5b11ce744cabc2bd6c4', class: "time-columns" }, string_utils.startsWithIgnoreCase(this.format, 'HH') &&
-            this.RenderTimeOptionsColumn(constants.TimeType.Hours), this.format.includes('mm') &&
-            this.RenderTimeOptionsColumn(constants.TimeType.Minutes), this.format.includes('ss') &&
-            this.RenderTimeOptionsColumn(constants.TimeType.Seconds)))), (this.description ||
-            this.el.querySelector('[slot="description"]')) && (index.h("div", { key: '1076ded73b32ff9afbd0f02184febcc82f8d839e', class: "description" }, index.h("slot", { key: '479d09b299d0e380533a6cd689ce7f03aa92ea8e', name: "description" }, this.description))), (this.errorDescription ||
-            this.el.querySelector('[slot="error-description"]')) && (index.h("div", { key: '5615246dbd797c300be357be37d3b9d0aee56e31', hidden: !this.error, class: "error-description" }, index.h("slot", { key: '6568ea3f9e0bdf85dd280c645956f8e0bb592e35', name: "error-description" }, this.errorDescription)))));
+        return (index.h(index.Host, { key: 'f66fe2a29f23a0bc967821a0c9bca4347b622286', onclick: (e) => this.handleHostClick(e), "aria-expanded": this.open ? 'true' : 'false' }, (this.label || this.el.querySelector('[slot="label"]')) && (index.h("label", { key: 'f01ce1b034b1b547cbdde5814db9357ee1913e04', htmlFor: this.inputId }, index.h("slot", { key: 'd81dcb20883b93280db6e76e0299f679f1f9ed84', name: "label" }, this.label))), index.h("nv-popover", { key: '8c9e83002edcfba89ca4ca282fc82db714ed2f43', ref: el => (this.popoverElement = el), triggerMode: "controlled", placement: "bottom-start", open: this.open }, index.h("div", { key: '3a5b26e4be67f277ead2a9fe2f04e5d12a4bd596', class: "input-wrapper", slot: "trigger" }, index.h("slot", { key: '2ea5f8269c6f0892c53a002a298ca3ceed8f8a00', name: "before-input" }), index.h("div", { key: 'ab97bbbf183118d7b510f82c800b4a3fa1fefda3', class: "input-container" }, index.h("slot", { key: 'a80d2f68b24d4226c18bf0df18ebf13ac6e0873e', name: "leading-input" }), this.renderTimeInputFields(), index.h("nv-iconbutton", { key: '1f7aacf1ab073c0c6ef10b50e948a7ecbca4dd75', name: 'clock', size: "md", emphasis: "lower", "aria-label": this.open ? 'Hide time picker' : 'Show time picker', onClick: () => this.HandleDropdownIconClick() }), this.error && (index.h("nv-icon", { key: '8f414a3b3daae6f0625b3c62b920621bf8698db3', name: "alert-circle", class: "validation", size: "sm" })), this.success && (index.h("nv-icon", { key: '13b5671664466b6bb50f2561b5cffb96517a1068', name: "circle-check", class: "validation", size: "sm" }))), index.h("slot", { key: 'b5d6085a9864ef84d4113062a0b1cb8a807ab241', name: "after-input" })), index.h("div", { key: '2950c5fac3a0f219e5db2e3a7e9f605d86e50aa2', class: "time-dropdown", slot: "content" }, index.h("div", { key: 'c5b7ff3818a05e1f6d7ca76657f57b85bb595345', class: "time-columns" }, this.renderTimeDropdownColumns()))), (this.description ||
+            this.el.querySelector('[slot="description"]')) && (index.h("div", { key: 'c8cb90fad74721a9b5eb0ab50980f3fd7c587e62', class: "description" }, index.h("slot", { key: '641d1a6a9dbf580267664831d5b371a601afb039', name: "description" }, this.description))), (this.errorDescription ||
+            this.el.querySelector('[slot="error-description"]')) && (index.h("div", { key: '5721b81d7a16b626bfa7c3af20897f33b7c37080', hidden: !this.error, class: "error-description" }, index.h("slot", { key: '84cef1043666ab6dd86f70d4ba0054d7f33ca589', name: "error-description" }, this.errorDescription)))));
     }
     static get formAssociated() { return true; }
     get el() { return index.getElement(this); }
     static get watchers() { return {
         "value": ["handleValueChange"],
-        "open": ["handleOpenChange"]
+        "open": ["handleOpenChange"],
+        "format": ["handleFormatChange"]
     }; }
 };
 NvFieldtime.style = NvFieldtimeStyle0;