将枚举转换为具有值的 object

Question

I would like to create a helper that can return an object/enum like value so we're not repeating patterns:

enum ActionTypes {
    Find,
    Update,
    Create
}
enum RequestTypes {
    Request,
    Success,
    Failure

}

If i was starting with this enum here, I need a helper method that can convert this to the following:

const actions = createActions(ActionTypes);
// actions.Find.Request -> 'FindRequest'
// actions.Find.Success -> 'FindSuccess'

Not even sure where to begin i'm pretty novice at typescript

The full expected output of actions should be:

{
    Find: {
        Request: 'FindRequest',
        Success: 'FindSuccess',
        Failure: 'FindFailure'
    },
    Create: {
        Request: 'CreateRequest',
        Success: 'CreateSuccess',
        Failure: 'CreateFailure'
    },
    Update: {
        Request: 'UpdateRequest',
        Success: 'UpdateSuccess',
        Failure: 'UpdateFailure'
    }
}

Answer 1

you can get the enum strings from Object.values method then iterate and concatenate as you want.

 enum ActionTypes { Find, Update, Create } enum RequestTypes { Request, Success, Failure } function createActions(actionTypes) { let actionTypeStrings = Object.values(actionTypes).filter(e => typeof e == 'string'); let requestTypeStrings = Object.values(RequestTypes).filter(e => typeof e == 'string'); let actions = actionTypeStrings.reduce((a, c) => { let anAction: any = {}; requestTypeStrings.forEach((e: any) => anAction[e] = c + e) a[c] = anAction; return a; }, < any > {}) return actions; } const actions = createActions(ActionTypes); console.log(actions);

Answer 2

This is what you can do:

enum ActionTypes {
    Find = 'Find',
    Update = 'Update',
    Create = 'Create'
}

enum RequestTypes {
    Request = 'Request',
    Success = 'Success',
    Failure  = 'Failure'

}

type combination = {
  [k in  ActionTypes]: {
    [k1 in  RequestTypes]: `${k}${k1}`
  }
}


function createActions(): combination {
  return Object.keys(ActionTypes).reduce((cum, k) => {
     cum[k] = Object.keys(RequestTypes).reduce((cum1, k1) => {
       cum1[k1] = `${k}${k1}`
       return cum1;
     }, {} as any)
     return cum;
  } , {} as any)
}


console.log(createActions().Create.Failure)
// CreateFailure

TS Playground: https://tsplay.dev/WG6bkm

Answer 3

Wrote a simple function to do this.

function mixEnumsToObject(e1: any, e2: any) {
  const keys1: string[] = Object.keys(e1).filter((key) => isNaN(Number(key)));
  const keys2: string[] = Object.keys(e2).filter((key) => isNaN(Number(key)));
  const mixEnumMap = new Map();

  keys1.forEach((key1) => {
    const valueObject = new Map();
    keys2.forEach((key2) => {
      valueObject.set(key2, key1 + key2);
    });
    mixEnumMap.set(key1, valueObject);
  });
  return mixEnumMap;
}

const mixedEnumObject = mixEnumsToObject(ActionTypes, RequestTypes);
console.log(mixedEnumObject);

Answer 4

Here's a type-safe functional solution that accepts two string enums as parameters (so you can reuse it for other cases):

TS Playground link

type StringEnum = Record<string, string>;

type NestedCombinedStringEnum<
  P extends StringEnum,
  C extends StringEnum,
> = {
  [KP in keyof P]: {
    [KC in keyof C]: KP extends string ? KC extends string ? `${KP}${KC}` : never : never;
  };
};

function nestAndCombineStringEnums <
  P extends StringEnum,
  C extends StringEnum,
>(enumParent: P, enumChild: C): NestedCombinedStringEnum<P, C> {
  const result: any = {};

  for (const keyP of Object.keys(enumParent)) {
    result[keyP] = {};
    for (const keyC of Object.keys(enumChild)) {
      result[keyP][keyC] = `${keyP}${keyC}`;
    }
  }

  return result;
}

// Use:

enum ActionType {
  Find = 'Find',
  Update = 'Update',
  Create = 'Create',
}

enum RequestType {
  Request = 'Request',
  Success = 'Success',
  Failure = 'Failure',
}

const actions = nestAndCombineStringEnums(ActionType, RequestType);
console.log(actions.Create.Success); // "CreateSuccess"
console.log(actions); // the expected result object in your question