@react-native/codegen 0.73.0 → 0.74.0-nightly-20231003-5dedf277c

package/lib/parsers/flow/modules/index.js

@@ -78,28 +78,26 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('../utils'),
-  resolveTypeAnnotation = _require.resolveTypeAnnotation;
-const _require2 = require('../../parsers-commons'),
-  unwrapNullable = _require2.unwrapNullable,
-  wrapNullable = _require2.wrapNullable,
+const _require = require('../../parsers-commons'),
+  unwrapNullable = _require.unwrapNullable,
+  wrapNullable = _require.wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter =
-    _require2.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  parseObjectProperty = _require2.parseObjectProperty;
-const _require3 = require('../../parsers-primitives'),
-  emitArrayType = _require3.emitArrayType,
-  emitFunction = _require3.emitFunction,
-  emitGenericObject = _require3.emitGenericObject,
-  emitPromise = _require3.emitPromise,
-  emitRootTag = _require3.emitRootTag,
-  emitUnion = _require3.emitUnion,
-  emitCommonTypes = _require3.emitCommonTypes,
-  typeAliasResolution = _require3.typeAliasResolution,
-  typeEnumResolution = _require3.typeEnumResolution;
-const _require4 = require('../../errors'),
+    _require.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty = _require.parseObjectProperty;
+const _require2 = require('../../parsers-primitives'),
+  emitArrayType = _require2.emitArrayType,
+  emitFunction = _require2.emitFunction,
+  emitDictionary = _require2.emitDictionary,
+  emitPromise = _require2.emitPromise,
+  emitRootTag = _require2.emitRootTag,
+  emitUnion = _require2.emitUnion,
+  emitCommonTypes = _require2.emitCommonTypes,
+  typeAliasResolution = _require2.typeAliasResolution,
+  typeEnumResolution = _require2.typeEnumResolution;
+const _require3 = require('../../errors'),
   UnsupportedTypeAnnotationParserError =
-    _require4.UnsupportedTypeAnnotationParserError,
-  UnsupportedGenericParserError = _require4.UnsupportedGenericParserError;
+    _require3.UnsupportedTypeAnnotationParserError,
+  UnsupportedGenericParserError = _require3.UnsupportedGenericParserError;
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -113,16 +111,18 @@ function translateTypeAnnotation(
   cxxOnly,
   parser,
 ) {
-  const _resolveTypeAnnotatio = resolveTypeAnnotation(
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
+  const _resolveTypeAnnotatio = resolveTypeAnnotationFN(
       flowTypeAnnotation,
       types,
+      parser,
     ),
     nullable = _resolveTypeAnnotatio.nullable,
     typeAnnotation = _resolveTypeAnnotatio.typeAnnotation,
     typeResolutionStatus = _resolveTypeAnnotatio.typeResolutionStatus;
   switch (typeAnnotation.type) {
     case 'GenericTypeAnnotation': {
-      switch (typeAnnotation.id.name) {
+      switch (parser.getTypeAnnotationName(typeAnnotation)) {
         case 'RootTag': {
           return emitRootTag(nullable);
         }
@@ -210,7 +210,7 @@ function translateTypeAnnotation(
           // check the property type to prevent developers from using unsupported types
           // the return value from `translateTypeAnnotation` is unused
           const propertyType = indexers[0].value;
-          translateTypeAnnotation(
+          const valueType = translateTypeAnnotation(
             hasteModuleName,
             propertyType,
             types,
@@ -221,7 +221,7 @@ function translateTypeAnnotation(
             parser,
           );
           // no need to do further checking
-          return emitGenericObject(nullable);
+          return emitDictionary(nullable, valueType);
         }
       }
       const objectTypeAnnotation = {

package/lib/parsers/flow/modules/index.js.flow

@@ -22,7 +22,6 @@ import type {
 import type {Parser} from '../../parser';
 import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
 
-const {resolveTypeAnnotation} = require('../utils');
 const {
   unwrapNullable,
   wrapNullable,
@@ -32,7 +31,7 @@ const {
 const {
   emitArrayType,
   emitFunction,
-  emitGenericObject,
+  emitDictionary,
   emitPromise,
   emitRootTag,
   emitUnion,
@@ -59,12 +58,13 @@ function translateTypeAnnotation(
   cxxOnly: boolean,
   parser: Parser,
 ): Nullable<NativeModuleTypeAnnotation> {
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
   const {nullable, typeAnnotation, typeResolutionStatus} =
-    resolveTypeAnnotation(flowTypeAnnotation, types);
+    resolveTypeAnnotationFN(flowTypeAnnotation, types, parser);
 
   switch (typeAnnotation.type) {
     case 'GenericTypeAnnotation': {
-      switch (typeAnnotation.id.name) {
+      switch (parser.getTypeAnnotationName(typeAnnotation)) {
         case 'RootTag': {
           return emitRootTag(nullable);
         }
@@ -152,7 +152,7 @@ function translateTypeAnnotation(
           // check the property type to prevent developers from using unsupported types
           // the return value from `translateTypeAnnotation` is unused
           const propertyType = indexers[0].value;
-          translateTypeAnnotation(
+          const valueType = translateTypeAnnotation(
             hasteModuleName,
             propertyType,
             types,
@@ -163,7 +163,7 @@ function translateTypeAnnotation(
             parser,
           );
           // no need to do further checking
-          return emitGenericObject(nullable);
+          return emitDictionary(nullable, valueType);
         }
       }
 

package/lib/parsers/flow/parser.d.ts

@@ -5,6 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type {Parser} from '../parser';
+import type { Parser } from '../parser';
+import type { SchemaType } from '../../CodegenSchema';
+import type { ParserType } from '../errors';
 
-export declare class FlowParser implements Parser{}
+export declare class FlowParser implements Parser {
+    language(): ParserType;
+    parseFile(filename: string): SchemaType;
+    parseString(contents: string, filename?: string): SchemaType;
+    parseModuleFixture(filename: string): SchemaType;
+}

package/lib/parsers/flow/parser.js

@@ -38,27 +38,31 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('./modules'),
-  flowTranslateTypeAnnotation = _require.flowTranslateTypeAnnotation;
+const invariant = require('invariant');
+const _require = require('./components/componentsUtils'),
+  getSchemaInfo = _require.getSchemaInfo,
+  getTypeAnnotation = _require.getTypeAnnotation,
+  flattenProperties = _require.flattenProperties;
+const _require2 = require('./modules'),
+  flowTranslateTypeAnnotation = _require2.flowTranslateTypeAnnotation;
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
-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 _require3 = require('../parsers-commons'),
+  buildSchema = _require3.buildSchema,
+  buildPropSchema = _require3.buildPropSchema,
+  buildModuleSchema = _require3.buildModuleSchema,
+  handleGenericTypeAnnotation = _require3.handleGenericTypeAnnotation;
+const _require4 = require('../parsers-primitives'),
+  Visitor = _require4.Visitor;
+const _require5 = require('./components'),
+  buildComponentSchema = _require5.buildComponentSchema;
+const _require6 = require('../schema.js'),
+  wrapComponentSchema = _require6.wrapComponentSchema;
 const fs = require('fs');
-const _require8 = require('../errors'),
+const _require7 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require8.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require7.UnsupportedObjectPropertyTypeAnnotationParserError;
 class FlowParser {
   constructor() {
     _defineProperty(
@@ -66,6 +70,19 @@ class FlowParser {
       'typeParameterInstantiation',
       'TypeParameterInstantiation',
     );
+    _defineProperty(this, 'typeAlias', 'TypeAlias');
+    _defineProperty(this, 'enumDeclaration', 'EnumDeclaration');
+    _defineProperty(this, 'interfaceDeclaration', 'InterfaceDeclaration');
+    _defineProperty(
+      this,
+      'nullLiteralTypeAnnotation',
+      'NullLiteralTypeAnnotation',
+    );
+    _defineProperty(
+      this,
+      'undefinedLiteralTypeAnnotation',
+      'VoidLiteralTypeAnnotation',
+    );
   }
   isProperty(property) {
     return property.type === 'ObjectTypeProperty';
@@ -84,7 +101,7 @@ class FlowParser {
   language() {
     return 'Flow';
   }
-  nameForGenericTypeAnnotation(typeAnnotation) {
+  getTypeAnnotationName(typeAnnotation) {
     var _typeAnnotation$id;
     return typeAnnotation === null || typeAnnotation === void 0
       ? void 0
@@ -122,7 +139,6 @@ class FlowParser {
       buildModuleSchema,
       Visitor,
       this,
-      resolveTypeAnnotation,
       flowTranslateTypeAnnotation,
     );
   }
@@ -315,6 +331,151 @@ class FlowParser {
   convertKeywordToTypeAnnotation(keyword) {
     return keyword;
   }
+  argumentForProp(prop) {
+    return prop.argument;
+  }
+  nameForArgument(prop) {
+    return prop.argument.id.name;
+  }
+  isOptionalProperty(property) {
+    return (
+      property.value.type === 'NullableTypeAnnotation' || property.optional
+    );
+  }
+  getGetSchemaInfoFN() {
+    return getSchemaInfo;
+  }
+  getTypeAnnotationFromProperty(property) {
+    return property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  }
+  getGetTypeAnnotationFN() {
+    return getTypeAnnotation;
+  }
+  getResolvedTypeAnnotation(typeAnnotation, types, parser) {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+    let node = typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus = {
+      successful: false,
+    };
+    for (;;) {
+      if (node.type === 'NullableTypeAnnotation') {
+        nullable = true;
+        node = node.typeAnnotation;
+        continue;
+      }
+      if (node.type !== 'GenericTypeAnnotation') {
+        break;
+      }
+      const typeAnnotationName = this.getTypeAnnotationName(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+      const _handleGenericTypeAnn = handleGenericTypeAnnotation(
+          node,
+          resolvedTypeAnnotation,
+          this,
+        ),
+        typeAnnotationNode = _handleGenericTypeAnn.typeAnnotation,
+        status = _handleGenericTypeAnn.typeResolutionStatus;
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
+    }
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+  getResolveTypeAnnotationFN() {
+    return (typeAnnotation, types, parser) =>
+      this.getResolvedTypeAnnotation(typeAnnotation, types, parser);
+  }
+  extendsForProp(prop, types, parser) {
+    const argument = this.argumentForProp(prop);
+    if (!argument) {
+      console.log('null', prop);
+    }
+    const name = parser.nameForArgument(prop);
+    if (types[name] != null) {
+      // This type is locally defined in the file
+      return null;
+    }
+    switch (name) {
+      case 'ViewProps':
+        return {
+          type: 'ReactNativeBuiltInType',
+          knownTypeName: 'ReactNativeCoreViewProps',
+        };
+      default: {
+        throw new Error(`Unable to handle prop spread: ${name}`);
+      }
+    }
+  }
+  removeKnownExtends(typeDefinition, types) {
+    return typeDefinition.filter(
+      prop =>
+        prop.type !== 'ObjectTypeSpreadProperty' ||
+        this.extendsForProp(prop, types, this) === null,
+    );
+  }
+  getExtendsProps(typeDefinition, types) {
+    return typeDefinition
+      .filter(prop => prop.type === 'ObjectTypeSpreadProperty')
+      .map(prop => this.extendsForProp(prop, types, this))
+      .filter(Boolean);
+  }
+  getProps(typeDefinition, types) {
+    const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
+    const props = flattenProperties(nonExtendsProps, types, this)
+      .map(property => buildPropSchema(property, types, this))
+      .filter(Boolean);
+    return {
+      props,
+      extendsProps: this.getExtendsProps(typeDefinition, types),
+    };
+  }
+  getProperties(typeName, types) {
+    const typeAlias = types[typeName];
+    try {
+      return typeAlias.right.typeParameters.params[0].properties;
+    } catch (e) {
+      throw new Error(
+        `Failed to find type definition for "${typeName}", please check that you have a valid codegen flow file`,
+      );
+    }
+  }
+  nextNodeForTypeAlias(typeAnnotation) {
+    return typeAnnotation.right;
+  }
+  nextNodeForEnum(typeAnnotation) {
+    return typeAnnotation.body;
+  }
+  genericTypeAnnotationErrorMessage(typeAnnotation) {
+    return `A non GenericTypeAnnotation must be a type declaration ('${this.typeAlias}') or enum ('${this.enumDeclaration}'). Instead, got the unsupported ${typeAnnotation.type}.`;
+  }
+  extractTypeFromTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.type === 'GenericTypeAnnotation'
+      ? typeAnnotation.id.name
+      : typeAnnotation.type;
+  }
+  getObjectProperties(typeAnnotation) {
+    return typeAnnotation.properties;
+  }
+  getLiteralValue(option) {
+    return option.value;
+  }
+  getPaperTopLevelNameDeprecated(typeAnnotation) {
+    return typeAnnotation.typeParameters.params.length > 1
+      ? typeAnnotation.typeParameters.params[1].value
+      : null;
+  }
 }
 module.exports = {
   FlowParser,

package/lib/parsers/flow/parser.js.flow

@@ -20,22 +20,50 @@ import type {
   NativeModuleEnumMembers,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  PropTypeAnnotation,
+  ExtendsPropsShape,
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
-import type {Parser} from '../parser';
-import type {ParserErrorCapturer, TypeDeclarationMap} from '../utils';
+import type {
+  GetSchemaInfoFN,
+  GetTypeAnnotationFN,
+  Parser,
+  ResolveTypeAnnotationFN,
+} from '../parser';
+import type {
+  ParserErrorCapturer,
+  TypeDeclarationMap,
+  PropAST,
+  TypeResolutionStatus,
+} from '../utils';
+
+type ExtendsForProp = null | {
+  type: 'ReactNativeBuiltInType',
+  knownTypeName: 'ReactNativeCoreViewProps',
+};
+
+const invariant = require('invariant');
+
+const {
+  getSchemaInfo,
+  getTypeAnnotation,
+  flattenProperties,
+} = require('./components/componentsUtils');
 
 const {flowTranslateTypeAnnotation} = require('./modules');
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
 
-const {buildSchema} = require('../parsers-commons');
+const {
+  buildSchema,
+  buildPropSchema,
+  buildModuleSchema,
+  handleGenericTypeAnnotation,
+} = require('../parsers-commons');
 const {Visitor} = require('../parsers-primitives');
 const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-const {buildModuleSchema} = require('../parsers-commons.js');
-const {resolveTypeAnnotation} = require('./utils');
 
 const fs = require('fs');
 
@@ -45,6 +73,11 @@ const {
 
 class FlowParser implements Parser {
   typeParameterInstantiation: string = 'TypeParameterInstantiation';
+  typeAlias: string = 'TypeAlias';
+  enumDeclaration: string = 'EnumDeclaration';
+  interfaceDeclaration: string = 'InterfaceDeclaration';
+  nullLiteralTypeAnnotation: string = 'NullLiteralTypeAnnotation';
+  undefinedLiteralTypeAnnotation: string = 'VoidLiteralTypeAnnotation';
 
   isProperty(property: $FlowFixMe): boolean {
     return property.type === 'ObjectTypeProperty';
@@ -66,7 +99,7 @@ class FlowParser implements Parser {
     return 'Flow';
   }
 
-  nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+  getTypeAnnotationName(typeAnnotation: $FlowFixMe): string {
     return typeAnnotation?.id?.name;
   }
 
@@ -106,7 +139,6 @@ class FlowParser implements Parser {
       buildModuleSchema,
       Visitor,
       this,
-      resolveTypeAnnotation,
       flowTranslateTypeAnnotation,
     );
   }
@@ -329,6 +361,198 @@ class FlowParser implements Parser {
   convertKeywordToTypeAnnotation(keyword: string): string {
     return keyword;
   }
+
+  argumentForProp(prop: PropAST): $FlowFixMe {
+    return prop.argument;
+  }
+
+  nameForArgument(prop: PropAST): $FlowFixMe {
+    return prop.argument.id.name;
+  }
+
+  isOptionalProperty(property: $FlowFixMe): boolean {
+    return (
+      property.value.type === 'NullableTypeAnnotation' || property.optional
+    );
+  }
+
+  getGetSchemaInfoFN(): GetSchemaInfoFN {
+    return getSchemaInfo;
+  }
+
+  getTypeAnnotationFromProperty(property: PropAST): $FlowFixMe {
+    return property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  }
+
+  getGetTypeAnnotationFN(): GetTypeAnnotationFN {
+    return getTypeAnnotation;
+  }
+
+  getResolvedTypeAnnotation(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): {
+    nullable: boolean,
+    typeAnnotation: $FlowFixMe,
+    typeResolutionStatus: TypeResolutionStatus,
+  } {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+
+    let node = typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus: TypeResolutionStatus = {
+      successful: false,
+    };
+
+    for (;;) {
+      if (node.type === 'NullableTypeAnnotation') {
+        nullable = true;
+        node = node.typeAnnotation;
+        continue;
+      }
+
+      if (node.type !== 'GenericTypeAnnotation') {
+        break;
+      }
+
+      const typeAnnotationName = this.getTypeAnnotationName(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+
+      const {typeAnnotation: typeAnnotationNode, typeResolutionStatus: status} =
+        handleGenericTypeAnnotation(node, resolvedTypeAnnotation, this);
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
+    }
+
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+
+  getResolveTypeAnnotationFN(): ResolveTypeAnnotationFN {
+    return (typeAnnotation, types, parser) =>
+      this.getResolvedTypeAnnotation(typeAnnotation, types, parser);
+  }
+  extendsForProp(
+    prop: PropAST,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): ExtendsForProp {
+    const argument = this.argumentForProp(prop);
+    if (!argument) {
+      console.log('null', prop);
+    }
+    const name = parser.nameForArgument(prop);
+
+    if (types[name] != null) {
+      // This type is locally defined in the file
+      return null;
+    }
+
+    switch (name) {
+      case 'ViewProps':
+        return {
+          type: 'ReactNativeBuiltInType',
+          knownTypeName: 'ReactNativeCoreViewProps',
+        };
+      default: {
+        throw new Error(`Unable to handle prop spread: ${name}`);
+      }
+    }
+  }
+
+  removeKnownExtends(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): $ReadOnlyArray<PropAST> {
+    return typeDefinition.filter(
+      prop =>
+        prop.type !== 'ObjectTypeSpreadProperty' ||
+        this.extendsForProp(prop, types, this) === null,
+    );
+  }
+
+  getExtendsProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): $ReadOnlyArray<ExtendsPropsShape> {
+    return typeDefinition
+      .filter(prop => prop.type === 'ObjectTypeSpreadProperty')
+      .map(prop => this.extendsForProp(prop, types, this))
+      .filter(Boolean);
+  }
+
+  getProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): {
+    props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+    extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+  } {
+    const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
+    const props = flattenProperties(nonExtendsProps, types, this)
+      .map(property => buildPropSchema(property, types, this))
+      .filter(Boolean);
+
+    return {
+      props,
+      extendsProps: this.getExtendsProps(typeDefinition, types),
+    };
+  }
+
+  getProperties(typeName: string, types: TypeDeclarationMap): $FlowFixMe {
+    const typeAlias = types[typeName];
+    try {
+      return typeAlias.right.typeParameters.params[0].properties;
+    } catch (e) {
+      throw new Error(
+        `Failed to find type definition for "${typeName}", please check that you have a valid codegen flow file`,
+      );
+    }
+  }
+
+  nextNodeForTypeAlias(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.right;
+  }
+
+  nextNodeForEnum(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.body;
+  }
+
+  genericTypeAnnotationErrorMessage(typeAnnotation: $FlowFixMe): string {
+    return `A non GenericTypeAnnotation must be a type declaration ('${this.typeAlias}') or enum ('${this.enumDeclaration}'). Instead, got the unsupported ${typeAnnotation.type}.`;
+  }
+
+  extractTypeFromTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+    return typeAnnotation.type === 'GenericTypeAnnotation'
+      ? typeAnnotation.id.name
+      : typeAnnotation.type;
+  }
+
+  getObjectProperties(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.properties;
+  }
+
+  getLiteralValue(option: $FlowFixMe): $FlowFixMe {
+    return option.value;
+  }
+
+  getPaperTopLevelNameDeprecated(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.typeParameters.params.length > 1
+      ? typeAnnotation.typeParameters.params[1].value
+      : null;
+  }
 }
 
 module.exports = {