@react-native/codegen 0.72.1 → 0.72.3

package/lib/parsers/parsers-commons.js

@@ -78,25 +78,24 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('./error-utils'),
+const _require = require('./utils'),
+  getConfigType = _require.getConfigType,
+  extractNativeModuleName = _require.extractNativeModuleName,
+  createParserErrorCapturer = _require.createParserErrorCapturer;
+const _require2 = require('./error-utils'),
   throwIfPropertyValueTypeIsUnsupported =
-    _require.throwIfPropertyValueTypeIsUnsupported,
+    _require2.throwIfPropertyValueTypeIsUnsupported,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError =
-    _require.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+    _require2.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError =
-    _require.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
-  throwIfModuleTypeIsUnsupported = _require.throwIfModuleTypeIsUnsupported;
-const _require2 = require('./errors'),
+    _require2.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfModuleTypeIsUnsupported = _require2.throwIfModuleTypeIsUnsupported;
+const _require3 = require('./errors'),
   MissingTypeParameterGenericParserError =
-    _require2.MissingTypeParameterGenericParserError,
+    _require3.MissingTypeParameterGenericParserError,
   MoreThanOneTypeParameterGenericParserError =
-    _require2.MoreThanOneTypeParameterGenericParserError,
-  UnsupportedEnumDeclarationParserError =
-    _require2.UnsupportedEnumDeclarationParserError,
-  UnsupportedGenericParserError = _require2.UnsupportedGenericParserError,
-  UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require2.UnsupportedObjectPropertyTypeAnnotationParserError,
-  UnnamedFunctionParamParserError = _require2.UnnamedFunctionParamParserError;
+    _require3.MoreThanOneTypeParameterGenericParserError,
+  UnnamedFunctionParamParserError = _require3.UnnamedFunctionParamParserError;
 const invariant = require('invariant');
 function wrapModuleSchema(nativeModuleSchema, hasteModuleName) {
   return {
@@ -151,15 +150,9 @@ function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
 function isObjectProperty(property, language) {
   switch (language) {
     case 'Flow':
-      return (
-        property.type === 'ObjectTypeProperty' ||
-        property.type === 'ObjectTypeIndexer'
-      );
+      return property.type === 'ObjectTypeProperty';
     case 'TypeScript':
-      return (
-        property.type === 'TSPropertySignature' ||
-        property.type === 'TSIndexSignature'
-      );
+      return property.type === 'TSPropertySignature';
     default:
       return false;
   }
@@ -169,6 +162,7 @@ function parseObjectProperty(
   hasteModuleName,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
   nullable,
@@ -176,42 +170,23 @@ function parseObjectProperty(
   parser,
 ) {
   const language = parser.language();
-  if (!isObjectProperty(property, language)) {
-    throw new UnsupportedObjectPropertyTypeAnnotationParserError(
-      hasteModuleName,
-      property,
-      property.type,
-      language,
-    );
-  }
+  const name = parser.getKeyName(property, hasteModuleName);
   const _property$optional = property.optional,
     optional = _property$optional === void 0 ? false : _property$optional;
-  const name = parser.getKeyName(property, hasteModuleName);
   const languageTypeAnnotation =
     language === 'TypeScript'
       ? property.typeAnnotation.typeAnnotation
       : property.value;
-  if (
-    property.type === 'ObjectTypeIndexer' ||
-    property.type === 'TSIndexSignature'
-  ) {
-    return {
-      name,
-      optional,
-      typeAnnotation: wrapNullable(nullable, {
-        type: 'GenericObjectTypeAnnotation',
-      }), //TODO: use `emitObject` for typeAnnotation
-    };
-  }
-
   const _unwrapNullable = unwrapNullable(
       translateTypeAnnotation(
         hasteModuleName,
         languageTypeAnnotation,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
+        parser,
       ),
     ),
     _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
@@ -227,7 +202,6 @@ function parseObjectProperty(
       languageTypeAnnotation,
       property.key,
       propertyTypeAnnotation.type,
-      language,
     );
   }
   return {
@@ -236,92 +210,38 @@ function parseObjectProperty(
     typeAnnotation: wrapNullable(isPropertyNullable, propertyTypeAnnotation),
   };
 }
-function translateDefault(
-  hasteModuleName,
-  typeAnnotation,
-  types,
-  nullable,
-  parser,
-) {
-  const maybeEnumDeclaration =
-    types[parser.nameForGenericTypeAnnotation(typeAnnotation)];
-  if (maybeEnumDeclaration && parser.isEnumDeclaration(maybeEnumDeclaration)) {
-    const memberType = parser.getMaybeEnumMemberType(maybeEnumDeclaration);
-    if (
-      memberType === 'NumberTypeAnnotation' ||
-      memberType === 'StringTypeAnnotation'
-    ) {
-      return wrapNullable(nullable, {
-        type: 'EnumDeclaration',
-        memberType: memberType,
-      });
-    } else {
-      throw new UnsupportedEnumDeclarationParserError(
-        hasteModuleName,
-        typeAnnotation,
-        memberType,
-        parser.language(),
-      );
-    }
-  }
-  throw new UnsupportedGenericParserError(
-    hasteModuleName,
-    typeAnnotation,
-    parser,
-  );
-}
-function getTypeAnnotationParameters(typeAnnotation, language) {
-  return language === 'Flow'
-    ? typeAnnotation.params
-    : typeAnnotation.parameters;
-}
-function getFunctionNameFromParameter(param, language) {
-  return language === 'Flow' ? param.name : param.typeAnnotation;
-}
-function getParameterName(param, language) {
-  return language === 'Flow' ? param.name.name : param.name;
-}
-function getParameterTypeAnnotation(param, language) {
-  return language === 'Flow'
-    ? param.typeAnnotation
-    : param.typeAnnotation.typeAnnotation;
-}
-function getTypeAnnotationReturnType(typeAnnotation, language) {
-  return language === 'Flow'
-    ? typeAnnotation.returnType
-    : typeAnnotation.typeAnnotation.typeAnnotation;
-}
 function translateFunctionTypeAnnotation(
   hasteModuleName,
   // TODO(T108222691): Use flow-types for @babel/parser
   // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.
-  typeAnnotation,
+  functionTypeAnnotation,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
   translateTypeAnnotation,
-  language,
+  parser,
 ) {
   const params = [];
-  for (const param of getTypeAnnotationParameters(typeAnnotation, language)) {
+  for (const param of parser.getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation,
+  )) {
     const parsedParam = tryParse(() => {
-      if (getFunctionNameFromParameter(param, language) == null) {
-        throw new UnnamedFunctionParamParserError(
-          param,
-          hasteModuleName,
-          language,
-        );
+      if (parser.getFunctionNameFromParameter(param) == null) {
+        throw new UnnamedFunctionParamParserError(param, hasteModuleName);
       }
-      const paramName = getParameterName(param, language);
+      const paramName = parser.getParameterName(param);
       const _unwrapNullable3 = unwrapNullable(
           translateTypeAnnotation(
             hasteModuleName,
-            getParameterTypeAnnotation(param, language),
+            parser.getParameterTypeAnnotation(param),
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
+            parser,
           ),
         ),
         _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 2),
@@ -354,11 +274,13 @@ function translateFunctionTypeAnnotation(
   const _unwrapNullable5 = unwrapNullable(
       translateTypeAnnotation(
         hasteModuleName,
-        getTypeAnnotationReturnType(typeAnnotation, language),
+        parser.getFunctionTypeAnnotationReturnType(functionTypeAnnotation),
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
+        parser,
       ),
     ),
     _unwrapNullable6 = _slicedToArray(_unwrapNullable5, 2),
@@ -366,9 +288,8 @@ function translateFunctionTypeAnnotation(
     isReturnTypeAnnotationNullable = _unwrapNullable6[1];
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
     hasteModuleName,
-    typeAnnotation,
+    functionTypeAnnotation,
     'FunctionTypeAnnotation',
-    language,
     cxxOnly,
     returnTypeAnnotation.type,
   );
@@ -391,17 +312,18 @@ function buildPropertySchema(
   property,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
-  language,
   resolveTypeAnnotation,
   translateTypeAnnotation,
+  parser,
 ) {
   let nullable = false;
   let key = property.key,
     value = property.value;
   const methodName = key.name;
-  if (language === 'TypeScript') {
+  if (parser.language() === 'TypeScript') {
     value =
       property.type === 'TSMethodSignature'
         ? property
@@ -415,7 +337,7 @@ function buildPropertySchema(
     property.value,
     key.name,
     value.type,
-    language,
+    parser.language(),
   );
   return {
     name: methodName,
@@ -427,14 +349,93 @@ function buildPropertySchema(
         value,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
         translateTypeAnnotation,
-        language,
+        parser,
       ),
     ),
   };
 }
+function buildSchemaFromConfigType(
+  configType,
+  filename,
+  ast,
+  wrapComponentSchema,
+  buildComponentSchema,
+  buildModuleSchema,
+  parser,
+) {
+  switch (configType) {
+    case 'component': {
+      return wrapComponentSchema(buildComponentSchema(ast, parser));
+    }
+    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, parser),
+      );
+      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 buildSchema(
+  contents,
+  filename,
+  wrapComponentSchema,
+  buildComponentSchema,
+  buildModuleSchema,
+  Visitor,
+  parser,
+) {
+  // Early return for non-Spec JavaScript files
+  if (
+    !contents.includes('codegenNativeComponent') &&
+    !contents.includes('TurboModule')
+  ) {
+    return {
+      modules: {},
+    };
+  }
+  const ast = parser.getAst(contents);
+  const configType = getConfigType(ast, Visitor);
+  return buildSchemaFromConfigType(
+    configType,
+    filename,
+    ast,
+    wrapComponentSchema,
+    buildComponentSchema,
+    buildModuleSchema,
+    parser,
+  );
+}
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -442,7 +443,8 @@ module.exports = {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   isObjectProperty,
   parseObjectProperty,
-  translateDefault,
   translateFunctionTypeAnnotation,
   buildPropertySchema,
+  buildSchemaFromConfigType,
+  buildSchema,
 };