hermes-transform 0.18.2 → 0.19.1

package/dist/generated/TransformCloneSignatures.js.flow

@@ -62,9 +62,11 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
+  DeclareNamespace,
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
@@ -94,6 +96,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -237,9 +241,11 @@ import type {
   DeclareExportAllDeclarationProps,
   DeclareExportDeclarationProps,
   DeclareFunctionProps,
+  DeclareHookProps,
   DeclareInterfaceProps,
   DeclareModuleProps,
   DeclareModuleExportsProps,
+  DeclareNamespaceProps,
   DeclareOpaqueTypeProps,
   DeclareTypeAliasProps,
   DeclareVariableProps,
@@ -269,6 +275,8 @@ import type {
   FunctionTypeAnnotationProps,
   FunctionTypeParamProps,
   GenericTypeAnnotationProps,
+  HookDeclarationProps,
+  HookTypeAnnotationProps,
   IdentifierProps,
   IfStatementProps,
   ImportAttributeProps,
@@ -693,6 +701,14 @@ type DeclareFunctionCloneSignature = ((
     node: ?DeclareFunction,
     newProps: Partial<DeclareFunctionProps>,
   ) => DetachedNode<DeclareFunction> | null);
+type DeclareHookCloneSignature = ((
+  node: DeclareHook,
+  newProps: Partial<DeclareHookProps>,
+) => DetachedNode<DeclareHook>) &
+  ((
+    node: ?DeclareHook,
+    newProps: Partial<DeclareHookProps>,
+  ) => DetachedNode<DeclareHook> | null);
 type DeclareInterfaceCloneSignature = ((
   node: DeclareInterface,
   newProps: Partial<DeclareInterfaceProps>,
@@ -717,6 +733,14 @@ type DeclareModuleExportsCloneSignature = ((
     node: ?DeclareModuleExports,
     newProps: Partial<DeclareModuleExportsProps>,
   ) => DetachedNode<DeclareModuleExports> | null);
+type DeclareNamespaceCloneSignature = ((
+  node: DeclareNamespace,
+  newProps: Partial<DeclareNamespaceProps>,
+) => DetachedNode<DeclareNamespace>) &
+  ((
+    node: ?DeclareNamespace,
+    newProps: Partial<DeclareNamespaceProps>,
+  ) => DetachedNode<DeclareNamespace> | null);
 type DeclareOpaqueTypeCloneSignature = ((
   node: DeclareOpaqueType,
   newProps: Partial<DeclareOpaqueTypeProps>,
@@ -949,6 +973,22 @@ type GenericTypeAnnotationCloneSignature = ((
     node: ?GenericTypeAnnotation,
     newProps: Partial<GenericTypeAnnotationProps>,
   ) => DetachedNode<GenericTypeAnnotation> | null);
+type HookDeclarationCloneSignature = ((
+  node: HookDeclaration,
+  newProps: Partial<HookDeclarationProps>,
+) => DetachedNode<HookDeclaration>) &
+  ((
+    node: ?HookDeclaration,
+    newProps: Partial<HookDeclarationProps>,
+  ) => DetachedNode<HookDeclaration> | null);
+type HookTypeAnnotationCloneSignature = ((
+  node: HookTypeAnnotation,
+  newProps: Partial<HookTypeAnnotationProps>,
+) => DetachedNode<HookTypeAnnotation>) &
+  ((
+    node: ?HookTypeAnnotation,
+    newProps: Partial<HookTypeAnnotationProps>,
+  ) => DetachedNode<HookTypeAnnotation> | null);
 type IdentifierCloneSignature = ((
   node: Identifier,
   newProps: Partial<IdentifierProps>,
@@ -1794,9 +1834,11 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   DeclareExportAllDeclarationCloneSignature &
   DeclareExportDeclarationCloneSignature &
   DeclareFunctionCloneSignature &
+  DeclareHookCloneSignature &
   DeclareInterfaceCloneSignature &
   DeclareModuleCloneSignature &
   DeclareModuleExportsCloneSignature &
+  DeclareNamespaceCloneSignature &
   DeclareOpaqueTypeCloneSignature &
   DeclareTypeAliasCloneSignature &
   DeclareVariableCloneSignature &
@@ -1826,6 +1868,8 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   FunctionTypeAnnotationCloneSignature &
   FunctionTypeParamCloneSignature &
   GenericTypeAnnotationCloneSignature &
+  HookDeclarationCloneSignature &
+  HookTypeAnnotationCloneSignature &
   IdentifierCloneSignature &
   IfStatementCloneSignature &
   ImportAttributeCloneSignature &

package/dist/generated/TransformModifySignatures.js.flow

@@ -62,9 +62,11 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
+  DeclareNamespace,
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
@@ -94,6 +96,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -237,9 +241,11 @@ import type {
   DeclareExportAllDeclarationProps,
   DeclareExportDeclarationProps,
   DeclareFunctionProps,
+  DeclareHookProps,
   DeclareInterfaceProps,
   DeclareModuleProps,
   DeclareModuleExportsProps,
+  DeclareNamespaceProps,
   DeclareOpaqueTypeProps,
   DeclareTypeAliasProps,
   DeclareVariableProps,
@@ -269,6 +275,8 @@ import type {
   FunctionTypeAnnotationProps,
   FunctionTypeParamProps,
   GenericTypeAnnotationProps,
+  HookDeclarationProps,
+  HookTypeAnnotationProps,
   IdentifierProps,
   IfStatementProps,
   ImportAttributeProps,
@@ -532,6 +540,10 @@ type DeclareFunctionModifySignature = (
   node: ?DeclareFunction,
   newProps: Partial<DeclareFunctionProps>,
 ) => void;
+type DeclareHookModifySignature = (
+  node: ?DeclareHook,
+  newProps: Partial<DeclareHookProps>,
+) => void;
 type DeclareInterfaceModifySignature = (
   node: ?DeclareInterface,
   newProps: Partial<DeclareInterfaceProps>,
@@ -544,6 +556,10 @@ type DeclareModuleExportsModifySignature = (
   node: ?DeclareModuleExports,
   newProps: Partial<DeclareModuleExportsProps>,
 ) => void;
+type DeclareNamespaceModifySignature = (
+  node: ?DeclareNamespace,
+  newProps: Partial<DeclareNamespaceProps>,
+) => void;
 type DeclareOpaqueTypeModifySignature = (
   node: ?DeclareOpaqueType,
   newProps: Partial<DeclareOpaqueTypeProps>,
@@ -660,6 +676,14 @@ type GenericTypeAnnotationModifySignature = (
   node: ?GenericTypeAnnotation,
   newProps: Partial<GenericTypeAnnotationProps>,
 ) => void;
+type HookDeclarationModifySignature = (
+  node: ?HookDeclaration,
+  newProps: Partial<HookDeclarationProps>,
+) => void;
+type HookTypeAnnotationModifySignature = (
+  node: ?HookTypeAnnotation,
+  newProps: Partial<HookTypeAnnotationProps>,
+) => void;
 type IdentifierModifySignature = (
   node: ?Identifier,
   newProps: Partial<IdentifierProps>,
@@ -1104,9 +1128,11 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   DeclareExportAllDeclarationModifySignature &
   DeclareExportDeclarationModifySignature &
   DeclareFunctionModifySignature &
+  DeclareHookModifySignature &
   DeclareInterfaceModifySignature &
   DeclareModuleModifySignature &
   DeclareModuleExportsModifySignature &
+  DeclareNamespaceModifySignature &
   DeclareOpaqueTypeModifySignature &
   DeclareTypeAliasModifySignature &
   DeclareVariableModifySignature &
@@ -1136,6 +1162,8 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   FunctionTypeAnnotationModifySignature &
   FunctionTypeParamModifySignature &
   GenericTypeAnnotationModifySignature &
+  HookDeclarationModifySignature &
+  HookTypeAnnotationModifySignature &
   IdentifierModifySignature &
   IfStatementModifySignature &
   ImportAttributeModifySignature &

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -60,9 +60,11 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
+  DeclareNamespace,
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
@@ -92,6 +94,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -384,6 +388,11 @@ type DeclareFunctionReplaceSignature = (
   nodeToReplaceWith: DetachedNode<DeclareFunction>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type DeclareHookReplaceSignature = (
+  target: DeclareHook,
+  nodeToReplaceWith: DetachedNode<DeclareHook>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type DeclareInterfaceReplaceSignature = (
   target: DeclareInterface,
   nodeToReplaceWith: DetachedNode<DeclareInterface>,
@@ -399,6 +408,11 @@ type DeclareModuleExportsReplaceSignature = (
   nodeToReplaceWith: DetachedNode<DeclareModuleExports>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type DeclareNamespaceReplaceSignature = (
+  target: DeclareNamespace,
+  nodeToReplaceWith: DetachedNode<DeclareNamespace>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type DeclareOpaqueTypeReplaceSignature = (
   target: DeclareOpaqueType,
   nodeToReplaceWith: DetachedNode<DeclareOpaqueType>,
@@ -544,6 +558,16 @@ type GenericTypeAnnotationReplaceSignature = (
   nodeToReplaceWith: DetachedNode<GenericTypeAnnotation>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type HookDeclarationReplaceSignature = (
+  target: HookDeclaration,
+  nodeToReplaceWith: DetachedNode<HookDeclaration>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type HookTypeAnnotationReplaceSignature = (
+  target: HookTypeAnnotation,
+  nodeToReplaceWith: DetachedNode<HookTypeAnnotation>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type IdentifierReplaceSignature = (
   target: Identifier,
   nodeToReplaceWith: DetachedNode<Identifier>,
@@ -1077,9 +1101,11 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   DeclareExportAllDeclarationReplaceSignature &
   DeclareExportDeclarationReplaceSignature &
   DeclareFunctionReplaceSignature &
+  DeclareHookReplaceSignature &
   DeclareInterfaceReplaceSignature &
   DeclareModuleReplaceSignature &
   DeclareModuleExportsReplaceSignature &
+  DeclareNamespaceReplaceSignature &
   DeclareOpaqueTypeReplaceSignature &
   DeclareTypeAliasReplaceSignature &
   DeclareVariableReplaceSignature &
@@ -1109,6 +1135,8 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   FunctionTypeAnnotationReplaceSignature &
   FunctionTypeParamReplaceSignature &
   GenericTypeAnnotationReplaceSignature &
+  HookDeclarationReplaceSignature &
+  HookTypeAnnotationReplaceSignature &
   IdentifierReplaceSignature &
   IfStatementReplaceSignature &
   ImportAttributeReplaceSignature &

package/dist/generated/node-types.js

@@ -62,6 +62,7 @@ var _exportNames = {
   DeclareInterface: true,
   DeclareModule: true,
   DeclareModuleExports: true,
+  DeclareNamespace: true,
   DeclareOpaqueType: true,
   DeclareTypeAlias: true,
   DeclareVariable: true,
@@ -90,6 +91,8 @@ var _exportNames = {
   FunctionTypeAnnotation: true,
   FunctionTypeParam: true,
   GenericTypeAnnotation: true,
+  HookDeclaration: true,
+  HookTypeAnnotation: true,
   IfStatement: true,
   ImportAttribute: true,
   ImportDeclaration: true,
@@ -220,6 +223,7 @@ exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
 exports.DeclareInterface = DeclareInterface;
 exports.DeclareModule = DeclareModule;
 exports.DeclareModuleExports = DeclareModuleExports;
+exports.DeclareNamespace = DeclareNamespace;
 exports.DeclareOpaqueType = DeclareOpaqueType;
 exports.DeclareTypeAlias = DeclareTypeAlias;
 exports.DeclareVariable = DeclareVariable;
@@ -249,6 +253,8 @@ exports.FunctionExpression = FunctionExpression;
 exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
 exports.FunctionTypeParam = FunctionTypeParam;
 exports.GenericTypeAnnotation = GenericTypeAnnotation;
+exports.HookDeclaration = HookDeclaration;
+exports.HookTypeAnnotation = HookTypeAnnotation;
 exports.IfStatement = IfStatement;
 exports.ImportAttribute = ImportAttribute;
 exports.ImportDeclaration = ImportDeclaration;
@@ -713,8 +719,7 @@ function DeclareModule(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareModule',
     id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
-    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body),
-    kind: props.kind
+    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
@@ -729,6 +734,16 @@ function DeclareModuleExports(props) {
   return node;
 }
 
+function DeclareNamespace(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'DeclareNamespace',
+    id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
+    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function DeclareOpaqueType(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareOpaqueType',
@@ -1026,6 +1041,31 @@ function GenericTypeAnnotation(props) {
   return node;
 }
 
+function HookDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'HookDeclaration',
+    id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
+    params: props.params.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body),
+    typeParameters: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeParameters),
+    returnType: (0, _detachedNode.asDetachedNodeForCodeGen)(props.returnType)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function HookTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'HookTypeAnnotation',
+    params: props.params.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    returnType: (0, _detachedNode.asDetachedNodeForCodeGen)(props.returnType),
+    rest: (0, _detachedNode.asDetachedNodeForCodeGen)(props.rest),
+    typeParameters: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeParameters)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function IfStatement(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'IfStatement',
@@ -1789,7 +1829,8 @@ function TypeCastExpression(props) {
 function TypeofTypeAnnotation(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeofTypeAnnotation',
-    argument: (0, _detachedNode.asDetachedNodeForCodeGen)(props.argument)
+    argument: (0, _detachedNode.asDetachedNodeForCodeGen)(props.argument),
+    typeArguments: (0, _detachedNode.asDetachedNodeForCodeGen)(props.typeArguments)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;

package/dist/generated/node-types.js.flow

@@ -60,6 +60,7 @@ import type {
   DeclareInterface as DeclareInterfaceType,
   DeclareModule as DeclareModuleType,
   DeclareModuleExports as DeclareModuleExportsType,
+  DeclareNamespace as DeclareNamespaceType,
   DeclareOpaqueType as DeclareOpaqueTypeType,
   DeclareTypeAlias as DeclareTypeAliasType,
   DeclareVariable as DeclareVariableType,
@@ -88,6 +89,8 @@ import type {
   FunctionTypeAnnotation as FunctionTypeAnnotationType,
   FunctionTypeParam as FunctionTypeParamType,
   GenericTypeAnnotation as GenericTypeAnnotationType,
+  HookDeclaration as HookDeclarationType,
+  HookTypeAnnotation as HookTypeAnnotationType,
   IfStatement as IfStatementType,
   ImportAttribute as ImportAttributeType,
   ImportDeclaration as ImportDeclarationType,
@@ -405,7 +408,6 @@ export type DeclareInterfaceProps = {
 export type DeclareModuleProps = {
   +id: MaybeDetachedNode<DeclareModuleType['id']>,
   +body: MaybeDetachedNode<DeclareModuleType['body']>,
-  +kind: DeclareModuleType['kind'],
 };
 
 export type DeclareModuleExportsProps = {
@@ -414,6 +416,11 @@ export type DeclareModuleExportsProps = {
   >,
 };
 
+export type DeclareNamespaceProps = {
+  +id: MaybeDetachedNode<DeclareNamespaceType['id']>,
+  +body: MaybeDetachedNode<DeclareNamespaceType['body']>,
+};
+
 export type DeclareOpaqueTypeProps = {
   +id: MaybeDetachedNode<DeclareOpaqueTypeType['id']>,
   +typeParameters?: ?MaybeDetachedNode<DeclareOpaqueTypeType['typeParameters']>,
@@ -593,6 +600,27 @@ export type GenericTypeAnnotationProps = {
   >,
 };
 
+export type HookDeclarationProps = {
+  +id: MaybeDetachedNode<HookDeclarationType['id']>,
+  +params: $ReadOnlyArray<
+    MaybeDetachedNode<HookDeclarationType['params'][number]>,
+  >,
+  +body: MaybeDetachedNode<HookDeclarationType['body']>,
+  +typeParameters?: ?MaybeDetachedNode<HookDeclarationType['typeParameters']>,
+  +returnType?: ?MaybeDetachedNode<HookDeclarationType['returnType']>,
+};
+
+export type HookTypeAnnotationProps = {
+  +params: $ReadOnlyArray<
+    MaybeDetachedNode<HookTypeAnnotationType['params'][number]>,
+  >,
+  +returnType: MaybeDetachedNode<HookTypeAnnotationType['returnType']>,
+  +rest?: ?MaybeDetachedNode<HookTypeAnnotationType['rest']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    HookTypeAnnotationType['typeParameters'],
+  >,
+};
+
 export type IfStatementProps = {
   +test: MaybeDetachedNode<IfStatementType['test']>,
   +consequent: MaybeDetachedNode<IfStatementType['consequent']>,
@@ -1024,6 +1052,9 @@ export type TypeCastExpressionProps = {
 
 export type TypeofTypeAnnotationProps = {
   +argument: MaybeDetachedNode<TypeofTypeAnnotationType['argument']>,
+  +typeArguments?: ?MaybeDetachedNode<
+    TypeofTypeAnnotationType['typeArguments'],
+  >,
 };
 
 export type TypeOperatorProps = {
@@ -1576,7 +1607,6 @@ export function DeclareModule(props: {
     type: 'DeclareModule',
     id: asDetachedNodeForCodeGen(props.id),
     body: asDetachedNodeForCodeGen(props.body),
-    kind: props.kind,
   });
   setParentPointersInDirectChildren(node);
   return node;
@@ -1594,6 +1624,19 @@ export function DeclareModuleExports(props: {
   return node;
 }
 
+export function DeclareNamespace(props: {
+  ...$ReadOnly<DeclareNamespaceProps>,
+  +parent?: ESNode,
+}): DetachedNode<DeclareNamespaceType> {
+  const node = detachedProps<DeclareNamespaceType>(props.parent, {
+    type: 'DeclareNamespace',
+    id: asDetachedNodeForCodeGen(props.id),
+    body: asDetachedNodeForCodeGen(props.body),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function DeclareOpaqueType(props: {
   ...$ReadOnly<DeclareOpaqueTypeProps>,
   +parent?: ESNode,
@@ -1975,6 +2018,37 @@ export function GenericTypeAnnotation(props: {
   return node;
 }
 
+export function HookDeclaration(props: {
+  ...$ReadOnly<HookDeclarationProps>,
+  +parent?: ESNode,
+}): DetachedNode<HookDeclarationType> {
+  const node = detachedProps<HookDeclarationType>(props.parent, {
+    type: 'HookDeclaration',
+    id: asDetachedNodeForCodeGen(props.id),
+    params: props.params.map(n => asDetachedNodeForCodeGen(n)),
+    body: asDetachedNodeForCodeGen(props.body),
+    typeParameters: asDetachedNodeForCodeGen(props.typeParameters),
+    returnType: asDetachedNodeForCodeGen(props.returnType),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export function HookTypeAnnotation(props: {
+  ...$ReadOnly<HookTypeAnnotationProps>,
+  +parent?: ESNode,
+}): DetachedNode<HookTypeAnnotationType> {
+  const node = detachedProps<HookTypeAnnotationType>(props.parent, {
+    type: 'HookTypeAnnotation',
+    params: props.params.map(n => asDetachedNodeForCodeGen(n)),
+    returnType: asDetachedNodeForCodeGen(props.returnType),
+    rest: asDetachedNodeForCodeGen(props.rest),
+    typeParameters: asDetachedNodeForCodeGen(props.typeParameters),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
 export function IfStatement(props: {
   ...$ReadOnly<IfStatementProps>,
   +parent?: ESNode,
@@ -2971,6 +3045,7 @@ export function TypeofTypeAnnotation(props: {
   const node = detachedProps<TypeofTypeAnnotationType>(props.parent, {
     type: 'TypeofTypeAnnotation',
     argument: asDetachedNodeForCodeGen(props.argument),
+    typeArguments: asDetachedNodeForCodeGen(props.typeArguments),
   });
   setParentPointersInDirectChildren(node);
   return node;

package/dist/generated/special-case-node-types/DeclareHook.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeclareHook = DeclareHook;
+
+var _detachedNode = require("../../detachedNode");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function DeclareHook(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'DeclareHook',
+    id: (0, _detachedNode.detachedProps)(null, {
+      type: 'Identifier',
+      name: props.name,
+      typeAnnotation: (0, _detachedNode.detachedProps)(null, {
+        type: 'TypeAnnotation',
+        typeAnnotation: (0, _detachedNode.asDetachedNode)(props.functionType)
+      })
+    })
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}

package/dist/generated/special-case-node-types/DeclareHook.js.flow

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {
+  DeclareHook as DeclareHookType,
+  ESNode,
+  FunctionTypeAnnotation as FunctionTypeAnnotationType,
+} from 'hermes-estree';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
+
+import {
+  asDetachedNode,
+  detachedProps,
+  setParentPointersInDirectChildren,
+} from '../../detachedNode';
+
+// the type annotation is stored on the Identifier's typeAnnotation
+// which is super awkward to work with and type - so we flatten the input
+// and put it in the right spot after
+export type DeclareHookProps = {
+  +name: string,
+  +functionType: MaybeDetachedNode<FunctionTypeAnnotationType>,
+};
+export function DeclareHook(props: {
+  ...$ReadOnly<DeclareHookProps>,
+  +parent?: ESNode,
+}): DetachedNode<DeclareHookType> {
+  const node = detachedProps<DeclareHookType>(props.parent, {
+    type: 'DeclareHook',
+    id: detachedProps(null, {
+      type: 'Identifier',
+      name: props.name,
+      typeAnnotation: detachedProps(null, {
+        type: 'TypeAnnotation',
+        typeAnnotation: asDetachedNode(props.functionType),
+      }),
+    }),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}

package/dist/generated/special-case-node-types.js

@@ -58,4 +58,12 @@ Object.keys(_Property).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _Property[key]) return;
   exports[key] = _Property[key];
+});
+
+var _DeclareHook = require("./special-case-node-types/DeclareHook");
+
+Object.keys(_DeclareHook).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DeclareHook[key]) return;
+  exports[key] = _DeclareHook[key];
 });

package/dist/generated/special-case-node-types.js.flow

@@ -21,3 +21,4 @@ export * from './special-case-node-types/Literal';
 export * from './special-case-node-types/ObjectTypeProperty';
 export * from './special-case-node-types/misc';
 export * from './special-case-node-types/Property';
+export * from './special-case-node-types/DeclareHook';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.18.2",
+  "version": "0.19.1",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,13 +12,13 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.18.2",
-    "hermes-estree": "0.18.2",
-    "hermes-parser": "0.18.2"
+    "hermes-eslint": "0.19.1",
+    "hermes-estree": "0.19.1",
+    "hermes-parser": "0.19.1"
   },
   "peerDependencies": {
     "prettier": "^3.0.0 || ^2.7.1",
-    "prettier-plugin-hermes-parser": "0.18.2"
+    "prettier-plugin-hermes-parser": "0.19.1"
   },
   "files": [
     "dist",