decap-cms-core 3.10.0 → 3.10.1

package/dist/esm/lib/entryCache.js

@@ -1,145 +0,0 @@
-/**
- * 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

@@ -1,102 +0,0 @@
-/**
- * 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/immutableHelpers.js

@@ -1,21 +0,0 @@
-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/pagination.js

@@ -1,68 +0,0 @@
-/**
- * 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;
-}