: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 {
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
}