guestbell-forms 3.0.38 → 3.0.40

package/src/lib/components/bookingCalendar/BookingCalendar.tsx

@@ -0,0 +1,327 @@
+import * as React from 'react';
+import {
+  BookingCalendarClasses,
+  bookingCalendarDefaultClasses,
+} from './classes';
+import classNames from 'classnames';
+import {
+  BookingCalendarDateRange,
+  BookingCalendarItemT,
+  defaultGetMomentFormatFunction,
+  GetNewMomentFunctionType,
+  defaultGetNewMomentFunction,
+  defaultGridAvailableSteps,
+  GetMomentFormatFunctionType,
+  ZoomLevel,
+} from './common';
+import {
+  BookingCalendarControls as DefaultBookingCalendarControls,
+  BookingCalendarControlsProps,
+} from './bookingCalendarControls/BookingCalendarControls';
+import {
+  generateGridItems,
+  LaneSourceData,
+  splitBookingsToLanes,
+} from './utils';
+import {
+  BookingCalendarLane as DefaultBookingCalendarLane,
+  BookingCalendarLaneProps,
+} from './bookingCalendarLane/BookingCalendarLane';
+import moment, { Moment, Duration } from 'moment';
+import { BookingCalendarItemProps } from './bookingCalendarItem';
+import { BookingCalendarRenderItemProps } from './bookingCalendarRenderItem';
+import {
+  BookingCalendarGrid as DefaultBookingCalendarGrid,
+  BookingCalendarGridProps,
+} from './bookingCalendarGrid/BookingCalendarGrid';
+import {
+  BookingCalendarLaneHeader as DefaultBookingCalendarLaneHeader,
+  BookingCalendarLaneHeaderProps,
+} from './bookingCalendarLaneHeader';
+import {
+  BookingCalendarLanesHeader as DefaultBookingCalendarLanesHeader,
+  BookingCalendarLanesHeaderProps,
+} from './bookingCalendarLanesHeader';
+import {
+  BookingCalendarDatePicker as DefaultBookingCalendarDatePicker,
+  BookingCalendarDatePickerProps,
+} from './bookingCalendarDatePicker';
+import { BookingCalendarTimeAxis } from './bookingCalendarTimeAxis/BookingCalendarTimeAxis';
+import useDimensions from 'react-cool-dimensions';
+import BookingCalendarSelection, {
+  BookingCalendarSelectionData,
+} from './bookingCalendarSelection/BookingCalendarSelection';
+
+export interface BookingCalendarProps<T extends BookingCalendarItemT, TLaneData>
+  extends BookingCalendarClasses {
+  bookings: T[];
+  from: Moment;
+  till: Moment;
+  getMomentFormatFunction?: GetMomentFormatFunctionType;
+  getNewMomentFunction?: GetNewMomentFunctionType;
+  onRangeChange?: (range: BookingCalendarDateRange) => void;
+  step?: Duration;
+  showZoomAllButton?: boolean;
+  showGrid?: boolean;
+  showSelection?: boolean;
+  minSelectionSize?: number;
+  gridAvailableSteps?: Duration[];
+  goalGridWidthPx?: number;
+  minLanesCount?: number;
+  lanesSource?: LaneSourceData<T, TLaneData>[];
+  unmatchedLanesToFront?: boolean;
+  children?: React.ReactNode;
+  bookingCalendarTopLeftHeader?: React.ReactNode;
+  filteringButton?: React.ReactNode;
+
+  zoomLevels?: ZoomLevel[];
+  filterBookingsToZoom?: (booking: T) => boolean;
+
+  BookingCalendarItem?: React.ComponentType<BookingCalendarItemProps<T>>;
+  BookingCalendarRenderItem?: React.ComponentType<
+    BookingCalendarRenderItemProps<T>
+  >;
+  BookingCalendarLane?: React.ComponentType<BookingCalendarLaneProps<T>>;
+  BookingCalendarControls?: React.ComponentType<
+    BookingCalendarControlsProps<T>
+  >;
+  BookingCalendarGrid?: React.ComponentType<BookingCalendarGridProps>;
+  BookingCalendarLaneHeader?: React.ComponentType<
+    BookingCalendarLaneHeaderProps<TLaneData>
+  >;
+  BookingCalendarLanesHeader?: React.ComponentType<
+    BookingCalendarLanesHeaderProps<T>
+  >;
+  BookingCalendarDatePicker?:
+    | React.ComponentType<BookingCalendarDatePickerProps<T>>
+    | React.ReactNode;
+}
+
+const defaultStep = moment.duration(1, 'day');
+
+export function BookingCalendar<T extends BookingCalendarItemT, TLaneData>(
+  props: BookingCalendarProps<T, TLaneData>
+) {
+  const {
+    bookings,
+    className,
+    laneContainerClassName,
+    laneHeaderContainerClassName,
+    lanesHeaderContainerClassName,
+    lanesHeaderHeaderContainerClassName,
+    controlsClasses,
+    tableClassName,
+    from,
+    till,
+    onRangeChange,
+    step = defaultStep,
+    showGrid = true,
+    showSelection = true,
+    showZoomAllButton = true,
+    gridAvailableSteps = defaultGridAvailableSteps,
+    getMomentFormatFunction = defaultGetMomentFormatFunction,
+    getNewMomentFunction = defaultGetNewMomentFunction,
+    goalGridWidthPx = 60,
+    minSelectionSize = 10,
+    minLanesCount,
+    lanesSource,
+    unmatchedLanesToFront = true,
+    filterBookingsToZoom,
+    zoomLevels,
+    BookingCalendarControls = DefaultBookingCalendarControls,
+    BookingCalendarItem,
+    BookingCalendarLane = DefaultBookingCalendarLane,
+    BookingCalendarRenderItem,
+    BookingCalendarGrid = DefaultBookingCalendarGrid,
+    BookingCalendarLaneHeader = DefaultBookingCalendarLaneHeader,
+    BookingCalendarLanesHeader = DefaultBookingCalendarLanesHeader,
+    BookingCalendarDatePicker = DefaultBookingCalendarDatePicker,
+    bookingCalendarTopLeftHeader,
+    filteringButton,
+    children,
+  } = props;
+  const lanes = React.useMemo(
+    () =>
+      splitBookingsToLanes<T, TLaneData>(
+        bookings,
+        from,
+        minLanesCount,
+        lanesSource,
+        unmatchedLanesToFront
+      ),
+    [bookings, from, minLanesCount, lanesSource, unmatchedLanesToFront]
+  );
+  const { observe, entry } = useDimensions<HTMLDivElement>();
+  const width = entry?.target?.scrollWidth ?? 0;
+  const { items: gridItems, bestStep } = React.useMemo(
+    () =>
+      generateGridItems(
+        from,
+        till,
+        step,
+        width,
+        gridAvailableSteps,
+        goalGridWidthPx,
+        from?.clone()?.startOf('day')
+      ),
+    [from, till, step, width, gridAvailableSteps, goalGridWidthPx]
+  );
+  const onSelected = React.useCallback(
+    (data: BookingCalendarSelectionData) => {
+      if (!from || !till || !width || !onRangeChange) {
+        return;
+      }
+      const screenSpaceStartX = Math.min(data.origin[0], data.target[0]);
+      const screenSpaceEndX = Math.max(data.origin[0], data.target[0]);
+      const durationMs = till.valueOf() - from.valueOf();
+      const toTimeSpace = (num: number) => (num / (width || 1)) * durationMs;
+      const timeSpaceStart = from
+        .clone()
+        .add(toTimeSpace(screenSpaceStartX), 'ms');
+      const timeSpaceEnd = from.clone().add(toTimeSpace(screenSpaceEndX), 'ms');
+      onRangeChange({ from: timeSpaceStart, till: timeSpaceEnd });
+    },
+    [from, till, width, onRangeChange]
+  );
+  return (
+    <div
+      className={classNames(bookingCalendarDefaultClasses.className, className)}
+    >
+      <BookingCalendarControls<T>
+        {...controlsClasses}
+        items={bookings}
+        from={from}
+        till={till}
+        onRangeChange={onRangeChange}
+        step={step}
+        filterBookingsToZoom={filterBookingsToZoom}
+        zoomLevels={zoomLevels}
+        filteringButton={filteringButton}
+        showZoomAllButton={showZoomAllButton}
+        bookingCalendarDatePicker={
+          <>
+            {typeof BookingCalendarDatePicker === 'function' ? (
+              <BookingCalendarDatePicker
+                from={from}
+                till={till}
+                onRangeChange={onRangeChange}
+                getNewMomentFunction={getNewMomentFunction}
+              />
+            ) : (
+              BookingCalendarDatePicker
+            )}
+          </>
+        }
+      />
+      <div
+        className={classNames(
+          bookingCalendarDefaultClasses.tableClassName,
+          tableClassName
+        )}
+      >
+        {showGrid && (
+          <BookingCalendarGrid
+            items={gridItems}
+            dataRowsCount={lanes.length}
+            width={width}
+          />
+        )}
+        {showSelection && (
+          <BookingCalendarSelection
+            dataRowsCount={lanes.length}
+            onSelected={onSelected}
+            minSelectionSize={minSelectionSize}
+          />
+        )}
+        <div
+          className={classNames(
+            bookingCalendarDefaultClasses.lanesHeaderHeaderContainerClassName,
+            lanesHeaderHeaderContainerClassName
+          )}
+        >
+          {bookingCalendarTopLeftHeader}
+        </div>
+        <div
+          className={classNames(
+            bookingCalendarDefaultClasses.lanesHeaderContainerClassName,
+            lanesHeaderContainerClassName
+          )}
+          ref={observe}
+        >
+          <BookingCalendarLanesHeader<T>
+            {...controlsClasses}
+            from={from}
+            till={till}
+            onRangeChange={onRangeChange}
+            step={step}
+          />
+        </div>
+
+        {lanes.map((lane, laneIndex) => {
+          const LaneBookingCalendarLaneHeader =
+            lane.BookingCalendarLaneHeader ?? BookingCalendarLaneHeader;
+          const LaneBookingCalendarLane =
+            lane.BookingCalendarLane ?? BookingCalendarLane;
+          return (
+            <React.Fragment key={laneIndex}>
+              <div
+                className={classNames(
+                  bookingCalendarDefaultClasses.laneHeaderContainerClassName,
+                  laneHeaderContainerClassName,
+                  lane.rowClassName,
+                  {
+                    [`${bookingCalendarDefaultClasses.laneHeaderContainerClassName}--last`]:
+                      laneIndex === lanes.length - 1,
+                    [`${bookingCalendarDefaultClasses.laneHeaderContainerClassName}--first`]:
+                      laneIndex === 0,
+                  }
+                )}
+              >
+                <LaneBookingCalendarLaneHeader<TLaneData>
+                  laneKey={lane.laneKey ?? laneIndex}
+                  data={lane.data}
+                />
+              </div>
+              <div
+                className={classNames(
+                  bookingCalendarDefaultClasses.laneContainerClassName,
+                  laneContainerClassName,
+                  lane.rowClassName,
+                  {
+                    [`${bookingCalendarDefaultClasses.laneContainerClassName}--last`]:
+                      laneIndex === lanes.length - 1,
+                    [`${bookingCalendarDefaultClasses.laneContainerClassName}--first`]:
+                      laneIndex === 0,
+                  }
+                )}
+              >
+                <LaneBookingCalendarLane
+                  laneIndex={laneIndex}
+                  items={lane.items}
+                  from={from}
+                  till={till}
+                  BookingCalendarItem={
+                    lane.BookingCalendarItem ?? BookingCalendarItem
+                  }
+                  BookingCalendarRenderItem={
+                    lane.BookingCalendarRenderItem ?? BookingCalendarRenderItem
+                  }
+                  step={step}
+                />
+              </div>
+            </React.Fragment>
+          );
+        })}
+        <div />
+        <div>
+          <BookingCalendarTimeAxis
+            items={gridItems}
+            bestStep={bestStep}
+            getMomentFormatFunction={getMomentFormatFunction}
+          />
+        </div>
+      </div>
+      {children}
+    </div>
+  );
+}

package/src/lib/components/bookingCalendar/bookingCalendarControls/BookingCalendarControls.tsx

@@ -0,0 +1,249 @@
+import classNames from 'classnames';
+import * as React from 'react';
+import {
+  BookingCalendarDateRange,
+  BookingCalendarItemT,
+  ZoomLevel,
+} from '../common';
+import moment, { Duration, Moment } from 'moment';
+import { BookingCalendarControlsClasses } from './classes';
+import { bookingCalendarControlsDefaultClasses } from './classes';
+import { Button } from '../../button/Button';
+import * as LeftArrowLongIcon from 'material-design-icons/navigation/svg/production/ic_arrow_back_24px.svg';
+import * as LeftArrowIcon from 'material-design-icons/hardware/svg/production/ic_keyboard_arrow_left_24px.svg';
+import * as RightArrowLongIcon from 'material-design-icons/navigation/svg/production/ic_arrow_forward_24px.svg';
+import * as RightArrowIcon from 'material-design-icons/hardware/svg/production/ic_keyboard_arrow_right_24px.svg';
+import * as UnfoldLessIcon from 'material-design-icons/navigation/svg/production/ic_unfold_less_24px.svg';
+import * as DateRangeIcon from 'material-design-icons/action/svg/production/ic_date_range_24px.svg';
+
+import Menu from '@mui/material/Menu';
+import MenuItem from '@mui/material/MenuItem';
+
+export interface BookingCalendarControlsProps<T extends BookingCalendarItemT>
+  extends BookingCalendarControlsClasses {
+  items: T[];
+  step: Duration;
+  from: Moment;
+  till: Moment;
+  zoomLevels?: ZoomLevel[];
+  onRangeChange?: (range: BookingCalendarDateRange) => void;
+  filterBookingsToZoom?: (booking: T) => boolean;
+  bookingCalendarDatePicker?: React.ReactNode;
+  filteringButton?: React.ReactNode;
+  showZoomAllButton?: boolean;
+}
+
+export function BookingCalendarControls<T extends BookingCalendarItemT>(
+  props: BookingCalendarControlsProps<T>
+) {
+  const {
+    className,
+    monthLabelClassName,
+    buttonsContainerClassName,
+    zoomBookingsButtonClassName,
+    zoomLevelsContainerClassName,
+    zoomLevelsButtonClassName,
+    zoomLevels,
+    step,
+    from,
+    till,
+    onRangeChange,
+    items,
+    filterBookingsToZoom = () => true,
+    bookingCalendarDatePicker,
+    filteringButton,
+    showZoomAllButton,
+  } = props;
+  if (!step || !from || !till) {
+    return null;
+  }
+  const onStepFactory = React.useCallback(
+    (_step: Duration) => () =>
+      onRangeChange({
+        from: from.clone().add(_step),
+        till: till.clone().add(_step),
+      }),
+    [from, till, onRangeChange]
+  );
+  const onBigStepLeftClick = React.useCallback(
+    onStepFactory(moment.duration(-7, 'days')),
+    [onStepFactory, till, from]
+  );
+  const onSmallStepLeftClick = React.useCallback(
+    onStepFactory(moment.duration(-1, 'day')),
+    [onStepFactory, step]
+  );
+  const onBigStepRightClick = React.useCallback(
+    onStepFactory(moment.duration(7, 'days')),
+    [onStepFactory, till, from]
+  );
+  const onSmallStepRightClick = React.useCallback(
+    onStepFactory(moment.duration(1, 'day')),
+    [onStepFactory, step]
+  );
+  const filteredItems = React.useMemo(
+    () => items?.filter(filterBookingsToZoom),
+    [filterBookingsToZoom, items]
+  );
+  const onZoomBookingsClick = React.useCallback(() => {
+    const minFromMs =
+      Math.min(
+        ...filteredItems
+          ?.filter(filterBookingsToZoom)
+          .map((a) => a.from.valueOf())
+      ) ?? from?.valueOf();
+    const minFrom = from.clone().subtract(from.valueOf() - minFromMs, 'ms');
+    const maxTillMs =
+      Math.max(
+        ...filteredItems
+          ?.filter(filterBookingsToZoom)
+          .map((a) => a.till.valueOf())
+      ) ?? till?.valueOf();
+    const maxTill = till.clone().subtract(till.valueOf() - maxTillMs, 'ms');
+    onRangeChange({
+      from: minFrom,
+      till: maxTill,
+    });
+  }, [from, till, filteredItems]);
+  const [anchorEl, setAnchorEl] = React.useState<null | HTMLElement>(null);
+  const open = Boolean(anchorEl);
+  const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
+    setAnchorEl(event.currentTarget);
+  };
+  const handleClose = () => {
+    setAnchorEl(null);
+  };
+  const selectedLevel = React.useMemo(
+    () =>
+      zoomLevels?.find(
+        (level) =>
+          till.valueOf() - from.valueOf() === level.step.asMilliseconds()
+      ),
+    [zoomLevels, till, from]
+  );
+  return (
+    <div
+      className={classNames(
+        bookingCalendarControlsDefaultClasses.className,
+        className
+      )}
+    >
+      {bookingCalendarDatePicker && (
+        <div
+          className={classNames(
+            bookingCalendarControlsDefaultClasses.monthLabelClassName,
+            monthLabelClassName
+          )}
+        >
+          {bookingCalendarDatePicker}
+        </div>
+      )}
+      {zoomLevels?.length > 0 && (
+        <div
+          className={classNames(
+            bookingCalendarControlsDefaultClasses.zoomLevelsContainerClassName,
+            zoomLevelsContainerClassName
+          )}
+        >
+          <Button
+            id="zoom-level-button"
+            className={classNames(
+              bookingCalendarControlsDefaultClasses.zoomLevelsButtonClassName,
+              zoomLevelsButtonClassName
+            )}
+            aria-controls={open ? 'zoom-level-menu' : undefined}
+            aria-haspopup="true"
+            aria-expanded={open ? 'true' : undefined}
+            onClick={handleClick}
+            noShadow={true}
+          >
+            <DateRangeIcon />
+            {selectedLevel ? ` ${selectedLevel.label}` : ''}
+          </Button>
+          <Menu
+            id="zoom-level-menu"
+            anchorEl={anchorEl}
+            open={open}
+            onClose={handleClose}
+            MenuListProps={{
+              'aria-labelledby': 'zoom-level-button',
+            }}
+          >
+            {zoomLevels.map((level, index) => (
+              <MenuItem
+                data-level={index}
+                key={index}
+                onClick={() => {
+                  onRangeChange({
+                    from: from.clone().startOf('day'),
+                    till: from.clone().startOf('day').add(level.step),
+                  });
+                  setAnchorEl(null);
+                }}
+                selected={
+                  till.valueOf() - from.valueOf() ===
+                  level.step.asMilliseconds()
+                }
+              >
+                {level.label}
+              </MenuItem>
+            ))}
+          </Menu>
+          {/*zoomLevels.map((level, index) => (
+            <Button
+              type={
+                till.valueOf() - from.valueOf() === level.step.asMilliseconds()
+                  ? 'primary'
+                  : undefined
+              }
+              // blank={true}
+              noShadow={true}
+              key={index}
+              onClick={() =>
+                onRangeChange({
+                  from: from.clone().startOf('day'),
+                  till: from.clone().startOf('day').add(level.step),
+                })
+              }
+            >
+              {level.label}
+            </Button>
+            ))*/}
+        </div>
+      )}
+      <div
+        className={classNames(
+          bookingCalendarControlsDefaultClasses.buttonsContainerClassName,
+          buttonsContainerClassName
+        )}
+      >
+        <Button noShadow={true} onClick={onBigStepLeftClick}>
+          <LeftArrowLongIcon />
+        </Button>
+        <Button noShadow={true} onClick={onSmallStepLeftClick}>
+          <LeftArrowIcon />
+        </Button>
+        <Button noShadow={true} onClick={onSmallStepRightClick}>
+          <RightArrowIcon />
+        </Button>
+        <Button noShadow={true} onClick={onBigStepRightClick}>
+          <RightArrowLongIcon />
+        </Button>
+        {showZoomAllButton && (
+          <Button
+            className={classNames(
+              bookingCalendarControlsDefaultClasses.zoomBookingsButtonClassName,
+              zoomBookingsButtonClassName
+            )}
+            noShadow={true}
+            disabled={!filteredItems?.length}
+            onClick={onZoomBookingsClick}
+          >
+            <UnfoldLessIcon />
+          </Button>
+        )}
+        {filteringButton}
+      </div>
+    </div>
+  );
+}

package/src/lib/components/bookingCalendar/bookingCalendarControls/classes.ts

@@ -0,0 +1,20 @@
+export interface BookingCalendarControlsClasses {
+  className?: string;
+  monthLabelClassName?: string;
+  zoomLevelsContainerClassName?: string;
+  buttonsContainerClassName?: string;
+  zoomBookingsButtonClassName?: string;
+  zoomLevelsButtonClassName?: string;
+}
+
+export const bookingCalendarControlsDefaultClasses: BookingCalendarControlsClasses =
+  {
+    className: 'bookingCalendar__controls',
+    monthLabelClassName: 'bookingCalendar__controls__monthLabel',
+    buttonsContainerClassName: 'bookingCalendar__controls__buttonsContainer',
+    zoomLevelsContainerClassName:
+      'bookingCalendar__controls__zoomLevelsContainer',
+    zoomBookingsButtonClassName:
+      'bookingCalendar__controls__zoomBookingsButton',
+    zoomLevelsButtonClassName: 'bookingCalendar__controls__zoomLevelsButton',
+  };

package/src/lib/components/bookingCalendar/bookingCalendarControls/index.ts

@@ -0,0 +1,2 @@
+export * from './BookingCalendarControls';
+export * from './classes';

package/src/lib/components/bookingCalendar/bookingCalendarDatePicker/BookingCalendarDatePicker.tsx

@@ -0,0 +1,104 @@
+import * as React from 'react';
+import classNames from 'classnames';
+import {
+  BookingCalendarDatePickerClasses,
+  bookingCalendarDatePickerDefaultClasses,
+} from './classes';
+import { Moment } from 'moment';
+import {
+  BookingCalendarDateRange,
+  BookingCalendarItemT,
+  GetNewMomentFunctionType,
+  defaultGetNewMomentFunction,
+} from '../common';
+import { Button } from '../../button/Button';
+import * as EventIcon from 'material-design-icons/action/svg/production/ic_event_24px.svg';
+try {
+  var DatePicker = require('react-datepicker').default;
+} catch {
+  DatePicker = undefined;
+}
+// import DatePicker from 'react-datepicker';
+
+export interface BookingCalendarDatePickerBaseProps<
+  T extends BookingCalendarItemT
+> {
+  from: Moment;
+  till: Moment;
+  onRangeChange?: (range: BookingCalendarDateRange) => void;
+  getNewMomentFunction?: GetNewMomentFunctionType;
+}
+
+export interface BookingCalendarDatePickerProps<T extends BookingCalendarItemT>
+  extends BookingCalendarDatePickerClasses,
+    BookingCalendarDatePickerBaseProps<T> {}
+
+export function BookingCalendarDatePicker<T extends BookingCalendarItemT>(
+  props: BookingCalendarDatePickerProps<T>
+) {
+  const {
+    className,
+    buttonClassName,
+    from,
+    till,
+    onRangeChange,
+    getNewMomentFunction = defaultGetNewMomentFunction,
+  } = props;
+  const [shownModal, setShownModal] = React.useState<null | 'start' | 'end'>();
+  const calendarRef = React.useRef<typeof DatePicker>();
+  const onButtonClick = React.useCallback(() => {
+    setShownModal('start');
+    calendarRef.current.setOpen(true);
+  }, []);
+  return (
+    <div
+      className={classNames(
+        bookingCalendarDatePickerDefaultClasses.className,
+        className
+      )}
+    >
+      <Button
+        className={classNames(
+          bookingCalendarDatePickerDefaultClasses.buttonClassName,
+          buttonClassName
+        )}
+        noShadow={true}
+        onClick={onButtonClick}
+      >
+        <EventIcon /> {from?.format('MMMM, YYYY')}
+      </Button>
+      <DatePicker
+        ref={calendarRef}
+        customInput={<span />}
+        selected={from?.toDate()}
+        // selectsRange={true}
+        selectsStart={shownModal !== 'end'}
+        selectsEnd={shownModal === 'end'}
+        startDate={from?.toDate()}
+        endDate={till?.toDate()}
+        shouldCloseOnSelect={shownModal === 'end'}
+        //dateFormat={DAY_FORMAT}
+        onChange={(dt: Date) => {
+          if (shownModal !== 'end') {
+            const dtm = getNewMomentFunction(dt);
+            let validTill = till.clone();
+            if (dtm.isAfter(till)) {
+              validTill = dtm.clone().add(1, 'day');
+            }
+            onRangeChange({ from: dtm, till: validTill });
+            setShownModal('end');
+          } else {
+            let dtm = getNewMomentFunction(dt).startOf('day').add(1, 'day');
+            let validFrom = from.clone();
+            if (dtm.isBefore(from)) {
+              validFrom = dtm.clone().add(-1, 'day');
+            }
+            onRangeChange({ from: validFrom, till: dtm });
+            setShownModal(null);
+          }
+        }}
+        withPortal={true}
+      />
+    </div>
+  );
+}