Create a "actionCreatorFactory" function

Very often I need to make reusable redux components, and also often these components state appear more than once in the Redux store.

To solve this I usually follow this pattern:

export function createParamActionCreators(paramTableName: string) {
  return {
    setParams: createActionCreator(
      `[${paramTableName}] SET_PARAMS`,
      (resolve) => (param: Param[]) => {
        return resolve(param);
      }
    ),

    addParam: createActionCreator(
      `[${paramTableName}] ADD_PARAM`,
      (resolve) => (param: Param) => {
        return resolve(param);
      }
    ),
    ...
  };
}

type ParamTableActionCreators = ReturnType<typeof createParamActionCreators>;

export function createParamTableReducer(actions: ParamTableActionCreators) {
  return createReducer([] as Param[], (handle) => [
    handle(actions.setParams, (_state, { payload }) => payload),
    handle(actions.addParam, (state, { payload }) =>
      produce(state, (draft: Draft<Param[]>) => {
        draft.push(payload);
      })
    ),
    ...
  ]);
}

I am trying to implement it myself, you can see my struggle to make a prototype here

I am opening this to see what people think about this, I think this is mostly an edge case of mine, not sure if it is worth putting on a library

[LouizFC]

Sorry for being away. September was a busy month.

I will do a rewrite with the approach that you suggested soon as I get some time.

[LouizFC]

My workaround would be passing an object with all the string literals like so:

//Over Simplified Version

// We have a "Factory" where we declare the shape of our ActionCreators
type Factory = {
  a: (name: string) => /** ActionCreator */ ()=> { type: name };
  b: (name: string) => /** ActionCreator */ ()=> { type: name };
};

// We have a object with the same keys as the factory where we pass the ActionTypes
type Names = {
  a: "A";
  b: "B";
};

// We have produce an object with the correct ActionCreators
type Result = {
  a: () =>{ type: "A" };
  b: () =>{ type: "B" };
};

// The shape of the function
function(factory): (names) => result

It introduces some boilerplate, but the types that it produces will have the correct literals.