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.

69.6 KB
Raw Blame
import {
    MakeLogicType,
    actions,
    afterMount,
    connect,
    kea,
    key,
    listeners,
    path,
    props,
    propsChanged,
    reducers,
    selectors,
} from 'kea'
import { loaders } from 'kea-loaders'
import { subscriptions } from 'kea-subscriptions'
import posthog from 'posthog-js'

import { IconPlus } from '@posthog/icons'
import { Spinner } from '@posthog/lemon-ui'

import api from 'lib/api'
import { LemonTreeSelectMode, TreeDataItem } from 'lib/lemon-ui/LemonTree/LemonTree'
import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { getEntryAccessDisabledReason } from 'lib/utils/accessControlUtils'

import { breadcrumbsLogic } from '~/layout/navigation/Breadcrumbs/breadcrumbsLogic'
import { PAGINATION_LIMIT, projectTreeDataLogic } from '~/layout/panel-layout/ProjectTree/projectTreeDataLogic'
import { FileSystemEntry } from '~/queries/schema/schema-general'
import { ProjectTreeRef } from '~/types'

import type { FeatureFlagsSet } from '../../../lib/logic/featureFlagLogic'
import type { Breadcrumb, UserBasicType } from '../../../types'
import { panelLayoutLogic } from '../panelLayoutLogic'
import type { PanelLayoutNavIdentifier } from '../panelLayoutLogic'
import type { FolderState, ProjectTreeAction } from './types'
import {
    calculateMovePath,
    convertFileSystemEntryToTreeDataItem,
    findInProjectTree,
    formatUrlAsName,
    isFileSystemEntryTypeEnabled,
    joinPath,
    matchesRefType,
    sortFilesAndFolders,
    splitPath,
    splitProtocolPath,
} from './utils'

export const PROJECT_TREE_KEY = 'project-tree'

export type ProjectTreeSortMethod = 'folder' | 'recent'

export interface RecentResults {
    results: FileSystemEntry[]
    startTime: string | null
    endTime: string | null
    hasMore: boolean
}

export interface SearchResults {
    searchTerm: string
    results: FileSystemEntry[]
    hasMore: boolean
    lastCount: number
}

export interface ProjectTreeLogicProps {
    key: string
    defaultSortMethod?: ProjectTreeSortMethod
    defaultOnlyFolders?: boolean
    root?: string
    includeRoot?: boolean
    hideFolders?: string[]
    isActiveInPanel?: boolean
    shortcutScope?: 'products' | 'files'
}

const FOLDER_LOADING = [
    {
        id: `folder-loading/`,
        name: 'Loading...',
        icon: <Spinner />,
        type: 'loading-indicator',
    } as TreeDataItem,
]

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface projectTreeLogicValues {
    appBreadcrumbs: Breadcrumb[] // breadcrumbsLogic
    projectTreeRef: ProjectTreeRef | null // breadcrumbsLogic
    sceneBreadcrumbs: Breadcrumb[] // breadcrumbsLogic
    featureFlags: FeatureFlagsSet // featureFlagLogic
    activePanelIdentifier: string // panelLayoutLogic
    folderLoadOffset: Record<string, number> // projectTreeDataLogic
    folderStates: Record<string, FolderState> // projectTreeDataLogic
    folders: Record<string, FileSystemEntry[]> // projectTreeDataLogic
    getStaticTreeItems: (searchTerm: string, onlyFolders: boolean) => TreeDataItem[] // projectTreeDataLogic
    lastNewFolder: string | null // projectTreeDataLogic
    loadingPaths: Record<string, boolean> // projectTreeDataLogic
    shortcutData: FileSystemEntry[] // projectTreeDataLogic
    sortedItems: FileSystemEntry[] // projectTreeDataLogic
    unfiledItems: boolean // projectTreeDataLogic
    unfiledItemsLoading: boolean // projectTreeDataLogic
    users: Record<string, UserBasicType> // projectTreeDataLogic
    viableItems: FileSystemEntry[] // projectTreeDataLogic
    viableItemsById: Record<string, FileSystemEntry> // projectTreeDataLogic
    checkedItemCountNumeric: number
    checkedItems: Record<string, boolean>
    checkedItemsArray: FileSystemEntry[]
    checkedItemsCount: string
    editingItemId: string
    expandedFolders: string[]
    expandedSearchFolders: string[]
    fullFileSystem: TreeDataItem[]
    fullFileSystemFiltered: TreeDataItem[]
    helpNoticeVisible: boolean
    lastCheckedItem: {
        checked: boolean
        id: string
        shift: boolean
    } | null
    lastViewedId: string
    onlyFolders: boolean
    projectTree: TreeDataItem[]
    projectTreeItems: TreeDataItem[]
    recentResults: RecentResults
    recentResultsLoading: boolean
    recentTreeItems: TreeDataItem[]
    scrollTargetId: string
    searchFilters: {
        fileType: string | null
        onlyMine: boolean
    }
    searchResults: SearchResults
    searchResultsLoading: boolean
    searchTerm: string
    searchTreeItems: TreeDataItem[]
    selectMode: LemonTreeSelectMode
    sortMethod: ProjectTreeSortMethod
    treeTableColumnOffsets: number[]
    treeTableColumnSizes: number[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface projectTreeLogicActions {
    resetPanelLayout: (keyboardAction: boolean) => {
        keyboardAction: boolean
    } // panelLayoutLogic
    setActivePanelIdentifier: (identifier: PanelLayoutNavIdentifier) => {
        identifier: PanelLayoutNavIdentifier
    } // panelLayoutLogic
    addLoadedResults: (results: RecentResults | SearchResults) => {
        results: RecentResults | SearchResults
    } // projectTreeDataLogic
    addLoadedUsers: (users: UserBasicType[]) => {
        users: UserBasicType[]
    } // projectTreeDataLogic
    createSavedItem: (savedItem: FileSystemEntry) => {
        savedItem: FileSystemEntry
    } // projectTreeDataLogic
    deleteItem: (
        item: FileSystemEntry,
        projectTreeLogicKey: string
    ) => {
        item: FileSystemEntry
        projectTreeLogicKey: string
    } // projectTreeDataLogic
    deleteSavedItem: (savedItem: FileSystemEntry) => {
        savedItem: FileSystemEntry
    } // projectTreeDataLogic
    deleteTypeAndRef: (
        type: string,
        ref: string
    ) => {
        ref: string
        type: string
    } // projectTreeDataLogic
    linkItem: (
        oldPath: string,
        newPath: string,
        force: boolean,
        projectTreeLogicKey: string
    ) => {
        force: boolean
        newPath: string
        oldPath: string
        projectTreeLogicKey: string
    } // projectTreeDataLogic
    loadFolder: (
        folder: string,
        forceReload?: boolean | undefined
    ) => {
        folder: string
        forceReload: boolean
    } // projectTreeDataLogic
    loadFolderIfNotLoaded: (folderId: string) => {
        folderId: string
    } // projectTreeDataLogic
    loadFolderStart: (
        folder: string,
        forceReload?: boolean | undefined
    ) => {
        folder: string
        forceReload: boolean
    } // projectTreeDataLogic
    loadFolderSuccess: (
        folder: string,
        entries: FileSystemEntry[],
        hasMore: boolean,
        offsetIncrease: number,
        forceReload?: boolean | undefined
    ) => {
        entries: FileSystemEntry[]
        folder: string
        forceReload: boolean
        hasMore: boolean
        offsetIncrease: number
    } // projectTreeDataLogic
    loadUnfiledItems: () => {
        value: true
    } // projectTreeDataLogic
    moveItem: (
        item: FileSystemEntry,
        newPath: string,
        force: boolean,
        projectTreeLogicKey: string
    ) => {
        force: boolean
        item: FileSystemEntry
        newPath: string
        projectTreeLogicKey: string
    } // projectTreeDataLogic
    moveItems: (
        moves: {
            item: FileSystemEntry
            newPath: string
        }[],
        force: boolean,
        projectTreeLogicKey: string
    ) => {
        force: boolean
        moves: {
            item: FileSystemEntry
            newPath: string
        }[]
        projectTreeLogicKey: string
    } // projectTreeDataLogic
    movedItem: (
        item: FileSystemEntry,
        oldPath: string,
        newPath: string
    ) => {
        item: FileSystemEntry
        newPath: string
        oldPath: string
    } // projectTreeDataLogic
    pruneClosedFolders: (expandedFolders: string[]) => {
        expandedFolders: string[]
    } // projectTreeDataLogic
    queueAction: (
        action: ProjectTreeAction,
        projectTreeLogicKey: string
    ) => {
        action: ProjectTreeAction
        projectTreeLogicKey: string
    } // projectTreeDataLogic
    addFolder: (
        folder: string,
        editAfter?: any,
        callback?: (folder: string) => void
    ) => {
        callback: ((folder: string) => void) | undefined
        editAfter: any
        folder: string
    }
    assureVisibility: (
        projectTreeRef: ProjectTreeRef,
        expandIfHidden?: boolean
    ) => {
        expandIfHidden: boolean
        projectTreeRef: ProjectTreeRef
    }
    checkSelectedFolders: () => {
        value: true
    }
    clearScrollTarget: () => {
        value: true
    }
    clearSearch: () => {
        value: true
    }
    createFolder: (
        parentPath: string,
        editAfter?: any,
        callback?: (folder: string) => void
    ) => {
        callback: ((folder: string) => void) | undefined
        editAfter: any
        parentPath: string
    }
    deleteCheckedItems: () => {
        value: true
    }
    expandProjectFolder: (path: string) => {
        path: string
    }
    linkCheckedItems: (path: string) => {
        path: string
    }
    loadRecentResults: (type: 'end' | 'start') => {
        type: 'end' | 'start'
    }
    loadRecentResultsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadRecentResultsSuccess: (
        recentResults: {
            endTime: string | null
            hasMore: boolean
            results: FileSystemEntry[]
            startTime: string | null
        },
        payload?: {
            type: 'end' | 'start'
        }
    ) => {
        recentResults: {
            endTime: string | null
            hasMore: boolean
            results: FileSystemEntry[]
            startTime: string | null
        }
        payload?: {
            type: 'end' | 'start'
        }
    }
    loadSearchResults: (
        searchTerm: string,
        offset?: any
    ) => {
        offset: any
        searchTerm: string
    }
    loadSearchResultsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadSearchResultsSuccess: (
        searchResults: {
            hasMore: boolean
            lastCount: number
            results: FileSystemEntry[]
            searchTerm: string
        },
        payload?: {
            offset: any
            searchTerm: string
        }
    ) => {
        searchResults: {
            hasMore: boolean
            lastCount: number
            results: FileSystemEntry[]
            searchTerm: string
        }
        payload?: {
            offset: any
            searchTerm: string
        }
    }
    moveCheckedItems: (path: string) => {
        path: string
    }
    onItemChecked: (
        id: string,
        checked: boolean,
        shift: boolean
    ) => {
        checked: boolean
        id: string
        shift: boolean
    }
    rename: (
        value: string,
        item: FileSystemEntry
    ) => {
        item: FileSystemEntry
        value: string
    }
    scrollToView: (item: FileSystemEntry) => {
        item: FileSystemEntry
    }
    setCheckedItems: (checkedItems: Record<string, boolean>) => {
        checkedItems: Record<string, boolean>
    }
    setEditingItemId: (id: string) => {
        id: string
    }
    setExpandedFolders: (folderIds: string[]) => {
        folderIds: string[]
    }
    setExpandedSearchFolders: (folderIds: string[]) => {
        folderIds: string[]
    }
    setHelpNoticeVisibility: (visible: boolean) => {
        visible: boolean
    }
    setLastCheckedItem: (
        id: string,
        checked: boolean,
        shift: boolean
    ) => {
        checked: boolean
        id: string
        shift: boolean
    }
    setLastViewedId: (id: string) => {
        id: string
    }
    setOnlyFolders: (onlyFolders: boolean) => {
        onlyFolders: boolean
    }
    setSearchTerm: (searchTerm: string) => {
        searchTerm: string
    }
    setSelectMode: (selectMode: LemonTreeSelectMode) => {
        selectMode: LemonTreeSelectMode
    }
    setSortMethod: (sortMethod: ProjectTreeSortMethod) => {
        sortMethod: ProjectTreeSortMethod
    }
    setTreeTableColumnSizes: (sizes: number[]) => {
        sizes: number[]
    }
    toggleFileTypeFilter: (fileType: string) => {
        fileType: string
    }
    toggleFolderOpen: (
        folderId: string,
        isExpanded: boolean
    ) => {
        folderId: string
        isExpanded: boolean
    }
    toggleOnlyMyStuff: () => {
        value: true
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface projectTreeLogicMeta {
    key: string
    __keaTypeGenInternalSelectorTypes: {
        searchFilters: (searchTerm: string) => {
            fileType: string | null
            onlyMine: boolean
        }
        projectTree: (
            viableItems: FileSystemEntry[],
            folderStates: Record<string, FolderState>,
            checkedItems: Record<string, boolean>,
            users: Record<string, UserBasicType>,
            onlyFolders: boolean
        ) => TreeDataItem[]
        recentTreeItems: (
            recentResults: RecentResults,
            recentResultsLoading: boolean,
            folderStates: Record<string, FolderState>,
            checkedItems: Record<string, boolean>,
            users: Record<string, UserBasicType>,
            featureFlags: FeatureFlagsSet
        ) => TreeDataItem[]
        searchTreeItems: (
            searchResults: SearchResults,
            searchResultsLoading: boolean,
            folderStates: Record<string, FolderState>,
            checkedItems: Record<string, boolean>,
            sortMethod: ProjectTreeSortMethod,
            onlyFolders: boolean,
            users: Record<string, UserBasicType>,
            featureFlags: FeatureFlagsSet
        ) => TreeDataItem[]
        projectTreeItems: (
            searchTerm: string,
            searchTreeItems: TreeDataItem[],
            projectTree: TreeDataItem[],
            loadingPaths: Record<string, boolean>,
            recentTreeItems: TreeDataItem[],
            sortMethod: ProjectTreeSortMethod
        ) => TreeDataItem[]
        fullFileSystem: (
            searchTerm: string,
            searchTreeItems: TreeDataItem[],
            searchResultsLoading: boolean,
            projectTree: TreeDataItem[],
            loadingPaths: Record<string, boolean>,
            recentTreeItems: TreeDataItem[],
            recentResultsLoading: boolean,
            sortMethod: ProjectTreeSortMethod,
            onlyFolders: boolean,
            getStaticTreeItems: (searchTerm: string, onlyFolders: boolean) => TreeDataItem[] // projectTreeDataLogic
        ) => TreeDataItem[]
        fullFileSystemFiltered: (
            fullFileSystem: TreeDataItem[],
            searchTerm: string,
            arg: any,
            arg2: any,
            arg3: any,
            arg4: any
        ) => TreeDataItem[]
        treeTableColumnOffsets: (treeTableColumnSizes: number[]) => number[]
        checkedItemCountNumeric: (checkedItems: Record<string, boolean>) => number
        checkedItemsCount: (
            checkedItems: Record<string, boolean>,
            viableItemsById: Record<string, FileSystemEntry>
        ) => string
        checkedItemsArray: (
            checkedItems: Record<string, boolean>,
            viableItemsById: Record<string, FileSystemEntry>
        ) => FileSystemEntry[]
    }
}

export type projectTreeLogicType = MakeLogicType<
    projectTreeLogicValues,
    projectTreeLogicActions,
    ProjectTreeLogicProps,
    projectTreeLogicMeta
>

const isProjectTreeActive = (
    props: ProjectTreeLogicProps,
    values: Pick<projectTreeLogicValues, 'activePanelIdentifier'>
): boolean =>
    props.key === PROJECT_TREE_KEY ? values.activePanelIdentifier === 'Project' : props.isActiveInPanel !== false

const shouldLoadUnfiledItems = (
    props: ProjectTreeLogicProps,
    values: Pick<projectTreeLogicValues, 'unfiledItems' | 'unfiledItemsLoading'>
): boolean =>
    props.root?.startsWith('project://') === true &&
    props.isActiveInPanel !== false &&
    !values.unfiledItems &&
    !values.unfiledItemsLoading

export const projectTreeLogic = kea<projectTreeLogicType>([
    path(['layout', 'navigation-3000', 'components', 'projectTreeLogic']),
    props({} as ProjectTreeLogicProps),
    key((props) => props.key),
    connect(() => ({
        values: [
            panelLayoutLogic,
            ['activePanelIdentifier'],
            breadcrumbsLogic,
            ['projectTreeRef', 'appBreadcrumbs', 'sceneBreadcrumbs'],
            featureFlagLogic,
            ['featureFlags'],
            projectTreeDataLogic,
            [
                'folders',
                'folderStates',
                'folderLoadOffset',
                'users',
                'viableItems',
                'viableItemsById',
                'sortedItems',
                'loadingPaths',
                'lastNewFolder',
                'getStaticTreeItems',
                'shortcutData',
                'unfiledItems',
                'unfiledItemsLoading',
            ],
        ],
        actions: [
            panelLayoutLogic,
            ['setActivePanelIdentifier', 'resetPanelLayout'],
            projectTreeDataLogic,
            [
                'loadFolder',
                'loadFolderIfNotLoaded',
                'loadFolderStart',
                'loadFolderSuccess',
                'addLoadedUsers',
                'addLoadedResults',
                'createSavedItem',
                'deleteSavedItem',
                'deleteTypeAndRef',
                'movedItem',
                'queueAction',
                'deleteItem',
                'moveItem',
                'moveItems',
                'linkItem',
                'pruneClosedFolders',
                'loadUnfiledItems',
            ],
        ],
    })),
    actions({
        addFolder: (folder: string, editAfter = true, callback?: (folder: string) => void) => ({
            folder,
            editAfter,
            callback,
        }),
        setExpandedFolders: (folderIds: string[]) => ({ folderIds }),
        setExpandedSearchFolders: (folderIds: string[]) => ({ folderIds }),
        setLastViewedId: (id: string) => ({ id }),
        toggleFolderOpen: (folderId: string, isExpanded: boolean) => ({ folderId, isExpanded }),
        setHelpNoticeVisibility: (visible: boolean) => ({ visible }),
        rename: (value: string, item: FileSystemEntry) => ({ value, item }),
        createFolder: (parentPath: string, editAfter = true, callback?: (folder: string) => void) => ({
            parentPath,
            editAfter,
            callback,
        }),
        setSearchTerm: (searchTerm: string) => ({ searchTerm }),
        toggleOnlyMyStuff: true,
        toggleFileTypeFilter: (fileType: string) => ({ fileType }),
        clearSearch: true,
        loadSearchResults: (searchTerm: string, offset = 0) => ({ searchTerm, offset }),
        loadRecentResults: (type: 'start' | 'end') => ({ type }),
        assureVisibility: (projectTreeRef: ProjectTreeRef, expandIfHidden: boolean = true) => ({
            projectTreeRef,
            expandIfHidden,
        }),
        onItemChecked: (id: string, checked: boolean, shift: boolean) => ({ id, checked, shift }),
        setLastCheckedItem: (id: string, checked: boolean, shift: boolean) => ({ id, checked, shift }),
        setCheckedItems: (checkedItems: Record<string, boolean>) => ({ checkedItems }),
        expandProjectFolder: (path: string) => ({ path }),
        moveCheckedItems: (path: string) => ({ path }),
        linkCheckedItems: (path: string) => ({ path }),
        deleteCheckedItems: true,
        checkSelectedFolders: true,
        scrollToView: (item: FileSystemEntry) => ({ item }),
        clearScrollTarget: true,
        setEditingItemId: (id: string) => ({ id }),
        setSortMethod: (sortMethod: ProjectTreeSortMethod) => ({ sortMethod }),
        setOnlyFolders: (onlyFolders: boolean) => ({ onlyFolders }),
        setSelectMode: (selectMode: LemonTreeSelectMode) => ({ selectMode }),
        setTreeTableColumnSizes: (sizes: number[]) => ({ sizes }),
    }),
    loaders(({ actions, values }) => ({
        searchResults: [
            { searchTerm: '', results: [], hasMore: false, lastCount: 0 } as SearchResults,
            {
                loadSearchResults: async ({ searchTerm, offset }, breakpoint) => {
                    await breakpoint(250)
                    const response = await api.fileSystem.list({
                        search: searchTerm,
                        offset,
                        limit: PAGINATION_LIMIT + 1,
                        orderBy: values.sortMethod === 'recent' ? '-created_at' : undefined,
                        notType: values.sortMethod === 'recent' ? 'folder' : undefined,
                    })
                    breakpoint()
                    const results = [
                        ...(offset > 0 && searchTerm === values.searchResults.searchTerm
                            ? values.searchResults.results
                            : []),
                        ...response.results.slice(0, PAGINATION_LIMIT),
                    ]
                    if (response.users?.length > 0) {
                        actions.addLoadedUsers(response.users)
                    }
                    actions.addLoadedResults(response as any as SearchResults)
                    return {
                        searchTerm,
                        results: values.sortMethod === 'recent' ? results : results.sort(sortFilesAndFolders),
                        hasMore: response.results.length > PAGINATION_LIMIT,
                        lastCount: Math.min(response.results.length, PAGINATION_LIMIT),
                    }
                },
            },
        ],
        recentResults: [
            { results: [], hasMore: false, startTime: null, endTime: null } as RecentResults,
            {
                loadRecentResults: async ({ type }, breakpoint) => {
                    await breakpoint(250)
                    const params = {
                        orderBy: '-created_at',
                        notType: 'folder',
                        limit: PAGINATION_LIMIT + 1,
                        createdAtGt:
                            type === 'start' && values.recentResults.startTime
                                ? values.recentResults.startTime
                                : undefined,
                        createdAtLt:
                            type === 'end' && values.recentResults.endTime ? values.recentResults.endTime : undefined,
                    }
                    const response = await api.fileSystem.list(params)
                    const returnedResults = response.results.slice(0, PAGINATION_LIMIT)
                    const hasMore = response.results.length > PAGINATION_LIMIT
                    breakpoint()
                    const seenIds = new Set()
                    const results = [...values.recentResults.results, ...returnedResults]
                        .filter((item) => {
                            if (seenIds.has(item.id)) {
                                return false
                            }
                            seenIds.add(item.id)
                            return true
                        })
                        .sort((a, b) => {
                            return new Date(b.created_at ?? '').getTime() - new Date(a.created_at ?? '').getTime()
                        })
                    if (response.users?.length > 0) {
                        actions.addLoadedUsers(response.users)
                    }
                    actions.addLoadedResults(response as any as RecentResults)
                    return {
                        results,
                        hasMore,
                        startTime: response.results[0]?.created_at ?? null,
                        endTime: response.results[response.results.length - 1]?.created_at ?? null,
                    }
                },
            },
        ],
    })),
    reducers(({ props }) => ({
        searchTerm: [
            '',
            {
                setSearchTerm: (_, { searchTerm }) => searchTerm,
                clearSearch: () => '',
            },
        ],
        searchResults: [
            { searchTerm: '', results: [], hasMore: false, lastCount: 0 } as SearchResults,
            {
                clearSearch: () => ({ searchTerm: '', results: [], hasMore: false, lastCount: 0 }),
                movedItem: (state, { newPath, item }) => {
                    if (state.searchTerm && state.results.length > 0) {
                        const newResults = state.results.map((result) => {
                            if (result.id === item.id) {
                                return { ...item, path: newPath }
                            }
                            return result
                        })
                        return { ...state, results: newResults }
                    }
                    return state
                },
                deleteSavedItem: (state, { savedItem }) => {
                    if (state.searchTerm && state.results.length > 0) {
                        const newResults = state.results.filter((result) => result.id !== savedItem.id)
                        return { ...state, results: newResults }
                    }
                    return state
                },
                deleteTypeAndRef: (state, { type, ref }) => {
                    return {
                        ...state,
                        results: state.results.filter((file) => !matchesRefType(file.type, type) || file.ref !== ref),
                    }
                },
                addLoadedResults: (state, { results }) => {
                    const newIdsSet = new Set(results.results.map((file) => file.id))
                    const hasAnyNewIds = state.results.some((file) => newIdsSet.has(file.id))
                    if (hasAnyNewIds) {
                        const newResults = state.results.map((result) => {
                            if (newIdsSet.has(result.id)) {
                                const file = results.results.find((file) => file.id === result.id)
                                return { ...result, ...file }
                            }
                            return result
                        })
                        return { ...state, results: newResults }
                    }
                    return state
                },
            },
        ],
        recentResults: [
            { results: [], hasMore: false, startTime: null, endTime: null } as RecentResults,
            {
                clearSearch: () => ({ results: [], hasMore: false, startTime: null, endTime: null }),
                movedItem: (state, { newPath, item }) => {
                    if (state.results.length > 0) {
                        const newResults = state.results.map((result) => {
                            if (result.id === item.id) {
                                return { ...item, path: newPath }
                            }
                            return result
                        })
                        return { ...state, results: newResults }
                    }
                    return state
                },
                deleteSavedItem: (state, { savedItem }) => {
                    if (state.results.length > 0) {
                        const newResults = state.results.filter((result) => result.id !== savedItem.id)
                        return { ...state, results: newResults }
                    }
                    return state
                },
                deleteTypeAndRef: (state, { type, ref }) => {
                    return {
                        ...state,
                        results: state.results.filter((file) => !matchesRefType(file.type, type) || file.ref !== ref),
                    }
                },
                createSavedItem: (state, { savedItem }) => {
                    if (state.results.find((result) => result.id === savedItem.id)) {
                        return {
                            ...state,
                            results: state.results.map((result) => (result.id === savedItem.id ? savedItem : result)),
                        }
                    } else if (savedItem.created_at && savedItem.type !== 'folder') {
                        const newResults = [...state.results, savedItem].sort((a, b) => {
                            return new Date(b.created_at ?? '').getTime() - new Date(a.created_at ?? '').getTime()
                        })
                        return { ...state, results: newResults }
                    }
                    return state
                },
                addLoadedResults: (state, { results }) => {
                    const newIdsSet = new Set(results.results.map((file) => file.id))
                    const hasAnyNewIds = state.results.some((file) => newIdsSet.has(file.id))
                    if (hasAnyNewIds) {
                        const newResults = state.results.map((result) => {
                            if (newIdsSet.has(result.id)) {
                                const file = results.results.find((file) => file.id === result.id)
                                return { ...result, ...file }
                            }
                            return result
                        })
                        return { ...state, results: newResults }
                    }
                    return state
                },
            },
        ],
        expandedFolders: [
            [props.root] as string[],
            {
                setExpandedFolders: (_, { folderIds }) => folderIds,
            },
        ],
        expandedSearchFolders: [
            ['/', 'project://', 'project://Unfiled'] as string[],
            {
                setExpandedSearchFolders: (_, { folderIds }) => folderIds,
                loadSearchResultsSuccess: (state, { searchResults: { results, lastCount } }) => {
                    const folders: Record<string, boolean> = state.reduce(
                        (acc: Record<string, boolean>, folderId) => {
                            acc[folderId] = true
                            return acc
                        },
                        { 'project://Unfiled': true }
                    )

                    for (const entry of results.slice(-lastCount)) {
                        const splits = splitPath(entry.path)
                        for (let i = 1; i < splits.length; i++) {
                            folders['project://' + joinPath(splits.slice(0, i))] = true
                        }
                    }
                    return Object.keys(folders)
                },
            },
        ],
        lastViewedId: [
            '',
            {
                setLastViewedId: (_, { id }) => id,
            },
        ],
        helpNoticeVisible: [
            true,
            {
                setHelpNoticeVisibility: (_, { visible }) => visible,
            },
        ],
        checkedItems: [
            {} as Record<string, boolean>,
            {
                setCheckedItems: (_, { checkedItems }) => checkedItems,
            },
        ],
        lastCheckedItem: [
            null as { id: string; checked: boolean; shift: boolean } | null,
            {
                setLastCheckedItem: (_, { id, checked, shift }) => ({ id, checked, shift }),
            },
        ],
        scrollTargetId: [
            '' as string,
            {
                scrollToView: (_, { item }) =>
                    item.type === 'folder' ? `project://${item.path}` : `project/${item.id}`,
                clearScrollTarget: () => '',
            },
        ],
        editingItemId: [
            '',
            {
                setEditingItemId: (_, { id }) => id,
            },
        ],
        sortMethod: [
            'folder' as ProjectTreeSortMethod,
            {
                setSortMethod: (_, { sortMethod }) => sortMethod,
            },
        ],
        onlyFolders: [
            false as boolean,
            {
                setOnlyFolders: (_, { onlyFolders }) => onlyFolders,
            },
        ],
        selectMode: [
            'default' as LemonTreeSelectMode,
            {
                setSelectMode: (_, { selectMode }) => selectMode,
            },
        ],
        treeTableColumnSizes: [
            [350, 200, 200, 200] as number[],
            { persist: true },
            {
                setTreeTableColumnSizes: (_, { sizes }) => sizes,
            },
        ],
    })),
    selectors({
        searchFilters: [
            (s) => [s.searchTerm],
            (searchTerm: string): { onlyMine: boolean; fileType: string | null } => {
                const tags = searchTerm.split(' ')
                return {
                    onlyMine: tags.includes('user:me'),
                    fileType: tags.find((tag) => tag.startsWith('type:'))?.slice(5) ?? null,
                }
            },
        ],
        projectTree: [
            (s) => [s.viableItems, s.folderStates, s.checkedItems, s.users, s.onlyFolders],
            (
                viableItems: FileSystemEntry[],
                folderStates: Record<string, import('./types').FolderState>,
                checkedItems: Record<string, boolean>,
                users: Record<string, import('~/types').UserBasicType>,
                onlyFolders: boolean
            ): TreeDataItem[] => {
                const children = convertFileSystemEntryToTreeDataItem({
                    imports: viableItems.map((i) => ({ ...i, protocol: 'project://' })),
                    folderStates,
                    checkedItems,
                    root: 'project://',
                    users,
                    disabledReason: (item) =>
                        getEntryAccessDisabledReason(item) ??
                        (onlyFolders && item.type !== 'folder' ? 'Only folders can be selected' : undefined),
                })
                return children
            },
        ],
        recentTreeItems: [
            (s) => [s.recentResults, s.recentResultsLoading, s.folderStates, s.checkedItems, s.users, s.featureFlags],
            (
                recentResults: RecentResults,
                recentResultsLoading: boolean,
                folderStates: Record<string, import('./types').FolderState>,
                checkedItems: Record<string, boolean>,
                users: Record<string, import('~/types').UserBasicType>,
                featureFlags: Record<string, unknown>
            ): TreeDataItem[] => {
                const results = convertFileSystemEntryToTreeDataItem({
                    imports: recentResults.results
                        .filter((entry) => isFileSystemEntryTypeEnabled(entry, featureFlags))
                        .map((i) => ({ ...i, protocol: 'project://' })),
                    folderStates,
                    checkedItems,
                    root: 'project://',
                    disableFolderSelect: true,
                    recent: true,
                    users,
                    disabledReason: (item) => getEntryAccessDisabledReason(item),
                })
                if (recentResultsLoading) {
                    results.push({
                        id: `recent-loading/`,
                        name: 'Loading...',
                        displayName: <>Loading...</>,
                        icon: <Spinner />,
                        disableSelect: true,
                        type: 'loading-indicator',
                    })
                } else if (recentResults.hasMore) {
                    results.push({
                        id: `recent-load-more/`,
                        name: 'Load more...',
                        displayName: <>Load more...</>,
                        icon: <IconPlus />,
                        disableSelect: true,
                        onClick: () => projectTreeLogic.actions.loadRecentResults('end'),
                    })
                }
                return results
            },
        ],
        searchTreeItems: [
            (s) => [
                s.searchResults,
                s.searchResultsLoading,
                s.folderStates,
                s.checkedItems,
                s.sortMethod,
                s.onlyFolders,
                s.users,
                s.featureFlags,
            ],
            (
                searchResults: SearchResults,
                searchResultsLoading: boolean,
                folderStates: Record<string, import('./types').FolderState>,
                checkedItems: Record<string, boolean>,
                sortMethod: ProjectTreeSortMethod,
                onlyFolders: boolean,
                users: Record<string, import('~/types').UserBasicType>,
                featureFlags: Record<string, unknown>
            ): TreeDataItem[] => {
                const results = convertFileSystemEntryToTreeDataItem({
                    imports: searchResults.results
                        .filter((entry) => isFileSystemEntryTypeEnabled(entry, featureFlags))
                        .map((i) => ({ ...i, protocol: 'project://' })),
                    folderStates,
                    checkedItems,
                    root: 'project://',
                    searchTerm: searchResults.searchTerm,
                    disableFolderSelect: true,
                    recent: sortMethod === 'recent',
                    users,
                    disabledReason: (item) =>
                        getEntryAccessDisabledReason(item) ??
                        (onlyFolders && item.type !== 'folder' ? 'Only folders can be selected' : undefined),
                })
                if (searchResultsLoading) {
                    results.push({
                        id: `search-loading/`,
                        name: 'Loading...',
                        displayName: <>Loading...</>,
                        icon: <Spinner />,
                        disableSelect: true,
                        type: 'loading-indicator',
                    })
                } else if (searchResults.hasMore) {
                    results.push({
                        id: `search-load-more/${searchResults.searchTerm}`,
                        name: 'Load more...',
                        displayName: <>Load more...</>,
                        icon: <IconPlus />,
                        disableSelect: true,
                        onClick: () =>
                            projectTreeLogic.actions.loadSearchResults(
                                searchResults.searchTerm,
                                searchResults.results.length
                            ),
                    })
                }
                return results
            },
        ],
        projectTreeItems: [
            (s) => [s.searchTerm, s.searchTreeItems, s.projectTree, s.loadingPaths, s.recentTreeItems, s.sortMethod],
            (
                searchTerm: string,
                searchTreeItems: TreeDataItem[],
                projectTree: TreeDataItem[],
                loadingPaths: Record<string, boolean>,
                recentTreeItems: TreeDataItem[],
                sortMethod: ProjectTreeSortMethod
            ): TreeDataItem[] => {
                if (searchTerm) {
                    return searchTreeItems
                }
                if (sortMethod === 'recent') {
                    return recentTreeItems
                }
                if (loadingPaths[''] && projectTree.length === 0) {
                    return FOLDER_LOADING
                }

                return projectTree
            },
        ],
        fullFileSystem: [
            (s) => [
                s.searchTerm,
                s.searchTreeItems,
                s.searchResultsLoading,
                s.projectTree,
                s.loadingPaths,
                s.recentTreeItems,
                s.recentResultsLoading,
                s.sortMethod,
                s.onlyFolders,
                s.getStaticTreeItems,
            ],
            (
                searchTerm: string,
                searchTreeItems: TreeDataItem[],
                searchResultsLoading: boolean,
                projectTree: TreeDataItem[],
                loadingPaths: Record<string, boolean>,
                recentTreeItems: TreeDataItem[],
                recentResultsLoading: boolean,
                sortMethod: ProjectTreeSortMethod,
                onlyFolders: boolean,
                getStaticTreeItems: (searchTerm: string, onlyFolders: boolean) => TreeDataItem[]
            ): TreeDataItem[] => {
                const rootItems: TreeDataItem[] = [
                    {
                        id: 'project://',
                        name: 'project://',
                        displayName: <>Project</>,
                        record: { type: 'folder', protocol: 'project://', path: '' },
                        children: searchTerm
                            ? searchResultsLoading && searchTreeItems.length === 0
                                ? FOLDER_LOADING
                                : searchTreeItems
                            : sortMethod === 'recent'
                              ? recentResultsLoading && recentTreeItems.length === 0
                                  ? FOLDER_LOADING
                                  : recentTreeItems
                              : loadingPaths[''] && projectTree.length === 0
                                ? FOLDER_LOADING
                                : projectTree,
                    } as TreeDataItem,
                    ...getStaticTreeItems(searchTerm, onlyFolders),
                ]
                return rootItems
            },
        ],
        fullFileSystemFiltered: [
            (s) => [
                s.fullFileSystem,
                s.searchTerm,
                (_, props) => props.root,
                (_, props) => props.includeRoot,
                (_, props) => props.hideFolders,
                (_, props) => props.shortcutScope,
            ],
            (
                fullFileSystem: TreeDataItem[],
                searchTerm: string,
                root,
                includeRoot,
                hideFolders,
                shortcutScope: ProjectTreeLogicProps['shortcutScope']
            ): TreeDataItem[] => {
                let firstFolders = fullFileSystem

                // Filter out folders specified in hideFolders prop
                if (hideFolders && hideFolders.length > 0) {
                    firstFolders = firstFolders.filter((item) => !hideFolders.includes(item.id))
                }

                const rootFolders = root ? splitPath(root) : []
                const rootWithProtocol =
                    rootFolders.length > 0 && rootFolders[0].endsWith(':') && root.startsWith(`${rootFolders[0]}//`)

                if (rootWithProtocol) {
                    const protocol = rootFolders[0] + '//'
                    const ref = joinPath(rootFolders.slice(1))
                    const firstFolder = fullFileSystem.find((item) => item.id === protocol)
                    if (firstFolder) {
                        if (ref) {
                            const found = findInProjectTree(`${protocol}${ref}`, firstFolder.children ?? [])
                            firstFolders = found?.children ?? []
                        } else {
                            firstFolders = firstFolder.children ?? []
                        }
                    } else {
                        firstFolders = []
                    }
                }

                if (root === 'shortcuts://' && shortcutScope) {
                    firstFolders = firstFolders.filter((item) => {
                        const isProduct = item.record?.type !== 'folder' && !item.record?.ref
                        return shortcutScope === 'products' ? isProduct : !isProduct
                    })
                }

                function addRoot(tree: TreeDataItem[]): TreeDataItem[] {
                    if (includeRoot) {
                        return [
                            {
                                id: root,
                                name: formatUrlAsName(root),
                                displayName: <>{formatUrlAsName(root)}</>,
                                record: {
                                    type: 'folder',
                                    path: rootWithProtocol ? joinPath(rootFolders.splice(2)) : root,
                                },
                                children: tree,
                            },
                        ] as TreeDataItem[]
                    }
                    return tree
                }

                // no client side filtering under project://
                if (!searchTerm || !root || root.startsWith('project://')) {
                    return addRoot(firstFolders)
                }
                const term = searchTerm.toLowerCase()

                const filterTree = (nodes: TreeDataItem[]): TreeDataItem[] =>
                    nodes.reduce<TreeDataItem[]>((acc, node) => {
                        // Do not do client side filtering under the project:// path if looking at the full tree
                        if (node.id === 'project://') {
                            acc.push(node)
                            return acc
                        }

                        const children = node.children ? filterTree(node.children) : undefined
                        const path =
                            typeof node.record === 'object' && node.record && 'path' in node.record
                                ? ((node.record as { path?: string }).path ?? '')
                                : ''
                        const matches = path.toLowerCase().includes(term)

                        if (matches || (children && children.length)) {
                            acc.push({ ...node, children })
                        }
                        return acc
                    }, [])

                return addRoot(filterTree(firstFolders))
            },
        ],
        treeTableColumnOffsets: [
            (s) => [s.treeTableColumnSizes],
            (sizes: number[]): number[] =>
                sizes.map((_, index) => sizes.slice(0, index).reduce((acc, s) => acc + s, 0)),
        ],
        checkedItemCountNumeric: [
            (s) => [s.checkedItems],
            (checkedItems: Record<string, boolean>): number => Object.values(checkedItems).filter((v) => !!v).length,
        ],
        checkedItemsCount: [
            (s) => [s.checkedItems, s.viableItemsById],
            (checkedItems: Record<string, boolean>, viableItemsById: Record<string, FileSystemEntry>): string => {
                let hasFolder = false
                let sum = 0
                for (const [key, value] of Object.entries(checkedItems)) {
                    if (value) {
                        sum += 1
                        if (viableItemsById[key]?.type === 'folder') {
                            hasFolder = true
                        }
                    }
                }

                return `${sum}${hasFolder ? '+' : ''}`
            },
        ],
        checkedItemsArray: [
            (s) => [s.checkedItems, s.viableItemsById],
            (
                checkedItems: Record<string, boolean>,
                viableItemsById: Record<string, FileSystemEntry>
            ): FileSystemEntry[] => {
                return Object.entries(checkedItems)
                    .filter(([_, checked]) => checked)
                    .map(([id]) => viableItemsById[id])
                    .filter(Boolean)
            },
        ],
    }),
    listeners(({ actions, values, key, props }) => ({
        setActivePanelIdentifier: ({ identifier }) => {
            if (props.key === PROJECT_TREE_KEY && identifier === 'Project' && values.projectTreeRef) {
                actions.assureVisibility(values.projectTreeRef, false)
            }
            if (values.searchTerm !== '') {
                actions.clearSearch()
            }
        },
        clearSearch: () => {
            // All trees share the folder data. A non-project tree has no project:// expanded folders,
            // so a prune from it removes every loaded project folder, including folders open in other trees.
            if (props.root === undefined || props.root.startsWith('project://')) {
                actions.pruneClosedFolders(values.expandedFolders)
            }
        },
        loadFolderSuccess: ({ folder }) => {
            if (props.root?.startsWith('project://') && props.isActiveInPanel === true && folder === '') {
                const rootItems = values.folders['']
                if (rootItems.length < 5 && !values.expandedFolders.includes('project://Unfiled')) {
                    actions.toggleFolderOpen('project://Unfiled', true)
                }
            }
            actions.checkSelectedFolders()
        },
        createSavedItem: () => {
            actions.checkSelectedFolders()
        },
        loadSearchResultsSuccess: ({ searchResults, payload }) => {
            // Fire once per settled search term (the 250ms breakpoint cancels intermediate keystrokes),
            // and only for the first page so pagination doesn't double-count.
            if (searchResults.searchTerm && (!payload || !payload.offset)) {
                posthog.capture('project tree searched', {
                    root: props.root ?? 'project://',
                    has_results: searchResults.results.length > 0,
                })
            }
            actions.checkSelectedFolders()
        },
        deleteSavedItem: () => {
            actions.checkSelectedFolders()
        },
        movedItem: () => {
            actions.checkSelectedFolders()
        },
        checkSelectedFolders: () => {
            // Select items added into folders that are selected
            const checkedItems = values.checkedItems
            const toCheck = []
            let checkingFolder: string | null = null
            for (const item of values.sortedItems) {
                if (checkingFolder === null) {
                    if (item.type === 'folder' && checkedItems[`project://${item.path}`]) {
                        checkingFolder = item.path
                    }
                } else {
                    if (item.path.startsWith(checkingFolder + '/')) {
                        if (item.type === 'folder') {
                            if (!checkedItems[`project://${item.path}`]) {
                                toCheck.push(`project://${item.path}`)
                            }
                        } else {
                            if (!checkedItems[`project/${item.id}`]) {
                                toCheck.push(`project/${item.id}`)
                            }
                        }
                    } else {
                        checkingFolder = null
                        if (item.type === 'folder' && checkedItems[`project://${item.path}`]) {
                            checkingFolder = item.path
                        }
                    }
                }
            }
            const toDelete = new Set<string>()
            for (const itemId of Object.keys(checkedItems)) {
                if (!values.viableItemsById[itemId]) {
                    toDelete.add(itemId)
                }
            }
            if (toCheck.length > 0 || toDelete.size > 0) {
                actions.setCheckedItems({
                    ...(toDelete.size === 0
                        ? checkedItems
                        : Object.fromEntries(Object.entries(checkedItems).filter((kv) => !toDelete.has(kv[0])))),
                    ...Object.fromEntries(toCheck.map((item) => [item, true])),
                })
            }
        },
        expandProjectFolder: ({ path }) => {
            const expandedSet = new Set(values.expandedFolders)
            const allFolders = splitPath(path).slice(0, -1)
            const allFullFolders = allFolders.map((_, index) => joinPath(allFolders.slice(0, index + 1)))
            const nonExpandedFolders = allFullFolders.filter((f) => !expandedSet.has('project://' + f))
            for (const folder of allFullFolders) {
                if (!values.folderStates[folder] || values.folderStates[folder] === 'error') {
                    actions.loadFolder(folder)
                }
            }
            actions.setExpandedFolders([...values.expandedFolders, ...nonExpandedFolders.map((f) => 'project://' + f)])
        },
        onItemChecked: ({ id, checked, shift }) => {
            const {
                sortedItems,
                searchResults,
                sortMethod,
                recentResults,
                viableItemsById,
                lastCheckedItem,
                checkedItems: prevChecked,
            } = values
            const clickedItem = viableItemsById[id]
            if (!clickedItem) {
                // should never happen
                return
            }
            const isSearching = !!values.searchTerm
            const shownItems = isSearching
                ? searchResults.results
                : sortMethod === 'recent'
                  ? recentResults.results
                  : sortedItems

            const checkedItems = { ...prevChecked }

            const itemKey = (item: FileSystemEntry): string =>
                item.type === 'folder' ? `project://${item.path}` : `project/${item.id}`

            const markItem = (item: FileSystemEntry, value: boolean): void => {
                checkedItems[itemKey(item)] = value
            }

            const markFolderContents = (folder: FileSystemEntry, value: boolean): void => {
                if (isSearching) {
                    return
                }
                const startIdx = shownItems.findIndex((i) => i.id === folder.id)
                for (let i = startIdx + 1; i < shownItems.length; i++) {
                    const entry = shownItems[i]
                    if (!entry.path.startsWith(folder.path + '/')) {
                        // left the folder
                        break
                    }
                    markItem(entry, value)
                }
            }

            const applyToItem = (item: FileSystemEntry): void => {
                markItem(item, !!checked)
                if (item.type === 'folder') {
                    markFolderContents(item, !!checked)
                }
            }

            if (shift && lastCheckedItem) {
                const prevIdx = shownItems.findIndex((it) => itemKey(it) === lastCheckedItem.id)
                const currIdx = shownItems.findIndex((it) => it.id === clickedItem.id)
                if (prevIdx !== -1 && currIdx !== -1) {
                    const [start, end] = [Math.min(prevIdx, currIdx), Math.max(prevIdx, currIdx)]
                    for (let i = start; i <= end; i++) {
                        applyToItem(shownItems[i])
                    }
                } else if (currIdx !== -1) {
                    applyToItem(shownItems[currIdx])
                }
            } else {
                applyToItem(clickedItem)
            }

            actions.setLastCheckedItem(id, checked, shift)
            actions.setCheckedItems(checkedItems)

            // If any items are checked, set the select mode to multi
            // We don't do the inverse because we don't want to set the select mode to default when deselecting all
            if (Object.values(checkedItems).some((v) => !!v)) {
                actions.setSelectMode('multi')
            }
        },
        moveCheckedItems: ({ path }) => {
            const { checkedItems } = values
            let skipInFolder: string | null = null
            // Descendants of a moved folder are skipped, so the checked count would overstate how many
            // items actually moved.
            const moves: { item: FileSystemEntry; newPath: string }[] = []
            for (const item of values.sortedItems) {
                if (skipInFolder !== null) {
                    if (item.path.startsWith(skipInFolder + '/')) {
                        continue
                    } else {
                        skipInFolder = null
                    }
                }
                const itemId = item.type === 'folder' ? `project://${item.path}` : `project/${item.id}`
                if (checkedItems[itemId]) {
                    const { newPath, isValidMove } = calculateMovePath(item, path)
                    if (isValidMove) {
                        moves.push({ item, newPath })
                    }
                    if (item.type === 'folder') {
                        skipInFolder = item.path
                    }
                }
            }
            actions.moveItems(moves, true, key)
            posthog.capture('project tree items moved', {
                root: props.root ?? 'project://',
                count: moves.length,
                is_bulk: true,
            })
        },
        linkCheckedItems: ({ path }) => {
            const { checkedItems } = values
            let skipInFolder: string | null = null
            for (const item of values.sortedItems) {
                if (skipInFolder !== null) {
                    if (item.path.startsWith(skipInFolder + '/')) {
                        continue
                    } else {
                        skipInFolder = null
                    }
                }
                const itemId = item.type === 'folder' ? `project://${item.path}` : `project/${item.id}`
                if (checkedItems[itemId]) {
                    actions.linkItem(
                        item.path,
                        joinPath([...splitPath(path), ...splitPath(item.path).slice(-1)]),
                        true,
                        key
                    )
                    if (item.type === 'folder') {
                        skipInFolder = item.path
                    }
                }
            }
        },
        deleteCheckedItems: () => {
            const { checkedItems } = values
            let skipInFolder: string | null = null
            for (const item of values.sortedItems) {
                if (skipInFolder !== null) {
                    if (item.path.startsWith(skipInFolder + '/')) {
                        continue
                    } else {
                        skipInFolder = null
                    }
                }
                const itemId = item.type === 'folder' ? `project://${item.path}` : `project/${item.id}`
                if (checkedItems[itemId]) {
                    actions.deleteItem(item, key)
                    if (item.type === 'folder') {
                        skipInFolder = item.path
                    }
                }
            }
        },
        addFolder: ({ folder, editAfter, callback }) => {
            // Like Mac, we don't allow duplicate folder names
            // So we need to increment the folder name until we find a unique one
            let folderName = folder
            let counter = 2
            while (values.viableItems.find((item) => item.path === folderName && item.type === 'folder')) {
                folderName = `${folder} ${counter}`
                counter++
            }

            actions.queueAction(
                {
                    type: 'create',
                    item: { id: `project/${folderName}`, path: folderName, type: 'folder' },
                    path: folderName,
                    newPath: folderName,
                },
                key
            )

            // Always set the editing item ID after a short delay to ensure the folder is in the DOM
            if (editAfter) {
                setTimeout(() => {
                    actions.setEditingItemId(`project://${folderName}`)
                }, 50)
            }
            callback?.(folderName)
        },
        toggleFolderOpen: ({ folderId }) => {
            if (values.searchTerm) {
                if (values.expandedSearchFolders.find((f) => f === folderId)) {
                    actions.setExpandedSearchFolders(values.expandedSearchFolders.filter((f) => f !== folderId))
                } else {
                    actions.setExpandedSearchFolders([...values.expandedSearchFolders, folderId])
                }
            } else {
                if (values.expandedFolders.find((f) => f === folderId)) {
                    const childPrefix = folderId.endsWith('://') ? folderId : folderId + '/'
                    const newExpandedFolders = values.expandedFolders.filter(
                        (f) => f !== folderId && !f.startsWith(childPrefix)
                    )
                    actions.setExpandedFolders(newExpandedFolders)
                    actions.pruneClosedFolders(newExpandedFolders)
                } else {
                    actions.setExpandedFolders([...values.expandedFolders, folderId])
                    actions.loadFolderIfNotLoaded(folderId)
                }
            }
        },
        loadFolderIfNotLoaded: ({ folderId }) => {
            if (folderId.startsWith('shortcuts://')) {
                const [, path] = splitProtocolPath(folderId)
                const firstFolder = splitPath(path)[0]

                const shortcut = values.shortcutData.find((s) => s.path === firstFolder && s.type === 'folder')
                if (shortcut?.ref) {
                    actions.loadFolderIfNotLoaded('project://' + shortcut.ref)
                }
            }

            if (values.folderStates[folderId] !== 'loaded' && values.folderStates[folderId] !== 'loading') {
                const folder = findInProjectTree(folderId, values.projectTree)
                if (folder) {
                    actions.loadFolder(folder.record?.path)
                } else if (folderId.startsWith('project://')) {
                    actions.loadFolder(folderId.slice('project://'.length))
                }
            }
        },
        rename: ({ value, item }) => {
            const splits = splitPath(item.path)
            if (splits.length > 0) {
                if (value) {
                    posthog.capture('project tree item renamed', {
                        root: props.root ?? 'project://',
                        item_type: item.type ?? null,
                    })
                    actions.moveItem(item, joinPath([...splits.slice(0, -1), value]), false, key)
                    actions.setEditingItemId('')
                }
            }
        },
        deleteItem: ({ item }) => {
            posthog.capture('project tree item deleted', {
                root: props.root ?? 'project://',
                item_type: item.type ?? null,
            })
        },
        createFolder: ({ parentPath, editAfter, callback }) => {
            posthog.capture('project tree folder created', {
                root: props.root ?? 'project://',
                is_root_folder: !parentPath,
            })
            const parentSplits = parentPath ? splitPath(parentPath) : []
            const newPath = joinPath([...parentSplits, 'Untitled folder'])
            actions.addFolder(newPath, editAfter, callback)
        },
        setSearchTerm: ({ searchTerm }) => {
            actions.loadSearchResults(searchTerm)
        },
        toggleOnlyMyStuff: () => {
            actions.setSearchTerm(
                values.searchFilters.onlyMine
                    ? values.searchTerm
                          .split(' ')
                          .filter((tag) => tag !== 'user:me')
                          .join(' ')
                          .trim()
                    : `${values.searchTerm.trim()} user:me`.trim()
            )
        },
        toggleFileTypeFilter: ({ fileType }) => {
            const withoutType = values.searchTerm
                .split(' ')
                .filter((tag) => !tag.startsWith('type:'))
                .join(' ')
                .trim()
            actions.setSearchTerm(
                values.searchFilters.fileType === fileType ? withoutType : `${withoutType} type:${fileType}`.trim()
            )
        },
        setSortMethod: ({ sortMethod }) => {
            posthog.capture('project tree sort changed', {
                root: props.root ?? 'project://',
                sort_method: sortMethod,
            })
            if (values.searchTerm) {
                actions.loadSearchResults(values.searchTerm, 0)
            }
            if (sortMethod === 'recent' && !values.recentResultsLoading) {
                actions.loadRecentResults('start')
            }
        },
        assureVisibility: async ({ projectTreeRef, expandIfHidden }, breakpoint) => {
            if (projectTreeRef) {
                const starredRef = projectTreeDataLogic.values.starredNavigationRef
                if (
                    !expandIfHidden &&
                    props.key === 'navbar-files' &&
                    starredRef &&
                    matchesRefType(starredRef.type, projectTreeRef.type) &&
                    starredRef.ref === projectTreeRef.ref
                ) {
                    return
                }
                if (projectTreeRef.type === 'insight' && !expandIfHidden && !isProjectTreeActive(props, values)) {
                    return
                }
                if (projectTreeRef.type === 'folder' && projectTreeRef.ref) {
                    if (!expandIfHidden && !isProjectTreeActive(props, values)) {
                        return
                    }
                    actions.expandProjectFolder(projectTreeRef.ref)
                    const item = values.viableItems.find(
                        (item) => item.type === 'folder' && item.path === projectTreeRef.ref
                    )
                    if (item) {
                        actions.scrollToView(item)
                    }
                    return
                }

                const treeItem = values.viableItems.find(
                    (item) => matchesRefType(item.type, projectTreeRef.type) && item.ref === projectTreeRef.ref
                )
                let path: string | undefined
                if (treeItem) {
                    path = treeItem.path
                } else if (projectTreeRef.ref !== null) {
                    await projectTreeDataLogic.asyncActions.syncTypeAndRef(projectTreeRef.type, projectTreeRef.ref)
                    breakpoint() // bail if we opened some other item in the meanwhile
                    path = values.viableItems.find(
                        (item) => matchesRefType(item.type, projectTreeRef.type) && item.ref === projectTreeRef.ref
                    )?.path
                }

                if (path && (expandIfHidden || isProjectTreeActive(props, values))) {
                    actions.expandProjectFolder(path)
                    if (treeItem) {
                        actions.scrollToView(treeItem)
                    }
                }
            }
        },
    })),
    subscriptions(({ actions, values, props }) => ({
        projectTreeRef: (newRef: ProjectTreeRef | null) => {
            // Only the project:// tree navigates to breadcrumb-driven items. Other roots
            // (products, shortcuts) don't contain project file-system items,
            // so subscribing on those instances would fire duplicate api.fileSystem.list calls
            // for every navigation when those panels are keep-mounted.
            // undefined root means the panel loads the project root (''), so it is project-equivalent.
            const isProjectRoot = props.root === undefined || props.root.startsWith('project://')
            if (!isProjectRoot) {
                return
            }
            if (newRef) {
                if (newRef.ref === null) {
                    if (typeof values.lastNewFolder === 'string') {
                        actions.assureVisibility({ type: 'folder', ref: values.lastNewFolder }, false)
                    }
                } else {
                    actions.assureVisibility(newRef, false)
                }
            }
        },
    })),
    afterMount(({ actions, values, props }) => {
        if (props.root) {
            if (props.root.startsWith('project://')) {
                actions.loadFolder(props.root.slice('project://'.length))
            }
        } else {
            actions.loadFolder('')
        }
        const isProjectRoot = props.root === undefined || props.root.startsWith('project://')
        if (shouldLoadUnfiledItems(props, values)) {
            actions.loadUnfiledItems()
        }
        if (values.projectTreeRef && isProjectRoot) {
            actions.assureVisibility(values.projectTreeRef, false)
        }
        if (typeof props.defaultOnlyFolders !== 'undefined') {
            actions.setOnlyFolders(props.defaultOnlyFolders)
        }
        if (typeof props.defaultSortMethod !== 'undefined') {
            actions.setSortMethod(props.defaultSortMethod)
        }
    }),
    propsChanged(({ actions, props, values }, oldProps) => {
        if (props.root !== oldProps.root) {
            const expandedFolders = values.expandedFolders.filter((f) => f !== oldProps.root)
            if (props.root) {
                expandedFolders.push(props.root)
            }
            actions.setExpandedFolders(expandedFolders)
            if (props.root) {
                actions.loadFolderIfNotLoaded(props.root)
            }
        }
        const projectPanelStateChanged =
            props.root !== oldProps.root || props.isActiveInPanel !== oldProps.isActiveInPanel
        if (
            projectPanelStateChanged &&
            isProjectTreeActive(props, values) &&
            values.projectTreeRef &&
            (props.root === undefined || props.root.startsWith('project://'))
        ) {
            actions.assureVisibility(values.projectTreeRef, false)
        }
        if (projectPanelStateChanged && shouldLoadUnfiledItems(props, values)) {
            actions.loadUnfiledItems()
        }
    }),
])

export function refreshTreeItem(type: string, ref: string): void {
    projectTreeDataLogic.findMounted()?.actions.syncTypeAndRef(type, ref)
}

export function deleteFromTree(type: string, ref: string): void {
    projectTreeDataLogic.findMounted()?.actions.deleteTypeAndRef(type, ref)
}

export function getLastNewFolder(): string | undefined {
    return projectTreeLogic.findMounted({ key: PROJECT_TREE_KEY })?.values.lastNewFolder ?? undefined
}