@react-native/codegen 0.73.0 → 0.74.0-nightly-20231003-5dedf277c

package/lib/generators/components/__test_fixtures__/fixtures.js.flow

@@ -123,7 +123,7 @@ const EVENTS_WITH_PAPER_NAME: SchemaType = {
               },
             },
             {
-              name: 'onDire tChange',
+              name: 'onDirectChange',
               paperTopLevelNameDeprecated: 'paperDirectChange',
               optional: true,
               bubblingType: 'direct',
@@ -1206,6 +1206,99 @@ const EVENT_PROPS: SchemaType = {
                 },
               },
             },
+            {
+              name: 'onArrayEventType',
+              optional: true,
+              bubblingType: 'bubble',
+              typeAnnotation: {
+                type: 'EventTypeAnnotation',
+                argument: {
+                  type: 'ObjectTypeAnnotation',
+                  properties: [
+                    {
+                      name: 'bool_array_event_prop',
+                      optional: false,
+                      typeAnnotation: {
+                        type: 'ArrayTypeAnnotation',
+                        elementType: {
+                          type: 'BooleanTypeAnnotation',
+                        },
+                      },
+                    },
+                    {
+                      name: 'string_enum_event_prop',
+                      optional: false,
+                      typeAnnotation: {
+                        type: 'ArrayTypeAnnotation',
+                        elementType: {
+                          type: 'StringEnumTypeAnnotation',
+                          options: ['YES', 'NO'],
+                        },
+                      },
+                    },
+                    {
+                      name: 'array_array_event_prop',
+                      optional: false,
+                      typeAnnotation: {
+                        type: 'ArrayTypeAnnotation',
+                        elementType: {
+                          type: 'ArrayTypeAnnotation',
+                          elementType: {
+                            type: 'StringTypeAnnotation',
+                          },
+                        },
+                      },
+                    },
+                    {
+                      name: 'array_object_event_prop',
+                      optional: false,
+                      typeAnnotation: {
+                        type: 'ArrayTypeAnnotation',
+                        elementType: {
+                          type: 'ObjectTypeAnnotation',
+                          properties: [
+                            {
+                              name: 'lat',
+                              optional: false,
+                              typeAnnotation: {
+                                type: 'DoubleTypeAnnotation',
+                              },
+                            },
+                            {
+                              name: 'lon',
+                              optional: false,
+                              typeAnnotation: {
+                                type: 'DoubleTypeAnnotation',
+                              },
+                            },
+                            {
+                              name: 'names',
+                              optional: false,
+                              typeAnnotation: {
+                                type: 'ArrayTypeAnnotation',
+                                elementType: {
+                                  type: 'StringTypeAnnotation',
+                                },
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                    {
+                      name: 'array_mixed_event_prop',
+                      optional: false,
+                      typeAnnotation: {
+                        type: 'ArrayTypeAnnotation',
+                        elementType: {
+                          type: 'MixedTypeAnnotation',
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
             {
               name: 'onEventDirect',
               optional: true,
@@ -1255,6 +1348,26 @@ const EVENT_PROPS: SchemaType = {
                 type: 'EventTypeAnnotation',
               },
             },
+            {
+              name: 'onEventWithMixedPropAttribute',
+              optional: true,
+              bubblingType: 'direct',
+              typeAnnotation: {
+                type: 'EventTypeAnnotation',
+                argument: {
+                  type: 'ObjectTypeAnnotation',
+                  properties: [
+                    {
+                      name: 'value',
+                      optional: false,
+                      typeAnnotation: {
+                        type: 'MixedTypeAnnotation',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
           ],
           props: [
             {

package/lib/generators/modules/GenerateModuleCpp.js

@@ -133,7 +133,7 @@ const FileTemplate = ({libraryName, modules}) => {
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
- * ${'@'}generated by codegen project: GenerateModuleH.js
+ * ${'@'}generated by codegen project: GenerateModuleCpp.js
  */
 
 #include "${libraryName}JSI.h"

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

@@ -96,7 +96,7 @@ const FileTemplate = ({
  * Do not edit this file as changes may cause incorrect behavior and will be lost
  * once the code is regenerated.
  *
- * ${'@'}generated by codegen project: GenerateModuleH.js
+ * ${'@'}generated by codegen project: GenerateModuleCpp.js
  */
 
 #include "${libraryName}JSI.h"

package/lib/generators/modules/GenerateModuleH.js

@@ -117,9 +117,11 @@ public:
     return delegate_.get(rt, propName);
   }
 
+  static constexpr std::string_view kModuleName = "${moduleName}";
+
 protected:
   ${hasteModuleName}CxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule("${moduleName}", jsInvoker),
+    : TurboModule(std::string{${hasteModuleName}CxxSpec::kModuleName}, jsInvoker),
       delegate_(static_cast<T*>(this), jsInvoker) {}
 
 private:
@@ -246,6 +248,15 @@ function translatePrimitiveJSTypeToCpp(
   }
 }
 function createStructsString(moduleName, aliasMap, resolveAlias, enumMap) {
+  const getCppType = v =>
+    translatePrimitiveJSTypeToCpp(
+      moduleName,
+      v.typeAnnotation,
+      false,
+      typeName => `Unsupported type for param "${v.name}". Found: ${typeName}`,
+      resolveAlias,
+      enumMap,
+    );
   return Object.keys(aliasMap)
     .map(alias => {
       const value = aliasMap[alias];
@@ -254,28 +265,22 @@ function createStructsString(moduleName, aliasMap, resolveAlias, enumMap) {
       }
       const structName = `${moduleName}Base${alias}`;
       const templateParameterWithTypename = value.properties
-        .map((v, i) => 'typename P' + i)
+        .map((v, i) => `typename P${i}`)
         .join(', ');
       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) {
+      const debugParameterConversion = value.properties
+        .map(
+          (v, i) => `  static ${getCppType(v)} ${
+            v.name
+          }ToJs(jsi::Runtime &rt, P${i} value) {
     return bridging::toJs(rt, value);
-  }`;
-        })
-        .join('\n');
-      return `#pragma mark - ${structName}
+  }`,
+        )
+        .join('\n\n');
+      return `
+#pragma mark - ${structName}
 
 template <${templateParameterWithTypename}>
 struct ${structName} {
@@ -304,28 +309,28 @@ ${value.properties
   }
 
 #ifdef DEBUG
-${paramemterConversion}
+${debugParameterConversion}
 #endif
 
   static jsi::Object toJs(
-    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;
-        }
-      };
+      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;
+  }
+};
 
 `;
     })
@@ -361,12 +366,12 @@ enum ${enumName} { ${values} };
 
 template <>
 struct Bridging<${enumName}> {
-  static ${enumName} fromJs(jsi::Runtime &rt, ${fromValue}, const std::shared_ptr<CallInvoker> &jsInvoker) {
+  static ${enumName} fromJs(jsi::Runtime &rt, ${fromValue}) {
     ${fromValueConversion}
     ${fromCases}
   }
 
-  static ${toValue} toJs(jsi::Runtime &rt, ${enumName} value, const std::shared_ptr<CallInvoker> &jsInvoker) {
+  static ${toValue} toJs(jsi::Runtime &rt, ${enumName} value) {
     ${toCases}
   }
 };`;

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

@@ -9,6 +9,10 @@
  */
 
 'use strict';
+import type {
+  NativeModuleBaseTypeAnnotation,
+  NamedShape,
+} from '../../CodegenSchema';
 
 import type {
   Nullable,
@@ -74,9 +78,11 @@ public:
     return delegate_.get(rt, propName);
   }
 
+  static constexpr std::string_view kModuleName = "${moduleName}";
+
 protected:
   ${hasteModuleName}CxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule("${moduleName}", jsInvoker),
+    : TurboModule(std::string{${hasteModuleName}CxxSpec::kModuleName}, jsInvoker),
       delegate_(static_cast<T*>(this), jsInvoker) {}
 
 private:
@@ -217,6 +223,18 @@ function createStructsString(
   resolveAlias: AliasResolver,
   enumMap: NativeModuleEnumMap,
 ): string {
+  const getCppType = (
+    v: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>,
+  ) =>
+    translatePrimitiveJSTypeToCpp(
+      moduleName,
+      v.typeAnnotation,
+      false,
+      typeName => `Unsupported type for param "${v.name}". Found: ${typeName}`,
+      resolveAlias,
+      enumMap,
+    );
+
   return Object.keys(aliasMap)
     .map(alias => {
       const value = aliasMap[alias];
@@ -225,28 +243,22 @@ function createStructsString(
       }
       const structName = `${moduleName}Base${alias}`;
       const templateParameterWithTypename = value.properties
-        .map((v, i) => 'typename P' + i)
+        .map((v, i) => `typename P${i}`)
         .join(', ');
       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) {
+      const debugParameterConversion = value.properties
+        .map(
+          (v, i) => `  static ${getCppType(v)} ${
+            v.name
+          }ToJs(jsi::Runtime &rt, P${i} value) {
     return bridging::toJs(rt, value);
-  }`;
-        })
-        .join('\n');
-      return `#pragma mark - ${structName}
+  }`,
+        )
+        .join('\n\n');
+      return `
+#pragma mark - ${structName}
 
 template <${templateParameterWithTypename}>
 struct ${structName} {
@@ -275,28 +287,28 @@ ${value.properties
   }
 
 #ifdef DEBUG
-${paramemterConversion}
+${debugParameterConversion}
 #endif
 
   static jsi::Object toJs(
-    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;
-        }
-      };
+      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;
+  }
+};
 
 `;
     })
@@ -338,12 +350,12 @@ enum ${enumName} { ${values} };
 
 template <>
 struct Bridging<${enumName}> {
-  static ${enumName} fromJs(jsi::Runtime &rt, ${fromValue}, const std::shared_ptr<CallInvoker> &jsInvoker) {
+  static ${enumName} fromJs(jsi::Runtime &rt, ${fromValue}) {
     ${fromValueConversion}
     ${fromCases}
   }
 
-  static ${toValue} toJs(jsi::Runtime &rt, ${enumName} value, const std::shared_ptr<CallInvoker> &jsInvoker) {
+  static ${toValue} toJs(jsi::Runtime &rt, ${enumName} value) {
     ${toCases}
   }
 };`;

package/lib/generators/modules/GenerateModuleJavaSpec.js

@@ -393,17 +393,19 @@ function getFalsyReturnStatementFromReturnType(
 }
 
 // Build special-cased runtime check for getConstants().
-function buildGetConstantsMethod(method, imports) {
+function buildGetConstantsMethod(method, imports, resolveAlias) {
   const _unwrapNullable7 = unwrapNullable(method.typeAnnotation),
     _unwrapNullable8 = _slicedToArray(_unwrapNullable7, 1),
     methodTypeAnnotation = _unwrapNullable8[0];
-  if (
-    methodTypeAnnotation.returnTypeAnnotation.type === 'ObjectTypeAnnotation'
-  ) {
+  let returnTypeAnnotation = methodTypeAnnotation.returnTypeAnnotation;
+  if (returnTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
+    // The return type is an alias, resolve it to get the expected undelying object literal type
+    returnTypeAnnotation = resolveAlias(returnTypeAnnotation.name);
+  }
+  if (returnTypeAnnotation.type === 'ObjectTypeAnnotation') {
     const requiredProps = [];
     const optionalProps = [];
-    const rawProperties =
-      methodTypeAnnotation.returnTypeAnnotation.properties || [];
+    const rawProperties = returnTypeAnnotation.properties || [];
     rawProperties.forEach(p => {
       if (p.optional || p.typeAnnotation.type === 'NullableTypeAnnotation') {
         optionalProps.push(p.name);
@@ -494,7 +496,7 @@ module.exports = {
       ]);
       const methods = properties.map(method => {
         if (method.name === 'getConstants') {
-          return buildGetConstantsMethod(method, imports);
+          return buildGetConstantsMethod(method, imports, resolveAlias);
         }
         const _unwrapNullable9 = unwrapNullable(method.typeAnnotation),
           _unwrapNullable10 = _slicedToArray(_unwrapNullable9, 1),

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

@@ -355,16 +355,20 @@ function getFalsyReturnStatementFromReturnType(
 function buildGetConstantsMethod(
   method: NativeModulePropertyShape,
   imports: Set<string>,
+  resolveAlias: AliasResolver,
 ): string {
   const [methodTypeAnnotation] =
     unwrapNullable<NativeModuleFunctionTypeAnnotation>(method.typeAnnotation);
-  if (
-    methodTypeAnnotation.returnTypeAnnotation.type === 'ObjectTypeAnnotation'
-  ) {
+  let returnTypeAnnotation = methodTypeAnnotation.returnTypeAnnotation;
+  if (returnTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
+    // The return type is an alias, resolve it to get the expected undelying object literal type
+    returnTypeAnnotation = resolveAlias(returnTypeAnnotation.name);
+  }
+
+  if (returnTypeAnnotation.type === 'ObjectTypeAnnotation') {
     const requiredProps = [];
     const optionalProps = [];
-    const rawProperties =
-      methodTypeAnnotation.returnTypeAnnotation.properties || [];
+    const rawProperties = returnTypeAnnotation.properties || [];
     rawProperties.forEach(p => {
       if (p.optional || p.typeAnnotation.type === 'NullableTypeAnnotation') {
         optionalProps.push(p.name);
@@ -470,7 +474,7 @@ module.exports = {
 
       const methods = properties.map(method => {
         if (method.name === 'getConstants') {
-          return buildGetConstantsMethod(method, imports);
+          return buildGetConstantsMethod(method, imports, resolveAlias);
         }
 
         const [methodTypeAnnotation] =

package/lib/generators/modules/GenerateModuleJniH.js

@@ -97,7 +97,7 @@ target_compile_options(
   -DLOG_TAG=\\"ReactNative\\"
   -fexceptions
   -frtti
-  -std=c++17
+  -std=c++20
   -Wall
 )
 `;

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

@@ -109,7 +109,7 @@ target_compile_options(
   -DLOG_TAG=\\"ReactNative\\"
   -fexceptions
   -frtti
-  -std=c++17
+  -std=c++20
   -Wall
 )
 `;

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

@@ -486,13 +486,21 @@ function serializeConstantsProtocolMethods(
       `${hasteModuleName}.getConstants() may only accept 0 arguments.`,
     );
   }
-  const returnTypeAnnotation = propertyTypeAnnotation.returnTypeAnnotation;
+  let returnTypeAnnotation = propertyTypeAnnotation.returnTypeAnnotation;
+  if (returnTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
+    // The return type is an alias, resolve it to get the expected undelying object literal type
+    returnTypeAnnotation = resolveAlias(returnTypeAnnotation.name);
+  }
   if (returnTypeAnnotation.type !== 'ObjectTypeAnnotation') {
     throw new Error(
-      `${hasteModuleName}.getConstants() may only return an object literal: {...}.`,
+      `${hasteModuleName}.getConstants() may only return an object literal: {...}` +
+        ` or a type alias of such. Got '${propertyTypeAnnotation.returnTypeAnnotation.type}'.`,
     );
   }
-  if (returnTypeAnnotation.properties.length === 0) {
+  if (
+    returnTypeAnnotation.type === 'ObjectTypeAnnotation' &&
+    returnTypeAnnotation.properties.length === 0
+  ) {
     return [];
   }
   const realTypeAnnotation = structCollector.process(

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

@@ -459,14 +459,24 @@ function serializeConstantsProtocolMethods(
     );
   }
 
-  const {returnTypeAnnotation} = propertyTypeAnnotation;
+  let {returnTypeAnnotation} = propertyTypeAnnotation;
+
+  if (returnTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
+    // The return type is an alias, resolve it to get the expected undelying object literal type
+    returnTypeAnnotation = resolveAlias(returnTypeAnnotation.name);
+  }
+
   if (returnTypeAnnotation.type !== 'ObjectTypeAnnotation') {
     throw new Error(
-      `${hasteModuleName}.getConstants() may only return an object literal: {...}.`,
+      `${hasteModuleName}.getConstants() may only return an object literal: {...}` +
+        ` or a type alias of such. Got '${propertyTypeAnnotation.returnTypeAnnotation.type}'.`,
     );
   }
 
-  if (returnTypeAnnotation.properties.length === 0) {
+  if (
+    returnTypeAnnotation.type === 'ObjectTypeAnnotation' &&
+    returnTypeAnnotation.properties.length === 0
+  ) {
     return [];
   }
 

package/lib/parsers/error-utils.js

@@ -280,6 +280,44 @@ function throwIfMoreThanOneCodegenNativecommands(commandsTypeNames) {
     throw new Error('codegenNativeCommands may only be called once in a file');
   }
 }
+function throwIfConfigNotfound(foundConfigs) {
+  if (foundConfigs.length === 0) {
+    throw new Error('Could not find component config for native component');
+  }
+}
+function throwIfMoreThanOneConfig(foundConfigs) {
+  if (foundConfigs.length > 1) {
+    throw new Error('Only one component is supported per file');
+  }
+}
+function throwIfEventHasNoName(typeAnnotation, parser) {
+  const name =
+    parser.language() === 'Flow' ? typeAnnotation.id : typeAnnotation.typeName;
+  if (!name) {
+    throw new Error("typeAnnotation of event doesn't have a name");
+  }
+}
+function throwIfBubblingTypeIsNull(bubblingType, eventName) {
+  if (!bubblingType) {
+    throw new Error(
+      `Unable to determine event bubbling type for "${eventName}"`,
+    );
+  }
+  return bubblingType;
+}
+function throwIfArgumentPropsAreNull(argumentProps, eventName) {
+  if (!argumentProps) {
+    throw new Error(`Unable to determine event arguments for "${eventName}"`);
+  }
+  return argumentProps;
+}
+function throwIfTypeAliasIsNotInterface(typeAlias, parser) {
+  if (typeAlias.type !== parser.interfaceDeclaration) {
+    throw new Error(
+      `The type argument for codegenNativeCommands must be an interface, received ${typeAlias.type}`,
+    );
+  }
+}
 module.exports = {
   throwIfModuleInterfaceIsMisnamed,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
@@ -298,4 +336,10 @@ module.exports = {
   throwIfPartialNotAnnotatingTypeParameter,
   throwIfPartialWithMoreParameter,
   throwIfMoreThanOneCodegenNativecommands,
+  throwIfConfigNotfound,
+  throwIfMoreThanOneConfig,
+  throwIfEventHasNoName,
+  throwIfBubblingTypeIsNull,
+  throwIfArgumentPropsAreNull,
+  throwIfTypeAliasIsNotInterface,
 };