@react-native/codegen 0.72.4 → 0.73.0

package/lib/parsers/flow/modules/index.js

@@ -88,15 +88,10 @@ const _require2 = require('../../parsers-commons'),
   parseObjectProperty = _require2.parseObjectProperty;
 const _require3 = require('../../parsers-primitives'),
   emitArrayType = _require3.emitArrayType,
-  emitBoolean = _require3.emitBoolean,
   emitFunction = _require3.emitFunction,
-  emitNumber = _require3.emitNumber,
   emitGenericObject = _require3.emitGenericObject,
   emitPromise = _require3.emitPromise,
   emitRootTag = _require3.emitRootTag,
-  emitVoid = _require3.emitVoid,
-  emitString = _require3.emitString,
-  emitMixed = _require3.emitMixed,
   emitUnion = _require3.emitUnion,
   emitCommonTypes = _require3.emitCommonTypes,
   typeAliasResolution = _require3.typeAliasResolution,
@@ -258,18 +253,6 @@ function translateTypeAnnotation(
         nullable,
       );
     }
-    case 'BooleanTypeAnnotation': {
-      return emitBoolean(nullable);
-    }
-    case 'NumberTypeAnnotation': {
-      return emitNumber(nullable);
-    }
-    case 'VoidTypeAnnotation': {
-      return emitVoid(nullable);
-    }
-    case 'StringTypeAnnotation': {
-      return emitString(nullable);
-    }
     case 'FunctionTypeAnnotation': {
       return emitFunction(
         nullable,
@@ -294,13 +277,6 @@ function translateTypeAnnotation(
         memberType: 'StringTypeAnnotation',
       });
     }
-    case 'MixedTypeAnnotation': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      } else {
-        return emitGenericObject(nullable);
-      }
-    }
     case 'EnumStringBody':
     case 'EnumNumberBody': {
       return typeEnumResolution(
@@ -313,11 +289,25 @@ function translateTypeAnnotation(
       );
     }
     default: {
-      throw new UnsupportedTypeAnnotationParserError(
+      const commonType = emitCommonTypes(
         hasteModuleName,
+        types,
         typeAnnotation,
-        parser.language(),
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
     }
   }
 }

package/lib/parsers/flow/modules/index.js.flow

@@ -31,15 +31,10 @@ const {
 } = require('../../parsers-commons');
 const {
   emitArrayType,
-  emitBoolean,
   emitFunction,
-  emitNumber,
   emitGenericObject,
   emitPromise,
   emitRootTag,
-  emitVoid,
-  emitString,
-  emitMixed,
   emitUnion,
   emitCommonTypes,
   typeAliasResolution,
@@ -207,18 +202,6 @@ function translateTypeAnnotation(
         nullable,
       );
     }
-    case 'BooleanTypeAnnotation': {
-      return emitBoolean(nullable);
-    }
-    case 'NumberTypeAnnotation': {
-      return emitNumber(nullable);
-    }
-    case 'VoidTypeAnnotation': {
-      return emitVoid(nullable);
-    }
-    case 'StringTypeAnnotation': {
-      return emitString(nullable);
-    }
     case 'FunctionTypeAnnotation': {
       return emitFunction(
         nullable,
@@ -243,13 +226,6 @@ function translateTypeAnnotation(
         memberType: 'StringTypeAnnotation',
       });
     }
-    case 'MixedTypeAnnotation': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      } else {
-        return emitGenericObject(nullable);
-      }
-    }
     case 'EnumStringBody':
     case 'EnumNumberBody': {
       return typeEnumResolution(
@@ -262,11 +238,26 @@ function translateTypeAnnotation(
       );
     }
     default: {
-      throw new UnsupportedTypeAnnotationParserError(
+      const commonType = emitCommonTypes(
         hasteModuleName,
+        types,
         typeAnnotation,
-        parser.language(),
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
+
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
     }
   }
 }

package/lib/parsers/flow/parser.js

@@ -85,7 +85,13 @@ class FlowParser {
     return 'Flow';
   }
   nameForGenericTypeAnnotation(typeAnnotation) {
-    return typeAnnotation.id.name;
+    var _typeAnnotation$id;
+    return typeAnnotation === null || typeAnnotation === void 0
+      ? void 0
+      : (_typeAnnotation$id = typeAnnotation.id) === null ||
+        _typeAnnotation$id === void 0
+      ? void 0
+      : _typeAnnotation$id.name;
   }
   checkIfInvalidModule(typeArguments) {
     return (
@@ -208,6 +214,9 @@ class FlowParser {
       node.extends[0].id.name === 'TurboModule'
     );
   }
+  isGenericTypeAnnotation(type) {
+    return type === 'GenericTypeAnnotation';
+  }
   extractAnnotatedElement(typeAnnotation, types) {
     return types[typeAnnotation.typeParameters.params[0].id.name];
   }
@@ -300,6 +309,12 @@ class FlowParser {
   getAnnotatedElementProperties(annotatedElement) {
     return annotatedElement.right.properties;
   }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.properties;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    return keyword;
+  }
 }
 module.exports = {
   FlowParser,

package/lib/parsers/flow/parser.js.flow

@@ -67,7 +67,7 @@ class FlowParser implements Parser {
   }
 
   nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
-    return typeAnnotation.id.name;
+    return typeAnnotation?.id?.name;
   }
 
   checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
@@ -214,6 +214,10 @@ class FlowParser implements Parser {
     );
   }
 
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return type === 'GenericTypeAnnotation';
+  }
+
   extractAnnotatedElement(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -317,6 +321,14 @@ class FlowParser implements Parser {
   getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
     return annotatedElement.right.properties;
   }
+
+  bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe> {
+    return typeAlias.body.properties;
+  }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    return keyword;
+  }
 }
 
 module.exports = {

package/lib/parsers/parser.js.flow

@@ -161,6 +161,11 @@ export interface Parser {
    */
   isModuleInterface(node: $FlowFixMe): boolean;
 
+  /**
+   * Given a type name, it returns true if it is a generic type annotation
+   */
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean;
+
   /**
    * Given a typeAnnotation, it returns the annotated element.
    * @parameter typeAnnotation: the annotation for a type.
@@ -236,4 +241,18 @@ export interface Parser {
    * @returns: the properties of annotated element.
    */
   getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a typeAlias, it returns an array of properties.
+   * @parameter typeAlias: the type alias.
+   * @returns: an array of properties.
+   */
+  bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe>;
+
+  /**
+   * Given a keyword convert it to TypeAnnotation.
+   * @parameter keyword
+   * @returns: converted TypeAnnotation to Keywords
+   */
+  convertKeywordToTypeAnnotation(keyword: string): string;
 }

package/lib/parsers/parserMock.js

@@ -158,6 +158,9 @@ export class MockedParser {
       node.extends[0].id.name === 'TurboModule'
     );
   }
+  isGenericTypeAnnotation(type) {
+    return true;
+  }
   extractAnnotatedElement(typeAnnotation, types) {
     return types[typeAnnotation.typeParameters.params[0].id.name];
   }
@@ -208,4 +211,10 @@ export class MockedParser {
   getAnnotatedElementProperties(annotatedElement) {
     return annotatedElement.right.properties;
   }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.properties;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    return keyword;
+  }
 }

package/lib/parsers/parserMock.js.flow

@@ -172,6 +172,10 @@ export class MockedParser implements Parser {
     );
   }
 
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return true;
+  }
+
   extractAnnotatedElement(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -231,4 +235,12 @@ export class MockedParser implements Parser {
   getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
     return annotatedElement.right.properties;
   }
+
+  bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe> {
+    return typeAlias.body.properties;
+  }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    return keyword;
+  }
 }

package/lib/parsers/parsers-commons.js

@@ -787,6 +787,40 @@ function getOptions(optionsExpression) {
   }
   return foundOptions;
 }
+function getCommandTypeNameAndOptionsExpression(namedExport, parser) {
+  let callExpression;
+  let calleeName;
+  try {
+    callExpression = namedExport.declaration.declarations[0].init;
+    calleeName = callExpression.callee.name;
+  } catch (e) {
+    return;
+  }
+  if (calleeName !== 'codegenNativeCommands') {
+    return;
+  }
+  if (callExpression.arguments.length !== 1) {
+    throw new Error(
+      'codegenNativeCommands must be passed options including the supported commands',
+    );
+  }
+  const typeArgumentParam =
+    parser.getTypeArgumentParamsFromDeclaration(callExpression)[0];
+  if (!parser.isGenericTypeAnnotation(typeArgumentParam.type)) {
+    throw new Error(
+      "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
+    );
+  }
+  return {
+    commandTypeName: parser.nameForGenericTypeAnnotation(typeArgumentParam),
+    commandOptionsExpression: callExpression.arguments[0],
+  };
+}
+function propertyNames(properties) {
+  return properties
+    .map(property => property && property.key && property.key.name)
+    .filter(Boolean);
+}
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -802,6 +836,8 @@ module.exports = {
   parseModuleName,
   buildModuleSchema,
   findNativeComponentType,
+  propertyNames,
   getCommandOptions,
   getOptions,
+  getCommandTypeNameAndOptionsExpression,
 };

package/lib/parsers/parsers-commons.js.flow

@@ -765,10 +765,58 @@ function getOptions(optionsExpression: OptionsAST): ?OptionsShape {
       'Failed to parse codegen options, cannot use both paperComponentName and paperComponentNameDeprecated',
     );
   }
-
   return foundOptions;
 }
 
+function getCommandTypeNameAndOptionsExpression(
+  namedExport: $FlowFixMe,
+  parser: Parser,
+): {
+  commandOptionsExpression: OptionsAST,
+  commandTypeName: string,
+} | void {
+  let callExpression;
+  let calleeName;
+  try {
+    callExpression = namedExport.declaration.declarations[0].init;
+    calleeName = callExpression.callee.name;
+  } catch (e) {
+    return;
+  }
+
+  if (calleeName !== 'codegenNativeCommands') {
+    return;
+  }
+
+  if (callExpression.arguments.length !== 1) {
+    throw new Error(
+      'codegenNativeCommands must be passed options including the supported commands',
+    );
+  }
+
+  const typeArgumentParam =
+    parser.getTypeArgumentParamsFromDeclaration(callExpression)[0];
+
+  if (!parser.isGenericTypeAnnotation(typeArgumentParam.type)) {
+    throw new Error(
+      "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
+    );
+  }
+
+  return {
+    commandTypeName: parser.nameForGenericTypeAnnotation(typeArgumentParam),
+    commandOptionsExpression: callExpression.arguments[0],
+  };
+}
+
+function propertyNames(
+  properties: $ReadOnlyArray<$FlowFixMe>,
+): $ReadOnlyArray<$FlowFixMe> {
+  return properties
+    .map(property => property && property.key && property.key.name)
+    .filter(Boolean);
+}
+
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -784,6 +832,8 @@ module.exports = {
   parseModuleName,
   buildModuleSchema,
   findNativeComponentType,
+  propertyNames,
   getCommandOptions,
   getOptions,
+  getCommandTypeNameAndOptionsExpression,
 };

package/lib/parsers/parsers-primitives.js

@@ -462,6 +462,7 @@ function Visitor(infoMap) {
   };
 }
 function emitPartial(
+  nullable,
   hasteModuleName,
   typeAnnotation,
   types,
@@ -469,7 +470,6 @@ function emitPartial(
   enumMap,
   tryParse,
   cxxOnly,
-  nullable,
   parser,
 ) {
   throwIfPartialWithMoreParameter(typeAnnotation);
@@ -502,43 +502,45 @@ function emitCommonTypes(
   nullable,
   parser,
 ) {
+  const typeMap = {
+    Stringish: emitStringish,
+    Int32: emitInt32,
+    Double: emitDouble,
+    Float: emitFloat,
+    UnsafeObject: emitGenericObject,
+    Object: emitGenericObject,
+    $Partial: emitPartial,
+    Partial: emitPartial,
+    BooleanTypeAnnotation: emitBoolean,
+    NumberTypeAnnotation: emitNumber,
+    VoidTypeAnnotation: emitVoid,
+    StringTypeAnnotation: emitString,
+    MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+  };
+  const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
+    typeAnnotation.type,
+  );
+  const simpleEmitter = typeMap[typeAnnotationName];
+  if (simpleEmitter) {
+    return simpleEmitter(nullable);
+  }
   const genericTypeAnnotationName =
     parser.nameForGenericTypeAnnotation(typeAnnotation);
-  switch (genericTypeAnnotationName) {
-    case 'Stringish': {
-      return emitStringish(nullable);
-    }
-    case 'Int32': {
-      return emitInt32(nullable);
-    }
-    case 'Double': {
-      return emitDouble(nullable);
-    }
-    case 'Float': {
-      return emitFloat(nullable);
-    }
-    case 'UnsafeObject':
-    case 'Object': {
-      return emitGenericObject(nullable);
-    }
-    case '$Partial':
-    case 'Partial': {
-      return emitPartial(
-        hasteModuleName,
-        typeAnnotation,
-        types,
-        aliasMap,
-        enumMap,
-        tryParse,
-        cxxOnly,
-        nullable,
-        parser,
-      );
-    }
-    default: {
-      return null;
-    }
+  const emitter = typeMap[genericTypeAnnotationName];
+  if (!emitter) {
+    return null;
   }
+  return emitter(
+    nullable,
+    hasteModuleName,
+    typeAnnotation,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+    parser,
+  );
 }
 module.exports = {
   emitArrayType,

package/lib/parsers/parsers-primitives.js.flow

@@ -476,6 +476,7 @@ function Visitor(infoMap: {isComponent: boolean, isModule: boolean}): {
 }
 
 function emitPartial(
+  nullable: boolean,
   hasteModuleName: string,
   typeAnnotation: $FlowFixMe,
   types: TypeDeclarationMap,
@@ -483,7 +484,6 @@ function emitPartial(
   enumMap: {...NativeModuleEnumMap},
   tryParse: ParserErrorCapturer,
   cxxOnly: boolean,
-  nullable: boolean,
   parser: Parser,
 ): Nullable<NativeModuleTypeAnnotation> {
   throwIfPartialWithMoreParameter(typeAnnotation);
@@ -521,44 +521,50 @@ function emitCommonTypes(
   nullable: boolean,
   parser: Parser,
 ): $FlowFixMe {
+  const typeMap = {
+    Stringish: emitStringish,
+    Int32: emitInt32,
+    Double: emitDouble,
+    Float: emitFloat,
+    UnsafeObject: emitGenericObject,
+    Object: emitGenericObject,
+    $Partial: emitPartial,
+    Partial: emitPartial,
+    BooleanTypeAnnotation: emitBoolean,
+    NumberTypeAnnotation: emitNumber,
+    VoidTypeAnnotation: emitVoid,
+    StringTypeAnnotation: emitString,
+    MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+  };
+
+  const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
+    typeAnnotation.type,
+  );
+
+  const simpleEmitter = typeMap[typeAnnotationName];
+  if (simpleEmitter) {
+    return simpleEmitter(nullable);
+  }
+
   const genericTypeAnnotationName =
     parser.nameForGenericTypeAnnotation(typeAnnotation);
 
-  switch (genericTypeAnnotationName) {
-    case 'Stringish': {
-      return emitStringish(nullable);
-    }
-    case 'Int32': {
-      return emitInt32(nullable);
-    }
-    case 'Double': {
-      return emitDouble(nullable);
-    }
-    case 'Float': {
-      return emitFloat(nullable);
-    }
-    case 'UnsafeObject':
-    case 'Object': {
-      return emitGenericObject(nullable);
-    }
-    case '$Partial':
-    case 'Partial': {
-      return emitPartial(
-        hasteModuleName,
-        typeAnnotation,
-        types,
-        aliasMap,
-        enumMap,
-        tryParse,
-        cxxOnly,
-        nullable,
-        parser,
-      );
-    }
-    default: {
-      return null;
-    }
+  const emitter = typeMap[genericTypeAnnotationName];
+  if (!emitter) {
+    return null;
   }
+
+  return emitter(
+    nullable,
+    hasteModuleName,
+    typeAnnotation,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+    parser,
+  );
 }
 
 module.exports = {