@react-native/codegen 0.72.1 → 0.72.3

package/lib/parsers/typescript/parser.js

@@ -38,9 +38,22 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('../errors'),
+// $FlowFixMe[untyped-import] Use flow-types for @babel/parser
+const babelParser = require('@babel/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 fs = require('fs');
+const _require6 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require6.UnsupportedObjectPropertyTypeAnnotationParserError;
 class TypeScriptParser {
   constructor() {
     _defineProperty(
@@ -49,31 +62,19 @@ class TypeScriptParser {
       'TSTypeParameterInstantiation',
     );
   }
-  getKeyName(propertyOrIndex, hasteModuleName) {
-    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) {
+    return property.type === 'TSPropertySignature';
   }
-  getMaybeEnumMemberType(maybeEnumDeclaration) {
-    if (maybeEnumDeclaration.members[0].initializer) {
-      return maybeEnumDeclaration.members[0].initializer.type
-        .replace('NumericLiteral', 'NumberTypeAnnotation')
-        .replace('StringLiteral', 'StringTypeAnnotation');
+  getKeyName(property, hasteModuleName) {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
     }
-    return 'StringTypeAnnotation';
-  }
-  isEnumDeclaration(maybeEnumDeclaration) {
-    return maybeEnumDeclaration.type === 'TSEnumDeclaration';
+    return property.key.name;
   }
   language() {
     return 'TypeScript';
@@ -99,6 +100,155 @@ class TypeScriptParser {
     };
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+  parseFile(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, filename);
+  }
+  parseString(contents, filename) {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+    );
+  }
+  parseModuleFixture(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, 'path/NativeSampleTurboModule.ts');
+  }
+  getAst(contents) {
+    return babelParser.parse(contents, {
+      sourceType: 'module',
+      plugins: ['typescript'],
+    }).program;
+  }
+  getFunctionTypeAnnotationParameters(functionTypeAnnotation) {
+    return functionTypeAnnotation.parameters;
+  }
+  getFunctionNameFromParameter(parameter) {
+    return parameter.typeAnnotation;
+  }
+  getParameterName(parameter) {
+    return parameter.name;
+  }
+  getParameterTypeAnnotation(parameter) {
+    return parameter.typeAnnotation.typeAnnotation;
+  }
+  getFunctionTypeAnnotationReturnType(functionTypeAnnotation) {
+    return functionTypeAnnotation.typeAnnotation.typeAnnotation;
+  }
+  parseEnumMembersType(typeAnnotation) {
+    var _typeAnnotation$membe;
+    const enumInitializer =
+      (_typeAnnotation$membe = typeAnnotation.members[0]) === null ||
+      _typeAnnotation$membe === void 0
+        ? void 0
+        : _typeAnnotation$membe.initializer;
+    const enumMembersType =
+      !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, enumMembersType) {
+    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 => {
+      var _member$initializer$t, _member$initializer;
+      if (
+        ((_member$initializer$t =
+          (_member$initializer = member.initializer) === null ||
+          _member$initializer === void 0
+            ? void 0
+            : _member$initializer.type) !== null &&
+        _member$initializer$t !== void 0
+          ? _member$initializer$t
+          : 'StringLiteral') !== enumInitializerType
+      ) {
+        throw new Error(
+          'Enum values can not be mixed. They all must be either blank, number, or string values.',
+        );
+      }
+    });
+  }
+  parseEnumMembers(typeAnnotation) {
+    return typeAnnotation.members.map(member => {
+      var _member$initializer$v, _member$initializer2;
+      return {
+        name: member.id.name,
+        value:
+          (_member$initializer$v =
+            (_member$initializer2 = member.initializer) === null ||
+            _member$initializer2 === void 0
+              ? void 0
+              : _member$initializer2.value) !== null &&
+          _member$initializer$v !== void 0
+            ? _member$initializer$v
+            : member.id.name,
+      };
+    });
+  }
+  isModuleInterface(node) {
+    var _node$extends;
+    return (
+      node.type === 'TSInterfaceDeclaration' &&
+      ((_node$extends = node.extends) === null || _node$extends === void 0
+        ? void 0
+        : _node$extends.length) === 1 &&
+      node.extends[0].type === 'TSExpressionWithTypeArguments' &&
+      node.extends[0].expression.name === 'TurboModule'
+    );
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].typeName.name];
+  }
+
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  getTypes(ast) {
+    return ast.body.reduce((types, node) => {
+      switch (node.type) {
+        case 'ExportNamedDeclaration': {
+          if (node.declaration) {
+            switch (node.declaration.type) {
+              case 'TSTypeAliasDeclaration':
+              case 'TSInterfaceDeclaration':
+              case 'TSEnumDeclaration': {
+                types[node.declaration.id.name] = node.declaration;
+                break;
+              }
+            }
+          }
+          break;
+        }
+        case 'TSTypeAliasDeclaration':
+        case 'TSInterfaceDeclaration':
+        case 'TSEnumDeclaration': {
+          types[node.id.name] = node;
+          break;
+        }
+      }
+      return types;
+    }, {});
+  }
 }
 module.exports = {
   TypeScriptParser,

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

@@ -10,9 +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';
+import type {TypeDeclarationMap} from '../utils';
+
+// $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('../schema.js');
+const {buildModuleSchema} = require('./modules');
+
+const fs = require('fs');
 
 const {
   UnsupportedObjectPropertyTypeAnnotationParserError,
@@ -21,34 +41,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 +87,158 @@ 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,
+    }));
+  }
+
+  isModuleInterface(node: $FlowFixMe): boolean {
+    return (
+      node.type === 'TSInterfaceDeclaration' &&
+      node.extends?.length === 1 &&
+      node.extends[0].type === 'TSExpressionWithTypeArguments' &&
+      node.extends[0].expression.name === 'TurboModule'
+    );
+  }
+
+  extractAnnotatedElement(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): $FlowFixMe {
+    return types[typeAnnotation.typeParameters.params[0].typeName.name];
+  }
+
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  getTypes(ast: $FlowFixMe): TypeDeclarationMap {
+    return ast.body.reduce((types, node) => {
+      switch (node.type) {
+        case 'ExportNamedDeclaration': {
+          if (node.declaration) {
+            switch (node.declaration.type) {
+              case 'TSTypeAliasDeclaration':
+              case 'TSInterfaceDeclaration':
+              case 'TSEnumDeclaration': {
+                types[node.declaration.id.name] = node.declaration;
+                break;
+              }
+            }
+          }
+          break;
+        }
+        case 'TSTypeAliasDeclaration':
+        case 'TSInterfaceDeclaration':
+        case 'TSEnumDeclaration': {
+          types[node.id.name] = node;
+          break;
+        }
+      }
+      return types;
+    }, {});
+  }
 }
 module.exports = {
   TypeScriptParser,

package/lib/parsers/typescript/utils.js

@@ -13,37 +13,6 @@
 const _require = require('./parseTopLevelType'),
   parseTopLevelType = _require.parseTopLevelType;
 
-/**
- * TODO(T108222691): Use flow-types for @babel/parser
- */
-
-function getTypes(ast) {
-  return ast.body.reduce((types, node) => {
-    switch (node.type) {
-      case 'ExportNamedDeclaration': {
-        if (node.declaration) {
-          switch (node.declaration.type) {
-            case 'TSTypeAliasDeclaration':
-            case 'TSInterfaceDeclaration':
-            case 'TSEnumDeclaration': {
-              types[node.declaration.id.name] = node.declaration;
-              break;
-            }
-          }
-        }
-        break;
-      }
-      case 'TSTypeAliasDeclaration':
-      case 'TSInterfaceDeclaration':
-      case 'TSEnumDeclaration': {
-        types[node.id.name] = node;
-        break;
-      }
-    }
-    return types;
-  }, {});
-}
-
 // $FlowFixMe[unclear-type] Use flow-types for @babel/parser
 
 const invariant = require('invariant');
@@ -61,41 +30,61 @@ 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 = {
   resolveTypeAnnotation,
-  getTypes,
 };