[typescript-fetch] Restore pre-es2017 compatibility in modelEnum template (OpenAPITools#18418)

* [typescript-fetch] Restore pre-es2017 compatibility in modelEnum template

Restore pre-es2017 compatibility in modelEnum template by not using Object.values in instanceOf{{classname}} function

* [typescript-fetch] Regenerate samples

* [typescript-fetch] Regenerate samples documentation

* [typescript-fetch] Add curly brackets

* [typescript-fetch] Regenerate samples

* [typescript-fetch] Use typed comparison

Co-authored-by: Esteban Gehring <esteban.gehring@gmail.com>

* [typescript-fetch] Regenerate samples

---------

Co-authored-by: Esteban Gehring <esteban.gehring@gmail.com>

Author: manuel-covas

modules/openapi-generator/src/main/resources/typescript-fetch/modelEnum.mustache

@@ -1,7 +1,14 @@
 {{>modelEnumInterfaces}}
 
 export function instanceOf{{classname}}(value: any): boolean {
-    return Object.values({{classname}}).includes(value);
+    for (const key in {{classname}}) {
+        if (Object.prototype.hasOwnProperty.call({{classname}}, key)) {
+            if ({{classname}}[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function {{classname}}FromJSON(json: any): {{classname}} {

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/EnumClass.ts

@@ -26,7 +26,14 @@ export type EnumClass = typeof EnumClass[keyof typeof EnumClass];
 
 
 export function instanceOfEnumClass(value: any): boolean {
-    return Object.values(EnumClass).includes(value);
+    for (const key in EnumClass) {
+        if (Object.prototype.hasOwnProperty.call(EnumClass, key)) {
+            if (EnumClass[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function EnumClassFromJSON(json: any): EnumClass {

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnum.ts

@@ -26,7 +26,14 @@ export type OuterEnum = typeof OuterEnum[keyof typeof OuterEnum];
 
 
 export function instanceOfOuterEnum(value: any): boolean {
-    return Object.values(OuterEnum).includes(value);
+    for (const key in OuterEnum) {
+        if (Object.prototype.hasOwnProperty.call(OuterEnum, key)) {
+            if (OuterEnum[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function OuterEnumFromJSON(json: any): OuterEnum {

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumDefaultValue.ts

@@ -26,7 +26,14 @@ export type OuterEnumDefaultValue = typeof OuterEnumDefaultValue[keyof typeof Ou
 
 
 export function instanceOfOuterEnumDefaultValue(value: any): boolean {
-    return Object.values(OuterEnumDefaultValue).includes(value);
+    for (const key in OuterEnumDefaultValue) {
+        if (Object.prototype.hasOwnProperty.call(OuterEnumDefaultValue, key)) {
+            if (OuterEnumDefaultValue[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function OuterEnumDefaultValueFromJSON(json: any): OuterEnumDefaultValue {

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumInteger.ts

@@ -26,7 +26,14 @@ export type OuterEnumInteger = typeof OuterEnumInteger[keyof typeof OuterEnumInt
 
 
 export function instanceOfOuterEnumInteger(value: any): boolean {
-    return Object.values(OuterEnumInteger).includes(value);
+    for (const key in OuterEnumInteger) {
+        if (Object.prototype.hasOwnProperty.call(OuterEnumInteger, key)) {
+            if (OuterEnumInteger[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function OuterEnumIntegerFromJSON(json: any): OuterEnumInteger {

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumIntegerDefaultValue.ts

@@ -26,7 +26,14 @@ export type OuterEnumIntegerDefaultValue = typeof OuterEnumIntegerDefaultValue[k
 
 
 export function instanceOfOuterEnumIntegerDefaultValue(value: any): boolean {
-    return Object.values(OuterEnumIntegerDefaultValue).includes(value);
+    for (const key in OuterEnumIntegerDefaultValue) {
+        if (Object.prototype.hasOwnProperty.call(OuterEnumIntegerDefaultValue, key)) {
+            if (OuterEnumIntegerDefaultValue[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function OuterEnumIntegerDefaultValueFromJSON(json: any): OuterEnumIntegerDefaultValue {

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/SingleRefType.ts

@@ -25,7 +25,14 @@ export type SingleRefType = typeof SingleRefType[keyof typeof SingleRefType];
 
 
 export function instanceOfSingleRefType(value: any): boolean {
-    return Object.values(SingleRefType).includes(value);
+    for (const key in SingleRefType) {
+        if (Object.prototype.hasOwnProperty.call(SingleRefType, key)) {
+            if (SingleRefType[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function SingleRefTypeFromJSON(json: any): SingleRefType {

samples/client/petstore/typescript-fetch/builds/enum/models/NumberEnum.ts

@@ -26,7 +26,14 @@ export type NumberEnum = typeof NumberEnum[keyof typeof NumberEnum];
 
 
 export function instanceOfNumberEnum(value: any): boolean {
-    return Object.values(NumberEnum).includes(value);
+    for (const key in NumberEnum) {
+        if (Object.prototype.hasOwnProperty.call(NumberEnum, key)) {
+            if (NumberEnum[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function NumberEnumFromJSON(json: any): NumberEnum {

samples/client/petstore/typescript-fetch/builds/enum/models/StringEnum.ts

@@ -26,7 +26,14 @@ export type StringEnum = typeof StringEnum[keyof typeof StringEnum];
 
 
 export function instanceOfStringEnum(value: any): boolean {
-    return Object.values(StringEnum).includes(value);
+    for (const key in StringEnum) {
+        if (Object.prototype.hasOwnProperty.call(StringEnum, key)) {
+            if (StringEnum[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function StringEnumFromJSON(json: any): StringEnum {

samples/client/petstore/typescript-fetch/builds/sagas-and-records/src/models/BehaviorType.ts

@@ -26,7 +26,14 @@ export type BehaviorType = typeof BehaviorType[keyof typeof BehaviorType];
 
 
 export function instanceOfBehaviorType(value: any): boolean {
-    return Object.values(BehaviorType).includes(value);
+    for (const key in BehaviorType) {
+        if (Object.prototype.hasOwnProperty.call(BehaviorType, key)) {
+            if (BehaviorType[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 export function BehaviorTypeFromJSON(json: any): BehaviorType {