@fullcalendar/interaction

  • Version 5.11.3
  • Published
  • 510 kB
  • 2 dependencies
  • MIT license

Install

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

Overview

Provides functionality for event drag-n-drop, resizing, dateClick, and selectable actions

Index

Variables

variable _default

const _default: _fullcalendar_common.PluginDef;

    variable LISTENER_REFINERS

    const LISTENER_REFINERS: {
    dateClick: Identity<(arg: DateClickArg) => void>;
    eventDragStart: Identity<(arg: EventDragStartArg) => void>;
    eventDragStop: Identity<(arg: EventDragStopArg) => void>;
    eventDrop: Identity<(arg: EventDropArg) => void>;
    eventResizeStart: Identity<(arg: EventResizeStartArg) => void>;
    eventResizeStop: Identity<(arg: EventResizeStopArg) => void>;
    eventResize: Identity<(arg: EventResizeDoneArg) => void>;
    drop: Identity<(arg: DropArg) => void>;
    eventReceive: Identity<(arg: EventReceiveArg) => void>;
    eventLeave: Identity<(arg: EventLeaveArg) => void>;
    };

      variable OPTION_REFINERS

      const OPTION_REFINERS: { fixedMirrorParent: Identity<HTMLElement> };

        Classes

        class Draggable

        class ExternalDraggable {}

          constructor

          constructor(el: HTMLElement, settings?: ExternalDraggableSettings);

            property dragging

            dragging: FeaturefulElementDragging;

              property handleDragStart

              handleDragStart: (ev: PointerDragEvent) => void;

                property handlePointerDown

                handlePointerDown: (ev: PointerDragEvent) => void;

                  property settings

                  settings: ExternalDraggableSettings;

                    method destroy

                    destroy: () => void;

                      class FeaturefulElementDragging

                      class FeaturefulElementDragging extends ElementDragging {}

                        constructor

                        constructor(containerEl: HTMLElement, selector?: string);

                          property autoScroller

                          autoScroller: AutoScroller;

                            property delay

                            delay: number;

                              property delayTimeoutId

                              delayTimeoutId: number;

                                property isDelayEnded

                                isDelayEnded: boolean;

                                  property isDistanceSurpassed

                                  isDistanceSurpassed: boolean;

                                    property isDragging

                                    isDragging: boolean;

                                      property isInteracting

                                      isInteracting: boolean;

                                        property minDistance

                                        minDistance: number;

                                          property mirror

                                          mirror: ElementMirror;

                                            property mirrorNeedsRevert

                                            mirrorNeedsRevert: boolean;

                                              property onPointerDown

                                              onPointerDown: (ev: PointerDragEvent) => void;

                                                property onPointerMove

                                                onPointerMove: (ev: PointerDragEvent) => void;

                                                  property onPointerUp

                                                  onPointerUp: (ev: PointerDragEvent) => void;

                                                    property pointer

                                                    pointer: PointerDragging;

                                                      property touchScrollAllowed

                                                      touchScrollAllowed: boolean;

                                                        method destroy

                                                        destroy: () => void;

                                                          method handleDelayEnd

                                                          handleDelayEnd: (ev: PointerDragEvent) => void;

                                                            method handleDistanceSurpassed

                                                            handleDistanceSurpassed: (ev: PointerDragEvent) => void;

                                                              method setAutoScrollEnabled

                                                              setAutoScrollEnabled: (bool: boolean) => void;

                                                                method setIgnoreMove

                                                                setIgnoreMove: (bool: boolean) => void;

                                                                  method setMirrorIsVisible

                                                                  setMirrorIsVisible: (bool: boolean) => void;

                                                                    method setMirrorNeedsRevert

                                                                    setMirrorNeedsRevert: (bool: boolean) => void;

                                                                      method startDelay

                                                                      startDelay: (ev: PointerDragEvent) => void;

                                                                        method stopDrag

                                                                        stopDrag: (ev: PointerDragEvent) => void;

                                                                          method tryStartDrag

                                                                          tryStartDrag: (ev: PointerDragEvent) => void;

                                                                            method tryStopDrag

                                                                            tryStopDrag: (ev: PointerDragEvent) => void;

                                                                              class PointerDragging

                                                                              class PointerDragging {}

                                                                                constructor

                                                                                constructor(containerEl: EventTarget);

                                                                                  property containerEl

                                                                                  containerEl: EventTarget;

                                                                                    property emitter

                                                                                    emitter: Emitter<any>;

                                                                                      property handleMouseDown

                                                                                      handleMouseDown: (ev: MouseEvent) => void;

                                                                                        property handleMouseMove

                                                                                        handleMouseMove: (ev: MouseEvent) => void;

                                                                                          property handleMouseUp

                                                                                          handleMouseUp: (ev: MouseEvent) => void;

                                                                                            property handleScroll

                                                                                            handleScroll: (ev: UIEvent) => void;

                                                                                              property handleSelector

                                                                                              handleSelector: string;

                                                                                                property handleTouchEnd

                                                                                                handleTouchEnd: (ev: TouchEvent) => void;

                                                                                                  property handleTouchMove

                                                                                                  handleTouchMove: (ev: TouchEvent) => void;

                                                                                                    property handleTouchScroll

                                                                                                    handleTouchScroll: () => void;

                                                                                                      property handleTouchStart

                                                                                                      handleTouchStart: (ev: TouchEvent) => void;

                                                                                                        property isDragging

                                                                                                        isDragging: boolean;

                                                                                                          property isTouchDragging

                                                                                                          isTouchDragging: boolean;

                                                                                                            property origPageX

                                                                                                            origPageX: number;

                                                                                                              property origPageY

                                                                                                              origPageY: number;

                                                                                                                property prevPageX

                                                                                                                prevPageX: number;

                                                                                                                  property prevPageY

                                                                                                                  prevPageY: number;

                                                                                                                    property prevScrollX

                                                                                                                    prevScrollX: number;

                                                                                                                      property prevScrollY

                                                                                                                      prevScrollY: number;

                                                                                                                        property selector

                                                                                                                        selector: string;

                                                                                                                          property shouldIgnoreMove

                                                                                                                          shouldIgnoreMove: boolean;

                                                                                                                            property shouldWatchScroll

                                                                                                                            shouldWatchScroll: boolean;

                                                                                                                              property subjectEl

                                                                                                                              subjectEl: HTMLElement;

                                                                                                                                property wasTouchScroll

                                                                                                                                wasTouchScroll: boolean;

                                                                                                                                  method cancelTouchScroll

                                                                                                                                  cancelTouchScroll: () => void;

                                                                                                                                    method cleanup

                                                                                                                                    cleanup: () => void;

                                                                                                                                      method createEventFromMouse

                                                                                                                                      createEventFromMouse: (ev: MouseEvent, isFirst?: boolean) => PointerDragEvent;

                                                                                                                                        method createEventFromTouch

                                                                                                                                        createEventFromTouch: (ev: TouchEvent, isFirst?: boolean) => PointerDragEvent;

                                                                                                                                          method destroy

                                                                                                                                          destroy: () => void;

                                                                                                                                            method destroyScrollWatch

                                                                                                                                            destroyScrollWatch: () => void;

                                                                                                                                              method initScrollWatch

                                                                                                                                              initScrollWatch: (ev: PointerDragEvent) => void;

                                                                                                                                                method querySubjectEl

                                                                                                                                                querySubjectEl: (ev: UIEvent) => HTMLElement;

                                                                                                                                                  method recordCoords

                                                                                                                                                  recordCoords: (ev: PointerDragEvent) => void;

                                                                                                                                                    method shouldIgnoreMouse

                                                                                                                                                    shouldIgnoreMouse: () => number | boolean;

                                                                                                                                                      method tryStart

                                                                                                                                                      tryStart: (ev: UIEvent) => boolean;

                                                                                                                                                        class ThirdPartyDraggable

                                                                                                                                                        class ThirdPartyDraggable {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(
                                                                                                                                                          containerOrSettings?: EventTarget | ThirdPartyDraggableSettings,
                                                                                                                                                          settings?: ThirdPartyDraggableSettings
                                                                                                                                                          );

                                                                                                                                                            property dragging

                                                                                                                                                            dragging: InferredElementDragging;

                                                                                                                                                              method destroy

                                                                                                                                                              destroy: () => void;

                                                                                                                                                                Interfaces

                                                                                                                                                                interface DateClickArg

                                                                                                                                                                interface DateClickArg extends DatePointApi {}

                                                                                                                                                                  property dayEl

                                                                                                                                                                  dayEl: HTMLElement;

                                                                                                                                                                    property jsEvent

                                                                                                                                                                    jsEvent: MouseEvent;

                                                                                                                                                                      property view

                                                                                                                                                                      view: ViewApi;

                                                                                                                                                                        interface DropArg

                                                                                                                                                                        interface DropArg extends DatePointApi {}

                                                                                                                                                                          property draggedEl

                                                                                                                                                                          draggedEl: HTMLElement;

                                                                                                                                                                            property jsEvent

                                                                                                                                                                            jsEvent: MouseEvent;

                                                                                                                                                                              property view

                                                                                                                                                                              view: ViewApi;

                                                                                                                                                                                interface EventResizeDoneArg

                                                                                                                                                                                interface EventResizeDoneArg extends EventChangeArg {}

                                                                                                                                                                                  property el

                                                                                                                                                                                  el: HTMLElement;

                                                                                                                                                                                    property endDelta

                                                                                                                                                                                    endDelta: Duration;

                                                                                                                                                                                      property jsEvent

                                                                                                                                                                                      jsEvent: MouseEvent;

                                                                                                                                                                                        property startDelta

                                                                                                                                                                                        startDelta: Duration;

                                                                                                                                                                                          property view

                                                                                                                                                                                          view: ViewApi;

                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                            type EventDragStartArg

                                                                                                                                                                                            type EventDragStartArg = EventDragArg;

                                                                                                                                                                                              type EventDragStopArg

                                                                                                                                                                                              type EventDragStopArg = EventDragArg;

                                                                                                                                                                                                type EventLeaveArg

                                                                                                                                                                                                type EventLeaveArg = EventReceiveLeaveArg;

                                                                                                                                                                                                  type EventReceiveArg

                                                                                                                                                                                                  type EventReceiveArg = EventReceiveLeaveArg;

                                                                                                                                                                                                    type EventResizeStartArg

                                                                                                                                                                                                    type EventResizeStartArg = EventResizeStartStopArg;

                                                                                                                                                                                                      type EventResizeStopArg

                                                                                                                                                                                                      type EventResizeStopArg = EventResizeStartStopArg;

                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                        Dependencies (2)

                                                                                                                                                                                                        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/interaction.

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