hermes-estree 0.28.1 → 0.29.0

package/dist/src/index.js

@@ -0,0 +1,22 @@
+/**
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _predicates = require("./predicates");
+
+Object.keys(_predicates).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _predicates[key]) return;
+  exports[key] = _predicates[key];
+});

package/dist/src/predicates.js

@@ -0,0 +1,250 @@
+/**
+ * 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.
+ *
+ * 
+ */
+'use strict';
+/*::
+import type {
+  ESNode,
+  Token,
+  MostTokens,
+  BlockComment,
+  LineComment,
+  AFunction,
+  PropertyDefinition,
+  PropertyDefinitionWithNonComputedName,
+  MethodDefinition,
+  MethodDefinitionConstructor,
+  MethodDefinitionWithNonComputedName,
+  MemberExpression,
+  MemberExpressionWithNonComputedName,
+  ObjectPropertyWithShorthandStaticName,
+  ObjectPropertyWithNonShorthandStaticName,
+  DestructuringObjectPropertyWithShorthandStaticName,
+  DestructuringObjectPropertyWithNonShorthandStaticName,
+  ClassMember,
+  ClassDeclaration,
+  ClassExpression,
+  Literal,
+  BigIntLiteral,
+  BooleanLiteral,
+  NullLiteral,
+  NumericLiteral,
+  RegExpLiteral,
+  StringLiteral,
+  Identifier,
+  EnumDefaultedMember,
+  Expression,
+  Statement,
+} from './types';
+*/
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  isClass: true,
+  isPropertyDefinitionWithNonComputedName: true,
+  isClassMember: true,
+  isClassMemberWithNonComputedName: true,
+  isComment: true,
+  isFunction: true,
+  isMethodDefinitionWithNonComputedName: true,
+  isMemberExpressionWithNonComputedProperty: true,
+  isOptionalMemberExpressionWithNonComputedProperty: true,
+  isObjectPropertyWithShorthand: true,
+  isObjectPropertyWithNonComputedName: true,
+  isBigIntLiteral: true,
+  isBooleanLiteral: true,
+  isNullLiteral: true,
+  isNumericLiteral: true,
+  isRegExpLiteral: true,
+  isStringLiteral: true,
+  isExpression: true,
+  isStatement: true
+};
+exports.isBigIntLiteral = isBigIntLiteral;
+exports.isBooleanLiteral = isBooleanLiteral;
+exports.isClass = isClass;
+exports.isClassMember = isClassMember;
+exports.isClassMemberWithNonComputedName = isClassMemberWithNonComputedName;
+exports.isComment = isComment;
+exports.isExpression = isExpression;
+exports.isFunction = isFunction;
+exports.isMemberExpressionWithNonComputedProperty = isMemberExpressionWithNonComputedProperty;
+exports.isMethodDefinitionWithNonComputedName = isMethodDefinitionWithNonComputedName;
+exports.isNullLiteral = isNullLiteral;
+exports.isNumericLiteral = isNumericLiteral;
+exports.isObjectPropertyWithNonComputedName = isObjectPropertyWithNonComputedName;
+exports.isObjectPropertyWithShorthand = isObjectPropertyWithShorthand;
+exports.isOptionalMemberExpressionWithNonComputedProperty = isOptionalMemberExpressionWithNonComputedProperty;
+exports.isPropertyDefinitionWithNonComputedName = isPropertyDefinitionWithNonComputedName;
+exports.isRegExpLiteral = isRegExpLiteral;
+exports.isStatement = isStatement;
+exports.isStringLiteral = isStringLiteral;
+
+var _predicates = require("./generated/predicates");
+
+Object.keys(_predicates).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _predicates[key]) return;
+  exports[key] = _predicates[key];
+});
+
+function isClass(node
+/*: ESNode */
+)
+/*: implies node is (ClassDeclaration | ClassExpression) */
+{
+  return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
+}
+
+function isPropertyDefinitionWithNonComputedName(node
+/*: ESNode */
+)
+/*: implies node is PropertyDefinitionWithNonComputedName */
+{
+  return node.type === 'PropertyDefinition' && node.computed === false;
+}
+
+function isClassMember(node
+/*: ESNode */
+)
+/*: implies node is ClassMember */
+{
+  return node.type === 'PropertyDefinition' || node.type === 'MethodDefinition';
+}
+
+function isClassMemberWithNonComputedName(node
+/*: ESNode */
+)
+/*: implies node is (PropertyDefinitionWithNonComputedName | MethodDefinitionConstructor | MethodDefinitionWithNonComputedName) */
+{
+  return (node.type === 'PropertyDefinition' || node.type === 'MethodDefinition') && node.computed === false;
+}
+
+function isComment(node
+/*: ESNode | Token */
+)
+/*: implies node is (MostTokens | BlockComment | LineComment) */
+{
+  return node.type === 'Block' || node.type === 'Line';
+}
+
+function isFunction(node
+/*: ESNode */
+)
+/*: implies node is AFunction */
+{
+  return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression';
+}
+
+function isMethodDefinitionWithNonComputedName(node
+/*: ESNode */
+)
+/*: implies node is (MethodDefinitionConstructor | MethodDefinitionWithNonComputedName) */
+{
+  return node.type === 'MethodDefinition' && node.computed === false;
+}
+
+function isMemberExpressionWithNonComputedProperty(node
+/*: ESNode */
+)
+/*: implies node is MemberExpressionWithNonComputedName */
+{
+  return node.type === 'MemberExpression' && node.computed === false;
+}
+
+function isOptionalMemberExpressionWithNonComputedProperty(node
+/*: ESNode */
+)
+/*: implies node is MemberExpressionWithNonComputedName */
+{
+  return node.type === 'MemberExpression' && node.computed === false;
+}
+
+function isObjectPropertyWithShorthand(node
+/*: ESNode */
+)
+/*: implies node is (ObjectPropertyWithShorthandStaticName | DestructuringObjectPropertyWithShorthandStaticName) */
+{
+  return node.type === 'Property' && node.shorthand === true;
+}
+
+function isObjectPropertyWithNonComputedName(node
+/*: ESNode */
+)
+/*: implies node is (ObjectPropertyWithNonShorthandStaticName | ObjectPropertyWithShorthandStaticName | DestructuringObjectPropertyWithNonShorthandStaticName | DestructuringObjectPropertyWithShorthandStaticName) */
+{
+  return node.type === 'Property' && node.computed === false;
+}
+
+function isBigIntLiteral(node
+/*: ESNode */
+)
+/*: implies node is BigIntLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'bigint';
+}
+
+function isBooleanLiteral(node
+/*: ESNode */
+)
+/*: implies node is BooleanLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'boolean';
+}
+
+function isNullLiteral(node
+/*: ESNode */
+)
+/*: implies node is NullLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'null';
+}
+
+function isNumericLiteral(node
+/*: ESNode */
+)
+/*: implies node is NumericLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'numeric';
+}
+
+function isRegExpLiteral(node
+/*: ESNode */
+)
+/*: implies node is RegExpLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'regexp';
+}
+
+function isStringLiteral(node
+/*: ESNode */
+)
+/*: implies node is StringLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'string';
+}
+
+function isExpression(node
+/*: ESNode */
+)
+/*: implies node is Expression */
+{
+  return node.type === 'ThisExpression' || node.type === 'ArrayExpression' || node.type === 'ObjectExpression' || // $FlowFixMe[incompatible-type]
+  node.type === 'ObjectExpression' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression' || node.type === 'YieldExpression' || node.type === 'Literal' || node.type === 'UnaryExpression' || node.type === 'UpdateExpression' || node.type === 'BinaryExpression' || node.type === 'AssignmentExpression' || node.type === 'LogicalExpression' || node.type === 'MemberExpression' || node.type === 'ConditionalExpression' || node.type === 'CallExpression' || node.type === 'NewExpression' || node.type === 'SequenceExpression' || node.type === 'TemplateLiteral' || node.type === 'TaggedTemplateExpression' || node.type === 'ClassExpression' || node.type === 'MetaProperty' || node.type === 'Identifier' || node.type === 'AwaitExpression' || node.type === 'ImportExpression' || node.type === 'ChainExpression' || node.type === 'TypeCastExpression' || node.type === 'AsExpression' || node.type === 'AsConstExpression' || node.type === 'JSXFragment' || node.type === 'JSXElement';
+}
+
+function isStatement(node
+/*: ESNode */
+)
+/*: implies node is Statement */
+{
+  return node.type === 'BlockStatement' || node.type === 'BreakStatement' || node.type === 'ClassDeclaration' || node.type === 'ContinueStatement' || node.type === 'DebuggerStatement' || node.type === 'DeclareClass' || node.type === 'DeclareVariable' || node.type === 'DeclareFunction' || node.type === 'DeclareInterface' || node.type === 'DeclareModule' || node.type === 'DeclareOpaqueType' || node.type === 'DeclareTypeAlias' || node.type === 'DoWhileStatement' || node.type === 'EmptyStatement' || node.type === 'EnumDeclaration' || node.type === 'ExpressionStatement' || node.type === 'ForInStatement' || node.type === 'ForOfStatement' || node.type === 'ForStatement' || node.type === 'FunctionDeclaration' || node.type === 'IfStatement' || node.type === 'InterfaceDeclaration' || node.type === 'LabeledStatement' || node.type === 'OpaqueType' || node.type === 'ReturnStatement' || node.type === 'SwitchStatement' || node.type === 'ThrowStatement' || node.type === 'TryStatement' || node.type === 'TypeAlias' || node.type === 'VariableDeclaration' || node.type === 'WhileStatement' || node.type === 'WithStatement';
+}

package/dist/src/selectors.js

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/src/types.js

@@ -0,0 +1,39 @@
+/**
+ * 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
+ */
+'use strict';
+/**
+ *
+ * IMPORTANT NOTE
+ *
+ * This file intentionally uses interfaces and `+` for readonly.
+ *
+ * - `$ReadOnly` is an "evaluated" utility type in flow; meaning that flow does
+ *    not actually calculate the resulting type until it is used. This creates
+ *    a copy of the type at each usage site - ballooning memory and processing
+ *    times.
+ *    Usually this isn't a problem as a type might only be used one or two times
+ *    - but in this giant circular-referencing graph that is the AST types, this
+ *    causes check times for consumers to be awful.
+ *
+ *    Thus instead we manually annotate properties with `+` to avoid the `$ReadOnly` type.
+ *
+ * - `...Type` spreads do not preserve the readonly-ness of the properties. If
+ *   we used object literal types then we would have to `$ReadOnly` all spreads
+ *   (see point 1). On the other hand extending an interface does preserve
+ *   readonlyness of properties.
+ *
+ *   Thus instead of object literals, we use interfaces.
+ *
+ *** Please ensure all properties are marked as readonly! ***
+ */
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/types.js.flow

@@ -1047,7 +1047,7 @@ export interface ImportAttribute extends BaseNode {
   +key: Identifier;
   +value: StringLiteral;
 
-  +parent: ImportDeclaration | ImportExpression;
+  +parent: ImportDeclaration;
 }
 
 export interface ImportSpecifier extends BaseNode {
@@ -1062,7 +1062,7 @@ export interface ImportSpecifier extends BaseNode {
 export interface ImportExpression extends BaseNode {
   +type: 'ImportExpression';
   +source: Expression;
-  +attributes: $ReadOnlyArray<ImportAttribute> | null;
+  +options: Expression | null;
 }
 
 export interface ImportDefaultSpecifier extends BaseNode {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-estree",
-  "version": "0.28.1",
+  "version": "0.29.0",
   "description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
   "main": "dist/index.js",
   "license": "MIT",