@react-native/codegen 0.72.1 → 0.72.3

package/lib/generators/modules/GenerateModuleH.js.flow

@@ -17,10 +17,20 @@ import type {
   NativeModuleFunctionTypeAnnotation,
   NativeModulePropertyShape,
   NativeModuleAliasMap,
+  NativeModuleEnumMap,
+  NativeModuleEnumMembers,
+  NativeModuleEnumMemberType,
 } from '../../CodegenSchema';
 
 import type {AliasResolver} from './Utils';
-const {createAliasResolver, getModules} = require('./Utils');
+
+const {getEnumName, toSafeCppString} = require('../Utils');
+
+const {
+  createAliasResolver,
+  getModules,
+  getAreEnumMembersInteger,
+} = require('./Utils');
 const {indent} = require('../Utils');
 const {unwrapNullable} = require('../../parsers/parsers-commons');
 
@@ -30,12 +40,15 @@ const ModuleClassDeclarationTemplate = ({
   hasteModuleName,
   moduleProperties,
   structs,
+  enums,
 }: $ReadOnly<{
   hasteModuleName: string,
   moduleProperties: string[],
   structs: string,
+  enums: string,
 }>) => {
-  return `${structs}class JSI_EXPORT ${hasteModuleName}CxxSpecJSI : public TurboModule {
+  return `${enums}
+  ${structs}class JSI_EXPORT ${hasteModuleName}CxxSpecJSI : public TurboModule {
 protected:
   ${hasteModuleName}CxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
@@ -112,10 +125,12 @@ ${modules.join('\n\n')}
 };
 
 function translatePrimitiveJSTypeToCpp(
+  moduleName: string,
   nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
   optional: boolean,
   createErrorMessage: (typeName: string) => string,
   resolveAlias: AliasResolver,
+  enumMap: NativeModuleEnumMap,
 ) {
   const [typeAnnotation, nullable] = unwrapNullable<NativeModuleTypeAnnotation>(
     nullableTypeAnnotation,
@@ -157,7 +172,11 @@ function translatePrimitiveJSTypeToCpp(
     case 'EnumDeclaration':
       switch (realTypeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrap('double');
+          return getAreEnumMembersInteger(
+            enumMap[realTypeAnnotation.name].members,
+          )
+            ? wrap('int')
+            : wrap('double');
         case 'StringTypeAnnotation':
           return wrap('jsi::String');
         default:
@@ -192,10 +211,11 @@ function translatePrimitiveJSTypeToCpp(
   }
 }
 
-function createStructs(
+function createStructsString(
   moduleName: string,
   aliasMap: NativeModuleAliasMap,
   resolveAlias: AliasResolver,
+  enumMap: NativeModuleEnumMap,
 ): string {
   return Object.keys(aliasMap)
     .map(alias => {
@@ -210,6 +230,22 @@ function createStructs(
       const templateParameter = value.properties
         .map((v, i) => 'P' + i)
         .join(', ');
+      const paramemterConversion = value.properties
+        .map((v, i) => {
+          const translatedParam = translatePrimitiveJSTypeToCpp(
+            moduleName,
+            v.typeAnnotation,
+            false,
+            typeName =>
+              `Unsupported type for param "${v.name}". Found: ${typeName}`,
+            resolveAlias,
+            enumMap,
+          );
+          return `  static ${translatedParam} ${v.name}ToJs(jsi::Runtime &rt, P${i} value) {
+    return bridging::toJs(rt, value);
+  }`;
+        })
+        .join('\n');
       return `#pragma mark - ${structName}
 
 template <${templateParameterWithTypename}>
@@ -238,33 +274,157 @@ ${value.properties
     return result;
   }
 
+#ifdef DEBUG
+${paramemterConversion}
+#endif
+
   static jsi::Object toJs(
-      jsi::Runtime &rt,
-      const ${structName}<${templateParameter}> &value) {
-    auto result = facebook::jsi::Object(rt);
-${value.properties
-  .map((v, i) => {
-    if (v.optional) {
-      return `    if (value.${v.name}) {
-      result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}.value()));
-    }`;
-    } else {
-      return `    result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}));`;
-    }
-  })
-  .join('\n')}
-    return result;
+    jsi::Runtime &rt,
+    const ${structName}<${templateParameter}> &value,
+    const std::shared_ptr<CallInvoker> &jsInvoker) {
+      auto result = facebook::jsi::Object(rt);
+      ${value.properties
+        .map((v, i) => {
+          if (v.optional) {
+            return `    if (value.${v.name}) {
+            result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}.value(), jsInvoker));
+          }`;
+          } else {
+            return `    result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}, jsInvoker));`;
+          }
+        })
+        .join('\n')}
+          return result;
+        }
+      };
+
+`;
+    })
+    .join('\n');
+}
+
+type NativeEnumMemberValueType = 'std::string' | 'int32_t' | 'float';
+
+const EnumTemplate = ({
+  enumName,
+  values,
+  fromCases,
+  toCases,
+  nativeEnumMemberType,
+}: {
+  enumName: string,
+  values: string,
+  fromCases: string,
+  toCases: string,
+  nativeEnumMemberType: NativeEnumMemberValueType,
+}) => {
+  const [fromValue, fromValueConversion, toValue] =
+    nativeEnumMemberType === 'std::string'
+      ? [
+          'const jsi::String &rawValue',
+          'std::string value = rawValue.utf8(rt);',
+          'jsi::String',
+        ]
+      : [
+          'const jsi::Value &rawValue',
+          'double value = (double)rawValue.asNumber();',
+          'jsi::Value',
+        ];
+
+  return `
+#pragma mark - ${enumName}
+
+enum ${enumName} { ${values} };
+
+template <>
+struct Bridging<${enumName}> {
+  static ${enumName} fromJs(jsi::Runtime &rt, ${fromValue}, const std::shared_ptr<CallInvoker> &jsInvoker) {
+    ${fromValueConversion}
+    ${fromCases}
+  }
+
+  static ${toValue} toJs(jsi::Runtime &rt, ${enumName} value, const std::shared_ptr<CallInvoker> &jsInvoker) {
+    ${toCases}
   }
+};`;
 };
 
-`;
+function generateEnum(
+  moduleName: string,
+  origEnumName: string,
+  members: NativeModuleEnumMembers,
+  memberType: NativeModuleEnumMemberType,
+): string {
+  const enumName = getEnumName(moduleName, origEnumName);
+
+  const nativeEnumMemberType: NativeEnumMemberValueType =
+    memberType === 'StringTypeAnnotation'
+      ? 'std::string'
+      : getAreEnumMembersInteger(members)
+      ? 'int32_t'
+      : 'float';
+
+  const getMemberValueAppearance = (value: string) =>
+    memberType === 'StringTypeAnnotation'
+      ? `"${value}"`
+      : `${value}${nativeEnumMemberType === 'float' ? 'f' : ''}`;
+
+  const fromCases =
+    members
+      .map(
+        member => `if (value == ${getMemberValueAppearance(member.value)}) {
+      return ${enumName}::${toSafeCppString(member.name)};
+    }`,
+      )
+      .join(' else ') +
+    ` else {
+      throw jsi::JSError(rt, "No appropriate enum member found for value");
+    }`;
+
+  const toCases =
+    members
+      .map(
+        member => `if (value == ${enumName}::${toSafeCppString(member.name)}) {
+      return bridging::toJs(rt, ${getMemberValueAppearance(member.value)});
+    }`,
+      )
+      .join(' else ') +
+    ` else {
+      throw jsi::JSError(rt, "No appropriate enum member found for enum value");
+    }`;
+
+  return EnumTemplate({
+    enumName,
+    values: members.map(member => member.name).join(', '),
+    fromCases,
+    toCases,
+    nativeEnumMemberType,
+  });
+}
+
+function createEnums(
+  moduleName: string,
+  enumMap: NativeModuleEnumMap,
+  resolveAlias: AliasResolver,
+): string {
+  return Object.entries(enumMap)
+    .map(([enumName, enumNode]) => {
+      return generateEnum(
+        moduleName,
+        enumName,
+        enumNode.members,
+        enumNode.memberType,
+      );
     })
+    .filter(Boolean)
     .join('\n');
 }
 
 function translatePropertyToCpp(
+  moduleName: string,
   prop: NativeModulePropertyShape,
   resolveAlias: AliasResolver,
+  enumMap: NativeModuleEnumMap,
   abstract: boolean = false,
 ) {
   const [propTypeAnnotation] =
@@ -276,20 +436,24 @@ function translatePropertyToCpp(
 
   const paramTypes = propTypeAnnotation.params.map(param => {
     const translatedParam = translatePrimitiveJSTypeToCpp(
+      moduleName,
       param.typeAnnotation,
       param.optional,
       typeName =>
         `Unsupported type for param "${param.name}" in ${prop.name}. Found: ${typeName}`,
       resolveAlias,
+      enumMap,
     );
     return `${translatedParam} ${param.name}`;
   });
 
   const returnType = translatePrimitiveJSTypeToCpp(
+    moduleName,
     propTypeAnnotation.returnTypeAnnotation,
     false,
     typeName => `Unsupported return type for ${prop.name}. Found: ${typeName}`,
     resolveAlias,
+    enumMap,
   );
 
   // The first param will always be the runtime reference.
@@ -322,26 +486,40 @@ module.exports = {
 
     const modules = Object.keys(nativeModules).flatMap(hasteModuleName => {
       const {
-        aliases,
+        aliasMap,
+        enumMap,
         spec: {properties},
         moduleName,
       } = nativeModules[hasteModuleName];
-      const resolveAlias = createAliasResolver(aliases);
-      const structs = createStructs(moduleName, aliases, resolveAlias);
+      const resolveAlias = createAliasResolver(aliasMap);
+      const structs = createStructsString(
+        moduleName,
+        aliasMap,
+        resolveAlias,
+        enumMap,
+      );
+      const enums = createEnums(moduleName, enumMap, resolveAlias);
 
       return [
         ModuleClassDeclarationTemplate({
           hasteModuleName,
           moduleProperties: properties.map(prop =>
-            translatePropertyToCpp(prop, resolveAlias, true),
+            translatePropertyToCpp(
+              moduleName,
+              prop,
+              resolveAlias,
+              enumMap,
+              true,
+            ),
           ),
           structs,
+          enums,
         }),
         ModuleSpecClassDeclarationTemplate({
           hasteModuleName,
           moduleName,
           moduleProperties: properties.map(prop =>
-            translatePropertyToCpp(prop, resolveAlias),
+            translatePropertyToCpp(moduleName, prop, resolveAlias, enumMap),
           ),
         }),
       ];

package/lib/generators/modules/GenerateModuleJavaSpec.js

@@ -474,14 +474,14 @@ module.exports = {
     const outputDir = `java/${normalizedPackageName.replace(/\./g, '/')}`;
     Object.keys(nativeModules).forEach(hasteModuleName => {
       const _nativeModules$hasteM = nativeModules[hasteModuleName],
-        aliases = _nativeModules$hasteM.aliases,
+        aliasMap = _nativeModules$hasteM.aliasMap,
         excludedPlatforms = _nativeModules$hasteM.excludedPlatforms,
         moduleName = _nativeModules$hasteM.moduleName,
         properties = _nativeModules$hasteM.spec.properties;
       if (excludedPlatforms != null && excludedPlatforms.includes('android')) {
         return;
       }
-      const resolveAlias = createAliasResolver(aliases);
+      const resolveAlias = createAliasResolver(aliasMap);
       const className = `${hasteModuleName}Spec`;
       const imports = new Set([
         // Always required.

package/lib/generators/modules/GenerateModuleJavaSpec.js.flow

@@ -184,7 +184,7 @@ function translateFunctionParamToJavaType(
       imports.add('com.facebook.react.bridge.Callback');
       return wrapNullable('Callback');
     default:
-      (realTypeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (realTypeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(createErrorMessage(realTypeAnnotation.type));
   }
 }
@@ -272,7 +272,7 @@ function translateFunctionReturnTypeToJavaType(
       imports.add('com.facebook.react.bridge.WritableArray');
       return wrapNullable('WritableArray');
     default:
-      (realTypeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (realTypeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(createErrorMessage(realTypeAnnotation.type));
   }
 }
@@ -346,7 +346,7 @@ function getFalsyReturnStatementFromReturnType(
     case 'ArrayTypeAnnotation':
       return 'return null;';
     default:
-      (realTypeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (realTypeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(createErrorMessage(realTypeAnnotation.type));
   }
 }
@@ -447,7 +447,7 @@ module.exports = {
 
     Object.keys(nativeModules).forEach(hasteModuleName => {
       const {
-        aliases,
+        aliasMap,
         excludedPlatforms,
         moduleName,
         spec: {properties},
@@ -455,7 +455,7 @@ module.exports = {
       if (excludedPlatforms != null && excludedPlatforms.includes('android')) {
         return;
       }
-      const resolveAlias = createAliasResolver(aliases);
+      const resolveAlias = createAliasResolver(aliasMap);
       const className = `${hasteModuleName}Spec`;
 
       const imports: Set<string> = new Set([

package/lib/generators/modules/GenerateModuleJniCpp.js

@@ -428,9 +428,9 @@ module.exports = {
       .sort()
       .map(hasteModuleName => {
         const _nativeModules$hasteM = nativeModules[hasteModuleName],
-          aliases = _nativeModules$hasteM.aliases,
+          aliasMap = _nativeModules$hasteM.aliasMap,
           properties = _nativeModules$hasteM.spec.properties;
-        const resolveAlias = createAliasResolver(aliases);
+        const resolveAlias = createAliasResolver(aliasMap);
         const translatedMethods = properties
           .map(property =>
             translateMethodForImplementation(

package/lib/generators/modules/GenerateModuleJniCpp.js.flow

@@ -193,7 +193,7 @@ function translateReturnTypeToKind(
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
     default:
-      (realTypeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (realTypeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(
         `Unknown prop type for returning value, found: ${realTypeAnnotation.type}"`,
       );
@@ -272,7 +272,7 @@ function translateParamTypeToJniType(
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
     default:
-      (realTypeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (realTypeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(
         `Unknown prop type for method arg, found: ${realTypeAnnotation.type}"`,
       );
@@ -348,7 +348,7 @@ function translateReturnTypeToJniType(
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
     default:
-      (realTypeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (realTypeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(
         `Unknown prop type for method return type, found: ${realTypeAnnotation.type}"`,
       );
@@ -438,10 +438,10 @@ module.exports = {
       .sort()
       .map(hasteModuleName => {
         const {
-          aliases,
+          aliasMap,
           spec: {properties},
         } = nativeModules[hasteModuleName];
-        const resolveAlias = createAliasResolver(aliases);
+        const resolveAlias = createAliasResolver(aliasMap);
 
         const translatedMethods = properties
           .map(property =>

package/lib/generators/modules/GenerateModuleObjCpp/index.js

@@ -106,13 +106,13 @@ module.exports = {
     const hasteModuleNames = Object.keys(nativeModules).sort();
     for (const hasteModuleName of hasteModuleNames) {
       const _nativeModules$hasteM = nativeModules[hasteModuleName],
-        aliases = _nativeModules$hasteM.aliases,
+        aliasMap = _nativeModules$hasteM.aliasMap,
         excludedPlatforms = _nativeModules$hasteM.excludedPlatforms,
         properties = _nativeModules$hasteM.spec.properties;
       if (excludedPlatforms != null && excludedPlatforms.includes('iOS')) {
         continue;
       }
-      const resolveAlias = createAliasResolver(aliases);
+      const resolveAlias = createAliasResolver(aliasMap);
       const structCollector = new StructCollector();
       const methodSerializations = [];
       const serializeProperty = property => {

package/lib/generators/modules/GenerateModuleObjCpp/index.js.flow

@@ -132,14 +132,14 @@ module.exports = {
     const hasteModuleNames: Array<string> = Object.keys(nativeModules).sort();
     for (const hasteModuleName of hasteModuleNames) {
       const {
-        aliases,
+        aliasMap,
         excludedPlatforms,
         spec: {properties},
       } = nativeModules[hasteModuleName];
       if (excludedPlatforms != null && excludedPlatforms.includes('iOS')) {
         continue;
       }
-      const resolveAlias = createAliasResolver(aliases);
+      const resolveAlias = createAliasResolver(aliasMap);
       const structCollector = new StructCollector();
 
       const methodSerializations: Array<MethodSerializationOutput> = [];

package/lib/generators/modules/GenerateModuleObjCpp/serializeMethod.js.flow

@@ -375,7 +375,7 @@ function getReturnObjCType(
     case 'GenericObjectTypeAnnotation':
       return wrapIntoNullableIfNeeded('NSDictionary *');
     default:
-      (typeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (typeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(
         `Unsupported return type for ${methodName}. Found: ${typeAnnotation.type}`,
       );
@@ -439,7 +439,7 @@ function getReturnJSType(
           );
       }
     default:
-      (typeAnnotation.type: 'EnumDeclaration' | 'MixedTypeAnnotation');
+      (typeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(
         `Unsupported return type for ${methodName}. Found: ${typeAnnotation.type}`,
       );

package/lib/generators/modules/Utils.js

@@ -28,7 +28,11 @@ function getModules(schema) {
     return modules;
   }, {});
 }
+function getAreEnumMembersInteger(members) {
+  return !members.some(m => `${m.value}`.includes('.'));
+}
 module.exports = {
   createAliasResolver,
   getModules,
+  getAreEnumMembersInteger,
 };

package/lib/generators/modules/Utils.js.flow

@@ -15,6 +15,7 @@ import type {
   NativeModuleAliasMap,
   NativeModuleObjectTypeAnnotation,
   NativeModuleSchema,
+  NativeModuleEnumMembers,
 } from '../../CodegenSchema';
 
 const invariant = require('invariant');
@@ -47,7 +48,12 @@ function getModules(
   );
 }
 
+function getAreEnumMembersInteger(members: NativeModuleEnumMembers): boolean {
+  return !members.some(m => `${m.value}`.includes('.'));
+}
+
 module.exports = {
   createAliasResolver,
   getModules,
+  getAreEnumMembersInteger,
 };