hermes-transform 0.8.0 → 0.10.0

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

@@ -14,261 +14,10 @@ The list of exported functions here must be kept in sync with the `NODES_WITH_SP
 list in `scripts/genTransformNodeTypes` to ensure there's no duplicates
 */
 
-import type {
-  ESNode,
-  ArrowFunctionExpression as ArrowFunctionExpressionType,
-  RegExpLiteral as RegExpLiteralType,
-  TemplateElement as TemplateElementType,
-  Identifier as IdentifierType,
-  BigIntLiteral as BigIntLiteralType,
-  BooleanLiteral as BooleanLiteralType,
-  NumericLiteral as NumericLiteralType,
-  NullLiteral as NullLiteralType,
-  StringLiteral as StringLiteralType,
-  LineComment as LineCommentType,
-  BlockComment as BlockCommentType,
-} from 'hermes-estree';
-import type {DetachedNode} from '../detachedNode';
-
-import {
-  detachedProps,
-  setParentPointersInDirectChildren,
-} from '../detachedNode';
-
-// hermes adds an `id` prop which is always null, and it adds an `expression`
-// boolean which is true when the body isn't a BlockStatement.
-// No need to make consumers set these
-export type ArrowFunctionExpressionProps = {
-  +params: $ReadOnlyArray<
-    DetachedNode<ArrowFunctionExpressionType['params'][number]>,
-  >,
-  +body: DetachedNode<ArrowFunctionExpressionType['body']>,
-  +typeParameters?: ?DetachedNode<
-    ArrowFunctionExpressionType['typeParameters'],
-  >,
-  +returnType?: ?DetachedNode<ArrowFunctionExpressionType['returnType']>,
-  +predicate?: ?DetachedNode<ArrowFunctionExpressionType['predicate']>,
-  +async: ArrowFunctionExpressionType['async'],
-};
-export function ArrowFunctionExpression({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ArrowFunctionExpressionProps>,
-  +parent?: ESNode,
-}): DetachedNode<ArrowFunctionExpressionType> {
-  const node = detachedProps<ArrowFunctionExpressionType>(parent, {
-    type: 'ArrowFunctionExpression',
-    id: null,
-    // $FlowExpectedError[incompatible-use]
-    expression: props.body.type !== 'BlockStatement',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-// pattern/flags are on a subobject in the estree spec, but are flat on the hermes types
-// also the value is supposed to be a RegExp instance
-export type RegExpLiteralProps = {
-  +pattern: RegExpLiteralType['regex']['pattern'],
-  +flags: RegExpLiteralType['regex']['flags'],
-};
-export function RegExpLiteral({
-  pattern,
-  flags,
-  parent,
-}: {
-  ...$ReadOnly<RegExpLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<RegExpLiteralType> {
-  const value = new RegExp(pattern, flags);
-  return detachedProps<RegExpLiteralType>(parent, {
-    type: 'Literal',
-    value,
-    raw: value.toString(),
-    regex: {
-      pattern,
-      flags,
-    },
-  });
-}
-
-// raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
-export type TemplateElementProps = {
-  +tail: TemplateElementType['tail'],
-  +cooked: TemplateElementType['value']['cooked'],
-  +raw: TemplateElementType['value']['raw'],
-};
-export function TemplateElement({
-  tail,
-  parent,
-  ...value
-}: {
-  ...$ReadOnly<TemplateElementProps>,
-  +parent?: ESNode,
-}): DetachedNode<TemplateElementType> {
-  return detachedProps<TemplateElementType>(parent, {
-    type: 'TemplateElement',
-    tail,
-    value,
-  });
-}
-
-// Identifier has a bunch of stuff that usually you don't want to provide - so we have
-// this manual def to allow us to default some values
-export type IdentifierProps = {
-  +name: IdentifierType['name'],
-  +typeAnnotation?: ?DetachedNode<IdentifierType['typeAnnotation']>,
-  +optional?: IdentifierType['optional'],
-};
-export function Identifier({
-  parent,
-  optional = false,
-  typeAnnotation = null,
-  ...props
-}: {
-  ...$ReadOnly<IdentifierProps>,
-  +parent?: ESNode,
-}): DetachedNode<IdentifierType> {
-  const node = detachedProps<IdentifierType>(parent, {
-    type: 'Identifier',
-    optional,
-    typeAnnotation,
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-//
-// Literals require a "raw" which is added by the estree transform, not hermes.
-//
-
-export type BigIntLiteralProps = {
-  +value: $FlowFixMe /* bigint | null */,
-  /**
-   * Only set this if you want to use a source-code representation like 1_1n, etc.
-   * By default "raw" will just be the exact number you've given.
-   */
-  +raw?: NumericLiteralType['raw'],
-};
-export function BigIntLiteral({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<BigIntLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<BigIntLiteralType> {
-  const node = detachedProps<BigIntLiteralType>(parent, {
-    type: 'Literal',
-    ...props,
-    raw: props.raw ?? `${props.value}n`,
-    bigint: `${props.value}`,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export type BooleanLiteralProps = {
-  +value: BooleanLiteralType['value'],
-};
-export function BooleanLiteral({
-  parent,
-  value,
-}: {
-  ...$ReadOnly<BooleanLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<BooleanLiteralType> {
-  return detachedProps<BooleanLiteralType>(parent, {
-    type: 'Literal',
-    raw: value ? 'true' : 'false',
-    value,
-  });
-}
-
-export type NumericLiteralProps = {
-  +value: NumericLiteralType['value'],
-  /**
-   * Only set this if you want to use a source-code representation like 1e100, 0x11, 1_1, etc.
-   * By default "raw" will just be the exact number you've given.
-   */
-  +raw?: NumericLiteralType['raw'],
-};
-export function NumericLiteral({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<NumericLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<NumericLiteralType> {
-  return detachedProps<NumericLiteralType>(parent, {
-    type: 'Literal',
-    ...props,
-    raw: props.raw ?? `${props.value}`,
-  });
-}
-
-export type NullLiteralProps = {};
-export function NullLiteral({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<NullLiteralType> {
-  return detachedProps<NullLiteralType>(parent, {
-    type: 'Literal',
-    value: null,
-    raw: 'null',
-  });
-}
-
-export type StringLiteralProps = {
-  +value: StringLiteralType['value'],
-  +raw?: StringLiteralType['raw'],
-};
-export function StringLiteral({
-  parent,
-  raw: rawIn,
-  value,
-}: {
-  ...$ReadOnly<StringLiteralProps>,
-  +parent?: ESNode,
-}): DetachedNode<StringLiteralType> {
-  const hasSingleQuote = value.includes('"');
-  const hasDoubleQuote = value.includes("'");
-  let raw = rawIn;
-  if (raw == null) {
-    if (hasSingleQuote && hasDoubleQuote) {
-      raw = `'${value.replace(/'/g, "\\'")}'`;
-    } else if (hasSingleQuote) {
-      raw = `"${value}"`;
-    } else {
-      raw = `'${value}'`;
-    }
-  }
-  return detachedProps<StringLiteralType>(parent, {
-    type: 'Literal',
-    raw,
-    value,
-  });
-}
-
-export type LineCommentProps = {+value: string};
-export function LineComment({value}: LineCommentProps): LineCommentType {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-return]
-  return detachedProps<LineCommentType>(undefined, {
-    type: 'Line',
-    value,
-  });
-}
-
-export type BlockCommentProps = {+value: string};
-export function BlockComment({value}: BlockCommentProps): BlockCommentType {
-  // $FlowExpectedError[prop-missing]
-  // $FlowExpectedError[incompatible-return]
-  return detachedProps<BlockCommentType>(undefined, {
-    type: 'Block',
-    value,
-  });
-}
+export * from './special-case-node-types/Comment';
+export * from './special-case-node-types/DeclareExportDeclaration';
+export * from './special-case-node-types/ExportNamedDeclaration';
+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';

package/dist/index.js

@@ -12,11 +12,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.traverseWithContext = exports.traverse = exports.transform = exports.t = exports.SimpleTraverser = void 0;
+exports.traverseWithContext = exports.traverse = exports.transform = exports.t = exports.print = exports.parse = exports.cloneJSDocCommentsToNewNode = exports.asDetachedNode = exports.SimpleTraverser = void 0;
 
-var _SimpleTraverser = require("./traverse/SimpleTraverser");
+var _hermesParser = require("hermes-parser");
 
-exports.SimpleTraverser = _SimpleTraverser.SimpleTraverser;
+exports.SimpleTraverser = _hermesParser.SimpleTraverser;
 
 var _traverse = require("./traverse/traverse");
 
@@ -27,10 +27,26 @@ var _transform = require("./transform/transform");
 
 exports.transform = _transform.transform;
 
+var _parse = require("./transform/parse");
+
+exports.parse = _parse.parse;
+
+var _print = require("./transform/print");
+
+exports.print = _print.print;
+
 var _t = _interopRequireWildcard(require("./generated/node-types"));
 
 exports.t = _t;
 
+var _detachedNode = require("./detachedNode");
+
+exports.asDetachedNode = _detachedNode.asDetachedNode;
+
+var _comments = require("./transform/comments/comments");
+
+exports.cloneJSDocCommentsToNewNode = _comments.cloneJSDocCommentsToNewNode;
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/index.js.flow

@@ -13,9 +13,13 @@
 export type {TraversalContextBase, Visitor} from './traverse/traverse';
 export type {TransformVisitor} from './transform/transform';
 export type {TransformContext} from './transform/TransformContext';
-export type {DetachedNode} from './detachedNode';
+export type {DetachedNode, MaybeDetachedNode} from './detachedNode';
 
-export {SimpleTraverser} from './traverse/SimpleTraverser';
+export {SimpleTraverser} from 'hermes-parser';
 export {traverse, traverseWithContext} from './traverse/traverse';
 export {transform} from './transform/transform';
+export {parse} from './transform/parse';
+export {print} from './transform/print';
 export * as t from './generated/node-types';
+export {asDetachedNode} from './detachedNode';
+export {cloneJSDocCommentsToNewNode} from './transform/comments/comments';

package/dist/transform/TransformContext.js

@@ -52,10 +52,9 @@ function getTransformContext() {
         return null;
       }
 
-      return (0, _detachedNode.shallowCloneNode)(node);
+      return (0, _detachedNode.shallowCloneNode)(node, {});
     },
-    // $FlowExpectedError[incompatible-exact]
-    shallowCloneNodeWithOverrides: (node, newProps) => {
+    shallowCloneNodeWithOverrides: (node, newProps = {}) => {
       if (node == null) {
         return null;
       }
@@ -67,17 +66,23 @@ function getTransformContext() {
         return null;
       }
 
-      return nodes.map(node => (0, _detachedNode.shallowCloneNode)(node));
+      return nodes.map(node => {
+        if (node == null) {
+          // $FlowExpectedError[incompatible-return]
+          return node;
+        }
+
+        return (0, _detachedNode.shallowCloneNode)(node, {});
+      });
     },
     deepCloneNode: node => {
       if (node == null) {
         return null;
       }
 
-      return (0, _detachedNode.deepCloneNode)(node);
+      return (0, _detachedNode.deepCloneNode)(node, {});
     },
-    // $FlowExpectedError[incompatible-exact]
-    deepCloneNodeWithOverrides: (node, newProps) => {
+    deepCloneNodeWithOverrides: (node, newProps = {}) => {
       if (node == null) {
         return null;
       }
@@ -130,10 +135,14 @@ function getTransformContext() {
   };
   const insertAPIs = {
     insertAfterStatement: (target, nodesToInsert) => {
-      pushMutation((0, _InsertStatement.createInsertStatementMutation)('after', target, toArray(nodesToInsert)));
+      pushMutation((0, _InsertStatement.createInsertStatementMutation)('after', target, toArray(nodesToInsert).map(n => (0, _detachedNode.asDetachedNode)(n, {
+        useDeepClone: true
+      }))));
     },
     insertBeforeStatement: (target, nodesToInsert) => {
-      pushMutation((0, _InsertStatement.createInsertStatementMutation)('before', target, toArray(nodesToInsert)));
+      pushMutation((0, _InsertStatement.createInsertStatementMutation)('before', target, toArray(nodesToInsert).map(n => (0, _detachedNode.asDetachedNode)(n, {
+        useDeepClone: true
+      }))));
     }
   };
   const removeAPIs = {
@@ -146,10 +155,23 @@ function getTransformContext() {
   };
   const replaceAPIs = {
     replaceNode: (target, nodeToReplaceWith, options) => {
-      pushMutation((0, _ReplaceNode.createReplaceNodeMutation)(target, nodeToReplaceWith, options));
+      pushMutation((0, _ReplaceNode.createReplaceNodeMutation)(target, (0, _detachedNode.asDetachedNode)(nodeToReplaceWith), options));
     },
     replaceStatementWithMany: (target, nodesToReplaceWith, options) => {
-      pushMutation((0, _ReplaceStatementWithMany.createReplaceStatementWithManyMutation)(target, nodesToReplaceWith, options));
+      pushMutation((0, _ReplaceStatementWithMany.createReplaceStatementWithManyMutation)(target, nodesToReplaceWith.map(n => (0, _detachedNode.asDetachedNode)(n)), options));
+    }
+  };
+  const modifyAPIs = {
+    modifyNodeInPlace: (node, newProps = {}, options) => {
+      if (node == null) {
+        return;
+      }
+
+      const cloned = (0, _detachedNode.shallowCloneNode)(node, newProps, {
+        preserveLocation: true
+      }); // $FlowExpectedError[incompatible-call]
+
+      replaceAPIs.replaceNode(node, cloned, options);
     }
   };
   return {
@@ -163,6 +185,7 @@ function getTransformContext() {
     ...cloneAPIs,
     ...commentAPIs,
     ...insertAPIs,
+    ...modifyAPIs,
     ...removeAPIs,
     ...replaceAPIs
   };