@react-native/codegen 0.72.3 → 0.72.4

package/lib/parsers/flow/parser.js

@@ -38,22 +38,27 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
+const _require = require('./modules'),
+  flowTranslateTypeAnnotation = _require.flowTranslateTypeAnnotation;
+
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
-const _require = require('../parsers-commons'),
-  buildSchema = _require.buildSchema;
-const _require2 = require('./Visitor'),
-  Visitor = _require2.Visitor;
-const _require3 = require('./components'),
-  buildComponentSchema = _require3.buildComponentSchema;
-const _require4 = require('../schema.js'),
-  wrapComponentSchema = _require4.wrapComponentSchema;
-const _require5 = require('./modules'),
-  buildModuleSchema = _require5.buildModuleSchema;
+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 fs = require('fs');
-const _require6 = require('../errors'),
+const _require8 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require6.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require8.UnsupportedObjectPropertyTypeAnnotationParserError;
 class FlowParser {
   constructor() {
     _defineProperty(
@@ -111,6 +116,8 @@ class FlowParser {
       buildModuleSchema,
       Visitor,
       this,
+      resolveTypeAnnotation,
+      flowTranslateTypeAnnotation,
     );
   }
   parseModuleFixture(filename) {
@@ -244,6 +251,55 @@ class FlowParser {
       return types;
     }, {});
   }
+  callExpressionTypeParameters(callExpression) {
+    return callExpression.typeArguments || null;
+  }
+  computePartialProperties(
+    properties,
+    hasteModuleName,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+  ) {
+    return properties.map(prop => {
+      return {
+        name: prop.key.name,
+        optional: true,
+        typeAnnotation: flowTranslateTypeAnnotation(
+          hasteModuleName,
+          prop.value,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          this,
+        ),
+      };
+    });
+  }
+  functionTypeAnnotation(propertyValueType) {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+  getTypeArgumentParamsFromDeclaration(declaration) {
+    return declaration.typeArguments.params;
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to typeArgumentParams and
+   * funcArgumentParams of generated AST.
+   */
+  getNativeComponentType(typeArgumentParams, funcArgumentParams) {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+  getAnnotatedElementProperties(annotatedElement) {
+    return annotatedElement.right.properties;
+  }
 }
 module.exports = {
   FlowParser,

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

@@ -18,19 +18,24 @@ import type {
   NativeModuleParamTypeAnnotation,
   NativeModuleEnumMemberType,
   NativeModuleEnumMembers,
+  NativeModuleAliasMap,
+  NativeModuleEnumMap,
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {Parser} from '../parser';
-import type {TypeDeclarationMap} from '../utils';
+import type {ParserErrorCapturer, TypeDeclarationMap} from '../utils';
+
+const {flowTranslateTypeAnnotation} = require('./modules');
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
 
 const {buildSchema} = require('../parsers-commons');
-const {Visitor} = require('./Visitor');
+const {Visitor} = require('../parsers-primitives');
 const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-const {buildModuleSchema} = require('./modules');
+const {buildModuleSchema} = require('../parsers-commons.js');
+const {resolveTypeAnnotation} = require('./utils');
 
 const fs = require('fs');
 
@@ -101,6 +106,8 @@ class FlowParser implements Parser {
       buildModuleSchema,
       Visitor,
       this,
+      resolveTypeAnnotation,
+      flowTranslateTypeAnnotation,
     );
   }
 
@@ -253,6 +260,63 @@ class FlowParser implements Parser {
       return types;
     }, {});
   }
+
+  callExpressionTypeParameters(callExpression: $FlowFixMe): $FlowFixMe | null {
+    return callExpression.typeArguments || null;
+  }
+
+  computePartialProperties(
+    properties: Array<$FlowFixMe>,
+    hasteModuleName: string,
+    types: TypeDeclarationMap,
+    aliasMap: {...NativeModuleAliasMap},
+    enumMap: {...NativeModuleEnumMap},
+    tryParse: ParserErrorCapturer,
+    cxxOnly: boolean,
+  ): Array<$FlowFixMe> {
+    return properties.map(prop => {
+      return {
+        name: prop.key.name,
+        optional: true,
+        typeAnnotation: flowTranslateTypeAnnotation(
+          hasteModuleName,
+          prop.value,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          this,
+        ),
+      };
+    });
+  }
+
+  functionTypeAnnotation(propertyValueType: string): boolean {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+
+  getTypeArgumentParamsFromDeclaration(declaration: $FlowFixMe): $FlowFixMe {
+    return declaration.typeArguments.params;
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to typeArgumentParams and
+   * funcArgumentParams of generated AST.
+   */
+  getNativeComponentType(
+    typeArgumentParams: $FlowFixMe,
+    funcArgumentParams: $FlowFixMe,
+  ): {[string]: string} {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
+    return annotatedElement.right.properties;
+  }
 }
 
 module.exports = {

package/lib/parsers/parser.d.ts

@@ -5,8 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { SchemaType } from "../CodegenSchema";
-import type { ParserType } from "./errors";
+import type { SchemaType } from '../CodegenSchema';
+import type { ParserType } from './errors';
 
 // useful members only for downstream
 export interface Parser {

package/lib/parsers/parser.js.flow

@@ -18,9 +18,11 @@ import type {
   NativeModuleParamTypeAnnotation,
   NativeModuleEnumMemberType,
   NativeModuleEnumMembers,
+  NativeModuleAliasMap,
+  NativeModuleEnumMap,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
-import type {TypeDeclarationMap} from './utils';
+import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
 
 /**
  * This is the main interface for Parsers of various languages.
@@ -161,8 +163,8 @@ export interface Parser {
 
   /**
    * Given a typeAnnotation, it returns the annotated element.
-   * @paramater typeAnnotation: the annotation for a type.
-   * @paramater types: a map of type declarations.
+   * @parameter typeAnnotation: the annotation for a type.
+   * @parameter types: a map of type declarations.
    * @returns: the annotated element.
    */
   extractAnnotatedElement(
@@ -174,4 +176,64 @@ export interface Parser {
    * Given the AST, returns the TypeDeclarationMap
    */
   getTypes(ast: $FlowFixMe): TypeDeclarationMap;
+
+  /**
+   * Given a callExpression, it returns the typeParameters of the callExpression.
+   * @parameter callExpression: the callExpression.
+   * @returns: the typeParameters of the callExpression or null if it does not exist.
+   */
+  callExpressionTypeParameters(callExpression: $FlowFixMe): $FlowFixMe | null;
+
+  /**
+   * Given an array of properties from a Partial type, it returns an array of remaped properties.
+   * @parameter properties: properties from a Partial types.
+   * @parameter hasteModuleName: a string with the native module name.
+   * @parameter types: a map of type declarations.
+   * @parameter aliasMap: a map of type aliases.
+   * @parameter enumMap: a map of type enums.
+   * @parameter tryParse: a parser error capturer.
+   * @parameter cxxOnly: a boolean specifying if the module is Cxx only.
+   * @returns: an array of remaped properties
+   */
+  computePartialProperties(
+    properties: Array<$FlowFixMe>,
+    hasteModuleName: string,
+    types: TypeDeclarationMap,
+    aliasMap: {...NativeModuleAliasMap},
+    enumMap: {...NativeModuleEnumMap},
+    tryParse: ParserErrorCapturer,
+    cxxOnly: boolean,
+  ): Array<$FlowFixMe>;
+
+  /**
+   * Given a propertyValueType, it returns a boolean specifying if the property is a function type annotation.
+   * @parameter propertyValueType: the propertyValueType.
+   * @returns: a boolean specifying if the property is a function type annotation.
+   */
+  functionTypeAnnotation(propertyValueType: string): boolean;
+
+  /**
+   * Given a declaration, it returns the typeArgumentParams of the declaration.
+   * @parameter declaration: the declaration.
+   * @returns: the typeArgumentParams of the declaration.
+   */
+  getTypeArgumentParamsFromDeclaration(declaration: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a typeArgumentParams and funcArgumentParams it returns a native component type.
+   * @parameter typeArgumentParams: the typeArgumentParams.
+   * @parameter funcArgumentParams: the funcArgumentParams.
+   * @returns: a native component type.
+   */
+  getNativeComponentType(
+    typeArgumentParams: $FlowFixMe,
+    funcArgumentParams: $FlowFixMe,
+  ): {[string]: string};
+
+  /**
+   * Given a annotatedElement, it returns the properties of annotated element.
+   * @parameter annotatedElement: the annotated element.
+   * @returns: the properties of annotated element.
+   */
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe;
 }

package/lib/parsers/parserMock.js

@@ -164,4 +164,48 @@ export class MockedParser {
   getTypes(ast) {
     return {};
   }
+  callExpressionTypeParameters(callExpression) {
+    return callExpression.typeArguments || null;
+  }
+  computePartialProperties(
+    properties,
+    hasteModuleName,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+  ) {
+    return [
+      {
+        name: 'a',
+        optional: true,
+        typeAnnotation: {
+          type: 'StringTypeAnnotation',
+        },
+      },
+      {
+        name: 'b',
+        optional: true,
+        typeAnnotation: {
+          type: 'BooleanTypeAnnotation',
+        },
+      },
+    ];
+  }
+  functionTypeAnnotation(propertyValueType) {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+  getTypeArgumentParamsFromDeclaration(declaration) {
+    return declaration.typeArguments.params;
+  }
+  getNativeComponentType(typeArgumentParams, funcArgumentParams) {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+  getAnnotatedElementProperties(annotatedElement) {
+    return annotatedElement.right.properties;
+  }
 }

package/lib/parsers/parserMock.js.flow

@@ -20,8 +20,10 @@ import type {
   NativeModuleParamTypeAnnotation,
   NativeModuleEnumMemberType,
   NativeModuleEnumMembers,
+  NativeModuleAliasMap,
+  NativeModuleEnumMap,
 } from '../CodegenSchema';
-import type {TypeDeclarationMap} from './utils';
+import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
@@ -180,4 +182,53 @@ export class MockedParser implements Parser {
   getTypes(ast: $FlowFixMe): TypeDeclarationMap {
     return {};
   }
+
+  callExpressionTypeParameters(callExpression: $FlowFixMe): $FlowFixMe | null {
+    return callExpression.typeArguments || null;
+  }
+
+  computePartialProperties(
+    properties: Array<$FlowFixMe>,
+    hasteModuleName: string,
+    types: TypeDeclarationMap,
+    aliasMap: {...NativeModuleAliasMap},
+    enumMap: {...NativeModuleEnumMap},
+    tryParse: ParserErrorCapturer,
+    cxxOnly: boolean,
+  ): Array<$FlowFixMe> {
+    return [
+      {
+        name: 'a',
+        optional: true,
+        typeAnnotation: {type: 'StringTypeAnnotation'},
+      },
+      {
+        name: 'b',
+        optional: true,
+        typeAnnotation: {type: 'BooleanTypeAnnotation'},
+      },
+    ];
+  }
+
+  functionTypeAnnotation(propertyValueType: string): boolean {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+
+  getTypeArgumentParamsFromDeclaration(declaration: $FlowFixMe): $FlowFixMe {
+    return declaration.typeArguments.params;
+  }
+
+  getNativeComponentType(
+    typeArgumentParams: $FlowFixMe,
+    funcArgumentParams: $FlowFixMe,
+  ): {[string]: string} {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
+    return annotatedElement.right.properties;
+  }
 }