@react-native/codegen - npm Package Compare versions

Comparing version 0.72.3 to 0.72.4

lib/CodegenSchema.d.ts

@@ -50,3 +50,3 @@ /**
   readonly properties: readonly NamedShape<T>[];
-  readonly baseTypes?: readonly string[];
+  readonly baseTypes?: readonly string[] | undefined;
 }
@@ -81,6 +81,6 @@
 export interface OptionsShape {
-  readonly interfaceOnly?: boolean;
-  readonly paperComponentName?: string;
-  readonly excludedPlatforms?: readonly PlatformType[];
-  readonly paperComponentNameDeprecated?: string;
+  readonly interfaceOnly?: boolean | undefined;
+  readonly paperComponentName?: string | undefined;
+  readonly excludedPlatforms?: readonly PlatformType[] | undefined;
+  readonly paperComponentNameDeprecated?: string | undefined;
 }
@@ -99,6 +99,6 @@
   readonly optional: boolean;
-  readonly paperTopLevelNameDeprecated?: string;
+  readonly paperTopLevelNameDeprecated?: string | undefined;
   readonly typeAnnotation: {
     readonly type: 'EventTypeAnnotation';
-    readonly argument?: ObjectTypeAnnotation<EventTypeAnnotation>;
+    readonly argument?: ObjectTypeAnnotation<EventTypeAnnotation> | undefined;
   };
@@ -217,3 +217,3 @@ }
   readonly moduleName: string;
-  readonly excludedPlatforms?: readonly PlatformType[];
+  readonly excludedPlatforms?: readonly PlatformType[] | undefined;
 }
@@ -241,3 +241,3 @@
   readonly type: 'ArrayTypeAnnotation';
-  readonly elementType?: T;
+  readonly elementType?: T | undefined;
 }
@@ -302,3 +302,3 @@
   readonly type: 'PromiseTypeAnnotation';
-  readonly elementType?: Nullable<NativeModuleBaseTypeAnnotation>;
+  readonly elementType?: Nullable<NativeModuleBaseTypeAnnotation> | undefined;
 }
@@ -305,0 +305,0 @@

lib/generators/components/__test_fixtures__/fixtures.js

@@ -1105,2 +1105,30 @@ /**
 };
+const MIXED_PROP = {
+  modules: {
+    CustomView: {
+      type: 'Component',
+      components: {
+        MixedPropNativeComponent: {
+          extendsProps: [
+            {
+              type: 'ReactNativeBuiltInType',
+              knownTypeName: 'ReactNativeCoreViewProps',
+            },
+          ],
+          events: [],
+          props: [
+            {
+              name: 'mixedProp',
+              optional: false,
+              typeAnnotation: {
+                type: 'MixedTypeAnnotation',
+              },
+            },
+          ],
+          commands: [],
+        },
+      },
+    },
+  },
+};
 const EVENT_PROPS = {
@@ -1673,2 +1701,3 @@ modules: {
   INT32_ENUM_PROP,
+  MIXED_PROP,
   EVENT_PROPS,
@@ -1675,0 +1704,0 @@ EVENTS_WITH_PAPER_NAME,

lib/generators/components/ComponentsGeneratorUtils.js

@@ -87,2 +87,4 @@ /**
       return getEnumName(componentName, prop.name);
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
     default:
@@ -89,0 +91,0 @@ typeAnnotation;

lib/generators/components/CppHelpers.js

@@ -168,2 +168,4 @@ /**
       )}`;
+    case 'MixedTypeAnnotation':
+      return '';
     default:
@@ -170,0 +172,0 @@ typeAnnotation;

lib/generators/components/GeneratePropsH.js

@@ -525,2 +525,4 @@ /**
         return;
+      case 'MixedTypeAnnotation':
+        return;
       default:
@@ -527,0 +529,0 @@ property.typeAnnotation.type;

lib/generators/components/GeneratePropsJavaDelegate.js

@@ -123,2 +123,4 @@ /**
       return `value == null ? ${typeAnnotation.default} : ((Double) value).intValue()`;
+    case 'MixedTypeAnnotation':
+      return 'new DynamicFromObject(value)';
     default:
@@ -125,0 +127,0 @@ typeAnnotation;

lib/generators/components/GeneratePropsJavaInterface.js

@@ -108,2 +108,4 @@ /**
       return '@Nullable Integer value';
+    case 'MixedTypeAnnotation':
+      return 'Dynamic value';
     default:
@@ -110,0 +112,0 @@ typeAnnotation;

lib/generators/components/GeneratePropsJavaPojo/serializePojo.js

@@ -21,2 +21,3 @@ /**
   const importYogaValue = () => addImport('com.facebook.yoga.YogaValue');
+  const importDynamic = () => addImport('com.facebook.react.bridge.Dynamic');
   switch (typeAnnotation.type) {
@@ -212,2 +213,6 @@ /**
     }
+    case 'MixedTypeAnnotation': {
+      importDynamic();
+      return 'Dynamic';
+    }
     default: {
@@ -214,0 +219,0 @@ typeAnnotation.type;

lib/generators/components/GenerateViewConfigJs.js

@@ -49,2 +49,3 @@ /**
     case 'Int32EnumTypeAnnotation':
+    case 'MixedTypeAnnotation':
       return j.literal(true);
@@ -51,0 +52,0 @@ case 'ReservedPropTypeAnnotation':

lib/generators/components/JavaHelpers.js

@@ -88,2 +88,9 @@ /**
     }
+    if (typeAnnotation.type === 'MixedTypeAnnotation') {
+      if (type === 'delegate') {
+        imports.add('import com.facebook.react.bridge.DynamicFromObject;');
+      } else {
+        imports.add('import com.facebook.react.bridge.Dynamic;');
+      }
+    }
   });
@@ -90,0 +97,0 @@ return imports;

lib/generators/RNCodegen.js

@@ -31,4 +31,4 @@ /**
 const generateModuleJavaSpec = require('./modules/GenerateModuleJavaSpec.js');
-const GenerateModuleJniCpp = require('./modules/GenerateModuleJniCpp.js');
-const GenerateModuleJniH = require('./modules/GenerateModuleJniH.js');
+const generateModuleJniCpp = require('./modules/GenerateModuleJniCpp.js');
+const generateModuleJniH = require('./modules/GenerateModuleJniH.js');
 const generatePropsJavaInterface = require('./components/GeneratePropsJavaInterface.js');
@@ -44,2 +44,28 @@ const generatePropsJavaDelegate = require('./components/GeneratePropsJavaDelegate.js');
 const schemaValidator = require('../SchemaValidator.js');
+const ALL_GENERATORS = {
+  generateComponentDescriptorH: generateComponentDescriptorH.generate,
+  generateComponentHObjCpp: generateComponentHObjCpp.generate,
+  generateEventEmitterCpp: generateEventEmitterCpp.generate,
+  generateEventEmitterH: generateEventEmitterH.generate,
+  generatePropsCpp: generatePropsCpp.generate,
+  generatePropsH: generatePropsH.generate,
+  generateStateCpp: generateStateCpp.generate,
+  generateStateH: generateStateH.generate,
+  generateModuleH: generateModuleH.generate,
+  generateModuleCpp: generateModuleCpp.generate,
+  generateModuleObjCpp: generateModuleObjCpp.generate,
+  generateModuleJavaSpec: generateModuleJavaSpec.generate,
+  generateModuleJniCpp: generateModuleJniCpp.generate,
+  generateModuleJniH: generateModuleJniH.generate,
+  generatePropsJavaInterface: generatePropsJavaInterface.generate,
+  generatePropsJavaDelegate: generatePropsJavaDelegate.generate,
+  generateTests: generateTests.generate,
+  generateShadowNodeCpp: generateShadowNodeCpp.generate,
+  generateShadowNodeH: generateShadowNodeH.generate,
+  generateThirdPartyFabricComponentsProviderObjCpp:
+    generateThirdPartyFabricComponentsProviderObjCpp.generate,
+  generateThirdPartyFabricComponentsProviderH:
+    generateThirdPartyFabricComponentsProviderH.generate,
+  generateViewConfigJs: generateViewConfigJs.generate,
+};
 const LIBRARY_GENERATORS = {
@@ -85,4 +111,4 @@ descriptors: [generateComponentDescriptorH.generate],
   modulesAndroid: [
-    GenerateModuleJniCpp.generate,
-    GenerateModuleJniH.generate,
+    generateModuleJniCpp.generate,
+    generateModuleJniH.generate,
     generateModuleJavaSpec.generate,
@@ -142,2 +168,5 @@ ],
 module.exports = {
+  allGenerators: ALL_GENERATORS,
+  libraryGenerators: LIBRARY_GENERATORS,
+  schemaGenerators: SCHEMAS_GENERATORS,
   generate(
@@ -144,0 +173,0 @@ {libraryName, schema, outputDirectory, packageName, assumeNonnull},

lib/parsers/error-utils.js

@@ -160,5 +160,5 @@ /**
   propertyValueType,
-  language,
+  parser,
 ) {
-  if (language === 'Flow' && propertyValueType !== 'FunctionTypeAnnotation') {
+  if (!parser.functionTypeAnnotation(propertyValueType)) {
     throw new UnsupportedModulePropertyParserError(
@@ -169,16 +169,4 @@ nativeModuleName,
       propertyValueType,
-      language,
+      parser.language(),
     );
-  } else if (
-    language === 'TypeScript' &&
-    propertyValueType !== 'TSFunctionType' &&
-    propertyValueType !== 'TSMethodSignature'
-  ) {
-    throw new UnsupportedModulePropertyParserError(
-      nativeModuleName,
-      propertyValue,
-      propertyName,
-      propertyValueType,
-      language,
-    );
   }
@@ -292,2 +280,7 @@ }
 }
+function throwIfMoreThanOneCodegenNativecommands(commandsTypeNames) {
+  if (commandsTypeNames.length > 1) {
+    throw new Error('codegenNativeCommands may only be called once in a file');
+  }
+}
 module.exports = {
@@ -310,2 +303,3 @@ throwIfModuleInterfaceIsMisnamed,
   throwIfPartialWithMoreParameter,
+  throwIfMoreThanOneCodegenNativecommands,
 };

lib/parsers/flow/components/__test_fixtures__/fixtures.js

@@ -208,3 +208,3 @@ /**
 
-import type {Int32, Double, Float, WithDefault} from 'CodegenTypes';
+import type {Int32, Double, Float, WithDefault, UnsafeMixed} from 'CodegenTypes';
 import type {ImageSource} from 'ImageSource';
@@ -317,2 +317,6 @@ import type {ColorValue, ColorArrayValue, PointValue, EdgeInsetsValue, DimensionValue} from 'StyleSheetTypes';
   dimension_optional_both?: ?DimensionValue,
+
+  // Mixed props
+  mixed_required: UnsafeMixed,
+  mixed_optional_key?: UnsafeMixed,
 |}>;
@@ -319,0 +323,0 @@

lib/parsers/flow/components/componentsUtils.js

@@ -367,2 +367,6 @@ /**
       );
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
     default:
@@ -369,0 +373,0 @@ type;

lib/parsers/flow/components/index.js

@@ -13,64 +13,2 @@ /**
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly &&
-      (symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      })),
-      keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2
-      ? ownKeys(Object(source), !0).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        })
-      : Object.getOwnPropertyDescriptors
-      ? Object.defineProperties(
-          target,
-          Object.getOwnPropertyDescriptors(source),
-        )
-      : ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(
-            target,
-            key,
-            Object.getOwnPropertyDescriptor(source, key),
-          );
-        });
-  }
-  return target;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, 'string');
-  return typeof key === 'symbol' ? key : String(key);
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== 'object' || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || 'default');
-    if (typeof res !== 'object') return res;
-    throw new TypeError('@@toPrimitive must return a primitive value.');
-  }
-  return (hint === 'string' ? String : Number)(input);
-}
 const _require = require('./commands'),
@@ -83,13 +21,17 @@ getCommands = _require.getCommands;
   removeKnownExtends = _require3.removeKnownExtends;
-const _require4 = require('./options'),
-  getCommandOptions = _require4.getCommandOptions,
-  getOptions = _require4.getOptions;
-const _require5 = require('./props'),
-  getProps = _require5.getProps;
-const _require6 = require('./componentsUtils.js'),
-  getProperties = _require6.getProperties;
+const _require4 = require('./props'),
+  getProps = _require4.getProps;
+const _require5 = require('./componentsUtils.js'),
+  getProperties = _require5.getProperties;
+const _require6 = require('../../error-utils'),
+  throwIfMoreThanOneCodegenNativecommands =
+    _require6.throwIfMoreThanOneCodegenNativecommands;
+const _require7 = require('../../parsers-commons'),
+  createComponentConfig = _require7.createComponentConfig,
+  findNativeComponentType = _require7.findNativeComponentType,
+  getCommandOptions = _require7.getCommandOptions,
+  getOptions = _require7.getOptions;
 
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function findComponentConfig(ast) {
+// $FlowFixMe[signature-verification-failure] there's no flowtype for AST
+function findComponentConfig(ast, parser) {
   const foundConfigs = [];
@@ -100,25 +42,3 @@ const defaultExports = ast.body.filter(
   defaultExports.forEach(statement => {
-    let declaration = statement.declaration;
-
-    // codegenNativeComponent can be nested inside a cast
-    // expression so we need to go one level deeper
-    if (declaration.type === 'TypeCastExpression') {
-      declaration = declaration.expression;
-    }
-    try {
-      if (declaration.callee.name === 'codegenNativeComponent') {
-        const typeArgumentParams = declaration.typeArguments.params;
-        const funcArgumentParams = declaration.arguments;
-        const nativeComponentType = {
-          propsTypeName: typeArgumentParams[0].id.name,
-          componentName: funcArgumentParams[0].value,
-        };
-        if (funcArgumentParams.length > 1) {
-          nativeComponentType.optionsExpression = funcArgumentParams[1];
-        }
-        foundConfigs.push(nativeComponentType);
-      }
-    } catch (e) {
-      // ignore
-    }
+    findNativeComponentType(statement, foundConfigs, parser);
   });
@@ -167,19 +87,4 @@ if (foundConfigs.length === 0) {
     .filter(Boolean);
-  if (commandsTypeNames.length > 1) {
-    throw new Error('codegenNativeCommands may only be called once in a file');
-  }
-  return _objectSpread(
-    _objectSpread({}, foundConfig),
-    {},
-    {
-      commandTypeName:
-        commandsTypeNames[0] == null
-          ? null
-          : commandsTypeNames[0].commandTypeName,
-      commandOptionsExpression:
-        commandsTypeNames[0] == null
-          ? null
-          : commandsTypeNames[0].commandOptionsExpression,
-    },
-  );
+  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
+  return createComponentConfig(foundConfig, commandsTypeNames);
 }
@@ -235,3 +140,3 @@ function getCommandProperties(
 function buildComponentSchema(ast, parser) {
-  const _findComponentConfig = findComponentConfig(ast),
+  const _findComponentConfig = findComponentConfig(ast, parser),
     componentName = _findComponentConfig.componentName,
@@ -238,0 +143,0 @@ propsTypeName = _findComponentConfig.propsTypeName,

lib/parsers/flow/modules/__test_fixtures__/fixtures.js

@@ -305,4 +305,4 @@ /**
   +getSomeObj: () => SomeObj;
-  +getPartialSomeObj: () => $Partial<SomeObj>;
-  +getSomeObjFromPartialSomeObj: (value: $Partial<SomeObj>) => SomeObj;
+  +getPartialSomeObj: () => Partial<SomeObj>;
+  +getSomeObjFromPartialSomeObj: (value: Partial<SomeObj>) => SomeObj;
 }
@@ -334,6 +334,6 @@
 
-export type PartialSomeObj = $Partial<SomeObj>;
+export type PartialSomeObj = Partial<SomeObj>;
 
 export interface Spec extends TurboModule {
-  +getPartialPartial: (value1: $Partial<SomeObj>, value2: PartialSomeObj) => SomeObj
+  +getPartialPartial: (value1: Partial<SomeObj>, value2: PartialSomeObj) => SomeObj
 }
@@ -340,0 +340,0 @@

lib/parsers/flow/modules/index.js

@@ -13,64 +13,2 @@ /**
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly &&
-      (symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      })),
-      keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2
-      ? ownKeys(Object(source), !0).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        })
-      : Object.getOwnPropertyDescriptors
-      ? Object.defineProperties(
-          target,
-          Object.getOwnPropertyDescriptors(source),
-        )
-      : ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(
-            target,
-            key,
-            Object.getOwnPropertyDescriptor(source, key),
-          );
-        });
-  }
-  return target;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, 'string');
-  return typeof key === 'symbol' ? key : String(key);
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== 'object' || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || 'default');
-    if (typeof res !== 'object') return res;
-    throw new TypeError('@@toPrimitive must return a primitive value.');
-  }
-  return (hint === 'string' ? String : Number)(input);
-}
 function _slicedToArray(arr, i) {
@@ -144,58 +82,29 @@ return (
 }
-const _require = require('../../utils'),
-  visit = _require.visit,
-  isModuleRegistryCall = _require.isModuleRegistryCall,
-  verifyPlatforms = _require.verifyPlatforms;
-const _require2 = require('../utils'),
-  resolveTypeAnnotation = _require2.resolveTypeAnnotation;
-const _require3 = require('../../parsers-commons'),
-  unwrapNullable = _require3.unwrapNullable,
-  wrapNullable = _require3.wrapNullable,
+const _require = require('../utils'),
+  resolveTypeAnnotation = _require.resolveTypeAnnotation;
+const _require2 = require('../../parsers-commons'),
+  unwrapNullable = _require2.unwrapNullable,
+  wrapNullable = _require2.wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter =
-    _require3.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  parseObjectProperty = _require3.parseObjectProperty,
-  buildPropertySchema = _require3.buildPropertySchema;
-const _require4 = require('../../parsers-primitives'),
-  emitArrayType = _require4.emitArrayType,
-  emitBoolean = _require4.emitBoolean,
-  emitDouble = _require4.emitDouble,
-  emitFloat = _require4.emitFloat,
-  emitFunction = _require4.emitFunction,
-  emitNumber = _require4.emitNumber,
-  emitInt32 = _require4.emitInt32,
-  emitGenericObject = _require4.emitGenericObject,
-  emitObject = _require4.emitObject,
-  emitPromise = _require4.emitPromise,
-  emitRootTag = _require4.emitRootTag,
-  emitVoid = _require4.emitVoid,
-  emitString = _require4.emitString,
-  emitStringish = _require4.emitStringish,
-  emitMixed = _require4.emitMixed,
-  emitUnion = _require4.emitUnion,
-  typeAliasResolution = _require4.typeAliasResolution,
-  typeEnumResolution = _require4.typeEnumResolution;
-const _require5 = require('../../errors'),
+    _require2.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty = _require2.parseObjectProperty;
+const _require3 = require('../../parsers-primitives'),
+  emitArrayType = _require3.emitArrayType,
+  emitBoolean = _require3.emitBoolean,
+  emitFunction = _require3.emitFunction,
+  emitNumber = _require3.emitNumber,
+  emitGenericObject = _require3.emitGenericObject,
+  emitPromise = _require3.emitPromise,
+  emitRootTag = _require3.emitRootTag,
+  emitVoid = _require3.emitVoid,
+  emitString = _require3.emitString,
+  emitMixed = _require3.emitMixed,
+  emitUnion = _require3.emitUnion,
+  emitCommonTypes = _require3.emitCommonTypes,
+  typeAliasResolution = _require3.typeAliasResolution,
+  typeEnumResolution = _require3.typeEnumResolution;
+const _require4 = require('../../errors'),
   UnsupportedTypeAnnotationParserError =
-    _require5.UnsupportedTypeAnnotationParserError,
-  UnsupportedGenericParserError = _require5.UnsupportedGenericParserError;
-const _require6 = require('../../error-utils'),
-  throwIfModuleInterfaceNotFound = _require6.throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed = _require6.throwIfModuleInterfaceIsMisnamed,
-  throwIfUnusedModuleInterfaceParserError =
-    _require6.throwIfUnusedModuleInterfaceParserError,
-  throwIfWrongNumberOfCallExpressionArgs =
-    _require6.throwIfWrongNumberOfCallExpressionArgs,
-  throwIfMoreThanOneModuleRegistryCalls =
-    _require6.throwIfMoreThanOneModuleRegistryCalls,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require6.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
-  throwIfIncorrectModuleRegistryCallArgument =
-    _require6.throwIfIncorrectModuleRegistryCallArgument,
-  throwIfUntypedModule = _require6.throwIfUntypedModule,
-  throwIfMoreThanOneModuleInterfaceParserError =
-    _require6.throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfPartialNotAnnotatingTypeParameter =
-    _require6.throwIfPartialNotAnnotatingTypeParameter,
-  throwIfPartialWithMoreParameter = _require6.throwIfPartialWithMoreParameter;
-const language = 'Flow';
+    _require4.UnsupportedTypeAnnotationParserError,
+  UnsupportedGenericParserError = _require4.UnsupportedGenericParserError;
 function translateTypeAnnotation(
@@ -278,53 +187,22 @@ hasteModuleName,
         }
-        case 'Stringish': {
-          return emitStringish(nullable);
-        }
-        case 'Int32': {
-          return emitInt32(nullable);
-        }
-        case 'Double': {
-          return emitDouble(nullable);
-        }
-        case 'Float': {
-          return emitFloat(nullable);
-        }
-        case 'UnsafeObject':
-        case 'Object': {
-          return emitGenericObject(nullable);
-        }
-        case '$Partial': {
-          throwIfPartialWithMoreParameter(typeAnnotation);
-          const annotatedElement = parser.extractAnnotatedElement(
-            typeAnnotation,
-            types,
-          );
-          throwIfPartialNotAnnotatingTypeParameter(
-            typeAnnotation,
-            types,
-            parser,
-          );
-          const properties = annotatedElement.right.properties.map(prop => {
-            return {
-              name: prop.key.name,
-              optional: true,
-              typeAnnotation: translateTypeAnnotation(
-                hasteModuleName,
-                prop.value,
-                types,
-                aliasMap,
-                enumMap,
-                tryParse,
-                cxxOnly,
-                parser,
-              ),
-            };
-          });
-          return emitObject(nullable, properties);
-        }
         default: {
-          throw new UnsupportedGenericParserError(
+          const commonType = emitCommonTypes(
             hasteModuleName,
+            types,
             typeAnnotation,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            nullable,
             parser,
           );
+          if (!commonType) {
+            throw new UnsupportedGenericParserError(
+              hasteModuleName,
+              typeAnnotation,
+              parser,
+            );
+          }
+          return commonType;
         }
@@ -436,3 +314,2 @@ }
         hasteModuleName,
-        language,
         enumMap,
@@ -446,3 +323,3 @@ parser,
         typeAnnotation,
-        language,
+        parser.language(),
       );
@@ -452,147 +329,4 @@ }
 }
-function buildModuleSchema(
-  hasteModuleName,
-  /**
-   * TODO(T71778680): Flow-type this node.
-   */
-  ast,
-  tryParse,
-  parser,
-) {
-  const types = parser.getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(t =>
-    parser.isModuleInterface(t),
-  );
-  throwIfModuleInterfaceNotFound(
-    moduleSpecs.length,
-    hasteModuleName,
-    ast,
-    language,
-  );
-  throwIfMoreThanOneModuleInterfaceParserError(
-    hasteModuleName,
-    moduleSpecs,
-    language,
-  );
-  const _moduleSpecs = _slicedToArray(moduleSpecs, 1),
-    moduleSpec = _moduleSpecs[0];
-  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
-
-  // Parse Module Name
-  const moduleName = (() => {
-    const callExpressions = [];
-    visit(ast, {
-      CallExpression(node) {
-        if (isModuleRegistryCall(node)) {
-          callExpressions.push(node);
-        }
-      },
-    });
-    throwIfUnusedModuleInterfaceParserError(
-      hasteModuleName,
-      moduleSpec,
-      callExpressions,
-    );
-    throwIfMoreThanOneModuleRegistryCalls(
-      hasteModuleName,
-      callExpressions,
-      callExpressions.length,
-    );
-    const callExpression = callExpressions[0];
-    const typeArguments = callExpression.typeArguments;
-    const methodName = callExpression.callee.property.name;
-    throwIfWrongNumberOfCallExpressionArgs(
-      hasteModuleName,
-      callExpression,
-      methodName,
-      callExpression.arguments.length,
-    );
-    throwIfIncorrectModuleRegistryCallArgument(
-      hasteModuleName,
-      callExpression.arguments[0],
-      methodName,
-    );
-    const $moduleName = callExpression.arguments[0].value;
-    throwIfUntypedModule(
-      typeArguments,
-      hasteModuleName,
-      callExpression,
-      methodName,
-      $moduleName,
-    );
-    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
-      hasteModuleName,
-      typeArguments,
-      methodName,
-      $moduleName,
-      parser,
-    );
-    return $moduleName;
-  })();
-
-  // Some module names use platform suffix to indicate platform-exclusive modules.
-  // Eventually this should be made explicit in the Flow type itself.
-  // Also check the hasteModuleName for platform suffix.
-  // Note: this shape is consistent with ComponentSchema.
-  const _verifyPlatforms = verifyPlatforms(hasteModuleName, moduleName),
-    cxxOnly = _verifyPlatforms.cxxOnly,
-    excludedPlatforms = _verifyPlatforms.excludedPlatforms;
-
-  // $FlowFixMe[missing-type-arg]
-  return moduleSpec.body.properties
-    .filter(property => property.type === 'ObjectTypeProperty')
-    .map(property => {
-      const aliasMap = {};
-      const enumMap = {};
-      return tryParse(() => ({
-        aliasMap: aliasMap,
-        enumMap: enumMap,
-        propertyShape: buildPropertySchema(
-          hasteModuleName,
-          property,
-          types,
-          aliasMap,
-          enumMap,
-          tryParse,
-          cxxOnly,
-          resolveTypeAnnotation,
-          translateTypeAnnotation,
-          parser,
-        ),
-      }));
-    })
-    .filter(Boolean)
-    .reduce(
-      (moduleSchema, {aliasMap, enumMap, propertyShape}) => ({
-        type: 'NativeModule',
-        aliasMap: _objectSpread(
-          _objectSpread({}, moduleSchema.aliasMap),
-          aliasMap,
-        ),
-        enumMap: _objectSpread(
-          _objectSpread({}, moduleSchema.enumMap),
-          enumMap,
-        ),
-        spec: {
-          properties: [...moduleSchema.spec.properties, propertyShape],
-        },
-        moduleName: moduleSchema.moduleName,
-        excludedPlatforms: moduleSchema.excludedPlatforms,
-      }),
-      {
-        type: 'NativeModule',
-        aliasMap: {},
-        enumMap: {},
-        spec: {
-          properties: [],
-        },
-        moduleName,
-        excludedPlatforms:
-          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
-      },
-    );
-}
 module.exports = {
-  buildModuleSchema,
   flowTranslateTypeAnnotation: translateTypeAnnotation,
 };

lib/parsers/flow/parser.js

@@ -41,18 +41,23 @@ /**
 }
+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 {
@@ -115,2 +120,4 @@ constructor() {
       this,
+      resolveTypeAnnotation,
+      flowTranslateTypeAnnotation,
     );
@@ -249,2 +256,51 @@ }
   }
+  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;
+  }
 }
@@ -251,0 +307,0 @@ module.exports = {

lib/parsers/parser.d.ts

@@ -8,4 +8,4 @@ /**
 
-import type { SchemaType } from "../CodegenSchema";
-import type { ParserType } from "./errors";
+import type { SchemaType } from '../CodegenSchema';
+import type { ParserType } from './errors';
 
@@ -12,0 +12,0 @@ // useful members only for downstream

lib/parsers/parserMock.js

@@ -167,2 +167,46 @@ /**
   }
+  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;
+  }
 }

lib/parsers/parsers-commons.js

@@ -13,2 +13,64 @@ /**
 
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly &&
+      (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })),
+      keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2
+      ? ownKeys(Object(source), !0).forEach(function (key) {
+          _defineProperty(target, key, source[key]);
+        })
+      : Object.getOwnPropertyDescriptors
+      ? Object.defineProperties(
+          target,
+          Object.getOwnPropertyDescriptors(source),
+        )
+      : ownKeys(Object(source)).forEach(function (key) {
+          Object.defineProperty(
+            target,
+            key,
+            Object.getOwnPropertyDescriptor(source, key),
+          );
+        });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, 'string');
+  return typeof key === 'symbol' ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== 'object' || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || 'default');
+    if (typeof res !== 'object') return res;
+    throw new TypeError('@@toPrimitive must return a primitive value.');
+  }
+  return (hint === 'string' ? String : Number)(input);
+}
 function _slicedToArray(arr, i) {
@@ -85,3 +147,6 @@ return (
   extractNativeModuleName = _require.extractNativeModuleName,
-  createParserErrorCapturer = _require.createParserErrorCapturer;
+  createParserErrorCapturer = _require.createParserErrorCapturer,
+  visit = _require.visit,
+  isModuleRegistryCall = _require.isModuleRegistryCall,
+  verifyPlatforms = _require.verifyPlatforms;
 const _require2 = require('./error-utils'),
@@ -94,3 +159,18 @@ throwIfPropertyValueTypeIsUnsupported =
     _require2.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
-  throwIfModuleTypeIsUnsupported = _require2.throwIfModuleTypeIsUnsupported;
+  throwIfModuleTypeIsUnsupported = _require2.throwIfModuleTypeIsUnsupported,
+  throwIfUnusedModuleInterfaceParserError =
+    _require2.throwIfUnusedModuleInterfaceParserError,
+  throwIfMoreThanOneModuleRegistryCalls =
+    _require2.throwIfMoreThanOneModuleRegistryCalls,
+  throwIfWrongNumberOfCallExpressionArgs =
+    _require2.throwIfWrongNumberOfCallExpressionArgs,
+  throwIfUntypedModule = _require2.throwIfUntypedModule,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
+    _require2.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument =
+    _require2.throwIfIncorrectModuleRegistryCallArgument,
+  throwIfModuleInterfaceNotFound = _require2.throwIfModuleInterfaceNotFound,
+  throwIfMoreThanOneModuleInterfaceParserError =
+    _require2.throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfModuleInterfaceIsMisnamed = _require2.throwIfModuleInterfaceIsMisnamed;
 const _require3 = require('./errors'),
@@ -343,3 +423,3 @@ MissingTypeParameterGenericParserError =
     value.type,
-    parser.language(),
+    parser,
   );
@@ -373,2 +453,4 @@ return {
   parser,
+  resolveTypeAnnotation,
+  translateTypeAnnotation,
 ) {
@@ -389,3 +471,10 @@ switch (configType) {
       const schema = tryParse(() =>
-        buildModuleSchema(nativeModuleName, ast, tryParse, parser),
+        buildModuleSchema(
+          nativeModuleName,
+          ast,
+          tryParse,
+          parser,
+          resolveTypeAnnotation,
+          translateTypeAnnotation,
+        ),
       );
@@ -423,2 +512,4 @@ if (parsingErrors.length > 0) {
   parser,
+  resolveTypeAnnotation,
+  translateTypeAnnotation,
 ) {
@@ -444,4 +535,264 @@ // Early return for non-Spec JavaScript files
     parser,
+    resolveTypeAnnotation,
+    translateTypeAnnotation,
   );
 }
+function createComponentConfig(foundConfig, commandsTypeNames) {
+  return _objectSpread(
+    _objectSpread({}, foundConfig),
+    {},
+    {
+      commandTypeName:
+        commandsTypeNames[0] == null
+          ? null
+          : commandsTypeNames[0].commandTypeName,
+      commandOptionsExpression:
+        commandsTypeNames[0] == null
+          ? null
+          : commandsTypeNames[0].commandOptionsExpression,
+    },
+  );
+}
+const parseModuleName = (hasteModuleName, moduleSpec, ast, parser) => {
+  const callExpressions = [];
+  visit(ast, {
+    CallExpression(node) {
+      if (isModuleRegistryCall(node)) {
+        callExpressions.push(node);
+      }
+    },
+  });
+  throwIfUnusedModuleInterfaceParserError(
+    hasteModuleName,
+    moduleSpec,
+    callExpressions,
+  );
+  throwIfMoreThanOneModuleRegistryCalls(
+    hasteModuleName,
+    callExpressions,
+    callExpressions.length,
+  );
+  const callExpression = callExpressions[0];
+  const typeParameters = parser.callExpressionTypeParameters(callExpression);
+  const methodName = callExpression.callee.property.name;
+  throwIfWrongNumberOfCallExpressionArgs(
+    hasteModuleName,
+    callExpression,
+    methodName,
+    callExpression.arguments.length,
+  );
+  throwIfIncorrectModuleRegistryCallArgument(
+    hasteModuleName,
+    callExpression.arguments[0],
+    methodName,
+  );
+  const $moduleName = callExpression.arguments[0].value;
+  throwIfUntypedModule(
+    typeParameters,
+    hasteModuleName,
+    callExpression,
+    methodName,
+    $moduleName,
+  );
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError(
+    hasteModuleName,
+    typeParameters,
+    methodName,
+    $moduleName,
+    parser,
+  );
+  return $moduleName;
+};
+const buildModuleSchema = (
+  hasteModuleName,
+  ast,
+  tryParse,
+  parser,
+  resolveTypeAnnotation,
+  translateTypeAnnotation,
+) => {
+  const language = parser.language();
+  const types = parser.getTypes(ast);
+  const moduleSpecs = Object.values(types).filter(t =>
+    parser.isModuleInterface(t),
+  );
+  throwIfModuleInterfaceNotFound(
+    moduleSpecs.length,
+    hasteModuleName,
+    ast,
+    language,
+  );
+  throwIfMoreThanOneModuleInterfaceParserError(
+    hasteModuleName,
+    moduleSpecs,
+    language,
+  );
+  const _moduleSpecs = _slicedToArray(moduleSpecs, 1),
+    moduleSpec = _moduleSpecs[0];
+  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
+
+  // Parse Module Name
+  const moduleName = parseModuleName(hasteModuleName, moduleSpec, ast, parser);
+
+  // Some module names use platform suffix to indicate platform-exclusive modules.
+  // Eventually this should be made explicit in the Flow type itself.
+  // Also check the hasteModuleName for platform suffix.
+  // Note: this shape is consistent with ComponentSchema.
+  const _verifyPlatforms = verifyPlatforms(hasteModuleName, moduleName),
+    cxxOnly = _verifyPlatforms.cxxOnly,
+    excludedPlatforms = _verifyPlatforms.excludedPlatforms;
+  const properties =
+    language === 'Flow' ? moduleSpec.body.properties : moduleSpec.body.body;
+
+  // $FlowFixMe[missing-type-arg]
+  return properties
+    .filter(
+      property =>
+        property.type === 'ObjectTypeProperty' ||
+        property.type === 'TSPropertySignature' ||
+        property.type === 'TSMethodSignature',
+    )
+    .map(property => {
+      const aliasMap = {};
+      const enumMap = {};
+      return tryParse(() => ({
+        aliasMap,
+        enumMap,
+        propertyShape: buildPropertySchema(
+          hasteModuleName,
+          property,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          resolveTypeAnnotation,
+          translateTypeAnnotation,
+          parser,
+        ),
+      }));
+    })
+    .filter(Boolean)
+    .reduce(
+      (moduleSchema, {aliasMap, enumMap, propertyShape}) => ({
+        type: 'NativeModule',
+        aliasMap: _objectSpread(
+          _objectSpread({}, moduleSchema.aliasMap),
+          aliasMap,
+        ),
+        enumMap: _objectSpread(
+          _objectSpread({}, moduleSchema.enumMap),
+          enumMap,
+        ),
+        spec: {
+          properties: [...moduleSchema.spec.properties, propertyShape],
+        },
+        moduleName: moduleSchema.moduleName,
+        excludedPlatforms: moduleSchema.excludedPlatforms,
+      }),
+      {
+        type: 'NativeModule',
+        aliasMap: {},
+        enumMap: {},
+        spec: {
+          properties: [],
+        },
+        moduleName,
+        excludedPlatforms:
+          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
+      },
+    );
+};
+
+/**
+ * This function is used to find the type of a native component
+ * provided the default exports statement from generated AST.
+ * @param statement The statement to be parsed.
+ * @param foundConfigs The 'mutable' array of configs that have been found.
+ * @param parser The language parser to be used.
+ * @returns void
+ */
+function findNativeComponentType(statement, foundConfigs, parser) {
+  let declaration = statement.declaration;
+
+  // codegenNativeComponent can be nested inside a cast
+  // expression so we need to go one level deeper
+  if (
+    declaration.type === 'TSAsExpression' ||
+    declaration.type === 'TypeCastExpression'
+  ) {
+    declaration = declaration.expression;
+  }
+  try {
+    if (declaration.callee.name === 'codegenNativeComponent') {
+      const typeArgumentParams =
+        parser.getTypeArgumentParamsFromDeclaration(declaration);
+      const funcArgumentParams = declaration.arguments;
+      const nativeComponentType = parser.getNativeComponentType(
+        typeArgumentParams,
+        funcArgumentParams,
+      );
+      if (funcArgumentParams.length > 1) {
+        nativeComponentType.optionsExpression = funcArgumentParams[1];
+      }
+      foundConfigs.push(nativeComponentType);
+    }
+  } catch (e) {
+    // ignore
+  }
+}
+function getCommandOptions(commandOptionsExpression) {
+  if (commandOptionsExpression == null) {
+    return null;
+  }
+  let foundOptions;
+  try {
+    foundOptions = commandOptionsExpression.properties.reduce(
+      (options, prop) => {
+        options[prop.key.name] = (
+          (prop && prop.value && prop.value.elements) ||
+          []
+        ).map(element => element && element.value);
+        return options;
+      },
+      {},
+    );
+  } catch (e) {
+    throw new Error(
+      'Failed to parse command options, please check that they are defined correctly',
+    );
+  }
+  return foundOptions;
+}
+function getOptions(optionsExpression) {
+  if (!optionsExpression) {
+    return null;
+  }
+  let foundOptions;
+  try {
+    foundOptions = optionsExpression.properties.reduce((options, prop) => {
+      if (prop.value.type === 'ArrayExpression') {
+        options[prop.key.name] = prop.value.elements.map(
+          element => element.value,
+        );
+      } else {
+        options[prop.key.name] = prop.value.value;
+      }
+      return options;
+    }, {});
+  } catch (e) {
+    throw new Error(
+      'Failed to parse codegen options, please check that they are defined correctly',
+    );
+  }
+  if (
+    foundOptions.paperComponentName &&
+    foundOptions.paperComponentNameDeprecated
+  ) {
+    throw new Error(
+      'Failed to parse codegen options, cannot use both paperComponentName and paperComponentNameDeprecated',
+    );
+  }
+  return foundOptions;
+}
 module.exports = {
@@ -458,2 +809,8 @@ wrapModuleSchema,
   buildSchema,
+  createComponentConfig,
+  parseModuleName,
+  buildModuleSchema,
+  findNativeComponentType,
+  getCommandOptions,
+  getOptions,
 };

lib/parsers/parsers-primitives.js

@@ -89,3 +89,6 @@ /**
   throwIfArrayElementTypeAnnotationIsUnsupported =
-    _require2.throwIfArrayElementTypeAnnotationIsUnsupported;
+    _require2.throwIfArrayElementTypeAnnotationIsUnsupported,
+  throwIfPartialNotAnnotatingTypeParameter =
+    _require2.throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter = _require2.throwIfPartialWithMoreParameter;
 const _require3 = require('./parsers-utils'),
@@ -99,2 +102,4 @@ nullGuard = _require3.nullGuard;
   translateFunctionTypeAnnotation = _require4.translateFunctionTypeAnnotation;
+const _require5 = require('./utils'),
+  isModuleRegistryCall = _require5.isModuleRegistryCall;
 function emitBoolean(nullable) {
@@ -225,3 +230,2 @@ return wrapNullable(nullable, {
   hasteModuleName,
-  language,
   enumMap,
@@ -234,3 +238,3 @@ parser,
       typeAnnotation,
-      language,
+      parser.language(),
     );
@@ -434,2 +438,111 @@ }
 }
+function Visitor(infoMap) {
+  return {
+    CallExpression(node) {
+      if (
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'codegenNativeComponent'
+      ) {
+        infoMap.isComponent = true;
+      }
+      if (isModuleRegistryCall(node)) {
+        infoMap.isModule = true;
+      }
+    },
+    InterfaceExtends(node) {
+      if (node.id.name === 'TurboModule') {
+        infoMap.isModule = true;
+      }
+    },
+    TSInterfaceDeclaration(node) {
+      if (
+        Array.isArray(node.extends) &&
+        node.extends.some(
+          extension => extension.expression.name === 'TurboModule',
+        )
+      ) {
+        infoMap.isModule = true;
+      }
+    },
+  };
+}
+function emitPartial(
+  hasteModuleName,
+  typeAnnotation,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  nullable,
+  parser,
+) {
+  throwIfPartialWithMoreParameter(typeAnnotation);
+  throwIfPartialNotAnnotatingTypeParameter(typeAnnotation, types, parser);
+  const annotatedElement = parser.extractAnnotatedElement(
+    typeAnnotation,
+    types,
+  );
+  const annotatedElementProperties =
+    parser.getAnnotatedElementProperties(annotatedElement);
+  const partialProperties = parser.computePartialProperties(
+    annotatedElementProperties,
+    hasteModuleName,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+  );
+  return emitObject(nullable, partialProperties);
+}
+function emitCommonTypes(
+  hasteModuleName,
+  types,
+  typeAnnotation,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  nullable,
+  parser,
+) {
+  const genericTypeAnnotationName =
+    parser.nameForGenericTypeAnnotation(typeAnnotation);
+  switch (genericTypeAnnotationName) {
+    case 'Stringish': {
+      return emitStringish(nullable);
+    }
+    case 'Int32': {
+      return emitInt32(nullable);
+    }
+    case 'Double': {
+      return emitDouble(nullable);
+    }
+    case 'Float': {
+      return emitFloat(nullable);
+    }
+    case 'UnsafeObject':
+    case 'Object': {
+      return emitGenericObject(nullable);
+    }
+    case '$Partial':
+    case 'Partial': {
+      return emitPartial(
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
+      );
+    }
+    default: {
+      return null;
+    }
+  }
+}
 module.exports = {
@@ -452,5 +565,8 @@ emitArrayType,
   emitUnion,
+  emitPartial,
+  emitCommonTypes,
   typeAliasResolution,
   typeEnumResolution,
   translateArrayTypeAnnotation,
+  Visitor,
 };

lib/parsers/schema/index.d.ts

@@ -8,4 +8,4 @@ /**
 
-import type { SchemaType } from "../../CodegenSchema";
+import type { SchemaType } from '../../CodegenSchema';
 
 export declare function parse(filename: string): SchemaType | undefined;

lib/parsers/typescript/components/__test_fixtures__/fixtures.js

@@ -196,3 +196,3 @@ /**
 
-import type {Int32, Double, Float, WithDefault} from 'CodegenTypes';
+import type {Int32, Double, Float, WithDefault, UnsafeMixed} from 'CodegenTypes';
 import type {ImageSource} from 'ImageSource';
@@ -310,2 +310,6 @@ import type {
   dimension_optional_both?: DimensionValue | null | undefined;
+
+  // Mixed props
+  mixed_required: UnsafeMixed,
+  mixed_optional_key?: UnsafeMixed,
 }
@@ -312,0 +316,0 @@

lib/parsers/typescript/components/componentsUtils.js

@@ -255,2 +255,6 @@ /**
       };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
     default:
@@ -393,2 +397,6 @@ return undefined;
       );
+    case 'TSFunctionType':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": must use a specific function type like BubblingEventHandler, or DirectEventHandler`,
+      );
     default:
@@ -395,0 +403,0 @@ type;

lib/parsers/typescript/components/index.js

@@ -13,64 +13,2 @@ /**
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly &&
-      (symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      })),
-      keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2
-      ? ownKeys(Object(source), !0).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        })
-      : Object.getOwnPropertyDescriptors
-      ? Object.defineProperties(
-          target,
-          Object.getOwnPropertyDescriptors(source),
-        )
-      : ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(
-            target,
-            key,
-            Object.getOwnPropertyDescriptor(source, key),
-          );
-        });
-  }
-  return target;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, 'string');
-  return typeof key === 'symbol' ? key : String(key);
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== 'object' || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || 'default');
-    if (typeof res !== 'object') return res;
-    throw new TypeError('@@toPrimitive must return a primitive value.');
-  }
-  return (hint === 'string' ? String : Number)(input);
-}
 const _require = require('./commands'),
@@ -82,13 +20,17 @@ getCommands = _require.getCommands;
   categorizeProps = _require3.categorizeProps;
-const _require4 = require('./options'),
-  getCommandOptions = _require4.getCommandOptions,
-  getOptions = _require4.getOptions;
-const _require5 = require('./props'),
-  getProps = _require5.getProps;
-const _require6 = require('./componentsUtils.js'),
-  getProperties = _require6.getProperties;
+const _require4 = require('./props'),
+  getProps = _require4.getProps;
+const _require5 = require('./componentsUtils.js'),
+  getProperties = _require5.getProperties;
+const _require6 = require('../../error-utils'),
+  throwIfMoreThanOneCodegenNativecommands =
+    _require6.throwIfMoreThanOneCodegenNativecommands;
+const _require7 = require('../../parsers-commons'),
+  createComponentConfig = _require7.createComponentConfig,
+  findNativeComponentType = _require7.findNativeComponentType,
+  getCommandOptions = _require7.getCommandOptions,
+  getOptions = _require7.getOptions;
 
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function findComponentConfig(ast) {
+// $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
+function findComponentConfig(ast, parser) {
   const foundConfigs = [];
@@ -98,27 +40,5 @@ const defaultExports = ast.body.filter(
   );
-  defaultExports.forEach(statement => {
-    let declaration = statement.declaration;
-
-    // codegenNativeComponent can be nested inside a cast
-    // expression so we need to go one level deeper
-    if (declaration.type === 'TSAsExpression') {
-      declaration = declaration.expression;
-    }
-    try {
-      if (declaration.callee.name === 'codegenNativeComponent') {
-        const typeArgumentParams = declaration.typeParameters.params;
-        const funcArgumentParams = declaration.arguments;
-        const nativeComponentType = {
-          propsTypeName: typeArgumentParams[0].typeName.name,
-          componentName: funcArgumentParams[0].value,
-        };
-        if (funcArgumentParams.length > 1) {
-          nativeComponentType.optionsExpression = funcArgumentParams[1];
-        }
-        foundConfigs.push(nativeComponentType);
-      }
-    } catch (e) {
-      // ignore
-    }
-  });
+  defaultExports.forEach(statement =>
+    findNativeComponentType(statement, foundConfigs, parser),
+  );
   if (foundConfigs.length === 0) {
@@ -166,19 +86,4 @@ throw new Error('Could not find component config for native component');
     .filter(Boolean);
-  if (commandsTypeNames.length > 1) {
-    throw new Error('codegenNativeCommands may only be called once in a file');
-  }
-  return _objectSpread(
-    _objectSpread({}, foundConfig),
-    {},
-    {
-      commandTypeName:
-        commandsTypeNames[0] == null
-          ? null
-          : commandsTypeNames[0].commandTypeName,
-      commandOptionsExpression:
-        commandsTypeNames[0] == null
-          ? null
-          : commandsTypeNames[0].commandOptionsExpression,
-    },
-  );
+  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
+  return createComponentConfig(foundConfig, commandsTypeNames);
 }
@@ -237,3 +142,3 @@ function getCommandProperties(
 function buildComponentSchema(ast, parser) {
-  const _findComponentConfig = findComponentConfig(ast),
+  const _findComponentConfig = findComponentConfig(ast, parser),
     componentName = _findComponentConfig.componentName,
@@ -240,0 +145,0 @@ propsTypeName = _findComponentConfig.propsTypeName,

lib/parsers/typescript/modules/index.js

@@ -13,132 +13,2 @@ /**
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly &&
-      (symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      })),
-      keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2
-      ? ownKeys(Object(source), !0).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        })
-      : Object.getOwnPropertyDescriptors
-      ? Object.defineProperties(
-          target,
-          Object.getOwnPropertyDescriptors(source),
-        )
-      : ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(
-            target,
-            key,
-            Object.getOwnPropertyDescriptor(source, key),
-          );
-        });
-  }
-  return target;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, 'string');
-  return typeof key === 'symbol' ? key : String(key);
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== 'object' || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || 'default');
-    if (typeof res !== 'object') return res;
-    throw new TypeError('@@toPrimitive must return a primitive value.');
-  }
-  return (hint === 'string' ? String : Number)(input);
-}
-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('../parseTopLevelType'),
@@ -148,56 +18,26 @@ flattenIntersectionType = _require.flattenIntersectionType;
   flattenProperties = _require2.flattenProperties;
-const _require3 = require('../../utils'),
-  visit = _require3.visit,
-  isModuleRegistryCall = _require3.isModuleRegistryCall,
-  verifyPlatforms = _require3.verifyPlatforms;
-const _require4 = require('../utils'),
-  resolveTypeAnnotation = _require4.resolveTypeAnnotation;
-const _require5 = require('../../parsers-commons'),
-  parseObjectProperty = _require5.parseObjectProperty,
-  buildPropertySchema = _require5.buildPropertySchema;
-const _require6 = require('../../parsers-primitives'),
-  typeEnumResolution = _require6.typeEnumResolution;
-const _require7 = require('../../parsers-primitives'),
-  emitArrayType = _require7.emitArrayType,
-  emitBoolean = _require7.emitBoolean,
-  emitDouble = _require7.emitDouble,
-  emitFloat = _require7.emitFloat,
-  emitFunction = _require7.emitFunction,
-  emitNumber = _require7.emitNumber,
-  emitInt32 = _require7.emitInt32,
-  emitGenericObject = _require7.emitGenericObject,
-  emitObject = _require7.emitObject,
-  emitPromise = _require7.emitPromise,
-  emitRootTag = _require7.emitRootTag,
-  emitVoid = _require7.emitVoid,
-  emitString = _require7.emitString,
-  emitStringish = _require7.emitStringish,
-  emitMixed = _require7.emitMixed,
-  emitUnion = _require7.emitUnion,
-  typeAliasResolution = _require7.typeAliasResolution,
-  translateArrayTypeAnnotation = _require7.translateArrayTypeAnnotation;
-const _require8 = require('../../errors'),
-  UnsupportedGenericParserError = _require8.UnsupportedGenericParserError,
+const _require3 = require('../utils'),
+  resolveTypeAnnotation = _require3.resolveTypeAnnotation;
+const _require4 = require('../../parsers-commons'),
+  parseObjectProperty = _require4.parseObjectProperty;
+const _require5 = require('../../parsers-primitives'),
+  emitArrayType = _require5.emitArrayType,
+  emitBoolean = _require5.emitBoolean,
+  emitFunction = _require5.emitFunction,
+  emitNumber = _require5.emitNumber,
+  emitGenericObject = _require5.emitGenericObject,
+  emitPromise = _require5.emitPromise,
+  emitRootTag = _require5.emitRootTag,
+  emitVoid = _require5.emitVoid,
+  emitString = _require5.emitString,
+  emitMixed = _require5.emitMixed,
+  emitUnion = _require5.emitUnion,
+  emitCommonTypes = _require5.emitCommonTypes,
+  typeAliasResolution = _require5.typeAliasResolution,
+  typeEnumResolution = _require5.typeEnumResolution,
+  translateArrayTypeAnnotation = _require5.translateArrayTypeAnnotation;
+const _require6 = require('../../errors'),
+  UnsupportedGenericParserError = _require6.UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError =
-    _require8.UnsupportedTypeAnnotationParserError;
-const _require9 = require('../../error-utils'),
-  throwIfUntypedModule = _require9.throwIfUntypedModule,
-  throwIfUnusedModuleInterfaceParserError =
-    _require9.throwIfUnusedModuleInterfaceParserError,
-  throwIfModuleInterfaceNotFound = _require9.throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed = _require9.throwIfModuleInterfaceIsMisnamed,
-  throwIfWrongNumberOfCallExpressionArgs =
-    _require9.throwIfWrongNumberOfCallExpressionArgs,
-  throwIfMoreThanOneModuleRegistryCalls =
-    _require9.throwIfMoreThanOneModuleRegistryCalls,
-  throwIfMoreThanOneModuleInterfaceParserError =
-    _require9.throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require9.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
-  throwIfIncorrectModuleRegistryCallArgument =
-    _require9.throwIfIncorrectModuleRegistryCallArgument,
-  throwIfPartialNotAnnotatingTypeParameter =
-    _require9.throwIfPartialNotAnnotatingTypeParameter,
-  throwIfPartialWithMoreParameter = _require9.throwIfPartialWithMoreParameter;
-const language = 'TypeScript';
+    _require6.UnsupportedTypeAnnotationParserError;
 function translateObjectTypeAnnotation(
@@ -258,2 +98,69 @@ hasteModuleName,
 }
+function translateTypeReferenceAnnotation(
+  typeName,
+  nullable,
+  typeAnnotation,
+  hasteModuleName,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  parser,
+) {
+  switch (typeName) {
+    case 'RootTag': {
+      return emitRootTag(nullable);
+    }
+    case 'Promise': {
+      return emitPromise(
+        hasteModuleName,
+        typeAnnotation,
+        parser,
+        nullable,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+      );
+    }
+    case 'Array':
+    case 'ReadonlyArray': {
+      return emitArrayType(
+        hasteModuleName,
+        typeAnnotation,
+        parser,
+        types,
+        aliasMap,
+        enumMap,
+        cxxOnly,
+        nullable,
+        translateTypeAnnotation,
+      );
+    }
+    default: {
+      const commonType = emitCommonTypes(
+        hasteModuleName,
+        types,
+        typeAnnotation,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
+      );
+      if (!commonType) {
+        throw new UnsupportedGenericParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser,
+        );
+      }
+      return commonType;
+    }
+  }
+}
 function translateTypeAnnotation(
@@ -320,89 +227,14 @@ hasteModuleName,
     case 'TSTypeReference': {
-      switch (typeAnnotation.typeName.name) {
-        case 'RootTag': {
-          return emitRootTag(nullable);
-        }
-        case 'Promise': {
-          return emitPromise(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-            nullable,
-            types,
-            aliasMap,
-            enumMap,
-            tryParse,
-            cxxOnly,
-            translateTypeAnnotation,
-          );
-        }
-        case 'Array':
-        case 'ReadonlyArray': {
-          return emitArrayType(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-            types,
-            aliasMap,
-            enumMap,
-            cxxOnly,
-            nullable,
-            translateTypeAnnotation,
-          );
-        }
-        case 'Stringish': {
-          return emitStringish(nullable);
-        }
-        case 'Int32': {
-          return emitInt32(nullable);
-        }
-        case 'Double': {
-          return emitDouble(nullable);
-        }
-        case 'Float': {
-          return emitFloat(nullable);
-        }
-        case 'UnsafeObject':
-        case 'Object': {
-          return emitGenericObject(nullable);
-        }
-        case 'Partial': {
-          throwIfPartialWithMoreParameter(typeAnnotation);
-          const annotatedElement = parser.extractAnnotatedElement(
-            typeAnnotation,
-            types,
-          );
-          throwIfPartialNotAnnotatingTypeParameter(
-            typeAnnotation,
-            types,
-            parser,
-          );
-          const properties = annotatedElement.typeAnnotation.members.map(
-            member => {
-              return {
-                name: member.key.name,
-                optional: true,
-                typeAnnotation: translateTypeAnnotation(
-                  hasteModuleName,
-                  member.typeAnnotation.typeAnnotation,
-                  types,
-                  aliasMap,
-                  enumMap,
-                  tryParse,
-                  cxxOnly,
-                  parser,
-                ),
-              };
-            },
-          );
-          return emitObject(nullable, properties);
-        }
-        default: {
-          throw new UnsupportedGenericParserError(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-          );
-        }
-      }
+      return translateTypeReferenceAnnotation(
+        typeAnnotation.typeName.name,
+        nullable,
+        typeAnnotation,
+        hasteModuleName,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
     }
@@ -512,3 +344,2 @@ case 'TSInterfaceDeclaration': {
         hasteModuleName,
-        language,
         enumMap,
@@ -558,3 +389,3 @@ parser,
         typeAnnotation,
-        language,
+        parser.language(),
       );
@@ -564,153 +395,4 @@ }
 }
-function buildModuleSchema(
-  hasteModuleName,
-  /**
-   * TODO(T108222691): Use flow-types for @babel/parser
-   */
-  ast,
-  tryParse,
-  parser,
-) {
-  const types = parser.getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(t =>
-    parser.isModuleInterface(t),
-  );
-  throwIfModuleInterfaceNotFound(
-    moduleSpecs.length,
-    hasteModuleName,
-    ast,
-    language,
-  );
-  throwIfMoreThanOneModuleInterfaceParserError(
-    hasteModuleName,
-    moduleSpecs,
-    language,
-  );
-  const _moduleSpecs = _slicedToArray(moduleSpecs, 1),
-    moduleSpec = _moduleSpecs[0];
-  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
-
-  // Parse Module Name
-  const moduleName = (() => {
-    const callExpressions = [];
-    visit(ast, {
-      CallExpression(node) {
-        if (isModuleRegistryCall(node)) {
-          callExpressions.push(node);
-        }
-      },
-    });
-    throwIfUnusedModuleInterfaceParserError(
-      hasteModuleName,
-      moduleSpec,
-      callExpressions,
-    );
-    throwIfMoreThanOneModuleRegistryCalls(
-      hasteModuleName,
-      callExpressions,
-      callExpressions.length,
-    );
-    const callExpression = callExpressions[0];
-    const typeParameters = callExpression.typeParameters;
-    const methodName = callExpression.callee.property.name;
-    throwIfWrongNumberOfCallExpressionArgs(
-      hasteModuleName,
-      callExpression,
-      methodName,
-      callExpression.arguments.length,
-    );
-    throwIfIncorrectModuleRegistryCallArgument(
-      hasteModuleName,
-      callExpression.arguments[0],
-      methodName,
-    );
-    const $moduleName = callExpression.arguments[0].value;
-    throwIfUntypedModule(
-      typeParameters,
-      hasteModuleName,
-      callExpression,
-      methodName,
-      $moduleName,
-    );
-    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
-      hasteModuleName,
-      typeParameters,
-      methodName,
-      $moduleName,
-      parser,
-    );
-    return $moduleName;
-  })();
-
-  // Some module names use platform suffix to indicate platform-exclusive modules.
-  // Eventually this should be made explicit in the Flow type itself.
-  // Also check the hasteModuleName for platform suffix.
-  // Note: this shape is consistent with ComponentSchema.
-  const _verifyPlatforms = verifyPlatforms(hasteModuleName, moduleName),
-    cxxOnly = _verifyPlatforms.cxxOnly,
-    excludedPlatforms = _verifyPlatforms.excludedPlatforms;
-
-  // $FlowFixMe[missing-type-arg]
-  return moduleSpec.body.body
-    .filter(
-      property =>
-        property.type === 'TSMethodSignature' ||
-        property.type === 'TSPropertySignature',
-    )
-    .map(property => {
-      const aliasMap = {};
-      const enumMap = {};
-      return tryParse(() => ({
-        aliasMap: aliasMap,
-        enumMap: enumMap,
-        propertyShape: buildPropertySchema(
-          hasteModuleName,
-          property,
-          types,
-          aliasMap,
-          enumMap,
-          tryParse,
-          cxxOnly,
-          resolveTypeAnnotation,
-          translateTypeAnnotation,
-          parser,
-        ),
-      }));
-    })
-    .filter(Boolean)
-    .reduce(
-      (moduleSchema, {aliasMap, enumMap, propertyShape}) => {
-        return {
-          type: 'NativeModule',
-          aliasMap: _objectSpread(
-            _objectSpread({}, moduleSchema.aliasMap),
-            aliasMap,
-          ),
-          enumMap: _objectSpread(
-            _objectSpread({}, moduleSchema.enumMap),
-            enumMap,
-          ),
-          spec: {
-            properties: [...moduleSchema.spec.properties, propertyShape],
-          },
-          moduleName: moduleSchema.moduleName,
-          excludedPlatforms: moduleSchema.excludedPlatforms,
-        };
-      },
-      {
-        type: 'NativeModule',
-        aliasMap: {},
-        enumMap: {},
-        spec: {
-          properties: [],
-        },
-        moduleName: moduleName,
-        excludedPlatforms:
-          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
-      },
-    );
-}
 module.exports = {
-  buildModuleSchema,
   typeScriptTranslateTypeAnnotation: translateTypeAnnotation,
 };

lib/parsers/typescript/parser.js

@@ -41,18 +41,24 @@ /**
 }
+const _require = require('./modules'),
+  typeScriptTranslateTypeAnnotation =
+    _require.typeScriptTranslateTypeAnnotation;
+
 // $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 _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 TypeScriptParser {
@@ -117,2 +123,4 @@ constructor() {
       this,
+      resolveTypeAnnotation,
+      typeScriptTranslateTypeAnnotation,
     );
@@ -254,2 +262,51 @@ }
   }
+  callExpressionTypeParameters(callExpression) {
+    return callExpression.typeParameters || null;
+  }
+  computePartialProperties(
+    properties,
+    hasteModuleName,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+  ) {
+    return properties.map(prop => {
+      return {
+        name: prop.key.name,
+        optional: true,
+        typeAnnotation: typeScriptTranslateTypeAnnotation(
+          hasteModuleName,
+          prop.typeAnnotation.typeAnnotation,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          this,
+        ),
+      };
+    });
+  }
+  functionTypeAnnotation(propertyValueType) {
+    return (
+      propertyValueType === 'TSFunctionType' ||
+      propertyValueType === 'TSMethodSignature'
+    );
+  }
+  getTypeArgumentParamsFromDeclaration(declaration) {
+    return declaration.typeParameters.params;
+  }
+
+  // This FlowFixMe is supposed to refer to typeArgumentParams and funcArgumentParams of generated AST.
+  getNativeComponentType(typeArgumentParams, funcArgumentParams) {
+    return {
+      propsTypeName: typeArgumentParams[0].typeName.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+  getAnnotatedElementProperties(annotatedElement) {
+    return annotatedElement.typeAnnotation.members;
+  }
 }
@@ -256,0 +313,0 @@ module.exports = {

lib/parsers/utils.js

@@ -22,2 +22,3 @@ /**
 function createParserErrorCapturer() {
+  // $FlowFixMe[missing-empty-array-annot]
   const errors = [];
@@ -31,2 +32,3 @@ function guard(fn) {
       }
+      // $FlowFixMe[incompatible-call]
       errors.push(error);
@@ -36,2 +38,4 @@ return null;
   }
+
+  // $FlowFixMe[incompatible-return]
   return [errors, guard];
@@ -38,0 +42,0 @@ }

lib/SchemaValidator.d.ts

@@ -8,5 +8,5 @@ /**
 
-import type { SchemaType } from "./CodegenSchema";
+import type { SchemaType } from './CodegenSchema';
 
 export declare function getErrors(schema: SchemaType): readonly string[];
 export declare function validate(schema: SchemaType): void;

package.json

 {
   "name": "@react-native/codegen",
-  "version": "0.72.3",
+  "version": "0.72.4",
   "description": "⚛️ Code generation tools for React Native",
@@ -5,0 +5,0 @@ "homepage": "https://github.com/facebook/react-native/tree/HEAD/packages/react-native-codegen",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

1447873

decreased by-0.1%

Number of package files

184

decreased by-3.66%

Lines of code

23422

decreased by-0.75%

No dependency changes