Skip to content

: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.

9.9 KB
Raw Blame
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)
            }
        },
    }
}