hermes-parser 0.10.1 → 0.11.0

package/dist/HermesParserWASM.js.flow

@@ -40,8 +40,8 @@ type HermesParserWASM = $ReadOnly<{
     (
       'hermesParse',
       'number',
-      ['number', 'number', 'number', 'number', 'number'],
-    ): (number, number, CBoolean, CBoolean, CBoolean) => number,
+      ['number', 'number', 'number', 'number', 'number', 'number'],
+    ): (number, number, CBoolean, CBoolean, CBoolean, CBoolean) => number,
     ('hermesParseResult_free', 'void', ['number']): number => void,
     ('hermesParseResult_getError', 'string', ['number']): number => string,
     ('hermesParseResult_getErrorLine', 'number', ['number']): number => number,

package/dist/HermesToBabelAdapter.js

@@ -107,6 +107,12 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
 
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
+      case 'KeyofTypeAnnotation':
+      case 'ConditionalType':
+      case 'InferType':
+      case 'TupleTypeLabeledElement':
+      case 'TupleTypeSpreadElement':
+      case 'ObjectTypeMappedTypeProperty':
         return this.mapUnsupportedTypeAnnotation(node);
 
       case 'BigIntLiteral':
@@ -118,6 +124,21 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'BigIntTypeAnnotation':
         return this.mapBigIntTypeAnnotation(node);
 
+      case 'TypeofTypeAnnotation':
+        return this.mapTypeofTypeAnnotation(node);
+
+      case 'QualifiedTypeofIdentifier':
+        return this.mapQualifiedTypeofIdentifier(node);
+
+      case 'DeclareVariable':
+        return this.mapDeclareVariable(node);
+
+      case 'DeclareEnum':
+        return this.mapDeclareEnum(node);
+
+      case 'JSXElement':
+        return this.mapJSXElement(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -509,6 +530,38 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
     return node;
   }
 
+  mapTypeofTypeAnnotation(nodeUnprocessed) {
+    nodeUnprocessed.argument = {
+      type: 'GenericTypeAnnotation',
+      id: nodeUnprocessed.argument,
+      typeParameters: null,
+      loc: nodeUnprocessed.argument.loc
+    };
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapQualifiedTypeofIdentifier(nodeUnprocessed) {
+    nodeUnprocessed.type = 'QualifiedTypeIdentifier';
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareVariable(nodeUnprocessed) {
+    delete nodeUnprocessed.kind;
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareEnum(nodeUnprocessed) {
+    nodeUnprocessed.id.typeAnnotation = this.mapUnsupportedTypeAnnotation(nodeUnprocessed.body);
+    delete nodeUnprocessed.body;
+    nodeUnprocessed.type = 'DeclareVariable';
+    return this.mapDeclareVariable(nodeUnprocessed);
+  }
+
+  mapJSXElement(nodeUnprocessed) {
+    delete nodeUnprocessed.openingElement.typeArguments;
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
 }
 
 exports.default = HermesToBabelAdapter;

package/dist/HermesToBabelAdapter.js.flow

@@ -79,6 +79,12 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapFunction(node);
       case 'IndexedAccessType':
       case 'OptionalIndexedAccessType':
+      case 'KeyofTypeAnnotation':
+      case 'ConditionalType':
+      case 'InferType':
+      case 'TupleTypeLabeledElement':
+      case 'TupleTypeSpreadElement':
+      case 'ObjectTypeMappedTypeProperty':
         return this.mapUnsupportedTypeAnnotation(node);
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
@@ -86,6 +92,16 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapBigIntLiteralTypeAnnotation(node);
       case 'BigIntTypeAnnotation':
         return this.mapBigIntTypeAnnotation(node);
+      case 'TypeofTypeAnnotation':
+        return this.mapTypeofTypeAnnotation(node);
+      case 'QualifiedTypeofIdentifier':
+        return this.mapQualifiedTypeofIdentifier(node);
+      case 'DeclareVariable':
+        return this.mapDeclareVariable(node);
+      case 'DeclareEnum':
+        return this.mapDeclareEnum(node);
+      case 'JSXElement':
+        return this.mapJSXElement(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -487,4 +503,44 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
 
     return node;
   }
+
+  mapTypeofTypeAnnotation(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.argument = {
+      type: 'GenericTypeAnnotation',
+      id: nodeUnprocessed.argument,
+      typeParameters: null,
+      loc: nodeUnprocessed.argument.loc,
+    };
+
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapQualifiedTypeofIdentifier(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.type = 'QualifiedTypeIdentifier';
+
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareVariable(nodeUnprocessed: HermesNode): HermesNode {
+    delete nodeUnprocessed.kind;
+
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
+
+  mapDeclareEnum(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.id.typeAnnotation = this.mapUnsupportedTypeAnnotation(
+      nodeUnprocessed.body,
+    );
+
+    delete nodeUnprocessed.body;
+
+    nodeUnprocessed.type = 'DeclareVariable';
+
+    return this.mapDeclareVariable(nodeUnprocessed);
+  }
+
+  mapJSXElement(nodeUnprocessed: HermesNode): HermesNode {
+    delete nodeUnprocessed.openingElement.typeArguments;
+    return this.mapNodeDefault(nodeUnprocessed);
+  }
 }

package/dist/ParserOptions.js.flow

@@ -12,6 +12,7 @@ export type ParserOptions = {
   allowReturnOutsideFunction?: boolean,
   babel?: boolean,
   flow?: 'all' | 'detect',
+  enableExperimentalComponentSyntax?: boolean,
   sourceFilename?: string,
   sourceType?: 'module' | 'script' | 'unambiguous',
   tokens?: boolean,

package/dist/generated/ESTreeVisitorKeys.js

@@ -44,11 +44,18 @@ module.exports = {
   ClassDeclaration: ['id', 'typeParameters', 'superClass', 'superTypeParameters', 'implements', 'decorators', 'body'],
   ClassExpression: ['id', 'typeParameters', 'superClass', 'superTypeParameters', 'implements', 'decorators', 'body'],
   ClassImplements: ['id', 'typeParameters'],
+  ComponentDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType'],
+  ComponentParameter: ['name', 'local'],
+  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'returnType'],
+  ComponentTypeParameter: ['name', 'typeAnnotation'],
   ConditionalExpression: ['test', 'consequent', 'alternate'],
+  ConditionalTypeAnnotation: ['checkType', 'extendsType', 'trueType', 'falseType'],
   ContinueStatement: ['label'],
   DebuggerStatement: [],
   DeclareClass: ['id', 'typeParameters', 'extends', 'implements', 'mixins', 'body'],
+  DeclareComponent: ['id', 'params', 'rest', 'typeParameters', 'returnType'],
   DeclaredPredicate: ['value'],
+  DeclareEnum: ['id', 'body'],
   DeclareExportAllDeclaration: ['source'],
   DeclareExportDeclaration: ['declaration', 'specifiers', 'source'],
   DeclareFunction: ['id', 'predicate'],
@@ -94,6 +101,7 @@ module.exports = {
   ImportSpecifier: ['imported', 'local'],
   IndexedAccessType: ['objectType', 'indexType'],
   InferredPredicate: [],
+  InferTypeAnnotation: ['typeParameter'],
   InterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
   InterfaceExtends: ['id', 'typeParameters'],
   InterfaceTypeAnnotation: ['extends', 'body'],
@@ -108,11 +116,12 @@ module.exports = {
   JSXIdentifier: [],
   JSXMemberExpression: ['object', 'property'],
   JSXNamespacedName: ['namespace', 'name'],
-  JSXOpeningElement: ['name', 'attributes'],
+  JSXOpeningElement: ['name', 'attributes', 'typeArguments'],
   JSXOpeningFragment: [],
   JSXSpreadAttribute: ['argument'],
   JSXSpreadChild: ['expression'],
   JSXText: [],
+  KeyofTypeAnnotation: ['argument'],
   LabeledStatement: ['label', 'body'],
   LogicalExpression: ['left', 'right'],
   MemberExpression: ['object', 'property'],
@@ -130,6 +139,7 @@ module.exports = {
   ObjectTypeCallProperty: ['value'],
   ObjectTypeIndexer: ['id', 'key', 'value', 'variance'],
   ObjectTypeInternalSlot: ['id', 'value'],
+  ObjectTypeMappedTypeProperty: ['keyTparam', 'propType', 'sourceType', 'variance'],
   ObjectTypeProperty: ['key', 'value', 'variance'],
   ObjectTypeSpreadProperty: ['argument'],
   OpaqueType: ['id', 'typeParameters', 'impltype', 'supertype'],
@@ -139,6 +149,7 @@ module.exports = {
   Property: ['key', 'value'],
   PropertyDefinition: ['key', 'value', 'variance', 'typeAnnotation', 'tsModifiers'],
   QualifiedTypeIdentifier: ['qualification', 'id'],
+  QualifiedTypeofIdentifier: ['qualification', 'id'],
   RestElement: ['argument'],
   ReturnStatement: ['argument'],
   SequenceExpression: ['expressions'],
@@ -157,6 +168,8 @@ module.exports = {
   ThrowStatement: ['argument'],
   TryStatement: ['block', 'handler', 'finalizer'],
   TupleTypeAnnotation: ['types'],
+  TupleTypeLabeledElement: ['label', 'elementType', 'variance'],
+  TupleTypeSpreadElement: ['label', 'typeAnnotation'],
   TypeAlias: ['id', 'typeParameters', 'right'],
   TypeAnnotation: ['typeAnnotation'],
   TypeCastExpression: ['expression', 'typeAnnotation'],
@@ -164,6 +177,7 @@ module.exports = {
   TypeParameter: ['bound', 'variance', 'default'],
   TypeParameterDeclaration: ['params'],
   TypeParameterInstantiation: ['params'],
+  TypePredicate: ['parameterName', 'typeAnnotation'],
   UnaryExpression: ['argument'],
   UnionTypeAnnotation: ['types'],
   UpdateExpression: ['argument'],

package/dist/generated/ParserVisitorKeys.js

@@ -113,11 +113,38 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     typeParameters: 'Node'
   },
+  ComponentDeclaration: {
+    id: 'Node',
+    params: 'NodeList',
+    body: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
+  ComponentParameter: {
+    name: 'Node',
+    local: 'Node'
+  },
+  ComponentTypeAnnotation: {
+    params: 'NodeList',
+    rest: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
+  ComponentTypeParameter: {
+    name: 'Node',
+    typeAnnotation: 'Node'
+  },
   ConditionalExpression: {
     test: 'Node',
     alternate: 'Node',
     consequent: 'Node'
   },
+  ConditionalTypeAnnotation: {
+    checkType: 'Node',
+    extendsType: 'Node',
+    trueType: 'Node',
+    falseType: 'Node'
+  },
   ContinueStatement: {
     label: 'Node'
   },
@@ -130,9 +157,20 @@ const HERMES_AST_VISITOR_KEYS = {
     mixins: 'NodeList',
     body: 'Node'
   },
+  DeclareComponent: {
+    id: 'Node',
+    params: 'NodeList',
+    rest: 'Node',
+    typeParameters: 'Node',
+    returnType: 'Node'
+  },
   DeclaredPredicate: {
     value: 'Node'
   },
+  DeclareEnum: {
+    id: 'Node',
+    body: 'Node'
+  },
   DeclareExportAllDeclaration: {
     source: 'Node'
   },
@@ -312,6 +350,9 @@ const HERMES_AST_VISITOR_KEYS = {
     indexType: 'Node'
   },
   InferredPredicate: {},
+  InferTypeAnnotation: {
+    typeParameter: 'Node'
+  },
   InterfaceDeclaration: {
     id: 'Node',
     typeParameters: 'Node',
@@ -362,7 +403,8 @@ const HERMES_AST_VISITOR_KEYS = {
   },
   JSXOpeningElement: {
     name: 'Node',
-    attributes: 'NodeList'
+    attributes: 'NodeList',
+    typeArguments: 'Node'
   },
   JSXOpeningFragment: {},
   JSXSpreadAttribute: {
@@ -372,6 +414,9 @@ const HERMES_AST_VISITOR_KEYS = {
     expression: 'Node'
   },
   JSXText: {},
+  KeyofTypeAnnotation: {
+    argument: 'Node'
+  },
   LabeledStatement: {
     label: 'Node',
     body: 'Node'
@@ -432,6 +477,12 @@ const HERMES_AST_VISITOR_KEYS = {
     id: 'Node',
     value: 'Node'
   },
+  ObjectTypeMappedTypeProperty: {
+    keyTparam: 'Node',
+    propType: 'Node',
+    sourceType: 'Node',
+    variance: 'Node'
+  },
   ObjectTypeProperty: {
     key: 'Node',
     value: 'Node',
@@ -469,6 +520,10 @@ const HERMES_AST_VISITOR_KEYS = {
     qualification: 'Node',
     id: 'Node'
   },
+  QualifiedTypeofIdentifier: {
+    qualification: 'Node',
+    id: 'Node'
+  },
   RegExpLiteral: {},
   RestElement: {
     argument: 'Node'
@@ -517,6 +572,15 @@ const HERMES_AST_VISITOR_KEYS = {
   TupleTypeAnnotation: {
     types: 'NodeList'
   },
+  TupleTypeLabeledElement: {
+    label: 'Node',
+    elementType: 'Node',
+    variance: 'Node'
+  },
+  TupleTypeSpreadElement: {
+    label: 'Node',
+    typeAnnotation: 'Node'
+  },
   TypeAlias: {
     id: 'Node',
     typeParameters: 'Node',
@@ -543,6 +607,10 @@ const HERMES_AST_VISITOR_KEYS = {
   TypeParameterInstantiation: {
     params: 'NodeList'
   },
+  TypePredicate: {
+    parameterName: 'Node',
+    typeAnnotation: 'Node'
+  },
   UnaryExpression: {
     argument: 'Node'
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-parser",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "A JavaScript parser built from the Hermes engine",
   "main": "dist/index.js",
   "license": "MIT",
@@ -9,10 +9,11 @@
     "url": "git@github.com:facebook/hermes.git"
   },
   "dependencies": {
-    "hermes-estree": "0.10.1"
+    "hermes-estree": "0.11.0"
   },
   "devDependencies": {
     "@babel/parser": "7.7.4",
+    "@babel/types": "7.7.4",
     "espree": "9.3.2"
   },
   "files": [