[Due for payment 2026-05-29] [$250] Expense - Dates greyed out in “Edit Multiple” date picker

[lanitochka17]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: V9.3.74
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #76150
Email or phone of affected tester (no customers): dreamnitethedragon+vegst@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Android
App Component: Money Requests

Action Performed:

1. Launch app
2. Create 2 manual expense
3. Open one expense and set date 1994 and a date in May month
4. Go to expense report - select both expenses - from drop-down select Edit multiple
5. Tap date - 1994 - May
6. Note dates are greyed out ( unable to select)

Expected Result:

Dates should remain selectable after choosing a historical year and month in the “Edit Multiple” date picker.

Actual Result:

The expense date can be set individually to May 1994 without issues. However, while using the “Edit Multiple” option, selecting year 1994 and month May causes all dates to appear greyed out and unselectable.

Workaround:

Unknown

Platforms:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Bug7153846_1778751897313.Screenrecorder-2026-05-14-15-00-51-879.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022054962139804092829
• Upwork Job ID: 2054962139804092829
• Last Price Increase: 2026-05-23

Issue Owner

Current Issue Owner: @marufsharifi

[MelvinBot]

Proposal

What is the root cause of that problem?

The "Edit Multiple" date page (SearchEditMultipleDatePage.tsx:68-69) passes minDate={CONST.CALENDAR_PICKER.MIN_DATE} to the DatePicker. MIN_DATE is defined as dateSubtract(new Date(), {years: 20}) (CONST/index.ts:54), which evaluates to ~May 2006 today.

The CalendarPicker disables any day before minDate (CalendarPicker/index.tsx:372), so every day in May 1994 is greyed out.

In contrast, single expense editing (IOURequestStepDate.tsx:154) does not pass minDate at all, so it defaults to MIN_YEAR (current year − 100 = 1926), which allows 1994.

What changes do you think we should make in order to solve the problem?

Remove the explicit minDate prop from SearchEditMultipleDatePage.tsx (or replace it with the same MIN_YEAR-based default used by single expense editing) so the bulk date picker allows the same date range as the individual expense date picker.

What alternative solutions did you explore? (Optional)

An alternative would be to change CONST.CALENDAR_PICKER.MIN_DATE itself to use MIN_YEAR, but that constant may be intentionally stricter for other consumers. The safest fix is to align SearchEditMultipleDatePage with IOURequestStepDate by simply not passing minDate.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

[dilshodmackbook-sketch]

Proposal

Please re-state the problem that we are trying to solve in this issue.

In the "Edit Multiple" (bulk edit) date picker, navigating to a historical year/month (e.g. May 1994) greys out every day so nothing can be selected — even though editing a single expense's date to May 1994 works fine.

What is the root cause of that problem?

The bulk-edit date picker explicitly caps minDate at 20 years ago, while the single-expense date picker doesn't.

SearchEditMultipleDatePage passes minDate={CONST.CALENDAR_PICKER.MIN_DATE} to DatePicker:

https://github.com/Expensify/App/blob/main/src/pages/Search/SearchEditMultiple/SearchEditMultipleDatePage.tsx#L68-L69

CONST.CALENDAR_PICKER.MIN_DATE is dateSubtract(new Date(), {years: 20}) — so for 2026 the minimum is ~2006. CalendarPicker disables any day before minDate, which is why May 1994 is fully greyed out.

The single-expense picker (IOURequestStepDate) does not pass minDate at all — it only passes maxDate:

https://github.com/Expensify/App/blob/main/src/pages/iou/request/step/IOURequestStepDate.tsx#L154

so it falls back to DatePicker's default minDate, which is 100 years back (CONST.CALENDAR_PICKER.MIN_YEAR):

https://github.com/Expensify/App/blob/main/src/components/DatePicker/index.tsx#L25

This divergence was introduced by commit cac17eedcbc ("Remove narrow 20-year minDate override from expense date pickers"), which removed the minDate={CONST.CALENDAR_PICKER.MIN_DATE} override from IOURequestStepDate, IOURequestStepTime, and SplitExpenseCreateDateRagePage — but missed SearchEditMultipleDatePage, so the bulk-edit picker still carries the old 20-year restriction.

What changes do you think we should make in order to solve the problem?

Remove the minDate override from the bulk-edit date picker so it falls back to the same 100-year default the single-expense picker uses:

                     <InputWrapper
                         InputComponent={DatePicker}
                         inputID={INPUT_IDS.DATE}
                         label={translate('common.date')}
                         autoFocus
                         defaultValue={currentDate}
                         maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
-                        minDate={CONST.CALENDAR_PICKER.MIN_DATE}
                     />

This makes SearchEditMultipleDatePage consistent with IOURequestStepDate (and the other pickers that commit cac17eedcbc already fixed), so historical dates like May 1994 stay selectable in the "Edit Multiple" flow.

What alternative solutions did you explore? (Optional)

• Widening CONST.CALENDAR_PICKER.MIN_DATE itself instead of dropping the prop. Rejected — MIN_DATE is a shared constant still used elsewhere, and the intended behavior (per commit cac17eedcbc) is for expense date pickers to use the 100-year MIN_YEAR default, not a separate MIN_DATE. Removing the override is the smaller, consistent change.

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @marufsharifi (External)

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022054962139804092829

[wildan-m]

Proposal

Please re-state the problem that we are trying to solve in this issue.

On the "Edit Multiple" date picker for expenses, after selecting a year more than 20 years in the past (e.g. 1994) and a month such as May, every day in the calendar is rendered greyed out and unselectable. The same date can be set successfully from the single-expense date picker, so this is specific to the bulk edit flow.

What is the root cause of that problem?

The Edit Multiple date page hard-codes minDate={CONST.CALENDAR_PICKER.MIN_DATE} when rendering the calendar:

App/src/pages/Search/SearchEditMultiple/SearchEditMultipleDatePage.tsx

Lines 61 to 71 in 5b98546

	<View style={styles.mb4}>
	<InputWrapper
	InputComponent={DatePicker}
	inputID={INPUT_IDS.DATE}
	label={translate('common.date')}
	autoFocus
	defaultValue={currentDate}
	maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
	minDate={CONST.CALENDAR_PICKER.MIN_DATE}
	/>
	</View>

CONST.CALENDAR_PICKER.MIN_DATE is defined as "20 years before today":

App/src/CONST/index.ts

Lines 52 to 54 in 5b98546

	const CURRENT_YEAR = new Date().getFullYear();
	const MAX_DATE = dateAdd(new Date(), {years: 1});
	const MIN_DATE = dateSubtract(new Date(), {years: 20});

However, the year picker inside CalendarPicker lets the user pick any year in the range [MIN_YEAR, MAX_YEAR] which is "100 years before today" through "100 years after today":

App/src/CONST/index.ts

Lines 463 to 469 in 5b98546

	CALENDAR_PICKER: {
	// Numbers were arbitrarily picked.
	MIN_YEAR: CURRENT_YEAR - 100,
	MAX_YEAR: CURRENT_YEAR + 100,
	MAX_DATE,
	MIN_DATE,
	},

App/src/components/DatePicker/CalendarPicker/index.tsx

Lines 93 to 103 in 5b98546

	const minYear = CONST.CALENDAR_PICKER.MIN_YEAR;
	const maxYear = CONST.CALENDAR_PICKER.MAX_YEAR;
	const [years, setYears] = useState<CalendarPickerListItem[]>(() =>
	Array.from({length: maxYear - minYear + 1}, (v, i) => i + minYear).map((year) => ({
	text: year.toString(),
	value: year,
	keyForList: year.toString(),
	isSelected: year === currentDateView.getFullYear(),
	})),
	);

When the user navigates the calendar to a year that is between MIN_YEAR (≈100 years ago) and MIN_DATE (20 years ago) — for example 1994 — every day cell in the grid evaluates isBeforeMinDate = currentDate < startOfDay(new Date(minDate)) as true, and therefore is rendered with isDisabled set to true:

App/src/components/DatePicker/CalendarPicker/index.tsx

Lines 370 to 383 in 5b98546

	{week.map((day, index) => {
	const currentDate = new Date(currentYearView, currentMonthView, day);
	const isBeforeMinDate = currentDate < startOfDay(new Date(minDate));
	const isAfterMaxDate = currentDate > startOfDay(new Date(maxDate));
	const isSelectable = selectableDates ? selectableDates?.some((date) => isSameDay(parseISO(date), currentDate)) : true;
	const isDisabled = !day || isBeforeMinDate || isAfterMaxDate || !isSelectable;
	const isSelected = !!day && isSameDay(parseISO(value.toString()), new Date(currentYearView, currentMonthView, day));
	const handleOnPress = () => {
	if (!day || isDisabled) {
	return;
	}
	onDayPressed(day);
	};

That is why all days appear greyed out in the Edit Multiple picker. The single-expense date page (IOURequestStepDate) does not pass a minDate, so it falls back to the CalendarPicker default of MIN_YEAR (≈100 years ago) and works correctly for the same input:

App/src/pages/iou/request/step/IOURequestStepDate.tsx

Lines 149 to 156 in 5b98546

	<InputWrapper
	InputComponent={DatePicker}
	inputID={INPUT_IDS.MONEY_REQUEST_CREATED}
	label={translate('common.date')}
	defaultValue={currentCreated}
	maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
	autoFocus
	/>

So the bulk edit flow is incorrectly applying the "20 years back" constraint that is intended for financial pickers like wallet card transaction start dates, not for an expense created date which can legitimately be older.

What changes do you think we should make in order to solve the problem?

In src/pages/Search/SearchEditMultiple/SearchEditMultipleDatePage.tsx, stop passing minDate={CONST.CALENDAR_PICKER.MIN_DATE} to the DatePicker for the bulk edit date input. Let CalendarPicker fall back to its built-in MIN_YEAR-based default (≈100 years ago), which matches the behavior of the single-expense date picker (IOURequestStepDate) and the same range presented by the year picker dropdown.

After this change, both the single-edit and Edit Multiple paths will allow the user to select an expense date from any year offered in the year picker, including historical years like 1994 from the bug report. The maxDate={CONST.CALENDAR_PICKER.MAX_DATE} constraint (one year in the future, matching IOURequestStepDate) should remain unchanged — that constraint is still meaningful for an expense created date.

Compare branch: https://github.com/Expensify/App/compare/main...wildan-m:App:wildan/90697-edit-multiple-date-min?expand=1

What alternative solutions did you explore? (Optional)

Tightening CalendarPicker itself to clamp the year picker to minDate.getFullYear()..maxDate.getFullYear() would also remove the inconsistency, but it is a much broader change that would affect every other consumer of CalendarPicker and risks regressing other date pickers in the app. Fixing the wrong-constant prop at the call site is the minimal, localized correction that matches the existing single-expense behavior.

[mukhrr]

Proposal

What is the root cause of that problem?

CONST.CALENDAR_PICKER.MIN_DATE is hard-coded to 20 years before today, while the same CALENDAR_PICKER block exposes MIN_YEAR = CURRENT_YEAR - 100 (i.e. 1926) as the picker's intended floor:

App/src/CONST/index.ts

Lines 52 to 54 in 1b89b63

	const CURRENT_YEAR = new Date().getFullYear();
	const MAX_DATE = dateAdd(new Date(), {years: 1});
	const MIN_DATE = dateSubtract(new Date(), {years: 20});

App/src/CONST/index.ts

Lines 461 to 467 in 1b89b63

	HIDDEN_MESSAGE_ATTRIBUTE: 'is-hidden-message',
	CALENDAR_PICKER: {
	// Numbers were arbitrarily picked.
	MIN_YEAR: CURRENT_YEAR - 100,
	MAX_YEAR: CURRENT_YEAR + 100,
	MAX_DATE,

The Edit Multiple date page passes that 20-year MIN_DATE straight into the DatePicker:

App/src/pages/Search/SearchEditMultiple/SearchEditMultipleDatePage.tsx

Lines 62 to 70 in 1b89b63

	<InputWrapper
	InputComponent={DatePicker}
	inputID={INPUT_IDS.DATE}
	label={translate('common.date')}
	autoFocus
	defaultValue={currentDate}
	maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
	minDate={CONST.CALENDAR_PICKER.MIN_DATE}
	/>

…and CalendarPicker then disables every day where currentDate < startOfDay(minDate):

App/src/components/DatePicker/CalendarPicker/index.tsx

Lines 374 to 380 in 1b89b63

	const isSelectable = selectableDates ? selectableDates?.some((date) => isSameDay(parseISO(date), currentDate)) : true;
	const isDisabled = !day || isBeforeMinDate || isAfterMaxDate || !isSelectable;
	const isSelected = !!day && isSameDay(parseISO(value.toString()), new Date(currentYearView, currentMonthView, day));
	const handleOnPress = () => {
	if (!day || isDisabled) {
	return;
	}

So when the bulk-edit draft transaction's created is older than ~today − 20 years (e.g. May 1994 carried over from an expense that was set individually via OldDot on Android), the calendar opens on that month with every day below MIN_DATE and therefore disabled. The single-edit flow on Android doesn't hit this because it goes through the OldDot date input, which doesn't apply this 20-year floor — that's the asymmetry the reporter sees.

What changes do you think we should make in order to solve the problem?

MIN_DATE should match the picker's own MIN_YEAR (100-year floor) so the year/month UI and the day grid agree on what's selectable. One-line change in src/CONST/index.ts:

- const MIN_DATE = dateSubtract(new Date(), {years: 20});
+ const MIN_DATE = startOfYear(dateSubtract(new Date(), {years: 100}));

(startOfYear is already exported by date-fns; just add it to the import at the top of the file.)

This keeps every existing call site untouched (IOURequestStepDate, SearchEditMultipleDatePage, IOURequestStepTime, SplitExpenseCreateDateRagePage, the company-card start-date pages, etc.) and consistently allows expenses dated up to 100 years in the past — matching the year picker's range and removing the "all days greyed out" state in Edit Multiple, single edit, and any other consumer.

What alternative solutions did you explore?

1. Override minDate only in SearchEditMultipleDatePage — fixes the reported symptom but leaves the same latent bug in IOURequestStepDate, IOURequestStepTime, etc., where the year picker would still advertise years that the day grid silently rejects.
2. Clamp the draft created to MIN_DATE when seeding the bulk-edit form — masks the inconsistency rather than fixing it, and would silently change the user's existing expense date the moment they open the page.
3. Drop MIN_DATE entirely and use setYear(new Date(), MIN_YEAR) at the call sites — works, but duplicates the same setYear boilerplate the DatePicker defaults already use; a single shared constant is cleaner.

[github-actions]

⚠️ @mukhrr Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

[yusufdeveloper2903]

Proposal

What is the root cause of that problem?

The "Edit Multiple" date screen, SearchEditMultipleDatePage, passes minDate={CONST.CALENDAR_PICKER.MIN_DATE} to the DatePicker:

maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
minDate={CONST.CALENDAR_PICKER.MIN_DATE}

CONST.CALENDAR_PICKER.MIN_DATE resolves to dateSubtract(new Date(), {years: 20}) — only 20 years back (currently 2006-05-14). The CalendarPicker disables every day before minDate, so once you navigate to May 1994 the whole grid is greyed out and unselectable.

The single-expense date editor, IOURequestStepDate, does not pass minDate at all — it only passes maxDate. So DatePicker falls back to its own default minDate = setYear(new Date(), CONST.CALENDAR_PICKER.MIN_YEAR), i.e. current year − 100 (1926). That is exactly why setting May 1994 works for a single expense but not in "Edit Multiple".

This is not a regression — minDate={CONST.CALENDAR_PICKER.MIN_DATE} has been on this input since the bulk-edit feature was first added (commit 3f28b7876b1). That 20-year constant is the right bound for card transaction start-date pages (its other call sites), but wrong for an expense date, which should accept the same range as the single-expense editor.

What changes do you think we should make in order to solve the problem?

Remove the minDate prop from SearchEditMultipleDatePage so the bulk date editor falls back to the same 100-year default DatePicker already uses for IOURequestStepDate:

                        defaultValue={currentDate}
                        maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
-                       minDate={CONST.CALENDAR_PICKER.MIN_DATE}

This gives the "Edit Multiple" date picker true parity with the single-expense date picker — May 1994 (and any year within the 100-year window) becomes selectable again, while maxDate still caps the future bound.

What alternative solutions did you explore? (Optional)

Pass minDate={setYear(new Date(), CONST.CALENDAR_PICKER.MIN_YEAR)} explicitly instead of removing the prop. It produces the same result, but it just re-states the component's existing default, so dropping the prop is cleaner and keeps the two date editors behaviorally identical.