hermes-parser 0.18.1 → 0.19.0

package/dist/babel/TransformESTreeToBabel.js

@@ -478,6 +478,9 @@ function mapPropertyDefinition(node) {
 }
 
 function mapTypeofTypeAnnotation(node) {
+  // $FlowExpectedError[cannot-write]
+  delete node.typeArguments;
+
   if (node.argument.type !== 'GenericTypeAnnotation') {
     return nodeWith(node, {
       // $FlowExpectedError[incompatible-call] Special override for Babel

package/dist/babel/TransformESTreeToBabel.js.flow

@@ -748,6 +748,8 @@ function mapPropertyDefinition(
 function mapTypeofTypeAnnotation(
   node: TypeofTypeAnnotation,
 ): TypeofTypeAnnotation {
+  // $FlowExpectedError[cannot-write]
+  delete node.typeArguments;
   if (node.argument.type !== 'GenericTypeAnnotation') {
     return nodeWith(node, {
       // $FlowExpectedError[incompatible-call] Special override for Babel

package/dist/estree/StripComponentSyntax.js

@@ -78,7 +78,7 @@ function getComponentParameterName(paramName) {
   }
 }
 
-function createPropsTypeAnnotation(loc, range) {
+function createPropsTypeAnnotation(propTypes, spread, loc, range) {
   // Create empty loc for type annotation nodes
   const createParamsTypeLoc = () => ({
     loc: {
@@ -87,8 +87,34 @@ function createPropsTypeAnnotation(loc, range) {
     },
     range: range != null ? range : [0, 0],
     parent: EMPTY_PARENT
-  });
+  }); // Optimize `{...Props}` -> `Props`
+
 
+  if (spread != null && propTypes.length === 0) {
+    return {
+      type: 'TypeAnnotation',
+      typeAnnotation: spread.argument,
+      ...createParamsTypeLoc()
+    };
+  }
+
+  const typeProperties = [...propTypes];
+
+  if (spread != null) {
+    // Spread needs to be the first type, as inline properties take precedence.
+    typeProperties.unshift(spread);
+  }
+
+  const propTypeObj = {
+    type: 'ObjectTypeAnnotation',
+    callProperties: [],
+    properties: typeProperties,
+    indexers: [],
+    internalSlots: [],
+    exact: false,
+    inexact: false,
+    ...createParamsTypeLoc()
+  };
   return {
     type: 'TypeAnnotation',
     typeAnnotation: {
@@ -102,16 +128,7 @@ function createPropsTypeAnnotation(loc, range) {
       },
       typeParameters: {
         type: 'TypeParameterInstantiation',
-        params: [{
-          type: 'ObjectTypeAnnotation',
-          callProperties: [],
-          properties: [],
-          indexers: [],
-          internalSlots: [],
-          exact: false,
-          inexact: true,
-          ...createParamsTypeLoc()
-        }],
+        params: [propTypeObj],
         ...createParamsTypeLoc()
       },
       ...createParamsTypeLoc()
@@ -130,13 +147,9 @@ function mapComponentParameters(params) {
 
 
   if (params.length === 1 && params[0].type === 'RestElement' && params[0].argument.type === 'Identifier') {
-    var _restElementArgument$, _restElementArgument$2;
-
     const restElementArgument = params[0].argument;
     return {
-      props: nodeWith(restElementArgument, {
-        typeAnnotation: createPropsTypeAnnotation((_restElementArgument$ = restElementArgument.typeAnnotation) == null ? void 0 : _restElementArgument$.loc, (_restElementArgument$2 = restElementArgument.typeAnnotation) == null ? void 0 : _restElementArgument$2.range)
-      }),
+      props: restElementArgument,
       ref: null
     };
   } // Filter out any ref param and capture it's details.
@@ -151,12 +164,30 @@ function mapComponentParameters(params) {
 
     return true;
   });
+  const [propTypes, spread] = paramsWithoutRef.reduce(([propTypes, spread], param) => {
+    switch (param.type) {
+      case 'RestElement':
+        {
+          if (spread != null) {
+            throw (0, _createSyntaxError.createSyntaxError)(param, `Invalid state, multiple rest elements found as Component Parameters`);
+          }
+
+          return [propTypes, mapComponentParameterRestElementType(param)];
+        }
+
+      case 'ComponentParameter':
+        {
+          propTypes.push(mapComponentParameterType(param));
+          return [propTypes, spread];
+        }
+    }
+  }, [[], null]);
   const propsProperties = paramsWithoutRef.flatMap(mapComponentParameter);
   let props = null;
 
   if (propsProperties.length === 0) {
     if (refParam == null) {
-      throw new Error('TransformReactScriptForBabel: Invalid state, ref should always be set at this point if props are empty');
+      throw new Error('StripComponentSyntax: Invalid state, ref should always be set at this point if props are empty');
     }
 
     const emptyParamsLoc = {
@@ -169,7 +200,7 @@ function mapComponentParameters(params) {
       type: 'Identifier',
       name: '_$$empty_props_placeholder$$',
       optional: false,
-      typeAnnotation: createPropsTypeAnnotation(emptyParamsLoc, emptyParamsRange),
+      typeAnnotation: createPropsTypeAnnotation([], null, emptyParamsLoc, emptyParamsRange),
       loc: emptyParamsLoc,
       range: emptyParamsRange,
       parent: EMPTY_PARENT
@@ -179,7 +210,7 @@ function mapComponentParameters(params) {
     props = {
       type: 'ObjectPattern',
       properties: propsProperties,
-      typeAnnotation: createPropsTypeAnnotation({
+      typeAnnotation: createPropsTypeAnnotation(propTypes, spread, {
         start: lastPropsProperty.loc.end,
         end: lastPropsProperty.loc.end
       }, [lastPropsProperty.range[1], lastPropsProperty.range[1]]),
@@ -204,6 +235,53 @@ function mapComponentParameters(params) {
   };
 }
 
+function mapComponentParameterType(param) {
+  var _typeAnnotation$typeA;
+
+  const typeAnnotation = param.local.type === 'AssignmentPattern' ? param.local.left.typeAnnotation : param.local.typeAnnotation;
+  const optional = param.local.type === 'AssignmentPattern' ? true : param.local.type === 'Identifier' ? param.local.optional : false;
+  return {
+    type: 'ObjectTypeProperty',
+    key: (0, _astNodeMutationHelpers.shallowCloneNode)(param.name),
+    value: (_typeAnnotation$typeA = typeAnnotation == null ? void 0 : typeAnnotation.typeAnnotation) != null ? _typeAnnotation$typeA : {
+      type: 'AnyTypeAnnotation',
+      loc: param.local.loc,
+      range: param.local.range,
+      parent: EMPTY_PARENT
+    },
+    kind: 'init',
+    optional,
+    method: false,
+    static: false,
+    proto: false,
+    variance: null,
+    loc: param.local.loc,
+    range: param.local.range,
+    parent: EMPTY_PARENT
+  };
+}
+
+function mapComponentParameterRestElementType(param) {
+  var _param$argument$typeA, _param$argument$typeA2;
+
+  if (param.argument.type !== 'Identifier' && param.argument.type !== 'ObjectPattern') {
+    throw (0, _createSyntaxError.createSyntaxError)(param, `Invalid ${param.argument.type} encountered in restParameter`);
+  }
+
+  return {
+    type: 'ObjectTypeSpreadProperty',
+    argument: (_param$argument$typeA = (_param$argument$typeA2 = param.argument.typeAnnotation) == null ? void 0 : _param$argument$typeA2.typeAnnotation) != null ? _param$argument$typeA : {
+      type: 'AnyTypeAnnotation',
+      loc: param.loc,
+      range: param.range,
+      parent: EMPTY_PARENT
+    },
+    loc: param.loc,
+    range: param.range,
+    parent: EMPTY_PARENT
+  };
+}
+
 function mapComponentParameter(param) {
   switch (param.type) {
     case 'RestElement':
@@ -425,6 +503,60 @@ function mapComponentDeclaration(node) {
     forwardRefDetails
   };
 }
+
+function mapDeclareHook(node) {
+  return {
+    type: 'DeclareFunction',
+    id: {
+      type: 'Identifier',
+      name: node.id.name,
+      optional: node.id.optional,
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+        typeAnnotation: {
+          type: 'FunctionTypeAnnotation',
+          this: null,
+          params: node.id.typeAnnotation.typeAnnotation.params,
+          typeParameters: node.id.typeAnnotation.typeAnnotation.typeParameters,
+          rest: node.id.typeAnnotation.typeAnnotation.rest,
+          returnType: node.id.typeAnnotation.typeAnnotation.returnType,
+          loc: node.id.typeAnnotation.typeAnnotation.loc,
+          range: node.id.typeAnnotation.typeAnnotation.range,
+          parent: node.id.typeAnnotation.typeAnnotation.parent
+        },
+        loc: node.id.typeAnnotation.loc,
+        range: node.id.typeAnnotation.range,
+        parent: node.id.typeAnnotation.parent
+      },
+      loc: node.id.loc,
+      range: node.id.range,
+      parent: node.id.parent
+    },
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent,
+    predicate: null
+  };
+}
+
+function mapHookDeclaration(node) {
+  const comp = {
+    type: 'FunctionDeclaration',
+    id: node.id && (0, _astNodeMutationHelpers.shallowCloneNode)(node.id),
+    __hookDeclaration: true,
+    typeParameters: node.typeParameters,
+    params: node.params,
+    returnType: node.returnType,
+    body: node.body,
+    async: false,
+    generator: false,
+    predicate: null,
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent
+  };
+  return comp;
+}
 /**
  * Scan a list of statements and return the position of the
  * first statement that contains a reference to a given component
@@ -502,9 +634,16 @@ function mapStatementList(stmts) {
           break;
         }
 
+      case 'HookDeclaration':
+        {
+          const decl = mapHookDeclaration(node);
+          newBody.push(decl);
+          break;
+        }
+
       case 'ExportNamedDeclaration':
         {
-          var _node$declaration;
+          var _node$declaration, _node$declaration2;
 
           if (((_node$declaration = node.declaration) == null ? void 0 : _node$declaration.type) === 'ComponentDeclaration') {
             mapComponentDeclarationIntoList(node.declaration, newBody, componentOrRef => {
@@ -543,21 +682,33 @@ function mapStatementList(stmts) {
             break;
           }
 
+          if (((_node$declaration2 = node.declaration) == null ? void 0 : _node$declaration2.type) === 'HookDeclaration') {
+            const comp = mapHookDeclaration(node.declaration);
+            newBody.push(comp);
+            break;
+          }
+
           newBody.push(node);
           break;
         }
 
       case 'ExportDefaultDeclaration':
         {
-          var _node$declaration2;
+          var _node$declaration3, _node$declaration4;
 
-          if (((_node$declaration2 = node.declaration) == null ? void 0 : _node$declaration2.type) === 'ComponentDeclaration') {
+          if (((_node$declaration3 = node.declaration) == null ? void 0 : _node$declaration3.type) === 'ComponentDeclaration') {
             mapComponentDeclarationIntoList(node.declaration, newBody, componentOrRef => nodeWith(node, {
               declaration: componentOrRef
             }));
             break;
           }
 
+          if (((_node$declaration4 = node.declaration) == null ? void 0 : _node$declaration4.type) === 'HookDeclaration') {
+            const comp = mapHookDeclaration(node.declaration);
+            newBody.push(comp);
+            break;
+          }
+
           newBody.push(node);
           break;
         }
@@ -581,6 +732,11 @@ function transformProgram(program, _options) {
             return mapDeclareComponent(node);
           }
 
+        case 'DeclareHook':
+          {
+            return mapDeclareHook(node);
+          }
+
         case 'Program':
         case 'BlockStatement':
           {
@@ -605,6 +761,13 @@ function transformProgram(program, _options) {
             throw (0, _createSyntaxError.createSyntaxError)(node, `Components must be defined at the top level of a module or within a ` + `BlockStatement, instead got parent of "${(_node$parent = node.parent) == null ? void 0 : _node$parent.type}".`);
           }
 
+        case 'HookDeclaration':
+          {
+            var _node$parent2;
+
+            throw (0, _createSyntaxError.createSyntaxError)(node, `Hooks must be defined at the top level of a module or within a ` + `BlockStatement, instead got parent of "${(_node$parent2 = node.parent) == null ? void 0 : _node$parent2.type}".`);
+          }
+
         default:
           {
             return node;

package/dist/estree/StripComponentSyntax.js.flow

@@ -37,9 +37,14 @@ import type {
   DestructuringObjectProperty,
   VariableDeclaration,
   ModuleDeclaration,
+  DeclareHook,
+  DeclareFunction,
+  HookDeclaration,
   Statement,
   AssignmentPattern,
   BindingName,
+  ObjectTypePropertySignature,
+  ObjectTypeSpreadProperty,
 } from 'hermes-estree';
 
 import {SimpleTransform} from '../transform/SimpleTransform';
@@ -100,6 +105,8 @@ function getComponentParameterName(
 }
 
 function createPropsTypeAnnotation(
+  propTypes: Array<ObjectTypePropertySignature>,
+  spread: ?ObjectTypeSpreadProperty,
   loc: ?SourceLocation,
   range: ?Range,
 ): TypeAnnotation {
@@ -113,6 +120,35 @@ function createPropsTypeAnnotation(
     parent: EMPTY_PARENT,
   });
 
+  // Optimize `{...Props}` -> `Props`
+  if (spread != null && propTypes.length === 0) {
+    return {
+      type: 'TypeAnnotation',
+      typeAnnotation: spread.argument,
+      ...createParamsTypeLoc(),
+    };
+  }
+
+  const typeProperties: Array<
+    ObjectTypePropertySignature | ObjectTypeSpreadProperty,
+  > = [...propTypes];
+
+  if (spread != null) {
+    // Spread needs to be the first type, as inline properties take precedence.
+    typeProperties.unshift(spread);
+  }
+
+  const propTypeObj = {
+    type: 'ObjectTypeAnnotation',
+    callProperties: [],
+    properties: typeProperties,
+    indexers: [],
+    internalSlots: [],
+    exact: false,
+    inexact: false,
+    ...createParamsTypeLoc(),
+  };
+
   return {
     type: 'TypeAnnotation',
     typeAnnotation: {
@@ -126,18 +162,7 @@ function createPropsTypeAnnotation(
       },
       typeParameters: {
         type: 'TypeParameterInstantiation',
-        params: [
-          {
-            type: 'ObjectTypeAnnotation',
-            callProperties: [],
-            properties: [],
-            indexers: [],
-            internalSlots: [],
-            exact: false,
-            inexact: true,
-            ...createParamsTypeLoc(),
-          },
-        ],
+        params: [propTypeObj],
         ...createParamsTypeLoc(),
       },
       ...createParamsTypeLoc(),
@@ -164,12 +189,7 @@ function mapComponentParameters(
   ) {
     const restElementArgument = params[0].argument;
     return {
-      props: nodeWith(restElementArgument, {
-        typeAnnotation: createPropsTypeAnnotation(
-          restElementArgument.typeAnnotation?.loc,
-          restElementArgument.typeAnnotation?.range,
-        ),
-      }),
+      props: restElementArgument,
       ref: null,
     };
   }
@@ -188,13 +208,36 @@ function mapComponentParameters(
     return true;
   });
 
+  const [propTypes, spread] = paramsWithoutRef.reduce<
+    [Array<ObjectTypePropertySignature>, ?ObjectTypeSpreadProperty],
+  >(
+    ([propTypes, spread], param) => {
+      switch (param.type) {
+        case 'RestElement': {
+          if (spread != null) {
+            throw createSyntaxError(
+              param,
+              `Invalid state, multiple rest elements found as Component Parameters`,
+            );
+          }
+          return [propTypes, mapComponentParameterRestElementType(param)];
+        }
+        case 'ComponentParameter': {
+          propTypes.push(mapComponentParameterType(param));
+          return [propTypes, spread];
+        }
+      }
+    },
+    [[], null],
+  );
+
   const propsProperties = paramsWithoutRef.flatMap(mapComponentParameter);
 
   let props = null;
   if (propsProperties.length === 0) {
     if (refParam == null) {
       throw new Error(
-        'TransformReactScriptForBabel: Invalid state, ref should always be set at this point if props are empty',
+        'StripComponentSyntax: Invalid state, ref should always be set at this point if props are empty',
       );
     }
     const emptyParamsLoc = {
@@ -208,6 +251,8 @@ function mapComponentParameters(
       name: '_$$empty_props_placeholder$$',
       optional: false,
       typeAnnotation: createPropsTypeAnnotation(
+        [],
+        null,
         emptyParamsLoc,
         emptyParamsRange,
       ),
@@ -221,6 +266,8 @@ function mapComponentParameters(
       type: 'ObjectPattern',
       properties: propsProperties,
       typeAnnotation: createPropsTypeAnnotation(
+        propTypes,
+        spread,
         {
           start: lastPropsProperty.loc.end,
           end: lastPropsProperty.loc.end,
@@ -247,6 +294,67 @@ function mapComponentParameters(
   };
 }
 
+function mapComponentParameterType(
+  param: ComponentParameter,
+): ObjectTypePropertySignature {
+  const typeAnnotation =
+    param.local.type === 'AssignmentPattern'
+      ? param.local.left.typeAnnotation
+      : param.local.typeAnnotation;
+  const optional =
+    param.local.type === 'AssignmentPattern'
+      ? true
+      : param.local.type === 'Identifier'
+      ? param.local.optional
+      : false;
+
+  return {
+    type: 'ObjectTypeProperty',
+    key: shallowCloneNode(param.name),
+    value: typeAnnotation?.typeAnnotation ?? {
+      type: 'AnyTypeAnnotation',
+      loc: param.local.loc,
+      range: param.local.range,
+      parent: EMPTY_PARENT,
+    },
+    kind: 'init',
+    optional,
+    method: false,
+    static: false,
+    proto: false,
+    variance: null,
+    loc: param.local.loc,
+    range: param.local.range,
+    parent: EMPTY_PARENT,
+  };
+}
+
+function mapComponentParameterRestElementType(
+  param: RestElement,
+): ObjectTypeSpreadProperty {
+  if (
+    param.argument.type !== 'Identifier' &&
+    param.argument.type !== 'ObjectPattern'
+  ) {
+    throw createSyntaxError(
+      param,
+      `Invalid ${param.argument.type} encountered in restParameter`,
+    );
+  }
+  return {
+    type: 'ObjectTypeSpreadProperty',
+    argument: param.argument.typeAnnotation?.typeAnnotation ?? {
+      type: 'AnyTypeAnnotation',
+      loc: param.loc,
+      range: param.range,
+      parent: EMPTY_PARENT,
+    },
+    loc: param.loc,
+    range: param.range,
+    parent: EMPTY_PARENT,
+  };
+}
+
 function mapComponentParameter(
   param: ComponentParameter | RestElement,
 ): Array<DestructuringObjectProperty | RestElement> {
@@ -484,6 +592,61 @@ function mapComponentDeclaration(node: ComponentDeclaration): {
   return {comp, forwardRefDetails};
 }
 
+function mapDeclareHook(node: DeclareHook): DeclareFunction {
+  return {
+    type: 'DeclareFunction',
+    id: {
+      type: 'Identifier',
+      name: node.id.name,
+      optional: node.id.optional,
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+        typeAnnotation: {
+          type: 'FunctionTypeAnnotation',
+          this: null,
+          params: node.id.typeAnnotation.typeAnnotation.params,
+          typeParameters: node.id.typeAnnotation.typeAnnotation.typeParameters,
+          rest: node.id.typeAnnotation.typeAnnotation.rest,
+          returnType: node.id.typeAnnotation.typeAnnotation.returnType,
+          loc: node.id.typeAnnotation.typeAnnotation.loc,
+          range: node.id.typeAnnotation.typeAnnotation.range,
+          parent: node.id.typeAnnotation.typeAnnotation.parent,
+        },
+        loc: node.id.typeAnnotation.loc,
+        range: node.id.typeAnnotation.range,
+        parent: node.id.typeAnnotation.parent,
+      },
+      loc: node.id.loc,
+      range: node.id.range,
+      parent: node.id.parent,
+    },
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent,
+    predicate: null,
+  };
+}
+
+function mapHookDeclaration(node: HookDeclaration): FunctionDeclaration {
+  const comp = {
+    type: 'FunctionDeclaration',
+    id: node.id && shallowCloneNode(node.id),
+    __hookDeclaration: true,
+    typeParameters: node.typeParameters,
+    params: node.params,
+    returnType: node.returnType,
+    body: node.body,
+    async: false,
+    generator: false,
+    predicate: null,
+    loc: node.loc,
+    range: node.range,
+    parent: node.parent,
+  };
+
+  return comp;
+}
+
 /**
  * Scan a list of statements and return the position of the
  * first statement that contains a reference to a given component
@@ -559,6 +722,11 @@ function mapStatementList(
         mapComponentDeclarationIntoList(node, newBody);
         break;
       }
+      case 'HookDeclaration': {
+        const decl = mapHookDeclaration(node);
+        newBody.push(decl);
+        break;
+      }
       case 'ExportNamedDeclaration': {
         if (node.declaration?.type === 'ComponentDeclaration') {
           mapComponentDeclarationIntoList(
@@ -598,6 +766,12 @@ function mapStatementList(
           break;
         }
 
+        if (node.declaration?.type === 'HookDeclaration') {
+          const comp = mapHookDeclaration(node.declaration);
+          newBody.push(comp);
+          break;
+        }
+
         newBody.push(node);
         break;
       }
@@ -611,6 +785,12 @@ function mapStatementList(
           break;
         }
 
+        if (node.declaration?.type === 'HookDeclaration') {
+          const comp = mapHookDeclaration(node.declaration);
+          newBody.push(comp);
+          break;
+        }
+
         newBody.push(node);
         break;
       }
@@ -633,6 +813,9 @@ export function transformProgram(
         case 'DeclareComponent': {
           return mapDeclareComponent(node);
         }
+        case 'DeclareHook': {
+          return mapDeclareHook(node);
+        }
         case 'Program':
         case 'BlockStatement': {
           return nodeWith(node, {body: mapStatementList(node.body)});
@@ -651,6 +834,13 @@ export function transformProgram(
               `BlockStatement, instead got parent of "${node.parent?.type}".`,
           );
         }
+        case 'HookDeclaration': {
+          throw createSyntaxError(
+            node,
+            `Hooks must be defined at the top level of a module or within a ` +
+              `BlockStatement, instead got parent of "${node.parent?.type}".`,
+          );
+        }
         default: {
           return node;
         }

package/dist/estree/StripFlowTypesForBabel.js

@@ -152,6 +152,7 @@ function transformProgram(program, _options) {
         case 'TupleTypeLabeledElement':
         case 'TupleTypeSpreadElement':
         case 'ComponentTypeAnnotation':
+        case 'HookTypeAnnotation':
         case 'TypeOperator':
         case 'TypePredicate':
           {

package/dist/estree/StripFlowTypesForBabel.js.flow

@@ -165,6 +165,7 @@ export function transformProgram(
         case 'TupleTypeLabeledElement':
         case 'TupleTypeSpreadElement':
         case 'ComponentTypeAnnotation':
+        case 'HookTypeAnnotation':
         case 'TypeOperator':
         case 'TypePredicate': {
           // Babel does not support these generic types, so convert to any