decap-cms-core 2.56.0-beta.1

package/src/reducers/medias.ts

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

package/src/reducers/notifications.ts

@@ -0,0 +1,53 @@
+import { produce } from 'immer';
+import uuid from 'uuid';
+
+import {
+  NOTIFICATION_SEND,
+  NOTIFICATION_DISMISS,
+  NOTIFICATIONS_CLEAR,
+} from '../actions/notifications';
+
+import type {
+  NotificationsAction,
+  NotificationMessage,
+  NotificationPayload,
+} from '../actions/notifications';
+import type { TypeOptions } from 'react-toastify';
+
+export type Notification = {
+  id: string;
+  message: string | NotificationMessage;
+  dismissAfter?: number;
+  type: TypeOptions | undefined;
+};
+
+export type NotificationsState = {
+  notifications: Notification[];
+};
+
+const defaultState: NotificationsState = {
+  notifications: [],
+};
+
+const notifications = produce((state: NotificationsState, action: NotificationsAction) => {
+  switch (action.type) {
+    case NOTIFICATIONS_CLEAR:
+      state.notifications = [];
+      break;
+    case NOTIFICATION_DISMISS:
+      console.log('dismissed!');
+      state.notifications = state.notifications.filter(n => n.id !== action.id);
+      break;
+    case NOTIFICATION_SEND:
+      state.notifications = [
+        ...state.notifications,
+        {
+          id: uuid(),
+          ...(action.payload as NotificationPayload),
+        },
+      ];
+      break;
+  }
+}, defaultState);
+
+export default notifications;

package/src/reducers/search.ts

@@ -0,0 +1,89 @@
+import { produce } from 'immer';
+
+import {
+  QUERY_FAILURE,
+  QUERY_REQUEST,
+  QUERY_SUCCESS,
+  SEARCH_CLEAR,
+  SEARCH_ENTRIES_FAILURE,
+  SEARCH_ENTRIES_REQUEST,
+  SEARCH_ENTRIES_SUCCESS,
+} from '../actions/search';
+
+import type { SearchAction } from '../actions/search';
+import type { EntryValue } from '../valueObjects/Entry';
+
+export type Search = {
+  isFetching: boolean;
+  term: string;
+  collections: string[];
+  page: number;
+  entryIds: { collection: string; slug: string }[];
+  queryHits: Record<string, EntryValue[]>;
+  error: Error | undefined;
+};
+
+const defaultState: Search = {
+  isFetching: false,
+  term: '',
+  collections: [],
+  page: 0,
+  entryIds: [],
+  queryHits: {},
+  error: undefined,
+};
+
+const search = produce((state: Search, action: SearchAction) => {
+  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 } = action.payload;
+      state.isFetching = true;
+      state.term = searchTerm;
+      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/src/reducers/status.ts

@@ -0,0 +1,40 @@
+import { produce } from 'immer';
+
+import { STATUS_REQUEST, STATUS_SUCCESS, STATUS_FAILURE } from '../actions/status';
+
+import type { StatusAction } from '../actions/status';
+
+export type Status = {
+  isFetching: boolean;
+  status: {
+    auth: { status: boolean };
+    api: { status: boolean; statusPage: string };
+  };
+  error: Error | undefined;
+};
+
+const defaultState: Status = {
+  isFetching: false,
+  status: {
+    auth: { status: true },
+    api: { status: true, statusPage: '' },
+  },
+  error: undefined,
+};
+
+const status = produce((state: Status, action: StatusAction) => {
+  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/src/redux/index.ts

@@ -0,0 +1,18 @@
+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';
+
+import type { ThunkMiddleware } from 'redux-thunk';
+import type { AnyAction } from 'redux';
+import type { State } from '../types/redux';
+import type { Reducer } from 'react';
+
+const store = createStore<State | undefined, AnyAction, unknown, unknown>(
+  createRootReducer() as unknown as Reducer<State | undefined, AnyAction>,
+  composeWithDevTools(applyMiddleware(thunkMiddleware as ThunkMiddleware<State>, waitUntilAction)),
+);
+
+export { store };

package/src/redux/middleware/waitUntilAction.ts

@@ -0,0 +1,64 @@
+// 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.
+ */
+import type { Middleware, MiddlewareAPI, Dispatch, AnyAction } from 'redux';
+import type { State } from '../../types/redux';
+
+export const WAIT_UNTIL_ACTION = 'WAIT_UNTIL_ACTION';
+
+export interface WaitActionArgs {
+  predicate: (action: AnyAction) => boolean;
+  run: (dispatch: Dispatch, getState: () => State, action: AnyAction) => void;
+}
+
+interface WaitAction extends WaitActionArgs {
+  type: typeof WAIT_UNTIL_ACTION;
+}
+
+// eslint-disable-next-line func-style
+export const waitUntilAction: Middleware<{}, State, Dispatch> = ({
+  dispatch,
+  getState,
+}: MiddlewareAPI<Dispatch, State>) => {
+  let pending: WaitAction[] = [];
+
+  function checkPending(action: AnyAction): void {
+    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: Dispatch<AnyAction>) =>
+    (action: AnyAction): null | AnyAction => {
+      if (action.type === WAIT_UNTIL_ACTION) {
+        pending.push(action as WaitAction);
+        return null;
+      }
+      const result = next(action);
+      checkPending(action);
+      return result;
+    };
+};

package/src/routing/__tests__/history.spec.ts

@@ -0,0 +1,49 @@
+import { createHashHistory } from 'history';
+import { mocked } from 'ts-jest/utils';
+
+import type { History } from 'history';
+
+jest.mock('history');
+
+const history = { push: jest.fn(), replace: jest.fn() } as unknown as History;
+const mockedCreateHashHistory = mocked(createHashHistory);
+mockedCreateHashHistory.mockReturnValue(history);
+
+describe('history', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('navigateToCollection', () => {
+    it('should push route', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { navigateToCollection } = require('../history');
+
+      navigateToCollection('posts');
+      expect(history.push).toHaveBeenCalledTimes(1);
+      expect(history.push).toHaveBeenCalledWith('/collections/posts');
+    });
+  });
+
+  describe('navigateToNewEntry', () => {
+    it('should replace route', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { navigateToNewEntry } = require('../history');
+
+      navigateToNewEntry('posts');
+      expect(history.replace).toHaveBeenCalledTimes(1);
+      expect(history.replace).toHaveBeenCalledWith('/collections/posts/new');
+    });
+  });
+
+  describe('navigateToEntry', () => {
+    it('should replace route', () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { navigateToEntry } = require('../history');
+
+      navigateToEntry('posts', 'index');
+      expect(history.replace).toHaveBeenCalledTimes(1);
+      expect(history.replace).toHaveBeenCalledWith('/collections/posts/entries/index');
+    });
+  });
+});

package/src/routing/history.ts

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

package/src/types/diacritics.d.ts

@@ -0,0 +1 @@
+declare module 'diacritics';

package/src/types/global.d.ts

@@ -0,0 +1,8 @@
+import type { CmsConfig } from './redux';
+
+declare global {
+  interface Window {
+    CMS_CONFIG?: CmsConfig;
+    CMS_ENV?: string;
+  }
+}

package/src/types/immutable.ts

@@ -0,0 +1,39 @@
+export interface StaticallyTypedRecord<T> {
+  get<K extends keyof T>(key: K, defaultValue?: T[K]): T[K];
+  set<K extends keyof T, V extends T[K]>(key: K, value: V): StaticallyTypedRecord<T> & T;
+  has<K extends keyof T>(key: K): boolean;
+  delete<K extends keyof T>(key: K): StaticallyTypedRecord<T>;
+  getIn<K1 extends keyof T, K2 extends keyof T[K1], V extends T[K1][K2]>(
+    keys: [K1, K2],
+    defaultValue?: V,
+  ): T[K1][K2];
+  getIn<
+    K1 extends keyof T,
+    K2 extends keyof T[K1],
+    K3 extends keyof T[K1][K2],
+    V extends T[K1][K2][K3],
+  >(
+    keys: [K1, K2, K3],
+    defaultValue?: V,
+  ): T[K1][K2][K3];
+  getIn(keys: string[]): unknown;
+  setIn<K1 extends keyof T, K2 extends keyof T[K1], V extends T[K1][K2]>(
+    keys: [K1, K2],
+    value: V,
+  ): StaticallyTypedRecord<T>;
+  setIn(keys: string[], value: unknown): StaticallyTypedRecord<T> & T;
+  toJS(): T;
+  isEmpty(): boolean;
+  some<K extends keyof T>(predicate: (value: T[K], key: K, iter: this) => boolean): boolean;
+  mapKeys<K extends keyof T, V>(mapFunc: (key: K, value: StaticallyTypedRecord<T>) => V): V[];
+  find<K extends keyof T>(findFunc: (value: T[K]) => boolean): T[K];
+  filter<K extends keyof T>(
+    predicate: (value: T[K], key: K, iter: this) => boolean,
+  ): StaticallyTypedRecord<T>;
+  valueSeq<K extends keyof T>(): T[K][] & { toArray: () => T[K][] };
+  map<K extends keyof T, V>(
+    mapFunc: (value: T[K]) => V,
+  ): StaticallyTypedRecord<{ [key: string]: V }>;
+  keySeq<K extends keyof T>(): { toArray: () => K[] };
+  withMutations(mutator: (mutable: StaticallyTypedRecord<T>) => unknown): StaticallyTypedRecord<T>;
+}