hermes-transform 0.9.0 → 0.10.1

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockComment = BlockComment;
+exports.LineComment = LineComment;
+
+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 LineComment(props) {
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[incompatible-return]
+  return (0, _detachedNode.detachedProps)(undefined, {
+    type: 'Line',
+    value: props.value
+  });
+}
+
+function BlockComment(props) {
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[incompatible-return]
+  return (0, _detachedNode.detachedProps)(undefined, {
+    type: 'Block',
+    value: props.value
+  });
+}

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

@@ -0,0 +1,36 @@
+/**
+ * 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 {
+  BlockComment as BlockCommentType,
+  LineComment as LineCommentType,
+} from 'hermes-estree';
+
+import {detachedProps} from '../../detachedNode';
+
+export type LineCommentProps = {+value: string};
+export function LineComment(props: LineCommentProps): LineCommentType {
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[incompatible-return]
+  return detachedProps<LineCommentType>(undefined, {
+    type: 'Line',
+    value: props.value,
+  });
+}
+
+export type BlockCommentProps = {+value: string};
+export function BlockComment(props: BlockCommentProps): BlockCommentType {
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[incompatible-return]
+  return detachedProps<BlockCommentType>(undefined, {
+    type: 'Block',
+    value: props.value,
+  });
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeclareExportDeclarationNamedWithDeclaration = DeclareExportDeclarationNamedWithDeclaration;
+exports.DeclareExportDeclarationNamedWithSpecifiers = DeclareExportDeclarationNamedWithSpecifiers;
+exports.DeclareExportDefaultDeclaration = DeclareExportDefaultDeclaration;
+
+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 DeclareExportDefaultDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'DeclareExportDeclaration',
+    declaration: (0, _detachedNode.asDetachedNode)(props.declaration),
+    specifiers: [],
+    source: null,
+    default: true
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function DeclareExportDeclarationNamedWithDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'DeclareExportDeclaration',
+    declaration: (0, _detachedNode.asDetachedNode)(props.declaration),
+    specifiers: [],
+    source: null,
+    default: false
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function DeclareExportDeclarationNamedWithSpecifiers(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'DeclareExportDeclaration',
+    declaration: null,
+    specifiers: props.specifiers.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    source: (0, _detachedNode.asDetachedNode)(props.source),
+    default: false
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}

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

@@ -0,0 +1,97 @@
+/**
+ * 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 {
+  DeclareExportDefaultDeclaration as DeclareExportDefaultDeclarationType,
+  ESNode,
+  DeclareExportDeclarationNamedWithDeclaration as DeclareExportDeclarationNamedWithDeclarationType,
+  DeclareExportDeclarationNamedWithSpecifiers as DeclareExportDeclarationNamedWithSpecifiersType,
+} from 'hermes-estree';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
+
+import {
+  asDetachedNode,
+  detachedProps,
+  setParentPointersInDirectChildren,
+} from '../../detachedNode';
+
+export type DeclareExportDefaultDeclarationProps = {
+  +declaration?: ?MaybeDetachedNode<
+    DeclareExportDefaultDeclarationType['declaration'],
+  >,
+};
+export function DeclareExportDefaultDeclaration(props: {
+  ...$ReadOnly<DeclareExportDefaultDeclarationProps>,
+  +parent?: ESNode,
+}): DetachedNode<DeclareExportDefaultDeclarationType> {
+  const node = detachedProps<DeclareExportDefaultDeclarationType>(
+    props.parent,
+    {
+      type: 'DeclareExportDeclaration',
+      declaration: asDetachedNode(props.declaration),
+      specifiers: [],
+      source: null,
+      default: true,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type DeclareExportDeclarationNamedWithDeclarationProps = {
+  +declaration?: ?MaybeDetachedNode<
+    DeclareExportDeclarationNamedWithDeclarationType['declaration'],
+  >,
+};
+export function DeclareExportDeclarationNamedWithDeclaration(props: {
+  ...$ReadOnly<DeclareExportDeclarationNamedWithDeclarationProps>,
+  +parent?: ESNode,
+}): DetachedNode<DeclareExportDeclarationNamedWithDeclarationType> {
+  const node = detachedProps<DeclareExportDeclarationNamedWithDeclarationType>(
+    props.parent,
+    {
+      type: 'DeclareExportDeclaration',
+      declaration: asDetachedNode(props.declaration),
+      specifiers: [],
+      source: null,
+      default: false,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type DeclareExportDeclarationNamedWithSpecifiersProps = {
+  +specifiers: $ReadOnlyArray<
+    MaybeDetachedNode<
+      DeclareExportDeclarationNamedWithSpecifiersType['specifiers'][number],
+    >,
+  >,
+  +source?: ?MaybeDetachedNode<
+    DeclareExportDeclarationNamedWithSpecifiersType['source'],
+  >,
+};
+export function DeclareExportDeclarationNamedWithSpecifiers(props: {
+  ...$ReadOnly<DeclareExportDeclarationNamedWithSpecifiersProps>,
+  +parent?: ESNode,
+}): DetachedNode<DeclareExportDeclarationNamedWithSpecifiersType> {
+  const node = detachedProps<DeclareExportDeclarationNamedWithSpecifiersType>(
+    props.parent,
+    {
+      type: 'DeclareExportDeclaration',
+      declaration: null,
+      specifiers: props.specifiers.map(n => asDetachedNode(n)),
+      source: asDetachedNode(props.source),
+      default: false,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExportNamedDeclarationWithDeclaration = ExportNamedDeclarationWithDeclaration;
+exports.ExportNamedDeclarationWithSpecifiers = ExportNamedDeclarationWithSpecifiers;
+
+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 ExportNamedDeclarationWithDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ExportNamedDeclaration',
+    declaration: (0, _detachedNode.asDetachedNode)(props.declaration),
+    specifiers: [],
+    source: null,
+    exportKind: props.exportKind
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ExportNamedDeclarationWithSpecifiers(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ExportNamedDeclaration',
+    declaration: null,
+    specifiers: props.specifiers.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    source: (0, _detachedNode.asDetachedNode)(props.source),
+    exportKind: props.exportKind
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}

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

@@ -0,0 +1,75 @@
+/**
+ * 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 {
+  ESNode,
+  ExportNamedDeclarationWithDeclaration as ExportNamedDeclarationWithDeclarationType,
+  ExportNamedDeclarationWithSpecifiers as ExportNamedDeclarationWithSpecifiersType,
+} from 'hermes-estree';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
+
+import {
+  asDetachedNode,
+  detachedProps,
+  setParentPointersInDirectChildren,
+} from '../../detachedNode';
+
+export type ExportNamedDeclarationWithDeclarationProps = {
+  +declaration?: ?MaybeDetachedNode<
+    ExportNamedDeclarationWithDeclarationType['declaration'],
+  >,
+  +exportKind: ExportNamedDeclarationWithDeclarationType['exportKind'],
+};
+export function ExportNamedDeclarationWithDeclaration(props: {
+  ...$ReadOnly<ExportNamedDeclarationWithDeclarationProps>,
+  +parent?: ESNode,
+}): DetachedNode<ExportNamedDeclarationWithDeclarationType> {
+  const node = detachedProps<ExportNamedDeclarationWithDeclarationType>(
+    props.parent,
+    {
+      type: 'ExportNamedDeclaration',
+      declaration: asDetachedNode(props.declaration),
+      specifiers: [],
+      source: null,
+      exportKind: props.exportKind,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ExportNamedDeclarationWithSpecifiersProps = {
+  +specifiers: $ReadOnlyArray<
+    MaybeDetachedNode<
+      ExportNamedDeclarationWithSpecifiersType['specifiers'][number],
+    >,
+  >,
+  +source?: ?MaybeDetachedNode<
+    ExportNamedDeclarationWithSpecifiersType['source'],
+  >,
+  +exportKind: ExportNamedDeclarationWithSpecifiersType['exportKind'],
+};
+export function ExportNamedDeclarationWithSpecifiers(props: {
+  ...$ReadOnly<ExportNamedDeclarationWithSpecifiersProps>,
+  +parent?: ESNode,
+}): DetachedNode<ExportNamedDeclarationWithSpecifiersType> {
+  const node = detachedProps<ExportNamedDeclarationWithSpecifiersType>(
+    props.parent,
+    {
+      type: 'ExportNamedDeclaration',
+      declaration: null,
+      specifiers: props.specifiers.map(n => asDetachedNode(n)),
+      source: asDetachedNode(props.source),
+      exportKind: props.exportKind,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BigIntLiteral = BigIntLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.NullLiteral = NullLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.RegExpLiteral = RegExpLiteral;
+exports.StringLiteral = StringLiteral;
+
+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 BigIntLiteral(props) {
+  var _props$raw;
+
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Literal',
+    value: props.value,
+    raw: (_props$raw = props.raw) != null ? _props$raw : `${props.value}n`,
+    bigint: `${props.value}`
+  });
+}
+
+function BooleanLiteral(props) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Literal',
+    raw: props.value ? 'true' : 'false',
+    value: props.value
+  });
+}
+
+function NumericLiteral(props) {
+  var _props$raw2;
+
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Literal',
+    value: props.value,
+    raw: (_props$raw2 = props.raw) != null ? _props$raw2 : `${props.value}`
+  });
+}
+
+function NullLiteral(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Literal',
+    value: null,
+    raw: 'null'
+  });
+} // 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(props) {
+  const value = new RegExp(props.pattern, props.flags);
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Literal',
+    value,
+    raw: value.toString(),
+    regex: {
+      pattern: props.pattern,
+      flags: props.flags
+    }
+  });
+}
+
+function StringLiteral(props) {
+  const hasSingleQuote = props.value.includes('"');
+  const hasDoubleQuote = props.value.includes("'");
+  let raw = props.raw;
+
+  if (raw == null) {
+    if (hasSingleQuote && hasDoubleQuote) {
+      raw = `'${props.value.replace(/'/g, "\\'")}'`;
+    } else if (hasSingleQuote) {
+      raw = `"${props.value}"`;
+    } else {
+      raw = `'${props.value}'`;
+    }
+  }
+
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Literal',
+    raw,
+    value: props.value
+  });
+}

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

@@ -0,0 +1,139 @@
+/**
+ * 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 {
+  BigIntLiteral as BigIntLiteralType,
+  BooleanLiteral as BooleanLiteralType,
+  ESNode,
+  NullLiteral as NullLiteralType,
+  NumericLiteral as NumericLiteralType,
+  RegExpLiteral as RegExpLiteralType,
+  StringLiteral as StringLiteralType,
+} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+
+import {detachedProps} from '../../detachedNode';
+
+// 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(props: {
+  ...$ReadOnly<BigIntLiteralProps>,
+  +parent?: ESNode,
+}): DetachedNode<BigIntLiteralType> {
+  return detachedProps<BigIntLiteralType>(props.parent, {
+    type: 'Literal',
+    value: props.value,
+    raw: props.raw ?? `${props.value}n`,
+    bigint: `${props.value}`,
+  });
+}
+
+export type BooleanLiteralProps = {
+  +value: BooleanLiteralType['value'],
+};
+export function BooleanLiteral(props: {
+  ...$ReadOnly<BooleanLiteralProps>,
+  +parent?: ESNode,
+}): DetachedNode<BooleanLiteralType> {
+  return detachedProps<BooleanLiteralType>(props.parent, {
+    type: 'Literal',
+    raw: props.value ? 'true' : 'false',
+    value: props.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(props: {
+  ...$ReadOnly<NumericLiteralProps>,
+  +parent?: ESNode,
+}): DetachedNode<NumericLiteralType> {
+  return detachedProps<NumericLiteralType>(props.parent, {
+    type: 'Literal',
+    value: props.value,
+    raw: props.raw ?? `${props.value}`,
+  });
+}
+
+export type NullLiteralProps = {};
+export function NullLiteral(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<NullLiteralType> {
+  return detachedProps<NullLiteralType>(props.parent, {
+    type: 'Literal',
+    value: null,
+    raw: 'null',
+  });
+}
+
+// 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(props: {
+  ...$ReadOnly<RegExpLiteralProps>,
+  +parent?: ESNode,
+}): DetachedNode<RegExpLiteralType> {
+  const value = new RegExp(props.pattern, props.flags);
+  return detachedProps<RegExpLiteralType>(props.parent, {
+    type: 'Literal',
+    value,
+    raw: value.toString(),
+    regex: {
+      pattern: props.pattern,
+      flags: props.flags,
+    },
+  });
+}
+
+export type StringLiteralProps = {
+  +value: StringLiteralType['value'],
+  +raw?: StringLiteralType['raw'],
+};
+export function StringLiteral(props: {
+  ...$ReadOnly<StringLiteralProps>,
+  +parent?: ESNode,
+}): DetachedNode<StringLiteralType> {
+  const hasSingleQuote = props.value.includes('"');
+  const hasDoubleQuote = props.value.includes("'");
+  let raw = props.raw;
+  if (raw == null) {
+    if (hasSingleQuote && hasDoubleQuote) {
+      raw = `'${props.value.replace(/'/g, "\\'")}'`;
+    } else if (hasSingleQuote) {
+      raw = `"${props.value}"`;
+    } else {
+      raw = `'${props.value}'`;
+    }
+  }
+  return detachedProps<StringLiteralType>(props.parent, {
+    type: 'Literal',
+    raw,
+    value: props.value,
+  });
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObjectTypeAccessorSignature = ObjectTypeAccessorSignature;
+exports.ObjectTypeMethodSignature = ObjectTypeMethodSignature;
+exports.ObjectTypePropertySignature = ObjectTypePropertySignature;
+
+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 ObjectTypeMethodSignature(props) {
+  var _props$proto, _props$static;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ObjectTypeProperty',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: 'init',
+    method: true,
+    optional: false,
+    proto: (_props$proto = props.proto) != null ? _props$proto : false,
+    static: (_props$static = props.static) != null ? _props$static : false,
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    variance: null
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ObjectTypePropertySignature(props) {
+  var _props$proto2, _props$static2;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ObjectTypeProperty',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: 'init',
+    method: false,
+    optional: props.optional,
+    proto: (_props$proto2 = props.proto) != null ? _props$proto2 : false,
+    static: (_props$static2 = props.static) != null ? _props$static2 : false,
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    variance: (0, _detachedNode.asDetachedNode)(props.variance)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ObjectTypeAccessorSignature(props) {
+  var _props$proto3, _props$static3;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ObjectTypeProperty',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: props.kind,
+    method: false,
+    optional: false,
+    proto: (_props$proto3 = props.proto) != null ? _props$proto3 : false,
+    static: (_props$static3 = props.static) != null ? _props$static3 : false,
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    variance: null
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}