@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/components/Collection/Entries/EntriesCollection.js

@@ -0,0 +1,241 @@
+import _styled from "@emotion/styled/base";
+import React from 'react';
+import PropTypes from 'prop-types';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import { connect } from 'react-redux';
+import { translate } from 'react-polyglot';
+import partial from 'lodash/partial';
+import { Cursor } from 'decap-cms-lib-util';
+import { colors } from 'decap-cms-ui-default';
+import { loadEntries as actionLoadEntries, traverseCollectionCursor as actionTraverseCollectionCursor } from '../../../actions/entries';
+import { loadUnpublishedEntries } from '../../../actions/editorialWorkflow';
+import { selectEntries, selectEntriesLoaded, selectIsFetching, selectGroups } from '../../../reducers/entries';
+import { selectUnpublishedEntry, selectUnpublishedEntriesByStatus } from '../../../reducers';
+import { selectCollectionEntriesCursor } from '../../../reducers/cursors';
+import Entries from './Entries';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const GroupHeading = /*#__PURE__*/_styled("h2", {
+  target: "e13tmaqg1",
+  label: "GroupHeading"
+})("font-size:22px;font-weight:600;line-height:37px;padding-inline-start:20px;color:", colors.textLead, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../src/components/Collection/Entries/EntriesCollection.js"],"names":[],"mappings":"AAyB8B","file":"../../../../../src/components/Collection/Entries/EntriesCollection.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport { connect } from 'react-redux';\nimport styled from '@emotion/styled';\nimport { translate } from 'react-polyglot';\nimport partial from 'lodash/partial';\nimport { Cursor } from 'decap-cms-lib-util';\nimport { colors } from 'decap-cms-ui-default';\n\nimport {\n  loadEntries as actionLoadEntries,\n  traverseCollectionCursor as actionTraverseCollectionCursor,\n} from '../../../actions/entries';\nimport { loadUnpublishedEntries } from '../../../actions/editorialWorkflow';\nimport {\n  selectEntries,\n  selectEntriesLoaded,\n  selectIsFetching,\n  selectGroups,\n} from '../../../reducers/entries';\nimport { selectUnpublishedEntry, selectUnpublishedEntriesByStatus } from '../../../reducers';\nimport { selectCollectionEntriesCursor } from '../../../reducers/cursors';\nimport Entries from './Entries';\n\nconst GroupHeading = styled.h2`\n  font-size: 22px;\n  font-weight: 600;\n  line-height: 37px;\n  padding-inline-start: 20px;\n  color: ${colors.textLead};\n`;\n\nconst GroupContainer = styled.div``;\n\nfunction getGroupEntries(entries, paths) {\n  return entries.filter(entry => paths.has(entry.get('path')));\n}\n\nfunction getGroupTitle(group, t) {\n  const { label, value } = group;\n  if (value === undefined) {\n    return t('collection.groups.other');\n  }\n  if (typeof value === 'boolean') {\n    return value ? label : t('collection.groups.negateLabel', { label });\n  }\n  return `${label} ${value}`.trim();\n}\n\nfunction withGroups(groups, entries, EntriesToRender, t) {\n  return groups.map(group => {\n    const title = getGroupTitle(group, t);\n    return (\n      <GroupContainer key={group.id} id={group.id}>\n        <GroupHeading>{title}</GroupHeading>\n        <EntriesToRender entries={getGroupEntries(entries, group.paths)} />\n      </GroupContainer>\n    );\n  });\n}\n\nexport class EntriesCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    collections: ImmutablePropTypes.iterable,\n    page: PropTypes.number,\n    entries: ImmutablePropTypes.list,\n    groups: PropTypes.array,\n    isFetching: PropTypes.bool.isRequired,\n    viewStyle: PropTypes.string,\n    cursor: PropTypes.object.isRequired,\n    loadEntries: PropTypes.func.isRequired,\n    traverseCollectionCursor: PropTypes.func.isRequired,\n    entriesLoaded: PropTypes.bool,\n    loadUnpublishedEntries: PropTypes.func.isRequired,\n    unpublishedEntriesLoaded: PropTypes.bool,\n    isEditorialWorkflowEnabled: PropTypes.bool,\n    getWorkflowStatus: PropTypes.func.isRequired,\n    getUnpublishedEntries: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(EntriesCollection.propTypes, this.props, 'prop', 'EntriesCollection');\n\n    const {\n      collection,\n      collections,\n      entriesLoaded,\n      loadEntries,\n      unpublishedEntriesLoaded,\n      loadUnpublishedEntries,\n      isEditorialWorkflowEnabled,\n    } = this.props;\n\n    if (collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n\n    if (isEditorialWorkflowEnabled && !unpublishedEntriesLoaded) {\n      loadUnpublishedEntries(collections);\n    }\n  }\n\n  componentDidUpdate(prevProps) {\n    const {\n      collection,\n      collections,\n      entriesLoaded,\n      loadEntries,\n      unpublishedEntriesLoaded,\n      loadUnpublishedEntries,\n      isEditorialWorkflowEnabled,\n    } = this.props;\n\n    if (collection !== prevProps.collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n\n    if (\n      isEditorialWorkflowEnabled &&\n      (!unpublishedEntriesLoaded || collection !== prevProps.collection)\n    ) {\n      loadUnpublishedEntries(collections);\n    }\n  }\n\n  handleCursorActions = (cursor, action) => {\n    const { collection, traverseCollectionCursor } = this.props;\n    traverseCollectionCursor(collection, action);\n  };\n\n  render() {\n    const {\n      collection,\n      entries,\n      groups,\n      isFetching,\n      viewStyle,\n      cursor,\n      page,\n      t,\n      getWorkflowStatus,\n      getUnpublishedEntries,\n      filterTerm,\n    } = this.props;\n\n    const EntriesToRender = ({ entries }) => {\n      return (\n        <Entries\n          collections={collection}\n          entries={entries}\n          isFetching={isFetching}\n          collectionName={collection.get('label')}\n          viewStyle={viewStyle}\n          cursor={cursor}\n          handleCursorActions={partial(this.handleCursorActions, cursor)}\n          page={page}\n          getWorkflowStatus={getWorkflowStatus}\n          getUnpublishedEntries={getUnpublishedEntries}\n          filterTerm={filterTerm}\n        />\n      );\n    };\n\n    if (groups && groups.length > 0) {\n      return withGroups(groups, entries, EntriesToRender, t);\n    }\n\n    return <EntriesToRender entries={entries} />;\n  }\n}\n\nexport function filterNestedEntries(path, collectionFolder, entries, subfolders) {\n  const filtered = entries.filter(e => {\n    let entryPath = e.get('path').slice(collectionFolder.length + 1);\n    if (!entryPath.startsWith(path)) {\n      return false;\n    }\n\n    // for subdirectories, trim off the parent folder corresponding to\n    // this nested collection entry\n    if (path) {\n      entryPath = entryPath.slice(path.length + 1);\n    }\n\n    // if subfolders legacy mode is enabled, show only immediate subfolders\n    // also show index file in root folder\n    if (subfolders) {\n      const depth = entryPath.split('/').length;\n      return path ? depth === 2 : depth <= 2;\n    }\n\n    // only show immediate children\n    return !entryPath.includes('/');\n  });\n  return filtered;\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection, viewStyle, filterTerm } = ownProps;\n  const page = state.entries.getIn(['pages', collection.get('name'), 'page']);\n\n  const collections = state.collections;\n\n  let entries = selectEntries(state.entries, collection);\n  const groups = selectGroups(state.entries, collection);\n\n  if (collection.has('nested')) {\n    const collectionFolder = collection.get('folder');\n    entries = filterNestedEntries(\n      filterTerm || '',\n      collectionFolder,\n      entries,\n      collection.get('nested').get('subfolders') !== false,\n    );\n  }\n  const entriesLoaded = selectEntriesLoaded(state.entries, collection.get('name'));\n  const isFetching = selectIsFetching(state.entries, collection.get('name'));\n\n  const rawCursor = selectCollectionEntriesCursor(state.cursors, collection.get('name'));\n  const cursor = Cursor.create(rawCursor).clearData();\n\n  const isEditorialWorkflowEnabled = state.config?.publish_mode === 'editorial_workflow';\n  const unpublishedEntriesLoaded = isEditorialWorkflowEnabled\n    ? !!state.editorialWorkflow?.getIn(['pages', 'ids'], false)\n    : true;\n\n  return {\n    collection,\n    collections,\n    page,\n    entries,\n    groups,\n    entriesLoaded,\n    isFetching,\n    viewStyle,\n    cursor,\n    unpublishedEntriesLoaded,\n    isEditorialWorkflowEnabled,\n    getWorkflowStatus: (collectionName, slug) => {\n      const unpublishedEntry = selectUnpublishedEntry(state, collectionName, slug);\n      return unpublishedEntry ? unpublishedEntry.get('status') : null;\n    },\n    getUnpublishedEntries: collectionName => {\n      if (!isEditorialWorkflowEnabled) return [];\n\n      const allStatuses = ['draft', 'pending_review', 'pending_publish'];\n      const unpublishedEntries = [];\n\n      allStatuses.forEach(statusKey => {\n        const entriesForStatus = selectUnpublishedEntriesByStatus(state, statusKey);\n        if (entriesForStatus) {\n          entriesForStatus.forEach(entry => {\n            if (entry.get('collection') === collectionName) {\n              const entryWithCollection = entry.set('collection', collectionName);\n              unpublishedEntries.push(entryWithCollection);\n            }\n          });\n        }\n      });\n\n      return unpublishedEntries;\n    },\n  };\n}\n\nconst mapDispatchToProps = {\n  loadEntries: actionLoadEntries,\n  traverseCollectionCursor: actionTraverseCollectionCursor,\n  loadUnpublishedEntries: collections => loadUnpublishedEntries(collections),\n};\n\nconst ConnectedEntriesCollection = connect(mapStateToProps, mapDispatchToProps)(EntriesCollection);\n\nexport default translate()(ConnectedEntriesCollection);\n"]} */"));
+const GroupContainer = /*#__PURE__*/_styled("div", {
+  target: "e13tmaqg0",
+  label: "GroupContainer"
+})(process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../src/components/Collection/Entries/EntriesCollection.js"],"names":[],"mappings":"AAiCiC","file":"../../../../../src/components/Collection/Entries/EntriesCollection.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport { connect } from 'react-redux';\nimport styled from '@emotion/styled';\nimport { translate } from 'react-polyglot';\nimport partial from 'lodash/partial';\nimport { Cursor } from 'decap-cms-lib-util';\nimport { colors } from 'decap-cms-ui-default';\n\nimport {\n  loadEntries as actionLoadEntries,\n  traverseCollectionCursor as actionTraverseCollectionCursor,\n} from '../../../actions/entries';\nimport { loadUnpublishedEntries } from '../../../actions/editorialWorkflow';\nimport {\n  selectEntries,\n  selectEntriesLoaded,\n  selectIsFetching,\n  selectGroups,\n} from '../../../reducers/entries';\nimport { selectUnpublishedEntry, selectUnpublishedEntriesByStatus } from '../../../reducers';\nimport { selectCollectionEntriesCursor } from '../../../reducers/cursors';\nimport Entries from './Entries';\n\nconst GroupHeading = styled.h2`\n  font-size: 22px;\n  font-weight: 600;\n  line-height: 37px;\n  padding-inline-start: 20px;\n  color: ${colors.textLead};\n`;\n\nconst GroupContainer = styled.div``;\n\nfunction getGroupEntries(entries, paths) {\n  return entries.filter(entry => paths.has(entry.get('path')));\n}\n\nfunction getGroupTitle(group, t) {\n  const { label, value } = group;\n  if (value === undefined) {\n    return t('collection.groups.other');\n  }\n  if (typeof value === 'boolean') {\n    return value ? label : t('collection.groups.negateLabel', { label });\n  }\n  return `${label} ${value}`.trim();\n}\n\nfunction withGroups(groups, entries, EntriesToRender, t) {\n  return groups.map(group => {\n    const title = getGroupTitle(group, t);\n    return (\n      <GroupContainer key={group.id} id={group.id}>\n        <GroupHeading>{title}</GroupHeading>\n        <EntriesToRender entries={getGroupEntries(entries, group.paths)} />\n      </GroupContainer>\n    );\n  });\n}\n\nexport class EntriesCollection extends React.Component {\n  static propTypes = {\n    collection: ImmutablePropTypes.map.isRequired,\n    collections: ImmutablePropTypes.iterable,\n    page: PropTypes.number,\n    entries: ImmutablePropTypes.list,\n    groups: PropTypes.array,\n    isFetching: PropTypes.bool.isRequired,\n    viewStyle: PropTypes.string,\n    cursor: PropTypes.object.isRequired,\n    loadEntries: PropTypes.func.isRequired,\n    traverseCollectionCursor: PropTypes.func.isRequired,\n    entriesLoaded: PropTypes.bool,\n    loadUnpublishedEntries: PropTypes.func.isRequired,\n    unpublishedEntriesLoaded: PropTypes.bool,\n    isEditorialWorkflowEnabled: PropTypes.bool,\n    getWorkflowStatus: PropTypes.func.isRequired,\n    getUnpublishedEntries: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(EntriesCollection.propTypes, this.props, 'prop', 'EntriesCollection');\n\n    const {\n      collection,\n      collections,\n      entriesLoaded,\n      loadEntries,\n      unpublishedEntriesLoaded,\n      loadUnpublishedEntries,\n      isEditorialWorkflowEnabled,\n    } = this.props;\n\n    if (collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n\n    if (isEditorialWorkflowEnabled && !unpublishedEntriesLoaded) {\n      loadUnpublishedEntries(collections);\n    }\n  }\n\n  componentDidUpdate(prevProps) {\n    const {\n      collection,\n      collections,\n      entriesLoaded,\n      loadEntries,\n      unpublishedEntriesLoaded,\n      loadUnpublishedEntries,\n      isEditorialWorkflowEnabled,\n    } = this.props;\n\n    if (collection !== prevProps.collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n\n    if (\n      isEditorialWorkflowEnabled &&\n      (!unpublishedEntriesLoaded || collection !== prevProps.collection)\n    ) {\n      loadUnpublishedEntries(collections);\n    }\n  }\n\n  handleCursorActions = (cursor, action) => {\n    const { collection, traverseCollectionCursor } = this.props;\n    traverseCollectionCursor(collection, action);\n  };\n\n  render() {\n    const {\n      collection,\n      entries,\n      groups,\n      isFetching,\n      viewStyle,\n      cursor,\n      page,\n      t,\n      getWorkflowStatus,\n      getUnpublishedEntries,\n      filterTerm,\n    } = this.props;\n\n    const EntriesToRender = ({ entries }) => {\n      return (\n        <Entries\n          collections={collection}\n          entries={entries}\n          isFetching={isFetching}\n          collectionName={collection.get('label')}\n          viewStyle={viewStyle}\n          cursor={cursor}\n          handleCursorActions={partial(this.handleCursorActions, cursor)}\n          page={page}\n          getWorkflowStatus={getWorkflowStatus}\n          getUnpublishedEntries={getUnpublishedEntries}\n          filterTerm={filterTerm}\n        />\n      );\n    };\n\n    if (groups && groups.length > 0) {\n      return withGroups(groups, entries, EntriesToRender, t);\n    }\n\n    return <EntriesToRender entries={entries} />;\n  }\n}\n\nexport function filterNestedEntries(path, collectionFolder, entries, subfolders) {\n  const filtered = entries.filter(e => {\n    let entryPath = e.get('path').slice(collectionFolder.length + 1);\n    if (!entryPath.startsWith(path)) {\n      return false;\n    }\n\n    // for subdirectories, trim off the parent folder corresponding to\n    // this nested collection entry\n    if (path) {\n      entryPath = entryPath.slice(path.length + 1);\n    }\n\n    // if subfolders legacy mode is enabled, show only immediate subfolders\n    // also show index file in root folder\n    if (subfolders) {\n      const depth = entryPath.split('/').length;\n      return path ? depth === 2 : depth <= 2;\n    }\n\n    // only show immediate children\n    return !entryPath.includes('/');\n  });\n  return filtered;\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collection, viewStyle, filterTerm } = ownProps;\n  const page = state.entries.getIn(['pages', collection.get('name'), 'page']);\n\n  const collections = state.collections;\n\n  let entries = selectEntries(state.entries, collection);\n  const groups = selectGroups(state.entries, collection);\n\n  if (collection.has('nested')) {\n    const collectionFolder = collection.get('folder');\n    entries = filterNestedEntries(\n      filterTerm || '',\n      collectionFolder,\n      entries,\n      collection.get('nested').get('subfolders') !== false,\n    );\n  }\n  const entriesLoaded = selectEntriesLoaded(state.entries, collection.get('name'));\n  const isFetching = selectIsFetching(state.entries, collection.get('name'));\n\n  const rawCursor = selectCollectionEntriesCursor(state.cursors, collection.get('name'));\n  const cursor = Cursor.create(rawCursor).clearData();\n\n  const isEditorialWorkflowEnabled = state.config?.publish_mode === 'editorial_workflow';\n  const unpublishedEntriesLoaded = isEditorialWorkflowEnabled\n    ? !!state.editorialWorkflow?.getIn(['pages', 'ids'], false)\n    : true;\n\n  return {\n    collection,\n    collections,\n    page,\n    entries,\n    groups,\n    entriesLoaded,\n    isFetching,\n    viewStyle,\n    cursor,\n    unpublishedEntriesLoaded,\n    isEditorialWorkflowEnabled,\n    getWorkflowStatus: (collectionName, slug) => {\n      const unpublishedEntry = selectUnpublishedEntry(state, collectionName, slug);\n      return unpublishedEntry ? unpublishedEntry.get('status') : null;\n    },\n    getUnpublishedEntries: collectionName => {\n      if (!isEditorialWorkflowEnabled) return [];\n\n      const allStatuses = ['draft', 'pending_review', 'pending_publish'];\n      const unpublishedEntries = [];\n\n      allStatuses.forEach(statusKey => {\n        const entriesForStatus = selectUnpublishedEntriesByStatus(state, statusKey);\n        if (entriesForStatus) {\n          entriesForStatus.forEach(entry => {\n            if (entry.get('collection') === collectionName) {\n              const entryWithCollection = entry.set('collection', collectionName);\n              unpublishedEntries.push(entryWithCollection);\n            }\n          });\n        }\n      });\n\n      return unpublishedEntries;\n    },\n  };\n}\n\nconst mapDispatchToProps = {\n  loadEntries: actionLoadEntries,\n  traverseCollectionCursor: actionTraverseCollectionCursor,\n  loadUnpublishedEntries: collections => loadUnpublishedEntries(collections),\n};\n\nconst ConnectedEntriesCollection = connect(mapStateToProps, mapDispatchToProps)(EntriesCollection);\n\nexport default translate()(ConnectedEntriesCollection);\n"]} */");
+function getGroupEntries(entries, paths) {
+  return entries.filter(entry => paths.has(entry.get('path')));
+}
+function getGroupTitle(group, t) {
+  const {
+    label,
+    value
+  } = group;
+  if (value === undefined) {
+    return t('collection.groups.other');
+  }
+  if (typeof value === 'boolean') {
+    return value ? label : t('collection.groups.negateLabel', {
+      label
+    });
+  }
+  return `${label} ${value}`.trim();
+}
+function withGroups(groups, entries, EntriesToRender, t) {
+  return groups.map(group => {
+    const title = getGroupTitle(group, t);
+    return ___EmotionJSX(GroupContainer, {
+      key: group.id,
+      id: group.id
+    }, ___EmotionJSX(GroupHeading, null, title), ___EmotionJSX(EntriesToRender, {
+      entries: getGroupEntries(entries, group.paths)
+    }));
+  });
+}
+export class EntriesCollection extends React.Component {
+  static propTypes = {
+    collection: ImmutablePropTypes.map.isRequired,
+    collections: ImmutablePropTypes.iterable,
+    page: PropTypes.number,
+    entries: ImmutablePropTypes.list,
+    groups: PropTypes.array,
+    isFetching: PropTypes.bool.isRequired,
+    viewStyle: PropTypes.string,
+    cursor: PropTypes.object.isRequired,
+    loadEntries: PropTypes.func.isRequired,
+    traverseCollectionCursor: PropTypes.func.isRequired,
+    entriesLoaded: PropTypes.bool,
+    loadUnpublishedEntries: PropTypes.func.isRequired,
+    unpublishedEntriesLoaded: PropTypes.bool,
+    isEditorialWorkflowEnabled: PropTypes.bool,
+    getWorkflowStatus: PropTypes.func.isRequired,
+    getUnpublishedEntries: PropTypes.func.isRequired
+  };
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(EntriesCollection.propTypes, this.props, 'prop', 'EntriesCollection');
+    const {
+      collection,
+      collections,
+      entriesLoaded,
+      loadEntries,
+      unpublishedEntriesLoaded,
+      loadUnpublishedEntries,
+      isEditorialWorkflowEnabled
+    } = this.props;
+    if (collection && !entriesLoaded) {
+      loadEntries(collection);
+    }
+    if (isEditorialWorkflowEnabled && !unpublishedEntriesLoaded) {
+      loadUnpublishedEntries(collections);
+    }
+  }
+  componentDidUpdate(prevProps) {
+    const {
+      collection,
+      collections,
+      entriesLoaded,
+      loadEntries,
+      unpublishedEntriesLoaded,
+      loadUnpublishedEntries,
+      isEditorialWorkflowEnabled
+    } = this.props;
+    if (collection !== prevProps.collection && !entriesLoaded) {
+      loadEntries(collection);
+    }
+    if (isEditorialWorkflowEnabled && (!unpublishedEntriesLoaded || collection !== prevProps.collection)) {
+      loadUnpublishedEntries(collections);
+    }
+  }
+  handleCursorActions = (cursor, action) => {
+    const {
+      collection,
+      traverseCollectionCursor
+    } = this.props;
+    traverseCollectionCursor(collection, action);
+  };
+  render() {
+    const {
+      collection,
+      entries,
+      groups,
+      isFetching,
+      viewStyle,
+      cursor,
+      page,
+      t,
+      getWorkflowStatus,
+      getUnpublishedEntries,
+      filterTerm
+    } = this.props;
+    const EntriesToRender = ({
+      entries
+    }) => {
+      return ___EmotionJSX(Entries, {
+        collections: collection,
+        entries: entries,
+        isFetching: isFetching,
+        collectionName: collection.get('label'),
+        viewStyle: viewStyle,
+        cursor: cursor,
+        handleCursorActions: partial(this.handleCursorActions, cursor),
+        page: page,
+        getWorkflowStatus: getWorkflowStatus,
+        getUnpublishedEntries: getUnpublishedEntries,
+        filterTerm: filterTerm
+      });
+    };
+    if (groups && groups.length > 0) {
+      return withGroups(groups, entries, EntriesToRender, t);
+    }
+    return ___EmotionJSX(EntriesToRender, {
+      entries: entries
+    });
+  }
+}
+export function filterNestedEntries(path, collectionFolder, entries, subfolders) {
+  const filtered = entries.filter(e => {
+    let entryPath = e.get('path').slice(collectionFolder.length + 1);
+    if (!entryPath.startsWith(path)) {
+      return false;
+    }
+
+    // for subdirectories, trim off the parent folder corresponding to
+    // this nested collection entry
+    if (path) {
+      entryPath = entryPath.slice(path.length + 1);
+    }
+
+    // if subfolders legacy mode is enabled, show only immediate subfolders
+    // also show index file in root folder
+    if (subfolders) {
+      const depth = entryPath.split('/').length;
+      return path ? depth === 2 : depth <= 2;
+    }
+
+    // only show immediate children
+    return !entryPath.includes('/');
+  });
+  return filtered;
+}
+function mapStateToProps(state, ownProps) {
+  const {
+    collection,
+    viewStyle,
+    filterTerm
+  } = ownProps;
+  const page = state.entries.getIn(['pages', collection.get('name'), 'page']);
+  const collections = state.collections;
+  let entries = selectEntries(state.entries, collection);
+  const groups = selectGroups(state.entries, collection);
+  if (collection.has('nested')) {
+    const collectionFolder = collection.get('folder');
+    entries = filterNestedEntries(filterTerm || '', collectionFolder, entries, collection.get('nested').get('subfolders') !== false);
+  }
+  const entriesLoaded = selectEntriesLoaded(state.entries, collection.get('name'));
+  const isFetching = selectIsFetching(state.entries, collection.get('name'));
+  const rawCursor = selectCollectionEntriesCursor(state.cursors, collection.get('name'));
+  const cursor = Cursor.create(rawCursor).clearData();
+  const isEditorialWorkflowEnabled = state.config?.publish_mode === 'editorial_workflow';
+  const unpublishedEntriesLoaded = isEditorialWorkflowEnabled ? !!state.editorialWorkflow?.getIn(['pages', 'ids'], false) : true;
+  return {
+    collection,
+    collections,
+    page,
+    entries,
+    groups,
+    entriesLoaded,
+    isFetching,
+    viewStyle,
+    cursor,
+    unpublishedEntriesLoaded,
+    isEditorialWorkflowEnabled,
+    getWorkflowStatus: (collectionName, slug) => {
+      const unpublishedEntry = selectUnpublishedEntry(state, collectionName, slug);
+      return unpublishedEntry ? unpublishedEntry.get('status') : null;
+    },
+    getUnpublishedEntries: collectionName => {
+      if (!isEditorialWorkflowEnabled) return [];
+      const allStatuses = ['draft', 'pending_review', 'pending_publish'];
+      const unpublishedEntries = [];
+      allStatuses.forEach(statusKey => {
+        const entriesForStatus = selectUnpublishedEntriesByStatus(state, statusKey);
+        if (entriesForStatus) {
+          entriesForStatus.forEach(entry => {
+            if (entry.get('collection') === collectionName) {
+              const entryWithCollection = entry.set('collection', collectionName);
+              unpublishedEntries.push(entryWithCollection);
+            }
+          });
+        }
+      });
+      return unpublishedEntries;
+    }
+  };
+}
+const mapDispatchToProps = {
+  loadEntries: actionLoadEntries,
+  traverseCollectionCursor: actionTraverseCollectionCursor,
+  loadUnpublishedEntries: collections => loadUnpublishedEntries(collections)
+};
+const ConnectedEntriesCollection = connect(mapStateToProps, mapDispatchToProps)(EntriesCollection);
+export default translate()(ConnectedEntriesCollection);

package/dist/esm/components/Collection/Entries/EntriesSearch.js

@@ -0,0 +1,113 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import { connect } from 'react-redux';
+import isEqual from 'lodash/isEqual';
+import { Cursor } from 'decap-cms-lib-util';
+import { selectSearchedEntries, selectUnpublishedEntry } from '../../../reducers';
+import { searchEntries as actionSearchEntries, clearSearch as actionClearSearch } from '../../../actions/search';
+import Entries from './Entries';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+class EntriesSearch extends React.Component {
+  static propTypes = {
+    isFetching: PropTypes.bool,
+    searchEntries: PropTypes.func.isRequired,
+    clearSearch: PropTypes.func.isRequired,
+    searchTerm: PropTypes.string.isRequired,
+    collections: ImmutablePropTypes.seq,
+    collectionNames: PropTypes.array,
+    entries: ImmutablePropTypes.list,
+    page: PropTypes.number,
+    getWorkflowStatus: PropTypes.func
+  };
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(EntriesSearch.propTypes, this.props, 'prop', 'EntriesSearch');
+    const {
+      searchTerm,
+      searchEntries,
+      collectionNames
+    } = this.props;
+    searchEntries(searchTerm, collectionNames);
+  }
+  componentDidUpdate(prevProps) {
+    const {
+      searchTerm,
+      collectionNames
+    } = this.props;
+
+    // check if the search parameters are the same
+    if (prevProps.searchTerm === searchTerm && isEqual(prevProps.collectionNames, collectionNames)) return;
+    const {
+      searchEntries
+    } = prevProps;
+    searchEntries(searchTerm, collectionNames);
+  }
+  componentWillUnmount() {
+    this.props.clearSearch();
+  }
+  getCursor = () => {
+    const {
+      page
+    } = this.props;
+    return Cursor.create({
+      actions: isNaN(page) ? [] : ['append_next']
+    });
+  };
+  handleCursorActions = action => {
+    const {
+      page,
+      searchTerm,
+      searchEntries,
+      collectionNames
+    } = this.props;
+    if (action === 'append_next') {
+      const nextPage = page + 1;
+      searchEntries(searchTerm, collectionNames, nextPage);
+    }
+  };
+  render() {
+    const {
+      collections,
+      entries,
+      isFetching,
+      getWorkflowStatus
+    } = this.props;
+    return ___EmotionJSX(Entries, {
+      cursor: this.getCursor(),
+      handleCursorActions: this.handleCursorActions,
+      collections: collections,
+      entries: entries,
+      isFetching: isFetching,
+      getWorkflowStatus: getWorkflowStatus
+    });
+  }
+}
+function mapStateToProps(state, ownProps) {
+  const {
+    searchTerm
+  } = ownProps;
+  const collections = ownProps.collections.toIndexedSeq();
+  const collectionNames = ownProps.collections.keySeq().toArray();
+  const isFetching = state.search.isFetching;
+  const page = state.search.page;
+  const entries = selectSearchedEntries(state, collectionNames);
+  function getWorkflowStatus(collectionName, slug) {
+    const unpublishedEntry = selectUnpublishedEntry(state, collectionName, slug);
+    return unpublishedEntry ? unpublishedEntry.get('status') : null;
+  }
+  return {
+    isFetching,
+    page,
+    collections,
+    collectionNames,
+    entries,
+    searchTerm,
+    getWorkflowStatus
+  };
+}
+const mapDispatchToProps = {
+  searchEntries: actionSearchEntries,
+  clearSearch: actionClearSearch
+};
+export default connect(mapStateToProps, mapDispatchToProps)(EntriesSearch);