@react-native/codegen 0.72.3 → 0.73.0

package/lib/parsers/parser.js.flow

@@ -18,9 +18,11 @@ import type {
   NativeModuleParamTypeAnnotation,
   NativeModuleEnumMemberType,
   NativeModuleEnumMembers,
+  NativeModuleAliasMap,
+  NativeModuleEnumMap,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
-import type {TypeDeclarationMap} from './utils';
+import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
 
 /**
  * This is the main interface for Parsers of various languages.
@@ -159,10 +161,15 @@ export interface Parser {
    */
   isModuleInterface(node: $FlowFixMe): boolean;
 
+  /**
+   * Given a type name, it returns true if it is a generic type annotation
+   */
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean;
+
   /**
    * Given a typeAnnotation, it returns the annotated element.
-   * @paramater typeAnnotation: the annotation for a type.
-   * @paramater types: a map of type declarations.
+   * @parameter typeAnnotation: the annotation for a type.
+   * @parameter types: a map of type declarations.
    * @returns: the annotated element.
    */
   extractAnnotatedElement(
@@ -174,4 +181,78 @@ export interface Parser {
    * Given the AST, returns the TypeDeclarationMap
    */
   getTypes(ast: $FlowFixMe): TypeDeclarationMap;
+
+  /**
+   * Given a callExpression, it returns the typeParameters of the callExpression.
+   * @parameter callExpression: the callExpression.
+   * @returns: the typeParameters of the callExpression or null if it does not exist.
+   */
+  callExpressionTypeParameters(callExpression: $FlowFixMe): $FlowFixMe | null;
+
+  /**
+   * Given an array of properties from a Partial type, it returns an array of remaped properties.
+   * @parameter properties: properties from a Partial types.
+   * @parameter hasteModuleName: a string with the native module name.
+   * @parameter types: a map of type declarations.
+   * @parameter aliasMap: a map of type aliases.
+   * @parameter enumMap: a map of type enums.
+   * @parameter tryParse: a parser error capturer.
+   * @parameter cxxOnly: a boolean specifying if the module is Cxx only.
+   * @returns: an array of remaped properties
+   */
+  computePartialProperties(
+    properties: Array<$FlowFixMe>,
+    hasteModuleName: string,
+    types: TypeDeclarationMap,
+    aliasMap: {...NativeModuleAliasMap},
+    enumMap: {...NativeModuleEnumMap},
+    tryParse: ParserErrorCapturer,
+    cxxOnly: boolean,
+  ): Array<$FlowFixMe>;
+
+  /**
+   * Given a propertyValueType, it returns a boolean specifying if the property is a function type annotation.
+   * @parameter propertyValueType: the propertyValueType.
+   * @returns: a boolean specifying if the property is a function type annotation.
+   */
+  functionTypeAnnotation(propertyValueType: string): boolean;
+
+  /**
+   * Given a declaration, it returns the typeArgumentParams of the declaration.
+   * @parameter declaration: the declaration.
+   * @returns: the typeArgumentParams of the declaration.
+   */
+  getTypeArgumentParamsFromDeclaration(declaration: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a typeArgumentParams and funcArgumentParams it returns a native component type.
+   * @parameter typeArgumentParams: the typeArgumentParams.
+   * @parameter funcArgumentParams: the funcArgumentParams.
+   * @returns: a native component type.
+   */
+  getNativeComponentType(
+    typeArgumentParams: $FlowFixMe,
+    funcArgumentParams: $FlowFixMe,
+  ): {[string]: string};
+
+  /**
+   * Given a annotatedElement, it returns the properties of annotated element.
+   * @parameter annotatedElement: the annotated element.
+   * @returns: the properties of annotated element.
+   */
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a typeAlias, it returns an array of properties.
+   * @parameter typeAlias: the type alias.
+   * @returns: an array of properties.
+   */
+  bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe>;
+
+  /**
+   * Given a keyword convert it to TypeAnnotation.
+   * @parameter keyword
+   * @returns: converted TypeAnnotation to Keywords
+   */
+  convertKeywordToTypeAnnotation(keyword: string): string;
 }

package/lib/parsers/parserMock.js

@@ -158,10 +158,63 @@ export class MockedParser {
       node.extends[0].id.name === 'TurboModule'
     );
   }
+  isGenericTypeAnnotation(type) {
+    return true;
+  }
   extractAnnotatedElement(typeAnnotation, types) {
     return types[typeAnnotation.typeParameters.params[0].id.name];
   }
   getTypes(ast) {
     return {};
   }
+  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;
+  }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.properties;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    return keyword;
+  }
 }

package/lib/parsers/parserMock.js.flow

@@ -20,8 +20,10 @@ import type {
   NativeModuleParamTypeAnnotation,
   NativeModuleEnumMemberType,
   NativeModuleEnumMembers,
+  NativeModuleAliasMap,
+  NativeModuleEnumMap,
 } from '../CodegenSchema';
-import type {TypeDeclarationMap} from './utils';
+import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
@@ -170,6 +172,10 @@ export class MockedParser implements Parser {
     );
   }
 
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return true;
+  }
+
   extractAnnotatedElement(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -180,4 +186,61 @@ export class MockedParser implements Parser {
   getTypes(ast: $FlowFixMe): TypeDeclarationMap {
     return {};
   }
+
+  callExpressionTypeParameters(callExpression: $FlowFixMe): $FlowFixMe | null {
+    return callExpression.typeArguments || null;
+  }
+
+  computePartialProperties(
+    properties: Array<$FlowFixMe>,
+    hasteModuleName: string,
+    types: TypeDeclarationMap,
+    aliasMap: {...NativeModuleAliasMap},
+    enumMap: {...NativeModuleEnumMap},
+    tryParse: ParserErrorCapturer,
+    cxxOnly: boolean,
+  ): Array<$FlowFixMe> {
+    return [
+      {
+        name: 'a',
+        optional: true,
+        typeAnnotation: {type: 'StringTypeAnnotation'},
+      },
+      {
+        name: 'b',
+        optional: true,
+        typeAnnotation: {type: 'BooleanTypeAnnotation'},
+      },
+    ];
+  }
+
+  functionTypeAnnotation(propertyValueType: string): boolean {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+
+  getTypeArgumentParamsFromDeclaration(declaration: $FlowFixMe): $FlowFixMe {
+    return declaration.typeArguments.params;
+  }
+
+  getNativeComponentType(
+    typeArgumentParams: $FlowFixMe,
+    funcArgumentParams: $FlowFixMe,
+  ): {[string]: string} {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
+    return annotatedElement.right.properties;
+  }
+
+  bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe> {
+    return typeAlias.body.properties;
+  }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    return keyword;
+  }
 }

package/lib/parsers/parsers-commons.js

@@ -10,6 +10,68 @@
 
 '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);
+}
 function _slicedToArray(arr, i) {
   return (
     _arrayWithHoles(arr) ||
@@ -81,7 +143,10 @@ function _arrayWithHoles(arr) {
 const _require = require('./utils'),
   getConfigType = _require.getConfigType,
   extractNativeModuleName = _require.extractNativeModuleName,
-  createParserErrorCapturer = _require.createParserErrorCapturer;
+  createParserErrorCapturer = _require.createParserErrorCapturer,
+  visit = _require.visit,
+  isModuleRegistryCall = _require.isModuleRegistryCall,
+  verifyPlatforms = _require.verifyPlatforms;
 const _require2 = require('./error-utils'),
   throwIfPropertyValueTypeIsUnsupported =
     _require2.throwIfPropertyValueTypeIsUnsupported,
@@ -89,7 +154,22 @@ const _require2 = require('./error-utils'),
     _require2.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError =
     _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'),
   MissingTypeParameterGenericParserError =
     _require3.MissingTypeParameterGenericParserError,
@@ -337,7 +417,7 @@ function buildPropertySchema(
     property.value,
     key.name,
     value.type,
-    parser.language(),
+    parser,
   );
   return {
     name: methodName,
@@ -366,6 +446,8 @@ function buildSchemaFromConfigType(
   buildComponentSchema,
   buildModuleSchema,
   parser,
+  resolveTypeAnnotation,
+  translateTypeAnnotation,
 ) {
   switch (configType) {
     case 'component': {
@@ -381,7 +463,14 @@ function buildSchemaFromConfigType(
         parsingErrors = _createParserErrorCap2[0],
         tryParse = _createParserErrorCap2[1];
       const schema = tryParse(() =>
-        buildModuleSchema(nativeModuleName, ast, tryParse, parser),
+        buildModuleSchema(
+          nativeModuleName,
+          ast,
+          tryParse,
+          parser,
+          resolveTypeAnnotation,
+          translateTypeAnnotation,
+        ),
       );
       if (parsingErrors.length > 0) {
         /**
@@ -414,6 +503,8 @@ function buildSchema(
   buildModuleSchema,
   Visitor,
   parser,
+  resolveTypeAnnotation,
+  translateTypeAnnotation,
 ) {
   // Early return for non-Spec JavaScript files
   if (
@@ -434,8 +525,302 @@ function buildSchema(
     buildComponentSchema,
     buildModuleSchema,
     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;
+}
+function getCommandTypeNameAndOptionsExpression(namedExport, parser) {
+  let callExpression;
+  let calleeName;
+  try {
+    callExpression = namedExport.declaration.declarations[0].init;
+    calleeName = callExpression.callee.name;
+  } catch (e) {
+    return;
+  }
+  if (calleeName !== 'codegenNativeCommands') {
+    return;
+  }
+  if (callExpression.arguments.length !== 1) {
+    throw new Error(
+      'codegenNativeCommands must be passed options including the supported commands',
+    );
+  }
+  const typeArgumentParam =
+    parser.getTypeArgumentParamsFromDeclaration(callExpression)[0];
+  if (!parser.isGenericTypeAnnotation(typeArgumentParam.type)) {
+    throw new Error(
+      "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
+    );
+  }
+  return {
+    commandTypeName: parser.nameForGenericTypeAnnotation(typeArgumentParam),
+    commandOptionsExpression: callExpression.arguments[0],
+  };
+}
+function propertyNames(properties) {
+  return properties
+    .map(property => property && property.key && property.key.name)
+    .filter(Boolean);
+}
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -447,4 +832,12 @@ module.exports = {
   buildPropertySchema,
   buildSchemaFromConfigType,
   buildSchema,
+  createComponentConfig,
+  parseModuleName,
+  buildModuleSchema,
+  findNativeComponentType,
+  propertyNames,
+  getCommandOptions,
+  getOptions,
+  getCommandTypeNameAndOptionsExpression,
 };