willba-component-library 0.2.54 → 0.2.56

package/lib/assets/IconsSvg.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type Icon = 'spinner' | 'warning';
+type Props = {
+    fill?: string;
+    size?: number;
+    icon: Icon;
+};
+export declare const IconsSvg: ({ fill, size, icon }: Props) => React.JSX.Element | undefined;
+export {};

package/lib/components/FilterBar/FilterBar.stories.d.ts

@@ -3,4 +3,4 @@ import FilterBar from './FilterBar';
 declare const meta: Meta<typeof FilterBar>;
 export default meta;
 type Story = StoryObj<typeof FilterBar>;
-export declare const Primary: Story;
+export declare const Main: Story;

package/lib/components/FilterCalendar/FilterCalendar.d.ts

@@ -2,4 +2,4 @@ import React from 'react';
 import '../../themes/Default.css';
 import { FilterCalendarTypes } from './FilterCalendarTypes';
 import './FilterCalendar.css';
-export default function FilterCalendar({ calendarOffset, language, palette, onSubmit, disableCalendarDates, toggleCalendar, loadingData, setToggleCalendar, requestDates, showFeedback, noActiveSelection, }: FilterCalendarTypes): React.JSX.Element;
+export default function FilterCalendar({ calendarOffset, language, palette, onSubmit, disableCalendarDates, toggleCalendar, loadingData, setToggleCalendar, requestDates, showFeedback, noActiveSelection, rangeContext, }: FilterCalendarTypes): React.JSX.Element;

package/lib/components/FilterCalendar/FilterCalendar.stories.d.ts

@@ -3,4 +3,5 @@ import FilterCalendar from './FilterCalendar';
 declare const meta: Meta<typeof FilterCalendar>;
 export default meta;
 type Story = StoryObj<typeof FilterCalendar>;
-export declare const Primary: Story;
+export declare const Default: Story;
+export declare const RangeContext: Story;

package/lib/components/FilterCalendar/hooks/useFilterCalendar.d.ts

@@ -16,8 +16,8 @@ export declare const useFilterCalendar: ({ onSubmit, setToggleCalendar, noActive
     disabledDates: Matcher[];
     updateCalendarMonthNavigation: boolean;
     updateCalendarDefaultMoth: number;
-    initialCalendarRange: DateRange | undefined;
-    overlappingDates: boolean;
-    setOverlappingDates: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    calendarHasError: boolean;
+    setCalendarHasError: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setUpdatedForSubmit: import("react").Dispatch<import("react").SetStateAction<boolean>>;
 };
 export {};

package/lib/core/components/calendar/CalendarTypes.d.ts

@@ -17,10 +17,10 @@ export type DisableCalendarDates = {
         page: string;
         offset: number;
     }[];
-    selectedDates?: {
-        to: Date;
-        from: Date;
-    };
+};
+export type RangeContext = {
+    from: Date;
+    to: Date;
 };
 export type CalendarTypes = {
     calendarRange?: DateRange | undefined;
@@ -33,12 +33,14 @@ export type CalendarTypes = {
     disabledDates?: Matcher[];
     setDisabledDates?: (arg: Matcher[]) => void;
     loadingData?: boolean;
-    initialCalendarRange?: DateRange | undefined;
     showFeedback?: boolean;
     noActiveSelection?: boolean;
     palette?: Palette;
     updateCalendarMonthNavigation?: boolean;
     setUpdateCalendarMonthNavigation?: (arg: (prev: boolean) => boolean) => void;
     updateCalendarDefaultMoth?: number;
-    setOverlappingDates: (arg: boolean) => void;
+    setCalendarHasError?: (arg: boolean) => void;
+    setUpdatedForSubmit?: (arg: boolean) => void;
+    rangeContext?: RangeContext;
+    calendarHasError?: boolean;
 };

package/lib/core/components/calendar/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useCalendarTooltips } from './useCalendarTooltips';
+export { useCalendarLoadingSpinner } from './useCalendarLoadingSpinner';
+export { useUpdateDisabledDates } from './useUpdateDisabledDates';

package/lib/core/components/calendar/hooks/useCalendarLoadingSpinner.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    loadingData?: boolean;
+    updateCalendarMonthNavigation?: boolean;
+    updateCalendarDefaultMoth?: number;
+};
+export declare const useCalendarLoadingSpinner: ({ loadingData, updateCalendarMonthNavigation, updateCalendarDefaultMoth, }: Props) => void;
+export {};

package/lib/core/components/calendar/hooks/useCalendarTooltips.d.ts

@@ -0,0 +1,10 @@
+import { DateRange } from 'react-day-picker';
+type Props = {
+    calendarRange?: DateRange;
+    updateCalendarMonthNavigation?: boolean;
+    overlappingDate?: DateRange[];
+    updateCalendarDefaultMoth?: number;
+    showFeedback?: boolean;
+};
+export declare const useCalendarTooltips: ({ calendarRange, updateCalendarMonthNavigation, overlappingDate, updateCalendarDefaultMoth, showFeedback, }: Props) => void;
+export {};

package/lib/core/components/calendar/hooks/useUpdateDisabledDates.d.ts

@@ -0,0 +1,13 @@
+import { DateRange } from 'react-day-picker';
+import { DisableCalendarDates } from '../CalendarTypes';
+type Props = {
+    disableCalendarDates?: DisableCalendarDates;
+    calendarRange?: DateRange;
+    updateCalendarMonthNavigation?: boolean;
+    updateCalendarDefaultMoth?: number;
+};
+export declare const useUpdateDisabledDates: ({ disableCalendarDates, calendarRange, updateCalendarMonthNavigation, updateCalendarDefaultMoth, }: Props) => {
+    newDisableCalendarDates: DisableCalendarDates | undefined;
+    overlappingDate: DateRange[] | undefined;
+};
+export {};

package/lib/core/components/calendar/utils/calendarSelectionRules.d.ts

@@ -0,0 +1,15 @@
+import { DateRange, Matcher } from 'react-day-picker';
+import { DisableCalendarDates, RangeContext } from '../CalendarTypes';
+type Props = {
+    range: DateRange | undefined;
+    newDisableCalendarDates?: DisableCalendarDates;
+    setCalendarRange: (range: DateRange | undefined) => void;
+    setDisabledDates?: (arg: Matcher[]) => void;
+    setCalendarHasError?: (arg: boolean) => void;
+    calendarRange?: DateRange;
+    overlappingDate?: DateRange[];
+    calendarHasError?: boolean;
+    rangeContext?: RangeContext;
+};
+export declare const calendarSelectionRules: ({ range, newDisableCalendarDates, setCalendarRange, setDisabledDates, calendarRange, overlappingDate, setCalendarHasError, rangeContext, }: Props) => void;
+export {};

package/lib/core/components/calendar/utils/checkForContinuousSelection.d.ts

@@ -0,0 +1,10 @@
+import { DateRange } from 'react-day-picker';
+import { RangeContext } from '../CalendarTypes';
+type Props = {
+    setCalendarHasError?: (arg: boolean) => void;
+    rangeContext?: RangeContext;
+    calendarRange?: DateRange;
+    calendarHasError?: boolean;
+};
+export declare const checkForContinuousSelection: ({ setCalendarHasError, rangeContext, calendarRange, calendarHasError, }: Props) => void;
+export {};

package/lib/core/components/calendar/utils/disabledDatesByPage.d.ts

@@ -0,0 +1,9 @@
+import { DisableCalendarDates } from '../CalendarTypes';
+export declare const disabledDatesByPage: ({ newDisableCalendarDates, selectedPath, today, }: {
+    newDisableCalendarDates?: DisableCalendarDates | undefined;
+    selectedPath?: string | undefined;
+    today: Date;
+}) => {
+    from: Date;
+    to: Date;
+}[];

package/lib/core/components/calendar/utils/handleCalendarModifiers.d.ts

@@ -0,0 +1,46 @@
+import { DateRange, Matcher } from 'react-day-picker';
+import { DisableCalendarDates, RangeContext } from '../CalendarTypes';
+type Props = {
+    newDisableCalendarDates?: DisableCalendarDates;
+    calendarRange?: DateRange;
+    disabledDatesByPage: {
+        from: Date;
+        to: Date;
+    }[];
+    disabledDates?: Matcher[];
+    overlappingDate?: DateRange[];
+    rangeContext?: RangeContext;
+    findFirstPossibleRangeContextCheckIn?: NonNullable<DisableCalendarDates['availableDates']>['0'];
+    findLastPossibleRangeContextCheckOut?: NonNullable<DisableCalendarDates['availableDates']>['0'];
+    firstPossibleRangeContextCheckIn: Matcher[];
+    lastPossibleRangeContextCheckOut: Matcher[];
+    currentSelectionLastCheckoutDate?: NonNullable<DisableCalendarDates['availableDates']>['0'];
+};
+export declare const handleCalendarModifiers: ({ newDisableCalendarDates, calendarRange, disabledDatesByPage, disabledDates, overlappingDate, rangeContext, firstPossibleRangeContextCheckIn, lastPossibleRangeContextCheckOut, findFirstPossibleRangeContextCheckIn, findLastPossibleRangeContextCheckOut, currentSelectionLastCheckoutDate, }: Props) => {
+    booked: Matcher[];
+    disabledAfterCheckIn: {
+        after: Date;
+    }[];
+    overlappingDate: {
+        from: Date | undefined;
+    }[];
+    noActiveSelectionStart: never[] | Date;
+    noActiveSelectionMid: {
+        from: Date;
+        to: Date;
+    }[];
+    noActiveSelectionEnd: never[] | Date;
+    checkoutOptionsMid: {
+        after: Date;
+        before: Date;
+    }[];
+    checkInOnly: {
+        from: Date;
+        to: Date;
+    }[];
+    checkOutOnly: {
+        from: Date;
+        to: Date;
+    }[];
+};
+export {};

package/lib/core/components/calendar/utils/handleRangeContextDisabledDates.d.ts

@@ -0,0 +1,27 @@
+import { DateRange, Matcher } from 'react-day-picker';
+import { DisableCalendarDates, RangeContext } from '../CalendarTypes';
+type Props = {
+    rangeContext?: RangeContext;
+    availableDates?: DisableCalendarDates['availableDates'];
+    calendarRange?: DateRange;
+};
+export declare const handleRangeContextDisabledDates: ({ rangeContext, availableDates, calendarRange, }: Props) => {
+    findFirstPossibleRangeContextCheckIn: {
+        checkIn: Date;
+        firstCheckOut: Date;
+        lastCheckOut: Date;
+    } | undefined;
+    findLastPossibleRangeContextCheckOut: {
+        checkIn: Date;
+        firstCheckOut: Date;
+        lastCheckOut: Date;
+    } | undefined;
+    firstPossibleRangeContextCheckIn: Matcher[];
+    lastPossibleRangeContextCheckOut: Matcher[];
+    currentSelectionLastCheckoutDate: {
+        checkIn: Date;
+        firstCheckOut: Date;
+        lastCheckOut: Date;
+    } | undefined;
+};
+export {};

package/lib/core/components/calendar/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { parseDates } from './parseDates';
+export { parseDate } from './parseDate';
+export { nightsCount } from './nightsCount';
+export { calendarSelectionRules } from './calendarSelectionRules';
+export { disabledDatesByPage } from './disabledDatesByPage';
+export { handleCalendarModifiers } from './handleCalendarModifiers';
+export { handleRangeContextDisabledDates } from './handleRangeContextDisabledDates';
+export { checkForContinuousSelection } from './checkForContinuousSelection';

package/lib/core/components/calendar/utils/nightsCount.d.ts

@@ -0,0 +1,6 @@
+import { DateRange } from 'react-day-picker';
+type Props = {
+    calendarRange?: DateRange;
+};
+export declare const nightsCount: ({ calendarRange }: Props) => number | undefined;
+export {};

package/lib/core/components/calendar/utils/parseDate.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    date?: Date;
+    dateFormat?: string;
+    language?: string;
+};
+export declare const parseDate: ({ date, dateFormat, language, }: Props) => string | null;
+export {};

package/lib/core/components/calendar/utils/parseDates.d.ts

@@ -0,0 +1,6 @@
+import { DateRange } from 'react-day-picker';
+type Props = {
+    calendarRange?: DateRange;
+};
+export declare const parseDates: ({ calendarRange }: Props) => string | null;
+export {};

package/lib/index.d.ts

@@ -31,6 +31,7 @@ declare const Button: ({ type, textColor, size, onClick, label, }: ButtonProps)
 type Palette = {
     primary: string;
     secondary: string;
+    error: string;
 };
 
 type CalendarOffset = {
@@ -50,10 +51,10 @@ type DisableCalendarDates = {
         page: string;
         offset: number;
     }[];
-    selectedDates?: {
-        to: Date;
-        from: Date;
-    };
+};
+type RangeContext = {
+    from: Date;
+    to: Date;
 };
 type CalendarTypes = {
     calendarRange?: DateRange | undefined;
@@ -66,14 +67,16 @@ type CalendarTypes = {
     disabledDates?: Matcher[];
     setDisabledDates?: (arg: Matcher[]) => void;
     loadingData?: boolean;
-    initialCalendarRange?: DateRange | undefined;
     showFeedback?: boolean;
     noActiveSelection?: boolean;
     palette?: Palette;
     updateCalendarMonthNavigation?: boolean;
     setUpdateCalendarMonthNavigation?: (arg: (prev: boolean) => boolean) => void;
     updateCalendarDefaultMoth?: number;
-    setOverlappingDates: (arg: boolean) => void;
+    setCalendarHasError?: (arg: boolean) => void;
+    setUpdatedForSubmit?: (arg: boolean) => void;
+    rangeContext?: RangeContext;
+    calendarHasError?: boolean;
 };
 
 type FilterBarProps = {
@@ -119,6 +122,6 @@ interface FilterCalendarTypes extends Partial<CalendarTypes> {
     setToggleCalendar: (val: boolean) => void;
 }
 
-declare function FilterCalendar({ calendarOffset, language, palette, onSubmit, disableCalendarDates, toggleCalendar, loadingData, setToggleCalendar, requestDates, showFeedback, noActiveSelection, }: FilterCalendarTypes): React.JSX.Element;
+declare function FilterCalendar({ calendarOffset, language, palette, onSubmit, disableCalendarDates, toggleCalendar, loadingData, setToggleCalendar, requestDates, showFeedback, noActiveSelection, rangeContext, }: FilterCalendarTypes): React.JSX.Element;
 
 export { Button, FilterBar, FilterCalendar, FilterCalendarTypes, Tab };