@react-native/codegen 0.72.1 → 0.72.2

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

@@ -10,10 +10,29 @@
 
 'use strict';
 
-import type {UnionTypeAnnotationMemberType} from '../../CodegenSchema.js';
+import type {
+  UnionTypeAnnotationMemberType,
+  SchemaType,
+  NamedShape,
+  Nullable,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleEnumMembers,
+  NativeModuleEnumMemberType,
+} from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {Parser} from '../parser';
 
+// $FlowFixMe[untyped-import] Use flow-types for @babel/parser
+const babelParser = require('@babel/parser');
+
+const {buildSchema} = require('../parsers-commons');
+const {Visitor} = require('./Visitor');
+const {buildComponentSchema} = require('./components');
+const {wrapComponentSchema} = require('./components/schema');
+const {buildModuleSchema} = require('./modules');
+
+const fs = require('fs');
+
 const {
   UnsupportedObjectPropertyTypeAnnotationParserError,
 } = require('../errors');
@@ -21,34 +40,20 @@ const {
 class TypeScriptParser implements Parser {
   typeParameterInstantiation: string = 'TSTypeParameterInstantiation';
 
-  getKeyName(propertyOrIndex: $FlowFixMe, hasteModuleName: string): string {
-    switch (propertyOrIndex.type) {
-      case 'TSPropertySignature':
-        return propertyOrIndex.key.name;
-      case 'TSIndexSignature':
-        return propertyOrIndex.parameters[0].name;
-      default:
-        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
-          hasteModuleName,
-          propertyOrIndex,
-          propertyOrIndex.type,
-          this.language(),
-        );
-    }
+  isProperty(property: $FlowFixMe): boolean {
+    return property.type === 'TSPropertySignature';
   }
 
-  getMaybeEnumMemberType(maybeEnumDeclaration: $FlowFixMe): string {
-    if (maybeEnumDeclaration.members[0].initializer) {
-      return maybeEnumDeclaration.members[0].initializer.type
-        .replace('NumericLiteral', 'NumberTypeAnnotation')
-        .replace('StringLiteral', 'StringTypeAnnotation');
+  getKeyName(property: $FlowFixMe, hasteModuleName: string): string {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
     }
-
-    return 'StringTypeAnnotation';
-  }
-
-  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean {
-    return maybeEnumDeclaration.type === 'TSEnumDeclaration';
+    return property.key.name;
   }
 
   language(): ParserType {
@@ -81,6 +86,112 @@ class TypeScriptParser implements Parser {
 
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+
+  parseFile(filename: string): SchemaType {
+    const contents = fs.readFileSync(filename, 'utf8');
+
+    return this.parseString(contents, filename);
+  }
+
+  parseString(contents: string, filename: ?string): SchemaType {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+    );
+  }
+
+  parseModuleFixture(filename: string): SchemaType {
+    const contents = fs.readFileSync(filename, 'utf8');
+
+    return this.parseString(contents, 'path/NativeSampleTurboModule.ts');
+  }
+
+  getAst(contents: string): $FlowFixMe {
+    return babelParser.parse(contents, {
+      sourceType: 'module',
+      plugins: ['typescript'],
+    }).program;
+  }
+
+  getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $ReadOnlyArray<$FlowFixMe> {
+    return functionTypeAnnotation.parameters;
+  }
+
+  getFunctionNameFromParameter(
+    parameter: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
+  ): $FlowFixMe {
+    return parameter.typeAnnotation;
+  }
+
+  getParameterName(parameter: $FlowFixMe): string {
+    return parameter.name;
+  }
+
+  getParameterTypeAnnotation(parameter: $FlowFixMe): $FlowFixMe {
+    return parameter.typeAnnotation.typeAnnotation;
+  }
+
+  getFunctionTypeAnnotationReturnType(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $FlowFixMe {
+    return functionTypeAnnotation.typeAnnotation.typeAnnotation;
+  }
+
+  parseEnumMembersType(typeAnnotation: $FlowFixMe): NativeModuleEnumMemberType {
+    const enumInitializer = typeAnnotation.members[0]?.initializer;
+    const enumMembersType: ?NativeModuleEnumMemberType =
+      !enumInitializer || enumInitializer.type === 'StringLiteral'
+        ? 'StringTypeAnnotation'
+        : enumInitializer.type === 'NumericLiteral'
+        ? 'NumberTypeAnnotation'
+        : null;
+    if (!enumMembersType) {
+      throw new Error(
+        'Enum values must be either blank, number, or string values.',
+      );
+    }
+    return enumMembersType;
+  }
+
+  validateEnumMembersSupported(
+    typeAnnotation: $FlowFixMe,
+    enumMembersType: NativeModuleEnumMemberType,
+  ): void {
+    if (!typeAnnotation.members || typeAnnotation.members.length === 0) {
+      throw new Error('Enums should have at least one member.');
+    }
+
+    const enumInitializerType =
+      enumMembersType === 'StringTypeAnnotation'
+        ? 'StringLiteral'
+        : enumMembersType === 'NumberTypeAnnotation'
+        ? 'NumericLiteral'
+        : null;
+
+    typeAnnotation.members.forEach(member => {
+      if (
+        (member.initializer?.type ?? 'StringLiteral') !== enumInitializerType
+      ) {
+        throw new Error(
+          'Enum values can not be mixed. They all must be either blank, number, or string values.',
+        );
+      }
+    });
+  }
+
+  parseEnumMembers(typeAnnotation: $FlowFixMe): NativeModuleEnumMembers {
+    return typeAnnotation.members.map(member => ({
+      name: member.id.name,
+      value: member.initializer?.value ?? member.id.name,
+    }));
+  }
 }
 module.exports = {
   TypeScriptParser,

package/lib/parsers/typescript/utils.js

@@ -16,7 +16,6 @@ const _require = require('./parseTopLevelType'),
 /**
  * TODO(T108222691): Use flow-types for @babel/parser
  */
-
 function getTypes(ast) {
   return ast.body.reduce((types, node) => {
     switch (node.type) {
@@ -61,38 +60,59 @@ function resolveTypeAnnotation(
       ? typeAnnotation.typeAnnotation
       : typeAnnotation;
   let nullable = false;
-  let typeAliasResolutionStatus = {
+  let typeResolutionStatus = {
     successful: false,
   };
   for (;;) {
     const topLevelType = parseTopLevelType(node);
     nullable = nullable || topLevelType.optional;
     node = topLevelType.type;
-    if (node.type === 'TSTypeReference') {
-      typeAliasResolutionStatus = {
-        successful: true,
-        aliasName: node.typeName.name,
-      };
-      const resolvedTypeAnnotation = types[node.typeName.name];
-      if (
-        resolvedTypeAnnotation == null ||
-        resolvedTypeAnnotation.type === 'TSEnumDeclaration'
-      ) {
+    if (node.type !== 'TSTypeReference') {
+      break;
+    }
+    const resolvedTypeAnnotation = types[node.typeName.name];
+    if (resolvedTypeAnnotation == null) {
+      break;
+    }
+    switch (resolvedTypeAnnotation.type) {
+      case 'TSTypeAliasDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'alias',
+          name: node.typeName.name,
+        };
+        node = resolvedTypeAnnotation.typeAnnotation;
         break;
       }
-      invariant(
-        resolvedTypeAnnotation.type === 'TSTypeAliasDeclaration',
-        `GenericTypeAnnotation '${node.typeName.name}' must resolve to a TSTypeAliasDeclaration. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
-      );
-      node = resolvedTypeAnnotation.typeAnnotation;
-    } else {
-      break;
+      case 'TSInterfaceDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'alias',
+          name: node.typeName.name,
+        };
+        node = resolvedTypeAnnotation;
+        break;
+      }
+      case 'TSEnumDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'enum',
+          name: node.typeName.name,
+        };
+        node = resolvedTypeAnnotation;
+        break;
+      }
+      default: {
+        throw new TypeError(
+          `A non GenericTypeAnnotation must be a type declaration ('TSTypeAliasDeclaration'), an interface ('TSInterfaceDeclaration'), or enum ('TSEnumDeclaration'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+        );
+      }
     }
   }
   return {
     nullable: nullable,
     typeAnnotation: node,
-    typeAliasResolutionStatus,
+    typeResolutionStatus,
   };
 }
 module.exports = {

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

@@ -10,14 +10,13 @@
 
 'use strict';
 
-import type {TypeAliasResolutionStatus, TypeDeclarationMap} from '../utils';
+import type {TypeResolutionStatus, TypeDeclarationMap} from '../utils';
 
 const {parseTopLevelType} = require('./parseTopLevelType');
 
 /**
  * TODO(T108222691): Use flow-types for @babel/parser
  */
-
 function getTypes(ast: $FlowFixMe): TypeDeclarationMap {
   return ast.body.reduce((types, node) => {
     switch (node.type) {
@@ -57,7 +56,7 @@ function resolveTypeAnnotation(
 ): {
   nullable: boolean,
   typeAnnotation: $FlowFixMe,
-  typeAliasResolutionStatus: TypeAliasResolutionStatus,
+  typeResolutionStatus: TypeResolutionStatus,
 } {
   invariant(
     typeAnnotation != null,
@@ -69,7 +68,7 @@ function resolveTypeAnnotation(
       ? typeAnnotation.typeAnnotation
       : typeAnnotation;
   let nullable = false;
-  let typeAliasResolutionStatus: TypeAliasResolutionStatus = {
+  let typeResolutionStatus: TypeResolutionStatus = {
     successful: false,
   };
 
@@ -78,34 +77,55 @@ function resolveTypeAnnotation(
     nullable = nullable || topLevelType.optional;
     node = topLevelType.type;
 
-    if (node.type === 'TSTypeReference') {
-      typeAliasResolutionStatus = {
-        successful: true,
-        aliasName: node.typeName.name,
-      };
-      const resolvedTypeAnnotation = types[node.typeName.name];
-      if (
-        resolvedTypeAnnotation == null ||
-        resolvedTypeAnnotation.type === 'TSEnumDeclaration'
-      ) {
-        break;
-      }
-
-      invariant(
-        resolvedTypeAnnotation.type === 'TSTypeAliasDeclaration',
-        `GenericTypeAnnotation '${node.typeName.name}' must resolve to a TSTypeAliasDeclaration. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
-      );
+    if (node.type !== 'TSTypeReference') {
+      break;
+    }
 
-      node = resolvedTypeAnnotation.typeAnnotation;
-    } else {
+    const resolvedTypeAnnotation = types[node.typeName.name];
+    if (resolvedTypeAnnotation == null) {
       break;
     }
+
+    switch (resolvedTypeAnnotation.type) {
+      case 'TSTypeAliasDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'alias',
+          name: node.typeName.name,
+        };
+        node = resolvedTypeAnnotation.typeAnnotation;
+        break;
+      }
+      case 'TSInterfaceDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'alias',
+          name: node.typeName.name,
+        };
+        node = resolvedTypeAnnotation;
+        break;
+      }
+      case 'TSEnumDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'enum',
+          name: node.typeName.name,
+        };
+        node = resolvedTypeAnnotation;
+        break;
+      }
+      default: {
+        throw new TypeError(
+          `A non GenericTypeAnnotation must be a type declaration ('TSTypeAliasDeclaration'), an interface ('TSInterfaceDeclaration'), or enum ('TSEnumDeclaration'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+        );
+      }
+    }
   }
 
   return {
     nullable: nullable,
     typeAnnotation: node,
-    typeAliasResolutionStatus,
+    typeResolutionStatus,
   };
 }
 

package/lib/parsers/utils.js

@@ -10,81 +10,9 @@
 
 'use strict';
 
-function _slicedToArray(arr, i) {
-  return (
-    _arrayWithHoles(arr) ||
-    _iterableToArrayLimit(arr, i) ||
-    _unsupportedIterableToArray(arr, i) ||
-    _nonIterableRest()
-  );
-}
-function _nonIterableRest() {
-  throw new TypeError(
-    'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
-  );
-}
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === 'Object' && o.constructor) n = o.constructor.name;
-  if (n === 'Map' || n === 'Set') return Array.from(o);
-  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-    return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _iterableToArrayLimit(arr, i) {
-  var _i =
-    null == arr
-      ? null
-      : ('undefined' != typeof Symbol && arr[Symbol.iterator]) ||
-        arr['@@iterator'];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
-    try {
-      if (((_x = (_i = _i.call(arr)).next), 0 === i)) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else
-        for (
-          ;
-          !(_n = (_s = _x.call(_i)).done) &&
-          (_arr.push(_s.value), _arr.length !== i);
-          _n = !0
-        );
-    } catch (err) {
-      (_d = !0), (_e = err);
-    } finally {
-      try {
-        if (!_n && null != _i.return && ((_r = _i.return()), Object(_r) !== _r))
-          return;
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-    return _arr;
-  }
-}
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
 const _require = require('./errors'),
   ParserError = _require.ParserError;
-const _require2 = require('./parsers-commons'),
-  wrapModuleSchema = _require2.wrapModuleSchema;
-const fs = require('fs');
 const path = require('path');
-const invariant = require('invariant');
 function extractNativeModuleName(filename) {
   // this should drop everything after the file name. For Example it will drop:
   // .android.js, .android.ts, .android.tsx, .ios.js, .ios.ts, .ios.tsx, .js, .ts, .tsx
@@ -130,10 +58,6 @@ function verifyPlatforms(hasteModuleName, moduleName) {
     excludedPlatforms: Array.from(excludedPlatforms),
   };
 }
-function parseFile(filename, callback) {
-  const contents = fs.readFileSync(filename, 'utf8');
-  return callback(contents, filename);
-}
 
 // TODO(T108222691): Use flow-types for @babel/parser
 function visit(astNode, visitor) {
@@ -156,53 +80,6 @@ function visit(astNode, visitor) {
     }
   }
 }
-function buildSchemaFromConfigType(
-  configType,
-  filename,
-  ast,
-  wrapComponentSchema,
-  buildComponentSchema,
-  buildModuleSchema,
-) {
-  switch (configType) {
-    case 'component': {
-      return wrapComponentSchema(buildComponentSchema(ast));
-    }
-    case 'module': {
-      if (filename === undefined || filename === null) {
-        throw new Error('Filepath expected while parasing a module');
-      }
-      const nativeModuleName = extractNativeModuleName(filename);
-      const _createParserErrorCap = createParserErrorCapturer(),
-        _createParserErrorCap2 = _slicedToArray(_createParserErrorCap, 2),
-        parsingErrors = _createParserErrorCap2[0],
-        tryParse = _createParserErrorCap2[1];
-      const schema = tryParse(() =>
-        buildModuleSchema(nativeModuleName, ast, tryParse),
-      );
-      if (parsingErrors.length > 0) {
-        /**
-         * TODO(T77968131): We have two options:
-         *  - Throw the first error, but indicate there are more then one errors.
-         *  - Display all errors, nicely formatted.
-         *
-         * For the time being, we're just throw the first error.
-         **/
-
-        throw parsingErrors[0];
-      }
-      invariant(
-        schema != null,
-        'When there are no parsing errors, the schema should not be null',
-      );
-      return wrapModuleSchema(schema, nativeModuleName);
-    }
-    default:
-      return {
-        modules: {},
-      };
-  }
-}
 function getConfigType(
   // TODO(T71778680): Flow-type this node.
   ast,
@@ -266,8 +143,6 @@ module.exports = {
   extractNativeModuleName,
   createParserErrorCapturer,
   verifyPlatforms,
-  parseFile,
   visit,
-  buildSchemaFromConfigType,
   isModuleRegistryCall,
 };

package/lib/parsers/utils.js.flow

@@ -10,21 +10,17 @@
 
 'use strict';
 
-import type {ComponentSchemaBuilderConfig} from './flow/components/schema';
-import type {NativeModuleSchema, SchemaType} from '../CodegenSchema';
 const {ParserError} = require('./errors');
-const {wrapModuleSchema} = require('./parsers-commons');
 
-const fs = require('fs');
 const path = require('path');
-const invariant = require('invariant');
 
 export type TypeDeclarationMap = {[declarationName: string]: $FlowFixMe};
 
-export type TypeAliasResolutionStatus =
+export type TypeResolutionStatus =
   | $ReadOnly<{
+      type: 'alias' | 'enum',
       successful: true,
-      aliasName: string,
+      name: string,
     }>
   | $ReadOnly<{
       successful: false,
@@ -95,15 +91,6 @@ function verifyPlatforms(
   };
 }
 
-function parseFile(
-  filename: string,
-  callback: (contents: string, filename: string) => SchemaType,
-): SchemaType {
-  const contents = fs.readFileSync(filename, 'utf8');
-
-  return callback(contents, filename);
-}
-
 // TODO(T108222691): Use flow-types for @babel/parser
 function visit(
   astNode: $FlowFixMe,
@@ -133,58 +120,6 @@ function visit(
   }
 }
 
-function buildSchemaFromConfigType(
-  configType: 'module' | 'component' | 'none',
-  filename: ?string,
-  ast: $FlowFixMe,
-  wrapComponentSchema: (config: ComponentSchemaBuilderConfig) => SchemaType,
-  buildComponentSchema: (ast: $FlowFixMe) => ComponentSchemaBuilderConfig,
-  buildModuleSchema: (
-    hasteModuleName: string,
-    ast: $FlowFixMe,
-    tryParse: ParserErrorCapturer,
-  ) => NativeModuleSchema,
-): SchemaType {
-  switch (configType) {
-    case 'component': {
-      return wrapComponentSchema(buildComponentSchema(ast));
-    }
-    case 'module': {
-      if (filename === undefined || filename === null) {
-        throw new Error('Filepath expected while parasing a module');
-      }
-      const nativeModuleName = extractNativeModuleName(filename);
-
-      const [parsingErrors, tryParse] = createParserErrorCapturer();
-
-      const schema = tryParse(() =>
-        buildModuleSchema(nativeModuleName, ast, tryParse),
-      );
-
-      if (parsingErrors.length > 0) {
-        /**
-         * TODO(T77968131): We have two options:
-         *  - Throw the first error, but indicate there are more then one errors.
-         *  - Display all errors, nicely formatted.
-         *
-         * For the time being, we're just throw the first error.
-         **/
-
-        throw parsingErrors[0];
-      }
-
-      invariant(
-        schema != null,
-        'When there are no parsing errors, the schema should not be null',
-      );
-
-      return wrapModuleSchema(schema, nativeModuleName);
-    }
-    default:
-      return {modules: {}};
-  }
-}
-
 function getConfigType(
   // TODO(T71778680): Flow-type this node.
   ast: $FlowFixMe,
@@ -259,8 +194,6 @@ module.exports = {
   extractNativeModuleName,
   createParserErrorCapturer,
   verifyPlatforms,
-  parseFile,
   visit,
-  buildSchemaFromConfigType,
   isModuleRegistryCall,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.72.1",
+  "version": "0.72.2",
   "description": "⚛️ Code generation tools for React Native",
   "homepage": "https://github.com/facebook/react-native/tree/HEAD/packages/react-native-codegen",
   "repository": {
@@ -41,5 +41,8 @@
     "mkdirp": "^0.5.1",
     "prettier": "^2.4.1",
     "rimraf": "^3.0.2"
+  },
+  "peerDependencies": {
+    "@babel/preset-env": "^7.1.6"
   }
 }