hermes-transform 0.9.0 → 0.10.0

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

@@ -0,0 +1,107 @@
+/**
+ * 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,
+  ObjectTypeAccessorSignature as ObjectTypeAccessorSignatureType,
+  ObjectTypeMethodSignature as ObjectTypeMethodSignatureType,
+  ObjectTypePropertySignature as ObjectTypePropertySignatureType,
+} from 'hermes-estree';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
+
+import {
+  asDetachedNode,
+  detachedProps,
+  setParentPointersInDirectChildren,
+} from '../../detachedNode';
+
+export type ObjectTypeMethodSignatureProps = {
+  +key: MaybeDetachedNode<ObjectTypeMethodSignatureType['key']>,
+  +value: MaybeDetachedNode<ObjectTypeMethodSignatureType['value']>,
+
+  // optional because they only apply to the class decl case
+  +static?: ObjectTypeMethodSignatureType['static'],
+  +proto?: ObjectTypeMethodSignatureType['proto'],
+};
+export function ObjectTypeMethodSignature(props: {
+  ...$ReadOnly<ObjectTypeMethodSignatureProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectTypeMethodSignatureType> {
+  const node = detachedProps<ObjectTypeMethodSignatureType>(props.parent, {
+    type: 'ObjectTypeProperty',
+    key: asDetachedNode(props.key),
+    kind: 'init',
+    method: true,
+    optional: false,
+    proto: props.proto ?? false,
+    static: props.static ?? false,
+    value: asDetachedNode(props.value),
+    variance: null,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ObjectTypePropertySignatureProps = {
+  +key: MaybeDetachedNode<ObjectTypePropertySignatureType['key']>,
+  +value: MaybeDetachedNode<ObjectTypePropertySignatureType['value']>,
+  +optional: ObjectTypePropertySignatureType['optional'],
+  +variance?: ?MaybeDetachedNode<ObjectTypePropertySignatureType['variance']>,
+
+  // optional because they only apply to the class decl case
+  +static?: ObjectTypeMethodSignatureType['static'],
+  +proto?: ObjectTypeMethodSignatureType['proto'],
+};
+export function ObjectTypePropertySignature(props: {
+  ...$ReadOnly<ObjectTypePropertySignatureProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectTypePropertySignatureType> {
+  const node = detachedProps<ObjectTypePropertySignatureType>(props.parent, {
+    type: 'ObjectTypeProperty',
+    key: asDetachedNode(props.key),
+    kind: 'init',
+    method: false,
+    optional: props.optional,
+    proto: props.proto ?? false,
+    static: props.static ?? false,
+    value: asDetachedNode(props.value),
+    variance: asDetachedNode(props.variance),
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ObjectTypeAccessorSignatureProps = {
+  +key: MaybeDetachedNode<ObjectTypeAccessorSignatureType['key']>,
+  +value: MaybeDetachedNode<ObjectTypeAccessorSignatureType['value']>,
+  +kind: ObjectTypeAccessorSignatureType['kind'],
+
+  // optional because they only apply to the class decl case
+  +static?: ObjectTypeMethodSignatureType['static'],
+  +proto?: ObjectTypeMethodSignatureType['proto'],
+};
+export function ObjectTypeAccessorSignature(props: {
+  ...$ReadOnly<ObjectTypeAccessorSignatureProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectTypeAccessorSignatureType> {
+  const node = detachedProps<ObjectTypeAccessorSignatureType>(props.parent, {
+    type: 'ObjectTypeProperty',
+    key: asDetachedNode(props.key),
+    kind: props.kind,
+    method: false,
+    optional: false,
+    proto: props.proto ?? false,
+    static: props.static ?? false,
+    value: asDetachedNode(props.value),
+    variance: null,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}

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

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DestructuringObjectProperty = DestructuringObjectProperty;
+exports.DestructuringObjectPropertyWithComputedName = DestructuringObjectPropertyWithComputedName;
+exports.DestructuringObjectPropertyWithNonShorthandStaticName = DestructuringObjectPropertyWithNonShorthandStaticName;
+exports.DestructuringObjectPropertyWithShorthandStaticName = DestructuringObjectPropertyWithShorthandStaticName;
+exports.ObjectProperty = ObjectProperty;
+exports.ObjectPropertyWithComputedName = ObjectPropertyWithComputedName;
+exports.ObjectPropertyWithNonShorthandStaticName = ObjectPropertyWithNonShorthandStaticName;
+exports.ObjectPropertyWithShorthandStaticName = ObjectPropertyWithShorthandStaticName;
+
+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 DestructuringObjectProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    kind: 'init',
+    method: false,
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: props.computed,
+    shorthand: props.shorthand
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function DestructuringObjectPropertyWithNonShorthandStaticName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    kind: 'init',
+    method: false,
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: false,
+    shorthand: false
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function DestructuringObjectPropertyWithShorthandStaticName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    kind: 'init',
+    method: false,
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: false,
+    shorthand: true
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function DestructuringObjectPropertyWithComputedName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    kind: 'init',
+    method: false,
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: true,
+    shorthand: false
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ObjectProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: props.kind,
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: props.computed,
+    method: props.method,
+    shorthand: props.shorthand
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ObjectPropertyWithNonShorthandStaticName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: props.kind,
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: false,
+    method: props.method,
+    shorthand: false
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ObjectPropertyWithShorthandStaticName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: 'init',
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: false,
+    method: false,
+    shorthand: true
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ObjectPropertyWithComputedName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Property',
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    kind: props.kind,
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: true,
+    method: props.method,
+    shorthand: false
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}

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

@@ -0,0 +1,237 @@
+/**
+ * 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 {
+  DestructuringObjectProperty as DestructuringObjectPropertyType,
+  DestructuringObjectPropertyWithComputedName as DestructuringObjectPropertyWithComputedNameType,
+  DestructuringObjectPropertyWithNonShorthandStaticName as DestructuringObjectPropertyWithNonShorthandStaticNameType,
+  DestructuringObjectPropertyWithShorthandStaticName as DestructuringObjectPropertyWithShorthandStaticNameType,
+  ESNode,
+  ObjectProperty as ObjectPropertyType,
+  ObjectPropertyWithComputedName as ObjectPropertyWithComputedNameType,
+  ObjectPropertyWithNonShorthandStaticName as ObjectPropertyWithNonShorthandStaticNameType,
+  ObjectPropertyWithShorthandStaticName as ObjectPropertyWithShorthandStaticNameType,
+} from 'hermes-estree';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
+
+import {
+  asDetachedNode,
+  detachedProps,
+  setParentPointersInDirectChildren,
+} from '../../detachedNode';
+
+export type DestructuringObjectPropertyProps = {
+  +key: MaybeDetachedNode<DestructuringObjectPropertyType['key']>,
+  +value: MaybeDetachedNode<DestructuringObjectPropertyType['value']>,
+  +computed: DestructuringObjectPropertyType['computed'],
+  +shorthand: DestructuringObjectPropertyType['shorthand'],
+};
+export function DestructuringObjectProperty(props: {
+  ...$ReadOnly<DestructuringObjectPropertyProps>,
+  +parent?: ESNode,
+}): DetachedNode<DestructuringObjectPropertyType> {
+  const node = detachedProps<DestructuringObjectPropertyType>(props.parent, {
+    type: 'Property',
+    kind: 'init',
+    method: false,
+    key: asDetachedNode(props.key),
+    value: asDetachedNode(props.value),
+    computed: props.computed,
+    shorthand: props.shorthand,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type DestructuringObjectPropertyWithNonShorthandStaticNameProps = {
+  +key: MaybeDetachedNode<
+    DestructuringObjectPropertyWithNonShorthandStaticNameType['key'],
+  >,
+  +value: MaybeDetachedNode<
+    DestructuringObjectPropertyWithNonShorthandStaticNameType['value'],
+  >,
+};
+export function DestructuringObjectPropertyWithNonShorthandStaticName(props: {
+  ...$ReadOnly<DestructuringObjectPropertyWithNonShorthandStaticNameProps>,
+  +parent?: ESNode,
+}): DetachedNode<DestructuringObjectPropertyWithNonShorthandStaticNameType> {
+  const node =
+    detachedProps<DestructuringObjectPropertyWithNonShorthandStaticNameType>(
+      props.parent,
+      {
+        type: 'Property',
+        kind: 'init',
+        method: false,
+        key: asDetachedNode(props.key),
+        value: asDetachedNode(props.value),
+        computed: false,
+        shorthand: false,
+      },
+    );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type DestructuringObjectPropertyWithShorthandStaticNameProps = {
+  +key: MaybeDetachedNode<
+    DestructuringObjectPropertyWithShorthandStaticNameType['key'],
+  >,
+  +value: MaybeDetachedNode<
+    DestructuringObjectPropertyWithShorthandStaticNameType['value'],
+  >,
+};
+export function DestructuringObjectPropertyWithShorthandStaticName(props: {
+  ...$ReadOnly<DestructuringObjectPropertyWithShorthandStaticNameProps>,
+  +parent?: ESNode,
+}): DetachedNode<DestructuringObjectPropertyWithShorthandStaticNameType> {
+  const node =
+    detachedProps<DestructuringObjectPropertyWithShorthandStaticNameType>(
+      props.parent,
+      {
+        type: 'Property',
+        kind: 'init',
+        method: false,
+        key: asDetachedNode(props.key),
+        value: asDetachedNode(props.value),
+        computed: false,
+        shorthand: true,
+      },
+    );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type DestructuringObjectPropertyWithComputedNameProps = {
+  +key: MaybeDetachedNode<
+    DestructuringObjectPropertyWithComputedNameType['key'],
+  >,
+  +value: MaybeDetachedNode<
+    DestructuringObjectPropertyWithComputedNameType['value'],
+  >,
+};
+export function DestructuringObjectPropertyWithComputedName(props: {
+  ...$ReadOnly<DestructuringObjectPropertyWithComputedNameProps>,
+  +parent?: ESNode,
+}): DetachedNode<DestructuringObjectPropertyWithComputedNameType> {
+  const node = detachedProps<DestructuringObjectPropertyWithComputedNameType>(
+    props.parent,
+    {
+      type: 'Property',
+      kind: 'init',
+      method: false,
+      key: asDetachedNode(props.key),
+      value: asDetachedNode(props.value),
+      computed: true,
+      shorthand: false,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ObjectPropertyProps = {
+  +key: MaybeDetachedNode<ObjectPropertyType['key']>,
+  +value: MaybeDetachedNode<ObjectPropertyType['value']>,
+  +kind: ObjectPropertyType['kind'],
+  +computed: ObjectPropertyType['computed'],
+  +method: ObjectPropertyType['method'],
+  +shorthand: ObjectPropertyType['shorthand'],
+};
+export function ObjectProperty(props: {
+  ...$ReadOnly<ObjectPropertyProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectPropertyType> {
+  const node = detachedProps<ObjectPropertyType>(props.parent, {
+    type: 'Property',
+    key: asDetachedNode(props.key),
+    kind: props.kind,
+    value: asDetachedNode(props.value),
+    computed: props.computed,
+    method: props.method,
+    shorthand: props.shorthand,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ObjectPropertyWithNonShorthandStaticNameProps = {
+  +key: MaybeDetachedNode<ObjectPropertyWithNonShorthandStaticNameType['key']>,
+  +value: MaybeDetachedNode<
+    ObjectPropertyWithNonShorthandStaticNameType['value'],
+  >,
+  +kind: ObjectPropertyWithNonShorthandStaticNameType['kind'],
+  +method: ObjectPropertyWithNonShorthandStaticNameType['method'],
+};
+export function ObjectPropertyWithNonShorthandStaticName(props: {
+  ...$ReadOnly<ObjectPropertyWithNonShorthandStaticNameProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectPropertyWithNonShorthandStaticNameType> {
+  const node = detachedProps<ObjectPropertyWithNonShorthandStaticNameType>(
+    props.parent,
+    {
+      type: 'Property',
+      key: asDetachedNode(props.key),
+      kind: props.kind,
+      value: asDetachedNode(props.value),
+      computed: false,
+      method: props.method,
+      shorthand: false,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ObjectPropertyWithShorthandStaticNameProps = {
+  +key: MaybeDetachedNode<ObjectPropertyWithShorthandStaticNameType['key']>,
+  +value: MaybeDetachedNode<ObjectPropertyWithShorthandStaticNameType['value']>,
+};
+export function ObjectPropertyWithShorthandStaticName(props: {
+  ...$ReadOnly<ObjectPropertyWithShorthandStaticNameProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectPropertyWithShorthandStaticNameType> {
+  const node = detachedProps<ObjectPropertyWithShorthandStaticNameType>(
+    props.parent,
+    {
+      type: 'Property',
+      key: asDetachedNode(props.key),
+      kind: 'init',
+      value: asDetachedNode(props.value),
+      computed: false,
+      method: false,
+      shorthand: true,
+    },
+  );
+  setParentPointersInDirectChildren(node);
+  return node;
+}
+
+export type ObjectPropertyWithComputedNameProps = {
+  +key: MaybeDetachedNode<ObjectPropertyWithComputedNameType['key']>,
+  +value: MaybeDetachedNode<ObjectPropertyWithComputedNameType['value']>,
+  +kind: ObjectPropertyWithComputedNameType['kind'],
+  +method: ObjectPropertyWithComputedNameType['method'],
+};
+export function ObjectPropertyWithComputedName(props: {
+  ...$ReadOnly<ObjectPropertyWithComputedNameProps>,
+  +parent?: ESNode,
+}): DetachedNode<ObjectPropertyWithComputedNameType> {
+  const node = detachedProps<ObjectPropertyWithComputedNameType>(props.parent, {
+    type: 'Property',
+    key: asDetachedNode(props.key),
+    kind: props.kind,
+    value: asDetachedNode(props.value),
+    computed: true,
+    method: props.method,
+    shorthand: false,
+  });
+  setParentPointersInDirectChildren(node);
+  return node;
+}

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

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.ClassDeclaration = ClassDeclaration;
+exports.DeclareFunction = DeclareFunction;
+exports.Identifier = Identifier;
+exports.Program = Program;
+exports.TemplateElement = TemplateElement;
+
+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 ArrowFunctionExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ArrowFunctionExpression',
+    id: null,
+    // $FlowExpectedError[incompatible-use]
+    expression: props.body.type !== 'BlockStatement',
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
+    predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
+    async: props.async
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function ClassDeclaration(props) {
+  var _props$decorators, _props$implements;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'ClassDeclaration',
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
+    superTypeParameters: (0, _detachedNode.asDetachedNode)(props.superTypeParameters),
+    decorators: ((_props$decorators = props.decorators) != null ? _props$decorators : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
+    implements: ((_props$implements = props.implements) != null ? _props$implements : []).map(n => (0, _detachedNode.asDetachedNode)(n)),
+    body: (0, _detachedNode.asDetachedNode)(props.body)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+} // raw/cooked are on a subobject in the estree spec, but are flat on the hermes types
+
+
+function TemplateElement(props) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'TemplateElement',
+    tail: props.tail,
+    value: {
+      cooked: props.cooked,
+      raw: props.raw
+    }
+  });
+} // 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(props) {
+  var _props$optional;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'Identifier',
+    name: props.name,
+    optional: (_props$optional = props.optional) != null ? _props$optional : false,
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function Program(props) {
+  return (0, _detachedNode.detachedProps)(null, {
+    type: 'Program',
+    sourceType: props.sourceType,
+    body: props.body.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    tokens: props.tokens,
+    comments: props.comments,
+    interpreter: props.interpreter != null ? // $FlowFixMe[incompatible-call]
+    (0, _detachedNode.asDetachedNode)({
+      type: 'InterpreterDirective',
+      value: props.interpreter
+    }) : null,
+    docblock: props.docblock
+  });
+} // 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
+
+
+function DeclareFunction(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'DeclareFunction',
+    id: (0, _detachedNode.detachedProps)(null, {
+      type: 'Identifier',
+      name: props.name,
+      typeAnnotation: (0, _detachedNode.detachedProps)(null, {
+        type: 'TypeAnnotation',
+        typeAnnotation: (0, _detachedNode.asDetachedNode)(props.functionType)
+      })
+    }),
+    predicate: (0, _detachedNode.asDetachedNode)(props.predicate)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}