hermes-transform 0.5.0

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

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.BlockComment = BlockComment;
+exports.BooleanLiteral = BooleanLiteral;
+exports.Identifier = Identifier;
+exports.LineComment = LineComment;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.RegExpLiteral = RegExpLiteral;
+exports.StringLiteral = StringLiteral;
+exports.TemplateElement = TemplateElement;
+
+var _detachedNode = require("../detachedNode");
+
+var _excluded = ["parent"],
+    _excluded2 = ["tail", "parent"],
+    _excluded3 = ["parent", "optional", "typeAnnotation"],
+    _excluded4 = ["parent"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ArrowFunctionExpression(_ref) {
+  var parent = _ref.parent,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  var node = (0, _detachedNode.detachedProps)(parent, _objectSpread({
+    type: 'ArrowFunctionExpression',
+    id: null,
+    // $FlowExpectedError[incompatible-use]
+    expression: props.body.type !== 'BlockStatement'
+  }, props));
+  (0, _detachedNode.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
+
+
+function RegExpLiteral(_ref2) {
+  var pattern = _ref2.pattern,
+      flags = _ref2.flags,
+      parent = _ref2.parent;
+  var value = new RegExp(pattern, flags);
+  return (0, _detachedNode.detachedProps)(parent, {
+    type: 'Literal',
+    value: value,
+    raw: value.toString(),
+    regex: {
+      pattern: pattern,
+      flags: flags
+    }
+  });
+} // raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
+
+
+function TemplateElement(_ref3) {
+  var tail = _ref3.tail,
+      parent = _ref3.parent,
+      value = _objectWithoutProperties(_ref3, _excluded2);
+
+  return (0, _detachedNode.detachedProps)(parent, {
+    type: 'TemplateElement',
+    tail: tail,
+    value: 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
+
+
+function Identifier(_ref4) {
+  var parent = _ref4.parent,
+      _ref4$optional = _ref4.optional,
+      optional = _ref4$optional === void 0 ? false : _ref4$optional,
+      _ref4$typeAnnotation = _ref4.typeAnnotation,
+      typeAnnotation = _ref4$typeAnnotation === void 0 ? null : _ref4$typeAnnotation,
+      props = _objectWithoutProperties(_ref4, _excluded3);
+
+  var node = (0, _detachedNode.detachedProps)(parent, _objectSpread({
+    type: 'Identifier',
+    optional: optional,
+    typeAnnotation: typeAnnotation
+  }, props));
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+} //
+// Literals require a "raw" which is added by the estree transform, not hermes.
+//
+
+
+function BooleanLiteral(_ref5) {
+  var parent = _ref5.parent,
+      value = _ref5.value;
+  return (0, _detachedNode.detachedProps)(parent, {
+    type: 'Literal',
+    raw: value ? 'true' : 'false',
+    value: value
+  });
+}
+
+function NumericLiteral(_ref6) {
+  var _props$raw;
+
+  var parent = _ref6.parent,
+      props = _objectWithoutProperties(_ref6, _excluded4);
+
+  return (0, _detachedNode.detachedProps)(parent, _objectSpread(_objectSpread({
+    type: 'Literal'
+  }, props), {}, {
+    raw: (_props$raw = props.raw) !== null && _props$raw !== void 0 ? _props$raw : "".concat(props.value)
+  }));
+}
+
+function NullLiteral() {
+  var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      parent = _ref7.parent;
+
+  return (0, _detachedNode.detachedProps)(parent, {
+    type: 'Literal',
+    value: null,
+    raw: 'null'
+  });
+}
+
+function StringLiteral(_ref8) {
+  var parent = _ref8.parent,
+      rawIn = _ref8.raw,
+      value = _ref8.value;
+  var hasSingleQuote = value.includes('"');
+  var hasDoubleQuote = value.includes("'");
+  var raw = rawIn;
+
+  if (raw == null) {
+    if (hasSingleQuote && hasDoubleQuote) {
+      raw = "'".concat(value.replace(/'/g, "\\'"), "'");
+    } else if (hasSingleQuote) {
+      raw = "\"".concat(value, "\"");
+    } else {
+      raw = "'".concat(value, "'");
+    }
+  }
+
+  return (0, _detachedNode.detachedProps)(parent, {
+    type: 'Literal',
+    raw: raw,
+    value: value
+  });
+}
+
+function LineComment(_ref9) {
+  var value = _ref9.value;
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[incompatible-return]
+  return (0, _detachedNode.detachedProps)(undefined, {
+    type: 'Line',
+    value: value
+  });
+}
+
+function BlockComment(_ref10) {
+  var value = _ref10.value;
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[incompatible-return]
+  return (0, _detachedNode.detachedProps)(undefined, {
+    type: 'Block',
+    value: value
+  });
+}

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

@@ -0,0 +1,248 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+/*
+These are a number of special-case node creation functions that we can't auto-generate.
+The list of exported functions here must be kept in sync with the `NODES_WITH_SPECIAL_HANDLING`
+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,
+  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 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, 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,
+  });
+}

package/dist/getVisitorKeys.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVisitorKeys = getVisitorKeys;
+exports.isNode = isNode;
+
+var _hermesEslint = require("hermes-eslint");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function isNode(thing) {
+  return _typeof(thing) === 'object' && thing != null && typeof thing.type === 'string';
+}
+
+function getVisitorKeys(node) {
+  var keys = _hermesEslint.VisitorKeys[node.type];
+
+  if (keys == null) {
+    throw new Error("No visitor keys found for node type \"".concat(node.type, "\"."));
+  } // $FlowExpectedError[prop-missing]
+
+
+  return keys;
+}

package/dist/getVisitorKeys.js.flow

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+'use strict';
+
+import type {ESNode} from 'hermes-estree';
+
+import {VisitorKeys} from 'hermes-eslint';
+
+export function isNode(thing: mixed): boolean %checks {
+  return (
+    typeof thing === 'object' && thing != null && typeof thing.type === 'string'
+  );
+}
+
+export function getVisitorKeys<T: ESNode>(node: T): $ReadOnlyArray<$Keys<T>> {
+  const keys = VisitorKeys[node.type];
+  if (keys == null) {
+    throw new Error(`No visitor keys found for node type "${node.type}".`);
+  }
+
+  // $FlowExpectedError[prop-missing]
+  return keys;
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.t = void 0;
+Object.defineProperty(exports, "transform", {
+  enumerable: true,
+  get: function get() {
+    return _transform.transform;
+  }
+});
+Object.defineProperty(exports, "traverse", {
+  enumerable: true,
+  get: function get() {
+    return _traverse.traverse;
+  }
+});
+
+var _traverse = require("./traverse/traverse");
+
+var _transform = require("./transform/transform");
+
+var _t = _interopRequireWildcard(require("./generated/node-types"));
+
+exports.t = _t;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+'use strict';
+
+export {traverse} from './traverse/traverse';
+export {transform} from './transform/transform';
+export * as t from './generated/node-types';