@react-native/codegen 0.72.4 → 0.73.0-nightly-20230603-fd9e295be

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

@@ -28,21 +28,14 @@ import type {
 const {flattenIntersectionType} = require('../parseTopLevelType');
 const {flattenProperties} = require('../components/componentsUtils');
 
-const {resolveTypeAnnotation} = require('../utils');
-
 const {parseObjectProperty} = require('../../parsers-commons');
 
 const {
   emitArrayType,
-  emitBoolean,
   emitFunction,
-  emitNumber,
-  emitGenericObject,
+  emitDictionary,
   emitPromise,
   emitRootTag,
-  emitVoid,
-  emitString,
-  emitMixed,
   emitUnion,
   emitCommonTypes,
   typeAliasResolution,
@@ -195,7 +188,9 @@ function translateTypeAnnotation(
   parser: Parser,
 ): Nullable<NativeModuleTypeAnnotation> {
   const {nullable, typeAnnotation, typeResolutionStatus} =
-    resolveTypeAnnotation(typeScriptTypeAnnotation, types);
+    parser.getResolvedTypeAnnotation(typeScriptTypeAnnotation, types, parser);
+  const resolveTypeaAnnotationFn = parser.getResolveTypeAnnotationFN();
+  resolveTypeaAnnotationFn(typeScriptTypeAnnotation, types, parser);
 
   switch (typeAnnotation.type) {
     case 'TSArrayType': {
@@ -314,7 +309,7 @@ function translateTypeAnnotation(
           // check the property type to prevent developers from using unsupported types
           // the return value from `translateTypeAnnotation` is unused
           const propertyType = indexSignatures[0].typeAnnotation;
-          translateTypeAnnotation(
+          const valueType = translateTypeAnnotation(
             hasteModuleName,
             propertyType,
             types,
@@ -325,7 +320,7 @@ function translateTypeAnnotation(
             parser,
           );
           // no need to do further checking
-          return emitGenericObject(nullable);
+          return emitDictionary(nullable, valueType);
         }
       }
 
@@ -353,18 +348,6 @@ function translateTypeAnnotation(
         parser,
       );
     }
-    case 'TSBooleanKeyword': {
-      return emitBoolean(nullable);
-    }
-    case 'TSNumberKeyword': {
-      return emitNumber(nullable);
-    }
-    case 'TSVoidKeyword': {
-      return emitVoid(nullable);
-    }
-    case 'TSStringKeyword': {
-      return emitString(nullable);
-    }
     case 'TSFunctionType': {
       return emitFunction(
         nullable,
@@ -382,18 +365,27 @@ function translateTypeAnnotation(
     case 'TSUnionType': {
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
-    case 'TSUnknownKeyword': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      }
-      // Fallthrough
-    }
     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/typescript/parser.d.ts

@@ -5,6 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type {Parser} from '../parser';
+import type { Parser } from '../parser';
+import type { SchemaType } from '../../CodegenSchema';
+import type { ParserType } from '../errors';
 
-export declare class TypeScriptParser implements Parser{}
+export declare class TypeScriptParser implements Parser {
+    language(): ParserType;
+    parseFile(filename: string): SchemaType;
+    parseString(contents: string, filename?: string): SchemaType;
+    parseModuleFixture(filename: string): SchemaType;
+}

package/lib/parsers/typescript/parser.js

@@ -38,6 +38,7 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
+const invariant = require('invariant');
 const _require = require('./modules'),
   typeScriptTranslateTypeAnnotation =
     _require.typeScriptTranslateTypeAnnotation;
@@ -53,13 +54,19 @@ const _require4 = require('./components'),
 const _require5 = require('../schema.js'),
   wrapComponentSchema = _require5.wrapComponentSchema;
 const _require6 = require('../parsers-commons.js'),
-  buildModuleSchema = _require6.buildModuleSchema;
-const _require7 = require('./utils'),
-  resolveTypeAnnotation = _require7.resolveTypeAnnotation;
+  buildModuleSchema = _require6.buildModuleSchema,
+  extendsForProp = _require6.extendsForProp,
+  buildPropSchema = _require6.buildPropSchema;
+const _require7 = require('./parseTopLevelType'),
+  parseTopLevelType = _require7.parseTopLevelType;
+const _require8 = require('./components/componentsUtils'),
+  getSchemaInfo = _require8.getSchemaInfo,
+  getTypeAnnotation = _require8.getTypeAnnotation,
+  flattenProperties = _require8.flattenProperties;
 const fs = require('fs');
-const _require8 = require('../errors'),
+const _require9 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require8.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require9.UnsupportedObjectPropertyTypeAnnotationParserError;
 class TypeScriptParser {
   constructor() {
     _defineProperty(
@@ -67,6 +74,15 @@ class TypeScriptParser {
       'typeParameterInstantiation',
       'TSTypeParameterInstantiation',
     );
+    _defineProperty(this, 'typeAlias', 'TSTypeAliasDeclaration');
+    _defineProperty(this, 'enumDeclaration', 'TSEnumDeclaration');
+    _defineProperty(this, 'interfaceDeclaration', 'TSInterfaceDeclaration');
+    _defineProperty(this, 'nullLiteralTypeAnnotation', 'TSNullKeyword');
+    _defineProperty(
+      this,
+      'undefinedLiteralTypeAnnotation',
+      'TSUndefinedKeyword',
+    );
   }
   isProperty(property) {
     return property.type === 'TSPropertySignature';
@@ -86,7 +102,13 @@ class TypeScriptParser {
     return 'TypeScript';
   }
   nameForGenericTypeAnnotation(typeAnnotation) {
-    return typeAnnotation.typeName.name;
+    var _typeAnnotation$typeN;
+    return typeAnnotation === null || typeAnnotation === void 0
+      ? void 0
+      : (_typeAnnotation$typeN = typeAnnotation.typeName) === null ||
+        _typeAnnotation$typeN === void 0
+      ? void 0
+      : _typeAnnotation$typeN.name;
   }
   checkIfInvalidModule(typeArguments) {
     return (
@@ -119,7 +141,6 @@ class TypeScriptParser {
       buildModuleSchema,
       Visitor,
       this,
-      resolveTypeAnnotation,
       typeScriptTranslateTypeAnnotation,
     );
   }
@@ -224,6 +245,9 @@ class TypeScriptParser {
       node.extends[0].expression.name === 'TurboModule'
     );
   }
+  isGenericTypeAnnotation(type) {
+    return type === 'TSTypeReference';
+  }
   extractAnnotatedElement(typeAnnotation, types) {
     return types[typeAnnotation.typeParameters.params[0].typeName.name];
   }
@@ -306,6 +330,168 @@ class TypeScriptParser {
   getAnnotatedElementProperties(annotatedElement) {
     return annotatedElement.typeAnnotation.members;
   }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.body;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    switch (keyword) {
+      case 'TSBooleanKeyword':
+        return 'BooleanTypeAnnotation';
+      case 'TSNumberKeyword':
+        return 'NumberTypeAnnotation';
+      case 'TSVoidKeyword':
+        return 'VoidTypeAnnotation';
+      case 'TSStringKeyword':
+        return 'StringTypeAnnotation';
+      case 'TSUnknownKeyword':
+        return 'MixedTypeAnnotation';
+    }
+    return keyword;
+  }
+  argumentForProp(prop) {
+    return prop.expression;
+  }
+  nameForArgument(prop) {
+    return prop.expression.name;
+  }
+  isOptionalProperty(property) {
+    return property.optional || false;
+  }
+  getGetSchemaInfoFN() {
+    return getSchemaInfo;
+  }
+  getGetTypeAnnotationFN() {
+    return getTypeAnnotation;
+  }
+  getResolvedTypeAnnotation(
+    // TODO(T108222691): Use flow-types for @babel/parser
+    typeAnnotation,
+    types,
+    parser,
+  ) {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+    let node =
+      typeAnnotation.type === 'TSTypeAnnotation'
+        ? typeAnnotation.typeAnnotation
+        : typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus = {
+      successful: false,
+    };
+    for (;;) {
+      const topLevelType = parseTopLevelType(node);
+      nullable = nullable || topLevelType.optional;
+      node = topLevelType.type;
+      if (node.type !== 'TSTypeReference') {
+        break;
+      }
+      const resolvedTypeAnnotation = types[node.typeName.name];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+      switch (resolvedTypeAnnotation.type) {
+        case parser.typeAlias: {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'alias',
+            name: node.typeName.name,
+          };
+          node = resolvedTypeAnnotation.typeAnnotation;
+          break;
+        }
+        case parser.interfaceDeclaration: {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'alias',
+            name: node.typeName.name,
+          };
+          node = resolvedTypeAnnotation;
+          break;
+        }
+        case parser.enumDeclaration: {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'enum',
+            name: node.typeName.name,
+          };
+          node = resolvedTypeAnnotation;
+          break;
+        }
+        default: {
+          throw new TypeError(
+            `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}'), an interface ('${parser.interfaceDeclaration}'), or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+          );
+        }
+      }
+    }
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+  getResolveTypeAnnotationFN() {
+    return (typeAnnotation, types, parser) => {
+      return this.getResolvedTypeAnnotation(typeAnnotation, types, parser);
+    };
+  }
+  isEvent(typeAnnotation) {
+    if (typeAnnotation.type !== 'TSTypeReference') {
+      return false;
+    }
+    const eventNames = new Set(['BubblingEventHandler', 'DirectEventHandler']);
+    return eventNames.has(typeAnnotation.typeName.name);
+  }
+  isProp(name, typeAnnotation) {
+    if (typeAnnotation.type !== 'TSTypeReference') {
+      return true;
+    }
+    const isStyle =
+      name === 'style' &&
+      typeAnnotation.type === 'GenericTypeAnnotation' &&
+      typeAnnotation.typeName.name === 'ViewStyleProp';
+    return !isStyle;
+  }
+  getProps(typeDefinition, types) {
+    const extendsProps = [];
+    const componentPropAsts = [];
+    const remaining = [];
+    for (const prop of typeDefinition) {
+      // find extends
+      if (prop.type === 'TSExpressionWithTypeArguments') {
+        const extend = extendsForProp(prop, types, this);
+        if (extend) {
+          extendsProps.push(extend);
+          continue;
+        }
+      }
+      remaining.push(prop);
+    }
+
+    // find events and props
+    for (const prop of flattenProperties(remaining, types)) {
+      const topLevelType = parseTopLevelType(
+        prop.typeAnnotation.typeAnnotation,
+        types,
+      );
+      if (
+        prop.type === 'TSPropertySignature' &&
+        !this.isEvent(topLevelType.type) &&
+        this.isProp(prop.key.name, prop)
+      ) {
+        componentPropAsts.push(prop);
+      }
+    }
+    return {
+      props: componentPropAsts
+        .map(property => buildPropSchema(property, types, this))
+        .filter(Boolean),
+      extendsProps,
+    };
+  }
 }
 module.exports = {
   TypeScriptParser,

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

@@ -20,10 +20,23 @@ import type {
   NativeModuleEnumMemberType,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  PropTypeAnnotation,
+  ExtendsPropsShape,
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
-import type {Parser} from '../parser';
-import type {ParserErrorCapturer, TypeDeclarationMap} from '../utils';
+import type {
+  GetSchemaInfoFN,
+  GetTypeAnnotationFN,
+  Parser,
+  ResolveTypeAnnotationFN,
+} from '../parser';
+import type {
+  ParserErrorCapturer,
+  TypeDeclarationMap,
+  PropAST,
+  TypeResolutionStatus,
+} from '../utils';
+const invariant = require('invariant');
 
 const {typeScriptTranslateTypeAnnotation} = require('./modules');
 
@@ -34,9 +47,18 @@ const {buildSchema} = require('../parsers-commons');
 const {Visitor} = require('../parsers-primitives');
 const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-const {buildModuleSchema} = require('../parsers-commons.js');
-const {resolveTypeAnnotation} = require('./utils');
+const {
+  buildModuleSchema,
+  extendsForProp,
+  buildPropSchema,
+} = require('../parsers-commons.js');
 
+const {parseTopLevelType} = require('./parseTopLevelType');
+const {
+  getSchemaInfo,
+  getTypeAnnotation,
+  flattenProperties,
+} = require('./components/componentsUtils');
 const fs = require('fs');
 
 const {
@@ -45,6 +67,11 @@ const {
 
 class TypeScriptParser implements Parser {
   typeParameterInstantiation: string = 'TSTypeParameterInstantiation';
+  typeAlias: string = 'TSTypeAliasDeclaration';
+  enumDeclaration: string = 'TSEnumDeclaration';
+  interfaceDeclaration: string = 'TSInterfaceDeclaration';
+  nullLiteralTypeAnnotation: string = 'TSNullKeyword';
+  undefinedLiteralTypeAnnotation: string = 'TSUndefinedKeyword';
 
   isProperty(property: $FlowFixMe): boolean {
     return property.type === 'TSPropertySignature';
@@ -67,7 +94,7 @@ class TypeScriptParser implements Parser {
   }
 
   nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
-    return typeAnnotation.typeName.name;
+    return typeAnnotation?.typeName?.name;
   }
 
   checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
@@ -108,7 +135,6 @@ class TypeScriptParser implements Parser {
       buildModuleSchema,
       Visitor,
       this,
-      resolveTypeAnnotation,
       typeScriptTranslateTypeAnnotation,
     );
   }
@@ -210,6 +236,10 @@ class TypeScriptParser implements Parser {
     );
   }
 
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return type === 'TSTypeReference';
+  }
+
   extractAnnotatedElement(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -303,6 +333,205 @@ class TypeScriptParser implements Parser {
   getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
     return annotatedElement.typeAnnotation.members;
   }
+
+  bodyProperties(typeAlias: TypeDeclarationMap): $ReadOnlyArray<$FlowFixMe> {
+    return typeAlias.body.body;
+  }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    switch (keyword) {
+      case 'TSBooleanKeyword':
+        return 'BooleanTypeAnnotation';
+      case 'TSNumberKeyword':
+        return 'NumberTypeAnnotation';
+      case 'TSVoidKeyword':
+        return 'VoidTypeAnnotation';
+      case 'TSStringKeyword':
+        return 'StringTypeAnnotation';
+      case 'TSUnknownKeyword':
+        return 'MixedTypeAnnotation';
+    }
+
+    return keyword;
+  }
+
+  argumentForProp(prop: PropAST): $FlowFixMe {
+    return prop.expression;
+  }
+
+  nameForArgument(prop: PropAST): $FlowFixMe {
+    return prop.expression.name;
+  }
+
+  isOptionalProperty(property: $FlowFixMe): boolean {
+    return property.optional || false;
+  }
+
+  getGetSchemaInfoFN(): GetSchemaInfoFN {
+    return getSchemaInfo;
+  }
+
+  getGetTypeAnnotationFN(): GetTypeAnnotationFN {
+    return getTypeAnnotation;
+  }
+
+  getResolvedTypeAnnotation(
+    // TODO(T108222691): Use flow-types for @babel/parser
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): {
+    nullable: boolean,
+    typeAnnotation: $FlowFixMe,
+    typeResolutionStatus: TypeResolutionStatus,
+  } {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+
+    let node =
+      typeAnnotation.type === 'TSTypeAnnotation'
+        ? typeAnnotation.typeAnnotation
+        : typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus: TypeResolutionStatus = {
+      successful: false,
+    };
+
+    for (;;) {
+      const topLevelType = parseTopLevelType(node);
+      nullable = nullable || topLevelType.optional;
+      node = topLevelType.type;
+
+      if (node.type !== 'TSTypeReference') {
+        break;
+      }
+
+      const resolvedTypeAnnotation = types[node.typeName.name];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+
+      switch (resolvedTypeAnnotation.type) {
+        case parser.typeAlias: {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'alias',
+            name: node.typeName.name,
+          };
+          node = resolvedTypeAnnotation.typeAnnotation;
+          break;
+        }
+        case parser.interfaceDeclaration: {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'alias',
+            name: node.typeName.name,
+          };
+          node = resolvedTypeAnnotation;
+          break;
+        }
+        case parser.enumDeclaration: {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'enum',
+            name: node.typeName.name,
+          };
+          node = resolvedTypeAnnotation;
+          break;
+        }
+        default: {
+          throw new TypeError(
+            `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}'), an interface ('${parser.interfaceDeclaration}'), or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+          );
+        }
+      }
+    }
+
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+
+  getResolveTypeAnnotationFN(): ResolveTypeAnnotationFN {
+    return (
+      typeAnnotation: $FlowFixMe,
+      types: TypeDeclarationMap,
+      parser: Parser,
+    ) => {
+      return this.getResolvedTypeAnnotation(typeAnnotation, types, parser);
+    };
+  }
+
+  isEvent(typeAnnotation: $FlowFixMe): boolean {
+    if (typeAnnotation.type !== 'TSTypeReference') {
+      return false;
+    }
+    const eventNames = new Set(['BubblingEventHandler', 'DirectEventHandler']);
+    return eventNames.has(typeAnnotation.typeName.name);
+  }
+
+  isProp(name: string, typeAnnotation: $FlowFixMe): boolean {
+    if (typeAnnotation.type !== 'TSTypeReference') {
+      return true;
+    }
+    const isStyle =
+      name === 'style' &&
+      typeAnnotation.type === 'GenericTypeAnnotation' &&
+      typeAnnotation.typeName.name === 'ViewStyleProp';
+    return !isStyle;
+  }
+
+  getProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): {
+    props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+    extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+  } {
+    const extendsProps: Array<ExtendsPropsShape> = [];
+    const componentPropAsts: Array<PropAST> = [];
+    const remaining: Array<PropAST> = [];
+
+    for (const prop of typeDefinition) {
+      // find extends
+      if (prop.type === 'TSExpressionWithTypeArguments') {
+        const extend = extendsForProp(prop, types, this);
+        if (extend) {
+          extendsProps.push(extend);
+          continue;
+        }
+      }
+
+      remaining.push(prop);
+    }
+
+    // find events and props
+    for (const prop of flattenProperties(remaining, types)) {
+      const topLevelType = parseTopLevelType(
+        prop.typeAnnotation.typeAnnotation,
+        types,
+      );
+
+      if (
+        prop.type === 'TSPropertySignature' &&
+        !this.isEvent(topLevelType.type) &&
+        this.isProp(prop.key.name, prop)
+      ) {
+        componentPropAsts.push(prop);
+      }
+    }
+
+    return {
+      props: componentPropAsts
+        .map(property => buildPropSchema(property, types, this))
+        .filter(Boolean),
+      extendsProps,
+    };
+  }
 }
 
 module.exports = {

package/lib/parsers/utils.js.flow

@@ -34,6 +34,12 @@ function extractNativeModuleName(filename: string): string {
 
 export type ParserErrorCapturer = <T>(fn: () => T) => ?T;
 
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+export type PropAST = Object;
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+export type ASTNode = Object;
+
 function createParserErrorCapturer(): [
   Array<ParserError>,
   ParserErrorCapturer,