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

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

@@ -9,110 +9,18 @@
  */
 
 'use strict';
-import type {ExtendsPropsShape} from '../../../CodegenSchema.js';
 import type {Parser} from '../../parser';
 import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
 const {getCommands} = require('./commands');
 const {getEvents} = require('./events');
 const {categorizeProps} = require('./extends');
-const {getProps} = require('./props');
-const {getProperties} = require('./componentsUtils.js');
-const {throwIfMoreThanOneCodegenNativecommands} = require('../../error-utils');
 const {
-  createComponentConfig,
-  findNativeComponentType,
-  propertyNames,
-  getCommandOptions,
   getOptions,
-  getCommandTypeNameAndOptionsExpression,
+  findComponentConfig,
+  getCommandProperties,
 } = require('../../parsers-commons');
 
-// $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
-function findComponentConfig(ast: $FlowFixMe, parser: Parser) {
-  const foundConfigs: Array<{[string]: string}> = [];
-
-  const defaultExports = ast.body.filter(
-    node => node.type === 'ExportDefaultDeclaration',
-  );
-
-  defaultExports.forEach(statement =>
-    findNativeComponentType(statement, foundConfigs, parser),
-  );
-
-  if (foundConfigs.length === 0) {
-    throw new Error('Could not find component config for native component');
-  }
-  if (foundConfigs.length > 1) {
-    throw new Error('Only one component is supported per file');
-  }
-
-  const foundConfig = foundConfigs[0];
-
-  const namedExports = ast.body.filter(
-    node => node.type === 'ExportNamedDeclaration',
-  );
-
-  const commandsTypeNames = namedExports
-    .map(statement => getCommandTypeNameAndOptionsExpression(statement, parser))
-    .filter(Boolean);
-
-  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
-
-  return createComponentConfig(foundConfig, commandsTypeNames);
-}
-
-function getCommandProperties(ast: $FlowFixMe, parser: Parser) {
-  const {commandTypeName, commandOptionsExpression} = findComponentConfig(
-    ast,
-    parser,
-  );
-  if (commandTypeName == null) {
-    return [];
-  }
-
-  const types = parser.getTypes(ast);
-  const typeAlias = types[commandTypeName];
-
-  if (typeAlias.type !== 'TSInterfaceDeclaration') {
-    throw new Error(
-      `The type argument for codegenNativeCommands must be an interface, received ${typeAlias.type}`,
-    );
-  }
-
-  const properties = parser.bodyProperties(typeAlias);
-  if (!properties) {
-    throw new Error(
-      `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen typescript file`,
-    );
-  }
-
-  const typeScriptPropertyNames = propertyNames(properties);
-
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-  if (commandOptions == null || commandOptions.supportedCommands == null) {
-    throw new Error(
-      'codegenNativeCommands must be given an options object with supportedCommands array',
-    );
-  }
-
-  if (
-    commandOptions.supportedCommands.length !==
-      typeScriptPropertyNames.length ||
-    !commandOptions.supportedCommands.every(supportedCommand =>
-      typeScriptPropertyNames.includes(supportedCommand),
-    )
-  ) {
-    throw new Error(
-      `codegenNativeCommands expected the same supportedCommands specified in the ${commandTypeName} interface: ${typeScriptPropertyNames.join(
-        ', ',
-      )}`,
-    );
-  }
-
-  return properties;
-}
-
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
 type PropsAST = Object;
 
@@ -128,24 +36,16 @@ function buildComponentSchema(
 
   const types = parser.getTypes(ast);
 
-  const propProperties = getProperties(propsTypeName, types);
+  const propProperties = parser.getProperties(propsTypeName, types);
 
   const commandProperties = getCommandProperties(ast, parser);
 
   const options = getOptions(optionsExpression);
 
-  const extendsProps: Array<ExtendsPropsShape> = [];
-  const componentPropAsts: Array<PropsAST> = [];
   const componentEventAsts: Array<PropsAST> = [];
-  categorizeProps(
-    propProperties,
-    types,
-    extendsProps,
-    componentPropAsts,
-    componentEventAsts,
-  );
-  const props = getProps(componentPropAsts, types);
-  const events = getEvents(componentEventAsts, types);
+  categorizeProps(propProperties, types, componentEventAsts);
+  const {props, extendsProps} = parser.getProps(propProperties, types);
+  const events = getEvents(componentEventAsts, types, parser);
   const commands = getCommands(commandProperties, types);
 
   return {

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

@@ -14,25 +14,23 @@ const _require = require('../parseTopLevelType'),
   flattenIntersectionType = _require.flattenIntersectionType;
 const _require2 = require('../components/componentsUtils'),
   flattenProperties = _require2.flattenProperties;
-const _require3 = require('../utils'),
-  resolveTypeAnnotation = _require3.resolveTypeAnnotation;
-const _require4 = require('../../parsers-commons'),
-  parseObjectProperty = _require4.parseObjectProperty;
-const _require5 = require('../../parsers-primitives'),
-  emitArrayType = _require5.emitArrayType,
-  emitFunction = _require5.emitFunction,
-  emitGenericObject = _require5.emitGenericObject,
-  emitPromise = _require5.emitPromise,
-  emitRootTag = _require5.emitRootTag,
-  emitUnion = _require5.emitUnion,
-  emitCommonTypes = _require5.emitCommonTypes,
-  typeAliasResolution = _require5.typeAliasResolution,
-  typeEnumResolution = _require5.typeEnumResolution,
-  translateArrayTypeAnnotation = _require5.translateArrayTypeAnnotation;
-const _require6 = require('../../errors'),
-  UnsupportedGenericParserError = _require6.UnsupportedGenericParserError,
+const _require3 = require('../../parsers-commons'),
+  parseObjectProperty = _require3.parseObjectProperty;
+const _require4 = require('../../parsers-primitives'),
+  emitArrayType = _require4.emitArrayType,
+  emitFunction = _require4.emitFunction,
+  emitDictionary = _require4.emitDictionary,
+  emitPromise = _require4.emitPromise,
+  emitRootTag = _require4.emitRootTag,
+  emitUnion = _require4.emitUnion,
+  emitCommonTypes = _require4.emitCommonTypes,
+  typeAliasResolution = _require4.typeAliasResolution,
+  typeEnumResolution = _require4.typeEnumResolution,
+  translateArrayTypeAnnotation = _require4.translateArrayTypeAnnotation;
+const _require5 = require('../../errors'),
+  UnsupportedGenericParserError = _require5.UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError =
-    _require6.UnsupportedTypeAnnotationParserError;
+    _require5.UnsupportedTypeAnnotationParserError;
 function translateObjectTypeAnnotation(
   hasteModuleName,
   /**
@@ -168,13 +166,16 @@ function translateTypeAnnotation(
   cxxOnly,
   parser,
 ) {
-  const _resolveTypeAnnotatio = resolveTypeAnnotation(
+  const _parser$getResolvedTy = parser.getResolvedTypeAnnotation(
       typeScriptTypeAnnotation,
       types,
+      parser,
     ),
-    nullable = _resolveTypeAnnotatio.nullable,
-    typeAnnotation = _resolveTypeAnnotatio.typeAnnotation,
-    typeResolutionStatus = _resolveTypeAnnotatio.typeResolutionStatus;
+    nullable = _parser$getResolvedTy.nullable,
+    typeAnnotation = _parser$getResolvedTy.typeAnnotation,
+    typeResolutionStatus = _parser$getResolvedTy.typeResolutionStatus;
+  const resolveTypeaAnnotationFn = parser.getResolveTypeAnnotationFN();
+  resolveTypeaAnnotationFn(typeScriptTypeAnnotation, types, parser);
   switch (typeAnnotation.type) {
     case 'TSArrayType': {
       return translateArrayTypeAnnotation(
@@ -217,7 +218,7 @@ function translateTypeAnnotation(
     }
     case 'TSTypeReference': {
       return translateTypeReferenceAnnotation(
-        typeAnnotation.typeName.name,
+        parser.getTypeAnnotationName(typeAnnotation),
         nullable,
         typeAnnotation,
         hasteModuleName,
@@ -259,7 +260,7 @@ function translateTypeAnnotation(
       return translateObjectTypeAnnotation(
         hasteModuleName,
         nullable,
-        flattenProperties([typeAnnotation], types),
+        flattenProperties([typeAnnotation], types, parser),
         typeResolutionStatus,
         baseTypes,
         types,
@@ -277,6 +278,7 @@ function translateTypeAnnotation(
         flattenProperties(
           flattenIntersectionType(typeAnnotation, types),
           types,
+          parser,
         ),
         typeResolutionStatus,
         [],
@@ -298,7 +300,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,
@@ -309,7 +311,7 @@ function translateTypeAnnotation(
             parser,
           );
           // no need to do further checking
-          return emitGenericObject(nullable);
+          return emitDictionary(nullable, valueType);
         }
       }
       return translateObjectTypeAnnotation(

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

@@ -28,14 +28,12 @@ import type {
 const {flattenIntersectionType} = require('../parseTopLevelType');
 const {flattenProperties} = require('../components/componentsUtils');
 
-const {resolveTypeAnnotation} = require('../utils');
-
 const {parseObjectProperty} = require('../../parsers-commons');
 
 const {
   emitArrayType,
   emitFunction,
-  emitGenericObject,
+  emitDictionary,
   emitPromise,
   emitRootTag,
   emitUnion,
@@ -190,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': {
@@ -234,7 +234,7 @@ function translateTypeAnnotation(
     }
     case 'TSTypeReference': {
       return translateTypeReferenceAnnotation(
-        typeAnnotation.typeName.name,
+        parser.getTypeAnnotationName(typeAnnotation),
         nullable,
         typeAnnotation,
         hasteModuleName,
@@ -270,7 +270,7 @@ function translateTypeAnnotation(
       return translateObjectTypeAnnotation(
         hasteModuleName,
         nullable,
-        flattenProperties([typeAnnotation], types),
+        flattenProperties([typeAnnotation], types, parser),
         typeResolutionStatus,
         baseTypes,
         types,
@@ -288,6 +288,7 @@ function translateTypeAnnotation(
         flattenProperties(
           flattenIntersectionType(typeAnnotation, types),
           types,
+          parser,
         ),
         typeResolutionStatus,
         [],
@@ -309,7 +310,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,
@@ -320,7 +321,7 @@ function translateTypeAnnotation(
             parser,
           );
           // no need to do further checking
-          return emitGenericObject(nullable);
+          return emitDictionary(nullable, valueType);
         }
       }
 

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,24 +38,31 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
+const invariant = require('invariant');
 const _require = require('./modules'),
   typeScriptTranslateTypeAnnotation =
     _require.typeScriptTranslateTypeAnnotation;
 
 // $FlowFixMe[untyped-import] Use flow-types for @babel/parser
 const babelParser = require('@babel/parser');
-const _require2 = require('../parsers-commons'),
-  buildSchema = _require2.buildSchema;
-const _require3 = require('../parsers-primitives'),
-  Visitor = _require3.Visitor;
-const _require4 = require('./components'),
-  buildComponentSchema = _require4.buildComponentSchema;
-const _require5 = require('../schema.js'),
-  wrapComponentSchema = _require5.wrapComponentSchema;
-const _require6 = require('../parsers-commons.js'),
-  buildModuleSchema = _require6.buildModuleSchema;
-const _require7 = require('./utils'),
-  resolveTypeAnnotation = _require7.resolveTypeAnnotation;
+const _require2 = require('../parsers-primitives'),
+  Visitor = _require2.Visitor;
+const _require3 = require('./components'),
+  buildComponentSchema = _require3.buildComponentSchema;
+const _require4 = require('../schema.js'),
+  wrapComponentSchema = _require4.wrapComponentSchema;
+const _require5 = require('../parsers-commons.js'),
+  buildSchema = _require5.buildSchema,
+  buildModuleSchema = _require5.buildModuleSchema,
+  extendsForProp = _require5.extendsForProp,
+  buildPropSchema = _require5.buildPropSchema,
+  handleGenericTypeAnnotation = _require5.handleGenericTypeAnnotation;
+const _require6 = require('./parseTopLevelType'),
+  parseTopLevelType = _require6.parseTopLevelType;
+const _require7 = require('./components/componentsUtils'),
+  getSchemaInfo = _require7.getSchemaInfo,
+  getTypeAnnotation = _require7.getTypeAnnotation,
+  flattenProperties = _require7.flattenProperties;
 const fs = require('fs');
 const _require8 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
@@ -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';
@@ -85,7 +101,7 @@ class TypeScriptParser {
   language() {
     return 'TypeScript';
   }
-  nameForGenericTypeAnnotation(typeAnnotation) {
+  getTypeAnnotationName(typeAnnotation) {
     var _typeAnnotation$typeN;
     return typeAnnotation === null || typeAnnotation === void 0
       ? void 0
@@ -125,7 +141,6 @@ class TypeScriptParser {
       buildModuleSchema,
       Visitor,
       this,
-      resolveTypeAnnotation,
       typeScriptTranslateTypeAnnotation,
     );
   }
@@ -333,6 +348,185 @@ class TypeScriptParser {
     }
     return keyword;
   }
+  argumentForProp(prop) {
+    return prop.expression;
+  }
+  nameForArgument(prop) {
+    return prop.expression.name;
+  }
+  isOptionalProperty(property) {
+    return property.optional || false;
+  }
+  getGetSchemaInfoFN() {
+    return getSchemaInfo;
+  }
+  getTypeAnnotationFromProperty(property) {
+    return property.typeAnnotation.typeAnnotation;
+  }
+  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 typeAnnotationName = this.getTypeAnnotationName(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+      const _handleGenericTypeAnn = handleGenericTypeAnnotation(
+          node,
+          resolvedTypeAnnotation,
+          this,
+        ),
+        typeAnnotationNode = _handleGenericTypeAnn.typeAnnotation,
+        status = _handleGenericTypeAnn.typeResolutionStatus;
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
+    }
+    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(this.getTypeAnnotationName(typeAnnotation));
+  }
+  isProp(name, typeAnnotation) {
+    if (typeAnnotation.type !== 'TSTypeReference') {
+      return true;
+    }
+    const isStyle =
+      name === 'style' &&
+      typeAnnotation.type === 'GenericTypeAnnotation' &&
+      this.getTypeAnnotationName(typeAnnotation) === '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, this)) {
+      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,
+    };
+  }
+  getProperties(typeName, types) {
+    const alias = types[typeName];
+    if (!alias) {
+      throw new Error(
+        `Failed to find definition for "${typeName}", please check that you have a valid codegen typescript file`,
+      );
+    }
+    const aliasKind =
+      alias.type === 'TSInterfaceDeclaration' ? 'interface' : 'type';
+    try {
+      if (aliasKind === 'interface') {
+        var _alias$extends;
+        return [
+          ...((_alias$extends = alias.extends) !== null &&
+          _alias$extends !== void 0
+            ? _alias$extends
+            : []),
+          ...alias.body.body,
+        ];
+      }
+      return (
+        alias.typeAnnotation.members ||
+        alias.typeAnnotation.typeParameters.params[0].members ||
+        alias.typeAnnotation.typeParameters.params
+      );
+    } catch (e) {
+      throw new Error(
+        `Failed to find ${aliasKind} definition for "${typeName}", please check that you have a valid codegen typescript file`,
+      );
+    }
+  }
+  nextNodeForTypeAlias(typeAnnotation) {
+    return typeAnnotation.typeAnnotation;
+  }
+  nextNodeForEnum(typeAnnotation) {
+    return typeAnnotation;
+  }
+  genericTypeAnnotationErrorMessage(typeAnnotation) {
+    return `A non GenericTypeAnnotation must be a type declaration ('${this.typeAlias}'), an interface ('${this.interfaceDeclaration}'), or enum ('${this.enumDeclaration}'). Instead, got the unsupported ${typeAnnotation.type}.`;
+  }
+  extractTypeFromTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.type === 'TSTypeReference'
+      ? typeAnnotation.typeName.name
+      : typeAnnotation.type;
+  }
+  getObjectProperties(typeAnnotation) {
+    return typeAnnotation.members;
+  }
+  getLiteralValue(option) {
+    return option.literal.value;
+  }
+  getPaperTopLevelNameDeprecated(typeAnnotation) {
+    return typeAnnotation.typeParameters.params.length > 1
+      ? typeAnnotation.typeParameters.params[1].literal.value
+      : null;
+  }
 }
 module.exports = {
   TypeScriptParser,