hermes-transform 0.18.2 → 0.19.0

package/dist/generated/TransformCloneSignatures.js.flow

@@ -62,6 +62,7 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
@@ -94,6 +95,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -237,6 +240,7 @@ import type {
   DeclareExportAllDeclarationProps,
   DeclareExportDeclarationProps,
   DeclareFunctionProps,
+  DeclareHookProps,
   DeclareInterfaceProps,
   DeclareModuleProps,
   DeclareModuleExportsProps,
@@ -269,6 +273,8 @@ import type {
   FunctionTypeAnnotationProps,
   FunctionTypeParamProps,
   GenericTypeAnnotationProps,
+  HookDeclarationProps,
+  HookTypeAnnotationProps,
   IdentifierProps,
   IfStatementProps,
   ImportAttributeProps,
@@ -693,6 +699,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>,
@@ -949,6 +963,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,6 +1824,7 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   DeclareExportAllDeclarationCloneSignature &
   DeclareExportDeclarationCloneSignature &
   DeclareFunctionCloneSignature &
+  DeclareHookCloneSignature &
   DeclareInterfaceCloneSignature &
   DeclareModuleCloneSignature &
   DeclareModuleExportsCloneSignature &
@@ -1826,6 +1857,8 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   FunctionTypeAnnotationCloneSignature &
   FunctionTypeParamCloneSignature &
   GenericTypeAnnotationCloneSignature &
+  HookDeclarationCloneSignature &
+  HookTypeAnnotationCloneSignature &
   IdentifierCloneSignature &
   IfStatementCloneSignature &
   ImportAttributeCloneSignature &

package/dist/generated/TransformModifySignatures.js.flow

@@ -62,6 +62,7 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
@@ -94,6 +95,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -237,6 +240,7 @@ import type {
   DeclareExportAllDeclarationProps,
   DeclareExportDeclarationProps,
   DeclareFunctionProps,
+  DeclareHookProps,
   DeclareInterfaceProps,
   DeclareModuleProps,
   DeclareModuleExportsProps,
@@ -269,6 +273,8 @@ import type {
   FunctionTypeAnnotationProps,
   FunctionTypeParamProps,
   GenericTypeAnnotationProps,
+  HookDeclarationProps,
+  HookTypeAnnotationProps,
   IdentifierProps,
   IfStatementProps,
   ImportAttributeProps,
@@ -532,6 +538,10 @@ type DeclareFunctionModifySignature = (
   node: ?DeclareFunction,
   newProps: Partial<DeclareFunctionProps>,
 ) => void;
+type DeclareHookModifySignature = (
+  node: ?DeclareHook,
+  newProps: Partial<DeclareHookProps>,
+) => void;
 type DeclareInterfaceModifySignature = (
   node: ?DeclareInterface,
   newProps: Partial<DeclareInterfaceProps>,
@@ -660,6 +670,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,6 +1122,7 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   DeclareExportAllDeclarationModifySignature &
   DeclareExportDeclarationModifySignature &
   DeclareFunctionModifySignature &
+  DeclareHookModifySignature &
   DeclareInterfaceModifySignature &
   DeclareModuleModifySignature &
   DeclareModuleExportsModifySignature &
@@ -1136,6 +1155,8 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   FunctionTypeAnnotationModifySignature &
   FunctionTypeParamModifySignature &
   GenericTypeAnnotationModifySignature &
+  HookDeclarationModifySignature &
+  HookTypeAnnotationModifySignature &
   IdentifierModifySignature &
   IfStatementModifySignature &
   ImportAttributeModifySignature &

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -60,6 +60,7 @@ import type {
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
+  DeclareHook,
   DeclareInterface,
   DeclareModule,
   DeclareModuleExports,
@@ -92,6 +93,8 @@ import type {
   FunctionTypeAnnotation,
   FunctionTypeParam,
   GenericTypeAnnotation,
+  HookDeclaration,
+  HookTypeAnnotation,
   Identifier,
   IfStatement,
   ImportAttribute,
@@ -384,6 +387,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>,
@@ -544,6 +552,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,6 +1095,7 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   DeclareExportAllDeclarationReplaceSignature &
   DeclareExportDeclarationReplaceSignature &
   DeclareFunctionReplaceSignature &
+  DeclareHookReplaceSignature &
   DeclareInterfaceReplaceSignature &
   DeclareModuleReplaceSignature &
   DeclareModuleExportsReplaceSignature &
@@ -1109,6 +1128,8 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   FunctionTypeAnnotationReplaceSignature &
   FunctionTypeParamReplaceSignature &
   GenericTypeAnnotationReplaceSignature &
+  HookDeclarationReplaceSignature &
+  HookTypeAnnotationReplaceSignature &
   IdentifierReplaceSignature &
   IfStatementReplaceSignature &
   ImportAttributeReplaceSignature &

package/dist/generated/node-types.js

@@ -90,6 +90,8 @@ var _exportNames = {
   FunctionTypeAnnotation: true,
   FunctionTypeParam: true,
   GenericTypeAnnotation: true,
+  HookDeclaration: true,
+  HookTypeAnnotation: true,
   IfStatement: true,
   ImportAttribute: true,
   ImportDeclaration: true,
@@ -249,6 +251,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;
@@ -1026,6 +1030,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 +1818,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

@@ -88,6 +88,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,
@@ -593,6 +595,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 +1047,9 @@ export type TypeCastExpressionProps = {
 
 export type TypeofTypeAnnotationProps = {
   +argument: MaybeDetachedNode<TypeofTypeAnnotationType['argument']>,
+  +typeArguments?: ?MaybeDetachedNode<
+    TypeofTypeAnnotationType['typeArguments'],
+  >,
 };
 
 export type TypeOperatorProps = {
@@ -1975,6 +2001,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 +3028,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.0",
   "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.0",
+    "hermes-estree": "0.19.0",
+    "hermes-parser": "0.19.0"
   },
   "peerDependencies": {
     "prettier": "^3.0.0 || ^2.7.1",
-    "prettier-plugin-hermes-parser": "0.18.2"
+    "prettier-plugin-hermes-parser": "0.19.0"
   },
   "files": [
     "dist",