@react-native/codegen 0.72.3 → 0.72.5

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,268 @@ 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;
+}
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -447,4 +798,10 @@ module.exports = {
   buildPropertySchema,
   buildSchemaFromConfigType,
   buildSchema,
+  createComponentConfig,
+  parseModuleName,
+  buildModuleSchema,
+  findNativeComponentType,
+  getCommandOptions,
+  getOptions,
 };