TypeScript dist.reducerWithInitialState函數代碼示例

export const createGraphqlOperationReducer = <State, Data, Variables, Error = ApolloError>(
  operationKey: string,
  initialState: GraphqlState<State>,
  actionCreators: OperationActionCreators<Data, Variables, Error>,
  reduceSuccess: (
    state: State | undefined,
    action: Action<ResolveDonePayload<Variables, Data>>
  ) => State | undefined = state => state,
  reduceFailure: (
    state: State | undefined,
    action: Action<ResolveFailedPayload<Variables, Error>>
  ) => State | undefined = state => state
) =>
  reducerWithInitialState(initialState)
    .caseWithAction(actionCreators.resolveStarted, (state, action) => ({
      ...state,
      current: {
        progress: 'running',
        time: Date.now(),
        parameters: {
          operationKey,
          variables: action.payload,
        },
      },
    }))
    .caseWithAction(actionCreators.resolveDone, (state, action) => ({
      ...state,
      current: {
        progress: 'idle',
      },
      last: {
        result: 'success',
        parameters: {
          operationKey,
          variables: action.payload.params,
        },
        time: Date.now(),
        isExhausted: false,
      },
      data: reduceSuccess(state.data, action),
    }))
    .caseWithAction(actionCreators.resolveFailed, (state, action) => ({
      ...state,
      current: {
        progress: 'idle',
      },
      last: {
        result: 'failure',
        reason: `${action.payload}`,
        time: Date.now(),
        parameters: {
          operationKey,
          variables: action.payload.params,
        },
      },
      data: reduceFailure(state.data, action),
    }))
    .build();

type TimeUpdatePolicy = ManualTimeUpdatePolicy | IntervalTimeUpdatePolicy;

export interface WaffleTimeState {
  currentTime: number;
  updatePolicy: TimeUpdatePolicy;
}

export const initialWaffleTimeState: WaffleTimeState = {
  currentTime: Date.now(),
  updatePolicy: {
    policy: 'manual',
  },
};

const currentTimeReducer = reducerWithInitialState(initialWaffleTimeState.currentTime).case(
  jumpToTime,
  (currentTime, targetTime) => targetTime
);

const updatePolicyReducer = reducerWithInitialState(initialWaffleTimeState.updatePolicy)
  .case(startAutoReload, () => ({
    policy: 'interval',
    interval: 5000,
  }))
  .case(stopAutoReload, () => ({
    policy: 'manual',
  }));

export const waffleTimeReducer = combineReducers<WaffleTimeState>({
  currentTime: currentTimeReducer,

}

export const initialMetricTimeState: MetricTimeState = {
  timeRange: {
    from: moment()
      .subtract(1, 'hour')
      .valueOf(),
    to: moment().valueOf(),
    interval: '>=1m',
  },
  updatePolicy: {
    policy: 'manual',
  },
};

const timeRangeReducer = reducerWithInitialState(initialMetricTimeState.timeRange).case(
  setRangeTime,
  (state, { to, from }) => ({ ...state, to, from })
);

const updatePolicyReducer = reducerWithInitialState(initialMetricTimeState.updatePolicy)
  .case(startMetricsAutoReload, () => ({
    policy: 'interval',
    interval: 5000,
  }))
  .case(stopMetricsAutoReload, () => ({
    policy: 'manual',
  }));

export const metricTimeReducer = combineReducers<MetricTimeState>({
  timeRange: timeRangeReducer,

/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License;
 * you may not use this file except in compliance with the Elastic License.
 */

import { reducerWithInitialState } from 'typescript-fsa-reducers/dist';

import { setMinimapIntervalSize } from './actions';

export interface LogMinimapState {
  intervalSize: number;
}

export const initialLogMinimapState: LogMinimapState = {
  intervalSize: 1000 * 60 * 60 * 24,
};

export const logMinimapReducer = reducerWithInitialState(initialLogMinimapState)
  .case(setMinimapIntervalSize, (state, intervalSize) => ({
    intervalSize,
  }))
  .build();

import { reducerWithInitialState } from 'typescript-fsa-reducers/dist';
import { loadAnimals, Animal } from './actions';

export type State = Animal[];

export const reducer = reducerWithInitialState([] as Animal[])
  .case(loadAnimals.done, (state, payload) => {
    return payload.result;
  });