decap-cms-core 3.7.1 → 3.8.1

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

@@ -8,18 +8,20 @@ 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: "eucqz2q1",
   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":"AAuB8B","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 {\n  selectEntries,\n  selectEntriesLoaded,\n  selectIsFetching,\n  selectGroups,\n} from '../../../reducers/entries';\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    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  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(EntriesCollection.propTypes, this.props, 'prop', 'EntriesCollection');\n\n    const { collection, entriesLoaded, loadEntries } = this.props;\n    if (collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entriesLoaded, loadEntries } = this.props;\n    if (collection !== prevProps.collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n  }\n\n  handleCursorActions = (cursor, action) => {\n    const { collection, traverseCollectionCursor } = this.props;\n    traverseCollectionCursor(collection, action);\n  };\n\n  render() {\n    const { collection, entries, groups, isFetching, viewStyle, cursor, page, t } = 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        />\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  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  return { collection, page, entries, groups, entriesLoaded, isFetching, viewStyle, cursor };\n}\n\nconst mapDispatchToProps = {\n  loadEntries: actionLoadEntries,\n  traverseCollectionCursor: actionTraverseCollectionCursor,\n};\n\nconst ConnectedEntriesCollection = connect(mapStateToProps, mapDispatchToProps)(EntriesCollection);\n\nexport default translate()(ConnectedEntriesCollection);\n"]} */"));
+})("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: "eucqz2q0",
   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":"AA+BiC","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 {\n  selectEntries,\n  selectEntriesLoaded,\n  selectIsFetching,\n  selectGroups,\n} from '../../../reducers/entries';\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    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  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(EntriesCollection.propTypes, this.props, 'prop', 'EntriesCollection');\n\n    const { collection, entriesLoaded, loadEntries } = this.props;\n    if (collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n  }\n\n  componentDidUpdate(prevProps) {\n    const { collection, entriesLoaded, loadEntries } = this.props;\n    if (collection !== prevProps.collection && !entriesLoaded) {\n      loadEntries(collection);\n    }\n  }\n\n  handleCursorActions = (cursor, action) => {\n    const { collection, traverseCollectionCursor } = this.props;\n    traverseCollectionCursor(collection, action);\n  };\n\n  render() {\n    const { collection, entries, groups, isFetching, viewStyle, cursor, page, t } = 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        />\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  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  return { collection, page, entries, groups, entriesLoaded, isFetching, viewStyle, cursor };\n}\n\nconst mapDispatchToProps = {\n  loadEntries: actionLoadEntries,\n  traverseCollectionCursor: actionTraverseCollectionCursor,\n};\n\nconst ConnectedEntriesCollection = connect(mapStateToProps, mapDispatchToProps)(EntriesCollection);\n\nexport default translate()(ConnectedEntriesCollection);\n"]} */");
+})(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')));
 }
@@ -52,6 +54,7 @@ function withGroups(groups, entries, EntriesToRender, t) {
 export class EntriesCollection extends React.Component {
   static propTypes = {
     collection: ImmutablePropTypes.map.isRequired,
+    collections: ImmutablePropTypes.iterable,
     page: PropTypes.number,
     entries: ImmutablePropTypes.list,
     groups: PropTypes.array,
@@ -60,29 +63,48 @@ export class EntriesCollection extends React.Component {
     cursor: PropTypes.object.isRequired,
     loadEntries: PropTypes.func.isRequired,
     traverseCollectionCursor: PropTypes.func.isRequired,
-    entriesLoaded: PropTypes.bool
+    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
+      loadEntries,
+      unpublishedEntriesLoaded,
+      loadUnpublishedEntries,
+      isEditorialWorkflowEnabled
     } = this.props;
     if (collection && !entriesLoaded) {
       loadEntries(collection);
     }
+    if (isEditorialWorkflowEnabled && !unpublishedEntriesLoaded) {
+      loadUnpublishedEntries(collections);
+    }
   }
   componentDidUpdate(prevProps) {
     const {
       collection,
+      collections,
       entriesLoaded,
-      loadEntries
+      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 {
@@ -100,7 +122,10 @@ export class EntriesCollection extends React.Component {
       viewStyle,
       cursor,
       page,
-      t
+      t,
+      getWorkflowStatus,
+      getUnpublishedEntries,
+      filterTerm
     } = this.props;
     const EntriesToRender = ({
       entries
@@ -113,7 +138,10 @@ export class EntriesCollection extends React.Component {
         viewStyle: viewStyle,
         cursor: cursor,
         handleCursorActions: partial(this.handleCursorActions, cursor),
-        page: page
+        page: page,
+        getWorkflowStatus: getWorkflowStatus,
+        getUnpublishedEntries: getUnpublishedEntries,
+        filterTerm: filterTerm
       });
     };
     if (groups && groups.length > 0) {
@@ -156,6 +184,7 @@ function mapStateToProps(state, ownProps) {
     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')) {
@@ -166,20 +195,47 @@ function mapStateToProps(state, ownProps) {
   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
+    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
+  traverseCollectionCursor: actionTraverseCollectionCursor,
+  loadUnpublishedEntries: collections => loadUnpublishedEntries(collections)
 };
 const ConnectedEntriesCollection = connect(mapStateToProps, mapDispatchToProps)(EntriesCollection);
 export default translate()(ConnectedEntriesCollection);

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

@@ -4,7 +4,7 @@ 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 } from '../../../reducers';
+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";
@@ -17,7 +17,8 @@ class EntriesSearch extends React.Component {
     collections: ImmutablePropTypes.seq,
     collectionNames: PropTypes.array,
     entries: ImmutablePropTypes.list,
-    page: PropTypes.number
+    page: PropTypes.number,
+    getWorkflowStatus: PropTypes.func
   };
   componentDidMount() {
     // Manually validate PropTypes - React 19 breaking change
@@ -69,14 +70,16 @@ class EntriesSearch extends React.Component {
     const {
       collections,
       entries,
-      isFetching
+      isFetching,
+      getWorkflowStatus
     } = this.props;
     return ___EmotionJSX(Entries, {
       cursor: this.getCursor(),
       handleCursorActions: this.handleCursorActions,
       collections: collections,
       entries: entries,
-      isFetching: isFetching
+      isFetching: isFetching,
+      getWorkflowStatus: getWorkflowStatus
     });
   }
 }
@@ -89,13 +92,18 @@ function mapStateToProps(state, ownProps) {
   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
+    searchTerm,
+    getWorkflowStatus
   };
 }
 const mapDispatchToProps = {