@react-native/codegen 0.72.2 → 0.72.4

package/lib/parsers/parsers-primitives.js.flow

@@ -34,7 +34,6 @@ import type {
   NativeModuleObjectTypeAnnotation,
   NativeModuleEnumDeclaration,
 } from '../CodegenSchema';
-import type {ParserType} from './errors';
 import type {Parser} from './parser';
 import type {
   ParserErrorCapturer,
@@ -50,6 +49,8 @@ const {
 
 const {
   throwIfArrayElementTypeAnnotationIsUnsupported,
+  throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter,
 } = require('./error-utils');
 const {nullGuard} = require('./parsers-utils');
 const {
@@ -59,6 +60,8 @@ const {
   translateFunctionTypeAnnotation,
 } = require('./parsers-commons');
 
+const {isModuleRegistryCall} = require('./utils');
+
 function emitBoolean(nullable: boolean): Nullable<BooleanTypeAnnotation> {
   return wrapNullable(nullable, {
     type: 'BooleanTypeAnnotation',
@@ -204,7 +207,6 @@ function typeEnumResolution(
   typeResolution: TypeResolutionStatus,
   nullable: boolean,
   hasteModuleName: string,
-  language: ParserType,
   enumMap: {...NativeModuleEnumMap},
   parser: Parser,
 ): Nullable<NativeModuleEnumDeclaration> {
@@ -212,7 +214,7 @@ function typeEnumResolution(
     throw new UnsupportedTypeAnnotationParserError(
       hasteModuleName,
       typeAnnotation,
-      language,
+      parser.language(),
     );
   }
 
@@ -439,6 +441,126 @@ function emitArrayType(
   );
 }
 
+function Visitor(infoMap: {isComponent: boolean, isModule: boolean}): {
+  [type: string]: (node: $FlowFixMe) => void,
+} {
+  return {
+    CallExpression(node: $FlowFixMe) {
+      if (
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'codegenNativeComponent'
+      ) {
+        infoMap.isComponent = true;
+      }
+
+      if (isModuleRegistryCall(node)) {
+        infoMap.isModule = true;
+      }
+    },
+    InterfaceExtends(node: $FlowFixMe) {
+      if (node.id.name === 'TurboModule') {
+        infoMap.isModule = true;
+      }
+    },
+    TSInterfaceDeclaration(node: $FlowFixMe) {
+      if (
+        Array.isArray(node.extends) &&
+        node.extends.some(
+          extension => extension.expression.name === 'TurboModule',
+        )
+      ) {
+        infoMap.isModule = true;
+      }
+    },
+  };
+}
+
+function emitPartial(
+  hasteModuleName: string,
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  nullable: boolean,
+  parser: Parser,
+): Nullable<NativeModuleTypeAnnotation> {
+  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: string,
+  types: TypeDeclarationMap,
+  typeAnnotation: $FlowFixMe,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  nullable: boolean,
+  parser: Parser,
+): $FlowFixMe {
+  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 = {
   emitArrayType,
   emitBoolean,
@@ -456,7 +578,10 @@ module.exports = {
   emitStringish,
   emitMixed,
   emitUnion,
+  emitPartial,
+  emitCommonTypes,
   typeAliasResolution,
   typeEnumResolution,
   translateArrayTypeAnnotation,
+  Visitor,
 };

package/lib/parsers/schema/index.d.ts

@@ -5,6 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { SchemaType } from "../../CodegenSchema";
+import type { SchemaType } from '../../CodegenSchema';
 
 export declare function parse(filename: string): SchemaType | undefined;

package/lib/parsers/{typescript/components/schema.js.flow → schema.js.flow}

@@ -18,7 +18,7 @@ import type {
   ExtendsPropsShape,
   SchemaType,
   OptionsShape,
-} from '../../../CodegenSchema.js';
+} from '../CodegenSchema.js';
 
 export type ComponentSchemaBuilderConfig = $ReadOnly<{
   filename: string,

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

@@ -193,7 +193,7 @@ const ALL_PROP_TYPES_NO_EVENTS = `
 
 const codegenNativeComponent = require('codegenNativeComponent');
 
-import type {Int32, Double, Float, WithDefault} from 'CodegenTypes';
+import type {Int32, Double, Float, WithDefault, UnsafeMixed} from 'CodegenTypes';
 import type {ImageSource} from 'ImageSource';
 import type {
   ColorValue,
@@ -306,6 +306,10 @@ export interface ModuleProps extends ViewProps {
   dimension_optional_key?: DimensionValue;
   dimension_optional_value: DimensionValue | null | undefined;
   dimension_optional_both?: DimensionValue | null | undefined;
+
+  // Mixed props
+  mixed_required: UnsafeMixed,
+  mixed_optional_key?: UnsafeMixed,
 }
 
 export default codegenNativeComponent<ModuleProps>(

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

@@ -197,7 +197,7 @@ const ALL_PROP_TYPES_NO_EVENTS = `
 
 const codegenNativeComponent = require('codegenNativeComponent');
 
-import type {Int32, Double, Float, WithDefault} from 'CodegenTypes';
+import type {Int32, Double, Float, WithDefault, UnsafeMixed} from 'CodegenTypes';
 import type {ImageSource} from 'ImageSource';
 import type {
   ColorValue,
@@ -310,6 +310,10 @@ export interface ModuleProps extends ViewProps {
   dimension_optional_key?: DimensionValue;
   dimension_optional_value: DimensionValue | null | undefined;
   dimension_optional_both?: DimensionValue | null | undefined;
+
+  // Mixed props
+  mixed_required: UnsafeMixed,
+  mixed_optional_key?: UnsafeMixed,
 }
 
 export default codegenNativeComponent<ModuleProps>(

package/lib/parsers/typescript/components/componentsUtils.js

@@ -252,6 +252,10 @@ function getCommonTypeAnnotation(
       return {
         type: 'StringTypeAnnotation',
       };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
     default:
       return undefined;
   }
@@ -389,6 +393,10 @@ function getTypeAnnotation(name, annotation, defaultValue, types, buildSchema) {
       throw new Error(
         `Cannot use "${type}" type annotation for "${name}": must use a specific numeric type like Int32, Double, or Float`,
       );
+    case 'TSFunctionType':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": must use a specific function type like BubblingEventHandler, or DirectEventHandler`,
+      );
     default:
       type;
       throw new Error(`Unknown prop type for "${name}": "${type}"`);

package/lib/parsers/typescript/components/componentsUtils.js.flow

@@ -262,6 +262,10 @@ function getCommonTypeAnnotation<T>(
       return {
         type: 'StringTypeAnnotation',
       };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
     default:
       return undefined;
   }
@@ -416,6 +420,10 @@ function getTypeAnnotation<T>(
       throw new Error(
         `Cannot use "${type}" type annotation for "${name}": must use a specific numeric type like Int32, Double, or Float`,
       );
+    case 'TSFunctionType':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": must use a specific function type like BubblingEventHandler, or DirectEventHandler`,
+      );
     default:
       (type: empty);
       throw new Error(`Unknown prop type for "${name}": "${type}"`);

package/lib/parsers/typescript/components/index.js

@@ -10,116 +10,34 @@
 
 'use strict';
 
-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('../utils'),
-  getTypes = _require.getTypes;
-const _require2 = require('./commands'),
-  getCommands = _require2.getCommands;
-const _require3 = require('./events'),
-  getEvents = _require3.getEvents;
-const _require4 = require('./extends'),
-  categorizeProps = _require4.categorizeProps;
-const _require5 = require('./options'),
-  getCommandOptions = _require5.getCommandOptions,
-  getOptions = _require5.getOptions;
-const _require6 = require('./props'),
-  getProps = _require6.getProps;
-const _require7 = require('./componentsUtils.js'),
-  getProperties = _require7.getProperties;
+const _require = require('./commands'),
+  getCommands = _require.getCommands;
+const _require2 = require('./events'),
+  getEvents = _require2.getEvents;
+const _require3 = require('./extends'),
+  categorizeProps = _require3.categorizeProps;
+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 = [];
   const defaultExports = ast.body.filter(
     node => node.type === 'ExportDefaultDeclaration',
   );
-  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) {
     throw new Error('Could not find component config for native component');
   }
@@ -162,23 +80,8 @@ function findComponentConfig(ast) {
       };
     })
     .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);
 }
 function getCommandProperties(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
@@ -231,16 +134,14 @@ function getCommandProperties(
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildComponentSchema(ast) {
-  const _findComponentConfig = findComponentConfig(ast),
+function buildComponentSchema(ast, parser) {
+  const _findComponentConfig = findComponentConfig(ast, parser),
     componentName = _findComponentConfig.componentName,
     propsTypeName = _findComponentConfig.propsTypeName,
     commandTypeName = _findComponentConfig.commandTypeName,
     commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
     optionsExpression = _findComponentConfig.optionsExpression;
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
   const propProperties = getProperties(propsTypeName, types);
   const commandOptions = getCommandOptions(commandOptionsExpression);
   const commandProperties = getCommandProperties(

package/lib/parsers/typescript/components/index.js.flow

@@ -10,54 +10,35 @@
 
 'use strict';
 import type {ExtendsPropsShape} from '../../../CodegenSchema.js';
+import type {Parser} from '../../parser';
 import type {TypeDeclarationMap} from '../../utils';
-import type {CommandOptions} from './options';
-import type {ComponentSchemaBuilderConfig} from './schema.js';
+import type {CommandOptions} from '../../parsers-commons';
+import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
-const {getTypes} = require('../utils');
 const {getCommands} = require('./commands');
 const {getEvents} = require('./events');
 const {categorizeProps} = require('./extends');
-const {getCommandOptions, getOptions} = require('./options');
 const {getProps} = require('./props');
 const {getProperties} = require('./componentsUtils.js');
+const {throwIfMoreThanOneCodegenNativecommands} = require('../../error-utils');
+const {
+  createComponentConfig,
+  findNativeComponentType,
+  getCommandOptions,
+  getOptions,
+} = require('../../parsers-commons');
 
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function findComponentConfig(ast) {
-  const foundConfigs = [];
+// $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
+function findComponentConfig(ast: $FlowFixMe, parser: Parser) {
+  const foundConfigs: Array<{[string]: string}> = [];
 
   const defaultExports = ast.body.filter(
     node => node.type === 'ExportDefaultDeclaration',
   );
 
-  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: {[string]: string} = {
-          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) {
     throw new Error('Could not find component config for native component');
@@ -109,21 +90,9 @@ function findComponentConfig(ast) {
     })
     .filter(Boolean);
 
-  if (commandsTypeNames.length > 1) {
-    throw new Error('codegenNativeCommands may only be called once in a file');
-  }
+  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
 
-  return {
-    ...foundConfig,
-    commandTypeName:
-      commandsTypeNames[0] == null
-        ? null
-        : commandsTypeNames[0].commandTypeName,
-    commandOptionsExpression:
-      commandsTypeNames[0] == null
-        ? null
-        : commandsTypeNames[0].commandOptionsExpression,
-  };
+  return createComponentConfig(foundConfig, commandsTypeNames);
 }
 
 function getCommandProperties(
@@ -185,18 +154,19 @@ function getCommandProperties(
 type PropsAST = Object;
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildComponentSchema(ast): ComponentSchemaBuilderConfig {
+function buildComponentSchema(
+  ast: $FlowFixMe,
+  parser: Parser,
+): ComponentSchemaBuilderConfig {
   const {
     componentName,
     propsTypeName,
     commandTypeName,
     commandOptionsExpression,
     optionsExpression,
-  } = findComponentConfig(ast);
+  } = findComponentConfig(ast, parser);
 
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
 
   const propProperties = getProperties(propsTypeName, types);
   const commandOptions = getCommandOptions(commandOptionsExpression);