@react-native/codegen 0.72.1 → 0.72.3

package/lib/generators/modules/GenerateModuleCpp.js

@@ -148,7 +148,7 @@ ${modules}
 } // namespace facebook
 `;
 };
-function serializeArg(arg, index, resolveAlias) {
+function serializeArg(moduleName, arg, index, resolveAlias, enumMap) {
   const nullableTypeAnnotation = arg.typeAnnotation,
     optional = arg.optional;
   const _unwrapNullable = unwrapNullable(nullableTypeAnnotation),
@@ -238,9 +238,11 @@ function serializeArg(arg, index, resolveAlias) {
   }
 }
 function serializePropertyIntoHostFunction(
+  moduleName,
   hasteModuleName,
   property,
   resolveAlias,
+  enumMap,
 ) {
   const _unwrapNullable3 = unwrapNullable(property.typeAnnotation),
     _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
@@ -250,7 +252,7 @@ function serializePropertyIntoHostFunction(
     methodName: property.name,
     returnTypeAnnotation: propertyTypeAnnotation.returnTypeAnnotation,
     args: propertyTypeAnnotation.params.map((p, i) =>
-      serializeArg(p, i, resolveAlias),
+      serializeArg(moduleName, p, i, resolveAlias, enumMap),
     ),
   });
 }
@@ -260,15 +262,18 @@ module.exports = {
     const modules = Object.keys(nativeModules)
       .map(hasteModuleName => {
         const nativeModule = nativeModules[hasteModuleName];
-        const aliases = nativeModule.aliases,
+        const aliasMap = nativeModule.aliasMap,
+          enumMap = nativeModule.enumMap,
           properties = nativeModule.spec.properties,
           moduleName = nativeModule.moduleName;
-        const resolveAlias = createAliasResolver(aliases);
+        const resolveAlias = createAliasResolver(aliasMap);
         const hostFunctions = properties.map(property =>
           serializePropertyIntoHostFunction(
+            moduleName,
             hasteModuleName,
             property,
             resolveAlias,
+            enumMap,
           ),
         );
         return ModuleTemplate({

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

@@ -18,6 +18,7 @@ import type {
   NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
   NativeModuleTypeAnnotation,
+  NativeModuleEnumMap,
 } from '../../CodegenSchema';
 
 import type {AliasResolver} from './Utils';
@@ -114,9 +115,11 @@ ${modules}
 type Param = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
 
 function serializeArg(
+  moduleName: string,
   arg: Param,
   index: number,
   resolveAlias: AliasResolver,
+  enumMap: NativeModuleEnumMap,
 ): string {
   const {typeAnnotation: nullableTypeAnnotation, optional} = arg;
   const [typeAnnotation, nullable] =
@@ -208,9 +211,11 @@ function serializeArg(
 }
 
 function serializePropertyIntoHostFunction(
+  moduleName: string,
   hasteModuleName: string,
   property: NativeModulePropertyShape,
   resolveAlias: AliasResolver,
+  enumMap: NativeModuleEnumMap,
 ): string {
   const [propertyTypeAnnotation] =
     unwrapNullable<NativeModuleFunctionTypeAnnotation>(property.typeAnnotation);
@@ -220,7 +225,7 @@ function serializePropertyIntoHostFunction(
     methodName: property.name,
     returnTypeAnnotation: propertyTypeAnnotation.returnTypeAnnotation,
     args: propertyTypeAnnotation.params.map((p, i) =>
-      serializeArg(p, i, resolveAlias),
+      serializeArg(moduleName, p, i, resolveAlias, enumMap),
     ),
   });
 }
@@ -238,16 +243,19 @@ module.exports = {
       .map((hasteModuleName: string) => {
         const nativeModule = nativeModules[hasteModuleName];
         const {
-          aliases,
+          aliasMap,
+          enumMap,
           spec: {properties},
           moduleName,
         } = nativeModule;
-        const resolveAlias = createAliasResolver(aliases);
+        const resolveAlias = createAliasResolver(aliasMap);
         const hostFunctions = properties.map(property =>
           serializePropertyIntoHostFunction(
+            moduleName,
             hasteModuleName,
             property,
             resolveAlias,
+            enumMap,
           ),
         );
 

package/lib/generators/modules/GenerateModuleH.js

@@ -78,19 +78,25 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('./Utils'),
-  createAliasResolver = _require.createAliasResolver,
-  getModules = _require.getModules;
-const _require2 = require('../Utils'),
-  indent = _require2.indent;
-const _require3 = require('../../parsers/parsers-commons'),
-  unwrapNullable = _require3.unwrapNullable;
+const _require = require('../Utils'),
+  getEnumName = _require.getEnumName,
+  toSafeCppString = _require.toSafeCppString;
+const _require2 = require('./Utils'),
+  createAliasResolver = _require2.createAliasResolver,
+  getModules = _require2.getModules,
+  getAreEnumMembersInteger = _require2.getAreEnumMembersInteger;
+const _require3 = require('../Utils'),
+  indent = _require3.indent;
+const _require4 = require('../../parsers/parsers-commons'),
+  unwrapNullable = _require4.unwrapNullable;
 const ModuleClassDeclarationTemplate = ({
   hasteModuleName,
   moduleProperties,
   structs,
+  enums,
 }) => {
-  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);
 
@@ -156,10 +162,12 @@ ${modules.join('\n\n')}
 `;
 };
 function translatePrimitiveJSTypeToCpp(
+  moduleName,
   nullableTypeAnnotation,
   optional,
   createErrorMessage,
   resolveAlias,
+  enumMap,
 ) {
   const _unwrapNullable = unwrapNullable(nullableTypeAnnotation),
     _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
@@ -199,7 +207,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:
@@ -233,7 +245,7 @@ function translatePrimitiveJSTypeToCpp(
       throw new Error(createErrorMessage(realTypeAnnotation.type));
   }
 }
-function createStructs(moduleName, aliasMap, resolveAlias) {
+function createStructsString(moduleName, aliasMap, resolveAlias, enumMap) {
   return Object.keys(aliasMap)
     .map(alias => {
       const value = aliasMap[alias];
@@ -247,6 +259,22 @@ function createStructs(moduleName, aliasMap, resolveAlias) {
       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}>
@@ -275,30 +303,136 @@ ${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');
 }
-function translatePropertyToCpp(prop, resolveAlias, abstract = false) {
+const EnumTemplate = ({
+  enumName,
+  values,
+  fromCases,
+  toCases,
+  nativeEnumMemberType,
+}) => {
+  const _ref =
+      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',
+          ],
+    _ref2 = _slicedToArray(_ref, 3),
+    fromValue = _ref2[0],
+    fromValueConversion = _ref2[1],
+    toValue = _ref2[2];
+  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, origEnumName, members, memberType) {
+  const enumName = getEnumName(moduleName, origEnumName);
+  const nativeEnumMemberType =
+    memberType === 'StringTypeAnnotation'
+      ? 'std::string'
+      : getAreEnumMembersInteger(members)
+      ? 'int32_t'
+      : 'float';
+  const getMemberValueAppearance = value =>
+    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, enumMap, resolveAlias) {
+  return Object.entries(enumMap)
+    .map(([enumName, enumNode]) => {
+      return generateEnum(
+        moduleName,
+        enumName,
+        enumNode.members,
+        enumNode.memberType,
+      );
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+function translatePropertyToCpp(
+  moduleName,
+  prop,
+  resolveAlias,
+  enumMap,
+  abstract = false,
+) {
   const _unwrapNullable3 = unwrapNullable(prop.typeAnnotation),
     _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
     propTypeAnnotation = _unwrapNullable4[0];
@@ -307,19 +441,23 @@ function translatePropertyToCpp(prop, resolveAlias, abstract = false) {
   );
   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.
@@ -342,24 +480,38 @@ module.exports = {
     const nativeModules = getModules(schema);
     const modules = Object.keys(nativeModules).flatMap(hasteModuleName => {
       const _nativeModules$hasteM = nativeModules[hasteModuleName],
-        aliases = _nativeModules$hasteM.aliases,
+        aliasMap = _nativeModules$hasteM.aliasMap,
+        enumMap = _nativeModules$hasteM.enumMap,
         properties = _nativeModules$hasteM.spec.properties,
         moduleName = _nativeModules$hasteM.moduleName;
-      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),
           ),
         }),
       ];