hermes-estree 0.15.1 → 0.17.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -28,6 +28,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsExpression,
   AssignmentExpression,
   AssignmentPattern,
   AwaitExpression,
@@ -175,6 +176,7 @@ import type {
   TypeAnnotation,
   TypeCastExpression,
   TypeofTypeAnnotation,
+  TypeOperator,
   TypeParameter,
   TypeParameterDeclaration,
   TypeParameterInstantiation,
@@ -235,6 +237,12 @@ interface ArrowFunctionExpression_With_expression
 interface ArrowFunctionExpression_With_async extends ArrowFunctionExpression {
   +async: $NonMaybeType<ArrowFunctionExpression['async']>;
 }
+interface AsExpression_With_expression extends AsExpression {
+  +expression: $NonMaybeType<AsExpression['expression']>;
+}
+interface AsExpression_With_typeAnnotation extends AsExpression {
+  +typeAnnotation: $NonMaybeType<AsExpression['typeAnnotation']>;
+}
 interface AssignmentExpression_With_operator extends AssignmentExpression {
   +operator: $NonMaybeType<AssignmentExpression['operator']>;
 }
@@ -1312,6 +1320,12 @@ interface TypeCastExpression_With_typeAnnotation extends TypeCastExpression {
 interface TypeofTypeAnnotation_With_argument extends TypeofTypeAnnotation {
   +argument: $NonMaybeType<TypeofTypeAnnotation['argument']>;
 }
+interface TypeOperator_With_operator extends TypeOperator {
+  +operator: $NonMaybeType<TypeOperator['operator']>;
+}
+interface TypeOperator_With_typeAnnotation extends TypeOperator {
+  +typeAnnotation: $NonMaybeType<TypeOperator['typeAnnotation']>;
+}
 interface TypeParameter_With_name extends TypeParameter {
   +name: $NonMaybeType<TypeParameter['name']>;
 }
@@ -1438,6 +1452,7 @@ type ExpressionSpecialSelector =
   | MetaProperty
   | ArrayExpression
   | ArrowFunctionExpression
+  | AsExpression
   | AssignmentExpression
   | AwaitExpression
   | BinaryExpression
@@ -1507,6 +1522,11 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ArrowFunctionExpression[async]'?: (
     node: ArrowFunctionExpression_With_async,
   ) => void,
+  +AsExpression?: (node: AsExpression) => void,
+  +'AsExpression[expression]'?: (node: AsExpression_With_expression) => void,
+  +'AsExpression[typeAnnotation]'?: (
+    node: AsExpression_With_typeAnnotation,
+  ) => void,
   +AssignmentExpression?: (node: AssignmentExpression) => void,
   +'AssignmentExpression[operator]'?: (
     node: AssignmentExpression_With_operator,
@@ -2375,6 +2395,11 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypeofTypeAnnotation[argument]'?: (
     node: TypeofTypeAnnotation_With_argument,
   ) => void,
+  +TypeOperator?: (node: TypeOperator) => void,
+  +'TypeOperator[operator]'?: (node: TypeOperator_With_operator) => void,
+  +'TypeOperator[typeAnnotation]'?: (
+    node: TypeOperator_With_typeAnnotation,
+  ) => void,
   +TypeParameter?: (node: TypeParameter) => void,
   +'TypeParameter[name]'?: (node: TypeParameter_With_name) => void,
   +'TypeParameter[bound]'?: (node: TypeParameter_With_bound) => void,
@@ -2484,6 +2509,13 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ArrowFunctionExpression[async]:exit'?: (
     node: ArrowFunctionExpression_With_async,
   ) => void,
+  +'AsExpression:exit'?: (node: AsExpression) => void,
+  +'AsExpression[expression]:exit'?: (
+    node: AsExpression_With_expression,
+  ) => void,
+  +'AsExpression[typeAnnotation]:exit'?: (
+    node: AsExpression_With_typeAnnotation,
+  ) => void,
   +'AssignmentExpression:exit'?: (node: AssignmentExpression) => void,
   +'AssignmentExpression[operator]:exit'?: (
     node: AssignmentExpression_With_operator,
@@ -3436,6 +3468,11 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypeofTypeAnnotation[argument]:exit'?: (
     node: TypeofTypeAnnotation_With_argument,
   ) => void,
+  +'TypeOperator:exit'?: (node: TypeOperator) => void,
+  +'TypeOperator[operator]:exit'?: (node: TypeOperator_With_operator) => void,
+  +'TypeOperator[typeAnnotation]:exit'?: (
+    node: TypeOperator_With_typeAnnotation,
+  ) => void,
   +'TypeParameter:exit'?: (node: TypeParameter) => void,
   +'TypeParameter[name]:exit'?: (node: TypeParameter_With_name) => void,
   +'TypeParameter[bound]:exit'?: (node: TypeParameter_With_bound) => void,

package/dist/generated/predicates.js

@@ -29,6 +29,7 @@ exports.isArrayExpression = isArrayExpression;
 exports.isArrayPattern = isArrayPattern;
 exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
 exports.isArrowFunctionExpression = isArrowFunctionExpression;
+exports.isAsExpression = isAsExpression;
 exports.isAsKeyword = isAsKeyword;
 exports.isAssignmentExpression = isAssignmentExpression;
 exports.isAssignmentPattern = isAssignmentPattern;
@@ -276,6 +277,7 @@ exports.isTypeAnnotation = isTypeAnnotation;
 exports.isTypeCastExpression = isTypeCastExpression;
 exports.isTypeKeyword = isTypeKeyword;
 exports.isTypeOfToken = isTypeOfToken;
+exports.isTypeOperator = isTypeOperator;
 exports.isTypeParameter = isTypeParameter;
 exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
 exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
@@ -319,6 +321,10 @@ function isArrowFunctionExpression(node) {
   return node.type === 'ArrowFunctionExpression';
 }
 
+function isAsExpression(node) {
+  return node.type === 'AsExpression';
+}
+
 function isAssignmentExpression(node) {
   return node.type === 'AssignmentExpression';
 }
@@ -903,6 +909,10 @@ function isTypeofTypeAnnotation(node) {
   return node.type === 'TypeofTypeAnnotation';
 }
 
+function isTypeOperator(node) {
+  return node.type === 'TypeOperator';
+}
+
 function isTypeParameter(node) {
   return node.type === 'TypeParameter';
 }

package/dist/generated/predicates.js.flow

@@ -45,6 +45,10 @@ export function isArrowFunctionExpression(
   return node.type === 'ArrowFunctionExpression';
 }
 
+export function isAsExpression(node: ESNode | Token): boolean %checks {
+  return node.type === 'AsExpression';
+}
+
 export function isAssignmentExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'AssignmentExpression';
 }
@@ -687,6 +691,10 @@ export function isTypeofTypeAnnotation(node: ESNode | Token): boolean %checks {
   return node.type === 'TypeofTypeAnnotation';
 }
 
+export function isTypeOperator(node: ESNode | Token): boolean %checks {
+  return node.type === 'TypeOperator';
+}
+
 export function isTypeParameter(node: ESNode | Token): boolean %checks {
   return node.type === 'TypeParameter';
 }

package/dist/types.js.flow

@@ -398,7 +398,7 @@ export interface ComponentDeclaration extends BaseNode {
   +body: BlockStatement;
   +id: Identifier;
   +params: $ReadOnlyArray<ComponentParameterAndRestElement>;
-  +rendersType: null | TypeAnnotation;
+  +rendersType: null | TypeOperator;
   +typeParameters: null | TypeParameterDeclaration;
 }
 
@@ -451,6 +451,7 @@ export type Expression =
   | ImportExpression
   | ChainExpression
   | TypeCastExpression
+  | AsExpression
   | JSXFragment
   | JSXElement;
 
@@ -544,8 +545,8 @@ export interface DestructuringObjectPropertyWithShorthandStaticName
   +computed: false;
   // shorthand keys *must* be identifiers
   +key: Identifier;
-  // shorthand values *must* be identifiers (that look the same as the key)
-  +value: Identifier;
+  // shorthand values *must* be identifiers or assignments (that look the same as the key)
+  +value: Identifier | AssignmentPattern;
   +shorthand: true;
 }
 export interface DestructuringObjectPropertyWithComputedName
@@ -700,7 +701,7 @@ export type Literal =
 
 export interface BigIntLiteral extends BaseNode {
   +type: 'Literal';
-  +value: null /* | bigint */;
+  +value: bigint;
   +bigint: string;
   +raw: string;
   +literalType: 'bigint';
@@ -1067,7 +1068,7 @@ export interface ExportNamedDeclarationWithSpecifiers
   extends ExportNamedDeclarationBase {
   +type: 'ExportNamedDeclaration';
   +declaration: null;
-  +source: null;
+  +source?: StringLiteral | null;
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
 }
 export interface ExportNamedDeclarationWithDeclaration
@@ -1140,6 +1141,7 @@ export type TypeAnnotationType =
   | UnionTypeAnnotation
   | IntersectionTypeAnnotation
   | ConditionalTypeAnnotation
+  | TypeOperator
   | TypePredicate
   | FunctionTypeAnnotation
   | ComponentTypeAnnotation
@@ -1223,7 +1225,7 @@ export interface NumberLiteralTypeAnnotation extends BaseNode {
 export interface BigIntLiteralTypeAnnotation extends BaseNode {
   +type: 'BigIntLiteralTypeAnnotation';
   +bigint: string;
-  +value: null /* | bigint */;
+  +value: bigint;
   +raw: string;
 }
 export interface BooleanLiteralTypeAnnotation extends BaseNode {
@@ -1320,6 +1322,13 @@ export interface ConditionalTypeAnnotation extends BaseNode {
   +falseType: TypeAnnotationType;
 }
 
+export interface TypeOperator extends BaseNode {
+  +type: 'TypeOperator';
+  // Supported type operators, currently only "renders".
+  +operator: 'renders';
+  +typeAnnotation: TypeAnnotationType;
+}
+
 export interface TypePredicate extends BaseNode {
   +type: 'TypePredicate';
   +parameterName: Identifier;
@@ -1349,7 +1358,7 @@ export interface ComponentTypeAnnotation extends BaseNode {
   +params: $ReadOnlyArray<ComponentTypeParameter>;
   +rest: null | ComponentTypeParameter;
   +typeParameters: null | TypeParameterDeclaration;
-  +rendersType: null | TypeAnnotationType;
+  +rendersType: null | TypeOperator;
 }
 export interface ComponentTypeParameter extends BaseNode {
   +type: 'ComponentTypeParameter';
@@ -1368,7 +1377,7 @@ export interface InferredPredicate extends BaseNode {
 
 export interface ObjectTypeAnnotation extends BaseNode {
   +type: 'ObjectTypeAnnotation';
-  +inexact: false;
+  +inexact: boolean;
   +exact: boolean;
   +properties: $ReadOnlyArray<
     | ObjectTypeProperty
@@ -1479,6 +1488,11 @@ export interface TypeCastExpression extends BaseNode {
   +expression: Expression;
   +typeAnnotation: TypeAnnotation;
 }
+export interface AsExpression extends BaseNode {
+  +type: 'AsExpression';
+  +expression: Expression;
+  +typeAnnotation: TypeAnnotation;
+}
 
 interface BaseInterfaceNode extends BaseNode {
   +body: ObjectTypeAnnotation;
@@ -1647,7 +1661,7 @@ export interface DeclareComponent extends BaseNode {
   +params: Array<ComponentTypeParameter>;
   +rest: null | ComponentTypeParameter;
   +typeParameters: null | TypeParameterDeclaration;
-  +rendersType: null | TypeAnnotation;
+  +rendersType: null | TypeOperator;
 }
 
 export interface DeclareVariable extends BaseNode {
@@ -1707,7 +1721,11 @@ interface DeclareExportDeclarationBase extends BaseNode {
 export interface DeclareExportDefaultDeclaration
   extends DeclareExportDeclarationBase {
   +type: 'DeclareExportDeclaration';
-  +declaration: DeclareClass | DeclareFunction | TypeAnnotationType;
+  +declaration:
+    | DeclareClass
+    | DeclareFunction
+    | DeclareComponent
+    | TypeAnnotationType;
   +default: true;
   // default cannot have a source
   +source: null;
@@ -1720,6 +1738,7 @@ export interface DeclareExportDeclarationNamedWithDeclaration
   +declaration:
     | DeclareClass
     | DeclareFunction
+    | DeclareComponent
     | DeclareInterface
     | DeclareOpaqueType
     | DeclareVariable

package/package.json

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