@react-native/codegen 0.74.0 → 0.75.0-nightly-20240221-a1171f79f

package/lib/generators/components/JavaHelpers.js

@@ -93,6 +93,14 @@ function getImports(component, type) {
       }
     }
   });
+  component.commands.forEach(command => {
+    command.typeAnnotation.params.forEach(param => {
+      const cmdParamType = param.typeAnnotation.type;
+      if (cmdParamType === 'ArrayTypeAnnotation') {
+        imports.add('import com.facebook.react.bridge.ReadableArray;');
+      }
+    });
+  });
   return imports;
 }
 module.exports = {

package/lib/generators/components/JavaHelpers.js.flow

@@ -127,6 +127,15 @@ function getImports(
     }
   });
 
+  component.commands.forEach(command => {
+    command.typeAnnotation.params.forEach(param => {
+      const cmdParamType = param.typeAnnotation.type;
+      if (cmdParamType === 'ArrayTypeAnnotation') {
+        imports.add('import com.facebook.react.bridge.ReadableArray;');
+      }
+    });
+  });
+
   return imports;
 }
 

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

@@ -1697,6 +1697,28 @@ const COMMANDS_AND_PROPS = {
                 },
               },
             },
+            {
+              name: 'addItems',
+              optional: false,
+              typeAnnotation: {
+                type: 'FunctionTypeAnnotation',
+                params: [
+                  {
+                    name: 'items',
+                    optional: false,
+                    typeAnnotation: {
+                      type: 'ArrayTypeAnnotation',
+                      elementType: {
+                        type: 'StringTypeAnnotation',
+                      },
+                    },
+                  },
+                ],
+                returnTypeAnnotation: {
+                  type: 'VoidTypeAnnotation',
+                },
+              },
+            },
           ],
         },
       },

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

@@ -1726,6 +1726,28 @@ const COMMANDS_AND_PROPS: SchemaType = {
                 },
               },
             },
+            {
+              name: 'addItems',
+              optional: false,
+              typeAnnotation: {
+                type: 'FunctionTypeAnnotation',
+                params: [
+                  {
+                    name: 'items',
+                    optional: false,
+                    typeAnnotation: {
+                      type: 'ArrayTypeAnnotation',
+                      elementType: {
+                        type: 'StringTypeAnnotation',
+                      },
+                    },
+                  },
+                ],
+                returnTypeAnnotation: {
+                  type: 'VoidTypeAnnotation',
+                },
+              },
+            },
           ],
         },
       },

package/lib/generators/modules/GenerateModuleCpp.js

@@ -78,11 +78,11 @@ 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('../../parsers/parsers-commons'),
-  unwrapNullable = _require2.unwrapNullable;
+const _require = require('../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable;
+const _require2 = require('./Utils'),
+  createAliasResolver = _require2.createAliasResolver,
+  getModules = _require2.getModules;
 const HostFunctionTemplate = ({
   hasteModuleName,
   methodName,
@@ -138,14 +138,12 @@ const FileTemplate = ({libraryName, modules}) => {
 
 #include "${libraryName}JSI.h"
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 ${modules}
 
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react
 `;
 };
 function serializeArg(moduleName, arg, index, resolveAlias, enumMap) {
@@ -257,7 +255,13 @@ function serializePropertyIntoHostFunction(
   });
 }
 module.exports = {
-  generate(libraryName, schema, packageName, assumeNonnull = false) {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+  ) {
     const nativeModules = getModules(schema);
     const modules = Object.keys(nativeModules)
       .map(hasteModuleName => {

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

@@ -11,19 +11,19 @@
 'use strict';
 
 import type {
-  SchemaType,
-  Nullable,
   NamedShape,
-  NativeModulePropertyShape,
+  NativeModuleEnumMap,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
+  NativeModulePropertyShape,
   NativeModuleTypeAnnotation,
-  NativeModuleEnumMap,
+  Nullable,
+  SchemaType,
 } from '../../CodegenSchema';
-
 import type {AliasResolver} from './Utils';
-const {createAliasResolver, getModules} = require('./Utils');
+
 const {unwrapNullable} = require('../../parsers/parsers-commons');
+const {createAliasResolver, getModules} = require('./Utils');
 
 type FilesOutput = Map<string, string>;
 
@@ -101,14 +101,12 @@ const FileTemplate = ({
 
 #include "${libraryName}JSI.h"
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 ${modules}
 
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react
 `;
 };
 
@@ -236,6 +234,7 @@ module.exports = {
     schema: SchemaType,
     packageName?: string,
     assumeNonnull: boolean = false,
+    headerPrefix?: string,
   ): FilesOutput {
     const nativeModules = getModules(schema);
 

package/lib/generators/modules/GenerateModuleH.js

@@ -78,17 +78,21 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('../Utils'),
-  getEnumName = _require.getEnumName,
-  toSafeCppString = _require.toSafeCppString;
-const _require2 = require('./Utils'),
-  createAliasResolver = _require2.createAliasResolver,
-  getModules = _require2.getModules,
-  getAreEnumMembersInteger = _require2.getAreEnumMembersInteger;
+const _require = require('../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable;
+const _require2 = require('../TypeUtils/Cxx'),
+  wrapOptional = _require2.wrapOptional;
 const _require3 = require('../Utils'),
-  indent = _require3.indent;
-const _require4 = require('../../parsers/parsers-commons'),
-  unwrapNullable = _require4.unwrapNullable;
+  getEnumName = _require3.getEnumName,
+  toSafeCppString = _require3.toSafeCppString;
+const _require4 = require('../Utils'),
+  indent = _require4.indent;
+const _require5 = require('./Utils'),
+  createAliasResolver = _require5.createAliasResolver,
+  getAreEnumMembersInteger = _require5.getAreEnumMembersInteger,
+  getModules = _require5.getModules,
+  isArrayRecursiveMember = _require5.isArrayRecursiveMember,
+  isDirectRecursiveMember = _require5.isDirectRecursiveMember;
 const ModuleClassDeclarationTemplate = ({
   hasteModuleName,
   moduleProperties,
@@ -122,7 +126,7 @@ public:
 protected:
   ${hasteModuleName}CxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule(std::string{${hasteModuleName}CxxSpec::kModuleName}, jsInvoker),
-      delegate_(static_cast<T*>(this), jsInvoker) {}
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
 
 private:
   class Delegate : public ${hasteModuleName}CxxSpecJSI {
@@ -154,17 +158,16 @@ const FileTemplate = ({modules}) => {
 #include <ReactCommon/TurboModule.h>
 #include <react/bridging/Bridging.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 ${modules.join('\n\n')}
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react
 `;
 };
 function translatePrimitiveJSTypeToCpp(
   moduleName,
+  parentObjectAliasName,
   nullableTypeAnnotation,
   optional,
   createErrorMessage,
@@ -175,19 +178,20 @@ function translatePrimitiveJSTypeToCpp(
     _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
     typeAnnotation = _unwrapNullable2[0],
     nullable = _unwrapNullable2[1];
-  const isRequired = !optional && !nullable;
+  const isRecursiveType = isDirectRecursiveMember(
+    parentObjectAliasName,
+    nullableTypeAnnotation,
+  );
+  const isRequired = (!optional && !nullable) || isRecursiveType;
   let realTypeAnnotation = typeAnnotation;
   if (realTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
     realTypeAnnotation = resolveAlias(realTypeAnnotation.name);
   }
-  function wrap(type) {
-    return isRequired ? type : `std::optional<${type}>`;
-  }
   switch (realTypeAnnotation.type) {
     case 'ReservedTypeAnnotation':
       switch (realTypeAnnotation.name) {
         case 'RootTag':
-          return wrap('double');
+          return wrapOptional('double', isRequired);
         default:
           realTypeAnnotation.name;
           throw new Error(createErrorMessage(realTypeAnnotation.name));
@@ -195,95 +199,96 @@ function translatePrimitiveJSTypeToCpp(
     case 'VoidTypeAnnotation':
       return 'void';
     case 'StringTypeAnnotation':
-      return wrap('jsi::String');
+      return wrapOptional('jsi::String', isRequired);
     case 'NumberTypeAnnotation':
-      return wrap('double');
+      return wrapOptional('double', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrap('double');
+      return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrap('double');
+      return wrapOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrap('int');
+      return wrapOptional('int', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrap('bool');
+      return wrapOptional('bool', isRequired);
     case 'EnumDeclaration':
       switch (realTypeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return getAreEnumMembersInteger(
-            enumMap[realTypeAnnotation.name].members,
-          )
-            ? wrap('int')
-            : wrap('double');
+          return wrapOptional('jsi::Value', isRequired);
         case 'StringTypeAnnotation':
-          return wrap('jsi::String');
+          return wrapOptional('jsi::String', isRequired);
         default:
           throw new Error(createErrorMessage(realTypeAnnotation.type));
       }
     case 'GenericObjectTypeAnnotation':
-      return wrap('jsi::Object');
+      return wrapOptional('jsi::Object', isRequired);
     case 'UnionTypeAnnotation':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrap('double');
+          return wrapOptional('double', isRequired);
         case 'ObjectTypeAnnotation':
-          return wrap('jsi::Object');
+          return wrapOptional('jsi::Object', isRequired);
         case 'StringTypeAnnotation':
-          return wrap('jsi::String');
+          return wrapOptional('jsi::String', isRequired);
         default:
           throw new Error(createErrorMessage(realTypeAnnotation.type));
       }
     case 'ObjectTypeAnnotation':
-      return wrap('jsi::Object');
+      return wrapOptional('jsi::Object', isRequired);
     case 'ArrayTypeAnnotation':
-      return wrap('jsi::Array');
+      return wrapOptional('jsi::Array', isRequired);
     case 'FunctionTypeAnnotation':
-      return wrap('jsi::Function');
+      return wrapOptional('jsi::Function', isRequired);
     case 'PromiseTypeAnnotation':
-      return wrap('jsi::Value');
+      return wrapOptional('jsi::Value', isRequired);
     case 'MixedTypeAnnotation':
-      return wrap('jsi::Value');
+      return wrapOptional('jsi::Value', isRequired);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
   }
 }
 function createStructsString(moduleName, aliasMap, resolveAlias, enumMap) {
-  const getCppType = v =>
+  const getCppType = (parentObjectAlias, v) =>
     translatePrimitiveJSTypeToCpp(
       moduleName,
+      parentObjectAlias,
       v.typeAnnotation,
       false,
       typeName => `Unsupported type for param "${v.name}". Found: ${typeName}`,
       resolveAlias,
       enumMap,
     );
-  return Object.keys(aliasMap)
-    .map(alias => {
-      const value = aliasMap[alias];
-      if (value.properties.length === 0) {
-        return '';
-      }
-      const structName = `${moduleName}Base${alias}`;
-      const templateParameterWithTypename = value.properties
-        .map((v, i) => `typename P${i}`)
-        .join(', ');
-      const templateParameter = value.properties
-        .map((v, i) => 'P' + i)
-        .join(', ');
-      const debugParameterConversion = value.properties
-        .map(
-          (v, i) => `  static ${getCppType(v)} ${
-            v.name
-          }ToJs(jsi::Runtime &rt, P${i} value) {
+
+  // TODO: T171006733 [Begin] Remove deprecated Cxx TMs structs after a new release.
+  return (
+    Object.keys(aliasMap)
+      .map(alias => {
+        const value = aliasMap[alias];
+        if (value.properties.length === 0) {
+          return '';
+        }
+        const structName = `${moduleName}Base${alias}`;
+        const structNameNew = `${moduleName}${alias}`;
+        const templateParameterWithTypename = value.properties
+          .map((v, i) => `typename P${i}`)
+          .join(', ');
+        const templateParameter = value.properties
+          .map((v, i) => 'P' + i)
+          .join(', ');
+        const debugParameterConversion = value.properties
+          .map(
+            (v, i) => `  static ${getCppType(alias, v)} ${
+              v.name
+            }ToJs(jsi::Runtime &rt, P${i} value) {
     return bridging::toJs(rt, value);
   }`,
-        )
-        .join('\n\n');
-      return `
+          )
+          .join('\n\n');
+        return `
 #pragma mark - ${structName}
 
 template <${templateParameterWithTypename}>
-struct ${structName} {
+struct [[deprecated("Use ${structNameNew} instead.")]] ${structName} {
 ${value.properties.map((v, i) => '  P' + i + ' ' + v.name).join(';\n')};
   bool operator==(const ${structName} &other) const {
     return ${value.properties
@@ -293,7 +298,7 @@ ${value.properties.map((v, i) => '  P' + i + ' ' + v.name).join(';\n')};
 };
 
 template <${templateParameterWithTypename}>
-struct ${structName}Bridging {
+struct [[deprecated("Use ${structNameNew}Bridging instead.")]] ${structName}Bridging {
   static ${structName}<${templateParameter}> fromJs(
       jsi::Runtime &rt,
       const jsi::Object &value,
@@ -333,8 +338,121 @@ ${value.properties
 };
 
 `;
-    })
-    .join('\n');
+      })
+      .join('\n') +
+    // TODO: T171006733 [End] Remove deprecated Cxx TMs structs after a new release.
+    Object.keys(aliasMap)
+      .map(alias => {
+        const value = aliasMap[alias];
+        if (value.properties.length === 0) {
+          return '';
+        }
+        const structName = `${moduleName}${alias}`;
+        const templateParameter = value.properties.filter(
+          v =>
+            !isDirectRecursiveMember(alias, v.typeAnnotation) &&
+            !isArrayRecursiveMember(alias, v.typeAnnotation),
+        );
+        const templateParameterWithTypename = templateParameter
+          .map((v, i) => `typename P${i}`)
+          .join(', ');
+        const templateParameterWithoutTypename = templateParameter
+          .map((v, i) => `P${i}`)
+          .join(', ');
+        let i = -1;
+        const templateMemberTypes = value.properties.map(v => {
+          if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+            return `std::unique_ptr<${structName}<${templateParameterWithoutTypename}>> ${v.name}`;
+          } else if (isArrayRecursiveMember(alias, v.typeAnnotation)) {
+            const _unwrapNullable3 = unwrapNullable(v.typeAnnotation),
+              _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
+              nullable = _unwrapNullable4[0];
+            return (
+              (nullable
+                ? `std::optional<std::vector<${structName}<${templateParameterWithoutTypename}>>>`
+                : `std::vector<${structName}<${templateParameterWithoutTypename}>>`) +
+              ` ${v.name}`
+            );
+          } else {
+            i++;
+            return `P${i} ${v.name}`;
+          }
+        });
+        const debugParameterConversion = value.properties
+          .map(
+            v => `  static ${getCppType(alias, v)} ${
+              v.name
+            }ToJs(jsi::Runtime &rt, decltype(types.${v.name}) value) {
+    return bridging::toJs(rt, value);
+  }`,
+          )
+          .join('\n\n');
+        return `
+#pragma mark - ${structName}
+
+template <${templateParameterWithTypename}>
+struct ${structName} {
+${templateMemberTypes.map(v => '  ' + v).join(';\n')};
+  bool operator==(const ${structName} &other) const {
+    return ${value.properties
+      .map(v => `${v.name} == other.${v.name}`)
+      .join(' && ')};
+  }
+};
+
+template <typename T>
+struct ${structName}Bridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+${value.properties
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `      value.hasProperty(rt, "${v.name}") ? std::make_unique<T>(bridging::fromJs<T>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)) : nullptr`;
+    } else {
+      return `      bridging::fromJs<decltype(types.${v.name})>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)`;
+    }
+  })
+  .join(',\n')}};
+    return result;
+  }
+
+#ifdef DEBUG
+${debugParameterConversion}
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+${value.properties
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `    if (value.${v.name}) {
+        result.setProperty(rt, "${v.name}", bridging::toJs(rt, *value.${v.name}, jsInvoker));
+      }`;
+    } else 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')
+  );
 }
 const EnumTemplate = ({
   enumName,
@@ -362,7 +480,7 @@ const EnumTemplate = ({
   return `
 #pragma mark - ${enumName}
 
-enum ${enumName} { ${values} };
+enum class ${enumName} { ${values} };
 
 template <>
 struct Bridging<${enumName}> {
@@ -438,15 +556,16 @@ function translatePropertyToCpp(
   enumMap,
   abstract = false,
 ) {
-  const _unwrapNullable3 = unwrapNullable(prop.typeAnnotation),
-    _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
-    propTypeAnnotation = _unwrapNullable4[0];
+  const _unwrapNullable5 = unwrapNullable(prop.typeAnnotation),
+    _unwrapNullable6 = _slicedToArray(_unwrapNullable5, 1),
+    propTypeAnnotation = _unwrapNullable6[0];
   const params = propTypeAnnotation.params.map(
     param => `std::move(${param.name})`,
   );
   const paramTypes = propTypeAnnotation.params.map(param => {
     const translatedParam = translatePrimitiveJSTypeToCpp(
       moduleName,
+      null,
       param.typeAnnotation,
       param.optional,
       typeName =>
@@ -458,6 +577,7 @@ function translatePropertyToCpp(
   });
   const returnType = translatePrimitiveJSTypeToCpp(
     moduleName,
+    null,
     propTypeAnnotation.returnTypeAnnotation,
     false,
     typeName => `Unsupported return type for ${prop.name}. Found: ${typeName}`,
@@ -481,7 +601,13 @@ function translatePropertyToCpp(
 }`;
 }
 module.exports = {
-  generate(libraryName, schema, packageName, assumeNonnull = false) {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+  ) {
     const nativeModules = getModules(schema);
     const modules = Object.keys(nativeModules).flatMap(hasteModuleName => {
       const _nativeModules$hasteM = nativeModules[hasteModuleName],