@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/reducers/notifications.js

@@ -0,0 +1,23 @@
+import { produce } from 'immer';
+import { v4 as uuid } from 'uuid';
+import { NOTIFICATION_SEND, NOTIFICATION_DISMISS, NOTIFICATIONS_CLEAR } from '../actions/notifications';
+const defaultState = {
+  notifications: []
+};
+const notifications = produce((state, action) => {
+  switch (action.type) {
+    case NOTIFICATIONS_CLEAR:
+      state.notifications = [];
+      break;
+    case NOTIFICATION_DISMISS:
+      state.notifications = state.notifications.filter(n => n.id !== action.id);
+      break;
+    case NOTIFICATION_SEND:
+      state.notifications = [...state.notifications, {
+        id: uuid(),
+        ...action.payload
+      }];
+      break;
+  }
+}, defaultState);
+export default notifications;

package/dist/esm/reducers/search.js

@@ -0,0 +1,92 @@
+import { produce } from 'immer';
+import { QUERY_FAILURE, QUERY_REQUEST, QUERY_SUCCESS, SEARCH_CLEAR, SEARCH_ENTRIES_FAILURE, SEARCH_ENTRIES_REQUEST, SEARCH_ENTRIES_SUCCESS, CLEAR_REQUESTS } from '../actions/search';
+const defaultState = {
+  isFetching: false,
+  term: '',
+  collections: [],
+  page: 0,
+  entryIds: [],
+  queryHits: {},
+  error: undefined,
+  requests: []
+};
+const search = produce((state, action) => {
+  switch (action.type) {
+    case SEARCH_CLEAR:
+      return defaultState;
+    case SEARCH_ENTRIES_REQUEST:
+      {
+        const {
+          page,
+          searchTerm,
+          searchCollections
+        } = action.payload;
+        state.isFetching = true;
+        state.term = searchTerm;
+        state.collections = searchCollections;
+        state.page = page;
+        break;
+      }
+    case 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_ENTRIES_FAILURE:
+      {
+        const {
+          error
+        } = action.payload;
+        state.isFetching = false;
+        state.error = error;
+        break;
+      }
+    case QUERY_REQUEST:
+      {
+        const {
+          searchTerm,
+          request
+        } = action.payload;
+        state.isFetching = true;
+        state.term = searchTerm;
+        if (request) {
+          state.requests.push(request);
+        }
+        break;
+      }
+    case CLEAR_REQUESTS:
+      {
+        state.requests = state.requests.filter(req => req.expires >= new Date());
+        break;
+      }
+    case QUERY_SUCCESS:
+      {
+        const {
+          namespace,
+          hits
+        } = action.payload;
+        state.isFetching = false;
+        state.queryHits[namespace] = hits;
+        break;
+      }
+    case QUERY_FAILURE:
+      {
+        const {
+          error
+        } = action.payload;
+        state.isFetching = false;
+        state.error = error;
+      }
+  }
+}, defaultState);
+export default search;

package/dist/esm/reducers/status.js

@@ -0,0 +1,30 @@
+import { produce } from 'immer';
+import { STATUS_REQUEST, STATUS_SUCCESS, STATUS_FAILURE } from '../actions/status';
+const defaultState = {
+  isFetching: false,
+  status: {
+    auth: {
+      status: true
+    },
+    api: {
+      status: true,
+      statusPage: ''
+    }
+  },
+  error: undefined
+};
+const status = produce((state, action) => {
+  switch (action.type) {
+    case STATUS_REQUEST:
+      state.isFetching = true;
+      break;
+    case STATUS_SUCCESS:
+      state.isFetching = false;
+      state.status = action.payload.status;
+      break;
+    case STATUS_FAILURE:
+      state.isFetching = false;
+      state.error = action.payload.error;
+  }
+}, defaultState);
+export default status;

package/dist/esm/redux/index.js

@@ -0,0 +1,7 @@
+import { createStore, applyMiddleware } from 'redux';
+import { composeWithDevTools } from 'redux-devtools-extension';
+import thunkMiddleware from 'redux-thunk';
+import { waitUntilAction } from './middleware/waitUntilAction';
+import createRootReducer from '../reducers/combinedReducer';
+const store = createStore(createRootReducer(), composeWithDevTools(applyMiddleware(thunkMiddleware, waitUntilAction)));
+export { store };

package/dist/esm/redux/middleware/waitUntilAction.js

@@ -0,0 +1,48 @@
+// Based on wait-service by Mozilla:
+// https://github.com/mozilla/gecko-dev/blob/master/devtools/client/shared/redux/middleware/wait-service.js
+
+/**
+ * A middleware that provides the ability for actions to install a
+ * function to be run once when a specific condition is met by an
+ * action coming through the system. Think of it as a thunk that
+ * blocks until the condition is met.
+ */
+
+export const WAIT_UNTIL_ACTION = 'WAIT_UNTIL_ACTION';
+// eslint-disable-next-line func-style
+export const waitUntilAction = ({
+  dispatch,
+  getState
+}) => {
+  let pending = [];
+  function checkPending(action) {
+    const readyRequests = [];
+    const stillPending = [];
+
+    // Find the pending requests whose predicates are satisfied with
+    // this action. Wait to run the requests until after we update the
+    // pending queue because the request handler may synchronously
+    // dispatch again and run this service (that use case is
+    // completely valid).
+    for (const request of pending) {
+      if (request.predicate(action)) {
+        readyRequests.push(request);
+      } else {
+        stillPending.push(request);
+      }
+    }
+    pending = stillPending;
+    for (const request of readyRequests) {
+      request.run(dispatch, getState, action);
+    }
+  }
+  return next => action => {
+    if (action.type === WAIT_UNTIL_ACTION) {
+      pending.push(action);
+      return null;
+    }
+    const result = next(action);
+    checkPending(action);
+    return result;
+  };
+};

package/dist/esm/routing/history.js

@@ -0,0 +1,12 @@
+import { createHashHistory } from 'history';
+const history = createHashHistory();
+export function navigateToCollection(collectionName) {
+  return history.push(`/collections/${collectionName}`);
+}
+export function navigateToNewEntry(collectionName) {
+  return history.replace(`/collections/${collectionName}/new`);
+}
+export function navigateToEntry(collectionName, slug) {
+  return history.replace(`/collections/${collectionName}/entries/${slug}`);
+}
+export { history };

package/dist/esm/types/global.d.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/immutable.js

@@ -0,0 +1,7 @@
+import { Map as ImmutableMap, List } from 'immutable';
+export function isImmutableMap(value) {
+  return ImmutableMap.isMap(value);
+}
+export function isImmutableList(value) {
+  return List.isList(value);
+}

package/dist/esm/types/redux.js

@@ -0,0 +1,14 @@
+// TODO: type properly
+
+export let SortDirection = /*#__PURE__*/function (SortDirection) {
+  SortDirection["Ascending"] = "Ascending";
+  SortDirection["Descending"] = "Descending";
+  SortDirection["None"] = "None";
+  return SortDirection;
+}({});
+
+// collection.field.active
+
+// collection.field.active
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/esm/valueObjects/AssetProxy.js

@@ -0,0 +1,44 @@
+export default class AssetProxy {
+  constructor({
+    url,
+    file,
+    path,
+    field
+  }) {
+    this.url = url ? url : file ? window.URL.createObjectURL(file) : '';
+    this.fileObj = file;
+    this.path = path;
+    this.field = field;
+  }
+  toString() {
+    return this.url;
+  }
+  async toBase64() {
+    const blob = await fetch(this.url).then(response => response.blob());
+    if (blob.size <= 0) {
+      return '';
+    }
+    const result = await new Promise(resolve => {
+      const fr = new FileReader();
+      fr.onload = readerEvt => {
+        const binaryString = readerEvt.target?.result || '';
+        resolve(binaryString.toString().split('base64,')[1]);
+      };
+      fr.readAsDataURL(blob);
+    });
+    return result;
+  }
+}
+export function createAssetProxy({
+  url,
+  file,
+  path,
+  field
+}) {
+  return new AssetProxy({
+    url,
+    file,
+    path,
+    field
+  });
+}

package/dist/esm/valueObjects/EditorComponent.js

@@ -0,0 +1,34 @@
+import { fromJS } from 'immutable';
+import isFunction from 'lodash/isFunction';
+const catchesNothing = /.^/;
+function bind(fn) {
+  return isFunction(fn) && fn.bind(null);
+}
+export default function createEditorComponent(config) {
+  const {
+    id = null,
+    label = 'unnamed component',
+    icon = 'exclamation-triangle',
+    type = 'shortcode',
+    widget = 'object',
+    pattern = catchesNothing,
+    fields = [],
+    fromBlock,
+    toBlock,
+    toPreview,
+    ...remainingConfig
+  } = config;
+  return {
+    id: id || label.replace(/[^A-Z0-9]+/gi, '_'),
+    label,
+    type,
+    icon,
+    widget,
+    pattern,
+    fromBlock: bind(fromBlock) || (() => ({})),
+    toBlock: bind(toBlock) || (() => 'Plugin'),
+    toPreview: bind(toPreview) || !widget && (bind(toBlock) || (() => 'Plugin')),
+    fields: fromJS(fields),
+    ...remainingConfig
+  };
+}

package/dist/esm/valueObjects/Entry.js

@@ -0,0 +1,20 @@
+import isBoolean from 'lodash/isBoolean';
+export function createEntry(collection, slug = '', path = '', options = {}) {
+  const returnObj = {
+    collection,
+    slug,
+    path,
+    partial: options.partial || false,
+    raw: options.raw || '',
+    data: options.data || {},
+    label: options.label || null,
+    isModification: isBoolean(options.isModification) ? options.isModification : null,
+    mediaFiles: options.mediaFiles || [],
+    author: options.author || '',
+    updatedOn: options.updatedOn || '',
+    status: options.status || '',
+    meta: options.meta || {},
+    i18n: options.i18n || {}
+  };
+  return returnObj;
+}