Add parseEnum utility function

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- `parseEnum` utility function
+
 ## [2.2.0] - 2025-10-02
 
 ### Added

src/lib/enum.spec.ts

@@ -1,110 +1,141 @@
-import { getEnumNames, getEnumNameFromValue, getEnumValueFromName, getEnumValues } from "./enum";
+import { getEnumNames, getEnumNameFromValue, getEnumValueFromName, getEnumValues, parseEnum } from "./enum";
+
+enum TestEnum {
+  A = 1,
+  B = 2,
+  C = 3,
+}
+
+enum TestEnumString {
+  A = "Test3",
+  B = "Test1",
+  C = "Test4",
+}
 
 describe("enum tests", () => {
   test("getEnumNameFromValue/getEnumValueFromName with integer values", () => {
-    enum TestEnum {
-      A = 1,
-      B = 2,
-      C = 3,
-    }
-
-    const name = getEnumNameFromValue<TestEnum>(TestEnum, TestEnum.B);
+    const name = getEnumNameFromValue(TestEnum, TestEnum.B);
     expect(name).toBe("B");
 
-    const value = getEnumValueFromName<TestEnum>(TestEnum, "B");
+    const value = getEnumValueFromName(TestEnum, "B");
     expect(value).toBe(TestEnum.B);
   });
 
   test("getEnumValueFromName/getEnumNameFromValue with string values", () => {
-    enum TestEnum {
-      A = "Test3",
-      B = "Test1",
-      C = "Test4",
-    }
-
-    const name = getEnumNameFromValue<TestEnum>(TestEnum, TestEnum.B);
+    const name = getEnumNameFromValue(TestEnumString, TestEnumString.B);
     expect(name).toBe("B");
 
-    const value = getEnumValueFromName<TestEnum>(TestEnum, "B");
-    expect(value).toBe(TestEnum.B);
+    const value = getEnumValueFromName(TestEnumString, "B");
+    expect(value).toBe(TestEnumString.B);
   });
 
   test("getEnumNames/getEnumValues with integer values", () => {
-    enum TestEnum {
-      A = 1,
-      B = 2,
-      C = 3,
-    }
-
-    const names = getEnumNames<TestEnum>(TestEnum);
+    const names = getEnumNames(TestEnum);
     expect(names).toStrictEqual(["A", "B", "C"]);
 
-    const values = getEnumValues<TestEnum>(TestEnum);
+    const values = getEnumValues(TestEnum);
     expect(values).toStrictEqual([TestEnum.A, TestEnum.B, TestEnum.C]);
   });
 
   test("getEnumNames/getEnumValues with unspecified values", () => {
-    enum TestEnum {
+    enum TestEnumUnspecified {
       A,
       B,
       C,
     }
-    const names = getEnumNames<TestEnum>(TestEnum);
+    const names = getEnumNames(TestEnumUnspecified);
     expect(names).toStrictEqual(["A", "B", "C"]);
 
-    const values = getEnumValues<TestEnum>(TestEnum);
+    const values = getEnumValues(TestEnumUnspecified);
     expect(values).toStrictEqual([0, 1, 2]);
   });
 
   test("getEnumNames/getEnumValues with progressive values", () => {
-    enum TestEnum {
+    enum TestEnumProgressive {
       A = 10,
       B,
       C,
     }
-    const names = getEnumNames<TestEnum>(TestEnum);
+    const names = getEnumNames(TestEnumProgressive);
     expect(names).toStrictEqual(["A", "B", "C"]);
 
-    const values = getEnumValues<TestEnum>(TestEnum);
+    const values = getEnumValues(TestEnumProgressive);
     expect(values).toStrictEqual([10, 11, 12]);
   });
 
   test("getEnumNames/getEnumValues with constants values", () => {
-    enum TestEnum {
+    enum TestEnumConstants {
       None,
       Read = 1 << 1,
       Write = 1 << 2,
       ReadWrite = Read | Write,
     }
 
-    const names = getEnumNames<TestEnum>(TestEnum);
+    const names = getEnumNames(TestEnumConstants);
     expect(names).toStrictEqual(["None", "Read", "Write", "ReadWrite"]);
 
-    const values = getEnumValues<TestEnum>(TestEnum);
+    const values = getEnumValues(TestEnumConstants);
     expect(values).toStrictEqual([0, 2, 4, 6]);
   });
 
   test("getEnumNames/getEnumValues with string values", () => {
-    enum TestEnum {
-      A = "Test3",
-      B = "Test1",
-      C = "Test4",
-    }
-
-    const names = getEnumNames<TestEnum>(TestEnum);
+    const names = getEnumNames(TestEnumString);
     expect(names).toStrictEqual(["A", "B", "C"]);
 
-    const values = getEnumValues<TestEnum>(TestEnum);
-    expect(values).toStrictEqual([TestEnum.A, TestEnum.B, TestEnum.C]);
+    const values = getEnumValues(TestEnumString);
+    expect(values).toStrictEqual([TestEnumString.A, TestEnumString.B, TestEnumString.C]);
   });
 
   test("getEnumNames/getEnumValues with empty enum", () => {
-    enum TestEnum {}
+    enum TestEnumEmpty {}
 
-    const names = getEnumNames<TestEnum>(TestEnum);
+    const names = getEnumNames(TestEnumEmpty);
     expect(names).toStrictEqual([]);
 
-    const values = getEnumValues<TestEnum>(TestEnum);
+    const values = getEnumValues(TestEnumEmpty);
     expect(values).toStrictEqual([]);
   });
+
+  test.each([
+    // Other types
+    [null as unknown as string, undefined],
+    [undefined as unknown as string, undefined],
+    [0 as unknown as string, undefined],
+    [2 as unknown as string, TestEnum.B],
+    [10 as unknown as string, undefined],
+    [new Date() as unknown as string, undefined],
+
+    // Actual strings
+    ["1", TestEnum.A],
+    ["2", TestEnum.B],
+    ["3", TestEnum.C],
+    ["", undefined],
+    ["   ", undefined],
+    ["A", undefined],
+    ["5", undefined],
+    ["test", undefined],
+  ])("parseEnum with integer values", (value, expected) => {
+    expect(parseEnum(TestEnum, value)).toBe(expected);
+  });
+
+  test.each([
+    // Other types
+    [null as unknown as string, undefined],
+    [undefined as unknown as string, undefined],
+    [0 as unknown as string, undefined],
+    [10 as unknown as string, undefined],
+    [new Date() as unknown as string, undefined],
+
+    // Actual strings
+    ["Test3", TestEnumString.A],
+    ["Test1", TestEnumString.B],
+    ["Test4", TestEnumString.C],
+    ["", undefined],
+    ["   ", undefined],
+    ["A", undefined],
+    ["5", undefined],
+    ["test", undefined],
+  ])("parseEnum with string values", (value, expected) => {
+    expect(parseEnum(TestEnumString, value)).toBe(expected);
+  });
 });

src/lib/enum.ts

@@ -58,6 +58,20 @@ export function getEnumValues<T>(enumVariable: StandardEnum<T>): T[] {
   ) as T[];
 }
 
+/**
+ * Parses a string to an enum value
+ * @param enumVariable The enum for which you want to get the values
+ * @param value The string to parse
+ * @returns The enum value corresponding to the string, or undefined if not found
+ */
+export function parseEnum<T>(enumVariable: StandardEnum<T>, value: string): T | undefined {
+  if (!isEnumString(enumVariable) && Number.isNaN(Number(value))) {
+    return undefined;
+  }
+
+  return getEnumValueFromName(enumVariable, getEnumNameFromValue(enumVariable, value as T));
+}
+
 /**
  * Returns if it's a enum with string value
  * @param enumVariable The enum