@watermarkinsights/ripple 0.0.1 → 0.1.0-alpha.1

package/dist/collection/components/wm-timepicker/wm-timepicker.js

@@ -0,0 +1,728 @@
+import { h, Host } from "@stencil/core";
+import { intl, shouldOpenUp, toBool, handleDisabledAttribute, showTooltip, hideTooltip } from "../../global/functions";
+/**
+ * Time input that lets users type a time or pick one from a dropdown list of 15-minute
+ * intervals. Supports 12-hour and 24-hour display and provides `reformatTime` and
+ * `isValidTime` utility methods. Use instead of native `<input type="time">`.
+ *
+ * @category Form Inputs
+ *
+ * @keyboardInteraction
+ * **Input field:**
+ * - **Arrow Down / Arrow Up**: Open the dropdown focused on the nearest time interval.
+ *
+ * **Dropdown button:**
+ * - **Enter / Space**: Open the dropdown.
+ *
+ * **Dropdown list:**
+ * - **Arrow Down / Arrow Up**: Move focus to the next/previous option; wraps at both ends.
+ * - **Home / End**: Move focus to the first/last option.
+ * - **Enter / Space**: Select the focused time and close the dropdown.
+ * - **Tab**: Close the dropdown and advance focus (without selecting).
+ * - **Escape**: Close the dropdown without selecting.
+ *
+ * @accessibility
+ * - `label` sets the accessible name on the input; required even when `label-position="none"`.
+ * - Error messages are announced via an `aria-live` region.
+ *
+ * @usageNotes
+ * - The dropdown displays 15-minute intervals (00:00–23:45) in 12-hour format; typed input
+ *   is accepted in both 12-hour and 24-hour formats.
+ * - `wmTimepickerTimeSelected` emits `{ time: string }` in 24-hour `hh:mm` format. Always
+ *   call `reformatTime("12", ...)` on the result and write it back to `value` so the input
+ *   displays the formatted string.
+ * - Use `reformatTime` and `isValidTime` via an imperative ref — they are async component
+ *   methods, not props.
+ * - When writing a curried event-handler factory, the outer function must NOT be async;
+ *   only the inner handler should be async, otherwise the factory returns a Promise instead
+ *   of a function.
+ *
+ * @example {html} Basic timepicker
+ * <wm-timepicker label="Start time"></wm-timepicker>
+ *
+ * @example {react} Basic timepicker
+ * // wmTimepickerTimeSelected emits { time } in 24hr format.
+ * // Call reformatTime and write back to value so the input displays the result.
+ * // handleInputBlur validates free-form typed input on blur using isValidTime.
+ * // NOTE: the outer factory function must NOT be async — only the inner handler should be.
+ * const startRef = useRef(null);
+ * const [startValue, setStartValue] = useState("");
+ * const [startError, setStartError] = useState("");
+ *
+ * const handleTimeSelected = (ref, setValue, setError) => async (e) => {
+ *   const time12 = await ref.current.reformatTime("12", e.detail.time);
+ *   setError("");
+ *   setValue(time12);
+ * };
+ *
+ * const handleInputBlur = (ref, value, setValue, setError) => async () => {
+ *   if (!value) return;
+ *   const valid = await ref.current.isValidTime(value);
+ *   if (valid) {
+ *     const time12 = await ref.current.reformatTime("12", value);
+ *     setError("");
+ *     setValue(time12);
+ *   } else {
+ *     setError("Please enter a valid time.");
+ *   }
+ * };
+ *
+ * <WmTimepicker
+ *   ref={startRef}
+ *   label="Start time"
+ *   value={startValue}
+ *   errorMessage={startError}
+ *   onWmTimepickerTimeSelected={handleTimeSelected(startRef, setStartValue, setStartError)}
+ *   onWmTimepickerInputBlurred={handleInputBlur(startRef, startValue, setStartValue, setStartError)}
+ * />
+ *
+ * @example {html} With pre-selected time
+ * <wm-timepicker label="Meeting time" preselected="14:30" value="2:30 PM"></wm-timepicker>
+ *
+ * @example {react} With pre-selected time
+ * // preselected (24hr) controls where the dropdown focuses on open.
+ * // value sets the initial display string in the input.
+ * const meetingRef = useRef(null);
+ * const [meetingValue, setMeetingValue] = useState("2:30 PM");
+ * const [meetingError, setMeetingError] = useState("");
+ *
+ * <WmTimepicker
+ *   ref={meetingRef}
+ *   label="Meeting time"
+ *   preselected="14:30"
+ *   value={meetingValue}
+ *   errorMessage={meetingError}
+ *   onWmTimepickerTimeSelected={handleTimeSelected(meetingRef, setMeetingValue, setMeetingError)}
+ *   onWmTimepickerInputBlurred={handleInputBlur(meetingRef, meetingValue, setMeetingValue, setMeetingError)}
+ * />
+ *
+ */
+export class Timepicker {
+    constructor() {
+        this.twelveHrValid = /^(0?[0-9]|1[0-2])\s*:?\s*([0-5][0-9])?\s?(a|p|am|pm)?$/i;
+        this.twentyFourHrValid = /^(0?[0-9]|1[0-9]|2[0-4])\s*:?\s*([0-5][0-9])?$/;
+        this.timeFormat = "hh:mm";
+        this.times = this.generateTimeIntervals();
+        this.openUp = false;
+        this.buttonAriaLabel = intl.formatMessage({
+            id: "time.selectTime",
+            defaultMessage: "Select time",
+            description: "Button text for screen readers.",
+        });
+        this.disabled = false;
+        this.value = "";
+        this.errorMessage = undefined;
+        this.label = "";
+        this.labelPosition = "top";
+        this.requiredField = false;
+        this.preselected = undefined;
+        this.isExpanded = false;
+    }
+    get selectedOption() {
+        return this.optionsList.filter((option) => option.tabIndex === 0)[0];
+    }
+    get optionsList() {
+        return Array.from(this.optionsEl.querySelectorAll("li"));
+    }
+    get isDisabled() {
+        // string "false" needs to be treated as bool False because react wrappers convert bool to string.
+        return toBool(this.disabled);
+    }
+    /**
+     * @description Validates a time string against both 12-hour and 24-hour formats.
+     * @param input The time string to validate.
+     * @returns `true` if the string is a valid time, `false` otherwise.
+     */
+    async isValidTime(input) {
+        return this.isValidTimeInternal(input);
+    }
+    isValidTimeInternal(input) {
+        return this.twelveHrValid.test(input) || this.twentyFourHrValid.test(input);
+    }
+    /**
+     * @description Converts a time string between 12-hour and 24-hour formats.
+     * @param format The target format: `"12"` for 12-hour (e.g. `"02:30 PM"`), `"24"` for
+     *   24-hour (e.g. `"14:30"`).
+     * @param time The time string to convert. Accepts both 12-hour and 24-hour input.
+     * @returns The reformatted time string.
+     */
+    async reformatTime(format, time) {
+        return this.reformatTimeInternal(format, time);
+    }
+    announce(message) {
+        if (this.liveRegionEl.textContent === message) {
+            message += "\u00A0";
+        }
+        this.liveRegionEl.textContent = message;
+    }
+    reformatTimeInternal(format, time) {
+        let [hours, minutes, amPm] = this.splitTime(time);
+        if (format === "12") {
+            if (hours === 12 && !amPm) {
+                amPm = "PM";
+            }
+            if (hours === 0 || hours === 24) {
+                hours = 12;
+            }
+            if (hours > 12) {
+                hours -= 12;
+                amPm = "PM";
+            }
+            if (amPm && amPm.toUpperCase().includes("P")) {
+                amPm = "PM";
+            }
+            else {
+                amPm = "AM";
+            }
+            return `${hours.toString().padStart(2, "0")}:${minutes} ${amPm}`;
+        }
+        else if (format === "24") {
+            if (hours === 24) {
+                hours = 0;
+            }
+            if (hours === 12 && amPm && amPm.toUpperCase().includes("A")) {
+                hours -= 12;
+            }
+            if (amPm && amPm.toUpperCase().includes("P") && hours !== 12) {
+                hours += 12;
+            }
+            return `${hours.toString().padStart(2, "0")}:${minutes}`;
+        }
+        else {
+            return time;
+        }
+    }
+    handleKey(ev) {
+        switch (ev.key) {
+            case "ArrowDown":
+                ev.preventDefault();
+                if (this.isExpanded === false) {
+                    this.open("next");
+                }
+                else {
+                    this.moveNext(this.selectedOption);
+                }
+                break;
+            case "ArrowUp":
+                ev.preventDefault();
+                if (this.isExpanded === false) {
+                    this.open("previous");
+                }
+                else {
+                    this.movePrevious(this.selectedOption);
+                }
+                break;
+            case "Enter":
+            case " ":
+                if (this.isExpanded) {
+                    ev.preventDefault();
+                    this.handleOptionClick(this.selectedOption.dataset.time);
+                }
+                break;
+            case "Escape":
+                ev.preventDefault();
+                if (this.isExpanded) {
+                    ev.stopPropagation(); // for instance if select is in a modal, esc should close the select but not the modal
+                    this.close();
+                }
+                break;
+            case "Tab":
+                if (this.isExpanded) {
+                    this.close(false);
+                }
+                break;
+            case "Home":
+                ev.preventDefault();
+                if (this.isExpanded) {
+                    this.focusOption(this.optionsList[0]);
+                }
+                break;
+            case "End":
+                ev.preventDefault();
+                if (this.isExpanded) {
+                    this.focusOption(this.optionsList[this.optionsList.length - 1]);
+                }
+                break;
+        }
+    }
+    handleDisabledChange() {
+        handleDisabledAttribute(this.el, this.isDisabled);
+    }
+    handleValueChange() {
+        this.inputEl.value = this.value ? this.value : "";
+    }
+    announceError() {
+        if (this.errorMessage) {
+            setTimeout(() => this.announce(this.errorMessage), 100);
+        }
+    }
+    componentWillLoad() {
+        if (this.label === "") {
+            console.error("You must include a label prop for the timepicker (for accessibility reasons), even if the label position is none.");
+        }
+        this.timeFormat = intl.formatMessage({
+            id: "time.timeFormat",
+            defaultMessage: "hh:mm",
+        });
+        handleDisabledAttribute(this.el, this.isDisabled);
+    }
+    componentDidLoad() {
+        this.optionsEl.classList.add("hidden");
+    }
+    handleOptionClick(time) {
+        this.close();
+        this.wmTimepickerTimeSelected.emit({ time: time });
+    }
+    handleInputBlur() {
+        this.wmTimepickerInputBlurred.emit();
+        this.tpWrapper.classList.remove("focus");
+    }
+    handleLabelMouseEnter(ev) {
+        const labelEl = ev.target;
+        if (labelEl.scrollWidth > labelEl.clientWidth) {
+            showTooltip("right", ev.target, this.label);
+        }
+    }
+    generateTimeIntervals() {
+        let timeIntervals = [];
+        let startTime = 0;
+        for (let i = 0; startTime < 24 * 60; i++) {
+            const h = Math.floor(startTime / 60);
+            const hour = h.toString().padStart(2, "0");
+            const m = (startTime % 60).toString();
+            const min = m.padStart(2, "0");
+            timeIntervals[i] = `${hour}:${min}`;
+            startTime = startTime + 15;
+        }
+        return timeIntervals;
+    }
+    splitTime(time) {
+        const splitTime = this.twelveHrValid.exec(time) || this.twentyFourHrValid.exec(time);
+        let hours = parseInt(splitTime[1]);
+        let minutes = splitTime[2] || "00";
+        let amPm = splitTime ? splitTime[3] : undefined;
+        // handles edge case uncaught by regex '0pm'
+        if (hours === 0 && (amPm === null || amPm === void 0 ? void 0 : amPm.toUpperCase().includes("P"))) {
+            // if user types '0pm' we change it to midnight
+            amPm = "AM";
+        }
+        return [hours, minutes, amPm];
+    }
+    open(itemToSelect) {
+        this.openUp = shouldOpenUp(this.el, this.optionsEl.clientHeight);
+        this.isExpanded = true;
+        this.optionsEl.classList.remove("hidden");
+        // focus hierarchy: preselected prop -> parsed time -> 09:00
+        let focusOnOpenEl = this.optionsList[36]; // 09:00
+        if (this.preselected) {
+            focusOnOpenEl = this.optionsList.filter((option) => option.dataset.time == this.preselected)[0];
+        }
+        else if (this.isValidTimeInternal(this.value)) {
+            const nearestTime = this.findNearestTimeInterval(this.reformatTimeInternal("24", this.value));
+            focusOnOpenEl = this.optionsList.filter((option) => option.dataset.time == nearestTime)[0];
+        }
+        // position option in center of dropdown
+        this.optionsEl.scrollTop =
+            (this.optionsList.findIndex((x) => x.textContent === (focusOnOpenEl === null || focusOnOpenEl === void 0 ? void 0 : focusOnOpenEl.textContent)) - 2) *
+                focusOnOpenEl.offsetHeight;
+        this.focusOption(focusOnOpenEl);
+        window.requestAnimationFrame(() => {
+            if (itemToSelect === "next") {
+                this.moveNext(this.selectedOption);
+            }
+            else if (itemToSelect === "previous") {
+                this.movePrevious(this.selectedOption);
+            }
+        });
+    }
+    close(returnFocus = true) {
+        this.isExpanded = false;
+        window.setTimeout(() => {
+            this.optionsEl.classList.add("hidden");
+            // Returns focus to button after popup closes (no need if user is tabbing)
+            // Delay is necessary for screenreader to get new expanded state before focus
+            // window.requestAnimationFrame is probably enough, but since we are already using setTimeout it may as well be here
+            // also UX wise, it makes sense for the button to only be focused after the animation is complete
+            if (returnFocus) {
+                this.buttonEl.focus();
+            }
+        }, 150);
+    }
+    focusOption(item) {
+        this.optionsList.forEach((option) => {
+            option.tabIndex = -1;
+        });
+        item.tabIndex = 0;
+        item.scrollIntoView({ block: "nearest" });
+        item.focus();
+    }
+    movePrevious(optionEl) {
+        this.focusOption(optionEl.previousElementSibling
+            ? optionEl.previousElementSibling
+            : this.optionsList[this.optionsList.length - 1]);
+    }
+    moveNext(optionEl) {
+        this.focusOption(optionEl.nextElementSibling ? optionEl.nextElementSibling : this.optionsList[0]);
+    }
+    findNearestTimeInterval(time) {
+        // accepts time in 24hr format
+        const minutes = parseInt(time.slice(3, 5));
+        // first find the closest 15 min increment
+        if (minutes % 15 !== 0) {
+            const hour = parseInt(time.slice(0, 2));
+            let roundedMinutes = (Math.round(minutes / 15) * 15).toString().padStart(2, "0");
+            if (roundedMinutes === "60") {
+                roundedMinutes = "00";
+                let roundedHour = hour + 1;
+                if (roundedHour === 24) {
+                    roundedHour = 0;
+                }
+                time = time.replace(`${hour.toString().padStart(2, "0")}:`, `${roundedHour.toString().padStart(2, "0")}:`);
+            }
+            if (parseInt(roundedMinutes) < 8) {
+                roundedMinutes = "00";
+            }
+            time = time.replace(`:${minutes.toString().padStart(2, "0")}`, `:${roundedMinutes}`);
+        }
+        return time;
+    }
+    renderOptions() {
+        return this.times.map((time, index) => (h("li", { id: `option${index + 1}`, "data-time": time, role: "option", onClick: () => this.handleOptionClick(time) }, this.reformatTimeInternal("12", time))));
+    }
+    render() {
+        return (h(Host, { key: '465a66ad7ca35812ed08210a1314e9045ce9d132', onBlur: () => this.close(false) }, h("div", { key: 'd47ce73ca7efcfd7f23b0db03b4a451a2dac4446', class: `wrapper label-${this.labelPosition} ${!!this.errorMessage ? "invalid" : ""}`, ref: (t) => (this.tpWrapper = t) }, h("div", { key: '9f28f2d4604301c40a1546c972e8063c6d8d3866', class: "label-wrapper" }, this.labelPosition !== "none" && (h("label", { key: '302946f368394139d04de0837cc0f5a9dc9f5d01', id: "label", class: "label", htmlFor: "time-input", onMouseEnter: (ev) => this.handleLabelMouseEnter(ev), onMouseLeave: () => hideTooltip() }, this.label)), this.labelPosition !== "none" && this.requiredField && (h("div", { key: 'a13ad11e096383e3f54fe4e9c058a72f4f1f23d8', "aria-hidden": "true", class: "required" }, "*"))), h("div", { key: 'e2505ced2cd45326f1d66de36aceebf177a1a159' }, h("div", { key: '838fa98f05e0fa033f10fec973eba5cbb64cfb84', class: "inner-wrapper" }, h("input", { key: '6e11818266217669281b105b38a746cee3add730', id: "time-input", "aria-label": this.label, "aria-describedby": "error", ref: (el) => (this.inputEl = el), onBlur: () => this.handleInputBlur(), onInput: () => (this.value = this.inputEl.value), disabled: this.isDisabled, "aria-required": this.requiredField ? "true" : null, placeholder: this.timeFormat, autocomplete: "off", value: this.value, onFocus: () => this.tpWrapper.classList.add("focus") }), h("button", { key: '4be47c23c8929847bd36289b103d14a52893e8ff', id: "btn", ref: (el) => (this.buttonEl = el), disabled: this.isDisabled, "aria-controls": "list", "aria-expanded": this.isExpanded ? "true" : "false", "aria-label": this.buttonAriaLabel, "aria-describedby": "time-input", onClick: () => (this.isExpanded ? this.close() : this.open()),
+            // This addresses an issue in Safari, where clicking buttons does not focus them
+            // if the button does not receive focus when clicked, Timepicker incorrectly emits a blur event
+            onMouseDown: (ev) => {
+                ev.preventDefault();
+                this.buttonEl.focus();
+            } }, h("span", { key: '584530b0cd9714d70fbfcaa4ea8e2eece6b35492', class: "svg-icon svg-time" })), h("ul", { key: 'de8dece352fe83eb8107d5f98af3f6e9a4085e88', class: `options ${this.isExpanded ? "open" : ""}  ${this.openUp ? "upwards" : ""}`, id: "list", role: "listbox", "aria-labelledby": "label", "aria-describedby": this.isExpanded ? "collapsed" : null, tabindex: -1, ref: (el) => (this.optionsEl = el) }, this.renderOptions())), h("div", { key: '951d548bdc145d5902b8ec30dbf5342207408bec', id: "error", class: "error" }, this.errorMessage)), h("div", { key: '820b447b0fa475bce5ed5a5d661e19d8ed9203d8', id: "live-polite", class: "sr-only", "aria-live": "polite", "aria-atomic": "true", ref: (el) => (this.liveRegionEl = el) }))));
+    }
+    static get is() { return "wm-timepicker"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["wm-timepicker.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["wm-timepicker.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Disables the timepicker, preventing all interaction."
+                        }, {
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": ""
+                },
+                "attribute": "disabled",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "value": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "The time displayed in the input field. Updated as the user types. Can also\nbe set programmatically by the application."
+                        }, {
+                            "name": "default",
+                            "text": "\"\""
+                        }],
+                    "text": ""
+                },
+                "attribute": "value",
+                "reflect": false,
+                "defaultValue": "\"\""
+            },
+            "errorMessage": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Puts the component in an error state and displays this message below the\ninput."
+                        }],
+                    "text": ""
+                },
+                "attribute": "error-message",
+                "reflect": false
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Accessible label for the input. Required even when `label-position=\"none\"`."
+                        }, {
+                            "name": "required",
+                            "text": undefined
+                        }],
+                    "text": ""
+                },
+                "attribute": "label",
+                "reflect": false,
+                "defaultValue": "\"\""
+            },
+            "labelPosition": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "\"top\" | \"left\" | \"none\"",
+                    "resolved": "\"left\" | \"none\" | \"top\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Controls label placement. `'none'` hides the label visually but keeps it\naccessible."
+                        }, {
+                            "name": "default",
+                            "text": "\"top\""
+                        }],
+                    "text": ""
+                },
+                "attribute": "label-position",
+                "reflect": false,
+                "defaultValue": "\"top\""
+            },
+            "requiredField": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Displays a required-field asterisk next to the label."
+                        }, {
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": ""
+                },
+                "attribute": "required-field",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "preselected": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "The time the dropdown scrolls to and focuses when opened, in 24-hour format\n(e.g. `'14:30'`). Falls back to parsing `value`; defaults to `'09:00'` if unparseable."
+                        }],
+                    "text": ""
+                },
+                "attribute": "preselected",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isExpanded": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "wmTimepickerInputBlurred",
+                "name": "wmTimepickerInputBlurred",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Fires when the input field loses focus."
+                        }],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "wmTimepickerTimeSelected",
+                "name": "wmTimepickerTimeSelected",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "description",
+                            "text": "Fires when the user selects a time from the dropdown list."
+                        }, {
+                            "name": "eventDetails",
+                            "text": "{{ time: string }} time \u2014 the selected time in 24-hour `hh:mm` format."
+                        }],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "isValidTime": {
+                "complexType": {
+                    "signature": "(input: string) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "input",
+                            "type": "string",
+                            "docs": "The time string to validate."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": [{
+                            "name": "description",
+                            "text": "Validates a time string against both 12-hour and 24-hour formats."
+                        }, {
+                            "name": "param",
+                            "text": "input The time string to validate."
+                        }, {
+                            "name": "returns",
+                            "text": "`true` if the string is a valid time, `false` otherwise."
+                        }]
+                }
+            },
+            "reformatTime": {
+                "complexType": {
+                    "signature": "(format: \"12\" | \"24\", time: TimeFormat12 | TimeFormat24) => Promise<string>",
+                    "parameters": [{
+                            "name": "format",
+                            "type": "\"12\" | \"24\"",
+                            "docs": "The target format: `\"12\"` for 12-hour (e.g. `\"02:30 PM\"`), `\"24\"` for\n24-hour (e.g. `\"14:30\"`)."
+                        }, {
+                            "name": "time",
+                            "type": "string",
+                            "docs": "The time string to convert. Accepts both 12-hour and 24-hour input."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "TimeFormat12": {
+                            "location": "import",
+                            "path": "../../global/interfaces",
+                            "id": "src/global/interfaces.ts::TimeFormat12"
+                        },
+                        "TimeFormat24": {
+                            "location": "import",
+                            "path": "../../global/interfaces",
+                            "id": "src/global/interfaces.ts::TimeFormat24"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": [{
+                            "name": "description",
+                            "text": "Converts a time string between 12-hour and 24-hour formats."
+                        }, {
+                            "name": "param",
+                            "text": "format The target format: `\"12\"` for 12-hour (e.g. `\"02:30 PM\"`), `\"24\"` for\n24-hour (e.g. `\"14:30\"`)."
+                        }, {
+                            "name": "param",
+                            "text": "time The time string to convert. Accepts both 12-hour and 24-hour input."
+                        }, {
+                            "name": "returns",
+                            "text": "The reformatted time string."
+                        }]
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "disabled",
+                "methodName": "handleDisabledChange"
+            }, {
+                "propName": "value",
+                "methodName": "handleValueChange"
+            }, {
+                "propName": "errorMessage",
+                "methodName": "announceError"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "keydown",
+                "method": "handleKey",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}