@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/reducers/entryDraft.js

@@ -0,0 +1,212 @@
+import { Map, List, fromJS } from 'immutable';
+import { v4 as uuid } from 'uuid';
+import get from 'lodash/get';
+import { join } from 'path';
+import { DRAFT_CREATE_FROM_ENTRY, DRAFT_CREATE_EMPTY, DRAFT_DISCARD, DRAFT_CHANGE_FIELD, DRAFT_VALIDATION_ERRORS, DRAFT_CLEAR_ERRORS, DRAFT_LOCAL_BACKUP_RETRIEVED, DRAFT_CREATE_FROM_LOCAL_BACKUP, DRAFT_CREATE_DUPLICATE_FROM_ENTRY, ENTRY_PERSIST_REQUEST, ENTRY_PERSIST_SUCCESS, ENTRY_PERSIST_FAILURE, ENTRY_DELETE_SUCCESS, ADD_DRAFT_ENTRY_MEDIA_FILE, REMOVE_DRAFT_ENTRY_MEDIA_FILE } from '../actions/entries';
+import { UNPUBLISHED_ENTRY_PERSIST_REQUEST, UNPUBLISHED_ENTRY_PERSIST_SUCCESS, UNPUBLISHED_ENTRY_PERSIST_FAILURE, UNPUBLISHED_ENTRY_STATUS_CHANGE_REQUEST, UNPUBLISHED_ENTRY_STATUS_CHANGE_SUCCESS, UNPUBLISHED_ENTRY_STATUS_CHANGE_FAILURE, UNPUBLISHED_ENTRY_PUBLISH_REQUEST, UNPUBLISHED_ENTRY_PUBLISH_SUCCESS, UNPUBLISHED_ENTRY_PUBLISH_FAILURE } from '../actions/editorialWorkflow';
+import { selectFolderEntryExtension, selectHasMetaPath } from './collections';
+import { getDataPath, duplicateI18nFields } from '../lib/i18n';
+const initialState = Map({
+  entry: Map(),
+  fieldsMetaData: Map(),
+  fieldsErrors: Map(),
+  hasChanged: false,
+  key: ''
+});
+function entryDraftReducer(state = Map(), action) {
+  switch (action.type) {
+    case DRAFT_CREATE_FROM_ENTRY:
+      // Existing Entry
+      return state.withMutations(state => {
+        state.set('entry', fromJS(action.payload.entry));
+        state.setIn(['entry', 'newRecord'], false);
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', false);
+        state.set('key', uuid());
+      });
+    case DRAFT_CREATE_EMPTY:
+      // New Entry
+      return state.withMutations(state => {
+        state.set('entry', fromJS(action.payload));
+        state.setIn(['entry', 'newRecord'], true);
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', false);
+        state.set('key', uuid());
+      });
+    case DRAFT_CREATE_FROM_LOCAL_BACKUP:
+      // Local Backup
+      return state.withMutations(state => {
+        const backupDraftEntry = state.get('localBackup');
+        const backupEntry = backupDraftEntry.get('entry');
+        state.delete('localBackup');
+        state.set('entry', backupEntry);
+        state.setIn(['entry', 'newRecord'], !backupEntry.get('path'));
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', true);
+        state.set('key', uuid());
+      });
+    case DRAFT_CREATE_DUPLICATE_FROM_ENTRY:
+      // Duplicate Entry
+      return state.withMutations(state => {
+        state.set('entry', fromJS(action.payload));
+        state.setIn(['entry', 'newRecord'], true);
+        state.set('mediaFiles', List());
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', true);
+      });
+    case DRAFT_DISCARD:
+      return initialState;
+    case DRAFT_LOCAL_BACKUP_RETRIEVED:
+      {
+        const {
+          entry
+        } = action.payload;
+        const newState = new Map({
+          entry: fromJS(entry)
+        });
+        return state.set('localBackup', newState);
+      }
+    case DRAFT_CHANGE_FIELD:
+      {
+        return state.withMutations(state => {
+          const {
+            field,
+            value,
+            metadata,
+            entries,
+            i18n
+          } = action.payload;
+          const name = field.get('name');
+          const meta = field.get('meta');
+          const dataPath = i18n && getDataPath(i18n.currentLocale, i18n.defaultLocale) || ['data'];
+          if (meta) {
+            state.setIn(['entry', 'meta', name], value);
+          } else {
+            state.setIn(['entry', ...dataPath, name], value);
+            if (i18n) {
+              state = duplicateI18nFields(state, field, i18n.locales, i18n.defaultLocale);
+            }
+          }
+          state.mergeDeepIn(['fieldsMetaData'], fromJS(metadata));
+          const newData = state.getIn(['entry', ...dataPath]);
+          const newMeta = state.getIn(['entry', 'meta']);
+          state.set('hasChanged', !entries.some(e => newData.equals(e.get(...dataPath))) || !entries.some(e => newMeta.equals(e.get('meta'))));
+        });
+      }
+    case DRAFT_VALIDATION_ERRORS:
+      if (action.payload.errors.length === 0) {
+        return state.deleteIn(['fieldsErrors', action.payload.uniquefieldId]);
+      } else {
+        return state.setIn(['fieldsErrors', action.payload.uniquefieldId], action.payload.errors);
+      }
+    case DRAFT_CLEAR_ERRORS:
+      {
+        const {
+          uniqueFieldId
+        } = action.payload;
+        return state.deleteIn(['fieldsErrors', uniqueFieldId]);
+      }
+    case ENTRY_PERSIST_REQUEST:
+    case UNPUBLISHED_ENTRY_PERSIST_REQUEST:
+      {
+        return state.setIn(['entry', 'isPersisting'], true);
+      }
+    case ENTRY_PERSIST_FAILURE:
+    case UNPUBLISHED_ENTRY_PERSIST_FAILURE:
+      {
+        return state.deleteIn(['entry', 'isPersisting']);
+      }
+    case UNPUBLISHED_ENTRY_STATUS_CHANGE_REQUEST:
+      return state.setIn(['entry', 'isUpdatingStatus'], true);
+    case UNPUBLISHED_ENTRY_STATUS_CHANGE_FAILURE:
+    case UNPUBLISHED_ENTRY_STATUS_CHANGE_SUCCESS:
+      return state.deleteIn(['entry', 'isUpdatingStatus']);
+    case UNPUBLISHED_ENTRY_PUBLISH_REQUEST:
+      return state.setIn(['entry', 'isPublishing'], true);
+    case UNPUBLISHED_ENTRY_PUBLISH_SUCCESS:
+    case UNPUBLISHED_ENTRY_PUBLISH_FAILURE:
+      return state.deleteIn(['entry', 'isPublishing']);
+    case ENTRY_PERSIST_SUCCESS:
+    case UNPUBLISHED_ENTRY_PERSIST_SUCCESS:
+      return state.withMutations(state => {
+        state.deleteIn(['entry', 'isPersisting']);
+        state.set('hasChanged', false);
+        if (!state.getIn(['entry', 'slug'])) {
+          state.setIn(['entry', 'slug'], action.payload.slug);
+        }
+      });
+    case ENTRY_DELETE_SUCCESS:
+      return state.withMutations(state => {
+        state.deleteIn(['entry', 'isPersisting']);
+        state.set('hasChanged', false);
+      });
+    case ADD_DRAFT_ENTRY_MEDIA_FILE:
+      {
+        return state.withMutations(state => {
+          const mediaFiles = state.getIn(['entry', 'mediaFiles']);
+          state.setIn(['entry', 'mediaFiles'], mediaFiles.filterNot(file => file.get('id') === action.payload.id).insert(0, fromJS(action.payload)));
+          state.set('hasChanged', true);
+        });
+      }
+    case REMOVE_DRAFT_ENTRY_MEDIA_FILE:
+      {
+        return state.withMutations(state => {
+          const mediaFiles = state.getIn(['entry', 'mediaFiles']);
+          state.setIn(['entry', 'mediaFiles'], mediaFiles.filterNot(file => file.get('id') === action.payload.id));
+          state.set('hasChanged', true);
+        });
+      }
+    default:
+      return state;
+  }
+}
+function cleanTitleForFilename(title) {
+  if (!title) return 'untitled';
+  // Convert to lowercase, replace spaces and special chars with hyphens
+  return title.toString().toLowerCase().trim().replace(/[^\w\s-]/g, '') // Remove special characters
+  .replace(/[\s_]+/g, '-') // Replace spaces and underscores with hyphens
+  .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
+}
+export function selectCustomPath(collection, entryDraft) {
+  if (!selectHasMetaPath(collection)) {
+    return;
+  }
+  const meta = entryDraft.getIn(['entry', 'meta']);
+  const path = meta && meta.get('path');
+  if (!path) {
+    return;
+  }
+  const extension = selectFolderEntryExtension(collection);
+  const indexFile = get(collection.toJS(), ['meta', 'path', 'index_file']);
+
+  // If index_file is specified, use the old behavior for backward compatibility
+  if (indexFile) {
+    const customPath = join(collection.get('folder'), path, `${indexFile}.${extension}`);
+    return customPath;
+  }
+
+  // New behavior: generate filename from entry title
+  const isNewEntry = entryDraft.getIn(['entry', 'newRecord']);
+  const currentPath = entryDraft.getIn(['entry', 'path']);
+  let filename;
+  if (isNewEntry || !currentPath) {
+    // For new entries, generate filename from title
+    const entryData = entryDraft.getIn(['entry', 'data']);
+    const title = entryData && entryData.get('title');
+    filename = cleanTitleForFilename(title);
+  } else {
+    // For existing entries, preserve the current filename
+    const {
+      basename: basenameFunc
+    } = require('path');
+    const currentFilename = basenameFunc(currentPath, `.${extension}`);
+    filename = currentFilename;
+  }
+  const customPath = join(collection.get('folder'), path, `${filename}.${extension}`);
+  return customPath;
+}
+export default entryDraftReducer;

package/dist/esm/reducers/globalUI.js

@@ -0,0 +1,25 @@
+import { produce } from 'immer';
+import { USE_OPEN_AUTHORING } from '../actions/auth';
+const LOADING_IGNORE_LIST = ['DEPLOY_PREVIEW', 'STATUS_REQUEST', 'STATUS_SUCCESS', 'STATUS_FAILURE'];
+function ignoreWhenLoading(action) {
+  return LOADING_IGNORE_LIST.some(type => action.type.includes(type));
+}
+const defaultState = {
+  isFetching: false,
+  useOpenAuthoring: false
+};
+
+/**
+ * Reducer for some global UI state that we want to share between components
+ */
+const globalUI = produce((state, action) => {
+  // Generic, global loading indicator
+  if (!ignoreWhenLoading(action) && action.type.includes('REQUEST')) {
+    state.isFetching = true;
+  } else if (!ignoreWhenLoading(action) && (action.type.includes('SUCCESS') || action.type.includes('FAILURE'))) {
+    state.isFetching = false;
+  } else if (action.type === USE_OPEN_AUTHORING) {
+    state.useOpenAuthoring = true;
+  }
+}, defaultState);
+export default globalUI;

package/dist/esm/reducers/index.js

@@ -0,0 +1,66 @@
+import { List } from 'immutable';
+import auth from './auth';
+import config from './config';
+import integrations, * as fromIntegrations from './integrations';
+import entries, * as fromEntries from './entries';
+import cursors from './cursors';
+import editorialWorkflow, * as fromEditorialWorkflow from './editorialWorkflow';
+import entryDraft from './entryDraft';
+import collections from './collections';
+import search from './search';
+import medias from './medias';
+import mediaLibrary from './mediaLibrary';
+import deploys, * as fromDeploys from './deploys';
+import globalUI from './globalUI';
+import status from './status';
+import notifications from './notifications';
+const reducers = {
+  auth,
+  config,
+  collections,
+  search,
+  integrations,
+  entries,
+  cursors,
+  editorialWorkflow,
+  entryDraft,
+  medias,
+  mediaLibrary,
+  deploys,
+  globalUI,
+  status,
+  notifications
+};
+export default reducers;
+
+/*
+ * Selectors
+ */
+export function selectEntry(state, collection, slug) {
+  return fromEntries.selectEntry(state.entries, collection, slug);
+}
+export function selectEntries(state, collection) {
+  return fromEntries.selectEntries(state.entries, collection);
+}
+export function selectPublishedSlugs(state, collection) {
+  return fromEntries.selectPublishedSlugs(state.entries, collection);
+}
+export function selectSearchedEntries(state, availableCollections) {
+  // only return search results for actually available collections
+  return List(state.search.entryIds).filter(entryId => availableCollections.indexOf(entryId.collection) !== -1).map(entryId => fromEntries.selectEntry(state.entries, entryId.collection, entryId.slug));
+}
+export function selectDeployPreview(state, collection, slug) {
+  return fromDeploys.selectDeployPreview(state.deploys, collection, slug);
+}
+export function selectUnpublishedEntry(state, collection, slug) {
+  return fromEditorialWorkflow.selectUnpublishedEntry(state.editorialWorkflow, collection, slug);
+}
+export function selectUnpublishedEntriesByStatus(state, status) {
+  return fromEditorialWorkflow.selectUnpublishedEntriesByStatus(state.editorialWorkflow, status);
+}
+export function selectUnpublishedSlugs(state, collection) {
+  return fromEditorialWorkflow.selectUnpublishedSlugs(state.editorialWorkflow, collection);
+}
+export function selectIntegration(state, collection, hook) {
+  return fromIntegrations.selectIntegration(state.integrations, collection, hook);
+}

package/dist/esm/reducers/integrations.js

@@ -0,0 +1,53 @@
+import { fromJS } from 'immutable';
+import { CONFIG_SUCCESS } from '../actions/config';
+export function getIntegrations(config) {
+  const integrations = config.integrations || [];
+  const newState = integrations.reduce((acc, integration) => {
+    const {
+      hooks,
+      collections,
+      provider,
+      ...providerData
+    } = integration;
+    acc.providers[provider] = {
+      ...providerData
+    };
+    if (!collections) {
+      hooks.forEach(hook => {
+        acc.hooks[hook] = provider;
+      });
+      return acc;
+    }
+    const integrationCollections = collections === '*' ? config.collections.map(collection => collection.name) : collections;
+    integrationCollections.forEach(collection => {
+      hooks.forEach(hook => {
+        acc.hooks[collection] ? acc.hooks[collection][hook] = provider : acc.hooks[collection] = {
+          [hook]: provider
+        };
+      });
+    });
+    return acc;
+  }, {
+    providers: {},
+    hooks: {}
+  });
+  return fromJS(newState);
+}
+const defaultState = fromJS({
+  providers: {},
+  hooks: {}
+});
+function integrations(state = defaultState, action) {
+  switch (action.type) {
+    case CONFIG_SUCCESS:
+      {
+        return getIntegrations(action.payload);
+      }
+    default:
+      return state;
+  }
+}
+export function selectIntegration(state, collection, hook) {
+  return collection ? state.getIn(['hooks', collection, hook], false) : state.getIn(['hooks', hook], false);
+}
+export default integrations;

package/dist/esm/reducers/mediaLibrary.js

@@ -0,0 +1,252 @@
+import { Map, List } from 'immutable';
+import { v4 as uuid } from 'uuid';
+import { dirname } from 'path';
+import { MEDIA_LIBRARY_OPEN, MEDIA_LIBRARY_CLOSE, MEDIA_LIBRARY_CREATE, MEDIA_INSERT, MEDIA_REMOVE_INSERTED, MEDIA_LOAD_REQUEST, MEDIA_LOAD_SUCCESS, MEDIA_LOAD_FAILURE, MEDIA_PERSIST_REQUEST, MEDIA_PERSIST_SUCCESS, MEDIA_PERSIST_FAILURE, MEDIA_DELETE_REQUEST, MEDIA_DELETE_SUCCESS, MEDIA_DELETE_FAILURE, MEDIA_DISPLAY_URL_REQUEST, MEDIA_DISPLAY_URL_SUCCESS, MEDIA_DISPLAY_URL_FAILURE } from '../actions/mediaLibrary';
+import { selectEditingDraft, selectMediaFolder } from './entries';
+import { selectIntegration } from './';
+const defaultState = {
+  isVisible: false,
+  showMediaButton: true,
+  controlMedia: Map(),
+  displayURLs: Map(),
+  config: Map()
+};
+function mediaLibrary(state = Map(defaultState), action) {
+  switch (action.type) {
+    case MEDIA_LIBRARY_CREATE:
+      return state.withMutations(map => {
+        map.set('externalLibrary', action.payload);
+        map.set('showMediaButton', action.payload.enableStandalone());
+      });
+    case MEDIA_LIBRARY_OPEN:
+      {
+        const {
+          controlID,
+          forImage,
+          privateUpload,
+          config,
+          field,
+          value,
+          replaceIndex
+        } = action.payload;
+        const libConfig = config || Map();
+        const privateUploadChanged = state.get('privateUpload') !== privateUpload;
+        if (privateUploadChanged) {
+          return Map({
+            isVisible: true,
+            forImage,
+            controlID,
+            canInsert: !!controlID,
+            privateUpload,
+            config: libConfig,
+            controlMedia: Map(),
+            displayURLs: Map(),
+            field,
+            value,
+            replaceIndex
+          });
+        }
+        return state.withMutations(map => {
+          map.set('isVisible', true);
+          map.set('forImage', forImage ?? false);
+          map.set('controlID', controlID ?? '');
+          map.set('canInsert', !!controlID);
+          map.set('privateUpload', privateUpload);
+          map.set('config', libConfig);
+          map.set('field', field ?? '');
+          map.set('value', value == '' && libConfig.get('multiple') ? [] : value ?? '');
+          map.set('replaceIndex', replaceIndex ?? false);
+        });
+      }
+    case MEDIA_LIBRARY_CLOSE:
+      return state.set('isVisible', false);
+    case MEDIA_INSERT:
+      {
+        const {
+          mediaPath
+        } = action.payload;
+        const controlID = state.get('controlID');
+        const value = state.get('value');
+        if (!Array.isArray(value)) {
+          return state.withMutations(map => {
+            map.setIn(['controlMedia', controlID], mediaPath);
+          });
+        }
+        const replaceIndex = state.get('replaceIndex');
+        const mediaArray = Array.isArray(mediaPath) ? mediaPath : [mediaPath];
+        const valueArray = value;
+        if (typeof replaceIndex == 'number') {
+          valueArray[replaceIndex] = mediaArray[0];
+        } else {
+          valueArray.push(...mediaArray);
+        }
+        return state.withMutations(map => {
+          map.setIn(['controlMedia', controlID], valueArray);
+        });
+      }
+    case MEDIA_REMOVE_INSERTED:
+      {
+        const controlID = action.payload.controlID;
+        return state.setIn(['controlMedia', controlID], '');
+      }
+    case MEDIA_LOAD_REQUEST:
+      return state.withMutations(map => {
+        map.set('isLoading', true);
+        map.set('isPaginating', action.payload.page > 1);
+      });
+    case MEDIA_LOAD_SUCCESS:
+      {
+        const {
+          files = [],
+          page,
+          canPaginate,
+          dynamicSearch,
+          dynamicSearchQuery,
+          privateUpload
+        } = action.payload;
+        const privateUploadChanged = state.get('privateUpload') !== privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        const filesWithKeys = files.map(file => ({
+          ...file,
+          key: uuid()
+        }));
+        return state.withMutations(map => {
+          map.set('isLoading', false);
+          map.set('isPaginating', false);
+          map.set('page', page ?? 1);
+          map.set('hasNextPage', !!(canPaginate && files.length > 0));
+          map.set('dynamicSearch', dynamicSearch ?? false);
+          map.set('dynamicSearchQuery', dynamicSearchQuery ?? '');
+          map.set('dynamicSearchActive', !!dynamicSearchQuery);
+          if (page && page > 1) {
+            const updatedFiles = map.get('files').concat(filesWithKeys);
+            map.set('files', updatedFiles);
+          } else {
+            map.set('files', filesWithKeys);
+          }
+        });
+      }
+    case MEDIA_LOAD_FAILURE:
+      {
+        const privateUploadChanged = state.get('privateUpload') !== action.payload.privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.set('isLoading', false);
+      }
+    case MEDIA_PERSIST_REQUEST:
+      return state.set('isPersisting', true);
+    case MEDIA_PERSIST_SUCCESS:
+      {
+        const {
+          file,
+          privateUpload
+        } = action.payload;
+        const privateUploadChanged = state.get('privateUpload') !== privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.withMutations(map => {
+          const fileWithKey = {
+            ...file,
+            key: uuid()
+          };
+          const files = map.get('files');
+          const updatedFiles = [fileWithKey, ...files];
+          map.set('files', updatedFiles);
+          map.set('isPersisting', false);
+        });
+      }
+    case MEDIA_PERSIST_FAILURE:
+      {
+        const privateUploadChanged = state.get('privateUpload') !== action.payload.privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.set('isPersisting', false);
+      }
+    case MEDIA_DELETE_REQUEST:
+      return state.set('isDeleting', true);
+    case MEDIA_DELETE_SUCCESS:
+      {
+        const {
+          file,
+          privateUpload
+        } = action.payload;
+        const {
+          key,
+          id
+        } = file;
+        const privateUploadChanged = state.get('privateUpload') !== privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.withMutations(map => {
+          const files = map.get('files');
+          const updatedFiles = files.filter(file => key ? file.key !== key : file.id !== id);
+          map.set('files', updatedFiles);
+          map.deleteIn(['displayURLs', id]);
+          map.set('isDeleting', false);
+        });
+      }
+    case MEDIA_DELETE_FAILURE:
+      {
+        const privateUploadChanged = state.get('privateUpload') !== action.payload.privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.set('isDeleting', false);
+      }
+    case MEDIA_DISPLAY_URL_REQUEST:
+      return state.setIn(['displayURLs', action.payload.key, 'isFetching'], true);
+    case MEDIA_DISPLAY_URL_SUCCESS:
+      {
+        const displayURLPath = ['displayURLs', action.payload.key];
+        return state.setIn([...displayURLPath, 'isFetching'], false).setIn([...displayURLPath, 'url'], action.payload.url);
+      }
+    case MEDIA_DISPLAY_URL_FAILURE:
+      {
+        const displayURLPath = ['displayURLs', action.payload.key];
+        return state.setIn([...displayURLPath, 'isFetching'], false)
+        // make sure that err is set so the CMS won't attempt to load
+        // the image again
+        .setIn([...displayURLPath, 'err'], action.payload.err || true).deleteIn([...displayURLPath, 'url']);
+      }
+    default:
+      return state;
+  }
+}
+export function selectMediaFiles(state, field) {
+  const {
+    mediaLibrary,
+    entryDraft
+  } = state;
+  const editingDraft = selectEditingDraft(state.entryDraft);
+  const integration = selectIntegration(state, null, 'assetStore');
+  let files;
+  if (editingDraft && !integration) {
+    const entryFiles = entryDraft.getIn(['entry', 'mediaFiles'], List()).toJS();
+    const entry = entryDraft.get('entry');
+    const collection = state.collections.get(entry?.get('collection'));
+    const mediaFolder = selectMediaFolder(state.config, collection, entry, field);
+    files = entryFiles.filter(f => dirname(f.path) === mediaFolder).map(file => ({
+      key: file.id,
+      ...file
+    }));
+  } else {
+    files = mediaLibrary.get('files') || [];
+  }
+  return files;
+}
+export function selectMediaFileByPath(state, path) {
+  const files = selectMediaFiles(state);
+  const file = files.find(file => file.path === path);
+  return file;
+}
+export function selectMediaDisplayURL(state, id) {
+  const displayUrlState = state.mediaLibrary.getIn(['displayURLs', id], Map());
+  return displayUrlState;
+}
+export default mediaLibrary;

package/dist/esm/reducers/medias.js

@@ -0,0 +1,68 @@
+import { produce } from 'immer';
+import { ADD_ASSETS, ADD_ASSET, REMOVE_ASSET, LOAD_ASSET_REQUEST, LOAD_ASSET_SUCCESS, LOAD_ASSET_FAILURE } from '../actions/media';
+const defaultState = {};
+const medias = produce((state, action) => {
+  switch (action.type) {
+    case ADD_ASSETS:
+      {
+        const assets = action.payload;
+        assets.forEach(asset => {
+          state[asset.path] = {
+            asset,
+            isLoading: false,
+            error: null
+          };
+        });
+        break;
+      }
+    case ADD_ASSET:
+      {
+        const asset = action.payload;
+        state[asset.path] = {
+          asset,
+          isLoading: false,
+          error: null
+        };
+        break;
+      }
+    case REMOVE_ASSET:
+      {
+        const path = action.payload;
+        delete state[path];
+        break;
+      }
+    case LOAD_ASSET_REQUEST:
+      {
+        const {
+          path
+        } = action.payload;
+        state[path] = state[path] || {};
+        state[path].isLoading = true;
+        break;
+      }
+    case LOAD_ASSET_SUCCESS:
+      {
+        const {
+          path
+        } = action.payload;
+        state[path] = state[path] || {};
+        state[path].isLoading = false;
+        state[path].error = null;
+        break;
+      }
+    case LOAD_ASSET_FAILURE:
+      {
+        const {
+          path,
+          error
+        } = action.payload;
+        state[path] = state[path] || {};
+        state[path].isLoading = false;
+        state[path].error = error;
+      }
+  }
+}, defaultState);
+export function selectIsLoadingAsset(state) {
+  return Object.values(state).some(state => state.isLoading);
+}
+export default medias;