@react-native/codegen 0.72.5 → 0.73.0-nightly-20230605-5062553c6

package/lib/parsers/parserMock.js

@@ -38,11 +38,17 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
+import invariant from 'invariant';
+const _require = require('./typescript/components/componentsUtils'),
+  flattenProperties = _require.flattenProperties;
+const _require2 = require('./parsers-commons'),
+  buildPropSchema = _require2.buildPropSchema;
+
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
-const _require = require('./errors'),
+const _require3 = require('./errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require3.UnsupportedObjectPropertyTypeAnnotationParserError;
 const schemaMock = {
   modules: {
     StringPropNativeComponentView: {
@@ -65,6 +71,19 @@ export class MockedParser {
       'typeParameterInstantiation',
       'TypeParameterInstantiation',
     );
+    _defineProperty(this, 'typeAlias', 'TypeAlias');
+    _defineProperty(this, 'enumDeclaration', 'EnumDeclaration');
+    _defineProperty(this, 'interfaceDeclaration', 'InterfaceDeclaration');
+    _defineProperty(
+      this,
+      'nullLiteralTypeAnnotation',
+      'NullLiteralTypeAnnotation',
+    );
+    _defineProperty(
+      this,
+      'undefinedLiteralTypeAnnotation',
+      'VoidLiteralTypeAnnotation',
+    );
   }
   isProperty(property) {
     return property.type === 'ObjectTypeProperty';
@@ -158,6 +177,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 +230,155 @@ export class MockedParser {
   getAnnotatedElementProperties(annotatedElement) {
     return annotatedElement.right.properties;
   }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.properties;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    return keyword;
+  }
+  argumentForProp(prop) {
+    return prop.expression;
+  }
+  nameForArgument(prop) {
+    return prop.expression.name;
+  }
+  isOptionalProperty(property) {
+    return property.optional || false;
+  }
+  getGetTypeAnnotationFN() {
+    return () => {
+      return {};
+    };
+  }
+  getGetSchemaInfoFN() {
+    return () => {
+      return {
+        name: 'MockedSchema',
+        optional: false,
+        typeAnnotation: 'BooleanTypeAnnotation',
+        defaultValue: false,
+        withNullDefault: false,
+      };
+    };
+  }
+  getResolveTypeAnnotationFN() {
+    return () => {
+      return {
+        nullable: false,
+        typeAnnotation: null,
+        typeResolutionStatus: {
+          successful: false,
+        },
+      };
+    };
+  }
+  getResolvedTypeAnnotation(typeAnnotation, types) {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+    let node = typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus = {
+      successful: false,
+    };
+    for (;;) {
+      if (node.type === 'NullableTypeAnnotation') {
+        nullable = true;
+        node = node.typeAnnotation;
+        continue;
+      }
+      if (node.type !== 'GenericTypeAnnotation') {
+        break;
+      }
+      const resolvedTypeAnnotation = types[node.id.name];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+      switch (resolvedTypeAnnotation.type) {
+        case 'TypeAlias': {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'alias',
+            name: node.id.name,
+          };
+          node = resolvedTypeAnnotation.right;
+          break;
+        }
+        case 'EnumDeclaration': {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'enum',
+            name: node.id.name,
+          };
+          node = resolvedTypeAnnotation.body;
+          break;
+        }
+        default: {
+          throw new TypeError(
+            `A non GenericTypeAnnotation must be a type declaration ('TypeAlias') or enum ('EnumDeclaration'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+          );
+        }
+      }
+    }
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+  getExtendsProps(typeDefinition, types) {
+    return typeDefinition
+      .filter(prop => prop.type === 'ObjectTypeSpreadProperty')
+      .map(prop => this.extendsForProp(prop, types, this))
+      .filter(Boolean);
+  }
+  extendsForProp(prop, types, parser) {
+    const argument = this.argumentForProp(prop);
+    if (!argument) {
+      console.log('null', prop);
+    }
+    const name = parser.nameForArgument(prop);
+    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}`);
+      }
+    }
+  }
+  removeKnownExtends(typeDefinition, types) {
+    return typeDefinition.filter(
+      prop =>
+        prop.type !== 'ObjectTypeSpreadProperty' ||
+        this.extendsForProp(prop, types, this) === null,
+    );
+  }
+  getProps(typeDefinition, types) {
+    const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
+    const props = flattenProperties(nonExtendsProps, types, this)
+      .map(property => buildPropSchema(property, types, this))
+      .filter(Boolean);
+    return {
+      props,
+      extendsProps: this.getExtendsProps(typeDefinition, types),
+    };
+  }
+  getProperties(typeName, types) {
+    const typeAlias = types[typeName];
+    try {
+      return typeAlias.right.typeParameters.params[0].properties;
+    } catch (e) {
+      throw new Error(
+        `Failed to find type definition for "${typeName}", please check that you have a valid codegen flow file`,
+      );
+    }
+  }
 }

package/lib/parsers/parserMock.js.flow

@@ -10,8 +10,17 @@
 
 'use strict';
 
-import type {Parser} from './parser';
+import type {
+  GetSchemaInfoFN,
+  GetTypeAnnotationFN,
+  Parser,
+  ResolveTypeAnnotationFN,
+} from './parser';
 import type {ParserType} from './errors';
+type ExtendsForProp = null | {
+  type: 'ReactNativeBuiltInType',
+  knownTypeName: 'ReactNativeCoreViewProps',
+};
 import type {
   UnionTypeAnnotationMemberType,
   SchemaType,
@@ -22,8 +31,20 @@ import type {
   NativeModuleEnumMembers,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  PropTypeAnnotation,
+  ExtendsPropsShape,
 } from '../CodegenSchema';
-import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
+import type {
+  ParserErrorCapturer,
+  PropAST,
+  TypeDeclarationMap,
+  TypeResolutionStatus,
+} from './utils';
+import invariant from 'invariant';
+
+const {flattenProperties} = require('./typescript/components/componentsUtils');
+
+const {buildPropSchema} = require('./parsers-commons');
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
@@ -49,6 +70,11 @@ const schemaMock = {
 
 export class MockedParser implements Parser {
   typeParameterInstantiation: string = 'TypeParameterInstantiation';
+  typeAlias: string = 'TypeAlias';
+  enumDeclaration: string = 'EnumDeclaration';
+  interfaceDeclaration: string = 'InterfaceDeclaration';
+  nullLiteralTypeAnnotation: string = 'NullLiteralTypeAnnotation';
+  undefinedLiteralTypeAnnotation: string = 'VoidLiteralTypeAnnotation';
 
   isProperty(property: $FlowFixMe): boolean {
     return property.type === 'ObjectTypeProperty';
@@ -172,6 +198,10 @@ export class MockedParser implements Parser {
     );
   }
 
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return true;
+  }
+
   extractAnnotatedElement(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -231,4 +261,199 @@ 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;
+  }
+
+  argumentForProp(prop: PropAST): $FlowFixMe {
+    return prop.expression;
+  }
+
+  nameForArgument(prop: PropAST): $FlowFixMe {
+    return prop.expression.name;
+  }
+
+  isOptionalProperty(property: $FlowFixMe): boolean {
+    return property.optional || false;
+  }
+
+  getGetTypeAnnotationFN(): GetTypeAnnotationFN {
+    return () => {
+      return {};
+    };
+  }
+
+  getGetSchemaInfoFN(): GetSchemaInfoFN {
+    return () => {
+      return {
+        name: 'MockedSchema',
+        optional: false,
+        typeAnnotation: 'BooleanTypeAnnotation',
+        defaultValue: false,
+        withNullDefault: false,
+      };
+    };
+  }
+
+  getResolveTypeAnnotationFN(): ResolveTypeAnnotationFN {
+    return () => {
+      return {
+        nullable: false,
+        typeAnnotation: null,
+        typeResolutionStatus: {successful: false},
+      };
+    };
+  }
+
+  getResolvedTypeAnnotation(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): {
+    nullable: boolean,
+    typeAnnotation: $FlowFixMe,
+    typeResolutionStatus: TypeResolutionStatus,
+  } {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+
+    let node = typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus: TypeResolutionStatus = {
+      successful: false,
+    };
+
+    for (;;) {
+      if (node.type === 'NullableTypeAnnotation') {
+        nullable = true;
+        node = node.typeAnnotation;
+        continue;
+      }
+
+      if (node.type !== 'GenericTypeAnnotation') {
+        break;
+      }
+
+      const resolvedTypeAnnotation = types[node.id.name];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+
+      switch (resolvedTypeAnnotation.type) {
+        case 'TypeAlias': {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'alias',
+            name: node.id.name,
+          };
+          node = resolvedTypeAnnotation.right;
+          break;
+        }
+        case 'EnumDeclaration': {
+          typeResolutionStatus = {
+            successful: true,
+            type: 'enum',
+            name: node.id.name,
+          };
+          node = resolvedTypeAnnotation.body;
+          break;
+        }
+        default: {
+          throw new TypeError(
+            `A non GenericTypeAnnotation must be a type declaration ('TypeAlias') or enum ('EnumDeclaration'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+          );
+        }
+      }
+    }
+
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+
+  getExtendsProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): $ReadOnlyArray<ExtendsPropsShape> {
+    return typeDefinition
+      .filter(prop => prop.type === 'ObjectTypeSpreadProperty')
+      .map(prop => this.extendsForProp(prop, types, this))
+      .filter(Boolean);
+  }
+
+  extendsForProp(
+    prop: PropAST,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): ExtendsForProp {
+    const argument = this.argumentForProp(prop);
+    if (!argument) {
+      console.log('null', prop);
+    }
+    const name = parser.nameForArgument(prop);
+
+    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}`);
+      }
+    }
+  }
+
+  removeKnownExtends(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): $ReadOnlyArray<PropAST> {
+    return typeDefinition.filter(
+      prop =>
+        prop.type !== 'ObjectTypeSpreadProperty' ||
+        this.extendsForProp(prop, types, this) === null,
+    );
+  }
+
+  getProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): {
+    props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+    extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+  } {
+    const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
+    const props = flattenProperties(nonExtendsProps, types, this)
+      .map(property => buildPropSchema(property, types, this))
+      .filter(Boolean);
+
+    return {
+      props,
+      extendsProps: this.getExtendsProps(typeDefinition, types),
+    };
+  }
+
+  getProperties(typeName: string, types: TypeDeclarationMap): $FlowFixMe {
+    const typeAlias = types[typeName];
+    try {
+      return typeAlias.right.typeParameters.params[0].properties;
+    } catch (e) {
+      throw new Error(
+        `Failed to find type definition for "${typeName}", please check that you have a valid codegen flow file`,
+      );
+    }
+  }
 }

package/lib/parsers/parsers-commons.js

@@ -169,7 +169,12 @@ const _require2 = require('./error-utils'),
   throwIfModuleInterfaceNotFound = _require2.throwIfModuleInterfaceNotFound,
   throwIfMoreThanOneModuleInterfaceParserError =
     _require2.throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfModuleInterfaceIsMisnamed = _require2.throwIfModuleInterfaceIsMisnamed;
+  throwIfModuleInterfaceIsMisnamed = _require2.throwIfModuleInterfaceIsMisnamed,
+  throwIfMoreThanOneCodegenNativecommands =
+    _require2.throwIfMoreThanOneCodegenNativecommands,
+  throwIfConfigNotfound = _require2.throwIfConfigNotfound,
+  throwIfMoreThanOneConfig = _require2.throwIfMoreThanOneConfig,
+  throwIfTypeAliasIsNotInterface = _require2.throwIfTypeAliasIsNotInterface;
 const _require3 = require('./errors'),
   MissingTypeParameterGenericParserError =
     _require3.MissingTypeParameterGenericParserError,
@@ -395,7 +400,6 @@ function buildPropertySchema(
   enumMap,
   tryParse,
   cxxOnly,
-  resolveTypeAnnotation,
   translateTypeAnnotation,
   parser,
 ) {
@@ -409,7 +413,8 @@ function buildPropertySchema(
         ? property
         : property.typeAnnotation;
   }
-  var _resolveTypeAnnotatio = resolveTypeAnnotation(value, types);
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
+  var _resolveTypeAnnotatio = resolveTypeAnnotationFN(value, types, parser);
   nullable = _resolveTypeAnnotatio.nullable;
   value = _resolveTypeAnnotatio.typeAnnotation;
   throwIfModuleTypeIsUnsupported(
@@ -446,7 +451,6 @@ function buildSchemaFromConfigType(
   buildComponentSchema,
   buildModuleSchema,
   parser,
-  resolveTypeAnnotation,
   translateTypeAnnotation,
 ) {
   switch (configType) {
@@ -468,7 +472,6 @@ function buildSchemaFromConfigType(
           ast,
           tryParse,
           parser,
-          resolveTypeAnnotation,
           translateTypeAnnotation,
         ),
       );
@@ -503,7 +506,6 @@ function buildSchema(
   buildModuleSchema,
   Visitor,
   parser,
-  resolveTypeAnnotation,
   translateTypeAnnotation,
 ) {
   // Early return for non-Spec JavaScript files
@@ -525,7 +527,6 @@ function buildSchema(
     buildComponentSchema,
     buildModuleSchema,
     parser,
-    resolveTypeAnnotation,
     translateTypeAnnotation,
   );
 }
@@ -600,7 +601,6 @@ const buildModuleSchema = (
   ast,
   tryParse,
   parser,
-  resolveTypeAnnotation,
   translateTypeAnnotation,
 ) => {
   const language = parser.language();
@@ -658,7 +658,6 @@ const buildModuleSchema = (
           enumMap,
           tryParse,
           cxxOnly,
-          resolveTypeAnnotation,
           translateTypeAnnotation,
           parser,
         ),
@@ -787,6 +786,160 @@ 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);
+}
+function extendsForProp(prop, types, parser) {
+  const argument = parser.argumentForProp(prop);
+  if (!argument) {
+    console.log('null', prop);
+  }
+  const name = parser.nameForArgument(prop);
+  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 buildPropSchema(property, types, parser) {
+  const getSchemaInfoFN = parser.getGetSchemaInfoFN();
+  const info = getSchemaInfoFN(property, types);
+  if (info == null) {
+    return null;
+  }
+  const name = info.name,
+    optional = info.optional,
+    typeAnnotation = info.typeAnnotation,
+    defaultValue = info.defaultValue,
+    withNullDefault = info.withNullDefault;
+  const getTypeAnnotationFN = parser.getGetTypeAnnotationFN();
+  return {
+    name,
+    optional,
+    typeAnnotation: getTypeAnnotationFN(
+      name,
+      typeAnnotation,
+      defaultValue,
+      withNullDefault,
+      types,
+      parser,
+      buildPropSchema,
+    ),
+  };
+}
+
+/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+ * LTI update could not be added via codemod */
+function getEventArgument(argumentProps, buildPropertiesForEvent, parser) {
+  return {
+    type: 'ObjectTypeAnnotation',
+    properties: argumentProps.map(member =>
+      buildPropertiesForEvent(member, parser),
+    ),
+  };
+}
+
+/* $FlowFixMe[signature-verification-failure] there's no flowtype for AST.
+ * 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);
+  });
+  throwIfConfigNotfound(foundConfigs);
+  throwIfMoreThanOneConfig(foundConfigs);
+  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);
+}
+
+// $FlowFixMe[signature-verification-failure] there's no flowtype for AST
+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];
+  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 file`,
+    );
+  }
+  const commandPropertyNames = 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 !== commandPropertyNames.length ||
+    !commandOptions.supportedCommands.every(supportedCommand =>
+      commandPropertyNames.includes(supportedCommand),
+    )
+  ) {
+    throw new Error(
+      `codegenNativeCommands expected the same supportedCommands specified in the ${commandTypeName} interface: ${commandPropertyNames.join(
+        ', ',
+      )}`,
+    );
+  }
+  return properties;
+}
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -802,6 +955,13 @@ module.exports = {
   parseModuleName,
   buildModuleSchema,
   findNativeComponentType,
+  propertyNames,
   getCommandOptions,
   getOptions,
+  getCommandTypeNameAndOptionsExpression,
+  extendsForProp,
+  buildPropSchema,
+  getEventArgument,
+  findComponentConfig,
+  getCommandProperties,
 };