@transferwise/components 0.0.0-experimental-b77dac7 → 0.0.0-experimental-fa3aa98

package/src/DateLookup/_stories/DateLookup.story.tsx

@@ -1,16 +1,23 @@
 import { useState } from 'react';
 import { StoryObj } from '@storybook/react-webpack5';
+import { fn } from 'storybook/test';
+import { action } from 'storybook/actions';
 import {
   createSandboxStory,
   globalScope,
 } from '../../../.storybook/components/sandbox/SandboxEditor';
+import { storySourceWithoutNoise } from '../../../.storybook/helpers';
 import { Size } from '../../common';
-import DateLookup, { type DateLookupProps } from '..';
 import Field from '../../Field';
+import DateLookup, { type DateLookupProps } from '..';
 
 export default {
   component: DateLookup,
   title: 'Forms/DateLookup',
+  args: {
+    onFocus: fn(),
+    onBlur: fn(),
+  },
   argTypes: {
     size: { control: 'select', options: [Size.SMALL, Size.MEDIUM, Size.LARGE] },
     disabled: { control: 'boolean' },
@@ -34,7 +41,7 @@ thePast.setUTCDate(epoch.getUTCDate() - 10);
 
 export const Sandbox = createSandboxStory({
   code: `const App = () => {
-  const [value, setValue] = React.useState(new Date('2024-06-15'));
+  const [value, setValue] = React.useState(new Date(2024, 5, 14));
 
   return (
     <DateLookup
@@ -44,6 +51,11 @@ export const Sandbox = createSandboxStory({
       placeholder="Choose date"
       clearable
       value={value}
+      disabledRules={{
+        weekdays: ['sat', 'sun'],
+        dates: [new Date(2024, 5, 19)],
+        reason: 'Weekends and holidays are unavailable.',
+      }}
       onChange={(date) => setValue(date)}
     />
   );
@@ -120,3 +132,113 @@ export const RightAligned: Story = {
     );
   },
 };
+
+/**
+ * Use `disabledRules` to disable specific weekdays, individual dates, or date ranges.
+ * Disabled dates remain focusable and keyboard-navigable — clicking or focusing one
+ * keeps the panel open, fires `onDateSelect` with `isEnabled: false`, and shows a
+ * negative inline prompt with the `reason` text. `min`/`max` out-of-range dates show
+ * a built-in boundary prompt (e.g. "Please select a date between 9 December 2024 and
+ * 22 January 2025.").
+ *
+ * The `reason` field is **required for accessibility**: it renders as an InlinePrompt
+ * below the grid and is linked to every disabled cell via `aria-describedby`, so screen
+ * reader users understand why a date is unavailable. For per-date reason customisation
+ * see [DisabledDatesWithDynamicReason](#disabled-dates-with-dynamic-reason).
+ */
+export const DisabledDates: Story = storySourceWithoutNoise({
+  args: {
+    size: Size.MEDIUM,
+    label: 'Select a date',
+    placeholder: 'Choose date',
+    monthFormat: 'long',
+  },
+  render: function Render(args: DateLookupProps) {
+    const min = new Date(2024, 11, 9);
+    const max = new Date(2025, 0, 22);
+    const bankHolidays = [new Date(2024, 11, 25), new Date(2024, 11, 26), new Date(2025, 0, 1)];
+    const [value, setValue] = useState<Date | null>(null);
+
+    return (
+      <DateLookup
+        {...args}
+        min={min}
+        max={max}
+        value={value}
+        disabledRules={{
+          weekdays: ['sat', 'sun'],
+          dates: bankHolidays,
+          ranges: [{ start: new Date(2024, 11, 23), end: new Date(2024, 11, 24) }],
+          reason: 'Some dates are unavailable for this service.',
+        }}
+        onChange={(date) => {
+          action('onChange')(date);
+          setValue(date);
+        }}
+        onDateSelect={({ date, isEnabled }) => {
+          action('onDateSelect')({ date, isEnabled });
+        }}
+      />
+    );
+  },
+});
+
+/**
+ * When different disabled dates warrant different explanations, drive the `reason`
+ * dynamically from `onDateSelect`. The `isEnabled` flag tells you whether the focused
+ * date is selectable; from there you can look up the specific reason and update state.
+ *
+ * `min`/`max` out-of-range dates are handled automatically — the component shows a
+ * built-in prompt with the boundary dates, so `determineReason` only needs to cover
+ * rule-disabled dates.
+ */
+export const DisabledDatesWithDynamicReason: Story = storySourceWithoutNoise({
+  args: {
+    size: Size.MEDIUM,
+    label: 'Select a date',
+    placeholder: 'Choose date',
+    monthFormat: 'long',
+  },
+  render: function Render(args: DateLookupProps) {
+    const DEFAULT_REASON = 'Some dates are unavailable for this service.';
+    const min = new Date(2024, 11, 9);
+    const max = new Date(2025, 0, 22);
+    const bankHolidays = [new Date(2024, 11, 25), new Date(2024, 11, 26), new Date(2025, 0, 1)];
+    const [value, setValue] = useState<Date | null>(null);
+    const [reason, setReason] = useState(DEFAULT_REASON);
+
+    function determineReason(date: Date, isEnabled: boolean): string {
+      if (isEnabled) return DEFAULT_REASON;
+      if (bankHolidays.some((holiday) => holiday.toDateString() === date.toDateString())) {
+        return 'This date is a bank holiday.';
+      }
+      if (date.getDay() === 0 || date.getDay() === 6) {
+        return 'We do not operate on weekends.';
+      }
+      return 'This date is unavailable due to scheduled maintenance.';
+    }
+
+    return (
+      <DateLookup
+        {...args}
+        min={min}
+        max={max}
+        value={value}
+        disabledRules={{
+          weekdays: ['sat', 'sun'],
+          dates: bankHolidays,
+          ranges: [{ start: new Date(2024, 11, 23), end: new Date(2024, 11, 24) }],
+          reason,
+        }}
+        onChange={(date) => {
+          action('onChange')(date);
+          setValue(date);
+        }}
+        onDateSelect={({ date, isEnabled }) => {
+          action('onDateSelect')({ date, isEnabled });
+          setReason(determineReason(date, isEnabled));
+        }}
+      />
+    );
+  },
+});

package/src/DateLookup/index.ts

@@ -1,2 +1,8 @@
 export { default } from './DateLookup';
 export type { DateLookupProps } from './DateLookup';
+export type {
+  DisabledRules,
+  DisabledDateRange,
+  WeekDayType,
+  OnDateSelectParams,
+} from '../Calendar/Calendar.types';

package/src/DefinitionList/DefinitionList.css

@@ -46,36 +46,6 @@
     margin-bottom: 8px;
     margin-bottom: var(--size-8);
   }
-  .tw-definition-list.tw-definition-list--horizontal-right-aligned {
-    display: grid;
-    grid-template-columns: minmax(0, max-content) minmax(0, max-content);
-    grid-column-gap: 52px;
-    grid-column-gap: var(--size-52);
-    -moz-column-gap: 52px;
-         column-gap: 52px;
-    -moz-column-gap: var(--size-52);
-         column-gap: var(--size-52);
-    justify-content: space-between;
-  }
-  .tw-definition-list.tw-definition-list--horizontal-right-aligned .tw-definition-list__item {
-    display: grid;
-    grid-template-columns: subgrid;
-    grid-column: 1 / -1;
-  }
-  .tw-definition-list.tw-definition-list--horizontal-right-aligned .tw-definition-list__item dt {
-    max-width: none;
-    min-width: 0;
-    word-wrap: anywhere;
-    margin-right: 0;
-  }
-  [dir="rtl"] .tw-definition-list.tw-definition-list--horizontal-right-aligned .tw-definition-list__item dt {
-    margin-left: 0;
-    margin-right: 0;
-    margin-right: initial;
-  }
-  .tw-definition-list.tw-definition-list--horizontal-right-aligned .tw-definition-list__item dd {
-    min-width: 0;
-  }
 }
 .np-theme-personal .tw-definition-list dt {
   color: #5d7079;

package/src/DefinitionList/DefinitionList.less

@@ -52,30 +52,6 @@
         }
       }
     }
-
-    &.tw-definition-list--horizontal-right-aligned {
-      display: grid;
-      grid-template-columns: minmax(0, max-content) minmax(0, max-content);
-      column-gap: var(--size-52);
-      justify-content: space-between;
-
-      .tw-definition-list__item {
-        display: grid;
-        grid-template-columns: subgrid;
-        grid-column: 1 / -1;
-
-        dt {
-          max-width: none;
-          min-width: 0;
-          overflow-wrap: anywhere;
-          .margin(right, 0);
-        }
-
-        dd {
-          min-width: 0;
-        }
-      }
-    }
   }
 
   .np-theme-personal & {

package/src/DefinitionList/DefinitionList.tsx

@@ -69,7 +69,6 @@ export default function DefinitionList({
         'tw-definition-list--columns flex-column flex-row--sm':
           layout === Layout.VERTICAL_TWO_COLUMN,
         'tw-definition-list--horizontal flex-column': isLayoutHorizontal(layout),
-        'tw-definition-list--horizontal-right-aligned': layout === Layout.HORIZONTAL_RIGHT_ALIGNED,
       })}
     >
       {definitions

package/src/common/DateUtils/hasDisabledDatesInMonth/hasDisabledDatesInMonth.test.ts

@@ -0,0 +1,98 @@
+import { hasDisabledDatesInMonth } from './hasDisabledDatesInMonth';
+import type { DisabledRules } from '../../../Calendar/Calendar.types';
+
+describe('hasDisabledDatesInMonth', () => {
+  describe('weekdays', () => {
+    it('returns true when weekday rules exist (every month has all weekdays)', () => {
+      const rules: DisabledRules = { weekdays: ['sat', 'sun'], reason: 'Closed' };
+      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(true);
+    });
+
+    it('returns true for any month when weekday rules exist', () => {
+      const rules: DisabledRules = { weekdays: ['mon'], reason: 'Closed' };
+      expect(hasDisabledDatesInMonth(0, 2024, rules)).toBe(true);
+      expect(hasDisabledDatesInMonth(11, 2024, rules)).toBe(true);
+    });
+
+    it('returns false when weekdays array is empty', () => {
+      const rules: DisabledRules = { weekdays: [], reason: 'None' };
+      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(false);
+    });
+  });
+
+  describe('specific dates', () => {
+    const rules: DisabledRules = {
+      dates: [new Date(2024, 6, 11), new Date(2024, 6, 25), new Date(2025, 0, 1)],
+      reason: 'Bank holidays',
+    };
+
+    it('returns true when month contains a disabled date', () => {
+      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(true);
+    });
+
+    it('returns false when month has no disabled dates', () => {
+      expect(hasDisabledDatesInMonth(5, 2024, rules)).toBe(false);
+    });
+
+    it('returns true for another year with disabled date', () => {
+      expect(hasDisabledDatesInMonth(0, 2025, rules)).toBe(true);
+    });
+  });
+
+  describe('ranges', () => {
+    const rules: DisabledRules = {
+      ranges: [{ start: new Date(2024, 2, 29), end: new Date(2024, 3, 3) }],
+      reason: 'Maintenance',
+    };
+
+    it('returns true when range starts in the month', () => {
+      expect(hasDisabledDatesInMonth(2, 2024, rules)).toBe(true);
+    });
+
+    it('returns true when range ends in the month', () => {
+      expect(hasDisabledDatesInMonth(3, 2024, rules)).toBe(true);
+    });
+
+    it('returns true when range spans the entire month', () => {
+      const spanRules: DisabledRules = {
+        ranges: [{ start: new Date(2024, 0, 1), end: new Date(2024, 11, 31) }],
+        reason: 'Year-long',
+      };
+      expect(hasDisabledDatesInMonth(6, 2024, spanRules)).toBe(true);
+    });
+
+    it('returns false when range does not overlap the month', () => {
+      expect(hasDisabledDatesInMonth(4, 2024, rules)).toBe(false);
+    });
+  });
+
+  describe('min/max constraints', () => {
+    it('returns false when all disabled dates in month are outside min/max', () => {
+      const rules: DisabledRules = {
+        dates: [new Date(2024, 6, 1), new Date(2024, 6, 2)],
+        reason: 'Early',
+      };
+      const min = new Date(2024, 6, 10);
+      const max = new Date(2024, 6, 31);
+      expect(hasDisabledDatesInMonth(6, 2024, rules, min, max)).toBe(false);
+    });
+
+    it('returns true when weekdays exist regardless of min/max', () => {
+      const rules: DisabledRules = { weekdays: ['sat'], reason: 'Closed' };
+      const min = new Date(2024, 6, 10);
+      const max = new Date(2024, 6, 20);
+      expect(hasDisabledDatesInMonth(6, 2024, rules, min, max)).toBe(true);
+    });
+  });
+
+  describe('no rules', () => {
+    it('returns false when disabledRules is undefined', () => {
+      expect(hasDisabledDatesInMonth(6, 2024, undefined)).toBe(false);
+    });
+
+    it('returns false when only reason is provided', () => {
+      const rules: DisabledRules = { reason: 'Reason only' };
+      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(false);
+    });
+  });
+});

package/src/common/DateUtils/hasDisabledDatesInMonth/hasDisabledDatesInMonth.ts

@@ -0,0 +1,45 @@
+import type { DisabledRules } from '../../../Calendar/Calendar.types';
+
+export function hasDisabledDatesInMonth(
+  month: number,
+  year: number,
+  disabledRules?: DisabledRules,
+  min?: Date | null,
+  max?: Date | null,
+): boolean {
+  if (!disabledRules) return false;
+
+  if (disabledRules.weekdays?.length) {
+    return true;
+  }
+
+  const monthStart = new Date(year, month, 1);
+  const monthEnd = new Date(year, month + 1, 0);
+
+  if (disabledRules.dates?.length) {
+    const hasDateInMonth = disabledRules.dates.some((date) => {
+      if (date.getFullYear() !== year || date.getMonth() !== month) return false;
+      if (min && date < min) return false;
+      if (max && date > max) return false;
+      return true;
+    });
+    if (hasDateInMonth) return true;
+  }
+
+  if (disabledRules.ranges?.length) {
+    const hasOverlap = disabledRules.ranges.some((range) => {
+      const rangeStart = new Date(
+        range.start.getFullYear(),
+        range.start.getMonth(),
+        range.start.getDate(),
+      );
+      const rangeEnd = new Date(range.end.getFullYear(), range.end.getMonth(), range.end.getDate());
+      if (max && rangeStart > max) return false;
+      if (min && rangeEnd < min) return false;
+      return rangeStart <= monthEnd && rangeEnd >= monthStart;
+    });
+    if (hasOverlap) return true;
+  }
+
+  return false;
+}

package/src/common/DateUtils/index.ts

@@ -6,3 +6,5 @@ export { isDateValid } from './isDateValid/isDateValid';
 export { isMonthAndYearFormat } from './isMonthAndYearFormat/isMonthAndYearFormat';
 export { MDY, YMD } from './getFormatForLocale/getFormatForLocale';
 export { returnDateView } from './getDateView/getDateView';
+export { isDateDisabled } from './isDateDisabled/isDateDisabled';
+export { hasDisabledDatesInMonth } from './hasDisabledDatesInMonth/hasDisabledDatesInMonth';

package/src/common/DateUtils/isDateDisabled/isDateDisabled.test.ts

@@ -0,0 +1,169 @@
+import { isDateDisabled } from './isDateDisabled';
+import type { DisabledRules } from '../../../Calendar/Calendar.types';
+
+describe('isDateDisabled', () => {
+  describe('when no rules provided', () => {
+    it('returns false when disabledRules is undefined', () => {
+      expect(isDateDisabled(new Date('2024-07-15'), undefined)).toBe(false);
+    });
+
+    it('returns false when disabledRules has only reason', () => {
+      const rules: DisabledRules = { reason: 'some reason' };
+      expect(isDateDisabled(new Date('2024-07-15'), rules)).toBe(false);
+    });
+  });
+
+  describe('weekdays', () => {
+    const rules: DisabledRules = {
+      weekdays: ['sat', 'sun'],
+      reason: 'Closed on weekends',
+    };
+
+    it('returns true for a Saturday', () => {
+      // 2024-07-13 is a Saturday
+      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(true);
+    });
+
+    it('returns true for a Sunday', () => {
+      // 2024-07-14 is a Sunday
+      expect(isDateDisabled(new Date(2024, 6, 14), rules)).toBe(true);
+    });
+
+    it('returns false for a Monday', () => {
+      // 2024-07-15 is a Monday
+      expect(isDateDisabled(new Date(2024, 6, 15), rules)).toBe(false);
+    });
+
+    it('returns false for a Friday', () => {
+      // 2024-07-12 is a Friday
+      expect(isDateDisabled(new Date(2024, 6, 12), rules)).toBe(false);
+    });
+
+    it('handles single weekday rule', () => {
+      const singleDay: DisabledRules = { weekdays: ['wed'], reason: 'Closed' };
+      // 2024-07-17 is a Wednesday
+      expect(isDateDisabled(new Date(2024, 6, 17), singleDay)).toBe(true);
+      // 2024-07-18 is a Thursday
+      expect(isDateDisabled(new Date(2024, 6, 18), singleDay)).toBe(false);
+    });
+  });
+
+  describe('specific dates', () => {
+    const rules: DisabledRules = {
+      dates: [new Date(2024, 6, 11), new Date(2025, 1, 12), new Date(2025, 4, 1)],
+      reason: 'Bank holidays',
+    };
+
+    it('returns true for a disabled date', () => {
+      expect(isDateDisabled(new Date(2024, 6, 11), rules)).toBe(true);
+    });
+
+    it('returns false for a non-disabled date', () => {
+      expect(isDateDisabled(new Date(2024, 6, 12), rules)).toBe(false);
+    });
+
+    it('compares date-only, ignoring time', () => {
+      const dateWithTime = new Date(2024, 6, 11, 14, 30, 0);
+      expect(isDateDisabled(dateWithTime, rules)).toBe(true);
+    });
+
+    it('handles disabled dates that have non-zero time components', () => {
+      const rulesWithTime: DisabledRules = {
+        dates: [new Date(2024, 6, 11, 23, 59, 59)],
+        reason: 'Holiday',
+      };
+      expect(isDateDisabled(new Date(2024, 6, 11), rulesWithTime)).toBe(true);
+    });
+  });
+
+  describe('ranges', () => {
+    const rules: DisabledRules = {
+      ranges: [
+        { start: new Date(2024, 2, 29), end: new Date(2024, 3, 3) },
+        { start: new Date(2024, 11, 24), end: new Date(2024, 11, 26) },
+      ],
+      reason: 'Scheduled maintenance',
+    };
+
+    it('returns true for start of range (inclusive)', () => {
+      expect(isDateDisabled(new Date(2024, 2, 29), rules)).toBe(true);
+    });
+
+    it('returns true for end of range (inclusive)', () => {
+      expect(isDateDisabled(new Date(2024, 3, 3), rules)).toBe(true);
+    });
+
+    it('returns true for date within range', () => {
+      expect(isDateDisabled(new Date(2024, 2, 31), rules)).toBe(true);
+    });
+
+    it('returns false for date before range', () => {
+      expect(isDateDisabled(new Date(2024, 2, 28), rules)).toBe(false);
+    });
+
+    it('returns false for date after range', () => {
+      expect(isDateDisabled(new Date(2024, 3, 4), rules)).toBe(false);
+    });
+
+    it('handles second range', () => {
+      expect(isDateDisabled(new Date(2024, 11, 25), rules)).toBe(true);
+      expect(isDateDisabled(new Date(2024, 11, 27), rules)).toBe(false);
+    });
+
+    it('correctly checks a date with non-midnight time against a range', () => {
+      const dateWithTime = new Date(2024, 2, 31, 14, 30, 0);
+      expect(isDateDisabled(dateWithTime, rules)).toBe(true);
+    });
+
+    it('correctly excludes a date with non-midnight time outside a range', () => {
+      const dateWithTime = new Date(2024, 2, 28, 23, 59, 59);
+      expect(isDateDisabled(dateWithTime, rules)).toBe(false);
+    });
+  });
+
+  describe('combined rules (additive)', () => {
+    const rules: DisabledRules = {
+      weekdays: ['sat', 'sun'],
+      dates: [new Date(2024, 6, 15)], // Monday
+      ranges: [{ start: new Date(2024, 6, 22), end: new Date(2024, 6, 24) }],
+      reason: 'Multiple rules',
+    };
+
+    it('disables by weekday', () => {
+      // 2024-07-13 is Saturday
+      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(true);
+    });
+
+    it('disables by specific date', () => {
+      // 2024-07-15 is Monday but explicitly disabled
+      expect(isDateDisabled(new Date(2024, 6, 15), rules)).toBe(true);
+    });
+
+    it('disables by range', () => {
+      // 2024-07-23 is Tuesday but in range
+      expect(isDateDisabled(new Date(2024, 6, 23), rules)).toBe(true);
+    });
+
+    it('allows date not matching any rule', () => {
+      // 2024-07-16 is Tuesday, not in dates or ranges
+      expect(isDateDisabled(new Date(2024, 6, 16), rules)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty weekdays array', () => {
+      const rules: DisabledRules = { weekdays: [], reason: 'Empty' };
+      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(false);
+    });
+
+    it('handles empty dates array', () => {
+      const rules: DisabledRules = { dates: [], reason: 'Empty' };
+      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(false);
+    });
+
+    it('handles empty ranges array', () => {
+      const rules: DisabledRules = { ranges: [], reason: 'Empty' };
+      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(false);
+    });
+  });
+});

package/src/common/DateUtils/isDateDisabled/isDateDisabled.ts

@@ -0,0 +1,59 @@
+import type { DisabledRules, WeekDayType } from '../../../Calendar/Calendar.types';
+
+const DAY_INDEX_TO_WEEKDAY: Record<number, WeekDayType> = {
+  0: 'sun',
+  1: 'mon',
+  2: 'tue',
+  3: 'wed',
+  4: 'thu',
+  5: 'fri',
+  6: 'sat',
+};
+
+export function isDateDisabled(date: Date, disabledRules?: DisabledRules): boolean {
+  if (!disabledRules) return false;
+
+  if (disabledRules.weekdays?.length) {
+    const weekday = DAY_INDEX_TO_WEEKDAY[date.getDay()];
+    if (disabledRules.weekdays.includes(weekday)) return true;
+  }
+
+  if (disabledRules.dates?.length) {
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    const day = date.getDate();
+    if (
+      disabledRules.dates.some(
+        (disabledDate) =>
+          disabledDate.getFullYear() === year &&
+          disabledDate.getMonth() === month &&
+          disabledDate.getDate() === day,
+      )
+    ) {
+      return true;
+    }
+  }
+
+  if (disabledRules.ranges?.length) {
+    const dateStart = date.getTime();
+    if (
+      disabledRules.ranges.some((range) => {
+        const rangeStart = new Date(
+          range.start.getFullYear(),
+          range.start.getMonth(),
+          range.start.getDate(),
+        ).getTime();
+        const rangeEnd = new Date(
+          range.end.getFullYear(),
+          range.end.getMonth(),
+          range.end.getDate(),
+        ).getTime();
+        return dateStart >= rangeStart && dateStart <= rangeEnd;
+      })
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/i18n/en.json

@@ -12,6 +12,10 @@
   "neptune.DateLookup.goTo20YearView": "Go to 20 year view",
   "neptune.DateLookup.month": "month",
   "neptune.DateLookup.next": "next",
+  "neptune.DateLookup.notAvailable": "not available",
+  "neptune.DateLookup.outOfRangeAfter": "Please select a date on or after {min}.",
+  "neptune.DateLookup.outOfRangeBefore": "Please select a date on or before {max}.",
+  "neptune.DateLookup.outOfRangeBetween": "Please select a date between {min} and {max}.",
   "neptune.DateLookup.previous": "previous",
   "neptune.DateLookup.selected": "selected",
   "neptune.DateLookup.twentyYears": "20 years",

package/src/index.ts

@@ -25,6 +25,8 @@ export type {
   ButtonProps as LegacyButtonProps,
   AnchorElementProps,
 } from './Button';
+export type { CalendarProps } from './Calendar';
+export type { DisabledRules, WeekDayType, DisabledDateRange } from './Calendar';
 export type { CardProps } from './_deprecated/Card';
 export type {
   CarouselProps,
@@ -55,7 +57,6 @@ export type {
 export type { BottomSheetProps } from './common/BottomSheet';
 export type { DateInputProps } from './DateInput';
 export type { DateLookupProps } from './DateLookup';
-export type { CalendarProps } from './Calendar';
 export type { DecisionProps } from './Decision';
 export type {
   DefinitionListProps,
@@ -201,6 +202,7 @@ export { default as Badge, BadgeAssets } from './_deprecated/Badge';
 export { default as Body } from './Body';
 export { default as Button } from './Button';
 export { default as IconButton } from './IconButton';
+export { default as Calendar } from './Calendar';
 export { default as Carousel } from './Carousel';
 export { default as Card } from './_deprecated/Card';
 export { default as Checkbox } from './Checkbox';
@@ -216,7 +218,6 @@ export { default as BaseCard } from './common/BaseCard';
 export { default as CriticalCommsBanner } from './_deprecated/CriticalBanner';
 export { default as DateInput } from './DateInput';
 export { default as DateLookup } from './DateLookup';
-export { default as Calendar } from './Calendar';
 export { default as Decision } from './Decision';
 export { default as DefinitionList } from './DefinitionList';
 export { default as Dimmer } from './Dimmer';