IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-25 18:55:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Removed unused factory and fixed index based mapper lookup

Browse Source
This commit is contained in:
Hugo Häggmark 2019-02-01 06:52:25 +01:00
parent 7e64ee8225
commit efec897fd4
1 changed files with 8 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
public/app/core/redux/reducerFactory.ts
View File

@ -1,4 +1,4 @@
import { ActionOf, ActionCreator, actionCreatorFactory } from './actionCreatorFactory'; import { ActionOf, ActionCreator } from './actionCreatorFactory';
import { Reducer } from 'redux'; import { Reducer } from 'redux';
export type Mapper<State, Payload> = (state: State, action: ActionOf<Payload>) => State; export type Mapper<State, Payload> = (state: State, action: ActionOf<Payload>) => State;
@ -17,23 +17,23 @@ export interface CreateReducer<State> extends AddMapper<State> {
} }
export const reducerFactory = <State>(initialState: State): AddMapper<State> => { export const reducerFactory = <State>(initialState: State): AddMapper<State> => {
const allMapperConfigs: Array<MapperConfig<State, any>> = []; const allMappers: { [key: string]: Mapper<State, any> } = {};
const addMapper = <Payload>(config: MapperConfig<State, Payload>): CreateReducer<State> => { const addMapper = <Payload>(config: MapperConfig<State, Payload>): CreateReducer<State> => {
if (allMapperConfigs.some(c => c.filter.type === config.filter.type)) { if (allMappers[config.filter.type]) {
throw new Error(`There is already a Mappers defined with the type ${config.filter.type}`); throw new Error(`There is already a mapper defined with the type ${config.filter.type}`);
} }
allMapperConfigs.push(config); allMappers[config.filter.type] = config.mapper;
return instance; return instance;
}; };
const create = (): Reducer<State, ActionOf<any>> => (state: State = initialState, action: ActionOf<any>): State => { const create = (): Reducer<State, ActionOf<any>> => (state: State = initialState, action: ActionOf<any>): State => {
const mapperConfig = allMapperConfigs.filter(config => config.filter.type === action.type)[0]; const mapper = allMappers[action.type];
if (mapperConfig) { if (mapper) {
return mapperConfig.mapper(state, action); return mapper(state, action);
} }
return state; return state;
@ -43,95 +43,3 @@ export const reducerFactory = <State>(initialState: State): AddMapper<State> =>
return instance; return instance;
}; };
/** Another type of fluent reducerFactory */
export interface FilterWith<State> {
filterWith: <Payload>(actionCreator: ActionCreator<Payload>) => MapTo<State, Payload>;
}
export interface OrFilterWith<State> {
orFilterWith: <Payload>(actionCreator: ActionCreator<Payload>) => MapTo<State, Payload>;
}
export interface MapTo<State, Payload> {
mapTo: (mapper: Mapper<State, Payload>) => CreateReducerEx<State>;
}
export interface CreateReducerEx<State> extends OrFilterWith<State> {
create: () => Reducer<State, ActionOf<any>>;
}
export const reducerFactoryEx = <State>(initialState: State): FilterWith<State> => {
const allMapperConfigs: Array<MapperConfig<State, any>> = [];
const innerMapTo = (actionCreator: ActionCreator<any>, mapper: Mapper<State, any>): CreateReducerEx<State> => {
allMapperConfigs.filter(config => config.filter.type === actionCreator.type)[0].mapper = mapper;
return instance;
};
const filterWith = <Payload>(actionCreator: ActionCreator<Payload>): MapTo<State, Payload> => {
if (allMapperConfigs.some(c => c.filter.type === actionCreator.type)) {
throw new Error(`There is already a mapper defined with the type ${actionCreator.type}`);
}
allMapperConfigs.push({ filter: actionCreator, mapper: null });
const mapTo = <Payload>(mapper: Mapper<State, Payload>): CreateReducerEx<State> => {
innerMapTo(actionCreator, mapper);
return instance;
};
return { mapTo };
};
const orFilterWith = <Payload>(actionCreator: ActionCreator<Payload>): MapTo<State, Payload> => {
if (allMapperConfigs.some(c => c.filter.type === actionCreator.type)) {
throw new Error(`There is already a mapper defined with the type ${actionCreator.type}`);
}
allMapperConfigs.push({ filter: actionCreator, mapper: null });
const mapTo = <Payload>(mapper: Mapper<State, Payload>): CreateReducerEx<State> => {
innerMapTo(actionCreator, mapper);
return instance;
};
return { mapTo };
};
const create = (): Reducer<State, ActionOf<any>> => (state: State = initialState, action: ActionOf<any>): State => {
const mapperConfig = allMapperConfigs.filter(config => config.filter.type === action.type)[0];
if (mapperConfig) {
return mapperConfig.mapper(state, action);
}
return state;
};
const instance = { filterWith, orFilterWith, create };
return instance;
};
interface TestState {
data: string[];
}
const initialState: TestState = {
data: [],
};
const dummyActionCreator = actionCreatorFactory<string>('dummyActionCreator').create();
const dummyActionCreator2 = actionCreatorFactory<number>('dummyActionCreator2').create();
export const reducerFactoryExReducer = reducerFactoryEx<TestState>(initialState)
.filterWith(dummyActionCreator)
.mapTo((state, action) => ({ ...state, data: state.data.concat(action.payload) }))
.orFilterWith(dummyActionCreator2)
.mapTo((state, action) => ({ ...state, data: state.data.concat(`${action.payload}`) }))
.create();