@fremtind/jokul 0.8.1 → 0.10.0

package/build/components/checkbox/Checkbox.d.ts

@@ -0,0 +1,17 @@
+import { default as React, ReactNode, ChangeEventHandler, FocusEventHandler, InputHTMLAttributes } from 'react';
+import { DataTestAutoId, Density } from '../..';
+export interface CheckboxProps extends DataTestAutoId, InputHTMLAttributes<HTMLInputElement> {
+    children: ReactNode;
+    name: string;
+    value: string;
+    checked?: boolean;
+    inline?: boolean;
+    className?: string;
+    density?: Density;
+    invalid?: boolean;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    indeterminate?: boolean;
+}
+export declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;

package/build/components/checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export type { CheckboxProps } from './Checkbox';
+export { Checkbox } from './Checkbox';

package/build/components/combobox/Combobox.d.ts

@@ -0,0 +1,39 @@
+import { FC, ChangeEvent } from 'react';
+import { ValuePair, Density } from '../..';
+import { InputGroupProps, LabelProps } from '../input-group';
+export type ComboboxValuePair = ValuePair & {
+    tagLabel?: string;
+    isMarked?: boolean;
+};
+export declare function getComboboxValuePair(item: string | ComboboxValuePair): ComboboxValuePair;
+interface PartialChangeEvent extends Partial<Omit<ChangeEvent<HTMLElement>, "target">> {
+    type: "change" | "blur";
+    target: {
+        name: string;
+        value: string;
+        selectedOptions: Array<ValuePair>;
+    };
+}
+type ChangeEventHandler = (event: PartialChangeEvent) => void;
+interface ComboboxProps extends InputGroupProps {
+    id?: string;
+    placeholder?: string;
+    labelProps?: Omit<LabelProps, "children" | "density" | "htmlFor" | "standAlone">;
+    items: Array<ValuePair>;
+    noMatchingOption?: string;
+    label: string;
+    name: string;
+    value?: Array<ValuePair>;
+    density?: Density;
+    width?: string;
+    helpLabel?: string;
+    errorLabel?: string;
+    className?: string;
+    invalid?: boolean;
+    hasTagHover?: boolean;
+    onChange: ChangeEventHandler;
+    onBlur?: ChangeEventHandler;
+    onFocus?: ChangeEventHandler;
+}
+export declare const Combobox: FC<ComboboxProps>;
+export {};

package/build/components/combobox/index.d.ts

@@ -0,0 +1,2 @@
+export { Combobox, getComboboxValuePair } from './Combobox';
+export type { ComboboxValuePair } from './Combobox';

package/build/components/cookie-consent/CookieConsent.d.ts

@@ -0,0 +1,6 @@
+import { AcceptConsentCallback } from './types';
+export interface CookieConsentProps {
+    blocking?: boolean;
+    onAccept?: AcceptConsentCallback;
+}
+export declare const CookieConsent: ({ blocking, onAccept, ...rest }: CookieConsentProps) => JSX.Element | null;

package/build/components/cookie-consent/CookieConsentContext.d.ts

@@ -0,0 +1,48 @@
+import { default as React } from 'react';
+import { WithChildren } from '../..';
+import { Consent, ConsentRequirement } from './types';
+interface SetShowConsentAction {
+    type: "SET_SHOW_CONSENT";
+    payload: boolean;
+}
+interface SetShowSettingsAction {
+    type: "SET_SHOW_SETTINGS";
+    payload: boolean;
+}
+interface UpdateConsentAction {
+    type: "UPDATE_CONSENT";
+    payload: Consent;
+}
+interface UpdateRequirementsAction {
+    type: "UPDATE_REQUIREMENTS";
+    payload: ConsentRequirement;
+}
+type Action = SetShowConsentAction | UpdateConsentAction | SetShowSettingsAction | UpdateRequirementsAction;
+type Dispatch = (action: Action) => void;
+interface State {
+    isOpen: boolean;
+    showSettings: boolean;
+    requirement: ConsentRequirement;
+    consent: Consent;
+}
+export declare const DEFAULT_COOKIE_NAME = "fremtind-cookie-consent";
+export interface CookieConsentProviderProps extends Partial<ConsentRequirement>, WithChildren {
+    cookieAdapter?: () => Consent | undefined;
+    cookieName?: string;
+    cookieDomain?: string;
+}
+declare const CookieConsentProvider: React.FC<CookieConsentProviderProps>;
+interface UseCookieConsentState extends State {
+    dispatch: Dispatch;
+    cookieName: string;
+    cookieDomain?: string;
+}
+declare const useCookieConsentState: () => UseCookieConsentState;
+type UseCookieConsent = {
+    openConsentModalWithSettings: () => void;
+    openConsentModalWithDefaults: () => void;
+    /** Se hvilke samtykker som er gitt, om du for eksempel trenger styre UI basert på samtykker. */
+    consents: Consent;
+};
+declare const useCookieConsent: () => UseCookieConsent;
+export { CookieConsentProvider, useCookieConsentState, useCookieConsent };

package/build/components/cookie-consent/CookieConsentModal.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { ConsentComponentBaseProps } from './types';
+export declare const CookieConsentModal: FC<ConsentComponentBaseProps>;

package/build/components/cookie-consent/consents/CustomConsents.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { ModalConfig } from '../../modal';
+import { Consent } from '../types';
+type Props = {
+    modalConfig: ModalConfig;
+    handleAccept: (v: Consent | "implicit") => void;
+};
+export declare const CustomConsents: FC<Props>;
+export {};

package/build/components/cookie-consent/consents/DefaultConsents.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { ModalConfig } from '../../modal';
+import { Consent } from '../types';
+type Props = {
+    modalConfig: ModalConfig;
+    handleAccept: (v: Consent | "implicit") => void;
+};
+export declare const DefaultConsents: FC<Props>;
+export {};

package/build/components/cookie-consent/consents/RequirementCheckbox.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { WithChildren } from '../../..';
+interface RequirementCheckboxProps extends WithChildren {
+    defaultChecked: boolean;
+    name: "functional" | "marketing" | "statistics";
+    label: string;
+}
+export declare const RequirementCheckbox: ({ defaultChecked, name, label, children }: RequirementCheckboxProps) => React.JSX.Element;
+export {};

package/build/components/cookie-consent/cookieConsentUtils.d.ts

@@ -0,0 +1,23 @@
+import { Consent, ConsentRequirement, ConsentState } from './types';
+export declare const getConsentCookie: ({ adapter, name, }: {
+    adapter?: (() => Consent | undefined) | undefined;
+    name: string;
+}) => Consent | undefined;
+export declare const setConsentCookie: ({ consent, maxAge, name, domain, }: {
+    consent: Consent;
+    maxAge?: number | undefined;
+    name: string;
+    domain?: string | undefined;
+}) => void;
+export declare const shouldShowConsentDialog: (requirement: ConsentRequirement, consent: Consent | undefined) => boolean;
+export declare const convertConsentValueToFormValue: (consent: ConsentState) => boolean | undefined;
+export declare const convertConsentObjectToBooleans: (consent: Partial<Record<keyof Consent, ConsentState>>) => {
+    [k: string]: boolean | undefined;
+};
+export declare const convertBooleanToConsentValue: (formValue: boolean | undefined) => ConsentState;
+export declare const convertBooleanConsentObjectToConsentObject: (consent: Partial<Record<keyof Consent, boolean | undefined>>) => Consent;
+export declare const buildRequirementsObject: ({ marketing, functional, statistics }: ConsentRequirement) => {
+    statistics?: true | undefined;
+    functional?: true | undefined;
+    marketing?: true | undefined;
+};

package/build/components/cookie-consent/index.d.ts

@@ -0,0 +1,5 @@
+export type { AcceptConsentCallback, Consent, ConsentState } from './types';
+export type { CookieConsentProps } from './CookieConsent';
+export { CookieConsent } from './CookieConsent';
+export type { CookieConsentProviderProps } from './CookieConsentContext';
+export { CookieConsentProvider, useCookieConsent } from './CookieConsentContext';

package/build/components/cookie-consent/types.d.ts

@@ -0,0 +1,12 @@
+export type ConsentState = null | "denied" | "accepted";
+export type ConsentRequirement = Partial<Record<keyof Consent, boolean>>;
+export interface Consent {
+    marketing?: ConsentState;
+    functional?: ConsentState;
+    statistics?: ConsentState;
+}
+export type AcceptConsentCallback = (consent: Consent) => void;
+export interface ConsentComponentBaseProps {
+    className?: string;
+    onAccept: AcceptConsentCallback;
+}

package/build/components/datepicker/DatePicker.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { DatePickerProps } from './types';
+export declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLInputElement>>;

package/build/components/datepicker/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './validation';
+export * from './utils';
+export { DatePicker } from './DatePicker';

package/build/components/datepicker/internal/Calendar.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { Density } from '../../../core';
+import { YearsToShow } from '../types';
+import { UseCalendarProps } from './useCalendar';
+interface CalendarProps extends Omit<UseCalendarProps, "date" | "onOffsetChanged" | "offset" | "firstDayOfWeek" | "selected"> {
+    date: Date | null;
+    density?: Density;
+    defaultSelected?: Date;
+    hidden?: boolean;
+    days?: string[];
+    months?: string[];
+    monthLabel?: string;
+    yearLabel?: string;
+    yearsToShow?: YearsToShow;
+    onTabOutside: React.KeyboardEventHandler;
+}
+export declare const Calendar: React.ForwardRefExoticComponent<CalendarProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/build/components/datepicker/internal/calendarReducer.d.ts

@@ -0,0 +1,18 @@
+import { Reducer } from 'react';
+export type CalendarAction = {
+    type: "SET_SELECTED_DATE";
+    newDate: Date;
+} | {
+    type: "SET_OFFSET";
+    newOffset: number;
+} | {
+    type: "ADD_OFFSET";
+    addedOffset: number;
+};
+export type CalendarState = {
+    selectedDate: Date;
+    offset: number;
+    shownDate: Date;
+};
+export declare const calendarReducer: Reducer<CalendarState, CalendarAction>;
+export declare const calendarInitializer: (initialDate: Date) => CalendarState;

package/build/components/datepicker/internal/useCalendar.d.ts

@@ -0,0 +1,59 @@
+import { default as React } from 'react';
+import { DateInfo, CalendarMonth } from './utils';
+type GetDateProps = {
+    onClick?: React.MouseEventHandler;
+    dateObj: DateInfo;
+};
+type GetDatePropsResult = {
+    onClick: React.MouseEventHandler;
+    disabled: boolean;
+    "aria-pressed": boolean;
+    role: "button";
+};
+type GetBackProps = {
+    onClick?: React.MouseEventHandler;
+    offset?: number;
+    calendars: CalendarMonth[];
+};
+type GetBackPropsResult = {
+    onClick: React.MouseEventHandler;
+    disabled: boolean;
+    "aria-label": string;
+    title: string;
+};
+type GetForwardProps = {
+    onClick?: React.MouseEventHandler;
+    offset?: number;
+    calendars: CalendarMonth[];
+};
+type GetForwardPropsResult = {
+    onClick: React.MouseEventHandler;
+    disabled: boolean;
+    "aria-label": string;
+    title: string;
+};
+export interface UseCalendarProps {
+    date?: Date;
+    maxDate?: Date;
+    minDate?: Date;
+    monthsToDisplay?: number;
+    firstDayOfWeek?: number;
+    showOutsideDays?: boolean;
+    offset: number;
+    onDateSelected: (dateObj: DateInfo, event: React.MouseEvent) => void;
+    onOffsetChanged: (newOffset: number) => void;
+    selected?: Date | Date[];
+}
+export type GetDatePropsFunc = (props: GetDateProps) => GetDatePropsResult;
+export type GetBackPropsFunc = (props: GetBackProps) => GetBackPropsResult;
+export type GetForwardPropsFunc = (props: GetForwardProps) => GetForwardPropsResult;
+export type HandleOffsetFunc = (newOffset: number) => void;
+export type UseCalendarResult = {
+    calendars: CalendarMonth[];
+    getDateProps: GetDatePropsFunc;
+    getBackProps: GetBackPropsFunc;
+    getForwardProps: GetForwardPropsFunc;
+    handleOffsetChanged: HandleOffsetFunc;
+};
+export declare function useCalendar({ date, maxDate, minDate, monthsToDisplay, firstDayOfWeek, showOutsideDays, offset, onDateSelected, onOffsetChanged, selected, }: UseCalendarProps): UseCalendarResult;
+export {};

package/build/components/datepicker/internal/utils.d.ts

@@ -0,0 +1,167 @@
+import { default as React } from 'react';
+import { ValuePair } from '../../../utilities';
+import { YearsToShow } from '../types';
+export declare function composeEventHandlers(...fns: Array<React.MouseEventHandler | undefined>): (event: React.MouseEvent) => boolean;
+/**
+ * Takes a calendars array and figures out the number of months to subtract
+ * based on the current offset and the minDate allowed.
+ * @param {Object} param The param object
+ * @param {Array} param.calendars The calendars array created by the getCalendars function
+ * @param {Number} param.offset The num of months to be subtracted
+ * @param {Date} param.minDate The earliest date we are allow to subtract back to
+ * @returns {Number} The number of months to subtract
+ */
+export declare function subtractMonth({ calendars, offset, minDate, }: {
+    calendars: CalendarMonth[];
+    offset: number;
+    minDate?: Date;
+}): number;
+export declare const DEFAULT_YEARS_TO_SHOW = 3;
+/**
+ * Generates an array of year strings for a year selector component, with min and max dates taken into account.
+ *
+ * @param {number} currentYear - The current year to center the list around
+ * @param {Date | undefined} [minDate] - The minimum date to include in the list of years
+ * @param {Date | undefined} [maxDate] - The maximum date to include in the list of years
+ *
+ * @returns {string[]} - An array of year strings, starting from the earliest year specified by minDate or currentYear - 3, and ending at the latest year specified by maxDate or currentYear + 3
+ */
+export declare function getYearSelectOptions(currentYear: number, minDate: Date | undefined, maxDate: Date | undefined, yearsToShow: YearsToShow): string[];
+/**
+ * Returns an array of months that are allowed for selection in the current year based on the minimum and maximum dates.
+ * @param {number} currentYear The current year
+ * @param {string[]} monthNames An array of strings representing the month names
+ * @param {Date | undefined} minDate The minimum date that is allowed for selection
+ * @param {Date | undefined} maxDate The maximum date that is allowed for selection
+ * @returns {ValuePair[]} An array of ValuePairs representing the months that are allowed for selection in the current year
+ */
+export declare function getMonthSelectOptions(currentYear: number, monthNames: string[], minDate: Date | undefined, maxDate: Date | undefined): ValuePair[];
+/**s
+ * Takes a calendars array and figures out the number of months to add
+ * based on the current offset and the maxDate allowed.
+ * @param {Object} param The param object
+ * @param {Array} param.calendars The calendars array created by the getCalendars function
+ * @param {Number} param.offset The num of months to be added
+ * @param {Date} param.maxDate The furthest date we are allow to add forward to
+ * @returns {Number} The number of months to add
+ */
+export declare function addMonth({ calendars, offset, maxDate, }: {
+    calendars: CalendarMonth[];
+    offset: number;
+    maxDate?: Date;
+}): number;
+/**
+ * Takes a calendars array and figures out if the back button should be
+ * disabled based on the minDate allowed.
+ * @param {Object} param The param object
+ * @param {Array} param.calendars The calendars array created by the getCalendars function
+ * @param {Date} param.minDate The earliest date available
+ * @returns {Boolean} Whether the back button should be disabled.
+ */
+export declare function isBackDisabled({ calendars, minDate }: {
+    calendars: CalendarMonth[];
+    minDate?: Date;
+}): boolean;
+/**
+ * Takes a calendars array and figures out if the forward button should be
+ * disabled based on the maxDate allowed.
+ * @param {Object} param The param object
+ * @param {Array} param.calendars The calendars array created by the getCalendars function
+ * @param {Date} param.maxDate The furthest date available
+ * @returns {Boolean} Whether the forward button should be disabled.
+ */
+export declare function isForwardDisabled({ calendars, maxDate }: {
+    calendars: CalendarMonth[];
+    maxDate?: Date;
+}): boolean;
+type GetCalendarProps = {
+    /**  The date to start the calendar at */
+    date: Date;
+    /** Date or dates currently selected. */
+    selected?: Date | Date[];
+    /**  The earliest date available */
+    minDate?: Date;
+    /**  The earliest date available */
+    maxDate?: Date;
+    /** The number of months to return in the calendar view */
+    monthsToDisplay: number;
+    /** The number of months to offset based off the param.date given  */
+    offset: number;
+    /** First day of week, 0-6 (Sunday to Saturday) */
+    firstDayOfWeek: number;
+    /** Flag to fill front and back weeks with dates from adjacent months */
+    showOutsideDays: boolean;
+};
+/**
+ * Figures out the months data needed based off the number of monthsToDisplay
+ * and other options provided.
+ * @param {Object} param The param object
+ * @param {Date} param.date The date to start the calendar at
+ * @param {Array.<Date>} param.selected An array of dates currently selected
+ * @param {Number} param.monthsToDisplay The number of months to return in the calendar view
+ * @param {Number} param.offset The number of months to offset based off the param.date given
+ * @param {Date} param.minDate The earliest date available
+ * @param {Date} param.maxDate The furthest date available
+ * @param {Number} param.firstDayOfWeek First day of week, 0-6 (Sunday to Saturday)
+ * @param {Bool} param.showOutsideDays Flag to fill front and back weeks with dates from adjacent months
+ * @returns {Array.<Object>} An array of objects with month data
+ */
+export declare function getCalendars({ date, selected, monthsToDisplay, offset, minDate, maxDate, firstDayOfWeek, showOutsideDays, }: GetCalendarProps): CalendarMonth[];
+export type CalendarMonth = {
+    firstDayOfMonth: Date;
+    lastDayOfMonth: Date;
+    month: number;
+    year: number;
+    weeks: CalendarWeek[];
+};
+export type CalendarWeek = CalendarDay[];
+export type CalendarDay = DateInfo | string;
+export type DateInfo = {
+    date: Date;
+    selected: boolean;
+    selectable: boolean;
+    today: boolean;
+    prevMonth: boolean;
+    nextMonth: boolean;
+};
+/**
+ * Check if two Date objects represent the same day
+ *
+ * @param date1 first Date to compare
+ * @param date2 second Date to compare
+ */
+export declare function isSameDay(date1: Date, date2: Date): boolean;
+/**
+ * Check if the date has changed from the previous date
+ *
+ * @param date First date to compare
+ * @param newDate Second date to compare
+ */
+export declare function dateHasChanged(date: Date | undefined, newDate: Date): boolean;
+/**
+ * Check if a given date is outside a given range
+ *
+ * @param date Input date
+ * @param rangeStart Dates before this date should be disabled
+ * @param rangeEnd Dates after this date should be disabled
+ */
+export declare function dateIsOutsideRange(date: Date, rangeStart: Date | undefined, rangeEnd: Date | undefined): boolean;
+/**
+ * Get the correct initial date for initiating the datepicker reducer store
+ *
+ * @param value Value from props
+ * @param initialDate Initial date from porps
+ * @param disableDate Function for checking whether the date should be disabled
+ */
+export declare function getInitialDate(value: string | undefined, defaultValue: string | undefined, minDate: Date | undefined, maxDate: Date | undefined): Date | null;
+/**
+ * Get the initial date to show in the calendar
+ *
+ * @param date The date set in the DatePicker (from props)
+ * @param defaultSelected The defaultSelected prop from DatePicker
+ * @param minDate The earliest selectable date, from props
+ * @param maxDate The latest selectable date, from props
+ * @returns The date to show in the calendar
+ */
+export declare function getInitialDateShown(date: Date | null, defaultSelected: Date | undefined, minDate: Date | undefined, maxDate: Date | undefined): Date;
+export {};