lint fixes

packages-premium

@@ -1 +1 @@
-Subproject commit 98a4627a7446489160993a03d70a822134913100
+Subproject commit e6afd334e6de0150027bb9a145c44697afedf24d

packages/__tests__/src/legacy/eventLimit.ts

@@ -91,7 +91,6 @@ describe('dayMaxEventRows', () => { // TODO: rename file
         expect(moreEls.length).toBe(1)
         expect(moreEls[0]).toHaveText('+2 more')
         expect(moreEls[0]).toBeBoundedBy(cells[2])
-
       })
 
       // https://github.com/fullcalendar/fullcalendar/issues/6187

packages/common/src/event-placement.ts

@@ -1,4 +1,3 @@
-
 export interface SegInput {
   index: number
   spanStart: number
@@ -57,10 +56,9 @@ export class SegHierarchy {
     if (this.isInsertionValid(insertion, entry)) {
       this.insertEntryAt(entry, insertion)
       return 1
-
-    } else {
-      return this.handleInvalidInsertion(insertion, entry, hiddenEntries)
     }
+
+    return this.handleInvalidInsertion(insertion, entry, hiddenEntries)
   }
 
   isInsertionValid(insertion: SegInsertion, entry: SegEntry) {
@@ -71,10 +69,10 @@ export class SegHierarchy {
   handleInvalidInsertion(insertion: SegInsertion, entry: SegEntry, hiddenEntries: SegEntry[]) {
     if (this.allowReslicing && insertion.touchingEntry) {
       return this.splitEntry(entry, insertion.touchingEntry, hiddenEntries)
-    } else {
-      hiddenEntries.push(entry)
-      return 0
     }
+
+    hiddenEntries.push(entry)
+    return 0
   }
 
   splitEntry(entry: SegEntry, barrier: SegEntry, hiddenEntries: SegEntry[]): number {
@@ -85,7 +83,7 @@ export class SegHierarchy {
       partCnt += this.insertEntry({
         ...entry,
         spanStart: entry.spanStart,
-        spanEnd: barrier.spanStart
+        spanEnd: barrier.spanStart,
       }, splitHiddenEntries)
     }
 
@@ -104,11 +102,10 @@ export class SegHierarchy {
         spanEnd: Math.min(barrier.spanEnd, entry.spanEnd), // intersect
       }, ...splitHiddenEntries)
       return partCnt
-
-    } else {
-      hiddenEntries.push(entry)
-      return 0
     }
+
+    hiddenEntries.push(entry)
+    return 0
   }
 
   insertEntryAt(entry: SegEntry, insertion: SegInsertion): void {
@@ -157,10 +154,10 @@ export class SegHierarchy {
           touchingEntry = entry
           resCoord = levelCoord + entry.thickness // move to bottom of colliding entry
         }
-        lateralEnd++
+        lateralEnd += 1
       }
 
-      level++
+      level += 1
     }
 
     return {
@@ -169,7 +166,7 @@ export class SegHierarchy {
       lateralStart,
       lateralEnd,
       touchingEntry,
-      stackCnt: touchingEntry ? stackCnts[buildEntryKey(touchingEntry)] + 1 : 0
+      stackCnt: touchingEntry ? stackCnts[buildEntryKey(touchingEntry)] + 1 : 0,
     }
   }
 
@@ -179,7 +176,7 @@ export class SegHierarchy {
     let levelCnt = entriesByLevel.length
     let rects: SegRect[] = []
 
-    for (let level = 0; level < levelCnt; level++) {
+    for (let level = 0; level < levelCnt; level += 1) {
       let entries = entriesByLevel[level]
       let levelCoord = levelCoords[level]
 
@@ -210,14 +207,15 @@ function insertAt<Item>(arr: Item[], index: number, item: Item) {
 export function binarySearch<Item>(
   a: Item[],
   searchVal: number,
-  getItemVal: (item: Item) => number
+  getItemVal: (item: Item) => number,
 ): [number, number] { // returns [level, isExactMatch ? 1 : 0]
   let startIndex = 0
   let endIndex = a.length // exclusive
 
   if (!endIndex || searchVal < getItemVal(a[startIndex])) { // no items OR before first item
     return [0, 0]
-  } else if (searchVal > getItemVal(a[endIndex - 1])) { // after last item
+  }
+  if (searchVal > getItemVal(a[endIndex - 1])) { // after last item
     return [endIndex, 0]
   }
 

packages/daygrid/src/TableRow.tsx

@@ -15,7 +15,7 @@ import {
   isPropsEqual,
   createRef,
   buildEventRangeKey,
-  sortEventSegs
+  sortEventSegs,
 } from '@fullcalendar/common'
 import { TableSeg, splitSegsByFirstCol } from './TableSeg'
 import { TableCell, TableCellModel, MoreLinkArg } from './TableCell'
@@ -83,7 +83,7 @@ export class TableRow extends DateComponent<TableRowProps, TableRowState> {
       props.dayMaxEventRows,
       state.eventInstanceHeights,
       state.maxContentHeight,
-      props.cells
+      props.cells,
     )
 
     let isForcedInvisible = // TODO: messy way to compute this
@@ -240,8 +240,8 @@ export class TableRow extends DateComponent<TableRowProps, TableRowState> {
               visibility: isVisible ? ('' as any) : 'hidden',
               marginTop: isAbsolute ? '' : placement.marginTop,
               top: isAbsolute ? placement.absoluteTop : '',
-              left: left,
-              right: right,
+              left,
+              right,
             }}
           >
             {hasListItemDisplay(seg) ? (
@@ -384,7 +384,7 @@ function buildMirrorPlacements(mirrorSegs: TableSeg[], colPlacements: TableSegPl
     isVisible: true,
     isAbsolute: true,
     absoluteTop: topsByInstanceId[seg.eventRange.instance.instanceId],
-    marginTop: 0
+    marginTop: 0,
   }))
 }
 

packages/daygrid/src/event-placement.ts

@@ -26,7 +26,7 @@ export function computeFgSegPlacement(
   dayMaxEventRows: boolean | number,
   eventInstanceHeights: { [instanceId: string]: number },
   maxContentHeight: number | null,
-  cells: TableCellModel[]
+  cells: TableCellModel[],
 ) {
   let hierarchy = new DayGridSegHierarchy()
   hierarchy.allowReslicing = true
@@ -44,7 +44,7 @@ export function computeFgSegPlacement(
   // create segInputs only for segs with known heights
   let segInputs: SegInput[] = []
   let unknownHeightSegs: TableSeg[] = []
-  for (let i = 0; i < segs.length; i++) {
+  for (let i = 0; i < segs.length; i += 1) {
     let seg = segs[i]
     let { instanceId } = seg.eventRange.instance
     let eventHeight = eventInstanceHeights[instanceId]
@@ -54,7 +54,7 @@ export function computeFgSegPlacement(
         index: i,
         spanStart: seg.firstCol,
         spanEnd: seg.lastCol + 1,
-        thickness: eventHeight
+        thickness: eventHeight,
       })
     } else {
       unknownHeightSegs.push(seg)
@@ -79,7 +79,7 @@ export function computeFgSegPlacement(
       marginTop: 0,
     })
 
-    for (let col = seg.firstCol; col <= seg.lastCol; col++) {
+    for (let col = seg.firstCol; col <= seg.lastCol; col += 1) {
       singleColPlacements[col].push({
         seg: resliceSeg(seg, col, col + 1, cells),
         isVisible: false,
@@ -91,7 +91,7 @@ export function computeFgSegPlacement(
   }
 
   // add the hidden entries
-  for (let col = 0; col < cells.length; col++) {
+  for (let col = 0; col < cells.length; col += 1) {
     moreCnts.push(0)
   }
   for (let hiddenEntry of hiddenEntries) {
@@ -105,8 +105,8 @@ export function computeFgSegPlacement(
       marginTop: 0,
     })
 
-    for (let col = hiddenEntry.spanStart; col < hiddenEntry.spanEnd; col++) {
-      moreCnts[col]++
+    for (let col = hiddenEntry.spanStart; col < hiddenEntry.spanEnd; col += 1) {
+      moreCnts[col] += 1
       singleColPlacements[col].push({
         seg: resliceSeg(seg, col, col + 1, cells),
         isVisible: false,
@@ -118,7 +118,7 @@ export function computeFgSegPlacement(
   }
 
   // deal with leftover margins
-  for (let col = 0; col < cells.length; col++) {
+  for (let col = 0; col < cells.length; col += 1) {
     if (moreCnts[col]) {
       moreMarginTops.push(leftoverMargins[col])
       cellPaddingBottoms.push(0)
@@ -132,13 +132,13 @@ export function computeFgSegPlacement(
 }
 
 // rects ordered by top coord, then left
-function placeRects(rects: SegRect[], segs: TableSeg[], cells: TableCellModel[]) {
-  let rectsByEachCol = groupRectsByEachCol(rects, cells.length)
+function placeRects(allRects: SegRect[], segs: TableSeg[], cells: TableCellModel[]) {
+  let rectsByEachCol = groupRectsByEachCol(allRects, cells.length)
   let singleColPlacements: TableSegPlacement[][] = []
   let multiColPlacements: TableSegPlacement[][] = []
   let leftoverMargins: number[] = []
 
-  for (let col = 0; col < cells.length; col++) {
+  for (let col = 0; col < cells.length; col += 1) {
     let rects = rectsByEachCol[col]
 
     // compute all static segs in singlePlacements
@@ -152,7 +152,7 @@ function placeRects(rects: SegRect[], segs: TableSeg[], cells: TableCellModel[])
         isVisible: true,
         isAbsolute: false,
         absoluteTop: 0,
-        marginTop: rect.levelCoord - currentHeight
+        marginTop: rect.levelCoord - currentHeight,
       })
       currentHeight = rect.levelCoord + rect.thickness
     }
@@ -180,17 +180,15 @@ function placeRects(rects: SegRect[], segs: TableSeg[], cells: TableCellModel[])
             marginTop: 0,
           })
         }
-      } else {
-        if (isFirstCol) {
-          multiPlacements.push({
-            seg: resliceSeg(seg, rect.spanStart, rect.spanEnd, cells),
-            isVisible: true,
-            isAbsolute: false,
-            absoluteTop: 0,
-            marginTop: currentMarginTop // claim the margin
-          })
-          currentMarginTop = 0
-        }
+      } else if (isFirstCol) {
+        multiPlacements.push({
+          seg: resliceSeg(seg, rect.spanStart, rect.spanEnd, cells),
+          isVisible: true,
+          isAbsolute: false,
+          absoluteTop: 0,
+          marginTop: currentMarginTop, // claim the margin
+        })
+        currentMarginTop = 0
       }
     }
 
@@ -205,12 +203,12 @@ function placeRects(rects: SegRect[], segs: TableSeg[], cells: TableCellModel[])
 function groupRectsByEachCol(rects: SegRect[], colCnt: number): SegRect[][] {
   let rectsByEachCol: SegRect[][] = []
 
-  for (let col = 0; col < colCnt; col++) {
+  for (let col = 0; col < colCnt; col += 1) {
     rectsByEachCol.push([])
   }
 
   for (let rect of rects) {
-    for (let col = rect.spanStart; col < rect.spanEnd; col++) {
+    for (let col = rect.spanStart; col < rect.spanEnd; col += 1) {
       rectsByEachCol[col].push(rect)
     }
   }
@@ -227,7 +225,7 @@ function resliceSeg(seg: TableSeg, spanStart: number, spanEnd: number, cells: Ta
   let origRange = eventRange.range
   let slicedRange = intersectRanges(origRange, {
     start: cells[spanStart].date,
-    end: addDays(cells[spanEnd - 1].date, 1)
+    end: addDays(cells[spanEnd - 1].date, 1),
   })
 
   return {
@@ -258,7 +256,7 @@ class DayGridSegHierarchy extends SegHierarchy {
     const excludeHidden = (entry: SegEntry) => !this.forceHidden[buildEntryKey(entry)]
 
     // remove the forced-hidden segs
-    for (let level = 0; level < entriesByLevel.length; level++) {
+    for (let level = 0; level < entriesByLevel.length; level += 1) {
       entriesByLevel[level] = entriesByLevel[level].filter(excludeHidden)
     }
 
@@ -270,14 +268,14 @@ class DayGridSegHierarchy extends SegHierarchy {
     const level = insertion.nextLevel - 1
 
     if (this.hiddenConsumes && level >= 0) {
-      for (let lateral = insertion.lateralStart; lateral < insertion.lateralEnd; lateral++) {
+      for (let lateral = insertion.lateralStart; lateral < insertion.lateralEnd; lateral += 1) {
         const leadingEntry = entriesByLevel[level][lateral]
 
         if (this.allowReslicing) {
           const placeholderEntry = {
             ...leadingEntry,
             spanStart: Math.max(leadingEntry.spanStart, entry.spanStart),
-            spanEnd: Math.min(leadingEntry.spanEnd, entry.spanEnd)
+            spanEnd: Math.min(leadingEntry.spanEnd, entry.spanEnd),
           }
           const placeholderEntryId = buildEntryKey(placeholderEntry)
 

packages/timegrid/src/TimeCol.tsx

@@ -163,7 +163,7 @@ export class TimeCol extends BaseComponent<TimeColProps> {
         ...this.computeSegTopBottomCss(segRect.segInput),
         // mirrors will span entire column width
         // also, won't assign z-index, which is good, fc-event-mirror will overpower other harnesses
-        ...(isMirror ? { left: 0, right: 0 } : this.computeSegLeftRightCss(segRect))
+        ...(isMirror ? { left: 0, right: 0 } : this.computeSegLeftRightCss(segRect)),
       }
 
       return (
@@ -194,7 +194,7 @@ export class TimeCol extends BaseComponent<TimeColProps> {
     let { eventMinHeight } = this.context.options
     let segInputs: SegInput[] = []
 
-    for (let i = 0; i < segs.length; i++) {
+    for (let i = 0; i < segs.length; i += 1) {
       let seg = segs[i]
       let spanStart = slatCoords.computeDateTop(seg.start, date)
       let spanEnd = Math.max(
@@ -205,7 +205,7 @@ export class TimeCol extends BaseComponent<TimeColProps> {
         index: i,
         spanStart: Math.round(spanStart), // for barely-overlapping collisions
         spanEnd: Math.round(spanEnd), //
-        thickness: 1
+        thickness: 1,
       })
     }
 

packages/timegrid/src/event-placement.ts

@@ -46,22 +46,22 @@ function buildWeb(hierarchy: SegHierarchy): SegNode[] {
 
       return [
         { ...entry, nextLevelNodes: nextLevelRes[0] },
-        entry.thickness + nextLevelRes[1] // the pressure builds
+        entry.thickness + nextLevelRes[1], // the pressure builds
       ]
-    }
+    },
   )
 
   return buildNodes(
     entriesByLevel.length
       ? { level: 0, lateralStart: 0, lateralEnd: entriesByLevel[0].length }
       : null,
-    buildNode
+    buildNode,
   )[0]
 }
 
 function buildNodes(
   siblingRange: SegSiblingRange | null,
-  buildNode: (level: number, lateral: number) => SegNodeAndPressure
+  buildNode: (level: number, lateral: number) => SegNodeAndPressure,
 ): [SegNode[], number] { // number is maxPressure
   if (!siblingRange) {
     return [[], 0]
@@ -73,14 +73,14 @@ function buildNodes(
 
   while (lateral < lateralEnd) {
     pairs.push(buildNode(level, lateral))
-    lateral++
+    lateral += 1
   }
 
   pairs.sort(cmpDescPressures)
 
   return [
     pairs.map(extractNode),
-    pairs[0][1] // first item's pressure
+    pairs[0][1], // first item's pressure
   ]
 }
 
@@ -100,9 +100,9 @@ function findNextLevelSegs(hierarchy: SegHierarchy, subjectLevel: number, subjec
   let level = subjectLevel
 
   // skip past levels that are too high up
-  for (; level < levelCnt && levelCoords[level] < afterSubject; level++) ; // do nothing
+  for (; level < levelCnt && levelCoords[level] < afterSubject; level += 1) ; // do nothing
 
-  for (; level < levelCnt; level++) {
+  for (; level < levelCnt; level += 1) {
     let entries = entriesByLevel[level]
     let entry: SegEntry
     let searchIndex = binarySearch(entries, subjectEntry.spanStart, getEntrySpanEnd)
@@ -112,7 +112,7 @@ function findNextLevelSegs(hierarchy: SegHierarchy, subjectLevel: number, subjec
     while ( // loop through entries that horizontally intersect
       (entry = entries[lateralEnd]) && // but not past the whole seg list
       entry.spanStart < subjectEntry.spanEnd
-    ) { lateralEnd++ }
+    ) { lateralEnd += 1 }
 
     if (lateralStart < lateralEnd) {
       return { level, lateralStart, lateralEnd }
@@ -151,9 +151,9 @@ function stretchWeb(topLevelNodes: SegNode[], totalThickness: number): SegNode[]
       return [endCoord - newThickness, {
         ...node,
         thickness: newThickness,
-        nextLevelNodes: newChildren
+        nextLevelNodes: newChildren,
       }]
-    }
+    },
   )
 
   return topLevelNodes.map((node: SegNode) => stretchNode(node, 0, 0)[1])
@@ -170,14 +170,14 @@ function webToRects(topLevelNodes: SegNode[]): TimeColSegRect[] {
         ...node,
         levelCoord,
         stackDepth,
-        stackForward: 0 // will assign after recursing
+        stackForward: 0, // will assign after recursing
       }
       rects.push(rect)
 
       return (
         rect.stackForward = processNodes(node.nextLevelNodes, levelCoord + node.thickness, stackDepth + 1) + 1
       )
-    }
+    },
   )
 
   function processNodes(nodes: SegNode[], levelCoord: number, stackDepth: number) { // returns stackForward
@@ -235,7 +235,7 @@ function groupIntersectingEntries(entries: SegEntry[]): SegEntryGroup[] {
 
 function cacheable<Args extends any[], Res>(
   keyFunc: (...args: Args) => string,
-  workFunc: (...args: Args) => Res
+  workFunc: (...args: Args) => Res,
 ): ((...args: Args) => Res) {
   const cache: { [key: string]: Res } = {}