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

package/lib/parsers/typescript/components/extends.js

@@ -12,28 +12,6 @@
 
 const _require = require('../parseTopLevelType'),
   parseTopLevelType = _require.parseTopLevelType;
-const _require2 = require('./componentsUtils.js'),
-  flattenProperties = _require2.flattenProperties;
-function extendsForProp(prop, types) {
-  if (!prop.expression) {
-    console.log('null', prop);
-  }
-  const name = prop.expression.name;
-  if (types[name] != null) {
-    // This type is locally defined in the file
-    return null;
-  }
-  switch (name) {
-    case 'ViewProps':
-      return {
-        type: 'ReactNativeBuiltInType',
-        knownTypeName: 'ReactNativeCoreViewProps',
-      };
-    default: {
-      throw new Error(`Unable to handle prop spread: ${name}`);
-    }
-  }
-}
 function isEvent(typeAnnotation) {
   if (typeAnnotation.type !== 'TSTypeReference') {
     return false;
@@ -41,35 +19,12 @@ function isEvent(typeAnnotation) {
   const eventNames = new Set(['BubblingEventHandler', 'DirectEventHandler']);
   return eventNames.has(typeAnnotation.typeName.name);
 }
-function isProp(name, typeAnnotation) {
-  if (typeAnnotation.type !== 'TSTypeReference') {
-    return true;
-  }
-  const isStyle =
-    name === 'style' &&
-    typeAnnotation.type === 'GenericTypeAnnotation' &&
-    typeAnnotation.typeName.name === 'ViewStyleProp';
-  return !isStyle;
-}
 
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
 
-function categorizeProps(typeDefinition, types, extendsProps, props, events) {
-  const remaining = [];
+function categorizeProps(typeDefinition, types, events) {
+  // find events
   for (const prop of typeDefinition) {
-    // find extends
-    if (prop.type === 'TSExpressionWithTypeArguments') {
-      const extend = extendsForProp(prop, types);
-      if (extend) {
-        extendsProps.push(extend);
-        continue;
-      }
-    }
-    remaining.push(prop);
-  }
-
-  // find events and props
-  for (const prop of flattenProperties(remaining, types)) {
     if (prop.type === 'TSPropertySignature') {
       const topLevelType = parseTopLevelType(
         prop.typeAnnotation.typeAnnotation,
@@ -77,8 +32,6 @@ function categorizeProps(typeDefinition, types, extendsProps, props, events) {
       );
       if (isEvent(topLevelType.type)) {
         events.push(prop);
-      } else if (isProp(prop.key.name, prop)) {
-        props.push(prop);
       }
     }
   }

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

@@ -10,33 +10,8 @@
 
 'use strict';
 
-import type {ExtendsPropsShape} from '../../../CodegenSchema.js';
 import type {TypeDeclarationMap} from '../../utils';
 const {parseTopLevelType} = require('../parseTopLevelType');
-const {flattenProperties} = require('./componentsUtils.js');
-
-function extendsForProp(prop: PropsAST, types: TypeDeclarationMap) {
-  if (!prop.expression) {
-    console.log('null', prop);
-  }
-  const name = prop.expression.name;
-
-  if (types[name] != null) {
-    // This type is locally defined in the file
-    return null;
-  }
-
-  switch (name) {
-    case 'ViewProps':
-      return {
-        type: 'ReactNativeBuiltInType',
-        knownTypeName: 'ReactNativeCoreViewProps',
-      };
-    default: {
-      throw new Error(`Unable to handle prop spread: ${name}`);
-    }
-  }
-}
 
 function isEvent(typeAnnotation: $FlowFixMe): boolean {
   if (typeAnnotation.type !== 'TSTypeReference') {
@@ -46,43 +21,16 @@ function isEvent(typeAnnotation: $FlowFixMe): boolean {
   return eventNames.has(typeAnnotation.typeName.name);
 }
 
-function 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;
-}
-
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
 type PropsAST = Object;
 
 function categorizeProps(
   typeDefinition: $ReadOnlyArray<PropsAST>,
   types: TypeDeclarationMap,
-  extendsProps: Array<ExtendsPropsShape>,
-  props: Array<PropsAST>,
   events: Array<PropsAST>,
 ): void {
-  const remaining: Array<PropsAST> = [];
+  // find events
   for (const prop of typeDefinition) {
-    // find extends
-    if (prop.type === 'TSExpressionWithTypeArguments') {
-      const extend = extendsForProp(prop, types);
-      if (extend) {
-        extendsProps.push(extend);
-        continue;
-      }
-    }
-
-    remaining.push(prop);
-  }
-
-  // find events and props
-  for (const prop of flattenProperties(remaining, types)) {
     if (prop.type === 'TSPropertySignature') {
       const topLevelType = parseTopLevelType(
         prop.typeAnnotation.typeAnnotation,
@@ -91,8 +39,6 @@ function categorizeProps(
 
       if (isEvent(topLevelType.type)) {
         events.push(prop);
-      } else if (isProp(prop.key.name, prop)) {
-        props.push(prop);
       }
     }
   }

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

@@ -16,100 +16,33 @@ const _require2 = require('./events'),
   getEvents = _require2.getEvents;
 const _require3 = require('./extends'),
   categorizeProps = _require3.categorizeProps;
-const _require4 = require('./props'),
-  getProps = _require4.getProps;
-const _require5 = require('./componentsUtils.js'),
-  getProperties = _require5.getProperties;
-const _require6 = require('../../error-utils'),
-  throwIfMoreThanOneCodegenNativecommands =
-    _require6.throwIfMoreThanOneCodegenNativecommands;
-const _require7 = require('../../parsers-commons'),
-  createComponentConfig = _require7.createComponentConfig,
-  findNativeComponentType = _require7.findNativeComponentType,
-  getCommandOptions = _require7.getCommandOptions,
-  getOptions = _require7.getOptions;
-
-// $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
-function findComponentConfig(ast, parser) {
-  const foundConfigs = [];
-  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 => {
-      let callExpression;
-      let calleeName;
-      try {
-        callExpression = statement.declaration.declarations[0].init;
-        calleeName = callExpression.callee.name;
-      } catch (e) {
-        return;
-      }
-      if (calleeName !== 'codegenNativeCommands') {
-        return;
-      }
-
-      // const statement.declaration.declarations[0].init
-      if (callExpression.arguments.length !== 1) {
-        throw new Error(
-          'codegenNativeCommands must be passed options including the supported commands',
-        );
-      }
-      const typeArgumentParam = callExpression.typeParameters.params[0];
-      if (typeArgumentParam.type !== 'TSTypeReference') {
-        throw new Error(
-          "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
-        );
-      }
-      return {
-        commandTypeName: typeArgumentParam.typeName.name,
-        commandOptionsExpression: callExpression.arguments[0],
-      };
-    })
-    .filter(Boolean);
-  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
-  return createComponentConfig(foundConfig, commandsTypeNames);
-}
-function getCommandProperties(
-  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
-   * LTI update could not be added via codemod */
-  commandTypeName,
-  types,
-  commandOptions,
-) {
+const _require4 = require('./componentsUtils.js'),
+  getProperties = _require4.getProperties;
+const _require5 = require('../../error-utils'),
+  throwIfTypeAliasIsNotInterface = _require5.throwIfTypeAliasIsNotInterface;
+const _require6 = require('../../parsers-commons'),
+  propertyNames = _require6.propertyNames,
+  getCommandOptions = _require6.getCommandOptions,
+  getOptions = _require6.getOptions,
+  findComponentConfig = _require6.findComponentConfig;
+function getCommandProperties(ast, parser) {
+  const _findComponentConfig = findComponentConfig(ast, parser),
+    commandTypeName = _findComponentConfig.commandTypeName,
+    commandOptionsExpression = _findComponentConfig.commandOptionsExpression;
   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}`,
-    );
-  }
-  let properties;
-  try {
-    properties = typeAlias.body.body;
-  } catch (e) {
+  throwIfTypeAliasIsNotInterface(typeAlias, parser);
+  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 = properties
-    .map(property => property && property.key && property.key.name)
-    .filter(Boolean);
+  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',
@@ -135,33 +68,20 @@ function getCommandProperties(
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
 function buildComponentSchema(ast, parser) {
-  const _findComponentConfig = findComponentConfig(ast, parser),
-    componentName = _findComponentConfig.componentName,
-    propsTypeName = _findComponentConfig.propsTypeName,
-    commandTypeName = _findComponentConfig.commandTypeName,
-    commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
-    optionsExpression = _findComponentConfig.optionsExpression;
+  const _findComponentConfig2 = findComponentConfig(ast, parser),
+    componentName = _findComponentConfig2.componentName,
+    propsTypeName = _findComponentConfig2.propsTypeName,
+    optionsExpression = _findComponentConfig2.optionsExpression;
   const types = parser.getTypes(ast);
   const propProperties = getProperties(propsTypeName, types);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-  const commandProperties = getCommandProperties(
-    commandTypeName,
-    types,
-    commandOptions,
-  );
+  const commandProperties = getCommandProperties(ast, parser);
   const options = getOptions(optionsExpression);
-  const extendsProps = [];
-  const componentPropAsts = [];
   const componentEventAsts = [];
-  categorizeProps(
-    propProperties,
-    types,
-    extendsProps,
-    componentPropAsts,
-    componentEventAsts,
-  );
-  const props = getProps(componentPropAsts, types);
-  const events = getEvents(componentEventAsts, types);
+  categorizeProps(propProperties, types, componentEventAsts);
+  const _parser$getProps = parser.getProps(propProperties, types),
+    props = _parser$getProps.props,
+    extendsProps = _parser$getProps.extendsProps;
+  const events = getEvents(componentEventAsts, types, parser);
   const commands = getCommands(commandProperties, types);
   return {
     filename: componentName,

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

@@ -9,124 +9,45 @@
  */
 
 'use strict';
-import type {ExtendsPropsShape} from '../../../CodegenSchema.js';
 import type {Parser} from '../../parser';
-import type {TypeDeclarationMap} from '../../utils';
-import type {CommandOptions} from '../../parsers-commons';
 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 {throwIfTypeAliasIsNotInterface} = require('../../error-utils');
 const {
-  createComponentConfig,
-  findNativeComponentType,
+  propertyNames,
   getCommandOptions,
   getOptions,
+  findComponentConfig,
 } = 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',
+function getCommandProperties(ast: $FlowFixMe, parser: Parser) {
+  const {commandTypeName, commandOptionsExpression} = findComponentConfig(
+    ast,
+    parser,
   );
-
-  const commandsTypeNames = namedExports
-    .map(statement => {
-      let callExpression;
-      let calleeName;
-      try {
-        callExpression = statement.declaration.declarations[0].init;
-        calleeName = callExpression.callee.name;
-      } catch (e) {
-        return;
-      }
-
-      if (calleeName !== 'codegenNativeCommands') {
-        return;
-      }
-
-      // const statement.declaration.declarations[0].init
-      if (callExpression.arguments.length !== 1) {
-        throw new Error(
-          'codegenNativeCommands must be passed options including the supported commands',
-        );
-      }
-
-      const typeArgumentParam = callExpression.typeParameters.params[0];
-
-      if (typeArgumentParam.type !== 'TSTypeReference') {
-        throw new Error(
-          "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
-        );
-      }
-
-      return {
-        commandTypeName: typeArgumentParam.typeName.name,
-        commandOptionsExpression: callExpression.arguments[0],
-      };
-    })
-    .filter(Boolean);
-
-  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
-
-  return createComponentConfig(foundConfig, commandsTypeNames);
-}
-
-function getCommandProperties(
-  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
-   * LTI update could not be added via codemod */
-  commandTypeName,
-  types: TypeDeclarationMap,
-  commandOptions: ?CommandOptions,
-) {
   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}`,
-    );
-  }
+  throwIfTypeAliasIsNotInterface(typeAlias, parser);
 
-  let properties;
-  try {
-    properties = typeAlias.body.body;
-  } catch (e) {
+  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 = properties
-    .map(property => property && property.key && property.key.name)
-    .filter(Boolean);
+  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',
@@ -158,39 +79,23 @@ function buildComponentSchema(
   ast: $FlowFixMe,
   parser: Parser,
 ): ComponentSchemaBuilderConfig {
-  const {
-    componentName,
-    propsTypeName,
-    commandTypeName,
-    commandOptionsExpression,
-    optionsExpression,
-  } = findComponentConfig(ast, parser);
+  const {componentName, propsTypeName, optionsExpression} = findComponentConfig(
+    ast,
+    parser,
+  );
 
   const types = parser.getTypes(ast);
 
   const propProperties = getProperties(propsTypeName, types);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
 
-  const commandProperties = getCommandProperties(
-    commandTypeName,
-    types,
-    commandOptions,
-  );
+  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,30 +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,
-  emitBoolean = _require5.emitBoolean,
-  emitFunction = _require5.emitFunction,
-  emitNumber = _require5.emitNumber,
-  emitGenericObject = _require5.emitGenericObject,
-  emitPromise = _require5.emitPromise,
-  emitRootTag = _require5.emitRootTag,
-  emitVoid = _require5.emitVoid,
-  emitString = _require5.emitString,
-  emitMixed = _require5.emitMixed,
-  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,
   /**
@@ -173,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(
@@ -303,7 +299,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,
@@ -314,7 +310,7 @@ function translateTypeAnnotation(
             parser,
           );
           // no need to do further checking
-          return emitGenericObject(nullable);
+          return emitDictionary(nullable, valueType);
         }
       }
       return translateObjectTypeAnnotation(
@@ -341,18 +337,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,
@@ -370,19 +354,26 @@ 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;
     }
   }
 }