@fullcalendar/timeline 6.1.14 → 7.0.0-beta.0

package/internal.d.ts

@@ -1,7 +1,41 @@
-import { DateRange, DateMarker, DateProfile, DateEnv, BaseOptionsRefined, DateProfileGenerator, PositionCache, SegSpan, DateComponent, ViewProps, Seg, Slicer, EventStore, EventUiHash, DateSpan, EventInteractionState, BaseComponent, ScrollRequest } from '@fullcalendar/core/internal';
-import { createElement, RefObject, VNode } from '@fullcalendar/core/preact';
+import { DateComponent, ViewProps, Hit, DateRange, DateMarker, DateProfile, DateEnv, BaseOptionsRefined, DateProfileGenerator, Seg, Slicer, EventStore, EventUiHash, DateSpan, EventInteractionState, BaseComponent, SegGroup, SegSpan } from '@fullcalendar/core/internal';
+import { createElement, Ref } from '@fullcalendar/core/preact';
 import { Duration, CssDimValue } from '@fullcalendar/core';
 
+interface TimelineViewState {
+    scrollerWidth?: number;
+    leftScrollbarWidth?: number;
+    rightScrollbarWidth?: number;
+    slotInnerWidth?: number;
+}
+declare class TimelineView extends DateComponent<ViewProps, TimelineViewState> {
+    private buildTimelineDateProfile;
+    private computeSlotWidth;
+    private headerScrollerRef;
+    private bodyScrollerRef;
+    private footerScrollerRef;
+    private tDateProfile?;
+    private bodyEl?;
+    private slotWidth?;
+    private headerSlotInnerWidth?;
+    private bodySlotInnerWidth?;
+    private syncedScroller;
+    render(): createElement.JSX.Element;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ViewProps): void;
+    componentWillUnmount(): void;
+    handleHeaderSlotInnerWidth: (innerWidth: number) => void;
+    handleBodySlotInnerWidth: (innerWidth: number) => void;
+    handleSlotInnerWidths: () => void;
+    handleScrollerWidth: (scrollerWidth: number) => void;
+    handleLeftScrollbarWidth: (leftScrollbarWidth: number) => void;
+    handleRightScrollbarWidth: (rightScrollbarWidth: number) => void;
+    updateSyncedScroller(): void;
+    private timeScrollResponder;
+    handeBodyEl: (el: HTMLElement | null) => void;
+    queryHit(positionLeft: number, positionTop: number, elWidth: number, elHeight: number): Hit;
+}
+
 interface TimelineDateProfile {
     labelInterval: Duration;
     slotDuration: Duration;
@@ -20,9 +54,9 @@ interface TimelineDateProfile {
     snapIndexToDiff: number[];
     snapCnt: number;
     slotCnt: number;
-    cellRows: TimelineHeaderCell[][];
+    cellRows: TimelineHeaderCellData[][];
 }
-interface TimelineHeaderCell {
+interface TimelineHeaderCellData {
     date: DateMarker;
     text: string;
     rowUnit: string;
@@ -31,54 +65,6 @@ interface TimelineHeaderCell {
 }
 declare function buildTimelineDateProfile(dateProfile: DateProfile, dateEnv: DateEnv, allOptions: BaseOptionsRefined, dateProfileGenerator: DateProfileGenerator): TimelineDateProfile;
 
-declare class TimelineCoords {
-    slatRootEl: HTMLElement;
-    dateProfile: DateProfile;
-    private tDateProfile;
-    private dateEnv;
-    isRtl: boolean;
-    outerCoordCache: PositionCache;
-    innerCoordCache: PositionCache;
-    constructor(slatRootEl: HTMLElement, // okay to expose?
-    slatEls: HTMLElement[], dateProfile: DateProfile, tDateProfile: TimelineDateProfile, dateEnv: DateEnv, isRtl: boolean);
-    isDateInRange(date: DateMarker): boolean;
-    dateToCoord(date: DateMarker): number;
-    rangeToCoords(range: DateRange): SegSpan;
-    durationToCoord(duration: Duration): number;
-    coordFromLeft(coord: number): number;
-    computeDateSnapCoverage(date: DateMarker): number;
-}
-declare function coordToCss(hcoord: number | null, isRtl: boolean): {
-    left: CssDimValue;
-    right: CssDimValue;
-};
-declare function coordsToCss(hcoords: SegSpan | null, isRtl: boolean): {
-    left: CssDimValue;
-    right: CssDimValue;
-};
-
-interface TimelineViewState {
-    slatCoords: TimelineCoords | null;
-    slotCushionMaxWidth: number | null;
-}
-declare class TimelineView extends DateComponent<ViewProps, TimelineViewState> {
-    private buildTimelineDateProfile;
-    private scrollGridRef;
-    state: {
-        slatCoords: any;
-        slotCushionMaxWidth: any;
-    };
-    render(): createElement.JSX.Element;
-    handleSlatCoords: (slatCoords: TimelineCoords | null) => void;
-    handleScrollLeftRequest: (scrollLeft: number) => void;
-    handleMaxCushionWidth: (slotCushionMaxWidth: any) => void;
-    computeFallbackSlotMinWidth(tDateProfile: TimelineDateProfile): number;
-}
-declare function buildSlatCols(tDateProfile: TimelineDateProfile, slotMinWidth?: number): {
-    span: number;
-    minWidth: number;
-}[];
-
 interface TimelineLaneSeg extends Seg {
     start: DateMarker;
     end: DateMarker;
@@ -92,140 +78,154 @@ declare class TimelineLaneSlicer extends Slicer<TimelineLaneSeg, [
     sliceRange(origRange: DateRange, dateProfile: DateProfile, dateProfileGenerator: DateProfileGenerator, tDateProfile: TimelineDateProfile, dateEnv: DateEnv): TimelineLaneSeg[];
 }
 
-interface TimelineSegPlacement {
-    seg: TimelineLaneSeg | TimelineLaneSeg[];
-    hcoords: SegSpan | null;
-    top: number | null;
+interface TimelineSegHorizontals {
+    start: number;
+    size: number;
 }
 
-interface TimelineLaneProps extends TimelineLaneCoreProps {
-    onHeightChange?: (innerEl: HTMLElement, isStable: boolean) => void;
-}
-interface TimelineLaneCoreProps {
-    nowDate: DateMarker;
-    todayRange: DateRange;
+interface TimelineLaneProps {
     dateProfile: DateProfile;
     tDateProfile: TimelineDateProfile;
+    nowDate: DateMarker;
+    todayRange: DateRange;
     nextDayThreshold: Duration;
-    businessHours: EventStore | null;
     eventStore: EventStore | null;
     eventUiBases: EventUiHash;
+    businessHours: EventStore | null;
     dateSelection: DateSpan | null;
-    eventSelection: string;
     eventDrag: EventInteractionState | null;
     eventResize: EventInteractionState | null;
-    timelineCoords: TimelineCoords | null;
+    eventSelection: string;
     resourceId?: string;
-    syncParentMinHeight?: boolean;
+    slotWidth: number | undefined;
 }
 interface TimelineLaneState {
-    eventInstanceHeights: {
-        [instanceId: string]: number;
-    };
-    moreLinkHeights: {
-        [isoStr: string]: number;
-    };
+    segHeightRev?: string;
+    moreLinkHeightRev?: string;
 }
 declare class TimelineLane extends BaseComponent<TimelineLaneProps, TimelineLaneState> {
-    private slicer;
     private sortEventSegs;
-    private harnessElRefs;
-    private moreElRefs;
-    private innerElRef;
-    state: TimelineLaneState;
+    private segHeightRefMap;
+    private moreLinkHeightRefMap;
+    private slicer;
     render(): createElement.JSX.Element;
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: TimelineLaneProps, prevState: TimelineLaneState): void;
-    componentWillUnmount(): void;
-    handleResize: (isForced: boolean) => void;
-    updateSize(): void;
-    renderFgSegs(segPlacements: TimelineSegPlacement[], isForcedInvisible: {
+    renderFgSegs(segs: TimelineLaneSeg[], segHorizontals: {
+        [instanceId: string]: TimelineSegHorizontals;
+    }, segTops: {
+        [instanceId: string]: number;
+    }, forcedInvisibleMap: {
         [instanceId: string]: any;
+    }, hiddenGroups: SegGroup[], hiddenGroupTops: {
+        [key: string]: number;
     }, isDragging: boolean, isResizing: boolean, isDateSelecting: boolean): createElement.JSX.Element;
+    private handleMoreLinkHeights;
+    private handleSegHeights;
 }
 
 interface TimelineLaneBgProps {
-    businessHourSegs: TimelineLaneSeg[] | null;
+    tDateProfile: TimelineDateProfile;
+    nowDate: DateMarker;
+    todayRange: DateRange;
     bgEventSegs: TimelineLaneSeg[] | null;
+    businessHourSegs: TimelineLaneSeg[] | null;
     dateSelectionSegs: TimelineLaneSeg[];
     eventResizeSegs: TimelineLaneSeg[];
-    timelineCoords: TimelineCoords | null;
-    todayRange: DateRange;
-    nowDate: DateMarker;
+    slotWidth: number | undefined;
 }
 declare class TimelineLaneBg extends BaseComponent<TimelineLaneBgProps> {
     render(): createElement.JSX.Element;
-    renderSegs(segs: TimelineLaneSeg[], timelineCoords: TimelineCoords | null, fillType: string): createElement.JSX.Element;
+    renderSegs(segs: TimelineLaneSeg[], fillType: string): createElement.JSX.Element;
 }
 
-interface TimelineHeaderProps {
+interface TimelineSlatsProps {
     dateProfile: DateProfile;
     tDateProfile: TimelineDateProfile;
-    clientWidth: number | null;
-    clientHeight: number | null;
-    tableMinWidth: CssDimValue;
-    tableColGroupNode: VNode;
-    slatCoords: TimelineCoords;
-    rowInnerHeights?: number[];
-    onMaxCushionWidth?: (number: any) => void;
-}
-declare class TimelineHeader extends BaseComponent<TimelineHeaderProps> {
-    rootElRef: RefObject<HTMLDivElement>;
+    nowDate: DateMarker;
+    todayRange: DateRange;
+    slotWidth: number | undefined;
+    innerWidthRef?: Ref<number>;
+}
+declare class TimelineSlats extends BaseComponent<TimelineSlatsProps> {
+    private innerWidthRefMap;
     render(): createElement.JSX.Element;
-    componentDidMount(): void;
-    componentDidUpdate(): void;
-    updateSize(): void;
-    computeMaxCushionWidth(): number;
+    handleInnerWidths: () => void;
 }
 
-interface TimelineSlatsContentProps {
+interface CoordRange {
+    start: number;
+    size: number;
+}
+declare function createVerticalStyle(props: {
+    start: number;
+    size: number;
+} | undefined): {
+    top: number;
+    height: number;
+} | undefined;
+declare function createHorizontalStyle(props: {
+    start: number;
+    size: number;
+} | undefined, isRtl: boolean): {
+    left: number;
+    width: number;
+} | {
+    right: number;
+    width: number;
+} | undefined;
+declare function computeSlotWidth(slatCnt: number, slatsPerLabel: number, slatMinWidth: number | undefined, labelInnerWidth: number | undefined, viewportWidth: number | undefined): [
+    canvasWidth: number | undefined,
+    slatWidth: number | undefined,
+    slatLiquid: boolean
+];
+declare function timeToCoord(// pixels
+time: Duration, dateEnv: DateEnv, dateProfile: DateProfile, tDateProfile: TimelineDateProfile, slowWidth: number): number;
+
+declare function coordToCss(hcoord: number | null, isRtl: boolean): {
+    left: CssDimValue;
+    right: CssDimValue;
+};
+declare function coordsToCss(hcoords: SegSpan | null, isRtl: boolean): {
+    left: CssDimValue;
+    right: CssDimValue;
+};
+
+interface TimelineHeaderRowProps {
     dateProfile: DateProfile;
     tDateProfile: TimelineDateProfile;
     nowDate: DateMarker;
     todayRange: DateRange;
+    rowLevel: number;
+    isLastRow: boolean;
+    cells: TimelineHeaderCellData[];
+    innerHeighRef?: Ref<number>;
+    innerWidthRef?: Ref<number>;
+    slotWidth: number | undefined;
+    height?: number;
+}
+declare class TimelineHeaderRow extends BaseComponent<TimelineHeaderRowProps> {
+    private innerWidthRefMap;
+    private innerHeightRefMap;
+    render(): createElement.JSX.Element;
+    handleInnerWidths: () => void;
+    handleInnerHeights: () => void;
 }
 
-interface TimelineSlatsProps extends TimelineSlatsContentProps {
-    clientWidth: number | null;
-    tableMinWidth: CssDimValue;
-    tableColGroupNode: VNode;
-    onCoords?: (coord: TimelineCoords | null) => void;
-    onScrollLeftRequest?: (scrollLeft: number) => void;
+interface TimelineNowIndicatorArrowProps {
+    tDateProfile: TimelineDateProfile;
+    nowDate: DateMarker;
+    slotWidth: number | undefined;
 }
-declare class TimelineSlats extends BaseComponent<TimelineSlatsProps> {
-    private rootElRef;
-    private cellElRefs;
-    private coords;
-    private scrollResponder;
+declare class TimelineNowIndicatorArrow extends BaseComponent<TimelineNowIndicatorArrowProps> {
     render(): createElement.JSX.Element;
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: TimelineSlatsProps): void;
-    componentWillUnmount(): void;
-    updateSizing(): void;
-    handleScrollRequest: (request: ScrollRequest) => boolean;
-    positionToHit(leftPosition: any): {
-        dateSpan: {
-            range: {
-                start: Date;
-                end: Date;
-            };
-            allDay: boolean;
-        };
-        dayEl: HTMLTableCellElement;
-        left: any;
-        right: any;
-    };
 }
 
-interface TimelineHeaderRowsProps {
-    dateProfile: DateProfile;
+interface TimelineNowIndicatorLineProps {
     tDateProfile: TimelineDateProfile;
     nowDate: DateMarker;
-    todayRange: DateRange;
-    rowInnerHeights?: number[];
+    slotWidth: number | undefined;
 }
-declare class TimelineHeaderRows extends BaseComponent<TimelineHeaderRowsProps> {
+declare class TimelineNowIndicatorLine extends BaseComponent<TimelineNowIndicatorLineProps> {
     render(): createElement.JSX.Element;
 }
 
-export { TimelineCoords, TimelineDateProfile, TimelineHeader, TimelineHeaderRows, TimelineLane, TimelineLaneBg, TimelineLaneCoreProps, TimelineLaneProps, TimelineLaneSeg, TimelineLaneSlicer, TimelineSlats, TimelineView, buildSlatCols, buildTimelineDateProfile, coordToCss, coordsToCss };
+export { CoordRange, TimelineDateProfile, TimelineHeaderRow, TimelineLane, TimelineLaneBg, TimelineLaneProps, TimelineLaneSeg, TimelineLaneSlicer, TimelineNowIndicatorArrow, TimelineNowIndicatorLine, TimelineSlats, TimelineView, buildTimelineDateProfile, computeSlotWidth, coordToCss, coordsToCss, createHorizontalStyle, createVerticalStyle, timeToCoord };