@pranaysahith/decap-cms-core 3.9.1

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

@@ -0,0 +1,198 @@
+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 PropTypes from 'prop-types';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import { connect } from 'react-redux';
+import { translate } from 'react-polyglot';
+import { lengths, components } from 'decap-cms-ui-default';
+import { getNewEntryUrl } from '../../lib/urlHelper';
+import Sidebar from './Sidebar';
+import CollectionTop from './CollectionTop';
+import EntriesCollection from './Entries/EntriesCollection';
+import EntriesSearch from './Entries/EntriesSearch';
+import CollectionControls from './CollectionControls';
+import { sortByField, filterByField, changeViewStyle, groupByField } from '../../actions/entries';
+import { selectSortableFields, selectViewFilters, selectViewGroups } from '../../reducers/collections';
+import { selectEntriesSort, selectEntriesFilter, selectEntriesGroup, selectViewStyle } from '../../reducers/entries';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const CollectionContainer = /*#__PURE__*/_styled("div", {
+  target: "ey8o4xe3",
+  label: "CollectionContainer"
+})("margin:", lengths.pageMargin, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/Collection.js"],"names":[],"mappings":"AA2BsC","file":"../../../../src/components/Collection/Collection.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { translate } from 'react-polyglot';\nimport { lengths, components } from 'decap-cms-ui-default';\n\nimport { getNewEntryUrl } from '../../lib/urlHelper';\nimport Sidebar from './Sidebar';\nimport CollectionTop from './CollectionTop';\nimport EntriesCollection from './Entries/EntriesCollection';\nimport EntriesSearch from './Entries/EntriesSearch';\nimport CollectionControls from './CollectionControls';\nimport { sortByField, filterByField, changeViewStyle, groupByField } from '../../actions/entries';\nimport {\n  selectSortableFields,\n  selectViewFilters,\n  selectViewGroups,\n} from '../../reducers/collections';\nimport {\n  selectEntriesSort,\n  selectEntriesFilter,\n  selectEntriesGroup,\n  selectViewStyle,\n} from '../../reducers/entries';\n\nconst CollectionContainer = styled.div`\n  margin: ${lengths.pageMargin};\n`;\n\nconst CollectionMain = styled.main`\n  padding-left: 280px;\n`;\n\nconst SearchResultContainer = styled.div`\n  ${components.cardTop};\n  margin-bottom: 22px;\n`;\n\nconst SearchResultHeading = styled.h1`\n  ${components.cardTopHeading};\n`;\n\nexport class Collection extends React.Component {\n  static propTypes = {\n    searchTerm: PropTypes.string,\n    collectionName: PropTypes.string,\n    isSearchResults: PropTypes.bool,\n    isSingleSearchResult: PropTypes.bool,\n    collection: ImmutablePropTypes.map.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    sortableFields: PropTypes.array,\n    sort: ImmutablePropTypes.orderedMap,\n    onSortClick: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(Collection.propTypes, this.props, 'prop', 'Collection');\n  }\n\n  renderEntriesCollection = () => {\n    const { collection, filterTerm, viewStyle } = this.props;\n    return (\n      <EntriesCollection collection={collection} viewStyle={viewStyle} filterTerm={filterTerm} />\n    );\n  };\n\n  renderEntriesSearch = () => {\n    const { searchTerm, collections, collection, isSingleSearchResult } = this.props;\n    return (\n      <EntriesSearch\n        collections={isSingleSearchResult ? collections.filter(c => c === collection) : collections}\n        searchTerm={searchTerm}\n      />\n    );\n  };\n\n  render() {\n    const {\n      collection,\n      collections,\n      collectionName,\n      isSearchEnabled,\n      isSearchResults,\n      isSingleSearchResult,\n      searchTerm,\n      sortableFields,\n      onSortClick,\n      sort,\n      viewFilters,\n      viewGroups,\n      filterTerm,\n      t,\n      onFilterClick,\n      onGroupClick,\n      filter,\n      group,\n      onChangeViewStyle,\n      viewStyle,\n    } = this.props;\n\n    let newEntryUrl = collection.get('create') ? getNewEntryUrl(collectionName) : '';\n    if (newEntryUrl && filterTerm) {\n      newEntryUrl = getNewEntryUrl(collectionName);\n      if (filterTerm) {\n        newEntryUrl = `${newEntryUrl}?path=${filterTerm}`;\n      }\n    }\n\n    const searchResultKey =\n      'collection.collectionTop.searchResults' + (isSingleSearchResult ? 'InCollection' : '');\n\n    return (\n      <CollectionContainer>\n        <Sidebar\n          collections={collections}\n          collection={(!isSearchResults || isSingleSearchResult) && collection}\n          isSearchEnabled={isSearchEnabled}\n          searchTerm={searchTerm}\n          filterTerm={filterTerm}\n        />\n        <CollectionMain>\n          {isSearchResults ? (\n            <SearchResultContainer>\n              <SearchResultHeading>\n                {t(searchResultKey, { searchTerm, collection: collection.get('label') })}\n              </SearchResultHeading>\n            </SearchResultContainer>\n          ) : (\n            <>\n              <CollectionTop collection={collection} newEntryUrl={newEntryUrl} />\n              <CollectionControls\n                viewStyle={viewStyle}\n                onChangeViewStyle={onChangeViewStyle}\n                sortableFields={sortableFields}\n                onSortClick={onSortClick}\n                sort={sort}\n                viewFilters={viewFilters}\n                viewGroups={viewGroups}\n                t={t}\n                onFilterClick={onFilterClick}\n                onGroupClick={onGroupClick}\n                filter={filter}\n                group={group}\n              />\n            </>\n          )}\n          {isSearchResults ? this.renderEntriesSearch() : this.renderEntriesCollection()}\n        </CollectionMain>\n      </CollectionContainer>\n    );\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collections } = state;\n  const isSearchEnabled = state.config && state.config.search != false;\n  const { isSearchResults, match, t } = ownProps;\n  const { name, searchTerm = '', filterTerm = '' } = match.params;\n  const collection = name ? collections.get(name) : collections.first();\n  const sort = selectEntriesSort(state.entries, collection.get('name'));\n  const sortableFields = selectSortableFields(collection, t);\n  const viewFilters = selectViewFilters(collection);\n  const viewGroups = selectViewGroups(collection);\n  const filter = selectEntriesFilter(state.entries, collection.get('name'));\n  const group = selectEntriesGroup(state.entries, collection.get('name'));\n  const viewStyle = selectViewStyle(state.entries);\n\n  return {\n    collection,\n    collections,\n    collectionName: name,\n    isSearchEnabled,\n    isSearchResults,\n    searchTerm,\n    filterTerm,\n    sort,\n    sortableFields,\n    viewFilters,\n    viewGroups,\n    filter,\n    group,\n    viewStyle,\n  };\n}\n\nconst mapDispatchToProps = {\n  sortByField,\n  filterByField,\n  changeViewStyle,\n  groupByField,\n};\n\nfunction mergeProps(stateProps, dispatchProps, ownProps) {\n  return {\n    ...stateProps,\n    ...ownProps,\n    onSortClick: (key, direction) =>\n      dispatchProps.sortByField(stateProps.collection, key, direction),\n    onFilterClick: filter => dispatchProps.filterByField(stateProps.collection, filter),\n    onGroupClick: group => dispatchProps.groupByField(stateProps.collection, group),\n    onChangeViewStyle: viewStyle => dispatchProps.changeViewStyle(viewStyle),\n  };\n}\n\nconst ConnectedCollection = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Collection);\n\nexport default translate()(ConnectedCollection);\n"]} */"));
+const CollectionMain = /*#__PURE__*/_styled("main", {
+  target: "ey8o4xe2",
+  label: "CollectionMain"
+})(process.env.NODE_ENV === "production" ? {
+  name: "tka7ew",
+  styles: "padding-left:280px"
+} : {
+  name: "tka7ew",
+  styles: "padding-left:280px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/Collection.js"],"names":[],"mappings":"AA+BkC","file":"../../../../src/components/Collection/Collection.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { translate } from 'react-polyglot';\nimport { lengths, components } from 'decap-cms-ui-default';\n\nimport { getNewEntryUrl } from '../../lib/urlHelper';\nimport Sidebar from './Sidebar';\nimport CollectionTop from './CollectionTop';\nimport EntriesCollection from './Entries/EntriesCollection';\nimport EntriesSearch from './Entries/EntriesSearch';\nimport CollectionControls from './CollectionControls';\nimport { sortByField, filterByField, changeViewStyle, groupByField } from '../../actions/entries';\nimport {\n  selectSortableFields,\n  selectViewFilters,\n  selectViewGroups,\n} from '../../reducers/collections';\nimport {\n  selectEntriesSort,\n  selectEntriesFilter,\n  selectEntriesGroup,\n  selectViewStyle,\n} from '../../reducers/entries';\n\nconst CollectionContainer = styled.div`\n  margin: ${lengths.pageMargin};\n`;\n\nconst CollectionMain = styled.main`\n  padding-left: 280px;\n`;\n\nconst SearchResultContainer = styled.div`\n  ${components.cardTop};\n  margin-bottom: 22px;\n`;\n\nconst SearchResultHeading = styled.h1`\n  ${components.cardTopHeading};\n`;\n\nexport class Collection extends React.Component {\n  static propTypes = {\n    searchTerm: PropTypes.string,\n    collectionName: PropTypes.string,\n    isSearchResults: PropTypes.bool,\n    isSingleSearchResult: PropTypes.bool,\n    collection: ImmutablePropTypes.map.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    sortableFields: PropTypes.array,\n    sort: ImmutablePropTypes.orderedMap,\n    onSortClick: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(Collection.propTypes, this.props, 'prop', 'Collection');\n  }\n\n  renderEntriesCollection = () => {\n    const { collection, filterTerm, viewStyle } = this.props;\n    return (\n      <EntriesCollection collection={collection} viewStyle={viewStyle} filterTerm={filterTerm} />\n    );\n  };\n\n  renderEntriesSearch = () => {\n    const { searchTerm, collections, collection, isSingleSearchResult } = this.props;\n    return (\n      <EntriesSearch\n        collections={isSingleSearchResult ? collections.filter(c => c === collection) : collections}\n        searchTerm={searchTerm}\n      />\n    );\n  };\n\n  render() {\n    const {\n      collection,\n      collections,\n      collectionName,\n      isSearchEnabled,\n      isSearchResults,\n      isSingleSearchResult,\n      searchTerm,\n      sortableFields,\n      onSortClick,\n      sort,\n      viewFilters,\n      viewGroups,\n      filterTerm,\n      t,\n      onFilterClick,\n      onGroupClick,\n      filter,\n      group,\n      onChangeViewStyle,\n      viewStyle,\n    } = this.props;\n\n    let newEntryUrl = collection.get('create') ? getNewEntryUrl(collectionName) : '';\n    if (newEntryUrl && filterTerm) {\n      newEntryUrl = getNewEntryUrl(collectionName);\n      if (filterTerm) {\n        newEntryUrl = `${newEntryUrl}?path=${filterTerm}`;\n      }\n    }\n\n    const searchResultKey =\n      'collection.collectionTop.searchResults' + (isSingleSearchResult ? 'InCollection' : '');\n\n    return (\n      <CollectionContainer>\n        <Sidebar\n          collections={collections}\n          collection={(!isSearchResults || isSingleSearchResult) && collection}\n          isSearchEnabled={isSearchEnabled}\n          searchTerm={searchTerm}\n          filterTerm={filterTerm}\n        />\n        <CollectionMain>\n          {isSearchResults ? (\n            <SearchResultContainer>\n              <SearchResultHeading>\n                {t(searchResultKey, { searchTerm, collection: collection.get('label') })}\n              </SearchResultHeading>\n            </SearchResultContainer>\n          ) : (\n            <>\n              <CollectionTop collection={collection} newEntryUrl={newEntryUrl} />\n              <CollectionControls\n                viewStyle={viewStyle}\n                onChangeViewStyle={onChangeViewStyle}\n                sortableFields={sortableFields}\n                onSortClick={onSortClick}\n                sort={sort}\n                viewFilters={viewFilters}\n                viewGroups={viewGroups}\n                t={t}\n                onFilterClick={onFilterClick}\n                onGroupClick={onGroupClick}\n                filter={filter}\n                group={group}\n              />\n            </>\n          )}\n          {isSearchResults ? this.renderEntriesSearch() : this.renderEntriesCollection()}\n        </CollectionMain>\n      </CollectionContainer>\n    );\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collections } = state;\n  const isSearchEnabled = state.config && state.config.search != false;\n  const { isSearchResults, match, t } = ownProps;\n  const { name, searchTerm = '', filterTerm = '' } = match.params;\n  const collection = name ? collections.get(name) : collections.first();\n  const sort = selectEntriesSort(state.entries, collection.get('name'));\n  const sortableFields = selectSortableFields(collection, t);\n  const viewFilters = selectViewFilters(collection);\n  const viewGroups = selectViewGroups(collection);\n  const filter = selectEntriesFilter(state.entries, collection.get('name'));\n  const group = selectEntriesGroup(state.entries, collection.get('name'));\n  const viewStyle = selectViewStyle(state.entries);\n\n  return {\n    collection,\n    collections,\n    collectionName: name,\n    isSearchEnabled,\n    isSearchResults,\n    searchTerm,\n    filterTerm,\n    sort,\n    sortableFields,\n    viewFilters,\n    viewGroups,\n    filter,\n    group,\n    viewStyle,\n  };\n}\n\nconst mapDispatchToProps = {\n  sortByField,\n  filterByField,\n  changeViewStyle,\n  groupByField,\n};\n\nfunction mergeProps(stateProps, dispatchProps, ownProps) {\n  return {\n    ...stateProps,\n    ...ownProps,\n    onSortClick: (key, direction) =>\n      dispatchProps.sortByField(stateProps.collection, key, direction),\n    onFilterClick: filter => dispatchProps.filterByField(stateProps.collection, filter),\n    onGroupClick: group => dispatchProps.groupByField(stateProps.collection, group),\n    onChangeViewStyle: viewStyle => dispatchProps.changeViewStyle(viewStyle),\n  };\n}\n\nconst ConnectedCollection = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Collection);\n\nexport default translate()(ConnectedCollection);\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+const SearchResultContainer = /*#__PURE__*/_styled("div", {
+  target: "ey8o4xe1",
+  label: "SearchResultContainer"
+})(components.cardTop, ";margin-bottom:22px;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/Collection.js"],"names":[],"mappings":"AAmCwC","file":"../../../../src/components/Collection/Collection.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { translate } from 'react-polyglot';\nimport { lengths, components } from 'decap-cms-ui-default';\n\nimport { getNewEntryUrl } from '../../lib/urlHelper';\nimport Sidebar from './Sidebar';\nimport CollectionTop from './CollectionTop';\nimport EntriesCollection from './Entries/EntriesCollection';\nimport EntriesSearch from './Entries/EntriesSearch';\nimport CollectionControls from './CollectionControls';\nimport { sortByField, filterByField, changeViewStyle, groupByField } from '../../actions/entries';\nimport {\n  selectSortableFields,\n  selectViewFilters,\n  selectViewGroups,\n} from '../../reducers/collections';\nimport {\n  selectEntriesSort,\n  selectEntriesFilter,\n  selectEntriesGroup,\n  selectViewStyle,\n} from '../../reducers/entries';\n\nconst CollectionContainer = styled.div`\n  margin: ${lengths.pageMargin};\n`;\n\nconst CollectionMain = styled.main`\n  padding-left: 280px;\n`;\n\nconst SearchResultContainer = styled.div`\n  ${components.cardTop};\n  margin-bottom: 22px;\n`;\n\nconst SearchResultHeading = styled.h1`\n  ${components.cardTopHeading};\n`;\n\nexport class Collection extends React.Component {\n  static propTypes = {\n    searchTerm: PropTypes.string,\n    collectionName: PropTypes.string,\n    isSearchResults: PropTypes.bool,\n    isSingleSearchResult: PropTypes.bool,\n    collection: ImmutablePropTypes.map.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    sortableFields: PropTypes.array,\n    sort: ImmutablePropTypes.orderedMap,\n    onSortClick: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(Collection.propTypes, this.props, 'prop', 'Collection');\n  }\n\n  renderEntriesCollection = () => {\n    const { collection, filterTerm, viewStyle } = this.props;\n    return (\n      <EntriesCollection collection={collection} viewStyle={viewStyle} filterTerm={filterTerm} />\n    );\n  };\n\n  renderEntriesSearch = () => {\n    const { searchTerm, collections, collection, isSingleSearchResult } = this.props;\n    return (\n      <EntriesSearch\n        collections={isSingleSearchResult ? collections.filter(c => c === collection) : collections}\n        searchTerm={searchTerm}\n      />\n    );\n  };\n\n  render() {\n    const {\n      collection,\n      collections,\n      collectionName,\n      isSearchEnabled,\n      isSearchResults,\n      isSingleSearchResult,\n      searchTerm,\n      sortableFields,\n      onSortClick,\n      sort,\n      viewFilters,\n      viewGroups,\n      filterTerm,\n      t,\n      onFilterClick,\n      onGroupClick,\n      filter,\n      group,\n      onChangeViewStyle,\n      viewStyle,\n    } = this.props;\n\n    let newEntryUrl = collection.get('create') ? getNewEntryUrl(collectionName) : '';\n    if (newEntryUrl && filterTerm) {\n      newEntryUrl = getNewEntryUrl(collectionName);\n      if (filterTerm) {\n        newEntryUrl = `${newEntryUrl}?path=${filterTerm}`;\n      }\n    }\n\n    const searchResultKey =\n      'collection.collectionTop.searchResults' + (isSingleSearchResult ? 'InCollection' : '');\n\n    return (\n      <CollectionContainer>\n        <Sidebar\n          collections={collections}\n          collection={(!isSearchResults || isSingleSearchResult) && collection}\n          isSearchEnabled={isSearchEnabled}\n          searchTerm={searchTerm}\n          filterTerm={filterTerm}\n        />\n        <CollectionMain>\n          {isSearchResults ? (\n            <SearchResultContainer>\n              <SearchResultHeading>\n                {t(searchResultKey, { searchTerm, collection: collection.get('label') })}\n              </SearchResultHeading>\n            </SearchResultContainer>\n          ) : (\n            <>\n              <CollectionTop collection={collection} newEntryUrl={newEntryUrl} />\n              <CollectionControls\n                viewStyle={viewStyle}\n                onChangeViewStyle={onChangeViewStyle}\n                sortableFields={sortableFields}\n                onSortClick={onSortClick}\n                sort={sort}\n                viewFilters={viewFilters}\n                viewGroups={viewGroups}\n                t={t}\n                onFilterClick={onFilterClick}\n                onGroupClick={onGroupClick}\n                filter={filter}\n                group={group}\n              />\n            </>\n          )}\n          {isSearchResults ? this.renderEntriesSearch() : this.renderEntriesCollection()}\n        </CollectionMain>\n      </CollectionContainer>\n    );\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collections } = state;\n  const isSearchEnabled = state.config && state.config.search != false;\n  const { isSearchResults, match, t } = ownProps;\n  const { name, searchTerm = '', filterTerm = '' } = match.params;\n  const collection = name ? collections.get(name) : collections.first();\n  const sort = selectEntriesSort(state.entries, collection.get('name'));\n  const sortableFields = selectSortableFields(collection, t);\n  const viewFilters = selectViewFilters(collection);\n  const viewGroups = selectViewGroups(collection);\n  const filter = selectEntriesFilter(state.entries, collection.get('name'));\n  const group = selectEntriesGroup(state.entries, collection.get('name'));\n  const viewStyle = selectViewStyle(state.entries);\n\n  return {\n    collection,\n    collections,\n    collectionName: name,\n    isSearchEnabled,\n    isSearchResults,\n    searchTerm,\n    filterTerm,\n    sort,\n    sortableFields,\n    viewFilters,\n    viewGroups,\n    filter,\n    group,\n    viewStyle,\n  };\n}\n\nconst mapDispatchToProps = {\n  sortByField,\n  filterByField,\n  changeViewStyle,\n  groupByField,\n};\n\nfunction mergeProps(stateProps, dispatchProps, ownProps) {\n  return {\n    ...stateProps,\n    ...ownProps,\n    onSortClick: (key, direction) =>\n      dispatchProps.sortByField(stateProps.collection, key, direction),\n    onFilterClick: filter => dispatchProps.filterByField(stateProps.collection, filter),\n    onGroupClick: group => dispatchProps.groupByField(stateProps.collection, group),\n    onChangeViewStyle: viewStyle => dispatchProps.changeViewStyle(viewStyle),\n  };\n}\n\nconst ConnectedCollection = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Collection);\n\nexport default translate()(ConnectedCollection);\n"]} */"));
+const SearchResultHeading = /*#__PURE__*/_styled("h1", {
+  target: "ey8o4xe0",
+  label: "SearchResultHeading"
+})(components.cardTopHeading, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/Collection/Collection.js"],"names":[],"mappings":"AAwCqC","file":"../../../../src/components/Collection/Collection.js","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport ImmutablePropTypes from 'react-immutable-proptypes';\nimport styled from '@emotion/styled';\nimport { connect } from 'react-redux';\nimport { translate } from 'react-polyglot';\nimport { lengths, components } from 'decap-cms-ui-default';\n\nimport { getNewEntryUrl } from '../../lib/urlHelper';\nimport Sidebar from './Sidebar';\nimport CollectionTop from './CollectionTop';\nimport EntriesCollection from './Entries/EntriesCollection';\nimport EntriesSearch from './Entries/EntriesSearch';\nimport CollectionControls from './CollectionControls';\nimport { sortByField, filterByField, changeViewStyle, groupByField } from '../../actions/entries';\nimport {\n  selectSortableFields,\n  selectViewFilters,\n  selectViewGroups,\n} from '../../reducers/collections';\nimport {\n  selectEntriesSort,\n  selectEntriesFilter,\n  selectEntriesGroup,\n  selectViewStyle,\n} from '../../reducers/entries';\n\nconst CollectionContainer = styled.div`\n  margin: ${lengths.pageMargin};\n`;\n\nconst CollectionMain = styled.main`\n  padding-left: 280px;\n`;\n\nconst SearchResultContainer = styled.div`\n  ${components.cardTop};\n  margin-bottom: 22px;\n`;\n\nconst SearchResultHeading = styled.h1`\n  ${components.cardTopHeading};\n`;\n\nexport class Collection extends React.Component {\n  static propTypes = {\n    searchTerm: PropTypes.string,\n    collectionName: PropTypes.string,\n    isSearchResults: PropTypes.bool,\n    isSingleSearchResult: PropTypes.bool,\n    collection: ImmutablePropTypes.map.isRequired,\n    collections: ImmutablePropTypes.map.isRequired,\n    sortableFields: PropTypes.array,\n    sort: ImmutablePropTypes.orderedMap,\n    onSortClick: PropTypes.func.isRequired,\n  };\n\n  componentDidMount() {\n    // Manually validate PropTypes - React 19 breaking change\n    PropTypes.checkPropTypes(Collection.propTypes, this.props, 'prop', 'Collection');\n  }\n\n  renderEntriesCollection = () => {\n    const { collection, filterTerm, viewStyle } = this.props;\n    return (\n      <EntriesCollection collection={collection} viewStyle={viewStyle} filterTerm={filterTerm} />\n    );\n  };\n\n  renderEntriesSearch = () => {\n    const { searchTerm, collections, collection, isSingleSearchResult } = this.props;\n    return (\n      <EntriesSearch\n        collections={isSingleSearchResult ? collections.filter(c => c === collection) : collections}\n        searchTerm={searchTerm}\n      />\n    );\n  };\n\n  render() {\n    const {\n      collection,\n      collections,\n      collectionName,\n      isSearchEnabled,\n      isSearchResults,\n      isSingleSearchResult,\n      searchTerm,\n      sortableFields,\n      onSortClick,\n      sort,\n      viewFilters,\n      viewGroups,\n      filterTerm,\n      t,\n      onFilterClick,\n      onGroupClick,\n      filter,\n      group,\n      onChangeViewStyle,\n      viewStyle,\n    } = this.props;\n\n    let newEntryUrl = collection.get('create') ? getNewEntryUrl(collectionName) : '';\n    if (newEntryUrl && filterTerm) {\n      newEntryUrl = getNewEntryUrl(collectionName);\n      if (filterTerm) {\n        newEntryUrl = `${newEntryUrl}?path=${filterTerm}`;\n      }\n    }\n\n    const searchResultKey =\n      'collection.collectionTop.searchResults' + (isSingleSearchResult ? 'InCollection' : '');\n\n    return (\n      <CollectionContainer>\n        <Sidebar\n          collections={collections}\n          collection={(!isSearchResults || isSingleSearchResult) && collection}\n          isSearchEnabled={isSearchEnabled}\n          searchTerm={searchTerm}\n          filterTerm={filterTerm}\n        />\n        <CollectionMain>\n          {isSearchResults ? (\n            <SearchResultContainer>\n              <SearchResultHeading>\n                {t(searchResultKey, { searchTerm, collection: collection.get('label') })}\n              </SearchResultHeading>\n            </SearchResultContainer>\n          ) : (\n            <>\n              <CollectionTop collection={collection} newEntryUrl={newEntryUrl} />\n              <CollectionControls\n                viewStyle={viewStyle}\n                onChangeViewStyle={onChangeViewStyle}\n                sortableFields={sortableFields}\n                onSortClick={onSortClick}\n                sort={sort}\n                viewFilters={viewFilters}\n                viewGroups={viewGroups}\n                t={t}\n                onFilterClick={onFilterClick}\n                onGroupClick={onGroupClick}\n                filter={filter}\n                group={group}\n              />\n            </>\n          )}\n          {isSearchResults ? this.renderEntriesSearch() : this.renderEntriesCollection()}\n        </CollectionMain>\n      </CollectionContainer>\n    );\n  }\n}\n\nfunction mapStateToProps(state, ownProps) {\n  const { collections } = state;\n  const isSearchEnabled = state.config && state.config.search != false;\n  const { isSearchResults, match, t } = ownProps;\n  const { name, searchTerm = '', filterTerm = '' } = match.params;\n  const collection = name ? collections.get(name) : collections.first();\n  const sort = selectEntriesSort(state.entries, collection.get('name'));\n  const sortableFields = selectSortableFields(collection, t);\n  const viewFilters = selectViewFilters(collection);\n  const viewGroups = selectViewGroups(collection);\n  const filter = selectEntriesFilter(state.entries, collection.get('name'));\n  const group = selectEntriesGroup(state.entries, collection.get('name'));\n  const viewStyle = selectViewStyle(state.entries);\n\n  return {\n    collection,\n    collections,\n    collectionName: name,\n    isSearchEnabled,\n    isSearchResults,\n    searchTerm,\n    filterTerm,\n    sort,\n    sortableFields,\n    viewFilters,\n    viewGroups,\n    filter,\n    group,\n    viewStyle,\n  };\n}\n\nconst mapDispatchToProps = {\n  sortByField,\n  filterByField,\n  changeViewStyle,\n  groupByField,\n};\n\nfunction mergeProps(stateProps, dispatchProps, ownProps) {\n  return {\n    ...stateProps,\n    ...ownProps,\n    onSortClick: (key, direction) =>\n      dispatchProps.sortByField(stateProps.collection, key, direction),\n    onFilterClick: filter => dispatchProps.filterByField(stateProps.collection, filter),\n    onGroupClick: group => dispatchProps.groupByField(stateProps.collection, group),\n    onChangeViewStyle: viewStyle => dispatchProps.changeViewStyle(viewStyle),\n  };\n}\n\nconst ConnectedCollection = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Collection);\n\nexport default translate()(ConnectedCollection);\n"]} */"));
+export class Collection extends React.Component {
+  static propTypes = {
+    searchTerm: PropTypes.string,
+    collectionName: PropTypes.string,
+    isSearchResults: PropTypes.bool,
+    isSingleSearchResult: PropTypes.bool,
+    collection: ImmutablePropTypes.map.isRequired,
+    collections: ImmutablePropTypes.map.isRequired,
+    sortableFields: PropTypes.array,
+    sort: ImmutablePropTypes.orderedMap,
+    onSortClick: PropTypes.func.isRequired
+  };
+  componentDidMount() {
+    // Manually validate PropTypes - React 19 breaking change
+    PropTypes.checkPropTypes(Collection.propTypes, this.props, 'prop', 'Collection');
+  }
+  renderEntriesCollection = () => {
+    const {
+      collection,
+      filterTerm,
+      viewStyle
+    } = this.props;
+    return ___EmotionJSX(EntriesCollection, {
+      collection: collection,
+      viewStyle: viewStyle,
+      filterTerm: filterTerm
+    });
+  };
+  renderEntriesSearch = () => {
+    const {
+      searchTerm,
+      collections,
+      collection,
+      isSingleSearchResult
+    } = this.props;
+    return ___EmotionJSX(EntriesSearch, {
+      collections: isSingleSearchResult ? collections.filter(c => c === collection) : collections,
+      searchTerm: searchTerm
+    });
+  };
+  render() {
+    const {
+      collection,
+      collections,
+      collectionName,
+      isSearchEnabled,
+      isSearchResults,
+      isSingleSearchResult,
+      searchTerm,
+      sortableFields,
+      onSortClick,
+      sort,
+      viewFilters,
+      viewGroups,
+      filterTerm,
+      t,
+      onFilterClick,
+      onGroupClick,
+      filter,
+      group,
+      onChangeViewStyle,
+      viewStyle
+    } = this.props;
+    let newEntryUrl = collection.get('create') ? getNewEntryUrl(collectionName) : '';
+    if (newEntryUrl && filterTerm) {
+      newEntryUrl = getNewEntryUrl(collectionName);
+      if (filterTerm) {
+        newEntryUrl = `${newEntryUrl}?path=${filterTerm}`;
+      }
+    }
+    const searchResultKey = 'collection.collectionTop.searchResults' + (isSingleSearchResult ? 'InCollection' : '');
+    return ___EmotionJSX(CollectionContainer, null, ___EmotionJSX(Sidebar, {
+      collections: collections,
+      collection: (!isSearchResults || isSingleSearchResult) && collection,
+      isSearchEnabled: isSearchEnabled,
+      searchTerm: searchTerm,
+      filterTerm: filterTerm
+    }), ___EmotionJSX(CollectionMain, null, isSearchResults ? ___EmotionJSX(SearchResultContainer, null, ___EmotionJSX(SearchResultHeading, null, t(searchResultKey, {
+      searchTerm,
+      collection: collection.get('label')
+    }))) : ___EmotionJSX(React.Fragment, null, ___EmotionJSX(CollectionTop, {
+      collection: collection,
+      newEntryUrl: newEntryUrl
+    }), ___EmotionJSX(CollectionControls, {
+      viewStyle: viewStyle,
+      onChangeViewStyle: onChangeViewStyle,
+      sortableFields: sortableFields,
+      onSortClick: onSortClick,
+      sort: sort,
+      viewFilters: viewFilters,
+      viewGroups: viewGroups,
+      t: t,
+      onFilterClick: onFilterClick,
+      onGroupClick: onGroupClick,
+      filter: filter,
+      group: group
+    })), isSearchResults ? this.renderEntriesSearch() : this.renderEntriesCollection()));
+  }
+}
+function mapStateToProps(state, ownProps) {
+  const {
+    collections
+  } = state;
+  const isSearchEnabled = state.config && state.config.search != false;
+  const {
+    isSearchResults,
+    match,
+    t
+  } = ownProps;
+  const {
+    name,
+    searchTerm = '',
+    filterTerm = ''
+  } = match.params;
+  const collection = name ? collections.get(name) : collections.first();
+  const sort = selectEntriesSort(state.entries, collection.get('name'));
+  const sortableFields = selectSortableFields(collection, t);
+  const viewFilters = selectViewFilters(collection);
+  const viewGroups = selectViewGroups(collection);
+  const filter = selectEntriesFilter(state.entries, collection.get('name'));
+  const group = selectEntriesGroup(state.entries, collection.get('name'));
+  const viewStyle = selectViewStyle(state.entries);
+  return {
+    collection,
+    collections,
+    collectionName: name,
+    isSearchEnabled,
+    isSearchResults,
+    searchTerm,
+    filterTerm,
+    sort,
+    sortableFields,
+    viewFilters,
+    viewGroups,
+    filter,
+    group,
+    viewStyle
+  };
+}
+const mapDispatchToProps = {
+  sortByField,
+  filterByField,
+  changeViewStyle,
+  groupByField
+};
+function mergeProps(stateProps, dispatchProps, ownProps) {
+  return {
+    ...stateProps,
+    ...ownProps,
+    onSortClick: (key, direction) => dispatchProps.sortByField(stateProps.collection, key, direction),
+    onFilterClick: filter => dispatchProps.filterByField(stateProps.collection, filter),
+    onGroupClick: group => dispatchProps.groupByField(stateProps.collection, group),
+    onChangeViewStyle: viewStyle => dispatchProps.changeViewStyle(viewStyle)
+  };
+}
+const ConnectedCollection = connect(mapStateToProps, mapDispatchToProps, mergeProps)(Collection);
+export default translate()(ConnectedCollection);

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

@@ -0,0 +1,46 @@
+import _styled from "@emotion/styled/base";
+import React from 'react';
+import { lengths } from 'decap-cms-ui-default';
+import ViewStyleControl from './ViewStyleControl';
+import SortControl from './SortControl';
+import FilterControl from './FilterControl';
+import GroupControl from './GroupControl';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+const CollectionControlsContainer = /*#__PURE__*/_styled("div", {
+  target: "e1hlhag20",
+  label: "CollectionControlsContainer"
+})("display:flex;align-items:center;flex-direction:row-reverse;margin-top:22px;width:", lengths.topCardWidth, ";max-width:100%;&>div{margin-left:6px;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+function CollectionControls({
+  viewStyle,
+  onChangeViewStyle,
+  sortableFields,
+  onSortClick,
+  sort,
+  viewFilters,
+  viewGroups,
+  onFilterClick,
+  onGroupClick,
+  t,
+  filter,
+  group
+}) {
+  return ___EmotionJSX(CollectionControlsContainer, null, ___EmotionJSX(ViewStyleControl, {
+    viewStyle: viewStyle,
+    onChangeViewStyle: onChangeViewStyle
+  }), viewGroups.length > 0 && ___EmotionJSX(GroupControl, {
+    viewGroups: viewGroups,
+    onGroupClick: onGroupClick,
+    t: t,
+    group: group
+  }), viewFilters.length > 0 && ___EmotionJSX(FilterControl, {
+    viewFilters: viewFilters,
+    onFilterClick: onFilterClick,
+    t: t,
+    filter: filter
+  }), sortableFields.length > 0 && ___EmotionJSX(SortControl, {
+    fields: sortableFields,
+    sort: sort,
+    onSortClick: onSortClick
+  }));
+}
+export default CollectionControls;