@vonage/vivid 5.15.0 → 5.16.0

package/unbundled/definition37.js

@@ -0,0 +1,225 @@
+import { o as defineVividComponent, s as createRegisterFunction } from "./vivid-element.js";
+import { n as visuallyHiddenDefinition } from "./definition.js";
+import { t as __decorate } from "./decorate.js";
+import { t as buttonDefinition } from "./definition7.js";
+import { t as popupDefinition } from "./definition10.js";
+import { n as textFieldDefinition } from "./definition25.js";
+import { t as dividerDefinition } from "./definition34.js";
+import { n as PickerField, r as picker_field_default, t as PickerFieldTemplate } from "./picker-field.template.js";
+import { a as formatPresentationDate, c as currentDateStr, i as CalendarPicker, l as isValidDateStr, o as parsePresentationDate, r as ValidDateFilter, s as compareDateStr, t as CalendarPickerTemplate, u as calendar_picker_default } from "./calendar-picker.template.js";
+import { t as SingleValuePicker } from "./single-value-picker.js";
+import { t as SingleDatePickerMixin } from "./single-date-picker.js";
+import { a as formatPresentationTime, c as compareTimeStr, i as TimeSelectionPicker, l as isValidTimeStr, o as parsePresentationTime, r as ValidTimeFilter, s as inlineTimePickerDefinition, t as TimeSelectionPickerTemplate } from "./time-selection-picker.template.js";
+import { attr, html } from "@microsoft/fast-element";
+//#region src/lib/date-time-picker/date-time-picker.scss?inline
+var date_time_picker_default = ".date-time-picker{gap:28px;padding-inline-start:12px;display:flex}.time-picker{padding-block:4px 12px}";
+//#endregion
+//#region src/shared/datetime/dateTimeStr.ts
+var extractDatePart = (dateTimeStr) => dateTimeStr.split("T")[0] || "";
+var extractTimePart = (dateTimeStr) => dateTimeStr.split("T")[1] || "";
+var isValidDateTimeStr = (string) => {
+	const [dateStr = "", timeStr = ""] = string.split("T");
+	return isValidDateStr(dateStr) && isValidTimeStr(timeStr);
+};
+//#endregion
+//#region src/shared/datetime/presentationDateTime.ts
+var formatPresentationDateTime = (dateTimeStr, locale, includeSeconds, use12HourClock) => {
+	const [dateStr, timeStr] = dateTimeStr.split("T");
+	return `${formatPresentationDate(dateStr, locale)} ${formatPresentationTime(timeStr, includeSeconds, use12HourClock)}`;
+};
+/**
+* Attempts to parse user input as date time.
+* Throws if input can't be parsed.
+*/
+var parsePresentationDateTime = (presentationDateTime, locale, use12HourClock) => {
+	const [datePart, ...timeParts] = presentationDateTime.split(" ");
+	return `${parsePresentationDate(datePart, locale)}T${parsePresentationTime(timeParts.join(" "), use12HourClock)}`;
+};
+//#endregion
+//#region src/lib/date-time-picker/date-time-picker.ts
+var ValidDateTimeFilter = {
+	fromView: (value) => {
+		if (value && isValidDateTimeStr(value)) return value;
+		return "";
+	},
+	toView(value) {
+		return value;
+	}
+};
+/**
+* Single date picker component.
+*
+* @public
+* @component date-time-picker
+* @slot helper-text - Describes how to use the date-picker. Alternative to the `helper-text` attribute.
+* @event {CustomEvent<undefined>} input - Emitted when the date is changed by the user.
+* @event {CustomEvent<undefined>} change - Emitted when the date is changed by the user.
+* @vueModel modelValue value input `event.currentTarget.value`
+* @testAction selectDateTime selectDateTime
+*/
+var DateTimePicker = class extends TimeSelectionPicker(SingleDatePickerMixin(SingleValuePicker(CalendarPicker(PickerField)))) {
+	get _resolvedMinDate() {
+		return this.minDate || extractDatePart(this.min);
+	}
+	get _resolvedMaxDate() {
+		return this.maxDate || extractDatePart(this.max);
+	}
+	get _resolvedMinTime() {
+		return this.minTime || this.min && extractDatePart(this.min) === this._dateValue() && extractTimePart(this.min) || "";
+	}
+	get _resolvedMaxTime() {
+		return this.maxTime || this.max && extractDatePart(this.max) === this._dateValue() && extractTimePart(this.max) || "";
+	}
+	/**
+	* @internal
+	*/
+	_toPresentationValue(value) {
+		return formatPresentationDateTime(value, this.locale.calendarPicker, this._displaySeconds, this._use12hClock);
+	}
+	/**
+	* @internal
+	*/
+	_parsePresentationValue(presentationValue) {
+		return parsePresentationDateTime(presentationValue, this.locale.calendarPicker, this._use12hClock);
+	}
+	/**
+	* @internal
+	*/
+	_dateValue() {
+		return extractDatePart(this.value);
+	}
+	/**
+	* @internal
+	*/
+	_withUpdatedDate(dateStr) {
+		return `${dateStr}T${extractTimePart(this.value) || "00:00:00"}`;
+	}
+	/**
+	* @internal
+	*/
+	get _timeValue() {
+		return extractTimePart(this.value);
+	}
+	/**
+	* @internal
+	*/
+	_withUpdatedTime(timeStr) {
+		return `${extractDatePart(this.value) || currentDateStr()}T${timeStr}`;
+	}
+	constructor() {
+		super();
+		this._isValidValue = isValidDateTimeStr;
+		this._textFieldSize = "30";
+		this.proxy.type = "datetime-local";
+		this.proxy.step = "1";
+		this.min = "";
+		this.minDate = "";
+		this.minTime = "";
+		this.max = "";
+		this.maxDate = "";
+		this.maxTime = "";
+	}
+	/**
+	* @internal
+	*/
+	_getCustomValidationError() {
+		if (this._isPresentationValueInvalid()) return this.locale.dateTimePicker.invalidDateTimeError;
+		if (this._dateValue() && this._resolvedMinDate && compareDateStr(this._dateValue(), this._resolvedMinDate) < 0) return this.locale.dateTimePicker.dateBeforeMinDateError(formatPresentationDate(this._resolvedMinDate, this.locale.calendarPicker));
+		if (this._dateValue() && this._resolvedMaxDate && compareDateStr(this._dateValue(), this._resolvedMaxDate) > 0) return this.locale.dateTimePicker.dateAfterMaxDateError(formatPresentationDate(this._resolvedMaxDate, this.locale.calendarPicker));
+		if (this._timeValue && this._resolvedMinTime && compareTimeStr(this._timeValue, this._resolvedMinTime) < 0) return this.locale.dateTimePicker.timeBeforeMinTimeError(formatPresentationTime(this._resolvedMinTime, this._displaySeconds, this._use12hClock));
+		if (this._timeValue && this._resolvedMaxTime && compareTimeStr(this._timeValue, this._resolvedMaxTime) > 0) return this.locale.dateTimePicker.timeAfterMaxTimeError(formatPresentationTime(this._resolvedMaxTime, this._displaySeconds, this._use12hClock));
+		return null;
+	}
+	/**
+	* @internal
+	*/
+	get _textFieldPlaceholder() {
+		return `${this.locale.calendarPicker.dateFormatPlaceholder} ${this._timePlaceholder}`;
+	}
+	/**
+	* @internal
+	*/
+	get _pickerButtonLabel() {
+		if (this.value) return this.locale.dateTimePicker.changeDateTimeLabel(this._toPresentationValue(this.value));
+		else return this.locale.dateTimePicker.chooseDateTimeLabel;
+	}
+	/**
+	* @internal
+	*/
+	_focusableElsWithinDialog() {
+		return this._dialogEl.querySelectorAll("#inline-time-picker, button, .vwc-button");
+	}
+	/**
+	* @internal
+	*/
+	get _pickerButtonIcon() {
+		return "calendar-clock-line";
+	}
+	/**
+	* @internal
+	*/
+	get _dialogLabel() {
+		return this.locale.dateTimePicker.chooseDateTimeLabel;
+	}
+};
+__decorate([attr({ converter: ValidDateTimeFilter })], DateTimePicker.prototype, "min", void 0);
+__decorate([attr({
+	converter: ValidTimeFilter,
+	attribute: "min-time"
+})], DateTimePicker.prototype, "minTime", void 0);
+__decorate([attr({
+	converter: ValidDateFilter,
+	attribute: "min-date"
+})], DateTimePicker.prototype, "minDate", void 0);
+__decorate([attr({ converter: ValidDateTimeFilter })], DateTimePicker.prototype, "max", void 0);
+__decorate([attr({
+	converter: ValidTimeFilter,
+	attribute: "max-time"
+})], DateTimePicker.prototype, "maxTime", void 0);
+__decorate([attr({
+	converter: ValidDateFilter,
+	attribute: "max-date"
+})], DateTimePicker.prototype, "maxDate", void 0);
+//#endregion
+//#region src/lib/date-time-picker/date-time-picker.template.ts
+var DateTimePickerTemplate = (context) => {
+	return PickerFieldTemplate(context, html`
+			<div class="date-time-picker">
+				${() => CalendarPickerTemplate(context)}
+				<div class="time-picker">
+					${() => TimeSelectionPickerTemplate(context, 9)}
+				</div>
+			</div>
+		`, {
+		withSeparator: false,
+		padded: false
+	});
+};
+//#endregion
+//#region src/lib/date-time-picker/definition.ts
+/**
+* @internal
+*/
+var dateTimePickerDefinition = defineVividComponent("date-time-picker", DateTimePicker, DateTimePickerTemplate, [
+	buttonDefinition,
+	popupDefinition,
+	textFieldDefinition,
+	dividerDefinition,
+	inlineTimePickerDefinition,
+	visuallyHiddenDefinition
+], {
+	styles: [
+		picker_field_default,
+		calendar_picker_default,
+		date_time_picker_default
+	],
+	shadowOptions: { delegatesFocus: true }
+});
+/**
+* Registers the date-time-picker element with the design system.
+*
+* @param prefix - the prefix to use for the component name
+*/
+var registerDateTimePicker = createRegisterFunction(dateTimePickerDefinition);
+//#endregion
+export { registerDateTimePicker as n, DateTimePicker as r, dateTimePickerDefinition as t };

package/unbundled/definition38.cjs

@@ -0,0 +1,409 @@
+require("./chunk.cjs");
+const require_vivid_element = require("./vivid-element.cjs");
+const require_definition = require("./definition.cjs");
+const require_definition$1 = require("./definition2.cjs");
+const require_decorate = require("./decorate.cjs");
+const require_localized = require("./localized.cjs");
+const require_definition$2 = require("./definition7.cjs");
+const require_definition$3 = require("./definition25.cjs");
+let _microsoft_fast_element = require("@microsoft/fast-element");
+let _microsoft_fast_web_utilities = require("@microsoft/fast-web-utilities");
+//#region src/lib/dial-pad/dial-pad.scss?inline
+var dial_pad_default = ":host{inline-size:230px;margin:16px;display:inline-block}.base{box-sizing:border-box;grid-template-rows:80px 1fr auto;display:grid}.base.no-input{grid-template-rows:1fr auto}.digits{grid-template-rows:repeat(4,1fr);grid-template-columns:repeat(3,1fr);gap:16px;inline-size:100%;display:grid}.phone-field{grid-column:1/-1;align-self:flex-start}.digit-btn{--_appearance-color-text:var(--_connotation-color-firm-all);--_appearance-color-fill:transparent;--_appearance-color-outline:var(--_connotation-color-pale)}@media (hover:hover){.digit-btn:hover:where(:not(.disabled,:disabled,.readonly)){--_appearance-color-text:var(--_connotation-color-firm-all);--_appearance-color-fill:transparent;--_appearance-color-outline:var(--_connotation-color-firm-all)}}.digit-btn.hover:where(:not(.disabled,:disabled,.readonly)){--_appearance-color-text:var(--_connotation-color-firm-all);--_appearance-color-fill:transparent;--_appearance-color-outline:var(--_connotation-color-firm-all)}.digit-btn:disabled,.digit-btn.disabled{--_appearance-color-text:var(--vvd-color-neutral-300);--_appearance-color-fill:transparent;--_appearance-color-outline:var(--vvd-color-neutral-100)}.digit-btn{--_connotation-color-contrast:var(--vvd-dial-pad-accent-contrast,var(--vvd-color-neutral-800));--_connotation-color-soft:var(--vvd-dial-pad-accent-soft,var(--vvd-color-neutral-100));--_connotation-color-pale:var(--vvd-dial-pad-accent-pale,var(--vvd-color-neutral-300));--_connotation-color-fierce:var(--vvd-dial-pad-accent-fierce,var(--vvd-color-neutral-700));--_connotation-color-firm-all:var(--vvd-dial-pad-accent-firm-all,var(--vvd-color-neutral-600));--_connotation-color-faint:var(--vvd-dial-pad-accent-faint,var(--vvd-color-neutral-50));--_connotation-color-dim:var(--vvd-dial-pad-accent-dim,var(--vvd-color-neutral-200));--vvd-button-accent-firm:var(--_appearance-color-text);box-shadow:0 0 0 1px var(--_appearance-color-outline);border-radius:16px;flex-direction:column;inline-size:100%;display:flex;overflow:hidden}.digit-btn:not(.disabled) .digit-btn-num{color:var(--vvd-color-canvas-text)}.digit-btn:focus-within{--focus-stroke-gap-color:transparent;box-shadow:0 0 0 4px color-mix(in srgb, var(--focus-stroke-color,var(--vvd-color-cta-500)), transparent 85%), inset 0 0 0 3px var(--focus-stroke-gap-color,currentColor);outline:1px solid var(--focus-stroke-color,var(--vvd-color-cta-500));outline-offset:calc(-1px - var(--focus-inset,0px))}.call-btn{grid-column:1/-1;margin-top:32px}";
+//#endregion
+//#region src/lib/dial-pad/dial-pad.ts
+/**
+* Base class for dial-pad
+*
+* @public
+* @component dial-pad
+* @event {CustomEvent<undefined>} change - Emitted when the text field value changes
+* @event {CustomEvent<undefined>} input - Emitted when the text field value changes
+* @event {CustomEvent<undefined>} blur - Emitted when the text field loses focus
+* @event {CustomEvent<undefined>} focus - Emitted when the text field receives focus
+* @event {CustomEvent<HTMLElement>}keypad-click - Emitted when a digit button is clicked
+* @event {CustomEvent<undefined>} dial - Emitted when the call button is clicked
+* @event {CustomEvent<undefined>} end-call - Emitted when the end call button is clicked
+* @vueModel modelValue value input `event.currentTarget.value`
+*
+*/
+var DialPad = class extends require_localized.Localized(require_vivid_element.VividElement) {
+	constructor(..._args) {
+		super(..._args);
+		this.helperText = null;
+		this.placeholder = null;
+		this.value = "";
+		this.pattern = "^[0-9#*]*$";
+		this.disabled = false;
+		this.pending = false;
+		this.callActive = false;
+		this.noCall = false;
+		this.noInput = false;
+		this.endCallButtonLabel = null;
+		this.callButtonLabel = null;
+		this.deleteAriaLabel = null;
+		this._longPressTimeoutId = null;
+		this._suppressNextClick = false;
+		this._keyboardLongPressCompleted = false;
+		this._onDial = () => {
+			if (!this._textFieldEl.checkValidity()) this._announceValidationError(this._textFieldEl.errorValidationMessage ?? "");
+			else this._clearErrorAnnouncement();
+			this.callActive ? this.$emit("end-call") : this.$emit("dial");
+		};
+		this.autofocus = false;
+		this._errorAnnouncement = "";
+		this._forceAnnouncementToggle = false;
+	}
+	valueChanged(_oldValue, newValue) {
+		if (newValue !== void 0 && newValue !== null && this._textFieldEl && newValue !== this._textFieldEl.value) {
+			this._textFieldEl.value = newValue;
+			this._textFieldEl.reportValidity();
+		}
+	}
+	/**
+	* @internal
+	*/
+	_startLongPress(digit, event) {
+		if (this.disabled || this.callActive || digit !== "0") return;
+		this._clearLongPressTimer();
+		const target = event.currentTarget;
+		this._longPressTimeoutId = window.setTimeout(() => {
+			this._suppressNextClick = true;
+			this.value += "+";
+			this.$emit("keypad-click", target);
+			this.$emit("input");
+			this.$emit("change");
+		}, 600);
+	}
+	/**
+	* @internal
+	*/
+	_startKeyboardLongPress() {
+		if (this.disabled || this.callActive) return;
+		if (this._longPressTimeoutId !== null) return;
+		this._keyboardLongPressCompleted = false;
+		this._longPressTimeoutId = window.setTimeout(() => {
+			this._keyboardLongPressCompleted = true;
+			this.value += "+";
+			this.$emit("input");
+			this.$emit("change");
+		}, 650);
+	}
+	/**
+	* @internal
+	*/
+	_endLongPress() {
+		this._clearLongPressTimer();
+		window.setTimeout(() => {
+			if (this._suppressNextClick) this._suppressNextClick = false;
+		}, 0);
+	}
+	/**
+	* @internal
+	* @returns true if long press completed (timer fired), false otherwise
+	*/
+	_endKeyboardLongPress() {
+		const wasLongPress = this._keyboardLongPressCompleted;
+		this._clearLongPressTimer();
+		window.setTimeout(() => {
+			this._keyboardLongPressCompleted = false;
+		}, 0);
+		return wasLongPress;
+	}
+	/**
+	* @internal
+	*/
+	_cancelLongPress() {
+		this._clearLongPressTimer();
+	}
+	_clearLongPressTimer() {
+		if (this._longPressTimeoutId !== null) {
+			clearTimeout(this._longPressTimeoutId);
+			this._longPressTimeoutId = null;
+		}
+	}
+	/**
+	* Moves focus into the Dial Pad. If `no-input` attribute is specified, it will be the first digit
+	* button. Otherwise, the input field will be focused.
+	*
+	* @public
+	*/
+	focus() {
+		const digitBtns = this.shadowRoot?.querySelectorAll(".digits .digit-btn");
+		(this._textFieldEl || digitBtns?.[0])?.focus();
+	}
+	/**
+	* @internal
+	*/
+	_announceValidationError(message) {
+		this._errorAnnouncement = "";
+		window.queueMicrotask(() => {
+			if (message) {
+				this._forceAnnouncementToggle = !this._forceAnnouncementToggle;
+				this._errorAnnouncement = `${message}${this._forceAnnouncementToggle ? "​" : ""}`;
+			} else this._clearErrorAnnouncement();
+		});
+	}
+	/**
+	* @internal
+	*/
+	_clearErrorAnnouncement() {
+		this._errorAnnouncement = "";
+		this._forceAnnouncementToggle = false;
+	}
+};
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ attribute: "helper-text" })], DialPad.prototype, "helperText", void 0);
+require_decorate.__decorate([_microsoft_fast_element.attr], DialPad.prototype, "placeholder", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ mode: "fromView" })], DialPad.prototype, "value", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ mode: "fromView" })], DialPad.prototype, "pattern", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ mode: "boolean" })], DialPad.prototype, "disabled", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ mode: "boolean" })], DialPad.prototype, "pending", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
+	attribute: "call-active",
+	mode: "boolean"
+})], DialPad.prototype, "callActive", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
+	mode: "boolean",
+	attribute: "no-call"
+})], DialPad.prototype, "noCall", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
+	mode: "boolean",
+	attribute: "no-input"
+})], DialPad.prototype, "noInput", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ attribute: "end-call-button-label" })], DialPad.prototype, "endCallButtonLabel", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ attribute: "call-button-label" })], DialPad.prototype, "callButtonLabel", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ attribute: "delete-aria-label" })], DialPad.prototype, "deleteAriaLabel", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ mode: "boolean" })], DialPad.prototype, "autofocus", void 0);
+require_decorate.__decorate([_microsoft_fast_element.observable], DialPad.prototype, "_errorAnnouncement", void 0);
+//#endregion
+//#region src/lib/dial-pad/dial-pad.template.ts
+var DialPadButton = class {
+	constructor(value, label, ariaLabel, icon, id) {
+		this.value = value;
+		this.label = label;
+		this.ariaLabel = ariaLabel;
+		this.icon = icon;
+		this.id = id;
+	}
+};
+var DIAL_PAD_BUTTONS = [
+	new DialPadButton("1", "&nbsp;", "digitOneLabel", "one-solid", "btn1"),
+	new DialPadButton("2", "ABC", "digitTwoLabel", "two-solid", "btn2"),
+	new DialPadButton("3", "DEF", "digitThreeLabel", "three-solid", "btn3"),
+	new DialPadButton("4", "GHI", "digitFourLabel", "four-solid", "btn4"),
+	new DialPadButton("5", "JKL", "digitFiveLabel", "five-solid", "btn5"),
+	new DialPadButton("6", "MNO", "digitSixLabel", "six-solid", "btn6"),
+	new DialPadButton("7", "PQRS", "digitSevenLabel", "seven-solid", "btn7"),
+	new DialPadButton("8", "TUV", "digitEightLabel", "eight-solid", "btn8"),
+	new DialPadButton("9", "WXYZ", "digitNineLabel", "nine-solid", "btn9"),
+	new DialPadButton("*", null, "digitAsteriskLabel", "asterisk-2-solid", "btnAsterisk"),
+	new DialPadButton("0", "+", "digitZeroLabel", "zero-solid", "btn0"),
+	new DialPadButton("#", null, "digitHashtagLabel", "hashtag-solid", "btnHashtag")
+];
+var getClasses = ({ noInput }) => (0, _microsoft_fast_web_utilities.classNames)("base", ["no-input", Boolean(noInput)]);
+function handleKeyDown(x, e) {
+	if (e.key === _microsoft_fast_web_utilities.keyEnter && !x.pending && !x.disabled && !x.callActive && !x.noCall && x.value.length > 0 && e.target instanceof HTMLInputElement) x._onDial();
+	else if (e.key === " " || e.key === "Space") {
+		/* v8 ignore else -- @preserve */
+		if (e.target instanceof HTMLInputElement) {
+			e.preventDefault();
+			/* v8 ignore else -- @preserve */
+			if (!e.repeat) x._startKeyboardLongPress();
+		}
+	} else {
+		const elementIndex = DIAL_PAD_BUTTONS.findIndex((x) => x.value === e.key);
+		if (elementIndex > -1) {
+			const digit = x.shadowRoot.querySelector(".digits").children[elementIndex];
+			/* v8 ignore else -- @preserve */
+			if (digit) {
+				digit.active = true;
+				setTimeout(() => {
+					digit.active = false;
+				}, 200);
+			}
+		}
+	}
+	return true;
+}
+function handleKeyUp(x, e) {
+	/* v8 ignore else -- @preserve */
+	if (e.key === " " || e.key === "Space") {
+		/* v8 ignore else -- @preserve */
+		if (e.target instanceof HTMLInputElement) {
+			e.preventDefault();
+			if (!x._endKeyboardLongPress() && !x.disabled && !x.callActive) {
+				x.value += " ";
+				x.$emit("input");
+				x.$emit("change");
+			}
+		}
+	}
+	return true;
+}
+function handleButtonKeyDown(digit, { parent: dialPad, event }) {
+	/* v8 ignore else -- @preserve */
+	if ((event.key === " " || event.key === "Space") && digit.value === "0") {
+		event.preventDefault();
+		/* v8 ignore else -- @preserve */
+		if (!event.repeat) dialPad._startKeyboardLongPress();
+	}
+	return true;
+}
+function handleButtonKeyUp(digit, { parent: dialPad, event }) {
+	/* v8 ignore else -- @preserve */
+	if ((event.key === " " || event.key === "Space") && digit.value === "0") {
+		event.preventDefault();
+		/* v8 ignore else -- @preserve */
+		if (!dialPad._endKeyboardLongPress() && !dialPad.disabled && !dialPad.callActive) onDigitClick(digit, {
+			parent: dialPad,
+			event: new MouseEvent("click", { bubbles: true })
+		});
+	}
+	return true;
+}
+function syncFieldAndPadValues(x) {
+	x.value = x._textFieldEl.value;
+}
+function stopPropagation(_, { event: e }) {
+	e.stopImmediatePropagation();
+}
+function deleteLastCharacter(dialPad) {
+	dialPad.value = dialPad.value.slice(0, -1);
+	dialPad.$emit("input");
+	dialPad.$emit("change");
+	if (dialPad.value === "") dialPad._textFieldEl?.focus();
+}
+function renderTextField(textFieldTag, buttonTag) {
+	return _microsoft_fast_element.html`<${textFieldTag} ${(0, _microsoft_fast_element.ref)("_textFieldEl")} class="phone-field" internal-part type="tel"
+        value="${(x) => x.value}" placeholder="${(x) => x.placeholder}"
+            ?disabled="${(x) => x.disabled}" helper-text="${(x) => x.helperText}" pattern="${(x) => x.pattern}"
+            aria-label="${(x) => x.locale.dialPad.inputLabel}"
+            @keydown="${(x, c) => handleKeyDown(x, c.event)}"
+            @keyup="${(x, c) => handleKeyUp(x, c.event)}"
+            @input="${syncFieldAndPadValues}"
+			@change="${syncFieldAndPadValues}"
+			@focus="${stopPropagation}"
+			@blur="${stopPropagation}"
+			?autofocus="${(x) => x.autofocus}"
+			>
+         ${(0, _microsoft_fast_element.when)((x) => x.value && x.value.length && x.value.length > 0, _microsoft_fast_element.html`<${buttonTag}
+                slot="action-items"
+								size='super-condensed'
+								icon="backspace-line"
+								aria-label="${(x) => x.deleteAriaLabel || x.locale.dialPad.deleteButtonLabel}"
+								appearance='ghost'
+								?disabled="${(x) => x.disabled || x.callActive}"
+								@click="${(x) => deleteLastCharacter(x)}">
+            </${buttonTag}>`)}
+        </${textFieldTag}>`;
+}
+function onDigitClick(digit, { parent: dialPad, event }) {
+	if (dialPad._suppressNextClick) {
+		dialPad._suppressNextClick = false;
+		return;
+	}
+	dialPad.value += digit.value;
+	dialPad.$emit("keypad-click", event.currentTarget);
+	dialPad.$emit("input");
+	dialPad.$emit("change");
+}
+function renderDigits(buttonTag, iconTag) {
+	return _microsoft_fast_element.html`
+		${(0, _microsoft_fast_element.repeat)((_) => DIAL_PAD_BUTTONS, _microsoft_fast_element.html`
+			<${buttonTag}
+					  id="${(x) => x.id}"
+					  value="${(x) => x.value}"
+					  stacked
+					  appearance="ghost-light"
+					  shape="pill"
+					  label="${(x) => x.label === "&nbsp;" ? "\xA0" : x.label}"
+					  size='condensed'
+					  class="digit-btn"
+						?autofocus="${(_, c) => c.parent.autofocus && c.parent.noInput && c.index === 0}"
+					  aria-label="${(x, c) => c.parent.locale.dialPad[x.ariaLabel]}"
+					  ?disabled="${(_, c) => c.parent.disabled}"
+					  @pointerdown="${(x, c) => c.parent._startLongPress(x.value, c.event)}"
+					  @pointerup="${(_, c) => c.parent._endLongPress()}"
+					  @pointercancel="${(_, c) => c.parent._cancelLongPress()}"
+					  @pointerleave="${(_, c) => c.parent._cancelLongPress()}"
+					  @keydown="${(x, c) => handleButtonKeyDown(x, {
+		parent: c.parent,
+		event: c.event
+	})}"
+					  @keyup="${(x, c) => handleButtonKeyUp(x, {
+		parent: c.parent,
+		event: c.event
+	})}"
+					  @click="${onDigitClick}">
+					  	<${iconTag} slot="icon"
+									name="${(x) => x.icon}"
+									class="digit-btn-num"></${iconTag}>
+					</${buttonTag}>
+		`, { positioning: true })}
+	`;
+}
+function renderDialButton(buttonTag) {
+	return _microsoft_fast_element.html`<${buttonTag} class="call-btn"
+        size="expanded"
+        appearance="filled"
+        icon="${(x) => x.callActive ? "disable-call-line" : "call-line"}"
+        connotation="${(x) => x.callActive ? "alert" : "cta"}"
+        ?disabled="${(x) => x.disabled}"
+		?pending="${(x) => x.pending}"
+        @click="${(x) => x._onDial()}"
+        label="${(x) => x.callActive ? x.endCallButtonLabel || x.locale.dialPad.endCallButtonLabel : x.callButtonLabel || x.locale.dialPad.callButtonLabel}">
+    </${buttonTag}>`;
+}
+function renderErrorAnnouncement(visuallyHiddenTag) {
+	return _microsoft_fast_element.html`<${visuallyHiddenTag} role="alert" aria-atomic="true">
+		${(x) => `${x.locale.dialPad.errorLabel} ${x._errorAnnouncement}`}
+	</${visuallyHiddenTag}>`;
+}
+var DialPadTemplate = (context) => {
+	const buttonTag = context.tagFor(require_definition$2.Button);
+	const iconTag = context.tagFor(require_definition$1.Icon);
+	const textFieldTag = context.tagFor(require_definition$3.TextField);
+	const visuallyHiddenTag = context.tagFor(require_definition.VisuallyHidden);
+	return _microsoft_fast_element.html` <div class="${getClasses}">
+		${(0, _microsoft_fast_element.when)((x) => !x.noInput, renderTextField(textFieldTag, buttonTag))}
+		<div class="digits">${renderDigits(buttonTag, iconTag)}</div>
+		${(0, _microsoft_fast_element.when)((x) => !x.noCall, renderDialButton(buttonTag))}
+		${renderErrorAnnouncement(visuallyHiddenTag)}
+	</div>`;
+};
+//#endregion
+//#region src/lib/dial-pad/definition.ts
+/**
+* @internal
+*/
+var dialPadDefinition = require_vivid_element.defineVividComponent("dial-pad", DialPad, DialPadTemplate, [
+	require_definition$2.buttonDefinition,
+	require_definition$3.textFieldDefinition,
+	require_definition$1.iconDefinition,
+	require_definition.visuallyHiddenDefinition
+], { styles: dial_pad_default });
+/**
+* Registers the dial-pad element with the design system.
+*
+* @param prefix - the prefix to use for the component name
+*/
+var registerDialPad = require_vivid_element.createRegisterFunction(dialPadDefinition);
+//#endregion
+Object.defineProperty(exports, "DialPad", {
+	enumerable: true,
+	get: function() {
+		return DialPad;
+	}
+});
+Object.defineProperty(exports, "dialPadDefinition", {
+	enumerable: true,
+	get: function() {
+		return dialPadDefinition;
+	}
+});
+Object.defineProperty(exports, "registerDialPad", {
+	enumerable: true,
+	get: function() {
+		return registerDialPad;
+	}
+});