planning

node_modules/decap-cms-core/dist/esm/reducers/auth.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultState = exports.default = void 0;
+var _immer = require("immer");
+var _auth = require("../actions/auth");
+const defaultState = exports.defaultState = {
+  isFetching: false,
+  user: undefined,
+  error: undefined
+};
+const auth = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _auth.AUTH_REQUEST:
+      state.isFetching = true;
+      break;
+    case _auth.AUTH_SUCCESS:
+      state.user = action.payload;
+      break;
+    case _auth.AUTH_FAILURE:
+      state.error = action.payload && action.payload.toString();
+      break;
+    case _auth.AUTH_REQUEST_DONE:
+      state.isFetching = false;
+      break;
+    case _auth.LOGOUT:
+      state.user = undefined;
+      state.isFetching = false;
+  }
+}, defaultState);
+var _default = exports.default = auth;

node_modules/decap-cms-core/dist/esm/reducers/collections.js

@@ -0,0 +1,427 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getFieldsNames = getFieldsNames;
+exports.getFileFromSlug = getFileFromSlug;
+exports.selectAllowDeletion = selectAllowDeletion;
+exports.selectAllowNewEntries = selectAllowNewEntries;
+exports.selectDefaultSortableFields = selectDefaultSortableFields;
+exports.selectEntryCollectionTitle = selectEntryCollectionTitle;
+exports.selectEntryPath = selectEntryPath;
+exports.selectEntrySlug = selectEntrySlug;
+exports.selectField = selectField;
+exports.selectFields = selectFields;
+exports.selectFieldsComments = selectFieldsComments;
+exports.selectFieldsWithMediaFolders = selectFieldsWithMediaFolders;
+exports.selectFileEntryLabel = selectFileEntryLabel;
+exports.selectFolderEntryExtension = selectFolderEntryExtension;
+exports.selectHasMetaPath = selectHasMetaPath;
+exports.selectIdentifier = selectIdentifier;
+exports.selectInferredField = selectInferredField;
+exports.selectMediaFolders = selectMediaFolders;
+exports.selectSortDataPath = selectSortDataPath;
+exports.selectSortableFields = selectSortableFields;
+exports.selectTemplateName = selectTemplateName;
+exports.selectViewFilters = selectViewFilters;
+exports.selectViewGroups = selectViewGroups;
+exports.traverseFields = traverseFields;
+exports.updateFieldByKey = updateFieldByKey;
+var _escapeRegExp2 = _interopRequireDefault(require("lodash/escapeRegExp"));
+var _get2 = _interopRequireDefault(require("lodash/get"));
+var _immutable = require("immutable");
+var _decapCmsLibWidgets = require("decap-cms-lib-widgets");
+var _consoleError = _interopRequireDefault(require("../lib/consoleError"));
+var _config = require("../actions/config");
+var _collectionTypes = require("../constants/collectionTypes");
+var _commitProps = require("../constants/commitProps");
+var _fieldInference = require("../constants/fieldInference");
+var _formats = require("../formats/formats");
+var _entries = require("./entries");
+var _formatters = require("../lib/formatters");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const {
+  keyToPathArray
+} = _decapCmsLibWidgets.stringTemplate;
+const defaultState = (0, _immutable.fromJS)({});
+function collections(state = defaultState, action) {
+  switch (action.type) {
+    case _config.CONFIG_SUCCESS:
+      {
+        const collections = action.payload.collections;
+        let newState = (0, _immutable.OrderedMap)({});
+        collections.forEach(collection => {
+          newState = newState.set(collection.name, (0, _immutable.fromJS)(collection));
+        });
+        return newState;
+      }
+    default:
+      return state;
+  }
+}
+const selectors = {
+  [_collectionTypes.FOLDER]: {
+    entryExtension(collection) {
+      const ext = collection.get('extension') || (0, _get2.default)((0, _formats.getFormatExtensions)(), collection.get('format') || 'frontmatter');
+      if (!ext) {
+        throw new Error(`No extension found for format ${collection.get('format')}`);
+      }
+      return ext.replace(/^\./, '');
+    },
+    fields(collection) {
+      return collection.get('fields');
+    },
+    entryPath(collection, slug) {
+      const folder = collection.get('folder').replace(/\/$/, '');
+      return `${folder}/${slug}.${this.entryExtension(collection)}`;
+    },
+    entrySlug(collection, path) {
+      var _path$split$pop;
+      const folder = collection.get('folder').replace(/\/$/, '');
+      const slug = (_path$split$pop = path.split(folder + '/').pop()) === null || _path$split$pop === void 0 ? void 0 : _path$split$pop.replace(new RegExp(`\\.${(0, _escapeRegExp2.default)(this.entryExtension(collection))}$`), '');
+      return slug;
+    },
+    allowNewEntries(collection) {
+      return collection.get('create');
+    },
+    allowDeletion(collection) {
+      return collection.get('delete', true);
+    },
+    templateName(collection) {
+      return collection.get('name');
+    }
+  },
+  [_collectionTypes.FILES]: {
+    fileForEntry(collection, slug) {
+      const files = collection.get('files');
+      return files && files.filter(f => (f === null || f === void 0 ? void 0 : f.get('name')) === slug).get(0);
+    },
+    fields(collection, slug) {
+      const file = this.fileForEntry(collection, slug);
+      return file && file.get('fields');
+    },
+    entryPath(collection, slug) {
+      const file = this.fileForEntry(collection, slug);
+      return file && file.get('file');
+    },
+    entrySlug(collection, path) {
+      const file = collection.get('files').filter(f => (f === null || f === void 0 ? void 0 : f.get('file')) === path).get(0);
+      return file && file.get('name');
+    },
+    entryLabel(collection, slug) {
+      const file = this.fileForEntry(collection, slug);
+      return file && file.get('label');
+    },
+    allowNewEntries() {
+      return false;
+    },
+    allowDeletion(collection) {
+      return collection.get('delete', false);
+    },
+    templateName(_collection, slug) {
+      return slug;
+    }
+  }
+};
+function getFieldsWithMediaFolders(fields) {
+  const fieldsWithMediaFolders = fields.reduce((acc, f) => {
+    if (f.has('media_folder')) {
+      acc = [...acc, f];
+    }
+    if (f.has('fields')) {
+      var _f$get;
+      const fields = (_f$get = f.get('fields')) === null || _f$get === void 0 ? void 0 : _f$get.toArray();
+      acc = [...acc, ...getFieldsWithMediaFolders(fields)];
+    } else if (f.has('field')) {
+      const field = f.get('field');
+      acc = [...acc, ...getFieldsWithMediaFolders([field])];
+    } else if (f.has('types')) {
+      var _f$get2;
+      const types = (_f$get2 = f.get('types')) === null || _f$get2 === void 0 ? void 0 : _f$get2.toArray();
+      acc = [...acc, ...getFieldsWithMediaFolders(types)];
+    }
+    return acc;
+  }, []);
+  return fieldsWithMediaFolders;
+}
+function getFileFromSlug(collection, slug) {
+  var _collection$get;
+  return (_collection$get = collection.get('files')) === null || _collection$get === void 0 ? void 0 : _collection$get.toArray().find(f => f.get('name') === slug);
+}
+function selectFieldsWithMediaFolders(collection, slug) {
+  if (collection.has('folder')) {
+    const fields = collection.get('fields').toArray();
+    return getFieldsWithMediaFolders(fields);
+  } else if (collection.has('files')) {
+    var _getFileFromSlug;
+    const fields = ((_getFileFromSlug = getFileFromSlug(collection, slug)) === null || _getFileFromSlug === void 0 ? void 0 : _getFileFromSlug.get('fields').toArray()) || [];
+    return getFieldsWithMediaFolders(fields);
+  }
+  return [];
+}
+function selectMediaFolders(config, collection, entry) {
+  const fields = selectFieldsWithMediaFolders(collection, entry.get('slug'));
+  const folders = fields.map(f => (0, _entries.selectMediaFolder)(config, collection, entry, f));
+  if (collection.has('files')) {
+    const file = getFileFromSlug(collection, entry.get('slug'));
+    if (file) {
+      folders.unshift((0, _entries.selectMediaFolder)(config, collection, entry, undefined));
+    }
+  }
+  if (collection.has('media_folder')) {
+    // stop evaluating media folders at collection level
+    collection = collection.delete('files');
+    folders.unshift((0, _entries.selectMediaFolder)(config, collection, entry, undefined));
+  }
+  return (0, _immutable.Set)(folders).toArray();
+}
+function selectFields(collection, slug) {
+  return selectors[collection.get('type')].fields(collection, slug);
+}
+function selectFolderEntryExtension(collection) {
+  return selectors[_collectionTypes.FOLDER].entryExtension(collection);
+}
+function selectFileEntryLabel(collection, slug) {
+  return selectors[_collectionTypes.FILES].entryLabel(collection, slug);
+}
+function selectEntryPath(collection, slug) {
+  return selectors[collection.get('type')].entryPath(collection, slug);
+}
+function selectEntrySlug(collection, path) {
+  return selectors[collection.get('type')].entrySlug(collection, path);
+}
+function selectAllowNewEntries(collection) {
+  return selectors[collection.get('type')].allowNewEntries(collection);
+}
+function selectAllowDeletion(collection) {
+  return selectors[collection.get('type')].allowDeletion(collection);
+}
+function selectTemplateName(collection, slug) {
+  return selectors[collection.get('type')].templateName(collection, slug);
+}
+function getFieldsNames(fields, prefix = '') {
+  let names = fields.map(f => `${prefix}${f.get('name')}`);
+  fields.forEach((f, index) => {
+    if (f.has('fields')) {
+      var _f$get3;
+      const fields = (_f$get3 = f.get('fields')) === null || _f$get3 === void 0 ? void 0 : _f$get3.toArray();
+      names = [...names, ...getFieldsNames(fields, `${names[index]}.`)];
+    } else if (f.has('field')) {
+      const field = f.get('field');
+      names = [...names, ...getFieldsNames([field], `${names[index]}.`)];
+    } else if (f.has('types')) {
+      var _f$get4;
+      const types = (_f$get4 = f.get('types')) === null || _f$get4 === void 0 ? void 0 : _f$get4.toArray();
+      names = [...names, ...getFieldsNames(types, `${names[index]}.`)];
+    }
+  });
+  return names;
+}
+function selectField(collection, key) {
+  const array = keyToPathArray(key);
+  let name;
+  let field;
+  let fields = collection.get('fields', (0, _immutable.List)()).toArray();
+  while ((name = array.shift()) && fields) {
+    var _field, _field3, _field5;
+    field = fields.find(f => f.get('name') === name);
+    if ((_field = field) !== null && _field !== void 0 && _field.has('fields')) {
+      var _field2, _field2$get;
+      fields = (_field2 = field) === null || _field2 === void 0 ? void 0 : (_field2$get = _field2.get('fields')) === null || _field2$get === void 0 ? void 0 : _field2$get.toArray();
+    } else if ((_field3 = field) !== null && _field3 !== void 0 && _field3.has('field')) {
+      var _field4;
+      fields = [(_field4 = field) === null || _field4 === void 0 ? void 0 : _field4.get('field')];
+    } else if ((_field5 = field) !== null && _field5 !== void 0 && _field5.has('types')) {
+      var _field6, _field6$get;
+      fields = (_field6 = field) === null || _field6 === void 0 ? void 0 : (_field6$get = _field6.get('types')) === null || _field6$get === void 0 ? void 0 : _field6$get.toArray();
+    }
+  }
+  return field;
+}
+function traverseFields(fields, updater, done = () => false) {
+  if (done()) {
+    return fields;
+  }
+  fields = fields.map(f => {
+    const field = updater(f);
+    if (done()) {
+      return field;
+    } else if (field.has('fields')) {
+      return field.set('fields', traverseFields(field.get('fields'), updater, done));
+    } else if (field.has('field')) {
+      return field.set('field', traverseFields((0, _immutable.List)([field.get('field')]), updater, done).get(0));
+    } else if (field.has('types')) {
+      return field.set('types', traverseFields(field.get('types'), updater, done));
+    } else {
+      return field;
+    }
+  }).toList();
+  return fields;
+}
+function updateFieldByKey(collection, key, updater) {
+  const selected = selectField(collection, key);
+  if (!selected) {
+    return collection;
+  }
+  let updated = false;
+  function updateAndBreak(f) {
+    const field = f;
+    if (field === selected) {
+      updated = true;
+      return updater(field);
+    } else {
+      return field;
+    }
+  }
+  collection = collection.set('fields', traverseFields(collection.get('fields', (0, _immutable.List)()), updateAndBreak, () => updated));
+  return collection;
+}
+function selectIdentifier(collection) {
+  const identifier = collection.get('identifier_field');
+  const identifierFields = identifier ? [identifier, ..._fieldInference.IDENTIFIER_FIELDS] : [..._fieldInference.IDENTIFIER_FIELDS];
+  const fieldNames = getFieldsNames(collection.get('fields', (0, _immutable.List)()).toArray());
+  return identifierFields.find(id => fieldNames.find(name => name.toLowerCase().trim() === id.toLowerCase().trim()));
+}
+function selectInferredField(collection, fieldName) {
+  if (fieldName === 'title' && collection.get('identifier_field')) {
+    return selectIdentifier(collection);
+  }
+  const inferableField = _fieldInference.INFERABLE_FIELDS[fieldName];
+  const fields = collection.get('fields');
+  let field;
+
+  // If collection has no fields or fieldName is not defined within inferables list, return null
+  if (!fields || !inferableField) return null;
+  // Try to return a field of the specified type with one of the synonyms
+  const mainTypeFields = fields.filter(f => (f === null || f === void 0 ? void 0 : f.get('widget', 'string')) === inferableField.type).map(f => f === null || f === void 0 ? void 0 : f.get('name'));
+  field = mainTypeFields.filter(f => inferableField.synonyms.indexOf(f) !== -1);
+  if (field && field.size > 0) return field.first();
+
+  // Try to return a field for each of the specified secondary types
+  const secondaryTypeFields = fields.filter(f => inferableField.secondaryTypes.indexOf(f === null || f === void 0 ? void 0 : f.get('widget', 'string')) !== -1).map(f => f === null || f === void 0 ? void 0 : f.get('name'));
+  field = secondaryTypeFields.filter(f => inferableField.synonyms.indexOf(f) !== -1);
+  if (field && field.size > 0) return field.first();
+
+  // Try to return the first field of the specified type
+  if (inferableField.fallbackToFirstField && mainTypeFields.size > 0) return mainTypeFields.first();
+
+  // Coundn't infer the field. Show error and return null.
+  if (inferableField.showError) {
+    (0, _consoleError.default)(`The Field ${fieldName} is missing for the collection “${collection.get('name')}”`, `Decap CMS tries to infer the entry ${fieldName} automatically, but one couldn't be found for entries of the collection “${collection.get('name')}”. Please check your site configuration.`);
+  }
+  return null;
+}
+function selectEntryCollectionTitle(collection, entry) {
+  // prefer formatted summary over everything else
+  const summaryTemplate = collection.get('summary');
+  if (summaryTemplate) return (0, _formatters.summaryFormatter)(summaryTemplate, entry, collection);
+
+  // if the collection is a file collection return the label of the entry
+  if (collection.get('type') == _collectionTypes.FILES) {
+    const label = selectFileEntryLabel(collection, entry.get('slug'));
+    if (label) return label;
+  }
+
+  // try to infer a title field from the entry data
+  const entryData = entry.get('data');
+  const titleField = selectInferredField(collection, 'title');
+  const result = titleField && entryData.getIn(keyToPathArray(titleField));
+
+  // if the custom field does not yield a result, fallback to 'title'
+  if (!result && titleField !== 'title') {
+    return entryData.getIn(keyToPathArray('title'));
+  }
+  return result;
+}
+function selectDefaultSortableFields(collection, backend, hasIntegration) {
+  let defaultSortable = _fieldInference.SORTABLE_FIELDS.map(type => {
+    const field = selectInferredField(collection, type);
+    if (backend.isGitBackend() && type === 'author' && !field && !hasIntegration) {
+      // default to commit author if not author field is found
+      return _commitProps.COMMIT_AUTHOR;
+    }
+    return field;
+  }).filter(Boolean);
+  if (backend.isGitBackend() && !hasIntegration) {
+    // always have commit date by default
+    defaultSortable = [_commitProps.COMMIT_DATE, ...defaultSortable];
+  }
+  return defaultSortable;
+}
+function selectSortableFields(collection, t) {
+  const fields = collection.get('sortable_fields').toArray().map(key => {
+    if (key === _commitProps.COMMIT_DATE) {
+      return {
+        key,
+        field: {
+          name: key,
+          label: t('collection.defaultFields.updatedOn.label')
+        }
+      };
+    }
+    const field = selectField(collection, key);
+    if (key === _commitProps.COMMIT_AUTHOR && !field) {
+      return {
+        key,
+        field: {
+          name: key,
+          label: t('collection.defaultFields.author.label')
+        }
+      };
+    }
+    return {
+      key,
+      field: field === null || field === void 0 ? void 0 : field.toJS()
+    };
+  }).filter(item => !!item.field).map(item => _objectSpread(_objectSpread({}, item.field), {}, {
+    key: item.key
+  }));
+  return fields;
+}
+function selectSortDataPath(collection, key) {
+  if (key === _commitProps.COMMIT_DATE) {
+    return 'updatedOn';
+  } else if (key === _commitProps.COMMIT_AUTHOR && !selectField(collection, key)) {
+    return 'author';
+  } else {
+    return `data.${key}`;
+  }
+}
+function selectViewFilters(collection) {
+  const viewFilters = collection.get('view_filters').toJS();
+  return viewFilters;
+}
+function selectViewGroups(collection) {
+  const viewGroups = collection.get('view_groups').toJS();
+  return viewGroups;
+}
+function selectFieldsComments(collection, entryMap) {
+  let fields = [];
+  if (collection.has('folder')) {
+    fields = collection.get('fields').toArray();
+  } else if (collection.has('files')) {
+    const file = collection.get('files').find(f => (f === null || f === void 0 ? void 0 : f.get('name')) === entryMap.get('slug'));
+    fields = file.get('fields').toArray();
+  }
+  const comments = {};
+  const names = getFieldsNames(fields);
+  names.forEach(name => {
+    const field = selectField(collection, name);
+    if (field !== null && field !== void 0 && field.has('comment')) {
+      comments[name] = field.get('comment');
+    }
+  });
+  return comments;
+}
+function selectHasMetaPath(collection) {
+  var _collection$get2;
+  return collection.has('folder') && collection.get('type') === _collectionTypes.FOLDER && collection.has('meta') && ((_collection$get2 = collection.get('meta')) === null || _collection$get2 === void 0 ? void 0 : _collection$get2.has('path'));
+}
+var _default = exports.default = collections;

node_modules/decap-cms-core/dist/esm/reducers/combinedReducer.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _redux = require("redux");
+var _index = _interopRequireDefault(require("./index"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function createRootReducer() {
+  return (0, _redux.combineReducers)(_objectSpread({}, _index.default));
+}
+var _default = exports.default = createRootReducer;

node_modules/decap-cms-core/dist/esm/reducers/config.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectLocale = selectLocale;
+exports.selectUseWorkflow = selectUseWorkflow;
+var _immer = require("immer");
+var _config = require("../actions/config");
+var _publishModes = require("../constants/publishModes");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const defaultState = {
+  isFetching: true
+};
+const config = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _config.CONFIG_REQUEST:
+      state.isFetching = true;
+      break;
+    case _config.CONFIG_SUCCESS:
+      return _objectSpread(_objectSpread({}, action.payload), {}, {
+        isFetching: false,
+        error: undefined
+      });
+    case _config.CONFIG_FAILURE:
+      state.isFetching = false;
+      state.error = action.payload.toString();
+  }
+}, defaultState);
+function selectLocale(state) {
+  return state.locale || 'en';
+}
+function selectUseWorkflow(state) {
+  return state.publish_mode === _publishModes.EDITORIAL_WORKFLOW;
+}
+var _default = exports.default = config;

node_modules/decap-cms-core/dist/esm/reducers/cursors.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectCollectionEntriesCursor = selectCollectionEntriesCursor;
+var _immutable = require("immutable");
+var _decapCmsLibUtil = require("decap-cms-lib-util");
+var _entries = require("../actions/entries");
+// Since pagination can be used for a variety of views (collections
+// and searches are the most common examples), we namespace cursors by
+// their type before storing them in the state.
+function selectCollectionEntriesCursor(state, collectionName) {
+  return new _decapCmsLibUtil.Cursor(state.getIn(['cursorsByType', 'collectionEntries', collectionName]));
+}
+function cursors(state = (0, _immutable.fromJS)({
+  cursorsByType: {
+    collectionEntries: {}
+  }
+}), action) {
+  switch (action.type) {
+    case _entries.ENTRIES_SUCCESS:
+      {
+        return state.setIn(['cursorsByType', 'collectionEntries', action.payload.collection], _decapCmsLibUtil.Cursor.create(action.payload.cursor).store);
+      }
+    case _entries.FILTER_ENTRIES_SUCCESS:
+    case _entries.GROUP_ENTRIES_SUCCESS:
+    case _entries.SORT_ENTRIES_SUCCESS:
+      {
+        return state.deleteIn(['cursorsByType', 'collectionEntries', action.payload.collection]);
+      }
+    default:
+      return state;
+  }
+}
+var _default = exports.default = cursors;

node_modules/decap-cms-core/dist/esm/reducers/deploys.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectDeployPreview = selectDeployPreview;
+var _immer = require("immer");
+var _deploys = require("../actions/deploys");
+const defaultState = {};
+const deploys = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _deploys.DEPLOY_PREVIEW_REQUEST:
+      {
+        const {
+          collection,
+          slug
+        } = action.payload;
+        const key = `${collection}.${slug}`;
+        state[key] = state[key] || {};
+        state[key].isFetching = true;
+        break;
+      }
+    case _deploys.DEPLOY_PREVIEW_SUCCESS:
+      {
+        const {
+          collection,
+          slug,
+          url,
+          status
+        } = action.payload;
+        const key = `${collection}.${slug}`;
+        state[key].isFetching = false;
+        state[key].url = url;
+        state[key].status = status;
+        break;
+      }
+    case _deploys.DEPLOY_PREVIEW_FAILURE:
+      {
+        const {
+          collection,
+          slug
+        } = action.payload;
+        state[`${collection}.${slug}`].isFetching = false;
+        break;
+      }
+  }
+}, defaultState);
+function selectDeployPreview(state, collection, slug) {
+  return state[`${collection}.${slug}`];
+}
+var _default = exports.default = deploys;

node_modules/decap-cms-core/dist/esm/reducers/editorialWorkflow.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectUnpublishedEntriesByStatus = selectUnpublishedEntriesByStatus;
+exports.selectUnpublishedEntry = selectUnpublishedEntry;
+exports.selectUnpublishedSlugs = selectUnpublishedSlugs;
+var _startsWith2 = _interopRequireDefault(require("lodash/startsWith"));
+var _immutable = require("immutable");
+var _publishModes = require("../constants/publishModes");
+var _editorialWorkflow = require("../actions/editorialWorkflow");
+var _config = require("../actions/config");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function unpublishedEntries(state = (0, _immutable.Map)(), action) {
+  switch (action.type) {
+    case _config.CONFIG_SUCCESS:
+      {
+        const publishMode = action.payload && action.payload.publish_mode;
+        if (publishMode === _publishModes.EDITORIAL_WORKFLOW) {
+          //  Editorial workflow state is explicitly initiated after the config.
+          return (0, _immutable.Map)({
+            entities: (0, _immutable.Map)(),
+            pages: (0, _immutable.Map)()
+          });
+        }
+        return state;
+      }
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_REQUEST:
+      return state.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isFetching'], true);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_REDIRECT:
+      return state.deleteIn(['entities', `${action.payload.collection}.${action.payload.slug}`]);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_SUCCESS:
+      return state.setIn(['entities', `${action.payload.collection}.${action.payload.entry.slug}`], (0, _immutable.fromJS)(action.payload.entry));
+    case _editorialWorkflow.UNPUBLISHED_ENTRIES_REQUEST:
+      return state.setIn(['pages', 'isFetching'], true);
+    case _editorialWorkflow.UNPUBLISHED_ENTRIES_SUCCESS:
+      return state.withMutations(map => {
+        action.payload.entries.forEach(entry => map.setIn(['entities', `${entry.collection}.${entry.slug}`], (0, _immutable.fromJS)(entry).set('isFetching', false)));
+        map.set('pages', (0, _immutable.Map)(_objectSpread(_objectSpread({}, action.payload.pages), {}, {
+          ids: (0, _immutable.List)(action.payload.entries.map(entry => entry.slug))
+        })));
+      });
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PERSIST_REQUEST:
+      {
+        return state.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isPersisting'], true);
+      }
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PERSIST_SUCCESS:
+      // Update Optimistically
+      return state.withMutations(map => {
+        map.setIn(['entities', `${action.payload.collection}.${action.payload.entry.get('slug')}`], (0, _immutable.fromJS)(action.payload.entry));
+        map.deleteIn(['entities', `${action.payload.collection}.${action.payload.entry.get('slug')}`, 'isPersisting']);
+        map.updateIn(['pages', 'ids'], (0, _immutable.List)(), list => list.push(action.payload.entry.get('slug')));
+      });
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PERSIST_FAILURE:
+      return state.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isPersisting'], false);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_STATUS_CHANGE_REQUEST:
+      // Update Optimistically
+      return state.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isUpdatingStatus'], true);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_STATUS_CHANGE_SUCCESS:
+      return state.withMutations(map => {
+        map.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'status'], action.payload.newStatus);
+        map.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isUpdatingStatus'], false);
+      });
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_STATUS_CHANGE_FAILURE:
+      return state.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isUpdatingStatus'], false);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PUBLISH_REQUEST:
+      return state.setIn(['entities', `${action.payload.collection}.${action.payload.slug}`, 'isPublishing'], true);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PUBLISH_SUCCESS:
+      return state.deleteIn(['entities', `${action.payload.collection}.${action.payload.slug}`]);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_DELETE_SUCCESS:
+      return state.deleteIn(['entities', `${action.payload.collection}.${action.payload.slug}`]);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PUBLISH_FAILURE:
+    default:
+      return state;
+  }
+}
+function selectUnpublishedEntry(state, collection, slug) {
+  return state && state.getIn(['entities', `${collection}.${slug}`]);
+}
+function selectUnpublishedEntriesByStatus(state, status) {
+  if (!state) return null;
+  const entities = state.get('entities');
+  return entities.filter(entry => entry.get('status') === status).valueSeq();
+}
+function selectUnpublishedSlugs(state, collection) {
+  if (!state.get('entities')) return null;
+  const entities = state.get('entities');
+  return entities.filter((_v, k) => (0, _startsWith2.default)(k, `${collection}.`)).map(entry => entry.get('slug')).valueSeq();
+}
+var _default = exports.default = unpublishedEntries;

node_modules/decap-cms-core/dist/esm/reducers/entries.js

@@ -0,0 +1,590 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectEditingDraft = selectEditingDraft;
+exports.selectEntries = selectEntries;
+exports.selectEntriesFilter = selectEntriesFilter;
+exports.selectEntriesFilterFields = selectEntriesFilterFields;
+exports.selectEntriesGroup = selectEntriesGroup;
+exports.selectEntriesGroupField = selectEntriesGroupField;
+exports.selectEntriesLoaded = selectEntriesLoaded;
+exports.selectEntriesSort = selectEntriesSort;
+exports.selectEntriesSortFields = selectEntriesSortFields;
+exports.selectEntry = selectEntry;
+exports.selectEntryByPath = selectEntryByPath;
+exports.selectGroups = selectGroups;
+exports.selectIsFetching = selectIsFetching;
+exports.selectMediaFilePath = selectMediaFilePath;
+exports.selectMediaFilePublicPath = selectMediaFilePublicPath;
+exports.selectMediaFolder = selectMediaFolder;
+exports.selectPublishedSlugs = selectPublishedSlugs;
+exports.selectViewStyle = selectViewStyle;
+var _groupBy2 = _interopRequireDefault(require("lodash/groupBy"));
+var _orderBy2 = _interopRequireDefault(require("lodash/orderBy"));
+var _set2 = _interopRequireDefault(require("lodash/set"));
+var _sortBy2 = _interopRequireDefault(require("lodash/sortBy"));
+var _once2 = _interopRequireDefault(require("lodash/once"));
+var _trim2 = _interopRequireDefault(require("lodash/trim"));
+var _immutable = require("immutable");
+var _path = require("path");
+var _decapCmsLibUtil = require("decap-cms-lib-util");
+var _decapCmsLibWidgets = require("decap-cms-lib-widgets");
+var _redux = require("../types/redux");
+var _formatters = require("../lib/formatters");
+var _collections = require("./collections");
+var _search = require("../actions/search");
+var _entries = require("../actions/entries");
+var _collectionViews = require("../constants/collectionViews");
+var _urlHelper = require("../lib/urlHelper");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const {
+  keyToPathArray
+} = _decapCmsLibWidgets.stringTemplate;
+let collection;
+let loadedEntries;
+let append;
+let page;
+let slug;
+const storageSortKey = 'decap-cms.entries.sort';
+const viewStyleKey = 'decap-cms.entries.viewStyle';
+const loadSort = (0, _once2.default)(() => {
+  const sortString = localStorage.getItem(storageSortKey);
+  if (sortString) {
+    try {
+      const sort = JSON.parse(sortString);
+      let map = (0, _immutable.Map)();
+      Object.entries(sort).forEach(([collection, sort]) => {
+        let orderedMap = (0, _immutable.OrderedMap)();
+        (0, _sortBy2.default)(Object.values(sort), ['index']).forEach(value => {
+          const {
+            key,
+            direction
+          } = value;
+          orderedMap = orderedMap.set(key, (0, _immutable.fromJS)({
+            key,
+            direction
+          }));
+        });
+        map = map.set(collection, orderedMap);
+      });
+      return map;
+    } catch (e) {
+      return (0, _immutable.Map)();
+    }
+  }
+  return (0, _immutable.Map)();
+});
+function clearSort() {
+  localStorage.removeItem(storageSortKey);
+}
+function persistSort(sort) {
+  if (sort) {
+    const storageSort = {};
+    sort.keySeq().forEach(key => {
+      const collection = key;
+      const sortObjects = sort.get(collection).valueSeq().toJS().map((value, index) => _objectSpread(_objectSpread({}, value), {}, {
+        index
+      }));
+      sortObjects.forEach(value => {
+        (0, _set2.default)(storageSort, [collection, value.key], value);
+      });
+    });
+    localStorage.setItem(storageSortKey, JSON.stringify(storageSort));
+  } else {
+    clearSort();
+  }
+}
+const loadViewStyle = (0, _once2.default)(() => {
+  const viewStyle = localStorage.getItem(viewStyleKey);
+  if (viewStyle) {
+    return viewStyle;
+  }
+  localStorage.setItem(viewStyleKey, _collectionViews.VIEW_STYLE_LIST);
+  return _collectionViews.VIEW_STYLE_LIST;
+});
+function clearViewStyle() {
+  localStorage.removeItem(viewStyleKey);
+}
+function persistViewStyle(viewStyle) {
+  if (viewStyle) {
+    localStorage.setItem(viewStyleKey, viewStyle);
+  } else {
+    clearViewStyle();
+  }
+}
+function entries(state = (0, _immutable.Map)({
+  entities: (0, _immutable.Map)(),
+  pages: (0, _immutable.Map)(),
+  sort: loadSort(),
+  viewStyle: loadViewStyle()
+}), action) {
+  switch (action.type) {
+    case _entries.ENTRY_REQUEST:
+      {
+        const payload = action.payload;
+        return state.setIn(['entities', `${payload.collection}.${payload.slug}`, 'isFetching'], true);
+      }
+    case _entries.ENTRY_SUCCESS:
+      {
+        const payload = action.payload;
+        collection = payload.collection;
+        slug = payload.entry.slug;
+        return state.withMutations(map => {
+          map.setIn(['entities', `${collection}.${slug}`], (0, _immutable.fromJS)(payload.entry));
+          const ids = map.getIn(['pages', collection, 'ids'], (0, _immutable.List)());
+          if (!ids.includes(slug)) {
+            map.setIn(['pages', collection, 'ids'], ids.unshift(slug));
+          }
+        });
+      }
+    case _entries.ENTRIES_REQUEST:
+      {
+        const payload = action.payload;
+        const newState = state.withMutations(map => {
+          map.setIn(['pages', payload.collection, 'isFetching'], true);
+        });
+        return newState;
+      }
+    case _entries.ENTRIES_SUCCESS:
+      {
+        const payload = action.payload;
+        collection = payload.collection;
+        loadedEntries = payload.entries;
+        append = payload.append;
+        page = payload.page;
+        return state.withMutations(map => {
+          loadedEntries.forEach(entry => map.setIn(['entities', `${collection}.${entry.slug}`], (0, _immutable.fromJS)(entry).set('isFetching', false)));
+          const ids = (0, _immutable.List)(loadedEntries.map(entry => entry.slug));
+          map.setIn(['pages', collection], (0, _immutable.Map)({
+            page,
+            ids: append ? map.getIn(['pages', collection, 'ids'], (0, _immutable.List)()).concat(ids) : ids
+          }));
+        });
+      }
+    case _entries.ENTRIES_FAILURE:
+      return state.setIn(['pages', action.meta.collection, 'isFetching'], false);
+    case _entries.ENTRY_FAILURE:
+      {
+        const payload = action.payload;
+        return state.withMutations(map => {
+          map.setIn(['entities', `${payload.collection}.${payload.slug}`, 'isFetching'], false);
+          map.setIn(['entities', `${payload.collection}.${payload.slug}`, 'error'], payload.error.message);
+        });
+      }
+    case _search.SEARCH_ENTRIES_SUCCESS:
+      {
+        const payload = action.payload;
+        loadedEntries = payload.entries;
+        return state.withMutations(map => {
+          loadedEntries.forEach(entry => map.setIn(['entities', `${entry.collection}.${entry.slug}`], (0, _immutable.fromJS)(entry).set('isFetching', false)));
+        });
+      }
+    case _entries.ENTRY_DELETE_SUCCESS:
+      {
+        const payload = action.payload;
+        return state.withMutations(map => {
+          map.deleteIn(['entities', `${payload.collectionName}.${payload.entrySlug}`]);
+          map.updateIn(['pages', payload.collectionName, 'ids'], ids => ids.filter(id => id !== payload.entrySlug));
+        });
+      }
+    case _entries.SORT_ENTRIES_REQUEST:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          key,
+          direction
+        } = payload;
+        const newState = state.withMutations(map => {
+          const sort = (0, _immutable.OrderedMap)({
+            [key]: (0, _immutable.Map)({
+              key,
+              direction
+            })
+          });
+          map.setIn(['sort', collection], sort);
+          map.setIn(['pages', collection, 'isFetching'], true);
+          map.deleteIn(['pages', collection, 'page']);
+        });
+        persistSort(newState.get('sort'));
+        return newState;
+      }
+    case _entries.GROUP_ENTRIES_SUCCESS:
+    case _entries.FILTER_ENTRIES_SUCCESS:
+    case _entries.SORT_ENTRIES_SUCCESS:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          entries
+        } = payload;
+        loadedEntries = entries;
+        const newState = state.withMutations(map => {
+          loadedEntries.forEach(entry => map.setIn(['entities', `${entry.collection}.${entry.slug}`], (0, _immutable.fromJS)(entry).set('isFetching', false)));
+          map.setIn(['pages', collection, 'isFetching'], false);
+          const ids = (0, _immutable.List)(loadedEntries.map(entry => entry.slug));
+          map.setIn(['pages', collection], (0, _immutable.Map)({
+            page: 1,
+            ids
+          }));
+        });
+        return newState;
+      }
+    case _entries.SORT_ENTRIES_FAILURE:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          key
+        } = payload;
+        const newState = state.withMutations(map => {
+          map.deleteIn(['sort', collection, key]);
+          map.setIn(['pages', collection, 'isFetching'], false);
+        });
+        persistSort(newState.get('sort'));
+        return newState;
+      }
+    case _entries.FILTER_ENTRIES_REQUEST:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          filter
+        } = payload;
+        const newState = state.withMutations(map => {
+          const current = map.getIn(['filter', collection, filter.id], (0, _immutable.fromJS)(filter));
+          map.setIn(['filter', collection, current.get('id')], current.set('active', !current.get('active')));
+        });
+        return newState;
+      }
+    case _entries.FILTER_ENTRIES_FAILURE:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          filter
+        } = payload;
+        const newState = state.withMutations(map => {
+          map.deleteIn(['filter', collection, filter.id]);
+          map.setIn(['pages', collection, 'isFetching'], false);
+        });
+        return newState;
+      }
+    case _entries.GROUP_ENTRIES_REQUEST:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          group
+        } = payload;
+        const newState = state.withMutations(map => {
+          const current = map.getIn(['group', collection, group.id], (0, _immutable.fromJS)(group));
+          map.deleteIn(['group', collection]);
+          map.setIn(['group', collection, current.get('id')], current.set('active', !current.get('active')));
+        });
+        return newState;
+      }
+    case _entries.GROUP_ENTRIES_FAILURE:
+      {
+        const payload = action.payload;
+        const {
+          collection,
+          group
+        } = payload;
+        const newState = state.withMutations(map => {
+          map.deleteIn(['group', collection, group.id]);
+          map.setIn(['pages', collection, 'isFetching'], false);
+        });
+        return newState;
+      }
+    case _entries.CHANGE_VIEW_STYLE:
+      {
+        const payload = action.payload;
+        const {
+          style
+        } = payload;
+        const newState = state.withMutations(map => {
+          map.setIn(['viewStyle'], style);
+        });
+        persistViewStyle(newState.get('viewStyle'));
+        return newState;
+      }
+    default:
+      return state;
+  }
+}
+function selectEntriesSort(entries, collection) {
+  const sort = entries.get('sort');
+  return sort === null || sort === void 0 ? void 0 : sort.get(collection);
+}
+function selectEntriesFilter(entries, collection) {
+  const filter = entries.get('filter');
+  return (filter === null || filter === void 0 ? void 0 : filter.get(collection)) || (0, _immutable.Map)();
+}
+function selectEntriesGroup(entries, collection) {
+  const group = entries.get('group');
+  return (group === null || group === void 0 ? void 0 : group.get(collection)) || (0, _immutable.Map)();
+}
+function selectEntriesGroupField(entries, collection) {
+  const groups = selectEntriesGroup(entries, collection);
+  const value = groups === null || groups === void 0 ? void 0 : groups.valueSeq().find(v => (v === null || v === void 0 ? void 0 : v.get('active')) === true);
+  return value;
+}
+function selectEntriesSortFields(entries, collection) {
+  const sort = selectEntriesSort(entries, collection);
+  const values = (sort === null || sort === void 0 ? void 0 : sort.valueSeq().filter(v => (v === null || v === void 0 ? void 0 : v.get('direction')) !== _redux.SortDirection.None).toArray()) || [];
+  return values;
+}
+function selectEntriesFilterFields(entries, collection) {
+  const filter = selectEntriesFilter(entries, collection);
+  const values = (filter === null || filter === void 0 ? void 0 : filter.valueSeq().filter(v => (v === null || v === void 0 ? void 0 : v.get('active')) === true).toArray()) || [];
+  return values;
+}
+function selectViewStyle(entries) {
+  return entries.get('viewStyle');
+}
+function selectEntry(state, collection, slug) {
+  return state.getIn(['entities', `${collection}.${slug}`]);
+}
+function selectPublishedSlugs(state, collection) {
+  return state.getIn(['pages', collection, 'ids'], (0, _immutable.List)());
+}
+function getPublishedEntries(state, collectionName) {
+  const slugs = selectPublishedSlugs(state, collectionName);
+  const entries = slugs && slugs.map(slug => selectEntry(state, collectionName, slug));
+  return entries;
+}
+function selectEntries(state, collection) {
+  const collectionName = collection.get('name');
+  let entries = getPublishedEntries(state, collectionName);
+  const sortFields = selectEntriesSortFields(state, collectionName);
+  if (sortFields && sortFields.length > 0) {
+    const keys = sortFields.map(v => (0, _collections.selectSortDataPath)(collection, v.get('key')));
+    const orders = sortFields.map(v => v.get('direction') === _redux.SortDirection.Ascending ? 'asc' : 'desc');
+    entries = (0, _immutable.fromJS)((0, _orderBy2.default)(entries.toJS(), keys, orders));
+  }
+  const filters = selectEntriesFilterFields(state, collectionName);
+  if (filters && filters.length > 0) {
+    entries = entries.filter(e => {
+      const allMatched = filters.every(f => {
+        const pattern = f.get('pattern');
+        const field = f.get('field');
+        const data = e.get('data') || (0, _immutable.Map)();
+        const toMatch = data.getIn(keyToPathArray(field));
+        const matched = toMatch !== undefined && new RegExp(String(pattern)).test(String(toMatch));
+        return matched;
+      });
+      return allMatched;
+    }).toList();
+  }
+  return entries;
+}
+function getGroup(entry, selectedGroup) {
+  const label = selectedGroup.get('label');
+  const field = selectedGroup.get('field');
+  const fieldData = entry.getIn(['data', ...keyToPathArray(field)]);
+  if (fieldData === undefined) {
+    return {
+      id: 'missing_value',
+      label,
+      value: fieldData
+    };
+  }
+  const dataAsString = String(fieldData);
+  if (selectedGroup.has('pattern')) {
+    const pattern = selectedGroup.get('pattern');
+    let value = '';
+    try {
+      const regex = new RegExp(pattern);
+      const matched = dataAsString.match(regex);
+      if (matched) {
+        value = matched[0];
+      }
+    } catch (e) {
+      console.warn(`Invalid view group pattern '${pattern}' for field '${field}'`, e);
+    }
+    return {
+      id: `${label}${value}`,
+      label,
+      value
+    };
+  }
+  return {
+    id: `${label}${fieldData}`,
+    label,
+    value: typeof fieldData === 'boolean' ? fieldData : dataAsString
+  };
+}
+function selectGroups(state, collection) {
+  const collectionName = collection.get('name');
+  const entries = getPublishedEntries(state, collectionName);
+  const selectedGroup = selectEntriesGroupField(state, collectionName);
+  if (selectedGroup === undefined) {
+    return [];
+  }
+  let groups = {};
+  const groupedEntries = (0, _groupBy2.default)(entries.toArray(), entry => {
+    const group = getGroup(entry, selectedGroup);
+    groups = _objectSpread(_objectSpread({}, groups), {}, {
+      [group.id]: group
+    });
+    return group.id;
+  });
+  const groupsArray = Object.entries(groupedEntries).map(([id, entries]) => {
+    return _objectSpread(_objectSpread({}, groups[id]), {}, {
+      paths: (0, _immutable.Set)(entries.map(entry => entry.get('path')))
+    });
+  });
+  return groupsArray;
+}
+function selectEntryByPath(state, collection, path) {
+  const slugs = selectPublishedSlugs(state, collection);
+  const entries = slugs && slugs.map(slug => selectEntry(state, collection, slug));
+  return entries && entries.find(e => (e === null || e === void 0 ? void 0 : e.get('path')) === path);
+}
+function selectEntriesLoaded(state, collection) {
+  return !!state.getIn(['pages', collection]);
+}
+function selectIsFetching(state, collection) {
+  return state.getIn(['pages', collection, 'isFetching'], false);
+}
+const DRAFT_MEDIA_FILES = 'DRAFT_MEDIA_FILES';
+function getFileField(collectionFiles, slug) {
+  const file = collectionFiles.find(f => (f === null || f === void 0 ? void 0 : f.get('name')) === slug);
+  return file;
+}
+function hasCustomFolder(folderKey, collection, slug, field) {
+  if (!collection) {
+    return false;
+  }
+  if (field && field.has(folderKey)) {
+    return true;
+  }
+  if (collection.has('files')) {
+    const file = getFileField(collection.get('files'), slug);
+    if (file && file.has(folderKey)) {
+      return true;
+    }
+  }
+  if (collection.has(folderKey)) {
+    return true;
+  }
+  return false;
+}
+function traverseFields(folderKey, config, collection, entryMap, field, fields, currentFolder) {
+  const matchedField = fields.filter(f => f === field)[0];
+  if (matchedField) {
+    return (0, _formatters.folderFormatter)(matchedField.has(folderKey) ? matchedField.get(folderKey) : `{{${folderKey}}}`, entryMap, collection, currentFolder, folderKey, config.slug);
+  }
+  for (let f of fields) {
+    if (!f.has(folderKey)) {
+      // add identity template if doesn't exist
+      f = f.set(folderKey, `{{${folderKey}}}`);
+    }
+    const folder = (0, _formatters.folderFormatter)(f.get(folderKey), entryMap, collection, currentFolder, folderKey, config.slug);
+    let fieldFolder = null;
+    if (f.has('fields')) {
+      fieldFolder = traverseFields(folderKey, config, collection, entryMap, field, f.get('fields').toArray(), folder);
+    } else if (f.has('field')) {
+      fieldFolder = traverseFields(folderKey, config, collection, entryMap, field, [f.get('field')], folder);
+    } else if (f.has('types')) {
+      fieldFolder = traverseFields(folderKey, config, collection, entryMap, field, f.get('types').toArray(), folder);
+    }
+    if (fieldFolder != null) {
+      return fieldFolder;
+    }
+  }
+  return null;
+}
+function evaluateFolder(folderKey, config, collection, entryMap, field) {
+  let currentFolder = config[folderKey];
+
+  // add identity template if doesn't exist
+  if (!collection.has(folderKey)) {
+    collection = collection.set(folderKey, `{{${folderKey}}}`);
+  }
+  if (collection.has('files')) {
+    // files collection evaluate the collection template
+    // then move on to the specific file configuration denoted by the slug
+    currentFolder = (0, _formatters.folderFormatter)(collection.get(folderKey), entryMap, collection, currentFolder, folderKey, config.slug);
+    let file = getFileField(collection.get('files'), entryMap === null || entryMap === void 0 ? void 0 : entryMap.get('slug'));
+    if (file) {
+      if (!file.has(folderKey)) {
+        // add identity template if doesn't exist
+        file = file.set(folderKey, `{{${folderKey}}}`);
+      }
+
+      // evaluate the file template and keep evaluating until we match our field
+      currentFolder = (0, _formatters.folderFormatter)(file.get(folderKey), entryMap, collection, currentFolder, folderKey, config.slug);
+      if (field) {
+        const fieldFolder = traverseFields(folderKey, config, collection, entryMap, field, file.get('fields').toArray(), currentFolder);
+        if (fieldFolder !== null) {
+          currentFolder = fieldFolder;
+        }
+      }
+    }
+  } else {
+    // folder collection, evaluate the collection template
+    // and keep evaluating until we match our field
+    currentFolder = (0, _formatters.folderFormatter)(collection.get(folderKey), entryMap, collection, currentFolder, folderKey, config.slug);
+    if (field) {
+      const fieldFolder = traverseFields(folderKey, config, collection, entryMap, field, collection.get('fields').toArray(), currentFolder);
+      if (fieldFolder !== null) {
+        currentFolder = fieldFolder;
+      }
+    }
+  }
+  return currentFolder;
+}
+function selectMediaFolder(config, collection, entryMap, field) {
+  const name = 'media_folder';
+  let mediaFolder = config[name];
+  const customFolder = hasCustomFolder(name, collection, entryMap === null || entryMap === void 0 ? void 0 : entryMap.get('slug'), field);
+  if (customFolder) {
+    const folder = evaluateFolder(name, config, collection, entryMap, field);
+    if (folder.startsWith('/')) {
+      // return absolute paths as is
+      mediaFolder = (0, _path.join)(folder);
+    } else {
+      const entryPath = entryMap === null || entryMap === void 0 ? void 0 : entryMap.get('path');
+      mediaFolder = entryPath ? (0, _path.join)((0, _path.dirname)(entryPath), folder) : (0, _path.join)(collection.get('folder'), DRAFT_MEDIA_FILES);
+    }
+  }
+  return (0, _trim2.default)(mediaFolder, '/');
+}
+function selectMediaFilePath(config, collection, entryMap, mediaPath, field) {
+  if ((0, _decapCmsLibUtil.isAbsolutePath)(mediaPath)) {
+    return mediaPath;
+  }
+  const mediaFolder = selectMediaFolder(config, collection, entryMap, field);
+  return (0, _path.join)(mediaFolder, (0, _decapCmsLibUtil.basename)(mediaPath));
+}
+function selectMediaFilePublicPath(config, collection, mediaPath, entryMap, field) {
+  if ((0, _decapCmsLibUtil.isAbsolutePath)(mediaPath)) {
+    return mediaPath;
+  }
+  const name = 'public_folder';
+  let publicFolder = config[name];
+  const customFolder = hasCustomFolder(name, collection, entryMap === null || entryMap === void 0 ? void 0 : entryMap.get('slug'), field);
+  if (customFolder) {
+    publicFolder = evaluateFolder(name, config, collection, entryMap, field);
+  }
+  if ((0, _decapCmsLibUtil.isAbsolutePath)(publicFolder)) {
+    return (0, _urlHelper.joinUrlPath)(publicFolder, (0, _decapCmsLibUtil.basename)(mediaPath));
+  }
+  return (0, _path.join)(publicFolder, (0, _decapCmsLibUtil.basename)(mediaPath));
+}
+function selectEditingDraft(state) {
+  const entry = state.get('entry');
+  const workflowDraft = entry && !entry.isEmpty();
+  return workflowDraft;
+}
+var _default = exports.default = entries;

node_modules/decap-cms-core/dist/esm/reducers/entryDraft.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectCustomPath = selectCustomPath;
+var _get2 = _interopRequireDefault(require("lodash/get"));
+var _immutable = require("immutable");
+var _uuid = require("uuid");
+var _path = require("path");
+var _entries = require("../actions/entries");
+var _editorialWorkflow = require("../actions/editorialWorkflow");
+var _collections = require("./collections");
+var _i18n = require("../lib/i18n");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const initialState = (0, _immutable.Map)({
+  entry: (0, _immutable.Map)(),
+  fieldsMetaData: (0, _immutable.Map)(),
+  fieldsErrors: (0, _immutable.Map)(),
+  hasChanged: false,
+  key: ''
+});
+function entryDraftReducer(state = (0, _immutable.Map)(), action) {
+  switch (action.type) {
+    case _entries.DRAFT_CREATE_FROM_ENTRY:
+      // Existing Entry
+      return state.withMutations(state => {
+        state.set('entry', (0, _immutable.fromJS)(action.payload.entry));
+        state.setIn(['entry', 'newRecord'], false);
+        state.set('fieldsMetaData', (0, _immutable.Map)());
+        state.set('fieldsErrors', (0, _immutable.Map)());
+        state.set('hasChanged', false);
+        state.set('key', (0, _uuid.v4)());
+      });
+    case _entries.DRAFT_CREATE_EMPTY:
+      // New Entry
+      return state.withMutations(state => {
+        state.set('entry', (0, _immutable.fromJS)(action.payload));
+        state.setIn(['entry', 'newRecord'], true);
+        state.set('fieldsMetaData', (0, _immutable.Map)());
+        state.set('fieldsErrors', (0, _immutable.Map)());
+        state.set('hasChanged', false);
+        state.set('key', (0, _uuid.v4)());
+      });
+    case _entries.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', (0, _immutable.Map)());
+        state.set('fieldsErrors', (0, _immutable.Map)());
+        state.set('hasChanged', true);
+        state.set('key', (0, _uuid.v4)());
+      });
+    case _entries.DRAFT_CREATE_DUPLICATE_FROM_ENTRY:
+      // Duplicate Entry
+      return state.withMutations(state => {
+        state.set('entry', (0, _immutable.fromJS)(action.payload));
+        state.setIn(['entry', 'newRecord'], true);
+        state.set('mediaFiles', (0, _immutable.List)());
+        state.set('fieldsMetaData', (0, _immutable.Map)());
+        state.set('fieldsErrors', (0, _immutable.Map)());
+        state.set('hasChanged', true);
+      });
+    case _entries.DRAFT_DISCARD:
+      return initialState;
+    case _entries.DRAFT_LOCAL_BACKUP_RETRIEVED:
+      {
+        const {
+          entry
+        } = action.payload;
+        const newState = new _immutable.Map({
+          entry: (0, _immutable.fromJS)(entry)
+        });
+        return state.set('localBackup', newState);
+      }
+    case _entries.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 && (0, _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 = (0, _i18n.duplicateI18nFields)(state, field, i18n.locales, i18n.defaultLocale);
+            }
+          }
+          state.mergeDeepIn(['fieldsMetaData'], (0, _immutable.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 _entries.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 _entries.DRAFT_CLEAR_ERRORS:
+      {
+        return state.set('fieldsErrors', (0, _immutable.Map)());
+      }
+    case _entries.ENTRY_PERSIST_REQUEST:
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PERSIST_REQUEST:
+      {
+        return state.setIn(['entry', 'isPersisting'], true);
+      }
+    case _entries.ENTRY_PERSIST_FAILURE:
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PERSIST_FAILURE:
+      {
+        return state.deleteIn(['entry', 'isPersisting']);
+      }
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_STATUS_CHANGE_REQUEST:
+      return state.setIn(['entry', 'isUpdatingStatus'], true);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_STATUS_CHANGE_FAILURE:
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_STATUS_CHANGE_SUCCESS:
+      return state.deleteIn(['entry', 'isUpdatingStatus']);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PUBLISH_REQUEST:
+      return state.setIn(['entry', 'isPublishing'], true);
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PUBLISH_SUCCESS:
+    case _editorialWorkflow.UNPUBLISHED_ENTRY_PUBLISH_FAILURE:
+      return state.deleteIn(['entry', 'isPublishing']);
+    case _entries.ENTRY_PERSIST_SUCCESS:
+    case _editorialWorkflow.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 _entries.ENTRY_DELETE_SUCCESS:
+      return state.withMutations(state => {
+        state.deleteIn(['entry', 'isPersisting']);
+        state.set('hasChanged', false);
+      });
+    case _entries.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, (0, _immutable.fromJS)(action.payload)));
+          state.set('hasChanged', true);
+        });
+      }
+    case _entries.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 selectCustomPath(collection, entryDraft) {
+  if (!(0, _collections.selectHasMetaPath)(collection)) {
+    return;
+  }
+  const meta = entryDraft.getIn(['entry', 'meta']);
+  const path = meta && meta.get('path');
+  const indexFile = (0, _get2.default)(collection.toJS(), ['meta', 'path', 'index_file']);
+  const extension = (0, _collections.selectFolderEntryExtension)(collection);
+  const customPath = path && (0, _path.join)(collection.get('folder'), path, `${indexFile}.${extension}`);
+  return customPath;
+}
+var _default = exports.default = entryDraftReducer;

node_modules/decap-cms-core/dist/esm/reducers/globalUI.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _immer = require("immer");
+var _auth = require("../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 = (0, _immer.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 === _auth.USE_OPEN_AUTHORING) {
+    state.useOpenAuthoring = true;
+  }
+}, defaultState);
+var _default = exports.default = globalUI;

node_modules/decap-cms-core/dist/esm/reducers/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectDeployPreview = selectDeployPreview;
+exports.selectEntries = selectEntries;
+exports.selectEntry = selectEntry;
+exports.selectIntegration = selectIntegration;
+exports.selectPublishedSlugs = selectPublishedSlugs;
+exports.selectSearchedEntries = selectSearchedEntries;
+exports.selectUnpublishedEntriesByStatus = selectUnpublishedEntriesByStatus;
+exports.selectUnpublishedEntry = selectUnpublishedEntry;
+exports.selectUnpublishedSlugs = selectUnpublishedSlugs;
+var _immutable = require("immutable");
+var _auth = _interopRequireDefault(require("./auth"));
+var _config = _interopRequireDefault(require("./config"));
+var _integrations = _interopRequireWildcard(require("./integrations"));
+var fromIntegrations = _integrations;
+var _entries = _interopRequireWildcard(require("./entries"));
+var fromEntries = _entries;
+var _cursors = _interopRequireDefault(require("./cursors"));
+var _editorialWorkflow = _interopRequireWildcard(require("./editorialWorkflow"));
+var fromEditorialWorkflow = _editorialWorkflow;
+var _entryDraft = _interopRequireDefault(require("./entryDraft"));
+var _collections = _interopRequireDefault(require("./collections"));
+var _search = _interopRequireDefault(require("./search"));
+var _medias = _interopRequireDefault(require("./medias"));
+var _mediaLibrary = _interopRequireDefault(require("./mediaLibrary"));
+var _deploys = _interopRequireWildcard(require("./deploys"));
+var fromDeploys = _deploys;
+var _globalUI = _interopRequireDefault(require("./globalUI"));
+var _status = _interopRequireDefault(require("./status"));
+var _notifications = _interopRequireDefault(require("./notifications"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const reducers = {
+  auth: _auth.default,
+  config: _config.default,
+  collections: _collections.default,
+  search: _search.default,
+  integrations: _integrations.default,
+  entries: _entries.default,
+  cursors: _cursors.default,
+  editorialWorkflow: _editorialWorkflow.default,
+  entryDraft: _entryDraft.default,
+  medias: _medias.default,
+  mediaLibrary: _mediaLibrary.default,
+  deploys: _deploys.default,
+  globalUI: _globalUI.default,
+  status: _status.default,
+  notifications: _notifications.default
+};
+var _default = exports.default = reducers;
+/*
+ * Selectors
+ */
+function selectEntry(state, collection, slug) {
+  return fromEntries.selectEntry(state.entries, collection, slug);
+}
+function selectEntries(state, collection) {
+  return fromEntries.selectEntries(state.entries, collection);
+}
+function selectPublishedSlugs(state, collection) {
+  return fromEntries.selectPublishedSlugs(state.entries, collection);
+}
+function selectSearchedEntries(state, availableCollections) {
+  // only return search results for actually available collections
+  return (0, _immutable.List)(state.search.entryIds).filter(entryId => availableCollections.indexOf(entryId.collection) !== -1).map(entryId => fromEntries.selectEntry(state.entries, entryId.collection, entryId.slug));
+}
+function selectDeployPreview(state, collection, slug) {
+  return fromDeploys.selectDeployPreview(state.deploys, collection, slug);
+}
+function selectUnpublishedEntry(state, collection, slug) {
+  return fromEditorialWorkflow.selectUnpublishedEntry(state.editorialWorkflow, collection, slug);
+}
+function selectUnpublishedEntriesByStatus(state, status) {
+  return fromEditorialWorkflow.selectUnpublishedEntriesByStatus(state.editorialWorkflow, status);
+}
+function selectUnpublishedSlugs(state, collection) {
+  return fromEditorialWorkflow.selectUnpublishedSlugs(state.editorialWorkflow, collection);
+}
+function selectIntegration(state, collection, hook) {
+  return fromIntegrations.selectIntegration(state.integrations, collection, hook);
+}

node_modules/decap-cms-core/dist/esm/reducers/integrations.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getIntegrations = getIntegrations;
+exports.selectIntegration = selectIntegration;
+var _immutable = require("immutable");
+var _config = require("../actions/config");
+const _excluded = ["hooks", "collections", "provider"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function getIntegrations(config) {
+  const integrations = config.integrations || [];
+  const newState = integrations.reduce((acc, integration) => {
+    const {
+        hooks,
+        collections,
+        provider
+      } = integration,
+      providerData = _objectWithoutProperties(integration, _excluded);
+    acc.providers[provider] = _objectSpread({}, 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 (0, _immutable.fromJS)(newState);
+}
+const defaultState = (0, _immutable.fromJS)({
+  providers: {},
+  hooks: {}
+});
+function integrations(state = defaultState, action) {
+  switch (action.type) {
+    case _config.CONFIG_SUCCESS:
+      {
+        return getIntegrations(action.payload);
+      }
+    default:
+      return state;
+  }
+}
+function selectIntegration(state, collection, hook) {
+  return collection ? state.getIn(['hooks', collection, hook], false) : state.getIn(['hooks', hook], false);
+}
+var _default = exports.default = integrations;

node_modules/decap-cms-core/dist/esm/reducers/mediaLibrary.js

@@ -0,0 +1,263 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectMediaDisplayURL = selectMediaDisplayURL;
+exports.selectMediaFileByPath = selectMediaFileByPath;
+exports.selectMediaFiles = selectMediaFiles;
+var _immutable = require("immutable");
+var _uuid = require("uuid");
+var _path = require("path");
+var _mediaLibrary = require("../actions/mediaLibrary");
+var _entries = require("./entries");
+var _ = require("./");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const defaultState = {
+  isVisible: false,
+  showMediaButton: true,
+  controlMedia: (0, _immutable.Map)(),
+  displayURLs: (0, _immutable.Map)(),
+  config: (0, _immutable.Map)()
+};
+function mediaLibrary(state = (0, _immutable.Map)(defaultState), action) {
+  switch (action.type) {
+    case _mediaLibrary.MEDIA_LIBRARY_CREATE:
+      return state.withMutations(map => {
+        map.set('externalLibrary', action.payload);
+        map.set('showMediaButton', action.payload.enableStandalone());
+      });
+    case _mediaLibrary.MEDIA_LIBRARY_OPEN:
+      {
+        const {
+          controlID,
+          forImage,
+          privateUpload,
+          config,
+          field,
+          value,
+          replaceIndex
+        } = action.payload;
+        const libConfig = config || (0, _immutable.Map)();
+        const privateUploadChanged = state.get('privateUpload') !== privateUpload;
+        if (privateUploadChanged) {
+          return (0, _immutable.Map)({
+            isVisible: true,
+            forImage,
+            controlID,
+            canInsert: !!controlID,
+            privateUpload,
+            config: libConfig,
+            controlMedia: (0, _immutable.Map)(),
+            displayURLs: (0, _immutable.Map)(),
+            field,
+            value,
+            replaceIndex
+          });
+        }
+        return state.withMutations(map => {
+          map.set('isVisible', true);
+          map.set('forImage', forImage !== null && forImage !== void 0 ? forImage : false);
+          map.set('controlID', controlID !== null && controlID !== void 0 ? controlID : '');
+          map.set('canInsert', !!controlID);
+          map.set('privateUpload', privateUpload);
+          map.set('config', libConfig);
+          map.set('field', field !== null && field !== void 0 ? field : '');
+          map.set('value', value == '' && libConfig.get('multiple') ? [] : value !== null && value !== void 0 ? value : '');
+          map.set('replaceIndex', replaceIndex !== null && replaceIndex !== void 0 ? replaceIndex : false);
+        });
+      }
+    case _mediaLibrary.MEDIA_LIBRARY_CLOSE:
+      return state.set('isVisible', false);
+    case _mediaLibrary.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 _mediaLibrary.MEDIA_REMOVE_INSERTED:
+      {
+        const controlID = action.payload.controlID;
+        return state.setIn(['controlMedia', controlID], '');
+      }
+    case _mediaLibrary.MEDIA_LOAD_REQUEST:
+      return state.withMutations(map => {
+        map.set('isLoading', true);
+        map.set('isPaginating', action.payload.page > 1);
+      });
+    case _mediaLibrary.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 => _objectSpread(_objectSpread({}, file), {}, {
+          key: (0, _uuid.v4)()
+        }));
+        return state.withMutations(map => {
+          map.set('isLoading', false);
+          map.set('isPaginating', false);
+          map.set('page', page !== null && page !== void 0 ? page : 1);
+          map.set('hasNextPage', !!(canPaginate && files.length > 0));
+          map.set('dynamicSearch', dynamicSearch !== null && dynamicSearch !== void 0 ? dynamicSearch : false);
+          map.set('dynamicSearchQuery', dynamicSearchQuery !== null && dynamicSearchQuery !== void 0 ? 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 _mediaLibrary.MEDIA_LOAD_FAILURE:
+      {
+        const privateUploadChanged = state.get('privateUpload') !== action.payload.privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.set('isLoading', false);
+      }
+    case _mediaLibrary.MEDIA_PERSIST_REQUEST:
+      return state.set('isPersisting', true);
+    case _mediaLibrary.MEDIA_PERSIST_SUCCESS:
+      {
+        const {
+          file,
+          privateUpload
+        } = action.payload;
+        const privateUploadChanged = state.get('privateUpload') !== privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.withMutations(map => {
+          const fileWithKey = _objectSpread(_objectSpread({}, file), {}, {
+            key: (0, _uuid.v4)()
+          });
+          const files = map.get('files');
+          const updatedFiles = [fileWithKey, ...files];
+          map.set('files', updatedFiles);
+          map.set('isPersisting', false);
+        });
+      }
+    case _mediaLibrary.MEDIA_PERSIST_FAILURE:
+      {
+        const privateUploadChanged = state.get('privateUpload') !== action.payload.privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.set('isPersisting', false);
+      }
+    case _mediaLibrary.MEDIA_DELETE_REQUEST:
+      return state.set('isDeleting', true);
+    case _mediaLibrary.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 _mediaLibrary.MEDIA_DELETE_FAILURE:
+      {
+        const privateUploadChanged = state.get('privateUpload') !== action.payload.privateUpload;
+        if (privateUploadChanged) {
+          return state;
+        }
+        return state.set('isDeleting', false);
+      }
+    case _mediaLibrary.MEDIA_DISPLAY_URL_REQUEST:
+      return state.setIn(['displayURLs', action.payload.key, 'isFetching'], true);
+    case _mediaLibrary.MEDIA_DISPLAY_URL_SUCCESS:
+      {
+        const displayURLPath = ['displayURLs', action.payload.key];
+        return state.setIn([...displayURLPath, 'isFetching'], false).setIn([...displayURLPath, 'url'], action.payload.url);
+      }
+    case _mediaLibrary.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;
+  }
+}
+function selectMediaFiles(state, field) {
+  const {
+    mediaLibrary,
+    entryDraft
+  } = state;
+  const editingDraft = (0, _entries.selectEditingDraft)(state.entryDraft);
+  const integration = (0, _.selectIntegration)(state, null, 'assetStore');
+  let files;
+  if (editingDraft && !integration) {
+    const entryFiles = entryDraft.getIn(['entry', 'mediaFiles'], (0, _immutable.List)()).toJS();
+    const entry = entryDraft.get('entry');
+    const collection = state.collections.get(entry === null || entry === void 0 ? void 0 : entry.get('collection'));
+    const mediaFolder = (0, _entries.selectMediaFolder)(state.config, collection, entry, field);
+    files = entryFiles.filter(f => (0, _path.dirname)(f.path) === mediaFolder).map(file => _objectSpread({
+      key: file.id
+    }, file));
+  } else {
+    files = mediaLibrary.get('files') || [];
+  }
+  return files;
+}
+function selectMediaFileByPath(state, path) {
+  const files = selectMediaFiles(state);
+  const file = files.find(file => file.path === path);
+  return file;
+}
+function selectMediaDisplayURL(state, id) {
+  const displayUrlState = state.mediaLibrary.getIn(['displayURLs', id], (0, _immutable.Map)());
+  return displayUrlState;
+}
+var _default = exports.default = mediaLibrary;

node_modules/decap-cms-core/dist/esm/reducers/medias.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.selectIsLoadingAsset = selectIsLoadingAsset;
+var _immer = require("immer");
+var _media = require("../actions/media");
+const defaultState = {};
+const medias = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _media.ADD_ASSETS:
+      {
+        const assets = action.payload;
+        assets.forEach(asset => {
+          state[asset.path] = {
+            asset,
+            isLoading: false,
+            error: null
+          };
+        });
+        break;
+      }
+    case _media.ADD_ASSET:
+      {
+        const asset = action.payload;
+        state[asset.path] = {
+          asset,
+          isLoading: false,
+          error: null
+        };
+        break;
+      }
+    case _media.REMOVE_ASSET:
+      {
+        const path = action.payload;
+        delete state[path];
+        break;
+      }
+    case _media.LOAD_ASSET_REQUEST:
+      {
+        const {
+          path
+        } = action.payload;
+        state[path] = state[path] || {};
+        state[path].isLoading = true;
+        break;
+      }
+    case _media.LOAD_ASSET_SUCCESS:
+      {
+        const {
+          path
+        } = action.payload;
+        state[path] = state[path] || {};
+        state[path].isLoading = false;
+        state[path].error = null;
+        break;
+      }
+    case _media.LOAD_ASSET_FAILURE:
+      {
+        const {
+          path,
+          error
+        } = action.payload;
+        state[path] = state[path] || {};
+        state[path].isLoading = false;
+        state[path].error = error;
+      }
+  }
+}, defaultState);
+function selectIsLoadingAsset(state) {
+  return Object.values(state).some(state => state.isLoading);
+}
+var _default = exports.default = medias;

node_modules/decap-cms-core/dist/esm/reducers/notifications.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _immer = require("immer");
+var _uuid = require("uuid");
+var _notifications = require("../actions/notifications");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const defaultState = {
+  notifications: []
+};
+const notifications = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _notifications.NOTIFICATIONS_CLEAR:
+      state.notifications = [];
+      break;
+    case _notifications.NOTIFICATION_DISMISS:
+      state.notifications = state.notifications.filter(n => n.id !== action.id);
+      break;
+    case _notifications.NOTIFICATION_SEND:
+      state.notifications = [...state.notifications, _objectSpread({
+        id: (0, _uuid.v4)()
+      }, action.payload)];
+      break;
+  }
+}, defaultState);
+var _default = exports.default = notifications;

node_modules/decap-cms-core/dist/esm/reducers/search.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _immer = require("immer");
+var _search = require("../actions/search");
+const defaultState = {
+  isFetching: false,
+  term: '',
+  collections: [],
+  page: 0,
+  entryIds: [],
+  queryHits: {},
+  error: undefined,
+  requests: []
+};
+const search = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _search.SEARCH_CLEAR:
+      return defaultState;
+    case _search.SEARCH_ENTRIES_REQUEST:
+      {
+        const {
+          page,
+          searchTerm,
+          searchCollections
+        } = action.payload;
+        state.isFetching = true;
+        state.term = searchTerm;
+        state.collections = searchCollections;
+        state.page = page;
+        break;
+      }
+    case _search.SEARCH_ENTRIES_SUCCESS:
+      {
+        const {
+          entries,
+          page
+        } = action.payload;
+        const entryIds = entries.map(entry => ({
+          collection: entry.collection,
+          slug: entry.slug
+        }));
+        state.isFetching = false;
+        state.page = page;
+        state.entryIds = !page || isNaN(page) || page === 0 ? entryIds : state.entryIds.concat(entryIds);
+        break;
+      }
+    case _search.SEARCH_ENTRIES_FAILURE:
+      {
+        const {
+          error
+        } = action.payload;
+        state.isFetching = false;
+        state.error = error;
+        break;
+      }
+    case _search.QUERY_REQUEST:
+      {
+        const {
+          searchTerm,
+          request
+        } = action.payload;
+        state.isFetching = true;
+        state.term = searchTerm;
+        if (request) {
+          state.requests.push(request);
+        }
+        break;
+      }
+    case _search.CLEAR_REQUESTS:
+      {
+        state.requests = state.requests.filter(req => req.expires >= new Date());
+        break;
+      }
+    case _search.QUERY_SUCCESS:
+      {
+        const {
+          namespace,
+          hits
+        } = action.payload;
+        state.isFetching = false;
+        state.queryHits[namespace] = hits;
+        break;
+      }
+    case _search.QUERY_FAILURE:
+      {
+        const {
+          error
+        } = action.payload;
+        state.isFetching = false;
+        state.error = error;
+      }
+  }
+}, defaultState);
+var _default = exports.default = search;

node_modules/decap-cms-core/dist/esm/reducers/status.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _immer = require("immer");
+var _status = require("../actions/status");
+const defaultState = {
+  isFetching: false,
+  status: {
+    auth: {
+      status: true
+    },
+    api: {
+      status: true,
+      statusPage: ''
+    }
+  },
+  error: undefined
+};
+const status = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _status.STATUS_REQUEST:
+      state.isFetching = true;
+      break;
+    case _status.STATUS_SUCCESS:
+      state.isFetching = false;
+      state.status = action.payload.status;
+      break;
+    case _status.STATUS_FAILURE:
+      state.isFetching = false;
+      state.error = action.payload.error;
+  }
+}, defaultState);
+var _default = exports.default = status;