decap-cms-core 3.9.0 → 3.10.0

package/dist/esm/constants/configSchema.js

@@ -1,24 +1,3 @@
-function _extendableBuiltin(cls) {
-  function ExtendableBuiltin() {
-    var instance = Reflect.construct(cls, Array.from(arguments));
-    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    return instance;
-  }
-  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-    constructor: {
-      value: cls,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ExtendableBuiltin, cls);
-  } else {
-    ExtendableBuiltin.__proto__ = cls;
-  }
-  return ExtendableBuiltin;
-}
 import AJV from 'ajv';
 import { select, uniqueItemProperties, instanceof as instanceOf, prohibited } from 'ajv-keywords/dist/keywords';
 import ajvErrors from 'ajv-errors';
@@ -410,7 +389,29 @@ 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: {
@@ -523,7 +524,7 @@ function getWidgetSchemas() {
   }));
   return Object.assign(...schemas);
 }
-class ConfigError extends _extendableBuiltin(Error) {
+class ConfigError extends Error {
   constructor(errors, ...args) {
     const message = errors.map(({
       message,
@@ -602,4 +603,21 @@ 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/dist/esm/lib/entryCache.js

@@ -0,0 +1,145 @@
+/**
+ * Entry Cache Module
+ *
+ * Provides localStorage-based caching for collection entries to improve performance
+ * when navigating between pages, sorting, or filtering.
+ *
+ * Cache Strategy:
+ * - Store fetched entries with timestamps
+ * - Invalidate on entry changes (persist, delete)
+ * - Time-based expiration (default: 5 minutes)
+ * - Collection-specific cache keys
+ */
+
+import localForage from 'decap-cms-lib-util/src/localForage';
+const CACHE_PREFIX = 'decap_entry_cache_';
+const CACHE_EXPIRATION_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Generate cache key for a collection
+ */
+function getCacheKey(collectionName) {
+  return `${CACHE_PREFIX}${collectionName}`;
+}
+
+/**
+ * Check if cached data is still valid
+ */
+function isCacheValid(cacheEntry) {
+  if (!cacheEntry) {
+    return false;
+  }
+  const now = Date.now();
+  const age = now - cacheEntry.timestamp;
+  return age < CACHE_EXPIRATION_MS;
+}
+
+/**
+ * Get cached entries for a collection
+ *
+ * @param collectionName - Name of the collection
+ * @returns Cached entries or null if cache miss/expired
+ */
+export async function getCachedEntries(collectionName) {
+  try {
+    const cacheKey = getCacheKey(collectionName);
+    const cached = await localForage.getItem(cacheKey);
+    if (cached && isCacheValid(cached)) {
+      console.log(`[EntryCache] Cache HIT for collection: ${collectionName}`);
+      return cached.entries;
+    }
+    console.log(`[EntryCache] Cache MISS for collection: ${collectionName}`);
+    return null;
+  } catch (error) {
+    console.warn('[EntryCache] Error reading cache:', error);
+    return null;
+  }
+}
+
+/**
+ * Store entries in cache
+ *
+ * @param collectionName - Name of the collection
+ * @param entries - Entries to cache
+ */
+export async function setCachedEntries(collectionName, entries) {
+  try {
+    const cacheKey = getCacheKey(collectionName);
+    const cacheEntry = {
+      entries,
+      timestamp: Date.now(),
+      collectionName,
+      version: 1
+    };
+    await localForage.setItem(cacheKey, cacheEntry);
+    console.log(`[EntryCache] Cached ${entries.length} entries for collection: ${collectionName}`);
+  } catch (error) {
+    console.warn('[EntryCache] Error writing cache:', error);
+  }
+}
+
+/**
+ * Invalidate cache for a specific collection
+ *
+ * Should be called when:
+ * - Entry is created
+ * - Entry is updated
+ * - Entry is deleted
+ *
+ * @param collectionName - Name of the collection to invalidate
+ */
+export async function invalidateCollectionCache(collectionName) {
+  try {
+    const cacheKey = getCacheKey(collectionName);
+    await localForage.removeItem(cacheKey);
+    console.log(`[EntryCache] Invalidated cache for collection: ${collectionName}`);
+  } catch (error) {
+    console.warn('[EntryCache] Error invalidating cache:', error);
+  }
+}
+
+/**
+ * Clear all entry caches
+ *
+ * Useful for logout or manual cache clearing
+ */
+export async function clearAllEntryCaches() {
+  try {
+    const keys = await localForage.keys();
+    const cacheKeys = keys.filter(key => key.startsWith(CACHE_PREFIX));
+    await Promise.all(cacheKeys.map(key => localForage.removeItem(key)));
+    console.log(`[EntryCache] Cleared ${cacheKeys.length} collection caches`);
+  } catch (error) {
+    console.warn('[EntryCache] Error clearing all caches:', error);
+  }
+}
+
+/**
+ * Get cache statistics for debugging
+ */
+export async function getCacheStats() {
+  try {
+    const keys = await localForage.keys();
+    const cacheKeys = keys.filter(key => key.startsWith(CACHE_PREFIX));
+    const cacheEntries = await Promise.all(cacheKeys.map(async key => {
+      const entry = await localForage.getItem(key);
+      return entry;
+    }));
+    const validCaches = cacheEntries.filter(entry => entry !== null);
+    const timestamps = validCaches.map(c => c.timestamp);
+    return {
+      collections: validCaches.map(c => c.collectionName),
+      totalEntries: validCaches.reduce((sum, c) => sum + c.entries.length, 0),
+      oldestCache: timestamps.length > 0 ? Math.min(...timestamps) : null,
+      newestCache: timestamps.length > 0 ? Math.max(...timestamps) : null
+    };
+  } catch (error) {
+    console.warn('[EntryCache] Error getting cache stats:', error);
+    return {
+      collections: [],
+      totalEntries: 0,
+      oldestCache: null,
+      newestCache: null
+    };
+  }
+}

package/dist/esm/lib/entryHelpers.js

@@ -0,0 +1,102 @@
+/**
+ * Utility functions for working with entries, filters, sorts, and groups
+ */
+
+/**
+ * Check if any filters are active in the Redux state
+ */
+export function hasActiveFilters(activeFilters) {
+  if (!activeFilters) return false;
+
+  // Check if it's an Immutable collection with a 'some' method
+  if (typeof activeFilters === 'object' &&
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  typeof activeFilters.some === 'function') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return activeFilters.some(f => f.get('active') === true);
+  }
+  return false;
+}
+
+/**
+ * Check if any groups are active in the Redux state
+ */
+export function hasActiveGroups(activeGroups) {
+  if (!activeGroups) return false;
+
+  // Check if it's an Immutable collection with a 'some' method
+  if (typeof activeGroups === 'object' &&
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  typeof activeGroups.some === 'function') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return activeGroups.some(g => g.get('active') === true);
+  }
+  return false;
+}
+
+/**
+ * Check if any sorts are active in the Redux state
+ */
+export function hasActiveSorts(activeSorts) {
+  if (!activeSorts) return false;
+
+  // Check if it's an Immutable collection with a 'size' property
+  if (typeof activeSorts === 'object' &&
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  typeof activeSorts.size === 'number') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return activeSorts.size > 0;
+  }
+  return false;
+}
+
+/**
+ * Get value from a nested field path (e.g., "data.title" or "data.nested.field")
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getFieldValue(obj, fieldPath) {
+  const pathParts = fieldPath.split('.');
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let value = obj;
+  for (const part of pathParts) {
+    value = value?.[part];
+  }
+  return value;
+}
+
+/**
+ * Extract active filters from Immutable collection into plain array
+ */
+
+export function extractActiveFilters(activeFilters) {
+  const filters = [];
+  if (!activeFilters) return filters;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (typeof activeFilters.forEach === 'function') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    activeFilters.forEach(f => {
+      if (f.get('active') === true) {
+        filters.push({
+          pattern: f.get('pattern'),
+          field: f.get('field')
+        });
+      }
+    });
+  }
+  return filters;
+}
+
+/**
+ * Apply filters to an entry
+ */
+export function matchesFilters(entry, filters) {
+  return filters.every(({
+    pattern,
+    field
+  }) => {
+    const data = ('data' in entry ? entry.data : entry) || {};
+    const value = getFieldValue(data, field);
+    return value !== undefined && new RegExp(String(pattern)).test(String(value));
+  });
+}

package/dist/esm/lib/formatters.js

@@ -11,6 +11,7 @@ import { COMMIT_AUTHOR, COMMIT_DATE } from '../constants/commitProps';
 const {
   compileStringTemplate,
   parseDateFromEntry,
+  parseDateFromEntryData,
   SLUG_MISSING_REQUIRED_DATE,
   keyToPathArray,
   addFileTemplateFields
@@ -91,7 +92,7 @@ export function slugFormatter(collection, entryData, slugConfig) {
     throw new Error('Collection must have a field name that is a valid entry identifier, or must have `identifier_field` set');
   }
   const processSegment = getProcessSegment(slugConfig);
-  const date = new Date();
+  const date = parseDateFromEntryData(entryData, selectInferredField(collection, 'date')) || new Date(Date.now());
   const slug = compileStringTemplate(slugTemplate, date, identifier, entryData, processSegment);
   if (!collection.has('path')) {
     return slug;

package/dist/esm/lib/immutableHelpers.js

@@ -0,0 +1,21 @@
+import { Map } from 'immutable';
+/**
+ * Type guard to check if an object is an Immutable.js Map
+ */
+export function isImmutableMap(obj) {
+  return Map.isMap(obj);
+}
+
+/**
+ * Helper to safely get a value from either an Immutable Map or plain object
+ */
+export function getValue(obj, key) {
+  if (!obj) return undefined;
+  if (isImmutableMap(obj)) {
+    return obj.get(key);
+  }
+  if (typeof obj === 'object' && obj !== null) {
+    return obj[key];
+  }
+  return undefined;
+}

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/lib/pagination.js

@@ -0,0 +1,68 @@
+/**
+ * Pagination Utilities
+ *
+ * This module provides helpers for determining if pagination is enabled for a collection,
+ * and for retrieving the effective pagination configuration (page size, enabled flag).
+ *
+ * Principles:
+ * - Pagination can be enabled/disabled per collection or globally via config.
+ * - If sorting, filtering, or grouping is active, pagination is handled client-side (all entries loaded).
+ * - If none are active, server-side pagination is used (only a page of entries loaded at a time).
+ * - The effective page size is determined by collection config, then global config, then a default.
+ *
+ * Usage:
+ * - Use isPaginationEnabled(collection, config) to check if pagination should be active.
+ * - Use getPaginationConfig(collection, config) to get the effective page size and enabled flag.
+ */
+import { getValue, isImmutableMap } from './immutableHelpers';
+const DEFAULT_PER_PAGE = 100;
+export function isPaginationEnabled(collection, globalConfig) {
+  const pagination = isImmutableMap(collection) ? collection.get('pagination') : collection.pagination;
+  if (typeof pagination !== 'undefined') {
+    if (typeof pagination === 'boolean') return pagination;
+    if (pagination && typeof pagination === 'object') {
+      const enabled = getValue(pagination, 'enabled');
+      return enabled !== false;
+    }
+    return false;
+  }
+  if (globalConfig?.pagination) {
+    if (typeof globalConfig.pagination === 'boolean') return globalConfig.pagination;
+    if (typeof globalConfig.pagination === 'object') {
+      const enabled = getValue(globalConfig.pagination, 'enabled');
+      return enabled !== false;
+    }
+  }
+  return false;
+}
+export function getPaginationConfig(collection, globalConfig) {
+  const defaults = {
+    enabled: false,
+    per_page: DEFAULT_PER_PAGE
+  };
+  if (globalConfig?.pagination) {
+    if (typeof globalConfig.pagination === 'boolean') {
+      defaults.enabled = globalConfig.pagination;
+    } else if (typeof globalConfig.pagination === 'object') {
+      const enabled = getValue(globalConfig.pagination, 'enabled');
+      defaults.enabled = enabled !== false;
+      const perPage = getValue(globalConfig.pagination, 'per_page');
+      defaults.per_page = typeof perPage === 'number' ? perPage : defaults.per_page;
+    }
+  }
+  const pagination = isImmutableMap(collection) ? collection.get('pagination') : collection.pagination;
+  if (pagination === true) {
+    return {
+      enabled: true,
+      per_page: defaults.per_page
+    };
+  } else if (typeof pagination === 'object' && pagination !== null) {
+    const perPage = getValue(pagination, 'per_page');
+    const enabled = getValue(pagination, 'enabled');
+    return {
+      enabled: enabled !== false,
+      per_page: typeof perPage === 'number' ? perPage : defaults.per_page
+    };
+  }
+  return defaults;
+}

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.0",
   "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": "0c1b7c7d63ba6ddb3de3692fbb6b16ac6ebb44d5"
 }

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);