:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import { cloneLayoutItem, horizontalCompactor, noCompactor } from 'react-grid-layout'
import type { Compactor, Layout, LayoutItem } from 'react-grid-layout'
import { fastVerticalCompactor } from 'react-grid-layout/extras'
import type { DashboardTileSpacing, TileGroupDisplay } from '~/types'
export const DashboardGridCompaction = {
Vertical: 'vertical',
Horizontal: 'horizontal',
Stable: 'stable',
} as const
export type DashboardGridCompaction = (typeof DashboardGridCompaction)[keyof typeof DashboardGridCompaction]
export const DASHBOARD_TILE_SPACING_GAPS: Record<DashboardTileSpacing, number> = {
tight: 8,
condensed: 12,
standard: 16,
relaxed: 32,
wide: 48,
}
export const DASHBOARD_TILE_SPACING_LABELS: Record<DashboardTileSpacing, string> = {
tight: 'Tight',
condensed: 'Compact',
standard: 'Standard',
relaxed: 'Relaxed',
wide: 'Wide',
}
const OFFERED_TILE_SPACINGS: DashboardTileSpacing[] = ['tight', 'condensed', 'standard']
// Relaxed and wide are no longer offered, but dashboards already using one keep it and still see it checked
export function getTileSpacingChoices(current: DashboardTileSpacing): DashboardTileSpacing[] {
return OFFERED_TILE_SPACINGS.includes(current) ? OFFERED_TILE_SPACINGS : [...OFFERED_TILE_SPACINGS, current]
}
export const DASHBOARD_GRID_COMPACTION_LABELS: Record<DashboardGridCompaction, string> = {
[DashboardGridCompaction.Vertical]: 'Stack tiles upward',
[DashboardGridCompaction.Horizontal]: 'Stack tiles to the left',
[DashboardGridCompaction.Stable]: 'Free-form placement',
}
export const TILE_GROUP_DISPLAY_LABELS: Record<TileGroupDisplay, string> = {
sections: 'Sections',
tabs: 'Tabs',
}
type GridOccupancy = Map<number, Array<LayoutItem | undefined>>
const MAX_FREE_FORM_TILE_HEIGHT_ROWS = 100
function getOccupants(occupancy: GridOccupancy, item: LayoutItem, cols: number): LayoutItem[] {
const occupants = new Set<LayoutItem>()
const startX = Math.max(0, item.x)
const endX = Math.min(cols, item.x + item.w)
for (let y = item.y; y < item.y + item.h; y++) {
const row = occupancy.get(y)
for (let x = startX; row && x < endX; x++) {
const occupant = row[x]
if (occupant) {
occupants.add(occupant)
}
}
}
return [...occupants]
}
function occupy(occupancy: GridOccupancy, item: LayoutItem, cols: number): void {
const startX = Math.max(0, item.x)
const endX = Math.min(cols, item.x + item.w)
for (let y = item.y; y < item.y + item.h; y++) {
const row = occupancy.get(y) ?? new Array<LayoutItem | undefined>(cols)
for (let x = startX; x < endX; x++) {
row[x] = item
}
occupancy.set(y, row)
}
}
function snapBetweenAdjacentTiles(
items: Layout,
activeTile: LayoutItem,
overlappingItems: LayoutItem[],
cols: number
): void {
if (overlappingItems.length < 2) {
return
}
const [left, ...others] = [...overlappingItems].sort((first, second) => first.x - second.x)
const right = others.find((item) => item.x > left.x)
if (
!right ||
left.x + left.w > right.x ||
overlappingItems.some(
(item) => (item.x !== left.x || item.w !== left.w) && (item.x !== right.x || item.w !== right.w)
)
) {
return
}
for (let distance = 1; distance <= activeTile.w; distance++) {
let bestCandidate: { x: number; collisions: number } | undefined
for (const candidateX of [activeTile.x + distance, activeTile.x - distance]) {
if (candidateX < 0 || candidateX + activeTile.w > cols) {
continue
}
const collisions = items.filter(
(item) =>
item.i !== activeTile.i &&
item.x < candidateX + activeTile.w &&
item.x + item.w > candidateX &&
item.y < activeTile.y + activeTile.h &&
item.y + item.h > activeTile.y
)
if (
collisions.length > 0 &&
collisions.every((collision) => overlappingItems.includes(collision)) &&
(collisions.every((collision) => collision.x === left.x) ||
collisions.every((collision) => collision.x === right.x)) &&
(!bestCandidate || collisions.length < bestCandidate.collisions)
) {
bestCandidate = { x: candidateX, collisions: collisions.length }
}
}
if (bestCandidate) {
activeTile.x = bestCandidate.x
return
}
}
}
export const freePlacementCompactor: Compactor = { ...noCompactor, allowOverlap: true }
export const makeRoomInRowCompactor: Compactor = horizontalCompactor
export interface DashboardGridCompactor extends Compactor {
compactInteraction: (
cols: number,
activeTileId: string,
restoredLayout: Layout,
resizedLayout: Layout,
isDragging?: boolean
) => Layout
}
export function resolveFreePlacementCollisions(
layout: Layout,
cols: number,
activeTileId?: string | null,
isDragging = true
): Layout {
const items = layout.map((item) => ({
...cloneLayoutItem(item),
h: Math.min(item.h, MAX_FREE_FORM_TILE_HEIGHT_ROWS),
}))
const activeTile = activeTileId ? items.find((item) => item.i === activeTileId) : undefined
if (activeTile && !activeTile.static && !items.some((item) => item.static)) {
const overlappingItems = items.filter(
(item) =>
item.i !== activeTileId &&
item.x < activeTile.x + activeTile.w &&
item.x + item.w > activeTile.x &&
item.y < activeTile.y + activeTile.h &&
item.y + item.h > activeTile.y
)
if (overlappingItems.length > 0) {
if (isDragging) {
snapBetweenAdjacentTiles(items, activeTile, overlappingItems, cols)
}
const occupancy: GridOccupancy = new Map()
const shiftByColumn = Array.from({ length: cols }, () => 0)
const lastOriginalBottomByColumn = Array.from({ length: cols }, () => 0)
const lastPlacedBottomByColumn = Array.from({ length: cols }, () => 0)
occupy(occupancy, activeTile, cols)
for (const item of items
.filter((item) => item.i !== activeTileId)
.sort((first, second) => first.y - second.y || first.x - second.x)) {
const originalY = item.y
const firstColumn = Math.max(0, item.x)
const lastColumn = Math.min(cols, item.x + item.w)
for (let column = firstColumn; column < lastColumn; column++) {
if (
originalY > lastOriginalBottomByColumn[column] &&
originalY >= lastPlacedBottomByColumn[column]
) {
shiftByColumn[column] = 0
}
item.y = Math.max(item.y, originalY + shiftByColumn[column])
}
let collisions = getOccupants(occupancy, item, cols)
while (collisions.length > 0) {
item.y = Math.max(...collisions.map((collision) => collision.y + collision.h))
collisions = getOccupants(occupancy, item, cols)
}
for (let column = firstColumn; column < lastColumn; column++) {
shiftByColumn[column] = Math.max(shiftByColumn[column], item.y - originalY)
lastOriginalBottomByColumn[column] = Math.max(
lastOriginalBottomByColumn[column],
originalY + item.h
)
lastPlacedBottomByColumn[column] = Math.max(lastPlacedBottomByColumn[column], item.y + item.h)
}
occupy(occupancy, item, cols)
}
return items
}
}
const occupancy: GridOccupancy = new Map()
for (const item of items) {
if (item.static) {
occupy(occupancy, item, cols)
}
}
const movableItems = items.filter((item) => !item.static && item.i !== activeTileId)
for (const item of activeTile && !activeTile.static ? [activeTile, ...movableItems] : movableItems) {
let collisions = getOccupants(occupancy, item, cols)
while (collisions.length > 0) {
item.y = Math.max(...collisions.map((collision) => collision.y + collision.h))
collisions = getOccupants(occupancy, item, cols)
}
occupy(occupancy, item, cols)
}
return items
}
export function getDashboardTileSpacingGap(tileSpacing?: string): number {
return DASHBOARD_TILE_SPACING_GAPS[tileSpacing as DashboardTileSpacing] ?? DASHBOARD_TILE_SPACING_GAPS.standard
}
export function getDashboardGridCompactor(layoutCompaction?: DashboardGridCompaction): DashboardGridCompactor {
const selectedCompaction = layoutCompaction ?? DashboardGridCompaction.Vertical
const compactor = (() => {
switch (selectedCompaction) {
case DashboardGridCompaction.Horizontal:
return makeRoomInRowCompactor
case DashboardGridCompaction.Stable:
return freePlacementCompactor
default:
return fastVerticalCompactor
}
})()
return {
...compactor,
compactInteraction: (cols, activeTileId, restoredLayout, resizedLayout, isDragging = true): Layout => {
switch (selectedCompaction) {
case DashboardGridCompaction.Stable:
return resolveFreePlacementCollisions(restoredLayout, cols, activeTileId, isDragging)
case DashboardGridCompaction.Vertical:
return compactor.compact(resizedLayout, cols)
default:
return compactor.compact(restoredLayout, cols)
}
},
}
}