@vonage/vivid 5.23.1 → 5.24.0

package/unbundled/definition38.cjs

@@ -5,217 +5,367 @@ const require_definition = require("./definition6.cjs");
 const require_definition$1 = require("./definition9.cjs");
 const require_definition$2 = require("./definition22.cjs");
 const require_definition$3 = require("./definition26.cjs");
-const require_definition$4 = require("./definition35.cjs");
+const require_definition$4 = require("./definition36.cjs");
 const require_picker_field_template = require("./picker-field.template.cjs");
 const require_calendar_picker_template = require("./calendar-picker.template.cjs");
-const require_single_value_picker = require("./single-value-picker.cjs");
-const require_single_date_picker = require("./single-date-picker.cjs");
-const require_time_selection_picker_template = require("./time-selection-picker.template.cjs");
 let _microsoft_fast_element = require("@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 require_calendar_picker_template.isValidDateStr(dateStr) && require_time_selection_picker_template.isValidTimeStr(timeStr);
+//#region src/shared/datetime/presentationDateRange.ts
+var formatRange = (from, to) => {
+	return `${from} – ${to}`;
 };
-//#endregion
-//#region src/shared/datetime/presentationDateTime.ts
-var formatPresentationDateTime = (dateTimeStr, locale, includeSeconds, use12HourClock) => {
-	const [dateStr, timeStr] = dateTimeStr.split("T");
-	return `${require_calendar_picker_template.formatPresentationDate(dateStr, locale)} ${require_time_selection_picker_template.formatPresentationTime(timeStr, includeSeconds, use12HourClock)}`;
+var formatPresentationDateRange = (dateRange, locale) => {
+	return formatRange(require_calendar_picker_template.formatPresentationDate(dateRange.start, locale), require_calendar_picker_template.formatPresentationDate(dateRange.end, locale));
 };
 /**
-* Attempts to parse user input as date time.
-* Throws if input can't be parsed.
+* Parse a presentation date range, which combines two presentation dates with a dash.
+* Will throw if the range can't be parsed
 */
-var parsePresentationDateTime = (presentationDateTime, locale, use12HourClock) => {
-	const [datePart, ...timeParts] = presentationDateTime.split(" ");
-	return `${require_calendar_picker_template.parsePresentationDate(datePart, locale)}T${require_time_selection_picker_template.parsePresentationTime(timeParts.join(" "), use12HourClock)}`;
+var parsePresentationDateRange = (presentationDateRange, locale) => {
+	const fragments = presentationDateRange.trim().split(/[\s—–-]+/);
+	if (fragments.length !== 2) throw new Error(`Invalid date range: ${presentationDateRange}`);
+	const [start, end] = fragments.map((fragment) => require_calendar_picker_template.parsePresentationDate(fragment, locale));
+	return {
+		start,
+		end
+	};
 };
 //#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;
-	}
-};
+//#region src/lib/date-range-picker/date-range-picker.ts
+var isFormAssociatedTryingToSetFormValue = (value) => typeof value === "string";
+function isDefined(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,@lazy:change `event.currentTarget.value`
-* @testAction selectDateTime selectDateTime
+* @component date-range-picker
+* @slot helper-text - Describes how to use the date-range-picker. Alternative to the `helper-text` attribute.
+* @event {CustomEvent<undefined>} input:start - Event emitted when the start value changes
+* @event {CustomEvent<undefined>} input:end - Event emitted when the end value changes
+* @event {CustomEvent<undefined>} input - Emitted when either the start or end value changes
+* @event {CustomEvent<undefined>} change - Emitted when either the start or end value changes
+* @vueModel start start input:start `event.currentTarget.start`
+* @vueModel end end input:end `event.currentTarget.end`
+* @testAction selectDateRange selectDateRange
+* @testQuery range range
 */
-var DateTimePicker = class extends require_time_selection_picker_template.TimeSelectionPicker(require_single_date_picker.SingleDatePickerMixin(require_single_value_picker.SingleValuePicker(require_calendar_picker_template.CalendarPicker(require_picker_field_template.PickerField)))) {
+var DateRangePicker = class extends require_calendar_picker_template.MinMaxCalendarPicker(require_calendar_picker_template.CalendarPicker(require_picker_field_template.PickerField)) {
+	constructor(..._args) {
+		super(..._args);
+		this.initialStart = "";
+		this.initialEnd = "";
+		this.#isInternalValueUpdate = false;
+		this.start = "";
+		this.end = "";
+		this.setFormValue = (value, state) => {
+			if (isFormAssociatedTryingToSetFormValue(value)) return;
+			super.setFormValue(value, state);
+		};
+		this._numCalendars = 2;
+		this._hideDatesOutsideMonth = true;
+		this._textFieldSize = "30";
+	}
+	/** @internal */
+	initialStartChanged() {
+		if (!this.dirtyValue) {
+			this.start = this.initialStart;
+			this.dirtyValue = false;
+		}
+	}
+	/** @internal */
+	initialEndChanged() {
+		if (!this.dirtyValue) {
+			this.end = this.initialEnd;
+			this.dirtyValue = false;
+		}
+	}
+	#isInternalValueUpdate;
 	/** @internal */
-	get _resolvedMinDate() {
-		return this.minDate || extractDatePart(this.min);
+	startChanged() {
+		if (this.start && !require_calendar_picker_template.isValidDateStr(this.start)) {
+			this.start = "";
+			return;
+		}
+		this.currentStart = this.start;
+		this.dirtyValue = true;
+		if (!this.#isInternalValueUpdate) this.#handleChangedValues();
 	}
 	/** @internal */
-	get _resolvedMaxDate() {
-		return this.maxDate || extractDatePart(this.max);
+	endChanged() {
+		if (this.end && !require_calendar_picker_template.isValidDateStr(this.end)) {
+			this.end = "";
+			return;
+		}
+		this.currentEnd = this.end;
+		this.dirtyValue = true;
+		if (!this.#isInternalValueUpdate) this.#handleChangedValues();
 	}
 	/** @internal */
-	get _resolvedMinTime() {
-		return this.minTime || this.min && extractDatePart(this.min) === this._dateValue() && extractTimePart(this.min) || "";
+	currentStartChanged() {
+		this.start = this.currentStart;
 	}
 	/** @internal */
-	get _resolvedMaxTime() {
-		return this.maxTime || this.max && extractDatePart(this.max) === this._dateValue() && extractTimePart(this.max) || "";
+	currentEndChanged() {
+		this.end = this.currentEnd;
+	}
+	#updateValues(range) {
+		this.#isInternalValueUpdate = true;
+		if (range.start !== void 0) {
+			this.start = range.start;
+			this.$emit("input:start");
+		}
+		if (range.end !== void 0) {
+			this.end = range.end;
+			this.$emit("input:end");
+		}
+		this.#isInternalValueUpdate = false;
+		this.$emit("input");
+		this.$emit("change");
+		this.#handleChangedValues();
+	}
+	#handleChangedValues() {
+		if (this.start && this.end) {
+			if (require_calendar_picker_template.compareDateStr(this.start, this.end) > 0) {
+				this.#updateValues({
+					start: this.end,
+					end: this.start
+				});
+				return;
+			}
+			this.value = formatRange(this.start, this.end);
+		} else this.value = "";
+		this._updatePresentationValue();
+		const dateToEnsureVisibilityOf = this.start || this.end;
+		if (dateToEnsureVisibilityOf) this._adjustSelectedMonthToEnsureVisibilityOf(dateToEnsureVisibilityOf);
+		this.#updateFormValue();
 	}
 	/** @internal */
-	_toPresentationValue(value) {
-		return formatPresentationDateTime(value, this.locale.calendarPicker, this._displaySeconds, this._use12hClock);
+	_updatePresentationValue() {
+		if (this.start && this.end) this._presentationValue = formatPresentationDateRange({
+			start: this.start,
+			end: this.end
+		}, this.locale.calendarPicker);
+		else this._presentationValue = "";
 	}
 	/** @internal */
-	_parsePresentationValue(presentationValue) {
-		return parsePresentationDateTime(presentationValue, this.locale.calendarPicker, this._use12hClock);
+	nameChanged(previous, next) {
+		super.nameChanged(previous, next);
+		this.#updateFormValue();
+	}
+	#updateFormValue() {
+		if (!this.name || !this.start || !this.end) this.setFormValue(null);
+		else {
+			const formData = new FormData();
+			formData.append(this.name, this.start);
+			formData.append(this.name, this.end);
+			this.setFormValue(formData);
+		}
 	}
 	/** @internal */
-	_dateValue() {
-		return extractDatePart(this.value);
+	connectedCallback() {
+		super.connectedCallback();
+		/* v8 ignore else -- @preserve */
+		if (!this.start) this.start = this.initialStart;
+		/* v8 ignore else -- @preserve */
+		if (!this.end) this.end = this.initialEnd;
+	}
+	#getVisibleRange() {
+		const candidates = [this.start, this.end].filter(isDefined);
+		const isPartialRange = candidates.length === 1;
+		if (this._hoverDate && isPartialRange) candidates.push(this._hoverDate);
+		const [start, end] = candidates.sort(require_calendar_picker_template.compareDateStr);
+		return {
+			start,
+			end
+		};
 	}
 	/** @internal */
-	_withUpdatedDate(dateStr) {
-		return `${dateStr}T${extractTimePart(this.value) || "00:00:00"}`;
+	_isDateAriaSelected(date) {
+		return this._isDateInSelectedRange(date);
 	}
 	/** @internal */
-	get _timeValue() {
-		return extractTimePart(this.value);
+	_isDateInSelectedRange(date) {
+		const { start, end } = this.#getVisibleRange();
+		if (start && end) return require_calendar_picker_template.compareDateStr(date, start) >= 0 && require_calendar_picker_template.compareDateStr(date, end) <= 0;
+		return false;
 	}
 	/** @internal */
-	_withUpdatedTime(timeStr) {
-		return `${extractDatePart(this.value) || require_calendar_picker_template.currentDateStr()}T${timeStr}`;
+	_isDateRangeStart(date) {
+		return date === this.#getVisibleRange().start;
 	}
-	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 */
+	_isDateRangeEnd(date) {
+		return date === this.#getVisibleRange().end;
+	}
+	/** @internal */
+	_getSelectedDates() {
+		const dates = [];
+		if (this.start) dates.push(this.start);
+		if (this.end) dates.push(this.end);
+		return dates;
+	}
+	/** @internal */
+	_onDateClick(date) {
+		if (this.start && this.end) this.#updateValues({
+			start: date,
+			end: ""
+		});
+		else if (this.start) {
+			this.#updateValues({ end: date });
+			this._closePopup();
+		} else if (this.end) {
+			this.#updateValues({ start: date });
+			this._closePopup();
+		} else this.#updateValues({ start: date });
+	}
+	/** @internal */
+	get _textFieldPlaceholder() {
+		return formatRange(this.locale.calendarPicker.dateFormatPlaceholder, this.locale.calendarPicker.dateFormatPlaceholder);
+	}
+	/** @internal */
+	_onTextFieldChange() {
+		if (this._presentationValue === "") {
+			this.#updateValues({
+				start: "",
+				end: ""
+			});
+			return;
+		}
+		try {
+			const { start, end } = parsePresentationDateRange(this._presentationValue, this.locale.calendarPicker);
+			this.#updateValues({
+				start,
+				end
+			});
+		} catch (_) {
+			const invalidPresentationValue = this._presentationValue;
+			this.#updateValues({
+				start: "",
+				end: ""
+			});
+			this._presentationValue = invalidPresentationValue;
+			return;
+		}
+	}
+	/** @internal */
+	_onDateMouseEnter(date) {
+		this._hoverDate = date;
+	}
+	/** @internal */
+	_onDateMouseLeave() {
+		this._hoverDate = void 0;
 	}
 	/** @internal */
 	_getCustomValidationError() {
-		if (this._isPresentationValueInvalid()) return this.locale.dateTimePicker.invalidDateTimeError;
-		if (this._dateValue() && this._resolvedMinDate && require_calendar_picker_template.compareDateStr(this._dateValue(), this._resolvedMinDate) < 0) return this.locale.dateTimePicker.dateBeforeMinDateError(require_calendar_picker_template.formatPresentationDate(this._resolvedMinDate, this.locale.calendarPicker));
-		if (this._dateValue() && this._resolvedMaxDate && require_calendar_picker_template.compareDateStr(this._dateValue(), this._resolvedMaxDate) > 0) return this.locale.dateTimePicker.dateAfterMaxDateError(require_calendar_picker_template.formatPresentationDate(this._resolvedMaxDate, this.locale.calendarPicker));
-		if (this._timeValue && this._resolvedMinTime && require_time_selection_picker_template.compareTimeStr(this._timeValue, this._resolvedMinTime) < 0) return this.locale.dateTimePicker.timeBeforeMinTimeError(require_time_selection_picker_template.formatPresentationTime(this._resolvedMinTime, this._displaySeconds, this._use12hClock));
-		if (this._timeValue && this._resolvedMaxTime && require_time_selection_picker_template.compareTimeStr(this._timeValue, this._resolvedMaxTime) > 0) return this.locale.dateTimePicker.timeAfterMaxTimeError(require_time_selection_picker_template.formatPresentationTime(this._resolvedMaxTime, this._displaySeconds, this._use12hClock));
+		if (this._isPresentationValueInvalid()) return this.locale.calendarPicker.invalidDateRangeError;
+		if (this.min && this.start && require_calendar_picker_template.compareDateStr(this.start, this.min) < 0) return this.locale.calendarPicker.startDateAfterMinDateError(require_calendar_picker_template.formatPresentationDate(this.min, this.locale.calendarPicker));
+		if (this.max && this.end && require_calendar_picker_template.compareDateStr(this.end, this.max) > 0) return this.locale.calendarPicker.endDateBeforeMaxDateError(require_calendar_picker_template.formatPresentationDate(this.max, this.locale.calendarPicker));
 		return null;
 	}
 	/** @internal */
-	get _textFieldPlaceholder() {
-		return `${this.locale.calendarPicker.dateFormatPlaceholder} ${this._timePlaceholder}`;
+	_isPresentationValueInvalid() {
+		if (this._presentationValue === "") return false;
+		try {
+			parsePresentationDateRange(this._presentationValue, this.locale.calendarPicker);
+			return false;
+		} catch (_) {
+			return true;
+		}
 	}
 	/** @internal */
-	get _pickerButtonLabel() {
-		if (this.value) return this.locale.dateTimePicker.changeDateTimeLabel(this._toPresentationValue(this.value));
-		else return this.locale.dateTimePicker.chooseDateTimeLabel;
+	_onClearClick() {
+		this.#updateValues({
+			start: "",
+			end: ""
+		});
+		super._onClearClick();
 	}
 	/** @internal */
-	_focusableElsWithinDialog() {
-		return this._dialogEl.querySelectorAll("#inline-time-picker, button, .vwc-button");
+	formResetCallback() {
+		this.#updateValues({
+			start: this.initialStart,
+			end: this.initialEnd
+		});
+		super.formResetCallback();
 	}
 	/** @internal */
-	get _pickerButtonIcon() {
-		return "calendar-clock-line";
+	get _pickerButtonLabel() {
+		if (this.start && this.end) return this.locale.calendarPicker.changeDatesLabel(formatPresentationDateRange({
+			start: this.start,
+			end: this.end
+		}, this.locale.calendarPicker));
+		else return this.locale.calendarPicker.chooseDatesLabel;
 	}
 	/** @internal */
 	get _dialogLabel() {
-		return this.locale.dateTimePicker.chooseDateTimeLabel;
+		return this.locale.calendarPicker.chooseDatesLabel;
+	}
+	/** @internal */
+	_focusableElsWithinDialog() {
+		return this._dialogEl.querySelectorAll("button, .vwc-button");
+	}
+	/** @internal */
+	get _pickerButtonIcon() {
+		return "calendar-line";
 	}
 };
-require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ converter: ValidDateTimeFilter })], DateTimePicker.prototype, "min", void 0);
-require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
-	converter: require_time_selection_picker_template.ValidTimeFilter,
-	attribute: "min-time"
-})], DateTimePicker.prototype, "minTime", void 0);
-require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
-	converter: require_calendar_picker_template.ValidDateFilter,
-	attribute: "min-date"
-})], DateTimePicker.prototype, "minDate", void 0);
-require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ converter: ValidDateTimeFilter })], DateTimePicker.prototype, "max", void 0);
 require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
-	converter: require_time_selection_picker_template.ValidTimeFilter,
-	attribute: "max-time"
-})], DateTimePicker.prototype, "maxTime", void 0);
+	mode: "fromView",
+	attribute: "start"
+})], DateRangePicker.prototype, "initialStart", void 0);
 require_decorate.__decorate([(0, _microsoft_fast_element.attr)({
-	converter: require_calendar_picker_template.ValidDateFilter,
-	attribute: "max-date"
-})], DateTimePicker.prototype, "maxDate", void 0);
+	mode: "fromView",
+	attribute: "end"
+})], DateRangePicker.prototype, "initialEnd", void 0);
+require_decorate.__decorate([_microsoft_fast_element.observable], DateRangePicker.prototype, "start", void 0);
+require_decorate.__decorate([_microsoft_fast_element.observable], DateRangePicker.prototype, "end", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ attribute: "current-start" })], DateRangePicker.prototype, "currentStart", void 0);
+require_decorate.__decorate([(0, _microsoft_fast_element.attr)({ attribute: "current-end" })], DateRangePicker.prototype, "currentEnd", void 0);
+require_decorate.__decorate([_microsoft_fast_element.observable], DateRangePicker.prototype, "_numCalendars", void 0);
+require_decorate.__decorate([_microsoft_fast_element.observable], DateRangePicker.prototype, "_hoverDate", void 0);
+require_decorate.__decorate([_microsoft_fast_element.volatile], DateRangePicker.prototype, "_pickerButtonLabel", null);
 //#endregion
-//#region src/lib/date-time-picker/date-time-picker.template.ts
-var DateTimePickerTemplate = (context) => {
-	return require_picker_field_template.PickerFieldTemplate(context, _microsoft_fast_element.html`
-			<div class="date-time-picker">
-				${() => require_calendar_picker_template.CalendarPickerTemplate(context)}
-				<div class="time-picker">
-					${() => require_time_selection_picker_template.TimeSelectionPickerTemplate(context, 9)}
-				</div>
-			</div>
-		`, {
+//#region src/lib/date-range-picker/date-range-picker.template.ts
+var DateRangePickerTemplate = (context) => {
+	return require_picker_field_template.PickerFieldTemplate(context, require_calendar_picker_template.CalendarPickerTemplate(context), {
 		withSeparator: false,
-		padded: false
+		padded: true
 	});
 };
 //#endregion
-//#region src/lib/date-time-picker/definition.ts
+//#region src/lib/date-range-picker/definition.ts
 /** @internal */
-var dateTimePickerDefinition = require_vivid_element.defineVividComponent("date-time-picker", DateTimePicker, DateTimePickerTemplate, [
+var dateRangePickerDefinition = require_vivid_element.defineVividComponent("date-range-picker", DateRangePicker, DateRangePickerTemplate, [
 	require_definition.buttonDefinition,
 	require_definition$1.popupDefinition,
 	require_definition$3.textFieldDefinition,
 	require_definition$4.dividerDefinition,
-	require_time_selection_picker_template.inlineTimePickerDefinition,
 	require_definition$2.visuallyHiddenDefinition
 ], {
-	styles: [
-		require_picker_field_template.picker_field_default,
-		require_calendar_picker_template.calendar_picker_default,
-		date_time_picker_default
-	],
+	styles: [require_picker_field_template.picker_field_default, require_calendar_picker_template.calendar_picker_default],
 	shadowOptions: { delegatesFocus: true }
 });
 /**
-* Registers the date-time-picker element with the design system.
+* Registers the date-range-picker element with the design system.
 *
 * @param prefix - the prefix to use for the component name
 */
-var registerDateTimePicker = require_vivid_element.createRegisterFunction(dateTimePickerDefinition);
+var registerDateRangePicker = require_vivid_element.createRegisterFunction(dateRangePickerDefinition);
 //#endregion
-Object.defineProperty(exports, "DateTimePicker", {
+Object.defineProperty(exports, "DateRangePicker", {
 	enumerable: true,
 	get: function() {
-		return DateTimePicker;
+		return DateRangePicker;
 	}
 });
-Object.defineProperty(exports, "dateTimePickerDefinition", {
+Object.defineProperty(exports, "dateRangePickerDefinition", {
 	enumerable: true,
 	get: function() {
-		return dateTimePickerDefinition;
+		return dateRangePickerDefinition;
 	}
 });
-Object.defineProperty(exports, "registerDateTimePicker", {
+Object.defineProperty(exports, "registerDateRangePicker", {
 	enumerable: true,
 	get: function() {
-		return registerDateTimePicker;
+		return registerDateRangePicker;
 	}
 });