decap-cms-core 3.9.0 → 3.10.1

package/dist/esm/lib/indexFileHelper.js

@@ -0,0 +1,36 @@
+/**
+ * Determines if a file slug matches the index file pattern for a collection.
+ * @param filePath - The file slug or path to check
+ * @param pattern - The regex pattern from the collection's index_file config
+ * @param nested - Whether the collection is nested (affects how the slug is extracted)
+ * @returns True if the file matches the index file pattern
+ */
+export function isIndexFile(filePath, pattern, nested) {
+  const fileSlug = nested ? filePath?.split('/').pop() : filePath;
+  return !!(fileSlug && new RegExp(pattern).test(fileSlug));
+}
+
+/**
+ * Determines if an entry is an index file entry.
+ * Checks both the meta.path_type field (set by the backend) and the slug pattern.
+ * @param entry - The entry to check
+ * @param collection - The collection configuration containing index_file pattern
+ * @returns True if the entry is an index file
+ */
+export function isIndexFileEntry(entry, collection) {
+  if (!entry) {
+    return false;
+  }
+  const pathType = entry.getIn(['meta', 'path_type']);
+  if (pathType === 'index') {
+    return true;
+  }
+  const indexFileConfig = collection.get('index_file');
+  if (!indexFileConfig) {
+    return false;
+  }
+  const slug = entry.get('slug');
+  const pattern = indexFileConfig.get('pattern');
+  const nested = !!collection.get('nested');
+  return isIndexFile(slug, pattern, nested);
+}

package/dist/esm/reducers/collections.js

@@ -305,32 +305,58 @@ export function selectDefaultSortableFields(collection, backend, hasIntegration)
     // always have commit date by default
     defaultSortable = [COMMIT_DATE, ...defaultSortable];
   }
-  return defaultSortable;
+
+  // Return as objects with field property
+  return defaultSortable.map(field => ({
+    field
+  }));
 }
 export function selectSortableFields(collection, t) {
-  const fields = collection.get('sortable_fields').toArray().map(key => {
+  const fields = collection.get('sortable_fields').toArray().map(sortableField => {
+    // Extract the field name and custom label from the sortable field object
+    const key = sortableField.get('field');
+    const customLabel = sortableField.get('label');
     if (key === COMMIT_DATE) {
+      const label = customLabel || t('collection.defaultFields.updatedOn.label');
       return {
         key,
         field: {
           name: key,
-          label: t('collection.defaultFields.updatedOn.label')
+          label
         }
       };
     }
     const field = selectField(collection, key);
     if (key === COMMIT_AUTHOR && !field) {
+      const label = customLabel || t('collection.defaultFields.author.label');
       return {
         key,
         field: {
           name: key,
-          label: t('collection.defaultFields.author.label')
+          label
         }
       };
     }
+    let fieldObj = field?.toJS();
+
+    // If custom label is provided, override the field's label
+    if (fieldObj && customLabel) {
+      fieldObj = {
+        ...fieldObj,
+        label: customLabel
+      };
+    }
+
+    // If no label exists at all, use the field name
+    if (fieldObj && !fieldObj.label) {
+      fieldObj = {
+        ...fieldObj,
+        label: fieldObj.name || key
+      };
+    }
     return {
       key,
-      field: field?.toJS()
+      field: fieldObj
     };
   }).filter(item => !!item.field).map(item => ({
     ...item.field,
@@ -338,6 +364,29 @@ export function selectSortableFields(collection, t) {
   }));
   return fields;
 }
+export function selectDefaultSortField(collection) {
+  const sortableFields = collection.get('sortable_fields').toArray();
+  const defaultField = sortableFields.find(field => field.get('default_sort') !== undefined);
+  if (!defaultField) {
+    return null;
+  }
+  const fieldName = defaultField.get('field');
+  const defaultSortValue = defaultField.get('default_sort');
+
+  // Determine direction based on default_sort value
+  let direction;
+  if (defaultSortValue === true || defaultSortValue === 'asc') {
+    direction = 'asc';
+  } else if (defaultSortValue === 'desc') {
+    direction = 'desc';
+  } else {
+    direction = 'asc'; // fallback
+  }
+  return {
+    field: fieldName,
+    direction
+  };
+}
 export function selectSortDataPath(collection, key) {
   if (key === COMMIT_DATE) {
     return 'updatedOn';

package/dist/esm/reducers/entries.js

@@ -25,6 +25,12 @@ let page;
 let slug;
 const storageSortKey = 'decap-cms.entries.sort';
 const viewStyleKey = 'decap-cms.entries.viewStyle';
+function normalizeDoubleSlashes(path) {
+  if (!path) {
+    return path;
+  }
+  return path.replace(/([^:]\/)\/+/g, '$1');
+}
 const loadSort = once(() => {
   const sortString = localStorage.getItem(storageSortKey);
   if (sortString) {
@@ -544,10 +550,10 @@ export function selectMediaFilePublicPath(config, collection, mediaPath, entryMa
     return mediaPath;
   }
   const name = 'public_folder';
-  let publicFolder = config[name];
+  let publicFolder = normalizeDoubleSlashes(config[name]);
   const customFolder = hasCustomFolder(name, collection, entryMap?.get('slug'), field);
   if (customFolder) {
-    publicFolder = evaluateFolder(name, config, collection, entryMap, field);
+    publicFolder = normalizeDoubleSlashes(evaluateFolder(name, config, collection, entryMap, field));
   }
   if (isAbsolutePath(publicFolder)) {
     return joinUrlPath(publicFolder, basename(mediaPath));

package/index.d.ts

@@ -292,6 +292,12 @@ declare module 'decap-cms-core' {
     pattern?: string;
   }
 
+  export interface SortableField {
+    field: string;
+    label?: string;
+    default_sort?: boolean | 'asc' | 'desc';
+  }
+
   export interface CmsCollection {
     name: string;
     label: string;
@@ -332,7 +338,7 @@ declare module 'decap-cms-core' {
     path?: string;
     media_folder?: string;
     public_folder?: string;
-    sortable_fields?: string[];
+    sortable_fields?: (string | SortableField)[];
     view_filters?: ViewFilter[];
     view_groups?: ViewGroup[];
     i18n?: boolean | CmsI18nConfig;
@@ -340,7 +346,7 @@ declare module 'decap-cms-core' {
     /**
      * @deprecated Use sortable_fields instead
      */
-    sortableFields?: string[];
+    sortableFields?: (string | SortableField)[];
   }
 
   export interface CmsBackend {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-core",
   "description": "Decap CMS core application, see decap-cms package for the main distribution.",
-  "version": "3.9.0",
+  "version": "3.10.1",
   "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-core",
   "bugs": "https://github.com/decaporg/decap-cms/issues",
   "module": "dist/esm/index.js",
@@ -28,7 +28,6 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@vercel/stega": "^0.1.2",
     "buffer": "^6.0.3",
-    "clean-stack": "^5.2.0",
     "copy-text-to-clipboard": "^3.0.0",
     "dayjs": "^1.11.10",
     "deepmerge": "^4.2.2",
@@ -100,5 +99,5 @@
   "browser": {
     "path": "path-browserify"
   },
-  "gitHead": "13afe6686b32f7c03b4819d343d787c63f13664f"
+  "gitHead": "46c6646c68ead2cd982acb236d7aff0356f313ba"
 }

package/src/actions/__tests__/config.spec.js

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import { dump } from 'js-yaml';
+import { stringify } from 'yaml';
 
 import {
   loadConfig,
@@ -480,7 +480,7 @@ describe('config', () => {
       ).toEqual({
         collections: [
           {
-            sortable_fields: ['title'],
+            sortable_fields: [{ field: 'title', default_sort: undefined }],
             folder: 'src',
             type: 'folder_based_collection',
             view_filters: [],
@@ -934,7 +934,7 @@ describe('config', () => {
 
       global.fetch.mockResolvedValue({
         status: 200,
-        text: () => Promise.resolve(dump({ backend: { repo: 'test-repo' } })),
+        text: () => Promise.resolve(stringify({ backend: { repo: 'test-repo' } })),
         headers: new Headers(),
       });
       await loadConfig()(dispatch);
@@ -962,7 +962,7 @@ describe('config', () => {
       document.querySelector.mockReturnValue({ type: 'text/yaml', href: 'custom-config.yml' });
       global.fetch.mockResolvedValue({
         status: 200,
-        text: () => Promise.resolve(dump({ backend: { repo: 'github' } })),
+        text: () => Promise.resolve(stringify({ backend: { repo: 'github' } })),
         headers: new Headers(),
       });
       await loadConfig()(dispatch);

package/src/actions/config.ts

@@ -171,6 +171,20 @@ function hasIntegration(config: CmsConfig, collection: CmsCollection) {
   return !!integration;
 }
 
+function normalizeSortableFields(
+  sortableFields: (
+    | string
+    | { field: string; label?: string; default_sort?: boolean | 'asc' | 'desc' }
+  )[],
+) {
+  return sortableFields.map(field => {
+    if (typeof field === 'string') {
+      return { field, default_sort: undefined };
+    }
+    return field;
+  });
+}
+
 export function normalizeConfig(config: CmsConfig) {
   const { collections = [] } = config;
 
@@ -200,6 +214,14 @@ export function normalizeConfig(config: CmsConfig) {
       );
     }
 
+    // Normalize sortable_fields to consistent object format
+    if (normalizedCollection.sortable_fields) {
+      normalizedCollection = {
+        ...normalizedCollection,
+        sortable_fields: normalizeSortableFields(normalizedCollection.sortable_fields),
+      };
+    }
+
     return normalizedCollection;
   });
 

package/src/actions/entries.ts

@@ -3,7 +3,7 @@ import isEqual from 'lodash/isEqual';
 import { Cursor } from 'decap-cms-lib-util';
 
 import { selectCollectionEntriesCursor } from '../reducers/cursors';
-import { selectFields, updateFieldByKey } from '../reducers/collections';
+import { selectFields, updateFieldByKey, selectDefaultSortField } from '../reducers/collections';
 import { selectIntegration, selectPublishedSlugs } from '../reducers';
 import { getIntegrationProvider } from '../integrations';
 import { currentBackend } from '../backend';
@@ -579,11 +579,21 @@ export function loadEntries(collection: Collection, page = 0) {
     }
     const state = getState();
     const sortFields = selectEntriesSortFields(state.entries, collection.get('name'));
+
+    // If user has already set a sort, use it
     if (sortFields && sortFields.length > 0) {
       const field = sortFields[0];
       return dispatch(sortByField(collection, field.get('key'), field.get('direction')));
     }
 
+    // Otherwise, check for a default sort field in the collection configuration
+    const defaultSort = selectDefaultSortField(collection);
+    if (defaultSort) {
+      const direction =
+        defaultSort.direction === 'desc' ? SortDirection.Descending : SortDirection.Ascending;
+      return dispatch(sortByField(collection, defaultSort.field, direction));
+    }
+
     const backend = currentBackend(state.config);
     const integration = selectIntegration(state, collection.get('name'), 'listEntries');
     const provider = integration

package/src/components/Collection/CollectionControls.js

@@ -36,7 +36,7 @@ function CollectionControls({
 }) {
   return (
     <CollectionControlsContainer>
-      <ViewStyleControl viewStyle={viewStyle} onChangeViewStyle={onChangeViewStyle} />
+      <ViewStyleControl viewStyle={viewStyle} onChangeViewStyle={onChangeViewStyle} t={t} />
       {viewGroups.length > 0 && (
         <GroupControl viewGroups={viewGroups} onGroupClick={onGroupClick} t={t} group={group} />
       )}

package/src/components/Collection/ViewStyleControl.js

@@ -28,16 +28,18 @@ const ViewControlsButton = styled.button`
   }
 `;
 
-function ViewStyleControl({ viewStyle, onChangeViewStyle }) {
+function ViewStyleControl({ viewStyle, onChangeViewStyle, t }) {
   return (
     <ViewControlsSection>
       <ViewControlsButton
+        aria-label={t('collection.collectionTop.viewAsList')}
         isActive={viewStyle === VIEW_STYLE_LIST}
         onClick={() => onChangeViewStyle(VIEW_STYLE_LIST)}
       >
         <Icon type="list" />
       </ViewControlsButton>
       <ViewControlsButton
+        aria-label={t('collection.collectionTop.viewAsGrid')}
         isActive={viewStyle === VIEW_STYLE_GRID}
         onClick={() => onChangeViewStyle(VIEW_STYLE_GRID)}
       >

package/src/components/Editor/EditorControlPane/EditorControl.js

@@ -245,6 +245,7 @@ class EditorControl extends React.Component {
         {({ css, cx }) => (
           <ControlContainer
             className={className}
+            aria-label={t('editor.editorControl.field.widgetLabel', { widgetLabel: widgetName })}
             css={css`
               ${isHidden && styleStrings.hidden};
             `}

package/src/components/MediaLibrary/MediaLibraryHeader.js

@@ -28,10 +28,10 @@ const LibraryTitle = styled.h1`
   color: ${props => props.isPrivate && colors.textFieldBorder};
 `;
 
-function MediaLibraryHeader({ onClose, title, isPrivate }) {
+function MediaLibraryHeader({ onClose, title, isPrivate, t }) {
   return (
     <div>
-      <CloseButton onClick={onClose}>
+      <CloseButton aria-label={t('mediaLibrary.mediaLibraryModal.close')} onClick={onClose}>
         <Icon type="close" />
       </CloseButton>
       <LibraryTitle isPrivate={isPrivate}>{title}</LibraryTitle>

package/src/components/MediaLibrary/MediaLibraryTop.js

@@ -70,6 +70,7 @@ function MediaLibraryTop({
               : t('mediaLibrary.mediaLibraryModal.mediaAssets')
           }`}
           isPrivate={privateUpload}
+          t={t}
         />
         <ButtonsContainer>
           <CopyToClipBoardButton

package/src/components/UI/ErrorBoundary.js

@@ -7,7 +7,6 @@ import truncate from 'lodash/truncate';
 import copyToClipboard from 'copy-text-to-clipboard';
 import { localForage } from 'decap-cms-lib-util';
 import { buttons, colors } from 'decap-cms-ui-default';
-import cleanStack from 'clean-stack';
 
 const ISSUE_URL = 'https://github.com/decaporg/decap-cms/issues/new?';
 
@@ -145,7 +144,7 @@ export class ErrorBoundary extends React.Component {
     console.error(error);
     return {
       hasError: true,
-      errorMessage: cleanStack(error.stack, { basePath: window.location.origin || '' }),
+      errorMessage: error.stack || error.toString(),
       errorTitle: error.toString(),
     };
   }

package/src/components/UI/SettingsDropdown.js

@@ -81,7 +81,7 @@ function SettingsDropdown({ displayUrl, isTestRepo, imageUrl, onLogoutClick, t }
         dropdownWidth="100px"
         dropdownPosition="right"
         renderButton={() => (
-          <AvatarDropdownButton>
+          <AvatarDropdownButton aria-label={t('ui.settingsDropdown.account')}>
             <Avatar imageUrl={imageUrl} />
           </AvatarDropdownButton>
         )}

package/src/constants/__tests__/configSchema.spec.js

@@ -216,6 +216,90 @@ describe('config', () => {
       }).toThrowError("'collections[0]' must NOT be valid");
     });
 
+    it('should allow sortable_fields to have object format with field property', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: [{ field: 'title' }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with default_sort as boolean', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: [{ field: 'title', default_sort: true }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with default_sort as asc/desc', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: ['title', { field: 'date', default_sort: 'desc' }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with custom label', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: [{ field: 'date', label: 'Publish Date' }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with label and default_sort', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [
+              {
+                sortable_fields: [
+                  'title',
+                  { field: 'date', label: 'Publish Date', default_sort: 'desc' },
+                ],
+              },
+            ],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow mixed string and object format in sortable_fields', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: ['title', { field: 'date', default_sort: true }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should throw if more than one sortable field has default_sort property', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [
+              {
+                sortable_fields: [
+                  { field: 'title', default_sort: true },
+                  { field: 'date', default_sort: true },
+                ],
+              },
+            ],
+          }),
+        );
+      }).toThrowError('only one sortable field can have the default_sort property');
+    });
+
     it('should throw if collection names are not unique', () => {
       expect(() => {
         validateConfig(

package/src/constants/configSchema.js

@@ -253,7 +253,21 @@ function getConfigSchema() {
             sortable_fields: {
               type: 'array',
               items: {
-                type: 'string',
+                oneOf: [
+                  { type: 'string' },
+                  {
+                    type: 'object',
+                    properties: {
+                      field: { type: 'string' },
+                      label: { type: 'string' },
+                      default_sort: {
+                        oneOf: [{ type: 'boolean' }, { type: 'string', enum: ['asc', 'desc'] }],
+                      },
+                    },
+                    required: ['field'],
+                    additionalProperties: false,
+                  },
+                ],
               },
             },
             sortableFields: {
@@ -405,4 +419,23 @@ export function validateConfig(config) {
     console.error('Config Errors', errors);
     throw new ConfigError(errors);
   }
+
+  // Custom validation: only one sortable field can have default_sort property
+  if (config.collections) {
+    config.collections.forEach((collection, index) => {
+      if (collection.sortable_fields) {
+        const defaultFields = collection.sortable_fields.filter(
+          field => typeof field === 'object' && field.default_sort !== undefined,
+        );
+        if (defaultFields.length > 1) {
+          const error = {
+            instancePath: `/collections/${index}/sortable_fields`,
+            message: 'only one sortable field can have the default_sort property',
+          };
+          console.error('Config Errors', [error]);
+          throw new ConfigError([error]);
+        }
+      }
+    });
+  }
 }

package/src/lib/__tests__/formatters.spec.js

@@ -274,8 +274,8 @@ describe('formatters', () => {
   };
 
   describe('slugFormatter', () => {
-    const date = new Date('2020-01-01');
-    jest.spyOn(global, 'Date').mockImplementation(() => date);
+    const date = new Date('2020-01-01').valueOf();
+    Date.now = jest.spyOn(Date, 'now').mockImplementation(() => date);
 
     const { selectIdentifier } = require('../../reducers/collections');
 
@@ -312,6 +312,34 @@ describe('formatters', () => {
       ).toBe('entry-slug');
     });
 
+    it('should see date filters applied to date from entry if it exists', () => {
+      const { selectInferredField } = require('../../reducers/collections');
+      selectInferredField.mockReturnValue('date');
+      const entryDate = new Date('2026-10-20');
+
+      expect(
+        slugFormatter(
+          Map({ slug: '{{year}}-{{month}}-{{day}}-{{title}}' }),
+          Map({ date: entryDate, title: 'post title' }),
+          slugConfig,
+        ),
+      ).toBe('2026-10-20-post-title');
+    });
+
+    it('should see date filters applied to publishDate from entry if it exists', () => {
+      const { selectInferredField } = require('../../reducers/collections');
+      selectInferredField.mockReturnValue('publishDate');
+      const entryDate = new Date('2026-10-20');
+
+      expect(
+        slugFormatter(
+          Map({ slug: '{{year}}-{{month}}-{{day}}-{{title}}' }),
+          Map({ publishDate: entryDate, title: 'post title' }),
+          slugConfig,
+        ),
+      ).toBe('2026-10-20-post-title');
+    });
+
     it('should return slug', () => {
       selectIdentifier.mockReturnValueOnce('title');
 

package/src/lib/formatters.ts

@@ -21,6 +21,7 @@ import type { Map } from 'immutable';
 const {
   compileStringTemplate,
   parseDateFromEntry,
+  parseDateFromEntryData,
   SLUG_MISSING_REQUIRED_DATE,
   keyToPathArray,
   addFileTemplateFields,
@@ -129,7 +130,11 @@ export function slugFormatter(
   }
 
   const processSegment = getProcessSegment(slugConfig);
-  const date = new Date();
+  const date =
+    parseDateFromEntryData(
+      entryData as unknown as Map<string, unknown>,
+      selectInferredField(collection, 'date'),
+    ) || new Date(Date.now());
   const slug = compileStringTemplate(slugTemplate, date, identifier, entryData, processSegment);
 
   if (!collection.has('path')) {

package/src/reducers/__tests__/collections.spec.js

@@ -11,6 +11,7 @@ import collections, {
   getFieldsNames,
   selectField,
   updateFieldByKey,
+  selectInferredField,
 } from '../collections';
 import { FILES, FOLDER } from '../../constants/collectionTypes';
 
@@ -568,4 +569,42 @@ describe('collections', () => {
       );
     });
   });
+
+  describe("selectInferredField(collection, 'date')", () => {
+    it('should return publishDate if set', () => {
+      const collection = fromJS({
+        fields: [{ name: 'title' }, { name: 'publishDate', widget: 'datetime' }],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('publishDate');
+    });
+
+    it('should return publish_date if set', () => {
+      const collection = fromJS({
+        fields: [{ name: 'title' }, { name: 'publish_date', widget: 'datetime' }],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('publish_date');
+    });
+
+    it('should return date if set', () => {
+      const collection = fromJS({
+        fields: [{ name: 'title' }, { name: 'date', widget: 'datetime' }],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('date');
+    });
+
+    it('should return first date field if multiple synonyms are present', () => {
+      const collection = fromJS({
+        fields: [
+          { name: 'title' },
+          { name: 'publishDate', widget: 'datetime' },
+          { name: 'date', widget: 'datetime' },
+        ],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('publishDate');
+    });
+  });
 });