hermes-estree 0.18.1 → 0.19.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -61,6 +61,7 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
@@ -93,6 +94,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -502,6 +505,9 @@ interface DeclareFunction_With_id extends DeclareFunction {
 interface DeclareFunction_With_predicate extends DeclareFunction {
   +predicate: $NonMaybeType<DeclareFunction['predicate']>;
 }
+interface DeclareHook_With_id extends DeclareHook {
+  +id: $NonMaybeType<DeclareHook['id']>;
+}
 interface DeclareInterface_With_id extends DeclareInterface {
   +id: $NonMaybeType<DeclareInterface['id']>;
 }
@@ -774,6 +780,33 @@ interface GenericTypeAnnotation_With_typeParameters
   extends GenericTypeAnnotation {
   +typeParameters: $NonMaybeType<GenericTypeAnnotation['typeParameters']>;
 }
+interface HookDeclaration_With_id extends HookDeclaration {
+  +id: $NonMaybeType<HookDeclaration['id']>;
+}
+interface HookDeclaration_With_params extends HookDeclaration {
+  +params: $NonMaybeType<HookDeclaration['params']>;
+}
+interface HookDeclaration_With_body extends HookDeclaration {
+  +body: $NonMaybeType<HookDeclaration['body']>;
+}
+interface HookDeclaration_With_typeParameters extends HookDeclaration {
+  +typeParameters: $NonMaybeType<HookDeclaration['typeParameters']>;
+}
+interface HookDeclaration_With_returnType extends HookDeclaration {
+  +returnType: $NonMaybeType<HookDeclaration['returnType']>;
+}
+interface HookTypeAnnotation_With_params extends HookTypeAnnotation {
+  +params: $NonMaybeType<HookTypeAnnotation['params']>;
+}
+interface HookTypeAnnotation_With_returnType extends HookTypeAnnotation {
+  +returnType: $NonMaybeType<HookTypeAnnotation['returnType']>;
+}
+interface HookTypeAnnotation_With_rest extends HookTypeAnnotation {
+  +rest: $NonMaybeType<HookTypeAnnotation['rest']>;
+}
+interface HookTypeAnnotation_With_typeParameters extends HookTypeAnnotation {
+  +typeParameters: $NonMaybeType<HookTypeAnnotation['typeParameters']>;
+}
 interface Identifier_With_name extends Identifier {
   +name: $NonMaybeType<Identifier['name']>;
 }
@@ -1320,6 +1353,9 @@ interface TypeCastExpression_With_typeAnnotation extends TypeCastExpression {
 interface TypeofTypeAnnotation_With_argument extends TypeofTypeAnnotation {
   +argument: $NonMaybeType<TypeofTypeAnnotation['argument']>;
 }
+interface TypeofTypeAnnotation_With_typeArguments extends TypeofTypeAnnotation {
+  +typeArguments: $NonMaybeType<TypeofTypeAnnotation['typeArguments']>;
+}
 interface TypeOperator_With_operator extends TypeOperator {
   +operator: $NonMaybeType<TypeOperator['operator']>;
 }
@@ -1442,6 +1478,7 @@ type DeclarationSpecialSelector =
   | ExportDefaultDeclaration
   | ExportNamedDeclaration
   | FunctionDeclaration
+  | HookDeclaration
   | ImportDeclaration
   | InterfaceDeclaration
   | TypeParameterDeclaration
@@ -1736,6 +1773,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DeclareFunction[predicate]'?: (
     node: DeclareFunction_With_predicate,
   ) => void,
+  +DeclareHook?: (node: DeclareHook) => void,
+  +'DeclareHook[id]'?: (node: DeclareHook_With_id) => void,
   +DeclareInterface?: (node: DeclareInterface) => void,
   +'DeclareInterface[id]'?: (node: DeclareInterface_With_id) => void,
   +'DeclareInterface[typeParameters]'?: (
@@ -1940,6 +1979,27 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'GenericTypeAnnotation[typeParameters]'?: (
     node: GenericTypeAnnotation_With_typeParameters,
   ) => void,
+  +HookDeclaration?: (node: HookDeclaration) => void,
+  +'HookDeclaration[id]'?: (node: HookDeclaration_With_id) => void,
+  +'HookDeclaration[params]'?: (node: HookDeclaration_With_params) => void,
+  +'HookDeclaration[body]'?: (node: HookDeclaration_With_body) => void,
+  +'HookDeclaration[typeParameters]'?: (
+    node: HookDeclaration_With_typeParameters,
+  ) => void,
+  +'HookDeclaration[returnType]'?: (
+    node: HookDeclaration_With_returnType,
+  ) => void,
+  +HookTypeAnnotation?: (node: HookTypeAnnotation) => void,
+  +'HookTypeAnnotation[params]'?: (
+    node: HookTypeAnnotation_With_params,
+  ) => void,
+  +'HookTypeAnnotation[returnType]'?: (
+    node: HookTypeAnnotation_With_returnType,
+  ) => void,
+  +'HookTypeAnnotation[rest]'?: (node: HookTypeAnnotation_With_rest) => void,
+  +'HookTypeAnnotation[typeParameters]'?: (
+    node: HookTypeAnnotation_With_typeParameters,
+  ) => void,
   +Identifier?: (node: Identifier) => void,
   +'Identifier[name]'?: (node: Identifier_With_name) => void,
   +'Identifier[typeAnnotation]'?: (
@@ -2395,6 +2455,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypeofTypeAnnotation[argument]'?: (
     node: TypeofTypeAnnotation_With_argument,
   ) => void,
+  +'TypeofTypeAnnotation[typeArguments]'?: (
+    node: TypeofTypeAnnotation_With_typeArguments,
+  ) => void,
   +TypeOperator?: (node: TypeOperator) => void,
   +'TypeOperator[operator]'?: (node: TypeOperator_With_operator) => void,
   +'TypeOperator[typeAnnotation]'?: (
@@ -2751,6 +2814,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DeclareFunction[predicate]:exit'?: (
     node: DeclareFunction_With_predicate,
   ) => void,
+  +'DeclareHook:exit'?: (node: DeclareHook) => void,
+  +'DeclareHook[id]:exit'?: (node: DeclareHook_With_id) => void,
   +'DeclareInterface:exit'?: (node: DeclareInterface) => void,
   +'DeclareInterface[id]:exit'?: (node: DeclareInterface_With_id) => void,
   +'DeclareInterface[typeParameters]:exit'?: (
@@ -2969,6 +3034,29 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'GenericTypeAnnotation[typeParameters]:exit'?: (
     node: GenericTypeAnnotation_With_typeParameters,
   ) => void,
+  +'HookDeclaration:exit'?: (node: HookDeclaration) => void,
+  +'HookDeclaration[id]:exit'?: (node: HookDeclaration_With_id) => void,
+  +'HookDeclaration[params]:exit'?: (node: HookDeclaration_With_params) => void,
+  +'HookDeclaration[body]:exit'?: (node: HookDeclaration_With_body) => void,
+  +'HookDeclaration[typeParameters]:exit'?: (
+    node: HookDeclaration_With_typeParameters,
+  ) => void,
+  +'HookDeclaration[returnType]:exit'?: (
+    node: HookDeclaration_With_returnType,
+  ) => void,
+  +'HookTypeAnnotation:exit'?: (node: HookTypeAnnotation) => void,
+  +'HookTypeAnnotation[params]:exit'?: (
+    node: HookTypeAnnotation_With_params,
+  ) => void,
+  +'HookTypeAnnotation[returnType]:exit'?: (
+    node: HookTypeAnnotation_With_returnType,
+  ) => void,
+  +'HookTypeAnnotation[rest]:exit'?: (
+    node: HookTypeAnnotation_With_rest,
+  ) => void,
+  +'HookTypeAnnotation[typeParameters]:exit'?: (
+    node: HookTypeAnnotation_With_typeParameters,
+  ) => void,
   +'Identifier:exit'?: (node: Identifier) => void,
   +'Identifier[name]:exit'?: (node: Identifier_With_name) => void,
   +'Identifier[typeAnnotation]:exit'?: (
@@ -3468,6 +3556,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypeofTypeAnnotation[argument]:exit'?: (
     node: TypeofTypeAnnotation_With_argument,
   ) => void,
+  +'TypeofTypeAnnotation[typeArguments]:exit'?: (
+    node: TypeofTypeAnnotation_With_typeArguments,
+  ) => void,
   +'TypeOperator:exit'?: (node: TypeOperator) => void,
   +'TypeOperator[operator]:exit'?: (node: TypeOperator_With_operator) => void,
   +'TypeOperator[typeAnnotation]:exit'?: (

package/dist/generated/predicates.js

@@ -64,6 +64,7 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
@@ -96,6 +97,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   IfStatement,
   ImportAttribute,
   ImportDeclaration,
@@ -266,6 +269,7 @@ exports.isDeclareEnum = isDeclareEnum;
 exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
 exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
 exports.isDeclareFunction = isDeclareFunction;
+exports.isDeclareHook = isDeclareHook;
 exports.isDeclareInterface = isDeclareInterface;
 exports.isDeclareKeyword = isDeclareKeyword;
 exports.isDeclareModule = isDeclareModule;
@@ -322,6 +326,8 @@ exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
 exports.isGetKeyword = isGetKeyword;
 exports.isGreaterThanOrEqualToToken = isGreaterThanOrEqualToToken;
 exports.isGreaterThanToken = isGreaterThanToken;
+exports.isHookDeclaration = isHookDeclaration;
+exports.isHookTypeAnnotation = isHookTypeAnnotation;
 exports.isIdentifier = isIdentifier;
 exports.isIfStatement = isIfStatement;
 exports.isIfToken = isIfToken;
@@ -805,6 +811,14 @@ function isDeclareFunction(node
   return node.type === 'DeclareFunction';
 }
 
+function isDeclareHook(node
+/*: ESNode | Token */
+)
+/*: node is DeclareHook */
+{
+  return node.type === 'DeclareHook';
+}
+
 function isDeclareInterface(node
 /*: ESNode | Token */
 )
@@ -1061,6 +1075,22 @@ function isGenericTypeAnnotation(node
   return node.type === 'GenericTypeAnnotation';
 }
 
+function isHookDeclaration(node
+/*: ESNode | Token */
+)
+/*: node is HookDeclaration */
+{
+  return node.type === 'HookDeclaration';
+}
+
+function isHookTypeAnnotation(node
+/*: ESNode | Token */
+)
+/*: node is HookTypeAnnotation */
+{
+  return node.type === 'HookTypeAnnotation';
+}
+
 function isIfStatement(node
 /*: ESNode | Token */
 )

package/dist/generated/predicates.js.flow

@@ -65,6 +65,7 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
@@ -97,6 +98,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   IfStatement,
   ImportAttribute,
   ImportDeclaration,
@@ -404,6 +407,11 @@ export function isDeclareFunction(node /*: ESNode | Token */) /*: node is Declar
 }
     
 
+export function isDeclareHook(node /*: ESNode | Token */) /*: node is DeclareHook */ {
+  return node.type === 'DeclareHook';
+}
+    
+
 export function isDeclareInterface(node /*: ESNode | Token */) /*: node is DeclareInterface */ {
   return node.type === 'DeclareInterface';
 }
@@ -564,6 +572,16 @@ export function isGenericTypeAnnotation(node /*: ESNode | Token */) /*: node is
 }
     
 
+export function isHookDeclaration(node /*: ESNode | Token */) /*: node is HookDeclaration */ {
+  return node.type === 'HookDeclaration';
+}
+    
+
+export function isHookTypeAnnotation(node /*: ESNode | Token */) /*: node is HookTypeAnnotation */ {
+  return node.type === 'HookTypeAnnotation';
+}
+    
+
 export function isIfStatement(node /*: ESNode | Token */) /*: node is IfStatement */ {
   return node.type === 'IfStatement';
 }

package/dist/predicates.js

@@ -62,77 +62,96 @@ Object.keys(_predicates).forEach(function (key) {
   exports[key] = _predicates[key];
 });
 
+// $FlowFixMe[deprecated-type]
 function isClass(node) {
   return (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isClassExpression)(node);
 }
 
-function isPropertyDefinitionWithNonComputedName(node) {
+function isPropertyDefinitionWithNonComputedName(node // $FlowFixMe[deprecated-type]
+) {
   return (0, _predicates.isPropertyDefinition)(node) && node.computed === false;
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isClassMember(node) {
   return (0, _predicates.isPropertyDefinition)(node) || (0, _predicates.isMethodDefinition)(node);
 }
 
-function isClassMemberWithNonComputedName(node) {
+function isClassMemberWithNonComputedName(node // $FlowFixMe[deprecated-type]
+) {
   return isClassMember(node) && node.computed === false;
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isComment(node) {
   return (0, _predicates.isBlockComment)(node) || (0, _predicates.isLineComment)(node);
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isFunction(node) {
   return (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isFunctionDeclaration)(node) || (0, _predicates.isFunctionExpression)(node);
 }
 
-function isMethodDefinitionWithNonComputedName(node) {
+function isMethodDefinitionWithNonComputedName(node // $FlowFixMe[deprecated-type]
+) {
   return (0, _predicates.isMethodDefinition)(node) && node.computed === false;
 }
 
-function isMemberExpressionWithNonComputedProperty(node) {
+function isMemberExpressionWithNonComputedProperty(node // $FlowFixMe[deprecated-type]
+) {
   return (0, _predicates.isMemberExpression)(node) && node.computed === false;
 }
 
-function isOptionalMemberExpressionWithNonComputedProperty(node) {
+function isOptionalMemberExpressionWithNonComputedProperty(node // $FlowFixMe[deprecated-type]
+) {
   return (0, _predicates.isMemberExpression)(node) && node.computed === false;
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isObjectPropertyWithShorthand(node) {
   return (0, _predicates.isProperty)(node) && node.shorthand === true;
 }
 
-function isObjectPropertyWithNonComputedName(node) {
+function isObjectPropertyWithNonComputedName(node // $FlowFixMe[deprecated-type]
+) {
   return (0, _predicates.isProperty)(node) && node.computed === false;
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isBigIntLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'bigint';
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isBooleanLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'boolean';
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isNullLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'null';
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isNumericLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'numeric';
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isRegExpLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'regexp';
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isStringLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'string';
-}
+} // $FlowFixMe[deprecated-type]
+
 
 function isExpression(node) {
-  return (0, _predicates.isThisExpression)(node) || (0, _predicates.isArrayExpression)(node) || (0, _predicates.isObjectExpression)(node) || (0, _predicates.isFunctionExpression)(node) || (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isYieldExpression)(node) || (0, _predicates.isLiteral)(node) || (0, _predicates.isUnaryExpression)(node) || (0, _predicates.isUpdateExpression)(node) || (0, _predicates.isBinaryExpression)(node) || (0, _predicates.isAssignmentExpression)(node) || (0, _predicates.isLogicalExpression)(node) || (0, _predicates.isMemberExpression)(node) || (0, _predicates.isConditionalExpression)(node) || (0, _predicates.isCallExpression)(node) || (0, _predicates.isNewExpression)(node) || (0, _predicates.isSequenceExpression)(node) || (0, _predicates.isTemplateLiteral)(node) || (0, _predicates.isTaggedTemplateExpression)(node) || (0, _predicates.isClassExpression)(node) || (0, _predicates.isMetaProperty)(node) || (0, _predicates.isIdentifier)(node) || (0, _predicates.isAwaitExpression)(node) || (0, _predicates.isImportExpression)(node) || (0, _predicates.isChainExpression)(node) || (0, _predicates.isTypeCastExpression)(node) || (0, _predicates.isJSXFragment)(node) || (0, _predicates.isJSXElement)(node);
-}
+  return (0, _predicates.isThisExpression)(node) || (0, _predicates.isArrayExpression)(node) || (0, _predicates.isObjectExpression)(node) || (0, _predicates.isFunctionExpression)(node) || (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isYieldExpression)(node) || (0, _predicates.isLiteral)(node) || (0, _predicates.isUnaryExpression)(node) || (0, _predicates.isUpdateExpression)(node) || (0, _predicates.isBinaryExpression)(node) || (0, _predicates.isAssignmentExpression)(node) || (0, _predicates.isLogicalExpression)(node) || (0, _predicates.isMemberExpression)(node) || (0, _predicates.isConditionalExpression)(node) || (0, _predicates.isCallExpression)(node) || (0, _predicates.isNewExpression)(node) || (0, _predicates.isSequenceExpression)(node) || (0, _predicates.isTemplateLiteral)(node) || (0, _predicates.isTaggedTemplateExpression)(node) || (0, _predicates.isClassExpression)(node) || (0, _predicates.isMetaProperty)(node) || (0, _predicates.isIdentifier)(node) || (0, _predicates.isAwaitExpression)(node) || (0, _predicates.isImportExpression)(node) || (0, _predicates.isChainExpression)(node) || (0, _predicates.isTypeCastExpression)(node) || (0, _predicates.isAsExpression)(node) || (0, _predicates.isJSXFragment)(node) || (0, _predicates.isJSXElement)(node);
+} // $FlowFixMe[deprecated-type]
+
 
 function isStatement(node) {
   return (0, _predicates.isBlockStatement)(node) || (0, _predicates.isBreakStatement)(node) || (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isContinueStatement)(node) || (0, _predicates.isDebuggerStatement)(node) || (0, _predicates.isDeclareClass)(node) || (0, _predicates.isDeclareVariable)(node) || (0, _predicates.isDeclareFunction)(node) || (0, _predicates.isDeclareInterface)(node) || (0, _predicates.isDeclareModule)(node) || (0, _predicates.isDeclareOpaqueType)(node) || (0, _predicates.isDeclareTypeAlias)(node) || (0, _predicates.isDoWhileStatement)(node) || (0, _predicates.isEmptyStatement)(node) || (0, _predicates.isEnumDeclaration)(node) || (0, _predicates.isExpressionStatement)(node) || (0, _predicates.isForInStatement)(node) || (0, _predicates.isForOfStatement)(node) || (0, _predicates.isForStatement)(node) || (0, _predicates.isFunctionDeclaration)(node) || (0, _predicates.isIfStatement)(node) || (0, _predicates.isInterfaceDeclaration)(node) || (0, _predicates.isLabeledStatement)(node) || (0, _predicates.isOpaqueType)(node) || (0, _predicates.isReturnStatement)(node) || (0, _predicates.isSwitchStatement)(node) || (0, _predicates.isThrowStatement)(node) || (0, _predicates.isTryStatement)(node) || (0, _predicates.isTypeAlias)(node) || (0, _predicates.isVariableDeclaration)(node) || (0, _predicates.isWhileStatement)(node) || (0, _predicates.isWithStatement)(node);

package/dist/predicates.js.flow

@@ -15,6 +15,7 @@ import type {ESNode, Token} from './types';
 import {
   isArrayExpression,
   isArrowFunctionExpression,
+  isAsExpression,
   isAssignmentExpression,
   isAwaitExpression,
   isBinaryExpression,
@@ -82,30 +83,36 @@ import {
 
 export * from './generated/predicates';
 
+// $FlowFixMe[deprecated-type]
 export function isClass(node: ESNode): boolean %checks {
   return isClassDeclaration(node) || isClassExpression(node);
 }
 
 export function isPropertyDefinitionWithNonComputedName(
   node: ESNode,
+  // $FlowFixMe[deprecated-type]
 ): boolean %checks {
   return isPropertyDefinition(node) && node.computed === false;
 }
 
+// $FlowFixMe[deprecated-type]
 export function isClassMember(node: ESNode): boolean %checks {
   return isPropertyDefinition(node) || isMethodDefinition(node);
 }
 
 export function isClassMemberWithNonComputedName(
   node: ESNode,
+  // $FlowFixMe[deprecated-type]
 ): boolean %checks {
   return isClassMember(node) && node.computed === false;
 }
 
+// $FlowFixMe[deprecated-type]
 export function isComment(node: ESNode | Token): boolean %checks {
   return isBlockComment(node) || isLineComment(node);
 }
 
+// $FlowFixMe[deprecated-type]
 export function isFunction(node: ESNode): boolean %checks {
   return (
     isArrowFunctionExpression(node) ||
@@ -116,56 +123,68 @@ export function isFunction(node: ESNode): boolean %checks {
 
 export function isMethodDefinitionWithNonComputedName(
   node: ESNode,
+  // $FlowFixMe[deprecated-type]
 ): boolean %checks {
   return isMethodDefinition(node) && node.computed === false;
 }
 
 export function isMemberExpressionWithNonComputedProperty(
   node: ESNode,
+  // $FlowFixMe[deprecated-type]
 ): boolean %checks {
   return isMemberExpression(node) && node.computed === false;
 }
 
 export function isOptionalMemberExpressionWithNonComputedProperty(
   node: ESNode,
+  // $FlowFixMe[deprecated-type]
 ): boolean %checks {
   return isMemberExpression(node) && node.computed === false;
 }
 
+// $FlowFixMe[deprecated-type]
 export function isObjectPropertyWithShorthand(node: ESNode): boolean %checks {
   return isProperty(node) && node.shorthand === true;
 }
 
 export function isObjectPropertyWithNonComputedName(
   node: ESNode,
+  // $FlowFixMe[deprecated-type]
 ): boolean %checks {
   return isProperty(node) && node.computed === false;
 }
 
+// $FlowFixMe[deprecated-type]
 export function isBigIntLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'bigint';
 }
 
+// $FlowFixMe[deprecated-type]
 export function isBooleanLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'boolean';
 }
 
+// $FlowFixMe[deprecated-type]
 export function isNullLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'null';
 }
 
+// $FlowFixMe[deprecated-type]
 export function isNumericLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'numeric';
 }
 
+// $FlowFixMe[deprecated-type]
 export function isRegExpLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'regexp';
 }
 
+// $FlowFixMe[deprecated-type]
 export function isStringLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'string';
 }
 
+// $FlowFixMe[deprecated-type]
 export function isExpression(node: ESNode): boolean %checks {
   return (
     isThisExpression(node) ||
@@ -194,11 +213,13 @@ export function isExpression(node: ESNode): boolean %checks {
     isImportExpression(node) ||
     isChainExpression(node) ||
     isTypeCastExpression(node) ||
+    isAsExpression(node) ||
     isJSXFragment(node) ||
     isJSXElement(node)
   );
 }
 
+// $FlowFixMe[deprecated-type]
 export function isStatement(node: ESNode): boolean %checks {
   return (
     isBlockStatement(node) ||

package/dist/types.js.flow

@@ -189,6 +189,7 @@ export type ESNode =
   | TypeParameterInstantiation
   | ComponentDeclaration
   | ComponentParameter
+  | HookDeclaration
   | EnumDeclaration
   | EnumNumberBody
   | EnumStringBody
@@ -236,6 +237,7 @@ export type Statement =
   | DebuggerStatement
   | DeclareClass
   | DeclareComponent
+  | DeclareHook
   | DeclareVariable
   | DeclareEnum
   | DeclareFunction
@@ -251,6 +253,7 @@ export type Statement =
   | ForOfStatement
   | ForStatement
   | FunctionDeclaration
+  | HookDeclaration
   | IfStatement
   | InterfaceDeclaration
   | LabeledStatement
@@ -402,6 +405,15 @@ export interface ComponentDeclaration extends BaseNode {
   +typeParameters: null | TypeParameterDeclaration;
 }
 
+export interface HookDeclaration extends BaseNode {
+  +type: 'HookDeclaration';
+  +id: Identifier;
+  +body: BlockStatement;
+  +params: $ReadOnlyArray<FunctionParameter>;
+  +returnType: null | TypeAnnotation;
+  +typeParameters: null | TypeParameterDeclaration;
+}
+
 export interface FunctionDeclaration extends BaseFunction {
   +type: 'FunctionDeclaration';
   /** It is null when a function declaration is a part of the `export default function` statement */
@@ -1048,7 +1060,8 @@ export interface ImportNamespaceSpecifier extends BaseNode {
 export type DefaultDeclaration =
   | FunctionDeclaration
   | ClassDeclaration
-  | ComponentDeclaration;
+  | ComponentDeclaration
+  | HookDeclaration;
 export type NamedDeclaration =
   | DefaultDeclaration
   | VariableDeclaration
@@ -1144,6 +1157,7 @@ export type TypeAnnotationType =
   | TypeOperator
   | TypePredicate
   | FunctionTypeAnnotation
+  | HookTypeAnnotation
   | ComponentTypeAnnotation
   | ObjectTypeAnnotation
   | IndexedAccessType
@@ -1262,6 +1276,7 @@ export interface QualifiedTypeofIdentifier extends BaseNode {
 export interface TypeofTypeAnnotation extends BaseNode {
   +type: 'TypeofTypeAnnotation';
   +argument: QualifiedTypeofIdentifier | Identifier;
+  +typeArguments?: TypeParameterInstantiation;
 }
 export interface KeyofTypeAnnotation extends BaseNode {
   +type: 'KeyofTypeAnnotation';
@@ -1372,6 +1387,13 @@ export interface FunctionTypeParam extends BaseNode {
 
   +parent: FunctionTypeAnnotation;
 }
+export interface HookTypeAnnotation extends BaseNode {
+  +type: 'HookTypeAnnotation';
+  +params: $ReadOnlyArray<FunctionTypeParam>;
+  +returnType: TypeAnnotationType;
+  +rest: null | FunctionTypeParam;
+  +typeParameters: null | TypeParameterDeclaration;
+}
 
 export interface ComponentTypeAnnotation extends BaseNode {
   +type: 'ComponentTypeAnnotation';
@@ -1653,6 +1675,7 @@ export interface EnumDefaultedMember extends BaseNode {
 export type DeclaredNode =
   | DeclareClass
   | DeclareComponent
+  | DeclareHook
   | DeclareVariable
   | DeclareEnum
   | DeclareFunction
@@ -1684,6 +1707,16 @@ export interface DeclareComponent extends BaseNode {
   +rendersType: null | RendersType;
 }
 
+export interface DeclareHook extends BaseNode {
+  +type: 'DeclareHook';
+  // the hook signature is stored as a type annotation on the ID
+  +id: interface extends Identifier {
+    +typeAnnotation: interface extends TypeAnnotation {
+      +typeAnnotation: HookTypeAnnotation,
+    },
+  };
+}
+
 export interface DeclareVariable extends BaseNode {
   +type: 'DeclareVariable';
   +id: Identifier;
@@ -1745,6 +1778,7 @@ export interface DeclareExportDefaultDeclaration
     | DeclareClass
     | DeclareFunction
     | DeclareComponent
+    | DeclareHook
     | TypeAnnotationType;
   +default: true;
   // default cannot have a source
@@ -1759,6 +1793,7 @@ export interface DeclareExportDeclarationNamedWithDeclaration
     | DeclareClass
     | DeclareFunction
     | DeclareComponent
+    | DeclareHook
     | DeclareInterface
     | DeclareOpaqueType
     | DeclareVariable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-estree",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
   "main": "dist/index.js",
   "license": "MIT",