@react-native-windows/codegen 0.71.3 → 0.72.0-preview.2

package/src/generators/ObjectTypes.ts

@@ -7,19 +7,40 @@
 'use strict';
 
 import type {
+  NativeModuleEnumDeclaration,
   NativeModuleBaseTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
   Nullable,
-} from 'react-native-tscodegen';
+} from '@react-native/codegen/lib/CodegenSchema';
 import {
   AliasMap,
   getAliasCppName,
   getAnonymousAliasCppName,
 } from './AliasManaging';
 
-export function translateField(
+function translateUnionReturnType(
+  type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+): string {
+  const memberType = type.memberType;
+  switch (type.memberType) {
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+      return 'double';
+    case 'ObjectTypeAnnotation':
+      return '::React::JSValue';
+    default:
+      throw new Error(
+        `Unknown enum/union member type in translateReturnType: ${memberType}`,
+      );
+  }
+}
+
+export function translateFieldOrReturnType(
   type: Nullable<NativeModuleBaseTypeAnnotation>,
   aliases: AliasMap,
   baseAliasName: string,
+  callerName: 'translateField' | 'translateReturnType',
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;
@@ -36,10 +57,11 @@ export function translateField(
       return 'bool';
     case 'ArrayTypeAnnotation':
       if (type.elementType) {
-        return `std::vector<${translateField(
+        return `std::vector<${translateFieldOrReturnType(
           type.elementType,
           aliases,
           `${baseAliasName}_element`,
+          callerName,
         )}>`;
       } else {
         return `::React::JSValueArray`;
@@ -54,20 +76,35 @@ export function translateField(
       // (#6597)
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${name} in translateReturnType`,
-        );
+        throw new Error(`Unknown reserved function: ${name} in ${callerName}`);
       return 'double';
     }
     case 'TypeAliasTypeAnnotation':
       return getAliasCppName(type.name);
     case 'NullableTypeAnnotation':
-      return `std::optional<${translateField(
+      return `std::optional<${translateFieldOrReturnType(
         type.typeAnnotation,
         aliases,
         baseAliasName,
+        callerName,
       )}>`;
+    case 'EnumDeclaration':
+    case 'UnionTypeAnnotation':
+      return translateUnionReturnType(type);
     default:
-      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+      throw new Error(`Unhandled type in ${callerName}: ${returnType}`);
   }
 }
+
+export function translateField(
+  type: Nullable<NativeModuleBaseTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateFieldOrReturnType(
+    type,
+    aliases,
+    baseAliasName,
+    'translateField',
+  );
+}

package/src/generators/ParamTypes.ts

@@ -8,9 +8,14 @@
 
 import type {
   NamedShape,
+  NativeModuleArrayTypeAnnotation,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleEnumDeclaration,
+  NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
   Nullable,
-} from 'react-native-tscodegen';
+} from '@react-native/codegen/lib/CodegenSchema';
 import {
   AliasMap,
   getAliasCppName,
@@ -34,6 +39,87 @@ function decorateType(type: string, target: ParamTarget): string {
   }
 }
 
+function translateUnionReturnType(
+  type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+  target: ParamTarget,
+): string {
+  const memberType = type.memberType;
+  switch (type.memberType) {
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+      return 'double';
+    case 'ObjectTypeAnnotation':
+      return decorateType('::React::JSValue', target);
+    default:
+      throw new Error(
+        `Unknown enum/union member type in translateReturnType: ${memberType}`,
+      );
+  }
+}
+
+function translateFunction(
+  param: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+): string {
+  // TODO: type.returnTypeAnnotation
+  switch (target) {
+    case 'spec':
+      return `Callback<${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateSpecFunctionParam(p, aliases, `${baseAliasName}_${p.name}`),
+        )
+        .join(', ')}>`;
+    case 'template':
+      return `std::function<void(${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+        )
+        .join(', ')})>`;
+    default:
+      return `std::function<void(${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+        )
+        .join(', ')})> const &`;
+  }
+}
+
+function translateArray(
+  param: NativeModuleArrayTypeAnnotation<
+    Nullable<NativeModuleBaseTypeAnnotation>
+  >,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+): string {
+  if (param.elementType) {
+    switch (target) {
+      case 'spec':
+      case 'template':
+        return `std::vector<${translateNullableParamType(
+          param.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          'template',
+          'template',
+        )}>`;
+      default:
+        return `std::vector<${translateNullableParamType(
+          param.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          'template',
+          'template',
+        )}> const &`;
+    }
+  } else {
+    return decorateType('::React::JSValueArray', target);
+  }
+}
+
 function translateParam(
   param: NativeModuleParamTypeAnnotation,
   aliases: AliasMap,
@@ -53,57 +139,10 @@ function translateParam(
       return 'int';
     case 'BooleanTypeAnnotation':
       return 'bool';
-    case 'FunctionTypeAnnotation': {
-      // TODO: type.returnTypeAnnotation
-      switch (target) {
-        case 'spec':
-          return `Callback<${param.params
-            .map((p: NativeModuleParamShape) =>
-              translateSpecFunctionParam(
-                p,
-                aliases,
-                `${baseAliasName}_${p.name}`,
-              ),
-            )
-            .join(', ')}>`;
-        case 'template':
-          return `std::function<void(${param.params
-            .map((p: NativeModuleParamShape) =>
-              translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
-            )
-            .join(', ')})>`;
-        default:
-          return `std::function<void(${param.params
-            .map((p: NativeModuleParamShape) =>
-              translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
-            )
-            .join(', ')})> const &`;
-      }
-    }
+    case 'FunctionTypeAnnotation':
+      return translateFunction(param, aliases, baseAliasName, target);
     case 'ArrayTypeAnnotation':
-      if (param.elementType) {
-        switch (target) {
-          case 'spec':
-          case 'template':
-            return `std::vector<${translateNullableParamType(
-              param.elementType,
-              aliases,
-              `${baseAliasName}_element`,
-              'template',
-              'template',
-            )}>`;
-          default:
-            return `std::vector<${translateNullableParamType(
-              param.elementType,
-              aliases,
-              `${baseAliasName}_element`,
-              'template',
-              'template',
-            )}> const &`;
-        }
-      } else {
-        return decorateType('::React::JSValueArray', target);
-      }
+      return translateArray(param, aliases, baseAliasName, target);
     case 'GenericObjectTypeAnnotation':
       return decorateType('::React::JSValue', target);
     case 'ObjectTypeAnnotation':
@@ -122,6 +161,9 @@ function translateParam(
     }
     case 'TypeAliasTypeAnnotation':
       return decorateType(getAliasCppName(param.name), target);
+    case 'EnumDeclaration':
+    case 'UnionTypeAnnotation':
+      return translateUnionReturnType(param, target);
     default:
       throw new Error(`Unhandled type in translateParam: ${paramType}`);
   }

package/src/generators/ReturnTypes.ts

@@ -9,61 +9,19 @@
 import type {
   NativeModuleReturnTypeAnnotation,
   Nullable,
-} from 'react-native-tscodegen';
-import {
-  AliasMap,
-  getAliasCppName,
-  getAnonymousAliasCppName,
-} from './AliasManaging';
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap} from './AliasManaging';
+import {translateFieldOrReturnType} from './ObjectTypes';
 
 function translateReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
   aliases: AliasMap,
   baseAliasName: string,
 ): string {
-  // avoid: Property 'type' does not exist on type 'never'
-  const returnType = type.type;
   switch (type.type) {
     case 'VoidTypeAnnotation':
     case 'PromiseTypeAnnotation':
       return 'void';
-    case 'StringTypeAnnotation':
-      return 'std::string';
-    case 'NumberTypeAnnotation':
-    case 'FloatTypeAnnotation':
-    case 'DoubleTypeAnnotation':
-      return 'double';
-    case 'Int32TypeAnnotation':
-      return 'int';
-    case 'BooleanTypeAnnotation':
-      return 'bool';
-    case 'ArrayTypeAnnotation':
-      if (type.elementType) {
-        return `std::vector<${translateReturnType(
-          type.elementType,
-          aliases,
-          `${baseAliasName}_element`,
-        )}>`;
-      } else {
-        return '::React::JSValueArray';
-      }
-    case 'GenericObjectTypeAnnotation':
-      return '::React::JSValue';
-    case 'ObjectTypeAnnotation':
-      return getAnonymousAliasCppName(aliases, baseAliasName, type);
-    case 'ReservedTypeAnnotation': {
-      // avoid: Property 'name' does not exist on type 'never'
-      const name = type.name;
-      // (#6597)
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${name} in translateReturnType`,
-        );
-      return 'double';
-    }
-    case 'TypeAliasTypeAnnotation':
-      return getAliasCppName(type.name);
     case 'NullableTypeAnnotation':
       return `std::optional<${translateReturnType(
         type.typeAnnotation,
@@ -71,7 +29,12 @@ function translateReturnType(
         baseAliasName,
       )}>`;
     default:
-      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+      return translateFieldOrReturnType(
+        type,
+        aliases,
+        baseAliasName,
+        'translateReturnType',
+      );
   }
 }
 

package/src/generators/ValidateConstants.ts

@@ -6,7 +6,7 @@
 
 'use strict';
 
-import type {NativeModuleSchema} from 'react-native-tscodegen';
+import type {NativeModuleSchema} from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap, getAnonymousAliasCppName} from './AliasManaging';
 
 export function generateValidateConstants(

package/src/generators/ValidateMethods.ts

@@ -10,7 +10,7 @@ import type {
   NativeModuleFunctionTypeAnnotation,
   NativeModulePropertyShape,
   NativeModuleSchema,
-} from 'react-native-tscodegen';
+} from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap} from './AliasManaging';
 import {translateArgs, translateSpecArgs} from './ParamTypes';
 import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
@@ -22,10 +22,6 @@ function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
   );
 }
 
-function isMethodReturnPromise(funcType: NativeModuleFunctionTypeAnnotation) {
-  return funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation';
-}
-
 function getPossibleMethodSignatures(
   prop: NativeModulePropertyShape,
   funcType: NativeModuleFunctionTypeAnnotation,
@@ -33,9 +29,18 @@ function getPossibleMethodSignatures(
   baseAliasName: string,
 ): string[] {
   const args = translateArgs(funcType.params, aliases, baseAliasName);
-  if (isMethodReturnPromise(funcType)) {
-    // TODO: type of the promise could be provided in the future
-    args.push('::React::ReactPromise<::React::JSValue> &&result');
+  if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
+    if (funcType.returnTypeAnnotation.elementType) {
+      args.push(
+        `::React::ReactPromise<${translateImplReturnType(
+          funcType.returnTypeAnnotation.elementType,
+          aliases,
+          baseAliasName,
+        )}> &&result`,
+      );
+    } else {
+      args.push('::React::ReactPromise<::React::JSValue> &&result');
+    }
   }
 
   // TODO: be much more exhastive on the possible method signatures that can be used..
@@ -98,9 +103,18 @@ function renderProperties(
         propAliasName,
       );
 
-      if (isMethodReturnPromise(funcType)) {
-        // TODO: type of the promise could be provided in the future
-        traversedArgs.push('Promise<::React::JSValue>');
+      if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
+        if (funcType.returnTypeAnnotation.elementType) {
+          traversedArgs.push(
+            `Promise<${translateSpecReturnType(
+              funcType.returnTypeAnnotation.elementType,
+              aliases,
+              propAliasName,
+            )}>`,
+          );
+        } else {
+          traversedArgs.push('Promise<::React::JSValue>');
+        }
       }
 
       if (tuple) {

package/src/index.ts

@@ -13,22 +13,31 @@ import {
   generateTypeScript,
   setOptionalTurboModule,
 } from './generators/GenerateTypeScript';
-import type {SchemaType} from 'react-native-tscodegen';
+import type {SchemaType} from '@react-native/codegen/lib/CodegenSchema';
+import type {Parser} from '@react-native/codegen/lib/parsers/parser';
 
-// Load react-native-codegen from react-native
+// Load @react-native/codegen from react-native
 const rnPath = path.dirname(require.resolve('react-native/package.json'));
 const rncodegenPath = path.dirname(
-  require.resolve('react-native-codegen/package.json', {paths: [rnPath]}),
+  require.resolve('@react-native/codegen/package.json', {paths: [rnPath]}),
 );
-const FlowParser = require(path.resolve(rncodegenPath, 'lib/parsers/flow'));
-const TypeScriptParser = require(path.resolve(
-  rncodegenPath,
-  'lib/parsers/typescript',
-));
+
+function getParser(isTypeScript: boolean): Parser {
+  if (isTypeScript) {
+    const fp = require(path.resolve(
+      rncodegenPath,
+      'lib/parsers/typescript/parser',
+    ));
+    return new fp.TypeScriptParser();
+  } else {
+    const fp = require(path.resolve(rncodegenPath, 'lib/parsers/flow/parser'));
+    return new fp.FlowParser();
+  }
+}
 
 const schemaValidator = require(path.resolve(
   rncodegenPath,
-  'lib/SchemaValidator',
+  'lib/schemaValidator',
 ));
 
 interface Options {
@@ -65,15 +74,20 @@ function checkFilesForChanges(
 ): boolean {
   let hasChanges = false;
 
+  outputDir = path.resolve(outputDir);
+  const globbyDir = outputDir.replace(/\\/g, '/');
   const allExistingFiles = globby
-    .sync(`${outputDir}/**`)
-    .map(_ => path.normalize(_))
-    .sort();
+    .sync([`${globbyDir}/**`, `${globbyDir}/**/.*`], {absolute: true})
+    .map(_ => path.normalize(_));
   const allGeneratedFiles = [...map.keys()].map(_ => path.normalize(_)).sort();
 
   if (
     allExistingFiles.length !== allGeneratedFiles.length ||
-    !allExistingFiles.every((val, index) => val === allGeneratedFiles[index])
+    !allGeneratedFiles.every(filepath =>
+      allExistingFiles.includes(
+        path.normalize(path.resolve(process.cwd(), filepath)),
+      ),
+    )
   )
     return true;
 
@@ -97,10 +111,19 @@ function checkFilesForChanges(
 function writeMapToFiles(map: Map<string, string>, outputDir: string) {
   let success = true;
 
+  outputDir = path.resolve(outputDir);
+  const globbyDir = outputDir.replace(/\\/g, '/');
+
   // This ensures that we delete any generated files from modules that have been deleted
-  const allExistingFiles = globby.sync(`${outputDir}/**`);
+  const allExistingFiles = globby.sync(
+    [`${globbyDir}/**`, `${globbyDir}/**/.*`],
+    {absolute: true},
+  );
+
+  const allGeneratedFiles = [...map.keys()].map(_ => path.normalize(_)).sort();
   allExistingFiles.forEach(existingFile => {
-    if (!map.has(path.normalize(existingFile))) {
+    if (!allGeneratedFiles.includes(path.normalize(existingFile))) {
+      console.log('Deleting ', existingFile);
       fs.unlinkSync(existingFile);
     }
   });
@@ -117,6 +140,7 @@ function writeMapToFiles(map: Map<string, string>, outputDir: string) {
         }
       }
 
+      console.log('Writing ', fileName);
       fs.writeFileSync(fileName, contents);
     } catch (error) {
       success = false;
@@ -132,15 +156,12 @@ export function parseFile(filename: string): SchemaType {
     const isTypeScript =
       path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
     const contents = fs.readFileSync(filename, 'utf8');
-    const schema = isTypeScript
-      ? TypeScriptParser.parseString(contents, filename)
-      : FlowParser.parseString(contents, filename);
+    const schema = getParser(isTypeScript).parseString(contents, filename);
     // there will be at most one turbo module per file
     const moduleName = Object.keys(schema.modules)[0];
     if (moduleName) {
       const spec = schema.modules[moduleName];
       if (spec.type === 'NativeModule') {
-        const contents = fs.readFileSync(filename, 'utf8');
         if (contents) {
           // This is a temporary implementation until such information is added to the schema in facebook/react-native
           if (contents.includes('TurboModuleRegistry.get<')) {