@fullcalendar/timegrid

  • Version 5.11.3
  • Published
  • 380 kB
  • 3 dependencies
  • MIT license

Install

npm i @fullcalendar/timegrid
yarn add @fullcalendar/timegrid
pnpm add @fullcalendar/timegrid

Overview

Display your events on a grid of time slots

Index

Variables

variable _default

const _default: _fullcalendar_common.PluginDef;

    variable OPTION_REFINERS

    const OPTION_REFINERS: { allDaySlot: BooleanConstructor };

      Functions

      function buildDayRanges

      buildDayRanges: (
      dayTableModel: DayTableModel,
      dateProfile: DateProfile,
      dateEnv: DateEnv
      ) => DateRange[];

        function buildSlatMetas

        buildSlatMetas: (
        slotMinTime: Duration,
        slotMaxTime: Duration,
        explicitLabelInterval: Duration | null,
        slotDuration: Duration,
        dateEnv: DateEnv
        ) => TimeSlatMeta[];

          function buildTimeColsModel

          buildTimeColsModel: (
          dateProfile: DateProfile,
          dateProfileGenerator: DateProfileGenerator
          ) => DayTableModel;

            Classes

            class DayTimeCols

            class DayTimeCols extends DateComponent<DayTimeColsProps> {}

              method render

              render: () => createElement.JSX.Element;

                class DayTimeColsSlicer

                class DayTimeColsSlicer extends Slicer<TimeColsSeg, [DateRange[]]> {}

                  method sliceRange

                  sliceRange: (range: DateRange, dayRanges: DateRange[]) => TimeColsSeg[];

                    class DayTimeColsView

                    class DayTimeColsView extends TimeColsView {}

                      method render

                      render: () => createElement.JSX.Element;

                        class TimeCols

                        class TimeCols extends DateComponent<TimeColsProps, TimeColsState> {}

                          property handleColCoords

                          handleColCoords: (colCoords: PositionCache | null) => void;

                            property handleRootEl

                            handleRootEl: (el: HTMLElement | null) => void;

                              property handleScrollRequest

                              handleScrollRequest: (request: ScrollRequest) => boolean;

                                property handleSlatCoords

                                handleSlatCoords: (slatCoords: TimeColsSlatsCoords | null) => void;

                                  property state

                                  state: { slatCoords: any };

                                    method componentDidMount

                                    componentDidMount: () => void;

                                      method componentDidUpdate

                                      componentDidUpdate: (prevProps: TimeColsProps) => void;

                                        method componentWillUnmount

                                        componentWillUnmount: () => void;

                                          method queryHit

                                          queryHit: (positionLeft: number, positionTop: number) => Hit;

                                            method render

                                            render: () => createElement.JSX.Element;

                                              class TimeColsSlatsCoords

                                              class TimeColsSlatsCoords {}

                                                constructor

                                                constructor(
                                                positions: PositionCache,
                                                dateProfile: DateProfile,
                                                slotDuration: Duration
                                                );

                                                  property positions

                                                  positions: PositionCache;

                                                    method computeDateTop

                                                    computeDateTop: (when: DateMarker, startOfDayDate?: DateMarker) => number;

                                                      method computeTimeTop

                                                      computeTimeTop: (duration: Duration) => number;

                                                        method safeComputeTop

                                                        safeComputeTop: (date: DateMarker) => number;

                                                          class TimeColsView

                                                          abstract class TimeColsView extends DateComponent<ViewProps, TimeColsViewState> {}

                                                            property allDaySplitter

                                                            protected allDaySplitter: AllDaySplitter;

                                                              property handleScrollTopRequest

                                                              handleScrollTopRequest: (scrollTop: number) => void;

                                                                property handleSlatCoords

                                                                handleSlatCoords: (slatCoords: TimeColsSlatsCoords) => void;

                                                                  property headerElRef

                                                                  protected headerElRef: RefObject<HTMLTableCellElement>;

                                                                    property renderHeadAxis

                                                                    renderHeadAxis: (
                                                                    rowKey: 'day' | string,
                                                                    frameHeight?: CssDimValue
                                                                    ) => createElement.JSX.Element;

                                                                      property renderTableRowAxis

                                                                      renderTableRowAxis: (rowHeight?: number) => createElement.JSX.Element;

                                                                        property state

                                                                        state: { slatCoords: any };

                                                                          method getAllDayMaxEventProps

                                                                          getAllDayMaxEventProps: () => {
                                                                          dayMaxEvents: number | boolean;
                                                                          dayMaxEventRows: number | false;
                                                                          };

                                                                            method renderHScrollLayout

                                                                            renderHScrollLayout: (
                                                                            headerRowContent: VNode | null,
                                                                            allDayContent: (contentArg: ChunkContentCallbackArgs) => VNode,
                                                                            timeContent: (contentArg: ChunkContentCallbackArgs) => VNode,
                                                                            colCnt: number,
                                                                            dayMinWidth: number,
                                                                            slatMetas: TimeSlatMeta[],
                                                                            slatCoords: TimeColsSlatsCoords | null
                                                                            ) => createElement.JSX.Element;

                                                                              method renderSimpleLayout

                                                                              renderSimpleLayout: (
                                                                              headerRowContent: VNode | null,
                                                                              allDayContent: (contentArg: ChunkContentCallbackArgs) => VNode,
                                                                              timeContent: (contentArg: ChunkContentCallbackArgs) => VNode
                                                                              ) => createElement.JSX.Element;

                                                                                Interfaces

                                                                                interface TimeColsSeg

                                                                                interface TimeColsSeg extends Seg {}

                                                                                  property col

                                                                                  col: number;

                                                                                    property end

                                                                                    end: DateMarker;

                                                                                      property start

                                                                                      start: DateMarker;

                                                                                        interface TimeSlatMeta

                                                                                        interface TimeSlatMeta {}

                                                                                          property date

                                                                                          date: DateMarker;

                                                                                            property isLabeled

                                                                                            isLabeled: boolean;

                                                                                              property isoTimeStr

                                                                                              isoTimeStr: string;

                                                                                                property key

                                                                                                key: string;

                                                                                                  property time

                                                                                                  time: Duration;

                                                                                                    Package Files (1)

                                                                                                    Dependencies (3)

                                                                                                    Dev Dependencies (1)

                                                                                                    Peer Dependencies (0)

                                                                                                    No peer dependencies.

                                                                                                    Badge

                                                                                                    To add a badge like this onejsDocs.io badgeto 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/timegrid.

                                                                                                    • Markdown
                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@fullcalendar/timegrid)
                                                                                                    • HTML
                                                                                                      <a href="https://www.jsdocs.io/package/@fullcalendar/timegrid"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>