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

package/lib/parsers/flow/utils.js

@@ -10,68 +10,6 @@
 
 'use strict';
 
-// $FlowFixMe[unclear-type] there's no flowtype for ASTs
-
-const invariant = require('invariant');
-function resolveTypeAnnotation(
-  // TODO(T71778680): This is an Flow TypeAnnotation. Flow-type this
-  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,
-  };
-}
 function getValueFromTypes(value, types) {
   if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {
     return getValueFromTypes(types[value.id.name].right, types);
@@ -80,5 +18,4 @@ function getValueFromTypes(value, types) {
 }
 module.exports = {
   getValueFromTypes,
-  resolveTypeAnnotation,
 };

package/lib/parsers/flow/utils.js.flow

@@ -10,82 +10,7 @@
 
 'use strict';
 
-import type {TypeResolutionStatus, TypeDeclarationMap} from '../utils';
-
-// $FlowFixMe[unclear-type] there's no flowtype for ASTs
-export type ASTNode = Object;
-
-const invariant = require('invariant');
-
-function resolveTypeAnnotation(
-  // TODO(T71778680): This is an Flow TypeAnnotation. Flow-type this
-  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,
-  };
-}
+import type {TypeDeclarationMap, ASTNode} from '../utils';
 
 function getValueFromTypes(value: ASTNode, types: TypeDeclarationMap): ASTNode {
   if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {
@@ -96,5 +21,4 @@ function getValueFromTypes(value: ASTNode, types: TypeDeclarationMap): ASTNode {
 
 module.exports = {
   getValueFromTypes,
-  resolveTypeAnnotation,
 };

package/lib/parsers/parser.js.flow

@@ -20,9 +20,60 @@ import type {
   NativeModuleEnumMembers,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  PropTypeAnnotation,
+  ExtendsPropsShape,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
-import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
+import type {
+  ParserErrorCapturer,
+  TypeDeclarationMap,
+  PropAST,
+  ASTNode,
+  TypeResolutionStatus,
+} from './utils';
+
+export type GetTypeAnnotationFN = (
+  name: string,
+  annotation: $FlowFixMe | ASTNode,
+  defaultValue: $FlowFixMe | void,
+  withNullDefault: boolean,
+  types: TypeDeclarationMap,
+  parser: Parser,
+  buildSchema: (
+    property: PropAST,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ) => $FlowFixMe,
+) => $FlowFixMe;
+
+export type SchemaInfo = {
+  name: string,
+  optional: boolean,
+  typeAnnotation: $FlowFixMe,
+  defaultValue: $FlowFixMe,
+  withNullDefault: boolean,
+};
+
+export type GetSchemaInfoFN = (
+  property: PropAST,
+  types: TypeDeclarationMap,
+) => ?SchemaInfo;
+
+export type BuildSchemaFN<T> = (
+  property: PropAST,
+  types: TypeDeclarationMap,
+  parser: Parser,
+) => ?NamedShape<T>;
+
+export type ResolveTypeAnnotationFN = (
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  parser: Parser,
+) => {
+  nullable: boolean,
+  typeAnnotation: $FlowFixMe,
+  typeResolutionStatus: TypeResolutionStatus,
+};
 
 /**
  * This is the main interface for Parsers of various languages.
@@ -34,6 +85,31 @@ export interface Parser {
    */
   typeParameterInstantiation: string;
 
+  /**
+   * TypeAlias property of the Parser
+   */
+  typeAlias: string;
+
+  /**
+   * enumDeclaration Property of the Parser
+   */
+  enumDeclaration: string;
+
+  /**
+   * InterfaceDeclaration property of the Parser
+   */
+  interfaceDeclaration: string;
+
+  /**
+   * This is the NullLiteralTypeAnnotation value
+   */
+  nullLiteralTypeAnnotation: string;
+
+  /**
+   * UndefinedLiteralTypeAnnotation property of the Parser
+   */
+  undefinedLiteralTypeAnnotation: string;
+
   /**
    * Given a declaration, it returns true if it is a property
    */
@@ -51,11 +127,11 @@ export interface Parser {
    */
   language(): ParserType;
   /**
-   * Given a type annotation for a generic type, it returns the type name.
+   * Given a type annotation, it returns the type name.
    * @parameter typeAnnotation: the annotation for a type in the AST.
    * @returns: the name of the type.
    */
-  nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string;
+  getTypeAnnotationName(typeAnnotation: $FlowFixMe): string;
   /**
    * Given a type arguments, it returns a boolean specifying if the Module is Invalid.
    * @parameter typeArguments: the type arguments.
@@ -255,4 +331,101 @@ export interface Parser {
    * @returns: converted TypeAnnotation to Keywords
    */
   convertKeywordToTypeAnnotation(keyword: string): string;
+
+  /**
+   * Given a prop return its arguments.
+   * @parameter prop
+   * @returns: Arguments of the prop
+   */
+  argumentForProp(prop: PropAST): $FlowFixMe;
+
+  /**
+   * Given a prop return its name.
+   * @parameter prop
+   * @returns: name property
+   */
+  nameForArgument(prop: PropAST): $FlowFixMe;
+
+  /**
+   * Given a property return if it is optional.
+   * @parameter property
+   * @returns: a boolean specifying if the Property is optional
+   */
+  isOptionalProperty(property: $FlowFixMe): boolean;
+
+  getGetTypeAnnotationFN(): GetTypeAnnotationFN;
+
+  getGetSchemaInfoFN(): GetSchemaInfoFN;
+
+  /**
+   * Given a property return the type annotation.
+   * @parameter property
+   * @returns: the annotation for a type in the AST.
+   */
+  getTypeAnnotationFromProperty(property: PropAST): $FlowFixMe;
+
+  getResolvedTypeAnnotation(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): {
+    nullable: boolean,
+    typeAnnotation: $FlowFixMe,
+    typeResolutionStatus: TypeResolutionStatus,
+  };
+
+  getResolveTypeAnnotationFN(): ResolveTypeAnnotationFN;
+
+  getProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): {
+    props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+    extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+  };
+
+  getProperties(typeName: string, types: TypeDeclarationMap): $FlowFixMe;
+
+  /**
+   * Given a typeAlias, it returns the next node.
+   */
+  nextNodeForTypeAlias(typeAnnotation: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given an enum Declaration, it returns the next node.
+   */
+  nextNodeForEnum(typeAnnotation: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a unsupported typeAnnotation, returns an error message.
+   */
+  genericTypeAnnotationErrorMessage(typeAnnotation: $FlowFixMe): string;
+
+  /**
+   * Given a type annotation, it extracts the type.
+   * @parameter typeAnnotation: the annotation for a type in the AST.
+   * @returns: the extracted type.
+   */
+  extractTypeFromTypeAnnotation(typeAnnotation: $FlowFixMe): string;
+
+  /**
+   * Given a typeAnnotation return the properties of an object.
+   * @parameter property
+   * @returns: the properties of an object represented by a type annotation.
+   */
+  getObjectProperties(typeAnnotation: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a option return the literal value.
+   * @parameter option
+   * @returns: the literal value of an union represented.
+   */
+  getLiteralValue(option: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a type annotation, it returns top level name in the AST if it exists else returns null.
+   * @parameter typeAnnotation: the annotation for a type in the AST.
+   * @returns: the top level name properties in the AST if it exists else null.
+   */
+  getPaperTopLevelNameDeprecated(typeAnnotation: $FlowFixMe): $FlowFixMe;
 }

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';
@@ -83,8 +102,14 @@ export class MockedParser {
   language() {
     return 'Flow';
   }
-  nameForGenericTypeAnnotation(typeAnnotation) {
-    return typeAnnotation.id.name;
+  getTypeAnnotationName(typeAnnotation) {
+    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 false;
@@ -217,4 +242,177 @@ export class MockedParser {
   convertKeywordToTypeAnnotation(keyword) {
     return keyword;
   }
+  argumentForProp(prop) {
+    return prop.expression;
+  }
+  nameForArgument(prop) {
+    return prop.expression.name;
+  }
+  isOptionalProperty(property) {
+    return property.optional || false;
+  }
+  getTypeAnnotationFromProperty(property) {
+    return property.typeAnnotation.typeAnnotation;
+  }
+  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`,
+      );
+    }
+  }
+  nextNodeForTypeAlias(typeAnnotation) {
+    return typeAnnotation.right;
+  }
+  nextNodeForEnum(typeAnnotation) {
+    return typeAnnotation.body;
+  }
+  genericTypeAnnotationErrorMessage(typeAnnotation) {
+    return `A non GenericTypeAnnotation must be a type declaration ('${this.typeAlias}') or enum ('${this.enumDeclaration}'). Instead, got the unsupported ${typeAnnotation.type}.`;
+  }
+  extractTypeFromTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.type === 'GenericTypeAnnotation'
+      ? typeAnnotation.id.name
+      : typeAnnotation.type;
+  }
+  getObjectProperties(typeAnnotation) {
+    return typeAnnotation.properties;
+  }
+  getLiteralValue(option) {
+    return option.value;
+  }
+  getPaperTopLevelNameDeprecated(typeAnnotation) {
+    return typeAnnotation.typeParameters.params.length > 1
+      ? typeAnnotation.typeParameters.params[1].value
+      : null;
+  }
 }