hermes-transform 0.6.0 → 0.9.0

package/dist/transform/mutations/CloneCommentsTo.js.flow

@@ -36,13 +36,12 @@ export function createCloneCommentsToMutation(
 }
 
 export function performCloneCommentsToMutation(
-  mutationContext: MutationContext,
+  _mutationContext: MutationContext,
   mutation: CloneCommentsToMutation,
 ): null {
   const newComments = [];
   for (const originalComment of getCommentsForNode(mutation.target)) {
     const comment = cloneCommentWithMarkers(originalComment);
-    mutationContext.appendCommentToSource(comment);
     newComments.push(comment);
   }
   addCommentsToNode(mutation.destination, newComments);

package/dist/transform/mutations/InsertStatement.js

@@ -43,6 +43,7 @@ function createInsertStatementMutation(side, target, nodesToInsert) {
 }
 
 function performInsertStatementMutation(mutationContext, mutation) {
+  mutationContext.assertNotDeleted(mutation.target, `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`);
   const insertionParent = (0, _getStatementParent.getStatementParent)(mutation.target); // enforce that if we are inserting module declarations - they are being inserted in a valid location
 
   if (!(0, _isValidModuleDeclarationParent.isValidModuleDeclarationParent)(insertionParent.parent, mutation.nodesToInsert)) {
@@ -57,7 +58,7 @@ function performInsertStatementMutation(mutationContext, mutation) {
     switch (mutation.side) {
       case 'before':
         {
-          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex - 1, mutation.nodesToInsert);
+          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
           break;
         }
 
@@ -85,5 +86,6 @@ function performInsertStatementMutation(mutationContext, mutation) {
     parent: insertionParent.parent
   });
   insertionParent.parent[insertionParent.key] = blockStatement;
+  statementToWrap.parent = blockStatement;
   return insertionParent.parent;
 }

package/dist/transform/mutations/InsertStatement.js.flow

@@ -46,6 +46,11 @@ export function performInsertStatementMutation(
   mutationContext: MutationContext,
   mutation: InsertStatementMutation,
 ): ESNode {
+  mutationContext.assertNotDeleted(
+    mutation.target,
+    `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`,
+  );
+
   const insertionParent = getStatementParent(mutation.target);
 
   // enforce that if we are inserting module declarations - they are being inserted in a valid location
@@ -70,7 +75,7 @@ export function performInsertStatementMutation(
       case 'before': {
         parent[insertionParent.key] = insertInArray(
           parent[insertionParent.key],
-          insertionParent.targetIndex - 1,
+          insertionParent.targetIndex,
           mutation.nodesToInsert,
         );
         break;
@@ -108,6 +113,7 @@ export function performInsertStatementMutation(
 
   (insertionParent.parent: interface {[string]: mixed})[insertionParent.key] =
     blockStatement;
+  statementToWrap.parent = blockStatement;
 
   return insertionParent.parent;
 }

package/dist/transform/mutations/RemoveNode.js

@@ -46,8 +46,7 @@ function getRemovalParent(node) {
 
     switch (node.type) {
       // ClassMember
-      case 'ClassProperty':
-      case 'ClassPrivateProperty':
+      case 'PropertyDefinition':
       case 'MethodDefinition':
         assertParent('ClassBody');
         return 'body';
@@ -70,6 +69,14 @@ function getRemovalParent(node) {
         assertParent('FunctionTypeAnnotation');
         return 'params';
 
+      case 'JSXAttribute':
+        assertParent('JSXOpeningElement');
+        return 'attributes';
+
+      case 'ImportDeclaration':
+        assertParent('Program');
+        return 'body';
+
       case 'ObjectTypeCallProperty':
         assertParent('ObjectTypeAnnotation');
         return 'callProperties';
@@ -161,7 +168,7 @@ function getRemovalParent(node) {
     const idx = arr.indexOf(node);
 
     if (idx === -1) {
-      throw new _Errors.InvalidRemovalError(`Could not find target in array of \`${parent.type}.${key}\`.`);
+      throw new _Errors.InvalidRemovalError(`Could not find target in array of \`${node.parent.type}.${key}\`.`);
     }
 
     return idx;

package/dist/transform/mutations/RemoveNode.js.flow

@@ -17,6 +17,8 @@ import type {
   EnumStringMember,
   FunctionParameter,
   FunctionTypeParam,
+  JSXAttribute,
+  ImportDeclaration,
   ObjectTypeCallProperty,
   ObjectTypeIndexer,
   ObjectTypeInternalSlot,
@@ -41,6 +43,8 @@ export type RemoveNodeMutation = $ReadOnly<{
     | EnumStringMember
     | FunctionParameter
     | FunctionTypeParam
+    | JSXAttribute
+    | ImportDeclaration
     | ObjectTypeCallProperty
     | ObjectTypeIndexer
     | ObjectTypeInternalSlot
@@ -102,8 +106,7 @@ function getRemovalParent(node: RemoveNodeMutation['node']): $ReadOnly<{
 
     switch (node.type) {
       // ClassMember
-      case 'ClassProperty':
-      case 'ClassPrivateProperty':
+      case 'PropertyDefinition':
       case 'MethodDefinition':
         assertParent('ClassBody');
         return 'body';
@@ -126,6 +129,14 @@ function getRemovalParent(node: RemoveNodeMutation['node']): $ReadOnly<{
         assertParent('FunctionTypeAnnotation');
         return 'params';
 
+      case 'JSXAttribute':
+        assertParent('JSXOpeningElement');
+        return 'attributes';
+
+      case 'ImportDeclaration':
+        assertParent('Program');
+        return 'body';
+
       case 'ObjectTypeCallProperty':
         assertParent('ObjectTypeAnnotation');
         return 'callProperties';
@@ -244,7 +255,7 @@ function getRemovalParent(node: RemoveNodeMutation['node']): $ReadOnly<{
     const idx = arr.indexOf(node);
     if (idx === -1) {
       throw new InvalidRemovalError(
-        `Could not find target in array of \`${parent.type}.${key}\`.`,
+        `Could not find target in array of \`${node.parent.type}.${key}\`.`,
       );
     }
     return idx;

package/dist/transform/mutations/ReplaceNode.js

@@ -12,6 +12,8 @@ var _comments = require("../comments/comments");
 
 var _Errors = require("../Errors");
 
+var _detachedNode = require("../../detachedNode");
+
 var _getVisitorKeys = require("../../getVisitorKeys");
 
 /**
@@ -71,7 +73,10 @@ function getParentKey(target) {
       }
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
-        if (parent[key][i] === target) {
+        const current = parent[key][i];
+        const originalNode = (0, _detachedNode.getOriginalNode)(current);
+
+        if (current === target || originalNode === target) {
           return {
             type: 'array',
             parent,
@@ -84,5 +89,5 @@ function getParentKey(target) {
   } // this shouldn't happen ever
 
 
-  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${target.type}.`);
+  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
 }

package/dist/transform/mutations/ReplaceNode.js.flow

@@ -15,6 +15,7 @@ import type {DetachedNode} from '../../detachedNode';
 import {replaceInArray} from './utils/arrayUtils';
 import {moveCommentsToNewNode} from '../comments/comments';
 import {InvalidReplacementError} from '../Errors';
+import {getOriginalNode} from '../../detachedNode';
 import {getVisitorKeys, isNode} from '../../getVisitorKeys';
 
 export type ReplaceNodeMutation = $ReadOnly<{
@@ -99,7 +100,9 @@ function getParentKey(target: ESNode): $ReadOnly<
       }
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
-        if (parent[key][i] === target) {
+        const current = parent[key][i];
+        const originalNode = getOriginalNode(current);
+        if (current === target || originalNode === target) {
           return {type: 'array', parent, key, targetIndex: i};
         }
       }
@@ -108,6 +111,6 @@ function getParentKey(target: ESNode): $ReadOnly<
 
   // this shouldn't happen ever
   throw new InvalidReplacementError(
-    `Expected to find the ${target.type} as a direct child of the ${target.type}.`,
+    `Expected to find the ${target.type} as a direct child of the ${parent.type}.`,
   );
 }

package/dist/transform/mutations/ReplaceStatementWithMany.js.flow

@@ -19,11 +19,14 @@ import {moveCommentsToNewNode} from '../comments/comments';
 import {InvalidReplacementError} from '../Errors';
 import * as t from '../../generated/node-types';
 
+export type ReplaceStatementWithManyMutationNodes =
+  | ModuleDeclaration
+  | Statement;
 export type ReplaceStatementWithManyMutation = $ReadOnly<{
   type: 'replaceStatementWithMany',
-  target: ModuleDeclaration | Statement,
+  target: ReplaceStatementWithManyMutationNodes,
   nodesToReplaceWith: $ReadOnlyArray<
-    DetachedNode<ModuleDeclaration | Statement>,
+    DetachedNode<ReplaceStatementWithManyMutationNodes>,
   >,
   keepComments: boolean,
 }>;

package/dist/transform/mutations/utils/arrayUtils.js

@@ -16,14 +16,28 @@ exports.replaceInArray = replaceInArray;
  * 
  * @format
  */
+function assertArrayBounds(array, index) {
+  if (index < 0 || index >= array.length) {
+    throw new Error(`Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`);
+  }
+}
+
 function insertInArray(array, index, elements) {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+
+  assertArrayBounds(array, index);
   return array.slice(0, index).concat(elements).concat(array.slice(index));
 }
 
 function removeFromArray(array, index) {
+  assertArrayBounds(array, index);
   return [...array.slice(0, index), ...array.slice(index + 1)];
 }
 
 function replaceInArray(array, index, elements) {
+  assertArrayBounds(array, index);
   return array.slice(0, index).concat(elements).concat(array.slice(index + 1));
 }

package/dist/transform/mutations/utils/arrayUtils.js.flow

@@ -8,11 +8,24 @@
  * @format
  */
 
+function assertArrayBounds<T>(array: $ReadOnlyArray<T>, index: number): void {
+  if (index < 0 || index >= array.length) {
+    throw new Error(
+      `Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`,
+    );
+  }
+}
+
 export function insertInArray<T>(
   array: $ReadOnlyArray<T>,
   index: number,
   elements: $ReadOnlyArray<T>,
 ): Array<T> {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+  assertArrayBounds(array, index);
   return array.slice(0, index).concat(elements).concat(array.slice(index));
 }
 
@@ -20,6 +33,7 @@ export function removeFromArray<T>(
   array: $ReadOnlyArray<T>,
   index: number,
 ): Array<T> {
+  assertArrayBounds(array, index);
   return [...array.slice(0, index), ...array.slice(index + 1)];
 }
 
@@ -28,6 +42,7 @@ export function replaceInArray<T>(
   index: number,
   elements: $ReadOnlyArray<T>,
 ): Array<T> {
+  assertArrayBounds(array, index);
   return array
     .slice(0, index)
     .concat(elements)

package/dist/transform/transform.js

@@ -33,16 +33,26 @@ function transform(originalCode, visitors, prettierOptions = {}) {
 
   if (!astWasMutated) {
     return originalCode;
-  } // prettier fully expects the parent pointers are NOT set and
-  // certain cases can crash due to prettier infinite-looping
-  // whilst naively traversing the parent property
-  // https://github.com/prettier/prettier/issues/11793
-
+  }
 
   _SimpleTraverser.SimpleTraverser.traverse(ast, {
     enter(node) {
+      // prettier fully expects the parent pointers are NOT set and
+      // certain cases can crash due to prettier infinite-looping
+      // whilst naively traversing the parent property
+      // https://github.com/prettier/prettier/issues/11793
       // $FlowExpectedError[cannot-write]
-      delete node.parent;
+      delete node.parent; // prettier currently relies on the AST being in the old-school, deprecated AST format for optional chaining
+      // so we have to apply their transform to our AST so it can actually format it.
+
+      if (node.type === 'ChainExpression') {
+        const newNode = transformChainExpression(node.expression); // $FlowExpectedError[cannot-write]
+
+        delete node.expression; // $FlowExpectedError[prop-missing]
+        // $FlowExpectedError[cannot-write]
+
+        Object.assign(node, newNode);
+      }
     },
 
     leave() {}
@@ -62,4 +72,26 @@ function transform(originalCode, visitors, prettierOptions = {}) {
     }
 
   });
+} // https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
+
+
+function transformChainExpression(node) {
+  switch (node.type) {
+    case 'CallExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalCallExpression'; // $FlowExpectedError[cannot-write]
+
+      node.callee = transformChainExpression(node.callee);
+      break;
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalMemberExpression'; // $FlowExpectedError[cannot-write]
+
+      node.object = transformChainExpression(node.object);
+      break;
+    // No default
+  }
+
+  return node;
 }

package/dist/transform/transform.js.flow

@@ -10,14 +10,15 @@
 
 'use strict';
 
+import type {ESNode} from 'hermes-estree';
 import type {Visitor} from '../traverse/traverse';
-import type {TransformContext} from './TransformContext';
+import type {TransformContextAdditions} from './TransformContext';
 
 import * as prettier from 'prettier';
 import {getTransformedAST} from './getTransformedAST';
 import {SimpleTraverser} from '../traverse/SimpleTraverser';
 
-export type TransformVisitor = Visitor<TransformContext>;
+export type TransformVisitor = Visitor<TransformContextAdditions>;
 
 export function transform(
   originalCode: string,
@@ -33,14 +34,25 @@ export function transform(
     return originalCode;
   }
 
-  // prettier fully expects the parent pointers are NOT set and
-  // certain cases can crash due to prettier infinite-looping
-  // whilst naively traversing the parent property
-  // https://github.com/prettier/prettier/issues/11793
   SimpleTraverser.traverse(ast, {
     enter(node) {
+      // prettier fully expects the parent pointers are NOT set and
+      // certain cases can crash due to prettier infinite-looping
+      // whilst naively traversing the parent property
+      // https://github.com/prettier/prettier/issues/11793
       // $FlowExpectedError[cannot-write]
       delete node.parent;
+
+      // prettier currently relies on the AST being in the old-school, deprecated AST format for optional chaining
+      // so we have to apply their transform to our AST so it can actually format it.
+      if (node.type === 'ChainExpression') {
+        const newNode = transformChainExpression(node.expression);
+        // $FlowExpectedError[cannot-write]
+        delete node.expression;
+        // $FlowExpectedError[prop-missing]
+        // $FlowExpectedError[cannot-write]
+        Object.assign(node, newNode);
+      }
     },
     leave() {},
   });
@@ -62,3 +74,25 @@ export function transform(
     },
   );
 }
+
+// https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
+function transformChainExpression(node: ESNode) {
+  switch (node.type) {
+    case 'CallExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalCallExpression';
+      // $FlowExpectedError[cannot-write]
+      node.callee = transformChainExpression(node.callee);
+      break;
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-write]
+      node.type = 'OptionalMemberExpression';
+      // $FlowExpectedError[cannot-write]
+      node.object = transformChainExpression(node.object);
+      break;
+    // No default
+  }
+
+  return node;
+}

package/dist/traverse/NodeEventGenerator.js.flow

@@ -34,7 +34,7 @@ type ParsedSelector = $ReadOnly<{
 
 const ESQUERY_OPTIONS: ESQueryOptions = Object.freeze({
   visitorKeys: VisitorKeys,
-  fallback: node => {
+  fallback: (node: ESNode) => {
     throw new Error(`No visitor keys found for node type "${node.type}".`);
   },
 });

package/dist/traverse/traverse.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.traverse = traverse;
 exports.traverseWithContext = traverseWithContext;
 
+var _codeFrame = require("@babel/code-frame");
+
 var _NodeEventGenerator = require("./NodeEventGenerator");
 
 var _SafeEmitter = require("./SafeEmitter");
@@ -28,7 +30,7 @@ var _SimpleTraverser = require("./SimpleTraverser");
  * @param scopeManager the eslint-scope compatible scope manager instance calculated using the ast
  * @param additionalContext a callback function which returns additional context members to add to the context provided to the visitor
  */
-function traverseWithContext(ast, scopeManager, additionalContext, visitor) {
+function traverseWithContext(code, ast, scopeManager, additionalContext, visitor) {
   const emitter = new _SafeEmitter.SafeEmitter();
   const nodeQueue = [];
   let currentNode = ast; // set parent pointers and build up the traversal queue
@@ -72,6 +74,28 @@ function traverseWithContext(ast, scopeManager, additionalContext, visitor) {
   };
 
   const traversalContextBase = Object.freeze({
+    buildCodeFrame: (node, message) => {
+      // babel uses 1-indexed columns
+      const locForBabel = {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + 1
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1
+        }
+      };
+      return (0, _codeFrame.codeFrameColumns)(code, locForBabel, {
+        linesAbove: 0,
+        linesBelow: 0,
+        highlightCode: process.env.NODE_ENV !== 'test',
+        message: message
+      });
+    },
+    buildSimpleCodeFrame: (node, message) => {
+      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
+    },
     getDeclaredVariables: node => scopeManager.getDeclaredVariables(node),
     getBinding: name => {
       let currentScope = getScope();
@@ -122,6 +146,6 @@ function traverseWithContext(ast, scopeManager, additionalContext, visitor) {
   });
 }
 
-function traverse(ast, scopeManager, visitor) {
-  traverseWithContext(ast, scopeManager, () => {}, visitor);
+function traverse(code, ast, scopeManager, visitor) {
+  traverseWithContext(code, ast, scopeManager, () => {}, visitor);
 }

package/dist/traverse/traverse.js.flow

@@ -12,11 +12,12 @@ import type {ESNode, ESQueryNodeSelectors, Program} from 'hermes-estree';
 import type {ScopeManager, Scope, Variable} from 'hermes-eslint';
 import type {EmitterListener} from './SafeEmitter';
 
+import {codeFrameColumns} from '@babel/code-frame';
 import {NodeEventGenerator} from './NodeEventGenerator';
 import {SafeEmitter} from './SafeEmitter';
 import {SimpleTraverser} from './SimpleTraverser';
 
-export type TraversalContext<T = void> = $ReadOnly<{
+export type TraversalContextBase = $ReadOnly<{
   /**
    * Gets the variables that were declared by the given node.
    */
@@ -31,13 +32,36 @@ export type TraversalContext<T = void> = $ReadOnly<{
    * Defaults to the currently traversed node.
    */
   getScope: (node?: ESNode) => Scope,
-
+  /**
+   * Creates a full code frame for the node along with the message.
+   *
+   * i.e. `context.buildCodeFrame(node, 'foo')` will create a string like:
+   * ```
+   * 56 | function () {
+   *    | ^^^^^^^^^^^^^
+   * 57 | }.bind(this)
+   *    | ^^ foo
+   * ```
+   */
+  buildCodeFrame: (node: ESNode, message: string) => string,
+  /**
+   * Creates a simple code frame for the node along with the message.
+   * Use this if you want a condensed marker for your message.
+   *
+   * i.e. `context.logWithNode(node, 'foo')` will create a string like:
+   * ```
+   * [FunctionExpression:56:44] foo
+   * ```
+   * (where 56:44 represents L56, Col44)
+   */
+  buildSimpleCodeFrame: (node: ESNode, message: string) => string,
+}>;
+export type TraversalContext<T> = $ReadOnly<{
+  ...TraversalContextBase,
   ...T,
 }>;
 
-export type Visitor<T = void> = (
-  context: TraversalContext<T>,
-) => ESQueryNodeSelectors;
+export type Visitor<T> = (context: TraversalContext<T>) => ESQueryNodeSelectors;
 
 /**
  * Traverse the AST with additional context members provided by `additionalContext`.
@@ -45,10 +69,11 @@ export type Visitor<T = void> = (
  * @param scopeManager the eslint-scope compatible scope manager instance calculated using the ast
  * @param additionalContext a callback function which returns additional context members to add to the context provided to the visitor
  */
-export function traverseWithContext<T = void>(
+export function traverseWithContext<T = TraversalContextBase>(
+  code: string,
   ast: Program,
   scopeManager: ScopeManager,
-  additionalContext: (TraversalContext<void>) => T,
+  additionalContext: TraversalContextBase => T,
   visitor: Visitor<T>,
 ): void {
   const emitter = new SafeEmitter();
@@ -86,11 +111,36 @@ export function traverseWithContext<T = void>(
     return scopeManager.scopes[0];
   };
 
-  const traversalContextBase: TraversalContext<void> = Object.freeze({
+  const traversalContextBase: TraversalContextBase = Object.freeze({
+    buildCodeFrame: (node: ESNode, message: string): string => {
+      // babel uses 1-indexed columns
+      const locForBabel = {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + 1,
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1,
+        },
+      };
+      return codeFrameColumns(code, locForBabel, {
+        linesAbove: 0,
+        linesBelow: 0,
+        highlightCode: process.env.NODE_ENV !== 'test',
+        message: message,
+      });
+    },
+
+    buildSimpleCodeFrame: (node: ESNode, message: string): string => {
+      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
+    },
+
     getDeclaredVariables: (node: ESNode) =>
       scopeManager.getDeclaredVariables(node),
+
     getBinding: (name: string) => {
-      let currentScope = getScope();
+      let currentScope: null | Scope = getScope();
 
       while (currentScope != null) {
         for (const variable of currentScope.variables) {
@@ -103,8 +153,10 @@ export function traverseWithContext<T = void>(
 
       return null;
     },
+
     getScope,
   });
+
   const traversalContext: TraversalContext<T> = Object.freeze({
     ...traversalContextBase,
     ...additionalContext(traversalContextBase),
@@ -141,9 +193,10 @@ export function traverseWithContext<T = void>(
 }
 
 export function traverse(
+  code: string,
   ast: Program,
   scopeManager: ScopeManager,
   visitor: Visitor<void>,
 ): void {
-  traverseWithContext(ast, scopeManager, () => {}, visitor);
+  traverseWithContext(code, ast, scopeManager, () => {}, visitor);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -11,13 +11,18 @@
   "dependencies": {
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
-    "hermes-eslint": "0.6.0",
-    "hermes-estree": "0.6.0"
+    "flow-enums-runtime": "^0.0.6",
+    "hermes-eslint": "0.9.0",
+    "hermes-estree": "0.9.0"
   },
   "peerDependencies": {
     "prettier": "^2.4.1"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENCE",
+    "ESLINT_LICENCE",
+    "PRETTIER_LICENCE",
+    "README.md"
   ]
 }