@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/components/Collection/GroupControl.js

@@ -0,0 +1,33 @@
+import React from 'react';
+import { translate } from 'react-polyglot';
+import { Dropdown, DropdownItem } from 'decap-cms-ui-default';
+import { ControlButton } from './ControlButton';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+function GroupControl({
+  viewGroups,
+  t,
+  onGroupClick,
+  group
+}) {
+  const hasActiveGroup = group?.valueSeq().toJS().some(f => f.active === true);
+  return ___EmotionJSX(Dropdown, {
+    renderButton: () => {
+      return ___EmotionJSX(ControlButton, {
+        active: hasActiveGroup,
+        title: t('collection.collectionTop.groupBy')
+      });
+    },
+    closeOnSelection: false,
+    dropdownTopOverlap: "30px",
+    dropdownWidth: "160px",
+    dropdownPosition: "left"
+  }, viewGroups.map(viewGroup => {
+    return ___EmotionJSX(DropdownItem, {
+      key: viewGroup.id,
+      label: viewGroup.label,
+      onClick: () => onGroupClick(viewGroup),
+      isActive: group.getIn([viewGroup.id, 'active'], false)
+    });
+  }));
+}
+export default translate()(GroupControl);

package/dist/esm/components/Collection/NestedCollection.js

@@ -0,0 +1,308 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import React from 'react';
+import { List } from 'immutable';
+import { css } from '@emotion/react';
+import { connect } from 'react-redux';
+import { NavLink } from 'react-router-dom';
+import { dirname, sep } from 'path';
+import { stringTemplate } from 'decap-cms-lib-widgets';
+import { Icon, colors, components } from 'decap-cms-ui-default';
+import PropTypes from 'prop-types';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import sortBy from 'lodash/sortBy';
+import { selectEntries } from '../../reducers/entries';
+import { selectEntryCollectionTitle } from '../../reducers/collections';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const {
+  addFileTemplateFields
+} = stringTemplate;
+const NodeTitleContainer = /*#__PURE__*/_styled("div", {
+  target: "e1674r195",
+  label: "NodeTitleContainer"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1vcob1d",
+  styles: "display:flex;justify-content:center;align-items:center"
+} : {
+  name: "1vcob1d",
+  styles: "display:flex;justify-content:center;align-items:center/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AAkBqC","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const NodeTitle = /*#__PURE__*/_styled("div", {
+  target: "e1674r194",
+  label: "NodeTitle"
+})(process.env.NODE_ENV === "production" ? {
+  name: "qamjgr",
+  styles: "margin-right:4px"
+} : {
+  name: "qamjgr",
+  styles: "margin-right:4px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AAwB4B","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const Caret = /*#__PURE__*/_styled("div", {
+  target: "e1674r193",
+  label: "Caret"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1lo1a34",
+  styles: "position:relative;top:2px"
+} : {
+  name: "1lo1a34",
+  styles: "position:relative;top:2px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AA4BwB","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const CaretDown = /*#__PURE__*/_styled(Caret, {
+  target: "e1674r192",
+  label: "CaretDown"
+})(components.caretDown, ";color:currentColor;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AAiC+B","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */"));
+const CaretRight = /*#__PURE__*/_styled(Caret, {
+  target: "e1674r191",
+  label: "CaretRight"
+})(components.caretRight, ";color:currentColor;left:2px;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AAsCgC","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */"));
+const TreeNavLink = /*#__PURE__*/_styled(NavLink, {
+  target: "e1674r190",
+  label: "TreeNavLink"
+})("display:flex;font-size:14px;font-weight:500;align-items:center;padding:8px;padding-left:", props => props.depth * 16 + 18, "px;border-left:2px solid #fff;", Icon, "{margin-right:4px;flex-shrink:0;}", props => /*#__PURE__*/css("&:hover,&:active,&.", props.activeClassName, "{color:", colors.active, ";background-color:", colors.activeBackground, ";border-left-color:#4863c6;};label:TreeNavLink;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AA0DgB","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */")), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/NestedCollection.js"],"names":[],"mappings":"AA4CmC","file":"../../../../src/components/Collection/NestedCollection.js","sourcesContent":["import React from 'react';\nimport { List } from 'immutable';\nimport { css } from '@emotion/react';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { NavLink } from 'react-router-dom';\nimport { dirname, sep } from 'path';\nimport { stringTemplate } from 'decap-cms-lib-widgets';\nimport { Icon, colors, components } from 'decap-cms-ui-default';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport sortBy from 'lodash/sortBy';\n\nimport { selectEntries } from '../../reducers/entries';\nimport { selectEntryCollectionTitle } from '../../reducers/collections';\n\nconst { addFileTemplateFields } = stringTemplate;\n\nconst NodeTitleContainer = styled.div`\n  display: flex;\n  justify-content: center;\n  align-items: center;\n`;\n\nconst NodeTitle = styled.div`\n  margin-right: 4px;\n`;\n\nconst Caret = styled.div`\n  position: relative;\n  top: 2px;\n`;\n\nconst CaretDown = styled(Caret)`\n  ${components.caretDown};\n  color: currentColor;\n`;\n\nconst CaretRight = styled(Caret)`\n  ${components.caretRight};\n  color: currentColor;\n  left: 2px;\n`;\n\nconst TreeNavLink = styled(NavLink)`\n  display: flex;\n  font-size: 14px;\n  font-weight: 500;\n  align-items: center;\n  padding: 8px;\n  padding-left: ${props => props.depth * 16 + 18}px;\n  border-left: 2px solid #fff;\n\n  ${Icon} {\n    margin-right: 4px;\n    flex-shrink: 0;\n  }\n\n  ${props => css`\n    &:hover,\n    &:active,\n    &.${props.activeClassName} {\n      color: ${colors.active};\n      background-color: ${colors.activeBackground};\n      border-left-color: #4863c6;\n    }\n  `};\n`;\n\nfunction getNodeTitle(node, collection) {\n  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,\n  // directory nodes should use the title of their index entry.\n  // Otherwise, use the folder name already stored in `node.title`.\n  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;\n  if (!node.isRoot && node.isDir && subfolders) {\n    const indexChild = node.children.find(child => !child.isDir);\n    if (indexChild && indexChild.title) {\n      return indexChild.title;\n    }\n  }\n  return node.title;\n}\n\nfunction TreeNode(props) {\n  const { collection, treeData, depth = 0, onToggle } = props;\n  const collectionName = collection.get('name');\n\n  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));\n  const subfolders = collection.get('nested')?.get('subfolders') !== false;\n  return sortedData.map(node => {\n    const leaf =\n      depth > 0 &&\n      (subfolders\n        ? node.children.length <= 1 && !node.children[0]?.isDir\n        : node.children.length === 0);\n    if (leaf) {\n      return null;\n    }\n    let to = `/collections/${collectionName}`;\n    if (depth > 0) {\n      to = `${to}/filter${node.path}`;\n    }\n    const title = getNodeTitle(node, collection);\n\n    const hasChildren =\n      depth === 0 ||\n      (subfolders\n        ? node.children.some(c => c.children.some(c => c.isDir))\n        : node.children.some(c => c.isDir));\n\n    return (\n      <React.Fragment key={node.path}>\n        <TreeNavLink\n          exact\n          to={to}\n          activeClassName=\"sidebar-active\"\n          onClick={() => onToggle({ node, expanded: !node.expanded })}\n          depth={depth}\n          data-testid={node.path}\n        >\n          <Icon type=\"write\" />\n          <NodeTitleContainer>\n            <NodeTitle>{title}</NodeTitle>\n            {hasChildren && (node.expanded ? <CaretDown /> : <CaretRight />)}\n          </NodeTitleContainer>\n        </TreeNavLink>\n        {node.expanded && (\n          <TreeNode\n            collection={collection}\n            depth={depth + 1}\n            treeData={node.children}\n            onToggle={onToggle}\n          />\n        )}\n      </React.Fragment>\n    );\n  });\n}\n\nTreeNode.propTypes = {\n  collection: ImmutablePropTypes.map.isRequired,\n  depth: PropTypes.number,\n  treeData: PropTypes.array.isRequired,\n  onToggle: PropTypes.func.isRequired,\n};\n\nexport function walk(treeData, callback) {\n  function traverse(children) {\n    for (const child of children) {\n      callback(child);\n      traverse(child.children);\n    }\n  }\n\n  return traverse(treeData);\n}\n\nexport function getTreeData(collection, entries) {\n  const collectionFolder = collection.get('folder');\n  const rootFolder = '/';\n  const entriesObj = entries\n    .toJS()\n    .map(e => ({ ...e, path: e.path.slice(collectionFolder.length) }));\n\n  const dirs = entriesObj.reduce((acc, entry) => {\n    let dir = dirname(entry.path);\n    while (!acc[dir] && dir && dir !== rootFolder) {\n      const parts = dir.split(sep);\n      acc[dir] = parts.pop();\n      dir = parts.length && parts.join(sep);\n    }\n    return acc;\n  }, {});\n\n  if (collection.getIn(['nested', 'summary'])) {\n    collection = collection.set('summary', collection.getIn(['nested', 'summary']));\n  } else {\n    collection = collection.delete('summary');\n  }\n\n  const flatData = [\n    {\n      title: collection.get('label'),\n      path: rootFolder,\n      isDir: true,\n      isRoot: true,\n    },\n    ...Object.entries(dirs).map(([key, value]) => ({\n      title: value,\n      path: key,\n      isDir: true,\n      isRoot: false,\n    })),\n    ...entriesObj.map((e, index) => {\n      let entryMap = entries.get(index);\n      entryMap = entryMap.set(\n        'data',\n        addFileTemplateFields(entryMap.get('path'), entryMap.get('data')),\n      );\n      const title = selectEntryCollectionTitle(collection, entryMap);\n      return {\n        ...e,\n        title,\n        isDir: false,\n        isRoot: false,\n      };\n    }),\n  ];\n\n  const parentsToChildren = flatData.reduce((acc, node) => {\n    const parent = node.path === rootFolder ? '' : dirname(node.path);\n    if (acc[parent]) {\n      acc[parent].push(node);\n    } else {\n      acc[parent] = [node];\n    }\n    return acc;\n  }, {});\n\n  function reducer(acc, value) {\n    const node = value;\n    let children = [];\n    if (parentsToChildren[node.path]) {\n      children = parentsToChildren[node.path].reduce(reducer, []);\n    }\n\n    acc.push({ ...node, children });\n    return acc;\n  }\n\n  const treeData = parentsToChildren[''].reduce(reducer, []);\n\n  return treeData;\n}\n\nexport function updateNode(treeData, node, callback) {\n  let stop = false;\n\n  function updater(nodes) {\n    if (stop) {\n      return nodes;\n    }\n    for (let i = 0; i < nodes.length; i++) {\n      if (nodes[i].path === node.path) {\n        nodes[i] = callback(node);\n        stop = true;\n        return nodes;\n      }\n    }\n    nodes.forEach(node => updater(node.children));\n    return nodes;\n  }\n\n  return updater([...treeData]);\n}\n\nexport class NestedCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    entries: ImmutablePropTypes.list.isRequired,\n    filterTerm: PropTypes.string,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      treeData: getTreeData(this.props.collection, this.props.entries),\n      selected: null,\n      useFilter: true,\n    };\n  }\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entries, filterTerm } = this.props;\n    if (\n      collection !== prevProps.collection ||\n      entries !== prevProps.entries ||\n      filterTerm !== prevProps.filterTerm\n    ) {\n      const expanded = {};\n      walk(this.state.treeData, node => {\n        if (node.expanded) {\n          expanded[node.path] = true;\n        }\n      });\n      const treeData = getTreeData(collection, entries);\n\n      const path = `/${filterTerm}`;\n      walk(treeData, node => {\n        if (expanded[node.path] || (this.state.useFilter && path.startsWith(node.path))) {\n          node.expanded = true;\n        }\n      });\n      this.setState({ treeData });\n    }\n  }\n\n  onToggle = ({ node, expanded }) => {\n    if (!this.state.selected || this.state.selected.path === node.path || expanded) {\n      const treeData = updateNode(this.state.treeData, node, node => ({\n        ...node,\n        expanded,\n      }));\n      this.setState({ treeData, selected: node, useFilter: false });\n    } else {\n      // don't collapse non selected nodes when clicked\n      this.setState({ selected: node, useFilter: false });\n    }\n  };\n\n  render() {\n    const { treeData } = this.state;\n    const { collection } = this.props;\n\n    return <TreeNode collection={collection} treeData={treeData} onToggle={this.onToggle} />;\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection } = ownProps;\n  const entries = selectEntries(state.entries, collection) || List();\n  return { entries };\n}\n\nexport default connect(mapStateToProps, null)(NestedCollection);\n"]} */"));
+function getNodeTitle(node, collection) {
+  // Backward compatibility: when `nested.subfolders` is true(default) or undefined,
+  // directory nodes should use the title of their index entry.
+  // Otherwise, use the folder name already stored in `node.title`.
+  const subfolders = collection.getIn(['nested', 'subfolders']) !== false;
+  if (!node.isRoot && node.isDir && subfolders) {
+    const indexChild = node.children.find(child => !child.isDir);
+    if (indexChild && indexChild.title) {
+      return indexChild.title;
+    }
+  }
+  return node.title;
+}
+function TreeNode(props) {
+  const {
+    collection,
+    treeData,
+    depth = 0,
+    onToggle
+  } = props;
+  const collectionName = collection.get('name');
+  const sortedData = sortBy(treeData, node => getNodeTitle(node, collection));
+  const subfolders = collection.get('nested')?.get('subfolders') !== false;
+  return sortedData.map(node => {
+    const leaf = depth > 0 && (subfolders ? node.children.length <= 1 && !node.children[0]?.isDir : node.children.length === 0);
+    if (leaf) {
+      return null;
+    }
+    let to = `/collections/${collectionName}`;
+    if (depth > 0) {
+      to = `${to}/filter${node.path}`;
+    }
+    const title = getNodeTitle(node, collection);
+    const hasChildren = depth === 0 || (subfolders ? node.children.some(c => c.children.some(c => c.isDir)) : node.children.some(c => c.isDir));
+    return ___EmotionJSX(React.Fragment, {
+      key: node.path
+    }, ___EmotionJSX(TreeNavLink, {
+      exact: true,
+      to: to,
+      activeClassName: "sidebar-active",
+      onClick: () => onToggle({
+        node,
+        expanded: !node.expanded
+      }),
+      depth: depth,
+      "data-testid": node.path
+    }, ___EmotionJSX(Icon, {
+      type: "write"
+    }), ___EmotionJSX(NodeTitleContainer, null, ___EmotionJSX(NodeTitle, null, title), hasChildren && (node.expanded ? ___EmotionJSX(CaretDown, null) : ___EmotionJSX(CaretRight, null)))), node.expanded && ___EmotionJSX(TreeNode, {
+      collection: collection,
+      depth: depth + 1,
+      treeData: node.children,
+      onToggle: onToggle
+    }));
+  });
+}
+TreeNode.propTypes = {
+  collection: ImmutablePropTypes.map.isRequired,
+  depth: PropTypes.number,
+  treeData: PropTypes.array.isRequired,
+  onToggle: PropTypes.func.isRequired
+};
+export function walk(treeData, callback) {
+  function traverse(children) {
+    for (const child of children) {
+      callback(child);
+      traverse(child.children);
+    }
+  }
+  return traverse(treeData);
+}
+export function getTreeData(collection, entries) {
+  const collectionFolder = collection.get('folder');
+  const rootFolder = '/';
+  const entriesObj = entries.toJS().map(e => ({
+    ...e,
+    path: e.path.slice(collectionFolder.length)
+  }));
+  const dirs = entriesObj.reduce((acc, entry) => {
+    let dir = dirname(entry.path);
+    while (!acc[dir] && dir && dir !== rootFolder) {
+      const parts = dir.split(sep);
+      acc[dir] = parts.pop();
+      dir = parts.length && parts.join(sep);
+    }
+    return acc;
+  }, {});
+  if (collection.getIn(['nested', 'summary'])) {
+    collection = collection.set('summary', collection.getIn(['nested', 'summary']));
+  } else {
+    collection = collection.delete('summary');
+  }
+  const flatData = [{
+    title: collection.get('label'),
+    path: rootFolder,
+    isDir: true,
+    isRoot: true
+  }, ...Object.entries(dirs).map(([key, value]) => ({
+    title: value,
+    path: key,
+    isDir: true,
+    isRoot: false
+  })), ...entriesObj.map((e, index) => {
+    let entryMap = entries.get(index);
+    entryMap = entryMap.set('data', addFileTemplateFields(entryMap.get('path'), entryMap.get('data')));
+    const title = selectEntryCollectionTitle(collection, entryMap);
+    return {
+      ...e,
+      title,
+      isDir: false,
+      isRoot: false
+    };
+  })];
+  const parentsToChildren = flatData.reduce((acc, node) => {
+    const parent = node.path === rootFolder ? '' : dirname(node.path);
+    if (acc[parent]) {
+      acc[parent].push(node);
+    } else {
+      acc[parent] = [node];
+    }
+    return acc;
+  }, {});
+  function reducer(acc, value) {
+    const node = value;
+    let children = [];
+    if (parentsToChildren[node.path]) {
+      children = parentsToChildren[node.path].reduce(reducer, []);
+    }
+    acc.push({
+      ...node,
+      children
+    });
+    return acc;
+  }
+  const treeData = parentsToChildren[''].reduce(reducer, []);
+  return treeData;
+}
+export function updateNode(treeData, node, callback) {
+  let stop = false;
+  function updater(nodes) {
+    if (stop) {
+      return nodes;
+    }
+    for (let i = 0; i < nodes.length; i++) {
+      if (nodes[i].path === node.path) {
+        nodes[i] = callback(node);
+        stop = true;
+        return nodes;
+      }
+    }
+    nodes.forEach(node => updater(node.children));
+    return nodes;
+  }
+  return updater([...treeData]);
+}
+export class NestedCollection extends React.Component {
+  static propTypes = {
+    collection: ImmutablePropTypes.map.isRequired,
+    entries: ImmutablePropTypes.list.isRequired,
+    filterTerm: PropTypes.string
+  };
+  constructor(props) {
+    super(props);
+    this.state = {
+      treeData: getTreeData(this.props.collection, this.props.entries),
+      selected: null,
+      useFilter: true
+    };
+  }
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(NestedCollection.propTypes, this.props, 'prop', 'NestedCollection');
+  }
+  componentDidUpdate(prevProps) {
+    const {
+      collection,
+      entries,
+      filterTerm
+    } = this.props;
+    if (collection !== prevProps.collection || entries !== prevProps.entries || filterTerm !== prevProps.filterTerm) {
+      const expanded = {};
+      walk(this.state.treeData, node => {
+        if (node.expanded) {
+          expanded[node.path] = true;
+        }
+      });
+      const treeData = getTreeData(collection, entries);
+      const path = `/${filterTerm}`;
+      walk(treeData, node => {
+        if (expanded[node.path] || this.state.useFilter && path.startsWith(node.path)) {
+          node.expanded = true;
+        }
+      });
+      this.setState({
+        treeData
+      });
+    }
+  }
+  onToggle = ({
+    node,
+    expanded
+  }) => {
+    if (!this.state.selected || this.state.selected.path === node.path || expanded) {
+      const treeData = updateNode(this.state.treeData, node, node => ({
+        ...node,
+        expanded
+      }));
+      this.setState({
+        treeData,
+        selected: node,
+        useFilter: false
+      });
+    } else {
+      // don't collapse non selected nodes when clicked
+      this.setState({
+        selected: node,
+        useFilter: false
+      });
+    }
+  };
+  render() {
+    const {
+      treeData
+    } = this.state;
+    const {
+      collection
+    } = this.props;
+    return ___EmotionJSX(TreeNode, {
+      collection: collection,
+      treeData: treeData,
+      onToggle: this.onToggle
+    });
+  }
+}
+function mapStateToProps(state, ownProps) {
+  const {
+    collection
+  } = ownProps;
+  const entries = selectEntries(state.entries, collection) || List();
+  return {
+    entries
+  };
+}
+export default connect(mapStateToProps, null)(NestedCollection);