hermes-estree 0.32.1 → 0.33.1

package/dist/estree/StripFlowTypes.js

@@ -1,175 +0,0 @@
-/**
- * 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
- */
-
-/**
- * This transform strips all Flow types.
- *
- * It is expected that all transforms create valid ESTree AST output. If
- * the transform requires outputting Babel specific AST nodes then it
- * should live in `ConvertESTreeToBabel.js`
- */
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformProgram = transformProgram;
-
-var _SimpleTransform = require("../transform/SimpleTransform");
-
-const nodeWith = _SimpleTransform.SimpleTransform.nodeWith;
-
-function transformProgram(program, _options) {
-  return _SimpleTransform.SimpleTransform.transformProgram(program, {
-    transform(node) {
-      switch (node.type) {
-        case 'AsExpression':
-        case 'AsConstExpression':
-        case 'TypeCastExpression':
-          {
-            return node.expression;
-          }
-
-        case 'CallExpression':
-        case 'NewExpression':
-          {
-            if (node.typeArguments != null) {
-              return nodeWith(node, {
-                typeArguments: null
-              });
-            }
-
-            return node;
-          }
-
-        case 'ObjectPattern':
-        case 'ArrayPattern':
-        case 'Identifier':
-          {
-            if (node.typeAnnotation != null) {
-              return nodeWith(node, {
-                typeAnnotation: null
-              });
-            }
-
-            return node;
-          }
-
-        case 'DeclareClass':
-        case 'DeclareFunction':
-        case 'DeclareInterface':
-        case 'DeclareModule':
-        case 'DeclareModuleExports':
-        case 'DeclareNamespace':
-        case 'DeclareOpaqueType':
-        case 'DeclareTypeAlias':
-        case 'DeclareVariable':
-        case 'InterfaceDeclaration':
-        case 'OpaqueType':
-        case 'TypeAlias':
-          {
-            return null;
-          }
-
-        case 'FunctionDeclaration':
-        case 'ArrowFunctionExpression':
-        case 'FunctionExpression':
-          {
-            const newParams = [];
-
-            for (let i = 0; i < node.params.length; i++) {
-              if (i === 0 && node.params[0].type === 'Identifier' && node.params[0].name === 'this') {
-                continue;
-              }
-
-              let param = node.params[i];
-
-              if (param.type === 'AssignmentPattern') {
-                param = param.left;
-              }
-
-              if (param.optional === true) {
-                param = nodeWith(param, {
-                  optional: false
-                });
-              }
-
-              newParams.push(param);
-            }
-
-            return nodeWith(node, {
-              params: newParams,
-              returnType: null,
-              typeParameters: null,
-              predicate: null
-            });
-          }
-
-        case 'ClassDeclaration':
-        case 'ClassExpression':
-          {
-            return nodeWith(node, {
-              typeParameters: null,
-              superTypeParameters: null,
-              implements: [],
-              decorators: []
-            });
-          }
-
-        case 'PropertyDefinition':
-          {
-            return nodeWith(node, {
-              typeAnnotation: null,
-              variance: null,
-              declare: false,
-              optional: false
-            });
-          }
-
-        case 'ImportDeclaration':
-          {
-            if (node.importKind === 'type' || node.importKind === 'typeof') {
-              return null;
-            }
-
-            const nonTypeSpecifiers = node.specifiers.filter(s => s.type !== 'ImportSpecifier' || s.importKind !== 'type' && s.importKind !== 'typeof');
-
-            if (nonTypeSpecifiers.length === 0) {
-              return null;
-            }
-
-            if (nonTypeSpecifiers.length === node.specifiers.length) {
-              return node;
-            }
-
-            return nodeWith(node, {
-              specifiers: nonTypeSpecifiers
-            });
-          }
-
-        case 'ExportAllDeclaration':
-        case 'ExportNamedDeclaration':
-          {
-            if (node.exportKind === 'type') {
-              return null;
-            }
-
-            return node;
-          }
-
-        default:
-          {
-            return node;
-          }
-      }
-    }
-
-  });
-}

package/dist/estree/StripFlowTypes.js.flow

@@ -1,158 +0,0 @@
-/**
- * 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
- * @format
- */
-
-/**
- * This transform strips all Flow types.
- *
- * It is expected that all transforms create valid ESTree AST output. If
- * the transform requires outputting Babel specific AST nodes then it
- * should live in `ConvertESTreeToBabel.js`
- */
-
-'use strict';
-
-import type {ParserOptions} from '../ParserOptions';
-import type {Program, ESNode} from 'hermes-estree';
-
-import {SimpleTransform} from '../transform/SimpleTransform';
-
-const nodeWith = SimpleTransform.nodeWith;
-
-export function transformProgram(
-  program: Program,
-  _options: ParserOptions,
-): Program {
-  return SimpleTransform.transformProgram(program, {
-    transform(node: ESNode) {
-      switch (node.type) {
-        case 'AsExpression':
-        case 'AsConstExpression':
-        case 'TypeCastExpression': {
-          return node.expression;
-        }
-
-        case 'CallExpression':
-        case 'NewExpression': {
-          if (node.typeArguments != null) {
-            return nodeWith(node, {typeArguments: null});
-          }
-          return node;
-        }
-
-        case 'ObjectPattern':
-        case 'ArrayPattern':
-        case 'Identifier': {
-          if (node.typeAnnotation != null) {
-            return nodeWith(node, {typeAnnotation: null});
-          }
-          return node;
-        }
-
-        case 'DeclareClass':
-        case 'DeclareFunction':
-        case 'DeclareInterface':
-        case 'DeclareModule':
-        case 'DeclareModuleExports':
-        case 'DeclareNamespace':
-        case 'DeclareOpaqueType':
-        case 'DeclareTypeAlias':
-        case 'DeclareVariable':
-        case 'InterfaceDeclaration':
-        case 'OpaqueType':
-        case 'TypeAlias': {
-          return null;
-        }
-
-        case 'FunctionDeclaration':
-        case 'ArrowFunctionExpression':
-        case 'FunctionExpression': {
-          const newParams = [];
-          for (let i = 0; i < node.params.length; i++) {
-            if (
-              i === 0 &&
-              node.params[0].type === 'Identifier' &&
-              node.params[0].name === 'this'
-            ) {
-              continue;
-            }
-
-            let param = node.params[i];
-            if (param.type === 'AssignmentPattern') {
-              param = param.left;
-            }
-            if (param.optional === true) {
-              param = nodeWith(param, {optional: false});
-            }
-            newParams.push(param);
-          }
-
-          return nodeWith(node, {
-            params: newParams,
-            returnType: null,
-            typeParameters: null,
-            predicate: null,
-          });
-        }
-
-        case 'ClassDeclaration':
-        case 'ClassExpression': {
-          return nodeWith(node, {
-            typeParameters: null,
-            superTypeParameters: null,
-            implements: [],
-            decorators: [],
-          });
-        }
-
-        case 'PropertyDefinition': {
-          return nodeWith(node, {
-            typeAnnotation: null,
-            variance: null,
-            declare: false,
-            optional: false,
-          });
-        }
-
-        case 'ImportDeclaration': {
-          if (node.importKind === 'type' || node.importKind === 'typeof') {
-            return null;
-          }
-          const nonTypeSpecifiers = node.specifiers.filter(
-            s =>
-              s.type !== 'ImportSpecifier' ||
-              (s.importKind !== 'type' && s.importKind !== 'typeof'),
-          );
-          if (nonTypeSpecifiers.length === 0) {
-            return null;
-          }
-          if (nonTypeSpecifiers.length === node.specifiers.length) {
-            return node;
-          }
-
-          return nodeWith(node, {
-            specifiers: nonTypeSpecifiers,
-          });
-        }
-
-        case 'ExportAllDeclaration':
-        case 'ExportNamedDeclaration': {
-          if (node.exportKind === 'type') {
-            return null;
-          }
-          return node;
-        }
-
-        default: {
-          return node;
-        }
-      }
-    },
-  });
-}

package/dist/estree/StripFlowTypesForBabel.js

@@ -1,215 +0,0 @@
-/**
- * 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
- */
-
-/**
- * This transform strips Flow types that are not supported past Babel 7.
- *
- * It is expected that all transforms create valid ESTree AST output. If
- * the transform requires outputting Babel specific AST nodes then it
- * should live in `ConvertESTreeToBabel.js`
- */
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformProgram = transformProgram;
-
-var _SimpleTransform = require("../transform/SimpleTransform");
-
-var _createSyntaxError = require("../utils/createSyntaxError");
-
-const nodeWith = _SimpleTransform.SimpleTransform.nodeWith; // Rely on the mapper to fix up parent relationships.
-
-const EMPTY_PARENT = null;
-
-function createSimpleGenericTypeAnnotation(name, nodeForLoc) {
-  return {
-    type: 'GenericTypeAnnotation',
-    id: {
-      type: 'Identifier',
-      name,
-      optional: false,
-      typeAnnotation: null,
-      loc: nodeForLoc.loc,
-      range: nodeForLoc.range,
-      parent: EMPTY_PARENT
-    },
-    typeParameters: null,
-    loc: nodeForLoc.loc,
-    range: nodeForLoc.range,
-    parent: nodeForLoc.parent
-  };
-}
-
-function createAnyTypeAnnotation(node) {
-  return {
-    type: 'AnyTypeAnnotation',
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-/**
- * Convert DeclareEnum nodes to DeclareVariable
- */
-
-
-function mapDeclareEnum(node) {
-  return {
-    type: 'DeclareVariable',
-    kind: 'const',
-    id: nodeWith(node.id, {
-      typeAnnotation: {
-        type: 'TypeAnnotation',
-        typeAnnotation: createAnyTypeAnnotation(node.body),
-        loc: node.body.loc,
-        range: node.body.range,
-        parent: EMPTY_PARENT
-      }
-    }),
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-/**
- * Convert DeclareNamespace nodes to DeclareVariable
- */
-
-
-function mapDeclareNamespace(node) {
-  return {
-    type: 'DeclareVariable',
-    kind: 'const',
-    id: nodeWith(node.id, {
-      typeAnnotation: {
-        type: 'TypeAnnotation',
-        typeAnnotation: createAnyTypeAnnotation(node.body),
-        loc: node.body.loc,
-        range: node.body.range,
-        parent: EMPTY_PARENT
-      }
-    }),
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-/**
- * Remove `this` param from functions.
- */
-
-
-function mapFunction(node) {
-  // Remove the first parameter if it is a this-type annotation,
-  // which is not recognized by Babel.
-  if (node.params.length !== 0 && node.params[0].name === 'this') {
-    return nodeWith(node, {
-      params: node.params.slice(1)
-    });
-  }
-
-  return node;
-}
-/**
- * Convert to QualifiedTypeIdentifier
- */
-
-
-function mapQualifiedTypeofIdentifier(node) {
-  return {
-    type: 'QualifiedTypeIdentifier',
-    qualification: node.qualification.type === 'QualifiedTypeofIdentifier' ? mapQualifiedTypeofIdentifier(node.qualification) : node.qualification,
-    id: node.id,
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-
-function transformProgram(program, _options) {
-  return _SimpleTransform.SimpleTransform.transformProgram(program, {
-    transform(node) {
-      switch (node.type) {
-        case 'SymbolTypeAnnotation':
-          {
-            // Convert to simple generic type annotation
-            return createSimpleGenericTypeAnnotation('symbol', node);
-          }
-
-        case 'BigIntTypeAnnotation':
-          {
-            // Convert to simple generic type annotation
-            return createSimpleGenericTypeAnnotation('bigint', node);
-          }
-
-        case 'ObjectTypeAnnotation':
-          {
-            const shouldStrip = node.properties.some(prop => prop.type === 'ObjectTypeMappedTypeProperty');
-
-            if (shouldStrip) {
-              return createAnyTypeAnnotation(node);
-            }
-
-            return node;
-          }
-
-        case 'ObjectTypeMappedTypeProperty':
-          {
-            throw (0, _createSyntaxError.createSyntaxError)(node, `Invalid AST structure, ObjectTypeMappedTypeProperty found outside of an ObjectTypeAnnotation`);
-          }
-
-        case 'IndexedAccessType':
-        case 'OptionalIndexedAccessType':
-        case 'KeyofTypeAnnotation':
-        case 'ConditionalTypeAnnotation':
-        case 'InferTypeAnnotation':
-        case 'TupleTypeLabeledElement':
-        case 'TupleTypeSpreadElement':
-        case 'ComponentTypeAnnotation':
-        case 'HookTypeAnnotation':
-        case 'TypeOperator':
-        case 'TypePredicate':
-          {
-            // Babel does not support these generic types, so convert to any
-            return createAnyTypeAnnotation(node);
-          }
-
-        case 'QualifiedTypeofIdentifier':
-          {
-            return mapQualifiedTypeofIdentifier(node);
-          }
-
-        case 'DeclareEnum':
-          {
-            return mapDeclareEnum(node);
-          }
-
-        case 'DeclareNamespace':
-          {
-            return mapDeclareNamespace(node);
-          }
-
-        case 'FunctionDeclaration':
-        case 'FunctionExpression':
-          {
-            return mapFunction(node);
-          }
-
-        default:
-          {
-            return node;
-          }
-      }
-    }
-
-  });
-}