@react-native/codegen 0.72.3 → 0.73.0

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,132 @@ 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(
+  nullable: boolean,
+  hasteModuleName: string,
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: 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 typeMap = {
+    Stringish: emitStringish,
+    Int32: emitInt32,
+    Double: emitDouble,
+    Float: emitFloat,
+    UnsafeObject: emitGenericObject,
+    Object: emitGenericObject,
+    $Partial: emitPartial,
+    Partial: emitPartial,
+    BooleanTypeAnnotation: emitBoolean,
+    NumberTypeAnnotation: emitNumber,
+    VoidTypeAnnotation: emitVoid,
+    StringTypeAnnotation: emitString,
+    MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+  };
+
+  const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
+    typeAnnotation.type,
+  );
+
+  const simpleEmitter = typeMap[typeAnnotationName];
+  if (simpleEmitter) {
+    return simpleEmitter(nullable);
+  }
+
+  const genericTypeAnnotationName =
+    parser.nameForGenericTypeAnnotation(typeAnnotation);
+
+  const emitter = typeMap[genericTypeAnnotationName];
+  if (!emitter) {
+    return null;
+  }
+
+  return emitter(
+    nullable,
+    hasteModuleName,
+    typeAnnotation,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+    parser,
+  );
+}
+
 module.exports = {
   emitArrayType,
   emitBoolean,
@@ -456,7 +584,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/__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,114 +10,37 @@
 
 '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('./commands'),
   getCommands = _require.getCommands;
 const _require2 = require('./events'),
   getEvents = _require2.getEvents;
 const _require3 = require('./extends'),
   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,
+  propertyNames = _require7.propertyNames,
+  getCommandOptions = _require7.getCommandOptions,
+  getOptions = _require7.getOptions,
+  getCommandTypeNameAndOptionsExpression =
+    _require7.getCommandTypeNameAndOptionsExpression;
 
-/* $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');
   }
@@ -129,82 +52,33 @@ function findComponentConfig(ast) {
     node => node.type === 'ExportNamedDeclaration',
   );
   const commandsTypeNames = namedExports
-    .map(statement => {
-      let callExpression;
-      let calleeName;
-      try {
-        callExpression = statement.declaration.declarations[0].init;
-        calleeName = callExpression.callee.name;
-      } catch (e) {
-        return;
-      }
-      if (calleeName !== 'codegenNativeCommands') {
-        return;
-      }
-
-      // const statement.declaration.declarations[0].init
-      if (callExpression.arguments.length !== 1) {
-        throw new Error(
-          'codegenNativeCommands must be passed options including the supported commands',
-        );
-      }
-      const typeArgumentParam = callExpression.typeParameters.params[0];
-      if (typeArgumentParam.type !== 'TSTypeReference') {
-        throw new Error(
-          "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
-        );
-      }
-      return {
-        commandTypeName: typeArgumentParam.typeName.name,
-        commandOptionsExpression: callExpression.arguments[0],
-      };
-    })
+    .map(statement => getCommandTypeNameAndOptionsExpression(statement, parser))
     .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
-   * LTI update could not be added via codemod */
-  commandTypeName,
-  types,
-  commandOptions,
-) {
+function getCommandProperties(ast, parser) {
+  const _findComponentConfig = findComponentConfig(ast, parser),
+    commandTypeName = _findComponentConfig.commandTypeName,
+    commandOptionsExpression = _findComponentConfig.commandOptionsExpression;
   if (commandTypeName == null) {
     return [];
   }
+  const types = parser.getTypes(ast);
   const typeAlias = types[commandTypeName];
   if (typeAlias.type !== 'TSInterfaceDeclaration') {
     throw new Error(
       `The type argument for codegenNativeCommands must be an interface, received ${typeAlias.type}`,
     );
   }
-  let properties;
-  try {
-    properties = typeAlias.body.body;
-  } catch (e) {
+  const properties = parser.bodyProperties(typeAlias);
+  if (!properties) {
     throw new Error(
       `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen typescript file`,
     );
   }
-  const typeScriptPropertyNames = properties
-    .map(property => property && property.key && property.key.name)
-    .filter(Boolean);
+  const typeScriptPropertyNames = propertyNames(properties);
+  const commandOptions = getCommandOptions(commandOptionsExpression);
   if (commandOptions == null || commandOptions.supportedCommands == null) {
     throw new Error(
       'codegenNativeCommands must be given an options object with supportedCommands array',
@@ -230,20 +104,13 @@ function getCommandProperties(
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
 function buildComponentSchema(ast, parser) {
-  const _findComponentConfig = findComponentConfig(ast),
-    componentName = _findComponentConfig.componentName,
-    propsTypeName = _findComponentConfig.propsTypeName,
-    commandTypeName = _findComponentConfig.commandTypeName,
-    commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
-    optionsExpression = _findComponentConfig.optionsExpression;
+  const _findComponentConfig2 = findComponentConfig(ast, parser),
+    componentName = _findComponentConfig2.componentName,
+    propsTypeName = _findComponentConfig2.propsTypeName,
+    optionsExpression = _findComponentConfig2.optionsExpression;
   const types = parser.getTypes(ast);
   const propProperties = getProperties(propsTypeName, types);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-  const commandProperties = getCommandProperties(
-    commandTypeName,
-    types,
-    commandOptions,
-  );
+  const commandProperties = getCommandProperties(ast, parser);
   const options = getOptions(optionsExpression);
   const extendsProps = [];
   const componentPropAsts = [];