hermes-parser 0.32.0 → 0.33.0

package/dist/HermesParserWASM.js.flow

@@ -44,7 +44,16 @@ export type HermesParserWASM = $ReadOnly<{
     (
       'hermesParse',
       'number',
-      ['number', 'number', 'number', 'number', 'number', 'number', 'number'],
+      [
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+      ],
     ): (
       number,
       number,
@@ -53,6 +62,7 @@ export type HermesParserWASM = $ReadOnly<{
       CBoolean,
       CBoolean,
       CBoolean,
+      CBoolean,
     ) => number,
     ('hermesParseResult_free', 'void', ['number']): number => void,
     ('hermesParseResult_getError', 'string', ['number']): number => string,

package/dist/ParserOptions.js

@@ -14,5 +14,5 @@ exports.ParserOptionsKeys = void 0;
  * 
  * @format
  */
-const ParserOptionsKeys = new Set(['allowReturnOutsideFunction', 'babel', 'flow', 'enableExperimentalComponentSyntax', 'enableExperimentalFlowMatchSyntax', 'reactRuntimeTarget', 'sourceFilename', 'sourceType', 'tokens']);
+const ParserOptionsKeys = new Set(['allowReturnOutsideFunction', 'babel', 'flow', 'enableExperimentalComponentSyntax', 'enableExperimentalFlowMatchSyntax', 'enableExperimentalFlowRecordSyntax', 'reactRuntimeTarget', 'sourceFilename', 'sourceType', 'tokens', 'transformOptions']);
 exports.ParserOptionsKeys = ParserOptionsKeys;

package/dist/ParserOptions.js.flow

@@ -8,16 +8,24 @@
  * @format
  */
 
+import type {Expression} from 'hermes-estree';
+
 export type ParserOptions = {
   allowReturnOutsideFunction?: boolean,
   babel?: boolean,
   flow?: 'all' | 'detect',
   enableExperimentalComponentSyntax?: boolean,
   enableExperimentalFlowMatchSyntax?: boolean,
+  enableExperimentalFlowRecordSyntax?: boolean,
   reactRuntimeTarget?: '18' | '19',
   sourceFilename?: string,
   sourceType?: 'module' | 'script' | 'unambiguous',
   tokens?: boolean,
+  transformOptions?: {
+    +TransformEnumSyntax?: {
+      +getRuntime: () => Expression,
+    },
+  },
 };
 
 export const ParserOptionsKeys: $ReadOnlySet<$Keys<ParserOptions>> = new Set([
@@ -26,8 +34,10 @@ export const ParserOptionsKeys: $ReadOnlySet<$Keys<ParserOptions>> = new Set([
   'flow',
   'enableExperimentalComponentSyntax',
   'enableExperimentalFlowMatchSyntax',
+  'enableExperimentalFlowRecordSyntax',
   'reactRuntimeTarget',
   'sourceFilename',
   'sourceType',
   'tokens',
+  'transformOptions',
 ]);

package/dist/babel/TransformESTreeToBabel.js

@@ -30,6 +30,8 @@ const FlowESTreeAndBabelVisitorKeys = { ..._ESTreeVisitorKeys.default,
   BigIntLiteral: [],
   BlockStatement: ['directives', ..._ESTreeVisitorKeys.default.BlockStatement],
   BooleanLiteral: [],
+  ClassExpression: ['superTypeParameters', ..._ESTreeVisitorKeys.default.ClassExpression],
+  ClassDeclaration: ['superTypeParameters', ..._ESTreeVisitorKeys.default.ClassDeclaration],
   ClassMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassPrivateMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassProperty: ['key', 'value', 'typeAnnotation', 'variance'],
@@ -50,6 +52,7 @@ const FlowESTreeAndBabelVisitorKeys = { ..._ESTreeVisitorKeys.default,
   RegExpLiteral: [],
   RestElement: [..._ESTreeVisitorKeys.default.RestElement, 'typeAnnotation'],
   StringLiteral: [],
+  TupleTypeAnnotation: ['types'],
   CommentBlock: [],
   CommentLine: []
 };
@@ -480,6 +483,7 @@ function mapPropertyDefinition(node) {
 function mapTypeofTypeAnnotation(node) {
   // $FlowExpectedError[cannot-write]
   delete node.typeArguments; // $FlowFixMe[incompatible-type]
+  // $FlowFixMe[invalid-compare]
 
   if (node.argument.type !== 'GenericTypeAnnotation') {
     return nodeWith(node, {
@@ -656,6 +660,7 @@ function transformNode(node) {
 
         // Check if we have already processed this node.
         // $FlowFixMe[incompatible-type]
+        // $FlowFixMe[invalid-compare]
         if (((_node$parent = node.parent) == null ? void 0 : _node$parent.type) === 'File') {
           return node;
         }
@@ -819,10 +824,74 @@ function transformNode(node) {
     case 'TupleTypeAnnotation':
       {
         // $FlowExpectedError[cannot-write]
-        delete node.inexact;
+        delete node.inexact; // $FlowExpectedError[prop-missing]
+
+        node.types = node.elementTypes; // $FlowExpectedError[cannot-write]
+
+        delete node.elementTypes;
         return node;
       }
 
+    case 'UnknownTypeAnnotation':
+      {
+        return {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: 'unknown',
+            optional: false,
+            typeAnnotation: null,
+            loc: node.loc,
+            range: node.range,
+            parent: EMPTY_PARENT
+          },
+          typeParameters: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT
+        };
+      }
+
+    case 'NeverTypeAnnotation':
+      {
+        return {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: 'never',
+            optional: false,
+            typeAnnotation: null,
+            loc: node.loc,
+            range: node.range,
+            parent: EMPTY_PARENT
+          },
+          typeParameters: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT
+        };
+      }
+
+    case 'UndefinedTypeAnnotation':
+      {
+        return {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: 'undefined',
+            optional: false,
+            typeAnnotation: null,
+            loc: node.loc,
+            range: node.range,
+            parent: EMPTY_PARENT
+          },
+          typeParameters: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT
+        };
+      }
+
     case 'JSXText':
       {
         // $FlowExpectedError[prop-missing]
@@ -985,9 +1054,15 @@ function transformNode(node) {
           delete node.implements;
         }
 
-        if (node.superTypeParameters == null) {
+        if (node.superTypeArguments == null) {
+          // $FlowExpectedError[cannot-write]
+          delete node.superTypeArguments;
+        } else {
           // $FlowExpectedError[cannot-write]
-          delete node.superTypeParameters;
+          // $FlowExpectedError[prop-missing]
+          node.superTypeParameters = node.superTypeArguments; // $FlowExpectedError[cannot-write]
+
+          delete node.superTypeArguments;
         }
 
         if (node.typeParameters == null) {
@@ -1110,6 +1185,7 @@ function transformProgram(program, options) {
 
     visitorKeys: FlowESTreeAndBabelVisitorKeys
   }); // $FlowFixMe[incompatible-type]
+  // $FlowFixMe[invalid-compare]
 
 
   if ((resultNode == null ? void 0 : resultNode.type) === 'File') {

package/dist/babel/TransformESTreeToBabel.js.flow

@@ -59,6 +59,11 @@ const FlowESTreeAndBabelVisitorKeys: VisitorKeys = {
   BigIntLiteral: [],
   BlockStatement: ['directives', ...FlowVisitorKeys.BlockStatement],
   BooleanLiteral: [],
+  ClassExpression: ['superTypeParameters', ...FlowVisitorKeys.ClassExpression],
+  ClassDeclaration: [
+    'superTypeParameters',
+    ...FlowVisitorKeys.ClassDeclaration,
+  ],
   ClassMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassPrivateMethod: ['key', 'params', 'body', 'returnType', 'typeParameters'],
   ClassProperty: ['key', 'value', 'typeAnnotation', 'variance'],
@@ -85,6 +90,7 @@ const FlowESTreeAndBabelVisitorKeys: VisitorKeys = {
   RegExpLiteral: [],
   RestElement: [...FlowVisitorKeys.RestElement, 'typeAnnotation'],
   StringLiteral: [],
+  TupleTypeAnnotation: ['types'],
   CommentBlock: [],
   CommentLine: [],
 };
@@ -753,6 +759,7 @@ function mapTypeofTypeAnnotation(
   // $FlowExpectedError[cannot-write]
   delete node.typeArguments;
   // $FlowFixMe[incompatible-type]
+  // $FlowFixMe[invalid-compare]
   if (node.argument.type !== 'GenericTypeAnnotation') {
     return nodeWith(node, {
       // $FlowExpectedError[incompatible-type] Special override for Babel
@@ -920,6 +927,7 @@ function transformNode(node: ESNodeOrBabelNode): ESNodeOrBabelNode | null {
     case 'Program': {
       // Check if we have already processed this node.
       // $FlowFixMe[incompatible-type]
+      // $FlowFixMe[invalid-compare]
       if (node.parent?.type === 'File') {
         return node;
       }
@@ -1038,9 +1046,68 @@ function transformNode(node: ESNodeOrBabelNode): ESNodeOrBabelNode | null {
     case 'TupleTypeAnnotation': {
       // $FlowExpectedError[cannot-write]
       delete node.inexact;
+      // $FlowExpectedError[prop-missing]
+      node.types = node.elementTypes;
+      // $FlowExpectedError[cannot-write]
+      delete node.elementTypes;
       return node;
     }
 
+    case 'UnknownTypeAnnotation': {
+      return {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'Identifier',
+          name: 'unknown',
+          optional: false,
+          typeAnnotation: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT,
+        },
+        typeParameters: null,
+        loc: node.loc,
+        range: node.range,
+        parent: EMPTY_PARENT,
+      };
+    }
+    case 'NeverTypeAnnotation': {
+      return {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'Identifier',
+          name: 'never',
+          optional: false,
+          typeAnnotation: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT,
+        },
+        typeParameters: null,
+        loc: node.loc,
+        range: node.range,
+        parent: EMPTY_PARENT,
+      };
+    }
+    case 'UndefinedTypeAnnotation': {
+      return {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'Identifier',
+          name: 'undefined',
+          optional: false,
+          typeAnnotation: null,
+          loc: node.loc,
+          range: node.range,
+          parent: EMPTY_PARENT,
+        },
+        typeParameters: null,
+        loc: node.loc,
+        range: node.range,
+        parent: EMPTY_PARENT,
+      };
+    }
+
     case 'JSXText': {
       // $FlowExpectedError[prop-missing]
       node.extra = {
@@ -1165,9 +1232,15 @@ function transformNode(node: ESNodeOrBabelNode): ESNodeOrBabelNode | null {
         // $FlowExpectedError[cannot-write]
         delete node.implements;
       }
-      if (node.superTypeParameters == null) {
+      if (node.superTypeArguments == null) {
+        // $FlowExpectedError[cannot-write]
+        delete node.superTypeArguments;
+      } else {
+        // $FlowExpectedError[cannot-write]
+        // $FlowExpectedError[prop-missing]
+        node.superTypeParameters = node.superTypeArguments;
         // $FlowExpectedError[cannot-write]
-        delete node.superTypeParameters;
+        delete node.superTypeArguments;
       }
       if (node.typeParameters == null) {
         // $FlowExpectedError[cannot-write]
@@ -1263,6 +1336,7 @@ export function transformProgram(
   });
 
   // $FlowFixMe[incompatible-type]
+  // $FlowFixMe[invalid-compare]
   if (resultNode?.type === 'File') {
     return resultNode;
   }

package/dist/estree/StripFlowTypes.js

@@ -117,7 +117,7 @@ function transformProgram(program, _options) {
           {
             return nodeWith(node, {
               typeParameters: null,
-              superTypeParameters: null,
+              superTypeArguments: null,
               implements: [],
               decorators: []
             });

package/dist/estree/StripFlowTypes.js.flow

@@ -105,7 +105,7 @@ export function transformProgram(
         case 'ClassExpression': {
           return nodeWith(node, {
             typeParameters: null,
-            superTypeParameters: null,
+            superTypeArguments: null,
             implements: [],
             decorators: [],
           });

package/dist/estree/{StripComponentSyntax.js → TransformComponentSyntax.js}

@@ -191,7 +191,7 @@ function mapComponentParameters(params, options) {
 
   if (propsProperties.length === 0) {
     if (refParam == null) {
-      throw new Error('StripComponentSyntax: Invalid state, ref should always be set at this point if props are empty');
+      throw new Error('TransformComponentSyntax: Invalid state, ref should always be set at this point if props are empty');
     }
 
     const emptyParamsLoc = {

package/dist/estree/{StripComponentSyntax.js.flow → TransformComponentSyntax.js.flow}

@@ -243,7 +243,7 @@ function mapComponentParameters(
   if (propsProperties.length === 0) {
     if (refParam == null) {
       throw new Error(
-        'StripComponentSyntax: Invalid state, ref should always be set at this point if props are empty',
+        'TransformComponentSyntax: Invalid state, ref should always be set at this point if props are empty',
       );
     }
     const emptyParamsLoc = {

package/dist/estree/TransformEnumSyntax.js

@@ -0,0 +1,106 @@
+/**
+ * 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';
+/**
+ * Transform Flow Enum declarations (https://flow.org/en/docs/enums/).
+ */
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformProgram = transformProgram;
+
+var _hermesEstree = require("hermes-estree");
+
+var _SimpleTransform = require("../transform/SimpleTransform");
+
+var _Builders = require("../utils/Builders");
+
+function mapEnumDeclaration(node, options) {
+  var _options$transformOpt, _options$transformOpt2;
+
+  const {
+    body
+  } = node;
+  const {
+    members
+  } = body;
+  const getRuntime = (_options$transformOpt = options.transformOptions) == null ? void 0 : (_options$transformOpt2 = _options$transformOpt.TransformEnumSyntax) == null ? void 0 : _options$transformOpt2.getRuntime;
+  const enumModule = typeof getRuntime === 'function' ? getRuntime() : (0, _Builders.callExpression)((0, _Builders.ident)('require'), [(0, _Builders.stringLiteral)('flow-enums-runtime')]);
+  const mirrored = body.type === 'EnumStringBody' && (!members.length || members[0].type === 'EnumDefaultedMember');
+  const enumExpression = mirrored ? (0, _Builders.callExpression)({
+    type: 'MemberExpression',
+    object: enumModule,
+    property: (0, _Builders.ident)('Mirrored'),
+    computed: false,
+    optional: false,
+    ...(0, _Builders.etc)()
+  }, [{
+    type: 'ArrayExpression',
+    elements: members.map(member => (0, _Builders.stringLiteral)(member.id.name)),
+    trailingComma: false,
+    ...(0, _Builders.etc)()
+  }]) : (0, _Builders.callExpression)(enumModule, [{
+    type: 'ObjectExpression',
+    properties: members.map(member => ({
+      type: 'Property',
+      key: member.id,
+      value: // String enums with `EnumDefaultedMember` are handled above by
+      // calculation of `mirrored`.
+      member.type === 'EnumDefaultedMember' ? (0, _Builders.callExpression)((0, _Builders.ident)('Symbol'), [(0, _Builders.stringLiteral)(member.id.name)]) : member.init,
+      kind: 'init',
+      method: false,
+      shorthand: false,
+      computed: false,
+      ...(0, _Builders.etc)(),
+      parent: _Builders.EMPTY_PARENT
+    })),
+    ...(0, _Builders.etc)()
+  }]);
+  return (0, _Builders.variableDeclaration)('const', node.id, enumExpression);
+}
+
+function transformProgram(program, options) {
+  return _SimpleTransform.SimpleTransform.transformProgram(program, {
+    transform(node) {
+      switch (node.type) {
+        case 'EnumDeclaration':
+          {
+            return mapEnumDeclaration(node, options);
+          }
+
+        case 'ExportDefaultDeclaration':
+          {
+            const {
+              declaration
+            } = node;
+
+            if ((0, _hermesEstree.isEnumDeclaration)(declaration)) {
+              const enumDeclaration = mapEnumDeclaration(declaration, options);
+
+              const exportDefault = _SimpleTransform.SimpleTransform.nodeWith(node, {
+                declaration: (0, _Builders.ident)(declaration.id.name)
+              });
+
+              return [enumDeclaration, exportDefault];
+            } else {
+              return node;
+            }
+          }
+
+        default:
+          {
+            return node;
+          }
+      }
+    }
+
+  });
+}

package/dist/estree/TransformEnumSyntax.js.flow

@@ -0,0 +1,125 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Transform Flow Enum declarations (https://flow.org/en/docs/enums/).
+ */
+
+import type {ParserOptions} from '../ParserOptions';
+import type {
+  ESNode,
+  EnumDeclaration,
+  ExportDefaultDeclaration,
+  ObjectPropertyWithNonShorthandStaticName,
+  Program,
+} from 'hermes-estree';
+
+import {isEnumDeclaration} from 'hermes-estree';
+import {SimpleTransform} from '../transform/SimpleTransform';
+import {
+  EMPTY_PARENT,
+  callExpression,
+  etc,
+  ident,
+  stringLiteral,
+  variableDeclaration,
+} from '../utils/Builders';
+
+function mapEnumDeclaration(node: EnumDeclaration, options: ParserOptions) {
+  const {body} = node;
+  const {members} = body;
+  const getRuntime = options.transformOptions?.TransformEnumSyntax?.getRuntime;
+  const enumModule =
+    typeof getRuntime === 'function'
+      ? getRuntime()
+      : callExpression(ident('require'), [stringLiteral('flow-enums-runtime')]);
+  const mirrored =
+    body.type === 'EnumStringBody' &&
+    (!members.length || members[0].type === 'EnumDefaultedMember');
+  const enumExpression = mirrored
+    ? callExpression(
+        {
+          type: 'MemberExpression',
+          object: enumModule,
+          property: ident('Mirrored'),
+          computed: false,
+          optional: false,
+          ...etc(),
+        },
+        [
+          {
+            type: 'ArrayExpression',
+            elements: members.map(member => stringLiteral(member.id.name)),
+            trailingComma: false,
+            ...etc(),
+          },
+        ],
+      )
+    : callExpression(enumModule, [
+        {
+          type: 'ObjectExpression',
+          properties: members.map(
+            (member): ObjectPropertyWithNonShorthandStaticName => ({
+              type: 'Property',
+              key: member.id,
+              value:
+                // String enums with `EnumDefaultedMember` are handled above by
+                // calculation of `mirrored`.
+                member.type === 'EnumDefaultedMember'
+                  ? callExpression(ident('Symbol'), [
+                      stringLiteral(member.id.name),
+                    ])
+                  : member.init,
+              kind: 'init',
+              method: false,
+              shorthand: false,
+              computed: false,
+              ...etc(),
+              parent: EMPTY_PARENT,
+            }),
+          ),
+          ...etc(),
+        },
+      ]);
+  return variableDeclaration('const', node.id, enumExpression);
+}
+
+export function transformProgram(
+  program: Program,
+  options: ParserOptions,
+): Program {
+  return SimpleTransform.transformProgram(program, {
+    transform(node: ESNode): ESNode | $ReadOnlyArray<ESNode> {
+      switch (node.type) {
+        case 'EnumDeclaration': {
+          return mapEnumDeclaration(node, options);
+        }
+        case 'ExportDefaultDeclaration': {
+          const {declaration} = node;
+          if (isEnumDeclaration(declaration)) {
+            const enumDeclaration = mapEnumDeclaration(declaration, options);
+            const exportDefault: ExportDefaultDeclaration =
+              SimpleTransform.nodeWith(node, {
+                declaration: ident(declaration.id.name),
+              });
+            return [enumDeclaration, exportDefault];
+          } else {
+            return node;
+          }
+        }
+        default: {
+          return node;
+        }
+      }
+    },
+  });
+}