hermes-parser 0.18.2 → 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

@@ -503,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
@@ -580,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 => {
@@ -621,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;
         }
@@ -659,6 +732,11 @@ function transformProgram(program, _options) {
             return mapDeclareComponent(node);
           }
 
+        case 'DeclareHook':
+          {
+            return mapDeclareHook(node);
+          }
+
         case 'Program':
         case 'BlockStatement':
           {
@@ -683,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,6 +37,9 @@ import type {
   DestructuringObjectProperty,
   VariableDeclaration,
   ModuleDeclaration,
+  DeclareHook,
+  DeclareFunction,
+  HookDeclaration,
   Statement,
   AssignmentPattern,
   BindingName,
@@ -589,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
@@ -664,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(
@@ -703,6 +766,12 @@ function mapStatementList(
           break;
         }
 
+        if (node.declaration?.type === 'HookDeclaration') {
+          const comp = mapHookDeclaration(node.declaration);
+          newBody.push(comp);
+          break;
+        }
+
         newBody.push(node);
         break;
       }
@@ -716,6 +785,12 @@ function mapStatementList(
           break;
         }
 
+        if (node.declaration?.type === 'HookDeclaration') {
+          const comp = mapHookDeclaration(node.declaration);
+          newBody.push(comp);
+          break;
+        }
+
         newBody.push(node);
         break;
       }
@@ -738,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)});
@@ -756,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

package/dist/generated/ESTreeVisitorKeys.js

@@ -60,6 +60,7 @@ module.exports = {
   DeclareExportAllDeclaration: ['source'],
   DeclareExportDeclaration: ['declaration', 'specifiers', 'source'],
   DeclareFunction: ['id', 'predicate'],
+  DeclareHook: ['id'],
   DeclareInterface: ['id', 'typeParameters', 'extends', 'body'],
   DeclareModule: ['id', 'body'],
   DeclareModuleExports: ['typeAnnotation'],
@@ -92,6 +93,8 @@ module.exports = {
   FunctionTypeAnnotation: ['params', 'this', 'returnType', 'rest', 'typeParameters'],
   FunctionTypeParam: ['name', 'typeAnnotation'],
   GenericTypeAnnotation: ['id', 'typeParameters'],
+  HookDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType'],
+  HookTypeAnnotation: ['params', 'returnType', 'rest', 'typeParameters'],
   Identifier: ['typeAnnotation'],
   IfStatement: ['test', 'consequent', 'alternate'],
   ImportAttribute: ['key', 'value'],
@@ -174,7 +177,7 @@ module.exports = {
   TypeAlias: ['id', 'typeParameters', 'right'],
   TypeAnnotation: ['typeAnnotation'],
   TypeCastExpression: ['expression', 'typeAnnotation'],
-  TypeofTypeAnnotation: ['argument'],
+  TypeofTypeAnnotation: ['argument', 'typeArguments'],
   TypeOperator: ['typeAnnotation'],
   TypeParameter: ['bound', 'variance', 'default'],
   TypeParameterDeclaration: ['params'],

package/dist/generated/ParserVisitorKeys.js

@@ -187,6 +187,9 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     predicate: 'Node'
   },
+  DeclareHook: {
+    id: 'Node'
+  },
   DeclareInterface: {
     id: 'Node',
     typeParameters: 'Node',
@@ -318,6 +321,19 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     typeParameters: 'Node'
   },
+  HookDeclaration: {
+    id: 'Node',
+    params: 'NodeList',
+    body: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
+  HookTypeAnnotation: {
+    params: 'NodeList',
+    returnType: 'Node',
+    rest: 'Node',
+    typeParameters: 'Node'
+  },
   Identifier: {
     typeAnnotation: 'Node'
   },
@@ -597,7 +613,8 @@ const HERMES_AST_VISITOR_KEYS = {
     typeAnnotation: 'Node'
   },
   TypeofTypeAnnotation: {
-    argument: 'Node'
+    argument: 'Node',
+    typeArguments: 'Node'
   },
   TypeOperator: {
     typeAnnotation: 'Node'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-parser",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "description": "A JavaScript parser built from the Hermes engine",
   "main": "dist/index.js",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "url": "git@github.com:facebook/hermes.git"
   },
   "dependencies": {
-    "hermes-estree": "0.18.2"
+    "hermes-estree": "0.19.0"
   },
   "devDependencies": {
     "@babel/parser": "7.7.4",