@fullcalendar/core

@fullcalendar/core

Version 6.1.11
Published 2 months ago
1.86 MB
1 dependency
MIT license

Install

npm i @fullcalendar/core

yarn add @fullcalendar/core

pnpm add @fullcalendar/core

Overview

FullCalendar core package for rendering a calendar

Index

Variables

variable globalLocales

const globalLocales: LocaleInput[];

variable globalPlugins

const globalPlugins: PluginDef[];

variable version

const version: string;

Functions

function createPlugin

createPlugin: (input: PluginDefInput) => PluginDef;

function formatDate

formatDate: (dateInput: DateInput, options?: FormatDateOptions) => string;

function formatRange

formatRange: (
    startInput: DateInput,
    endInput: DateInput,
    options: FormatRangeOptions
) => string;

function sliceEvents

sliceEvents: (
    props: ViewProps & { dateProfile: DateProfile; nextDayThreshold: Duration },
    allDay?: boolean
) => EventRenderRange[];

Classes

class Calendar

class Calendar extends CalendarImpl {}

constructor

constructor(el: HTMLElement, optionOverrides?: CalendarOptions);

property el

el: HTMLElement;

method batchRendering

batchRendering: (func: any) => void;

method destroy

destroy: () => void;

method pauseRendering

pauseRendering: () => void;

method render

render: () => void;

method resetOptions

resetOptions: (optionOverrides: any, changedOptionNames?: string[]) => void;

method resumeRendering

resumeRendering: () => void;

method updateSize

updateSize: () => void;

class CustomRenderingStore

class CustomRenderingStore<RenderProps> extends Store<
    Map<string, CustomRendering<RenderProps>>
> {}

method handle

handle: (customRendering: CustomRendering<RenderProps>) => void;

class JsonRequestError

class JsonRequestError extends Error {}

constructor

constructor(message: string, response: Response);

property response

response: Response;

Interfaces

interface AllDayContentArg

interface AllDayContentArg {}

property text

text: string;

property view

view: ViewApi;

interface ButtonHintCompoundInput

interface ButtonHintCompoundInput {}

property day

day?: string | ((...args: any[]) => string);

property month

month?: string | ((...args: any[]) => string);

property next

next?: string | ((...args: any[]) => string);

property nextYear

nextYear?: string | ((...args: any[]) => string);

property prev

prev?: string | ((...args: any[]) => string);

property prevYear

prevYear?: string | ((...args: any[]) => string);

property today

today?: string | ((...args: any[]) => string);

property week

week?: string | ((...args: any[]) => string);

index signature

[viewOrCustomButton: string]: string | ((...args: any[]) => string) | undefined;

interface ButtonIconsInput

interface ButtonIconsInput {}

property next

next?: string;

property nextYear

nextYear?: string;

property prev

prev?: string;

property prevYear

prevYear?: string;

property today

today?: string;

index signature

[viewOrCustomButton: string]: string | undefined;

interface ButtonTextCompoundInput

interface ButtonTextCompoundInput {}

property day

day?: string;

property month

month?: string;

property next

next?: string;

property nextYear

nextYear?: string;

property prev

prev?: string;

property prevYear

prevYear?: string;

property today

today?: string;

property week

week?: string;

index signature

[viewOrCustomButton: string]: string | undefined;

interface CalendarApi

interface CalendarApi {}

property view

view: ViewApi;

method addEvent

addEvent: (
    eventInput: EventInput,
    sourceInput?: EventSourceApi | string | boolean
) => EventApi | null;

method addEventSource

addEventSource: (sourceInput: EventSourceInput) => EventSourceApi;

method changeView

changeView: (viewType: string, dateOrRange?: DateRangeInput | DateInput) => void;

method formatDate

formatDate: (d: DateInput, formatter: FormatterInput) => string;

method formatIso

formatIso: (d: DateInput, omitTime?: boolean) => string;

method formatRange

formatRange: (d0: DateInput, d1: DateInput, settings: any) => string;

method getAvailableLocaleCodes

getAvailableLocaleCodes: () => string[];

method getDate

getDate: () => Date;

method getEventById

getEventById: (id: string) => EventApi | null;

method getEvents

getEvents: () => EventApi[];

method getEventSourceById

getEventSourceById: (id: string) => EventSourceApi | null;

method getEventSources

getEventSources: () => EventSourceApi[];

method getOption

getOption: <
    OptionName extends
        | 'navLinkDayClick'
        | 'navLinkWeekClick'
        | 'duration'
        | 'bootstrapFontAwesome'
        | 'buttonIcons'
        | 'customButtons'
        | 'defaultAllDayEventDuration'
        | 'defaultTimedEventDuration'
        | 'nextDayThreshold'
        | 'scrollTime'
        | 'scrollTimeReset'
        | 'slotMinTime'
        | 'slotMaxTime'
        | 'dayPopoverFormat'
        | 'slotDuration'
        | 'snapDuration'
        | 'headerToolbar'
        | 'footerToolbar'
        | 'defaultRangeSeparator'
        | 'titleRangeSeparator'
        | 'forceEventDuration'
        | 'dayHeaders'
        | 'dayHeaderFormat'
        | 'dayHeaderClassNames'
        | 'dayHeaderContent'
        | 'dayHeaderDidMount'
        | 'dayHeaderWillUnmount'
        | 'dayCellClassNames'
        | 'dayCellContent'
        | 'dayCellDidMount'
        | 'dayCellWillUnmount'
        | 'initialView'
        | 'aspectRatio'
        | 'weekends'
        | 'weekNumberCalculation'
        | 'weekNumbers'
        | 'weekNumberClassNames'
        | 'weekNumberContent'
        | 'weekNumberDidMount'
        | 'weekNumberWillUnmount'
        | 'editable'
        | 'viewClassNames'
        | 'viewDidMount'
        | 'viewWillUnmount'
        | 'nowIndicator'
        | 'nowIndicatorClassNames'
        | 'nowIndicatorContent'
        | 'nowIndicatorDidMount'
        | 'nowIndicatorWillUnmount'
        | 'showNonCurrentDates'
        | 'lazyFetching'
        | 'startParam'
        | 'endParam'
        | 'timeZoneParam'
        | 'timeZone'
        | 'locales'
        | 'locale'
        | 'themeSystem'
        | 'dragRevertDuration'
        | 'dragScroll'
        | 'allDayMaintainDuration'
        | 'unselectAuto'
        | 'dropAccept'
        | 'eventOrder'
        | 'eventOrderStrict'
        | 'handleWindowResize'
        | 'windowResizeDelay'
        | 'longPressDelay'
        | 'eventDragMinDistance'
        | 'expandRows'
        | 'height'
        | 'contentHeight'
        | 'direction'
        | 'weekNumberFormat'
        | 'eventResizableFromStart'
        | 'displayEventTime'
        | 'displayEventEnd'
        | 'weekText'
        | 'weekTextLong'
        | 'progressiveEventRendering'
        | 'businessHours'
        | 'initialDate'
        | 'now'
        | 'eventDataTransform'
        | 'stickyHeaderDates'
        | 'stickyFooterScrollbar'
        | 'viewHeight'
        | 'defaultAllDay'
        | 'eventSourceFailure'
        | 'eventSourceSuccess'
        | 'eventDisplay'
        | 'eventStartEditable'
        | 'eventDurationEditable'
        | 'eventOverlap'
        | 'eventConstraint'
        | 'eventAllow'
        | 'eventBackgroundColor'
        | 'eventBorderColor'
        | 'eventTextColor'
        | 'eventColor'
        | 'eventClassNames'
        | 'eventContent'
        | 'eventDidMount'
        | 'eventWillUnmount'
        | 'selectConstraint'
        | 'selectOverlap'
        | 'selectAllow'
        | 'droppable'
        | 'unselectCancel'
        | 'slotLabelFormat'
        | 'slotLaneClassNames'
        | 'slotLaneContent'
        | 'slotLaneDidMount'
        | 'slotLaneWillUnmount'
        | 'slotLabelClassNames'
        | 'slotLabelContent'
        | 'slotLabelDidMount'
        | 'slotLabelWillUnmount'
        | 'dayMaxEvents'
        | 'dayMaxEventRows'
        | 'dayMinWidth'
        | 'slotLabelInterval'
        | 'allDayText'
        | 'allDayClassNames'
        | 'allDayContent'
        | 'allDayDidMount'
        | 'allDayWillUnmount'
        | 'slotMinWidth'
        | 'navLinks'
        | 'eventTimeFormat'
        | 'rerenderDelay'
        | 'moreLinkText'
        | 'moreLinkHint'
        | 'selectMinDistance'
        | 'selectable'
        | 'selectLongPressDelay'
        | 'eventLongPressDelay'
        | 'selectMirror'
        | 'eventMaxStack'
        | 'eventMinHeight'
        | 'eventMinWidth'
        | 'eventShortHeight'
        | 'slotEventOverlap'
        | 'plugins'
        | 'firstDay'
        | 'dayCount'
        | 'dateAlignment'
        | 'dateIncrement'
        | 'hiddenDays'
        | 'fixedWeekCount'
        | 'validRange'
        | 'visibleRange'
        | 'titleFormat'
        | 'eventInteractive'
        | 'noEventsText'
        | 'viewHint'
        | 'navLinkHint'
        | 'closeHint'
        | 'timeHint'
        | 'eventHint'
        | 'moreLinkClick'
        | 'moreLinkClassNames'
        | 'moreLinkContent'
        | 'moreLinkDidMount'
        | 'moreLinkWillUnmount'
        | 'monthStartFormat'
        | 'handleCustomRendering'
        | 'customRenderingMetaMap'
        | 'customRenderingReplaces'
        | 'datesSet'
        | 'eventsSet'
        | 'eventAdd'
        | 'eventChange'
        | 'eventRemove'
        | 'windowResize'
        | 'eventClick'
        | 'eventMouseEnter'
        | 'eventMouseLeave'
        | 'select'
        | 'unselect'
        | 'loading'
        | '_unmount'
        | '_beforeprint'
        | '_afterprint'
        | '_noEventDrop'
        | '_noEventResize'
        | '_resize'
        | '_scrollRequest'
        | 'buttonText'
        | 'buttonHints'
        | 'views'
        | 'initialEvents'
        | 'events'
        | 'eventSources'
>(
    name: OptionName
) => CalendarOptions[OptionName];

method gotoDate

gotoDate: (zonedDateInput: DateInput) => void;

method incrementDate

incrementDate: (deltaInput: DurationInput) => void;

method next

next: () => void;

method nextYear

nextYear: () => void;

method off

off: <ListenerName extends keyof CalendarListenerRefiners>(
    handlerName: ListenerName,
    handler: CalendarListeners[ListenerName]
) => void;

method on

on: <ListenerName extends keyof CalendarListenerRefiners>(
    handlerName: ListenerName,
    handler: CalendarListeners[ListenerName]
) => void;

method prev

prev: () => void;

method prevYear

prevYear: () => void;

method refetchEvents

refetchEvents: () => void;

method removeAllEvents

removeAllEvents: () => void;

method removeAllEventSources

removeAllEventSources: () => void;

method scrollToTime

scrollToTime: (timeInput: DurationInput) => void;

method select

select: (dateOrObj: DateInput | any, endDate?: DateInput) => void;

method setOption

setOption: <
    OptionName extends
        | 'navLinkDayClick'
        | 'navLinkWeekClick'
        | 'duration'
        | 'bootstrapFontAwesome'
        | 'buttonIcons'
        | 'customButtons'
        | 'defaultAllDayEventDuration'
        | 'defaultTimedEventDuration'
        | 'nextDayThreshold'
        | 'scrollTime'
        | 'scrollTimeReset'
        | 'slotMinTime'
        | 'slotMaxTime'
        | 'dayPopoverFormat'
        | 'slotDuration'
        | 'snapDuration'
        | 'headerToolbar'
        | 'footerToolbar'
        | 'defaultRangeSeparator'
        | 'titleRangeSeparator'
        | 'forceEventDuration'
        | 'dayHeaders'
        | 'dayHeaderFormat'
        | 'dayHeaderClassNames'
        | 'dayHeaderContent'
        | 'dayHeaderDidMount'
        | 'dayHeaderWillUnmount'
        | 'dayCellClassNames'
        | 'dayCellContent'
        | 'dayCellDidMount'
        | 'dayCellWillUnmount'
        | 'initialView'
        | 'aspectRatio'
        | 'weekends'
        | 'weekNumberCalculation'
        | 'weekNumbers'
        | 'weekNumberClassNames'
        | 'weekNumberContent'
        | 'weekNumberDidMount'
        | 'weekNumberWillUnmount'
        | 'editable'
        | 'viewClassNames'
        | 'viewDidMount'
        | 'viewWillUnmount'
        | 'nowIndicator'
        | 'nowIndicatorClassNames'
        | 'nowIndicatorContent'
        | 'nowIndicatorDidMount'
        | 'nowIndicatorWillUnmount'
        | 'showNonCurrentDates'
        | 'lazyFetching'
        | 'startParam'
        | 'endParam'
        | 'timeZoneParam'
        | 'timeZone'
        | 'locales'
        | 'locale'
        | 'themeSystem'
        | 'dragRevertDuration'
        | 'dragScroll'
        | 'allDayMaintainDuration'
        | 'unselectAuto'
        | 'dropAccept'
        | 'eventOrder'
        | 'eventOrderStrict'
        | 'handleWindowResize'
        | 'windowResizeDelay'
        | 'longPressDelay'
        | 'eventDragMinDistance'
        | 'expandRows'
        | 'height'
        | 'contentHeight'
        | 'direction'
        | 'weekNumberFormat'
        | 'eventResizableFromStart'
        | 'displayEventTime'
        | 'displayEventEnd'
        | 'weekText'
        | 'weekTextLong'
        | 'progressiveEventRendering'
        | 'businessHours'
        | 'initialDate'
        | 'now'
        | 'eventDataTransform'
        | 'stickyHeaderDates'
        | 'stickyFooterScrollbar'
        | 'viewHeight'
        | 'defaultAllDay'
        | 'eventSourceFailure'
        | 'eventSourceSuccess'
        | 'eventDisplay'
        | 'eventStartEditable'
        | 'eventDurationEditable'
        | 'eventOverlap'
        | 'eventConstraint'
        | 'eventAllow'
        | 'eventBackgroundColor'
        | 'eventBorderColor'
        | 'eventTextColor'
        | 'eventColor'
        | 'eventClassNames'
        | 'eventContent'
        | 'eventDidMount'
        | 'eventWillUnmount'
        | 'selectConstraint'
        | 'selectOverlap'
        | 'selectAllow'
        | 'droppable'
        | 'unselectCancel'
        | 'slotLabelFormat'
        | 'slotLaneClassNames'
        | 'slotLaneContent'
        | 'slotLaneDidMount'
        | 'slotLaneWillUnmount'
        | 'slotLabelClassNames'
        | 'slotLabelContent'
        | 'slotLabelDidMount'
        | 'slotLabelWillUnmount'
        | 'dayMaxEvents'
        | 'dayMaxEventRows'
        | 'dayMinWidth'
        | 'slotLabelInterval'
        | 'allDayText'
        | 'allDayClassNames'
        | 'allDayContent'
        | 'allDayDidMount'
        | 'allDayWillUnmount'
        | 'slotMinWidth'
        | 'navLinks'
        | 'eventTimeFormat'
        | 'rerenderDelay'
        | 'moreLinkText'
        | 'moreLinkHint'
        | 'selectMinDistance'
        | 'selectable'
        | 'selectLongPressDelay'
        | 'eventLongPressDelay'
        | 'selectMirror'
        | 'eventMaxStack'
        | 'eventMinHeight'
        | 'eventMinWidth'
        | 'eventShortHeight'
        | 'slotEventOverlap'
        | 'plugins'
        | 'firstDay'
        | 'dayCount'
        | 'dateAlignment'
        | 'dateIncrement'
        | 'hiddenDays'
        | 'fixedWeekCount'
        | 'validRange'
        | 'visibleRange'
        | 'titleFormat'
        | 'eventInteractive'
        | 'noEventsText'
        | 'viewHint'
        | 'navLinkHint'
        | 'closeHint'
        | 'timeHint'
        | 'eventHint'
        | 'moreLinkClick'
        | 'moreLinkClassNames'
        | 'moreLinkContent'
        | 'moreLinkDidMount'
        | 'moreLinkWillUnmount'
        | 'monthStartFormat'
        | 'handleCustomRendering'
        | 'customRenderingMetaMap'
        | 'customRenderingReplaces'
        | 'datesSet'
        | 'eventsSet'
        | 'eventAdd'
        | 'eventChange'
        | 'eventRemove'
        | 'windowResize'
        | 'eventClick'
        | 'eventMouseEnter'
        | 'eventMouseLeave'
        | 'select'
        | 'unselect'
        | 'loading'
        | '_unmount'
        | '_beforeprint'
        | '_afterprint'
        | '_noEventDrop'
        | '_noEventResize'
        | '_resize'
        | '_scrollRequest'
        | 'buttonText'
        | 'buttonHints'
        | 'views'
        | 'initialEvents'
        | 'events'
        | 'eventSources'
>(
    name: OptionName,
    val: CalendarOptions[OptionName]
) => void;

method today

today: () => void;

method trigger

trigger: <ListenerName extends keyof CalendarListenerRefiners>(
    handlerName: ListenerName,
    ...args: Parameters<CalendarListeners[ListenerName]>
) => void;

method unselect

unselect: () => void;

method updateSize

updateSize: () => void;

method zoomTo

zoomTo: (dateMarker: Date, viewType?: string) => void;

interface CustomButtonInput

interface CustomButtonInput {}

property bootstrapFontAwesome

bootstrapFontAwesome?: string;

property hint

hint?: string;

property icon

icon?: string;

property text

text?: string;

property themeIcon

themeIcon?: string;

method click

click: (ev: MouseEvent, element: HTMLElement) => void;

interface DatePointApi

interface DatePointApi {}

property allDay

allDay: boolean;

property date

date: Date;

property dateStr

dateStr: string;

interface DateRangeInput

interface DateRangeInput {}

property end

end?: DateInput;

property start

start?: DateInput;

interface DateSelectArg

interface DateSelectArg extends DateSpanApi {}

property jsEvent

jsEvent: MouseEvent | null;

property view

view: ViewApi;

interface DateSelectionApi

interface DateSelectionApi extends DateSpanApi {}

property jsEvent

jsEvent: UIEvent;

property view

view: ViewApi;

interface DateSpanApi

interface DateSpanApi extends RangeApi {}

property allDay

allDay: boolean;

interface DateSpanInput

interface DateSpanInput extends OpenDateSpanInput {}

property end

end: DateInput;

property start

start: DateInput;

interface DateUnselectArg

interface DateUnselectArg {}

property jsEvent

jsEvent: MouseEvent;

property view

view: ViewApi;

interface DayCellContentArg

interface DayCellContentArg extends DateMeta {}

property date

date: DateMarker;

property dayNumberText

dayNumberText: string;

property view

view: ViewApi;

index signature

[extraProp: string]: any;

interface DayHeaderContentArg

interface DayHeaderContentArg extends DateMeta {}

property date

date: Date;

property text

text: string;

property view

view: ViewApi;

index signature

[otherProp: string]: any;

interface Duration

interface Duration {}

property days

days: number;

property milliseconds

milliseconds: number;

property months

months: number;

property specifiedWeeks

specifiedWeeks?: boolean;

property years

years: number;

interface EventAddArg

interface EventAddArg {}

property event

event: EventImpl;

property relatedEvents

relatedEvents: EventImpl[];

property revert

revert: () => void;

interface EventApi

interface EventApi {}

property allDay

allDay: boolean;

property allow

allow: any;

property backgroundColor

backgroundColor: string;

property borderColor

borderColor: string;

property classNames

classNames: string[];

property constraint

constraint: any;

property display

display: string;

property durationEditable

durationEditable: boolean;

property end

end: Date | null;

property endStr

endStr: string;

property extendedProps

extendedProps: Dictionary;

property groupId

groupId: string;

property id

id: string;

property overlap

overlap: boolean;

property source

source: EventSourceApi | null;

property start

start: Date | null;

property startEditable

startEditable: boolean;

property startStr

startStr: string;

property textColor

textColor: string;

property title

title: string;

property url

url: string;

method formatRange

formatRange: (formatInput: FormatterInput) => any;

method moveDates

moveDates: (deltaInput: DurationInput) => void;

method moveEnd

moveEnd: (deltaInput: DurationInput) => void;

method moveStart

moveStart: (deltaInput: DurationInput) => void;

method remove

remove: () => void;

method setAllDay

setAllDay: (allDay: boolean, options?: { maintainDuration?: boolean }) => void;

method setDates

setDates: (
    startInput: DateInput,
    endInput: DateInput | null,
    options?: { allDay?: boolean; granularity?: string }
) => void;

method setEnd

setEnd: (endInput: DateInput | null, options?: { granularity?: string }) => void;

method setExtendedProp

setExtendedProp: (name: string, val: any) => void;

method setProp

setProp: (name: string, val: any) => void;

method setStart

setStart: (
    startInput: DateInput,
    options?: { granularity?: string; maintainDuration?: boolean }
) => void;

method toJSON

toJSON: () => Dictionary;

method toPlainObject

toPlainObject: (settings?: {
    collapseExtendedProps?: boolean;
    collapseColor?: boolean;
}) => Dictionary;

interface EventChangeArg

interface EventChangeArg {}

property event

event: EventImpl;

property oldEvent

oldEvent: EventImpl;

property relatedEvents

relatedEvents: EventImpl[];

property revert

revert: () => void;

interface EventClickArg

interface EventClickArg {}

property el

el: HTMLElement;

property event

event: EventImpl;

property jsEvent

jsEvent: MouseEvent;

property view

view: ViewApi;

interface EventContentArg

interface EventContentArg {}

property backgroundColor

backgroundColor: string;

property borderColor

borderColor: string;

property event

event: EventImpl;

property isDraggable

isDraggable: boolean;

property isDragging

isDragging: boolean;

property isEnd

isEnd: boolean;

property isEndResizable

isEndResizable: boolean;

property isFuture

isFuture: boolean;

property isMirror

isMirror: boolean;

property isPast

isPast: boolean;

property isResizing

isResizing: boolean;

property isSelected

isSelected: boolean;

property isStart

isStart: boolean;

property isStartResizable

isStartResizable: boolean;

property isToday

isToday: boolean;

property textColor

textColor: string;

property timeText

timeText: string;

property view

view: ViewApi;

interface EventDropArg

interface EventDropArg extends EventChangeArg {}

property delta

delta: Duration;

property el

el: HTMLElement;

property jsEvent

jsEvent: MouseEvent;

property view

view: ViewApi$1;

interface EventHoveringArg

interface EventHoveringArg {}

property el

el: HTMLElement;

property event

event: EventImpl;

property jsEvent

jsEvent: MouseEvent;

property view

view: ViewApi;

interface EventRemoveArg

interface EventRemoveArg {}

property event

event: EventImpl;

property relatedEvents

relatedEvents: EventImpl[];

property revert

revert: () => void;

interface EventRenderRange

interface EventRenderRange extends EventTuple {}

property isEnd

isEnd: boolean;

property isStart

isStart: boolean;

property range

range: DateRange;

property ui

ui: EventUi;

interface EventSegment

interface EventSegment {}

property end

end: Date;

property event

event: EventApi;

property isEnd

isEnd: boolean;

property isStart

isStart: boolean;

property start

start: Date;

interface EventSourceApi

interface EventSourceApi {}

property format

format: string;

property id

id: string;

property url

url: string;

method refetch

refetch: () => void;

method remove

remove: () => void;

interface FormatDateOptions

interface FormatDateOptions extends NativeFormatterOptions {}

property locale

locale?: string;

interface FormatRangeOptions

interface FormatRangeOptions extends FormatDateOptions {}

property isEndExclusive

isEndExclusive?: boolean;

property separator

separator?: string;

interface LocaleInput

interface LocaleInput extends CalendarOptions {}

property code

code: string;

interface MoreLinkArg

interface MoreLinkArg {}

property allDay

allDay: boolean;

property allSegs

allSegs: EventSegment[];

property date

date: Date;

property hiddenSegs

hiddenSegs: EventSegment[];

property jsEvent

jsEvent: UIEvent;

property view

view: ViewApi;

interface MoreLinkContentArg

interface MoreLinkContentArg {}

property num

num: number;

property shortText

shortText: string;

property text

text: string;

property view

view: ViewApi;

interface NowIndicatorContentArg

interface NowIndicatorContentArg {}

property date

date: Date;

property isAxis

isAxis: boolean;

property view

view: ViewApi;

interface PluginDef

interface PluginDef extends PluginHooks {}

property deps

deps: PluginDef[];

property id

id: string;

property name

name: string;

interface PluginDefInput

interface PluginDefInput {}

property calendarInteractions

calendarInteractions?: CalendarInteractionClass[];

property cmdFormatter

cmdFormatter?: CmdFormatterFunc;

property componentInteractions

componentInteractions?: InteractionClass[];

property contextInit

contextInit?: (context: CalendarContext) => void;

property datePointTransforms

datePointTransforms?: DatePointTransform[];

property dateSelectionTransformers

dateSelectionTransformers?: dateSelectionJoinTransformer[];

property dateSpanTransforms

dateSpanTransforms?: DateSpanTransform[];

property deps

deps?: PluginDef[];

property elementDraggingImpl

elementDraggingImpl?: ElementDraggingClass;

property eventDefMemberAdders

eventDefMemberAdders?: EventDefMemberAdder[];

property eventDefMutationAppliers

eventDefMutationAppliers?: eventDefMutationApplier[];

property eventDragMutationMassagers

eventDragMutationMassagers?: eventDragMutationMassager[];

property eventDropTransformers

eventDropTransformers?: EventDropTransformers[];

property eventRefiners

eventRefiners?: GenericRefiners;

property eventSourceDefs

eventSourceDefs?: EventSourceDef<any>[];

property eventSourceRefiners

eventSourceRefiners?: GenericRefiners;

property externalDefTransforms

externalDefTransforms?: ExternalDefTransform[];

property initialView

initialView?: string;

property isDraggableTransformers

isDraggableTransformers?: eventIsDraggableTransformer[];

property isLoadingFuncs

isLoadingFuncs?: ((state: Dictionary) => boolean)[];

property isPropsValid

isPropsValid?: isPropsValidTester;

property listenerRefiners

listenerRefiners?: GenericListenerRefiners;

property name

name: string;

property namedTimeZonedImpl

namedTimeZonedImpl?: NamedTimeZoneImplClass;

property optionChangeHandlers

optionChangeHandlers?: OptionChangeHandlerMap;

property optionRefiners

optionRefiners?: GenericRefiners;

property premiumReleaseDate

premiumReleaseDate?: string;

property propSetHandlers

propSetHandlers?: {
    [propName: string]: (val: any, context: CalendarData) => void;
};

property recurringTypes

recurringTypes?: RecurringType<any>[];

property reducers

reducers?: ReducerFunc[];

property scrollGridImpl

scrollGridImpl?: ScrollGridImpl;

property themeClasses

themeClasses?: {
    [themeSystemName: string]: ThemeClass;
};

property viewContainerAppends

viewContainerAppends?: ViewContainerAppend[];

property viewPropsTransformers

viewPropsTransformers?: ViewPropsTransformerClass[];

property views

views?: ViewConfigInputHash;

interface SlotLabelContentArg

interface SlotLabelContentArg {}

property date

date: Date;

property level

level: number;

property text

text: string;

property time

time: Duration;

property view

view: ViewApi;

interface SlotLaneContentArg

interface SlotLaneContentArg extends Partial<DateMeta> {}

property date

date?: Date;

property time

time?: Duration;

property view

view: ViewApi;

interface SpecificViewContentArg

interface SpecificViewContentArg extends ViewProps {}

property nextDayThreshold

nextDayThreshold: Duration;

interface ToolbarInput

interface ToolbarInput {}

property center

center?: string;

property end

end?: string;

property left

left?: string;

property right

right?: string;

property start

start?: string;

interface ViewApi

interface ViewApi {}

property activeEnd

activeEnd: Date;

property activeStart

activeStart: Date;

property calendar

calendar: CalendarApi;

property currentEnd

currentEnd: Date;

property currentStart

currentStart: Date;

property title

title: string;

property type

type: string;

method getOption

getOption: (name: string) => any;

interface ViewContentArg

interface ViewContentArg {}

property view

view: ViewApi;

interface WeekNumberContentArg

interface WeekNumberContentArg {}

property date

date: Date;

property num

num: number;

property text

text: string;

Type Aliases

type AllDayMountArg

type AllDayMountArg = MountArg<AllDayContentArg>;

type AllowFunc

type AllowFunc = (span: DateSpanApi, movingEvent: EventImpl | null) => boolean;

type BusinessHoursInput

type BusinessHoursInput = boolean | EventInput | EventInput[];

type CalendarListeners

type CalendarListeners = Required<CalendarListenersLoose>;

type CalendarOptions

type CalendarOptions = BaseOptions &
    CalendarListenersLoose &
    RawOptionsFromRefiners<Required<CalendarOptionRefiners>>;

type ClassNamesGenerator

type ClassNamesGenerator<RenderProps> =
    | ClassNamesInput
    | ((renderProps: RenderProps) => ClassNamesInput);

type ConstraintInput

type ConstraintInput = 'businessHours' | string | EventInput | EventInput[];

type CssDimValue

type CssDimValue = string | number;

type CustomContentGenerator

type CustomContentGenerator<RenderProps> =
    | CustomContent
    | ((renderProps: RenderProps, createElement: any) => CustomContent | true);

type CustomRenderingHandler

type CustomRenderingHandler<RenderProps> = (
    customRender: CustomRendering<RenderProps>
) => void;

type DateInput

type DateInput = Date | string | number | number[];

type DatesSetArg

type DatesSetArg = RangeApiWithTimeZone & {
    view: ViewApi;
};

type DayCellMountArg

type DayCellMountArg = MountArg<DayCellContentArg>;

type DayHeaderMountArg

type DayHeaderMountArg = MountArg<DayHeaderContentArg>;

type DidMountHandler

type DidMountHandler<
    TheMountArg extends {
        el: HTMLElement;
    }
> = (mountArg: TheMountArg) => void;

type DurationInput

type DurationInput = DurationObjectInput | string | number;

type EventInput

type EventInput = EventUiInput &
    RawOptionsFromRefiners<Required<EventRefiners>> & { // Required hack
        [extendedProp: string]: any;
    };

type EventInputTransformer

type EventInputTransformer = (input: EventInput) => EventInput;

type EventMountArg

type EventMountArg = MountArg<EventContentArg>;

type EventSourceFunc

type EventSourceFunc =
    | ((
          arg: EventSourceFuncArg,
          successCallback: (eventInputs: EventInput[]) => void,
          failureCallback: (error: Error) => void
      ) => void)
    | ((arg: EventSourceFuncArg) => Promise<EventInput[]>);

type EventSourceFuncArg

type EventSourceFuncArg = {
    start: Date;
    end: Date;
    startStr: string;
    endStr: string;
    timeZone: string;
};

type EventSourceInput

type EventSourceInput =
    | EventSourceInputObject // object in extended form
    | EventInput[]
    | EventSourceFunc // just a function
    | string;

type FormatterInput

type FormatterInput = NativeFormatterOptions | string | FuncFormatterFunc;

type LocaleSingularArg

type LocaleSingularArg = LocaleCodeArg | LocaleInput;

type MoreLinkAction

type MoreLinkAction = MoreLinkSimpleAction | MoreLinkHandler;

type MoreLinkHandler

type MoreLinkHandler = (arg: MoreLinkArg) => MoreLinkSimpleAction | void;

type MoreLinkMountArg

type MoreLinkMountArg = MountArg<MoreLinkContentArg>;

type MoreLinkSimpleAction

type MoreLinkSimpleAction =
    | 'popover'
    | 'week'
    | 'day'
    | 'timeGridWeek'
    | 'timeGridDay'
    | string;

type NowIndicatorMountArg

type NowIndicatorMountArg = MountArg<NowIndicatorContentArg>;

type OverlapFunc

type OverlapFunc = (stillEvent: EventImpl, movingEvent: EventImpl | null) => boolean;

type SlotLabelMountArg

type SlotLabelMountArg = MountArg<SlotLabelContentArg>;

type SlotLaneMountArg

type SlotLaneMountArg = MountArg<SlotLaneContentArg>;

type SpecificViewMountArg

type SpecificViewMountArg = MountArg<SpecificViewContentArg>;

type ViewComponentType

type ViewComponentType = ComponentType<ViewProps>;

type ViewMountArg

type ViewMountArg = MountArg<ViewContentArg>;

type WeekNumberCalculation

type WeekNumberCalculation = 'local' | 'ISO' | ((m: Date) => number);

type WeekNumberMountArg

type WeekNumberMountArg = MountArg<WeekNumberContentArg>;

type WillUnmountHandler

type WillUnmountHandler<
    TheMountArg extends {
        el: HTMLElement;
    }
> = (mountArg: TheMountArg) => void;

Package Files (2)

Dependencies (1)

preact

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@fullcalendar/core.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@fullcalendar/core)

HTML

<a href="https://www.jsdocs.io/package/@fullcalendar/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 6768 ms.
Missing or incorrect documentation? Open an issue for this package.