@naturalcycles/js-lib 14.187.0 → 14.188.0

package/dist/enum.util.d.ts

@@ -1,20 +1,20 @@
 import type { NumberEnum, StringEnum } from './types';
 /**
- * Returns all number keys of a number-enum.
+ * Returns all String keys of a number-enum.
  */
 export declare function _numberEnumKeys(en: NumberEnum): string[];
 /**
- * Returns all number values of a number-enum.
+ * Returns all Number values of a number-enum.
  */
 export declare function _numberEnumValues(en: NumberEnum): number[];
 /**
- * Returns all string keys of a string-enum.
+ * Returns all String keys of a string-enum.
  */
 export declare function _stringEnumKeys(en: StringEnum): string[];
 /**
- * Returns all string values of a string-enum.
+ * Returns all String values of a string-enum.
  */
-export declare function _stringEnumValues(en: StringEnum): string[];
+export declare function _stringEnumValues<T extends StringEnum>(en: T): T[keyof T][];
 /**
  * Returns all number-enum "entries", where entry is a tuple of [key, value],
  * where key is a String key, value is a Number value, typed as Enum itself.
@@ -22,28 +22,55 @@ export declare function _stringEnumValues(en: StringEnum): string[];
  * Doesn't work on String-enums!
  */
 export declare function _numberEnumEntries<T extends NumberEnum>(en: T): [k: string, v: T[keyof T]][];
+/**
+ * Like _numberEnumEntries, but reversed.
+ * So, keys are Numbers, values are Strings.
+ */
+export declare function _numberEnumEntriesReversed<T extends NumberEnum>(en: T): [k: number, v: keyof T][];
+/**
+ * Like _numberEnumEntries, but as a Map.
+ * Keys are Strings, values are Numbers.
+ */
+export declare function _numberEnumAsMap<T extends NumberEnum>(en: T): Map<string, T[keyof T]>;
+/**
+ * Like _numberEnumEntriesReversed, but as a Map.
+ * Keys are Numbers (actual Numbers, because it's a Map, not an Object), values are Strings.
+ */
+export declare function _numberEnumAsMapReversed<T extends NumberEnum>(en: T): Map<number, keyof T>;
 /**
  * Returns all string-enum "entries", where entry is a tuple of [key, value],
  * where key is a String key, value is a String value, typed as Enum itself.
  *
  * Doesn't work on Number-enums!
  */
-export declare function _stringEnumEntries<T extends StringEnum>(en: T): [k: string, v: T[keyof T]][];
+export declare function _stringEnumEntries<T extends StringEnum>(en: T): [k: keyof T, v: T[keyof T]][];
+/**
+ * Like _stringEnumEntries, but keys and values are reversed.
+ */
+export declare function _stringEnumEntriesReversed<T extends StringEnum>(en: T): [k: T[keyof T], v: keyof T][];
+/**
+ * Return String enum as Map (with the same keys and values).
+ */
+export declare function _stringEnumAsMap<T extends StringEnum>(en: T): Map<keyof T, T[keyof T]>;
+/**
+ * Return String enum as Map, with keys and values reversed.
+ */
+export declare function _stringEnumAsMapReversed<T extends StringEnum>(en: T): Map<T[keyof T], keyof T>;
 /**
  * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
  * e.g:
- * const v = SomeEnum['stringValue']
+ * const v = SomeEnum['stringKey']
  * // v is of type SomeEnum, which is of type Number
  *
  * Throws if value is not found!
  */
-export declare function _numberEnumInverse<T extends NumberEnum>(en: T, v: string): T[keyof T];
+export declare function _numberEnumValue<T extends NumberEnum>(en: T, k: keyof T): T[keyof T];
 /**
- * _numberEnumInverse, but allows to get/return undefined output.
+ * _numberEnumKey, but allows to get/return undefined output.
  */
-export declare function _numberEnumInverseNullable<T extends NumberEnum>(en: T, v: string | undefined): T[keyof T] | undefined;
+export declare function _numberEnumValueOrUndefined<T extends NumberEnum>(en: T, k: keyof T | undefined): T[keyof T] | undefined;
 /**
- * Takes number or string enum input, returns normalized Enum output.
+ * Takes number or string enum input, returns normalized Enum output (Number).
  * Only works for number enums.
  *
  * Throws if value is not found!
@@ -52,14 +79,14 @@ export declare function _numberEnumNormalize<T extends NumberEnum>(en: T, v: str
 /**
  * Same as _numberEnumNormalize, but allows to return undefined values.
  */
-export declare function _numberEnumNormalizeNullable<T extends NumberEnum>(en: T, v: string | number | undefined): T[keyof T] | undefined;
+export declare function _numberEnumNormalizeOrUndefined<T extends NumberEnum>(en: T, v: string | number | undefined): T[keyof T] | undefined;
 /**
  * Returns a String key for given NumberEnum value, or undefined if not found.
  */
-export declare function _numberEnumKeyNullable<T extends NumberEnum>(en: T, v: T[keyof T] | undefined | null): keyof T | undefined;
+export declare function _numberEnumKeyOrUndefined<T extends NumberEnum>(en: T, v: T[keyof T] | undefined | null): keyof T | undefined;
 /**
  * Returns a String key for given NumberEnum value, throws if not found.
  */
 export declare function _numberEnumKey<T extends NumberEnum>(en: T, v: T[keyof T] | undefined | null): keyof T;
-export declare function _stringEnumKeyNullable<T extends StringEnum>(en: T, v: string | undefined | null): keyof T | undefined;
+export declare function _stringEnumKeyOrUndefined<T extends StringEnum>(en: T, v: string | undefined | null): keyof T | undefined;
 export declare function _stringEnumKey<T extends StringEnum>(en: T, v: string | undefined | null): keyof T;

package/dist/enum.util.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._stringEnumKey = exports._stringEnumKeyNullable = exports._numberEnumKey = exports._numberEnumKeyNullable = exports._numberEnumNormalizeNullable = exports._numberEnumNormalize = exports._numberEnumInverseNullable = exports._numberEnumInverse = exports._stringEnumEntries = exports._numberEnumEntries = exports._stringEnumValues = exports._stringEnumKeys = exports._numberEnumValues = exports._numberEnumKeys = void 0;
+exports._stringEnumKey = exports._stringEnumKeyOrUndefined = exports._numberEnumKey = exports._numberEnumKeyOrUndefined = exports._numberEnumNormalizeOrUndefined = exports._numberEnumNormalize = exports._numberEnumValueOrUndefined = exports._numberEnumValue = exports._stringEnumAsMapReversed = exports._stringEnumAsMap = exports._stringEnumEntriesReversed = exports._stringEnumEntries = exports._numberEnumAsMapReversed = exports._numberEnumAsMap = exports._numberEnumEntriesReversed = exports._numberEnumEntries = exports._stringEnumValues = exports._stringEnumKeys = exports._numberEnumValues = exports._numberEnumKeys = void 0;
 /**
- * Returns all number keys of a number-enum.
+ * Returns all String keys of a number-enum.
  */
 function _numberEnumKeys(en) {
     return Object.values(en).filter(k => typeof k === 'string');
 }
 exports._numberEnumKeys = _numberEnumKeys;
 /**
- * Returns all number values of a number-enum.
+ * Returns all Number values of a number-enum.
  */
 function _numberEnumValues(en) {
     return Object.values(en).filter(k => typeof k === 'number');
 }
 exports._numberEnumValues = _numberEnumValues;
 /**
- * Returns all string keys of a string-enum.
+ * Returns all String keys of a string-enum.
  */
 function _stringEnumKeys(en) {
     return Object.keys(en);
 }
 exports._stringEnumKeys = _stringEnumKeys;
 /**
- * Returns all string values of a string-enum.
+ * Returns all String values of a string-enum.
  */
 function _stringEnumValues(en) {
     // filtering here is unnecessary, but works as a safety in case Number-enum is passed
@@ -42,6 +42,36 @@ function _numberEnumEntries(en) {
         .map(k => [k, en[k]]);
 }
 exports._numberEnumEntries = _numberEnumEntries;
+/**
+ * Like _numberEnumEntries, but reversed.
+ * So, keys are Numbers, values are Strings.
+ */
+function _numberEnumEntriesReversed(en) {
+    return Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [en[k], k]);
+}
+exports._numberEnumEntriesReversed = _numberEnumEntriesReversed;
+/**
+ * Like _numberEnumEntries, but as a Map.
+ * Keys are Strings, values are Numbers.
+ */
+function _numberEnumAsMap(en) {
+    return new Map(Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [k, en[k]]));
+}
+exports._numberEnumAsMap = _numberEnumAsMap;
+/**
+ * Like _numberEnumEntriesReversed, but as a Map.
+ * Keys are Numbers (actual Numbers, because it's a Map, not an Object), values are Strings.
+ */
+function _numberEnumAsMapReversed(en) {
+    return new Map(Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [en[k], k]));
+}
+exports._numberEnumAsMapReversed = _numberEnumAsMapReversed;
 /**
  * Returns all string-enum "entries", where entry is a tuple of [key, value],
  * where key is a String key, value is a String value, typed as Enum itself.
@@ -52,36 +82,57 @@ function _stringEnumEntries(en) {
     return Object.entries(en);
 }
 exports._stringEnumEntries = _stringEnumEntries;
+/**
+ * Like _stringEnumEntries, but keys and values are reversed.
+ */
+function _stringEnumEntriesReversed(en) {
+    return Object.entries(en).map(([k, v]) => [v, k]);
+}
+exports._stringEnumEntriesReversed = _stringEnumEntriesReversed;
+/**
+ * Return String enum as Map (with the same keys and values).
+ */
+function _stringEnumAsMap(en) {
+    return new Map(Object.entries(en));
+}
+exports._stringEnumAsMap = _stringEnumAsMap;
+/**
+ * Return String enum as Map, with keys and values reversed.
+ */
+function _stringEnumAsMapReversed(en) {
+    return new Map(Object.entries(en).map(([k, v]) => [v, k]));
+}
+exports._stringEnumAsMapReversed = _stringEnumAsMapReversed;
 /**
  * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
  * e.g:
- * const v = SomeEnum['stringValue']
+ * const v = SomeEnum['stringKey']
  * // v is of type SomeEnum, which is of type Number
  *
  * Throws if value is not found!
  */
-function _numberEnumInverse(en, v) {
-    const r = en[v];
+function _numberEnumValue(en, k) {
+    const r = en[k];
     if (!r)
-        throw new Error(`_numberEnumInverse value not found for: ${v}`);
+        throw new Error(`_numberEnumValue not found for: ${k}`);
     return r;
 }
-exports._numberEnumInverse = _numberEnumInverse;
+exports._numberEnumValue = _numberEnumValue;
 /**
- * _numberEnumInverse, but allows to get/return undefined output.
+ * _numberEnumKey, but allows to get/return undefined output.
  */
-function _numberEnumInverseNullable(en, v) {
-    return en[v];
+function _numberEnumValueOrUndefined(en, k) {
+    return en[k];
 }
-exports._numberEnumInverseNullable = _numberEnumInverseNullable;
+exports._numberEnumValueOrUndefined = _numberEnumValueOrUndefined;
 /**
- * Takes number or string enum input, returns normalized Enum output.
+ * Takes number or string enum input, returns normalized Enum output (Number).
  * Only works for number enums.
  *
  * Throws if value is not found!
  */
 function _numberEnumNormalize(en, v) {
-    const r = _numberEnumNormalizeNullable(en, v);
+    const r = _numberEnumNormalizeOrUndefined(en, v);
     if (!r || !en[r])
         throw new Error(`_numberEnumNormalize value not found for: ${v}`);
     return r;
@@ -90,19 +141,19 @@ exports._numberEnumNormalize = _numberEnumNormalize;
 /**
  * Same as _numberEnumNormalize, but allows to return undefined values.
  */
-function _numberEnumNormalizeNullable(en, v) {
+function _numberEnumNormalizeOrUndefined(en, v) {
     return typeof v === 'string' ? en[v] : v;
 }
-exports._numberEnumNormalizeNullable = _numberEnumNormalizeNullable;
+exports._numberEnumNormalizeOrUndefined = _numberEnumNormalizeOrUndefined;
 /**
  * Returns a String key for given NumberEnum value, or undefined if not found.
  */
-function _numberEnumKeyNullable(en, v) {
+function _numberEnumKeyOrUndefined(en, v) {
     const key = en[v];
     // This prevents passing a Key (not a Value) of enum here, which returns unexpected result (number, not string)
     return typeof key === 'string' ? key : undefined;
 }
-exports._numberEnumKeyNullable = _numberEnumKeyNullable;
+exports._numberEnumKeyOrUndefined = _numberEnumKeyOrUndefined;
 /**
  * Returns a String key for given NumberEnum value, throws if not found.
  */
@@ -114,14 +165,14 @@ function _numberEnumKey(en, v) {
     return key;
 }
 exports._numberEnumKey = _numberEnumKey;
-function _stringEnumKeyNullable(en, 
+function _stringEnumKeyOrUndefined(en, 
 // v: T[keyof T] | undefined | null, // cannot make it type-safe :(
 v) {
     return Object.entries(en).find(([_, v2]) => v2 === v)?.[0];
 }
-exports._stringEnumKeyNullable = _stringEnumKeyNullable;
+exports._stringEnumKeyOrUndefined = _stringEnumKeyOrUndefined;
 function _stringEnumKey(en, v) {
-    const r = _stringEnumKeyNullable(en, v);
+    const r = _stringEnumKeyOrUndefined(en, v);
     if (!r)
         throw new Error(`_stringEnumKey not found for: ${v}`);
     return r;

package/dist-esm/enum.util.js

@@ -1,23 +1,23 @@
 /**
- * Returns all number keys of a number-enum.
+ * Returns all String keys of a number-enum.
  */
 export function _numberEnumKeys(en) {
     return Object.values(en).filter(k => typeof k === 'string');
 }
 /**
- * Returns all number values of a number-enum.
+ * Returns all Number values of a number-enum.
  */
 export function _numberEnumValues(en) {
     return Object.values(en).filter(k => typeof k === 'number');
 }
 /**
- * Returns all string keys of a string-enum.
+ * Returns all String keys of a string-enum.
  */
 export function _stringEnumKeys(en) {
     return Object.keys(en);
 }
 /**
- * Returns all string values of a string-enum.
+ * Returns all String values of a string-enum.
  */
 export function _stringEnumValues(en) {
     // filtering here is unnecessary, but works as a safety in case Number-enum is passed
@@ -34,6 +34,33 @@ export function _numberEnumEntries(en) {
         .filter(k => typeof k === 'string')
         .map(k => [k, en[k]]);
 }
+/**
+ * Like _numberEnumEntries, but reversed.
+ * So, keys are Numbers, values are Strings.
+ */
+export function _numberEnumEntriesReversed(en) {
+    return Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [en[k], k]);
+}
+/**
+ * Like _numberEnumEntries, but as a Map.
+ * Keys are Strings, values are Numbers.
+ */
+export function _numberEnumAsMap(en) {
+    return new Map(Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [k, en[k]]));
+}
+/**
+ * Like _numberEnumEntriesReversed, but as a Map.
+ * Keys are Numbers (actual Numbers, because it's a Map, not an Object), values are Strings.
+ */
+export function _numberEnumAsMapReversed(en) {
+    return new Map(Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [en[k], k]));
+}
 /**
  * Returns all string-enum "entries", where entry is a tuple of [key, value],
  * where key is a String key, value is a String value, typed as Enum itself.
@@ -43,34 +70,52 @@ export function _numberEnumEntries(en) {
 export function _stringEnumEntries(en) {
     return Object.entries(en);
 }
+/**
+ * Like _stringEnumEntries, but keys and values are reversed.
+ */
+export function _stringEnumEntriesReversed(en) {
+    return Object.entries(en).map(([k, v]) => [v, k]);
+}
+/**
+ * Return String enum as Map (with the same keys and values).
+ */
+export function _stringEnumAsMap(en) {
+    return new Map(Object.entries(en));
+}
+/**
+ * Return String enum as Map, with keys and values reversed.
+ */
+export function _stringEnumAsMapReversed(en) {
+    return new Map(Object.entries(en).map(([k, v]) => [v, k]));
+}
 /**
  * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
  * e.g:
- * const v = SomeEnum['stringValue']
+ * const v = SomeEnum['stringKey']
  * // v is of type SomeEnum, which is of type Number
  *
  * Throws if value is not found!
  */
-export function _numberEnumInverse(en, v) {
-    const r = en[v];
+export function _numberEnumValue(en, k) {
+    const r = en[k];
     if (!r)
-        throw new Error(`_numberEnumInverse value not found for: ${v}`);
+        throw new Error(`_numberEnumValue not found for: ${k}`);
     return r;
 }
 /**
- * _numberEnumInverse, but allows to get/return undefined output.
+ * _numberEnumKey, but allows to get/return undefined output.
  */
-export function _numberEnumInverseNullable(en, v) {
-    return en[v];
+export function _numberEnumValueOrUndefined(en, k) {
+    return en[k];
 }
 /**
- * Takes number or string enum input, returns normalized Enum output.
+ * Takes number or string enum input, returns normalized Enum output (Number).
  * Only works for number enums.
  *
  * Throws if value is not found!
  */
 export function _numberEnumNormalize(en, v) {
-    const r = _numberEnumNormalizeNullable(en, v);
+    const r = _numberEnumNormalizeOrUndefined(en, v);
     if (!r || !en[r])
         throw new Error(`_numberEnumNormalize value not found for: ${v}`);
     return r;
@@ -78,13 +123,13 @@ export function _numberEnumNormalize(en, v) {
 /**
  * Same as _numberEnumNormalize, but allows to return undefined values.
  */
-export function _numberEnumNormalizeNullable(en, v) {
+export function _numberEnumNormalizeOrUndefined(en, v) {
     return typeof v === 'string' ? en[v] : v;
 }
 /**
  * Returns a String key for given NumberEnum value, or undefined if not found.
  */
-export function _numberEnumKeyNullable(en, v) {
+export function _numberEnumKeyOrUndefined(en, v) {
     const key = en[v];
     // This prevents passing a Key (not a Value) of enum here, which returns unexpected result (number, not string)
     return typeof key === 'string' ? key : undefined;
@@ -99,14 +144,14 @@ export function _numberEnumKey(en, v) {
         throw new Error(`_numberEnumKey not found for: ${v}`);
     return key;
 }
-export function _stringEnumKeyNullable(en, 
+export function _stringEnumKeyOrUndefined(en, 
 // v: T[keyof T] | undefined | null, // cannot make it type-safe :(
 v) {
     var _a;
     return (_a = Object.entries(en).find(([_, v2]) => v2 === v)) === null || _a === void 0 ? void 0 : _a[0];
 }
 export function _stringEnumKey(en, v) {
-    const r = _stringEnumKeyNullable(en, v);
+    const r = _stringEnumKeyOrUndefined(en, v);
     if (!r)
         throw new Error(`_stringEnumKey not found for: ${v}`);
     return r;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.187.0",
+  "version": "14.188.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/enum.util.ts

@@ -1,32 +1,32 @@
 import type { NumberEnum, StringEnum } from './types'
 
 /**
- * Returns all number keys of a number-enum.
+ * Returns all String keys of a number-enum.
  */
 export function _numberEnumKeys(en: NumberEnum): string[] {
   return Object.values(en).filter(k => typeof k === 'string') as string[]
 }
 
 /**
- * Returns all number values of a number-enum.
+ * Returns all Number values of a number-enum.
  */
 export function _numberEnumValues(en: NumberEnum): number[] {
   return Object.values(en).filter(k => typeof k === 'number') as number[]
 }
 
 /**
- * Returns all string keys of a string-enum.
+ * Returns all String keys of a string-enum.
  */
 export function _stringEnumKeys(en: StringEnum): string[] {
   return Object.keys(en)
 }
 
 /**
- * Returns all string values of a string-enum.
+ * Returns all String values of a string-enum.
  */
-export function _stringEnumValues(en: StringEnum): string[] {
+export function _stringEnumValues<T extends StringEnum>(en: T): T[keyof T][] {
   // filtering here is unnecessary, but works as a safety in case Number-enum is passed
-  return Object.values(en).filter(k => typeof k === 'string')
+  return Object.values(en).filter(k => typeof k === 'string') as any
 }
 
 /**
@@ -41,48 +41,105 @@ export function _numberEnumEntries<T extends NumberEnum>(en: T): [k: string, v:
     .map(k => [k, en[k]]) as any
 }
 
+/**
+ * Like _numberEnumEntries, but reversed.
+ * So, keys are Numbers, values are Strings.
+ */
+export function _numberEnumEntriesReversed<T extends NumberEnum>(en: T): [k: number, v: keyof T][] {
+  return Object.values(en)
+    .filter(k => typeof k === 'string')
+    .map(k => [en[k], k]) as any
+}
+
+/**
+ * Like _numberEnumEntries, but as a Map.
+ * Keys are Strings, values are Numbers.
+ */
+export function _numberEnumAsMap<T extends NumberEnum>(en: T): Map<string, T[keyof T]> {
+  return new Map(
+    Object.values(en)
+      .filter(k => typeof k === 'string')
+      .map(k => [k, en[k]]) as any,
+  )
+}
+
+/**
+ * Like _numberEnumEntriesReversed, but as a Map.
+ * Keys are Numbers (actual Numbers, because it's a Map, not an Object), values are Strings.
+ */
+export function _numberEnumAsMapReversed<T extends NumberEnum>(en: T): Map<number, keyof T> {
+  return new Map(
+    Object.values(en)
+      .filter(k => typeof k === 'string')
+      .map(k => [en[k], k]) as any,
+  )
+}
+
 /**
  * Returns all string-enum "entries", where entry is a tuple of [key, value],
  * where key is a String key, value is a String value, typed as Enum itself.
  *
  * Doesn't work on Number-enums!
  */
-export function _stringEnumEntries<T extends StringEnum>(en: T): [k: string, v: T[keyof T]][] {
+export function _stringEnumEntries<T extends StringEnum>(en: T): [k: keyof T, v: T[keyof T]][] {
   return Object.entries(en) as any
 }
 
+/**
+ * Like _stringEnumEntries, but keys and values are reversed.
+ */
+export function _stringEnumEntriesReversed<T extends StringEnum>(
+  en: T,
+): [k: T[keyof T], v: keyof T][] {
+  return Object.entries(en).map(([k, v]) => [v, k]) as any
+}
+
+/**
+ * Return String enum as Map (with the same keys and values).
+ */
+export function _stringEnumAsMap<T extends StringEnum>(en: T): Map<keyof T, T[keyof T]> {
+  return new Map(Object.entries(en)) as any
+}
+
+/**
+ * Return String enum as Map, with keys and values reversed.
+ */
+export function _stringEnumAsMapReversed<T extends StringEnum>(en: T): Map<T[keyof T], keyof T> {
+  return new Map(Object.entries(en).map(([k, v]) => [v, k])) as any
+}
+
 /**
  * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
  * e.g:
- * const v = SomeEnum['stringValue']
+ * const v = SomeEnum['stringKey']
  * // v is of type SomeEnum, which is of type Number
  *
  * Throws if value is not found!
  */
-export function _numberEnumInverse<T extends NumberEnum>(en: T, v: string): T[keyof T] {
-  const r = en[v as keyof T] as any
-  if (!r) throw new Error(`_numberEnumInverse value not found for: ${v}`)
+export function _numberEnumValue<T extends NumberEnum>(en: T, k: keyof T): T[keyof T] {
+  const r = en[k]
+  if (!r) throw new Error(`_numberEnumValue not found for: ${k as string}`)
   return r
 }
 
 /**
- * _numberEnumInverse, but allows to get/return undefined output.
+ * _numberEnumKey, but allows to get/return undefined output.
  */
-export function _numberEnumInverseNullable<T extends NumberEnum>(
+export function _numberEnumValueOrUndefined<T extends NumberEnum>(
   en: T,
-  v: string | undefined,
+  k: keyof T | undefined,
 ): T[keyof T] | undefined {
-  return en[v as keyof T]
+  return en[k!]
 }
 
 /**
- * Takes number or string enum input, returns normalized Enum output.
+ * Takes number or string enum input, returns normalized Enum output (Number).
  * Only works for number enums.
  *
  * Throws if value is not found!
  */
 export function _numberEnumNormalize<T extends NumberEnum>(en: T, v: string | number): T[keyof T] {
-  const r = _numberEnumNormalizeNullable(en, v)
+  const r = _numberEnumNormalizeOrUndefined(en, v)
   if (!r || !en[r as keyof T]) throw new Error(`_numberEnumNormalize value not found for: ${v}`)
   return r
 }
@@ -90,7 +147,7 @@ export function _numberEnumNormalize<T extends NumberEnum>(en: T, v: string | nu
 /**
  * Same as _numberEnumNormalize, but allows to return undefined values.
  */
-export function _numberEnumNormalizeNullable<T extends NumberEnum>(
+export function _numberEnumNormalizeOrUndefined<T extends NumberEnum>(
   en: T,
   v: string | number | undefined,
 ): T[keyof T] | undefined {
@@ -100,7 +157,7 @@ export function _numberEnumNormalizeNullable<T extends NumberEnum>(
 /**
  * Returns a String key for given NumberEnum value, or undefined if not found.
  */
-export function _numberEnumKeyNullable<T extends NumberEnum>(
+export function _numberEnumKeyOrUndefined<T extends NumberEnum>(
   en: T,
   v: T[keyof T] | undefined | null,
 ): keyof T | undefined {
@@ -122,7 +179,7 @@ export function _numberEnumKey<T extends NumberEnum>(
   return key
 }
 
-export function _stringEnumKeyNullable<T extends StringEnum>(
+export function _stringEnumKeyOrUndefined<T extends StringEnum>(
   en: T,
   // v: T[keyof T] | undefined | null, // cannot make it type-safe :(
   v: string | undefined | null,
@@ -131,7 +188,7 @@ export function _stringEnumKeyNullable<T extends StringEnum>(
 }
 
 export function _stringEnumKey<T extends StringEnum>(en: T, v: string | undefined | null): keyof T {
-  const r = _stringEnumKeyNullable(en, v)
+  const r = _stringEnumKeyOrUndefined(en, v)
   if (!r) throw new Error(`_stringEnumKey not found for: ${v}`)
   return r
 }