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.3 KB
Raw Blame
import { MakeLogicType, actions, beforeUnmount, kea, key, listeners, path, props, reducers, selectors } from 'kea'
import posthog from 'posthog-js'

export type ResizerEvent = {
    desiredSize: number
}

export type ResizerLogicProps = {
    logicKey: string
    persistent?: boolean
    /** Optional prefix for localStorage key - change this to invalidate cached values */
    persistPrefix?: string
    placement: 'left' | 'right' | 'top' | 'bottom'
    containerRef: React.RefObject<HTMLDivElement>
    /** At what size, should this rather be considered a "close" event */
    closeThreshold?: number
    /** Fired when the "closeThreshold" is crossed */
    onToggleClosed?: (closed: boolean) => void
    onDoubleClick?: () => void
    /** The smallest size a drag can set */
    minSize?: number
    /** The largest size a drag can set */
    maxSize?: number
}

function clampSize(size: number, { minSize = 0, maxSize = Infinity }: ResizerLogicProps): number {
    return Math.min(Math.max(size, minSize), maxSize)
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface resizerLogicValues {
    desiredSize: number | null
    isResizeInProgress: boolean
    isStart: boolean
    isVertical: boolean
    resizingSize: number | null
    size: number | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface resizerLogicActions {
    beginResize: (startXOrY: number) => {
        startXOrY: number
    }
    endResize: () => {
        value: true
    }
    resetDesiredSize: () => {
        value: true
    }
    setDesiredSize: (size: number | null) => {
        size: number | null
    }
    setResizingSize: (size: number | null) => {
        size: number | null
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface resizerLogicMeta {
    key: string
    __keaTypeGenInternalSelectorTypes: {
        desiredSize: (size: number | null, resizingSize: number | null, isResizeInProgress: boolean) => number | null
        isVertical: (placement: 'bottom' | 'left' | 'right' | 'top') => boolean
        isStart: (placement: 'bottom' | 'left' | 'right' | 'top') => boolean
    }
}

export type resizerLogicType = MakeLogicType<
    resizerLogicValues,
    resizerLogicActions,
    ResizerLogicProps,
    resizerLogicMeta
>

export const resizerLogic = kea<resizerLogicType>([
    props({} as ResizerLogicProps),
    key((props) => props.logicKey),
    path((key) => ['components', 'resizer', 'resizerLogic', key]),

    actions({
        beginResize: (startXOrY: number) => ({ startXOrY }),
        endResize: true,
        setResizingSize: (size: number | null) => ({ size }),
        setDesiredSize: (size: number | null) => ({ size }),
        resetDesiredSize: true,
    }),
    reducers(({ props }) => ({
        isResizeInProgress: [
            false,
            {
                beginResize: () => true,
                endResize: () => false,
            },
        ],
        size: [
            null as number | null,
            { persist: props.persistent, prefix: props.persistPrefix },
            {
                setDesiredSize: (_, { size }) => (size === null ? null : clampSize(size, props)),
                resetDesiredSize: () => null,
            },
        ],
        resizingSize: [
            null as number | null,
            {
                setResizingSize: (_, { size }) => (size === null ? null : clampSize(size, props)),
                beginResize: () => null,
                endResize: () => null,
            },
        ],
    })),
    selectors({
        desiredSize: [
            (s) => [s.size, s.resizingSize, s.isResizeInProgress],
            (size: number | null, resizingSize: number | null, isResizeInProgress: boolean) => {
                return isResizeInProgress ? (resizingSize ?? size) : size
            },
        ],
        isVertical: [
            (_, p) => [p.placement],
            (placement: 'bottom' | 'left' | 'right' | 'top') => ['left', 'right'].includes(placement),
        ],
        isStart: [
            (_, p) => [p.placement],
            (placement: 'bottom' | 'left' | 'right' | 'top') => ['left', 'top'].includes(placement),
        ],
    }),
    listeners(({ cache, props, actions, values }) => ({
        beginResize: ({ startXOrY }) => {
            if (!props.containerRef.current) {
                return
            }

            let isDoubleClick = cache.firstClickTimestamp && Date.now() - cache.firstClickTimestamp < 500
            cache.firstClickTimestamp = Date.now()

            const originContainerBounds = props.containerRef.current.getBoundingClientRect()
            const originContainerBoundsSize = values.isVertical
                ? originContainerBounds.width
                : originContainerBounds.height

            let isClosed = props.closeThreshold ? originContainerBoundsSize < props.closeThreshold : false

            cache.originXOrY = startXOrY

            const calculateEvent = (e: MouseEvent): ResizerEvent => {
                // desired width is based on the change relative to the original bounds
                // The resizer could be on the left or the right, so we need to account for this
                const eventSize = values.isVertical ? e.pageX : e.pageY
                const difference = eventSize - cache.originXOrY
                const desiredSize = values.isStart
                    ? originContainerBoundsSize - difference
                    : originContainerBoundsSize + difference

                return { desiredSize }
            }

            // We need to add this class to the body to make sure that the cursor is
            // grabbing, and to disable pointer events on all elements except the resizer
            document.body.classList.add('is-resizing')

            let pendingMouseMove: MouseEvent | null = null
            let pendingFrame: number | null = null
            const updateResize = (e: MouseEvent): void => {
                const event = calculateEvent(e)
                actions.setResizingSize(event.desiredSize)

                const newIsClosed = props.closeThreshold ? event.desiredSize < props.closeThreshold : false
                if (newIsClosed !== isClosed) {
                    props.onToggleClosed?.(newIsClosed)
                }
                isClosed = newIsClosed
            }

            // Add dynamic event listeners using disposables
            cache.disposables.add(() => {
                const onMouseMove = (e: MouseEvent): void => {
                    isDoubleClick = false
                    pendingMouseMove = e
                    if (pendingFrame === null) {
                        pendingFrame = requestAnimationFrame(() => {
                            pendingFrame = null
                            if (pendingMouseMove) {
                                updateResize(pendingMouseMove)
                                pendingMouseMove = null
                            }
                        })
                    }
                }
                document.addEventListener('mousemove', onMouseMove)
                return () => {
                    document.removeEventListener('mousemove', onMouseMove)
                    if (pendingFrame !== null) {
                        cancelAnimationFrame(pendingFrame)
                        pendingFrame = null
                    }
                    pendingMouseMove = null
                }
            }, 'dynamicMouseMove')

            cache.disposables.add(() => {
                const onMouseUp = (e: MouseEvent): void => {
                    if (e.button === 0) {
                        if (pendingMouseMove) {
                            updateResize(e)
                        }
                        const event = calculateEvent(e)

                        if (isDoubleClick) {
                            // Double click - reset to original width
                            actions.resetDesiredSize()
                            cache.firstClickTimestamp = null

                            props.onDoubleClick?.()
                        } else if (event.desiredSize !== values.size) {
                            if (!isClosed) {
                                // We only want to persist the value if it is open
                                actions.setDesiredSize(event.desiredSize)
                            }

                            posthog.capture('element resized', {
                                key: props.logicKey,
                                newWidth: event.desiredSize,
                                originalWidth: originContainerBounds.width,
                                isClosed,
                            })
                        }

                        actions.endResize()
                    }
                }
                document.addEventListener('mouseup', onMouseUp)
                return () => document.removeEventListener('mouseup', onMouseUp)
            }, 'dynamicMouseUp')
        },

        endResize: () => {
            // Remove the dynamic listeners we added
            cache.disposables.dispose('dynamicMouseMove')
            cache.disposables.dispose('dynamicMouseUp')

            document.body.classList.remove('is-resizing')
        },
    })),
    // Clear the body resizing state if we unmount mid-drag (before mouseup fires endResize).
    beforeUnmount(() => {
        document.body.classList.remove('is-resizing')
    }),
])