hermes-parser 0.11.1 → 0.12.0

package/dist/HermesParserWASM.js.flow

@@ -12,7 +12,11 @@ type INTENTIONAL_ANY = $FlowFixMe;
 type JSType = 'number' | 'string' | 'array' | 'boolean';
 type CBoolean = ?(number | boolean);
 
-type HermesParserWASM = $ReadOnly<{
+type WASMModuleOverrides = $ReadOnly<{
+  quit(status: number, toThrow: Error): void,
+}>;
+
+export type HermesParserWASM = $ReadOnly<{
   HEAP8: Int8Array,
   HEAP16: Int16Array,
   HEAP32: Int32Array,
@@ -72,4 +76,4 @@ type HermesParserWASM = $ReadOnly<{
   stackRestore(ptr: number): void,
 }>;
 
-declare module.exports: HermesParserWASM;
+declare module.exports: WASMModuleOverrides => HermesParserWASM;

package/dist/HermesToBabelAdapter.js

@@ -18,6 +18,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * 
  * @format
  */
+function createSyntaxError(node, err) {
+  const syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
+
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column
+  };
+  return syntaxError;
+}
+
 class HermesToBabelAdapter extends _HermesASTAdapter.default {
   fixSourceLocation(node) {
     var _this$sourceFilename;
@@ -113,6 +123,7 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'TupleTypeLabeledElement':
       case 'TupleTypeSpreadElement':
       case 'ObjectTypeMappedTypeProperty':
+      case 'ComponentTypeAnnotation':
         return this.mapUnsupportedTypeAnnotation(node);
 
       case 'BigIntLiteral':
@@ -136,9 +147,15 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'DeclareEnum':
         return this.mapDeclareEnum(node);
 
+      case 'DeclareComponent':
+        return this.mapDeclareComponent(node);
+
       case 'JSXElement':
         return this.mapJSXElement(node);
 
+      case 'ComponentDeclaration':
+        return this.mapComponentDeclaration(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -557,11 +574,195 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
     return this.mapDeclareVariable(nodeUnprocessed);
   }
 
+  mapDeclareComponent(nodeUnprocessed) {
+    nodeUnprocessed.id.typeAnnotation = this.mapUnsupportedTypeAnnotation(nodeUnprocessed);
+    delete nodeUnprocessed.params;
+    delete nodeUnprocessed.rest;
+    delete nodeUnprocessed.typeParameters;
+    delete nodeUnprocessed.rendersType;
+    nodeUnprocessed.type = 'DeclareVariable';
+    return this.mapDeclareVariable(nodeUnprocessed);
+  }
+
   mapJSXElement(nodeUnprocessed) {
     delete nodeUnprocessed.openingElement.typeArguments;
     return this.mapNodeDefault(nodeUnprocessed);
   }
 
+  mapComponentDeclaration(nodeUnprocessed) {
+    let rendersType = nodeUnprocessed.rendersType;
+
+    if (rendersType == null) {
+      // Create empty loc for return type annotation nodes
+      const createRendersTypeLoc = () => ({
+        loc: {
+          start: { ...nodeUnprocessed.body.loc.end
+          },
+          end: { ...nodeUnprocessed.body.loc.end
+          },
+          rangeStart: nodeUnprocessed.body.loc.rangeStart,
+          rangeEnd: nodeUnprocessed.body.loc.rangeEnd
+        }
+      });
+
+      rendersType = {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'QualifiedTypeIdentifier',
+          qualification: {
+            type: 'Identifier',
+            name: 'React',
+            ...createRendersTypeLoc()
+          },
+          id: {
+            type: 'Identifier',
+            name: 'Node',
+            ...createRendersTypeLoc()
+          }
+        },
+        typeParameters: null,
+        ...createRendersTypeLoc()
+      };
+    }
+
+    function getParamName(paramName) {
+      switch (paramName.type) {
+        case 'Identifier':
+          return paramName.name;
+
+        case 'StringLiteral':
+          return paramName.value;
+
+        default:
+          throw createSyntaxError(paramName, `Unknown Component parameter name type of "${paramName.type}"`);
+      }
+    }
+
+    const properties = nodeUnprocessed.params.map(param => {
+      switch (param.type) {
+        case 'RestElement':
+          {
+            delete param.typeAnnotation;
+            return param;
+          }
+
+        case 'ComponentParameter':
+          {
+            if (getParamName(param.name) === 'ref') {
+              throw createSyntaxError(param, 'Component parameters named "ref" are currently not supported');
+            }
+
+            if (param.name.type === 'Identifier') {
+              delete param.name.typeAnnotation;
+            }
+
+            if (param.local.type === 'AssignmentPattern') {
+              delete param.local.left.typeAnnotation;
+              delete param.local.left.optional;
+            } else {
+              delete param.local.typeAnnotation;
+              delete param.local.optional;
+            }
+
+            return {
+              type: 'ObjectProperty',
+              key: param.name,
+              value: param.local,
+              method: false,
+              shorthand: param.shorthand,
+              computed: false,
+              loc: param.loc,
+              start: param.start,
+              end: param.end
+            };
+          }
+
+        default:
+          {
+            throw createSyntaxError(param, `Unknown Component parameter type of "${param.type}"`);
+          }
+      }
+    });
+
+    const paramsLoc = (() => {
+      if (properties.length === 0) {
+        // No props, approximate range via existing nodes.
+        const startLoc = nodeUnprocessed.typeParameters != null ? nodeUnprocessed.typeParameters.loc : nodeUnprocessed.id.loc;
+        return {
+          start: startLoc.end,
+          end: rendersType.loc.start,
+          startRange: startLoc.endRange,
+          endRange: rendersType.loc.startRange
+        };
+      }
+
+      return {
+        start: properties[0].loc.start,
+        end: properties[properties.length - 1].loc.end,
+        startRange: properties[0].loc.startRange,
+        endRange: properties[properties.length - 1].loc.endRange
+      };
+    })(); // Create empty loc for type annotation nodes
+
+
+    const createParamsTypeLoc = () => ({
+      loc: {
+        start: { ...paramsLoc.end
+        },
+        end: { ...paramsLoc.end
+        },
+        startRange: paramsLoc.endRange,
+        endRange: paramsLoc.endRange
+      }
+    });
+
+    const params = [{
+      type: 'ObjectPattern',
+      properties,
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+        typeAnnotation: {
+          type: 'GenericTypeAnnotation',
+          id: {
+            type: 'Identifier',
+            name: '$ReadOnly',
+            ...createParamsTypeLoc()
+          },
+          typeParameters: {
+            type: 'TypeParameterInstantiation',
+            params: [{
+              type: 'ObjectTypeAnnotation',
+              callProperties: [],
+              properties: [],
+              indexers: [],
+              internalSlots: [],
+              exact: false,
+              inexact: true,
+              ...createParamsTypeLoc()
+            }],
+            ...createParamsTypeLoc()
+          },
+          ...createParamsTypeLoc()
+        },
+        ...createParamsTypeLoc()
+      },
+      loc: paramsLoc
+    }];
+    const functionComponent = {
+      type: 'FunctionDeclaration',
+      id: nodeUnprocessed.id,
+      typeParameters: nodeUnprocessed.typeParameters,
+      params,
+      returnType: rendersType,
+      body: nodeUnprocessed.body,
+      async: false,
+      generator: false,
+      predicate: null,
+      loc: nodeUnprocessed.loc
+    };
+    return this.mapNodeDefault(functionComponent);
+  }
+
 }
 
 exports.default = HermesToBabelAdapter;

package/dist/HermesToBabelAdapter.js.flow

@@ -14,6 +14,17 @@ import HermesASTAdapter from './HermesASTAdapter';
 
 declare var BigInt: ?(value: $FlowFixMe) => mixed;
 
+function createSyntaxError(node: HermesNode, err: string): SyntaxError {
+  const syntaxError = new SyntaxError(err);
+  // $FlowExpectedError[prop-missing]
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column,
+  };
+
+  return syntaxError;
+}
+
 export default class HermesToBabelAdapter extends HermesASTAdapter {
   fixSourceLocation(node: HermesNode): void {
     const loc = node.loc;
@@ -85,6 +96,7 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
       case 'TupleTypeLabeledElement':
       case 'TupleTypeSpreadElement':
       case 'ObjectTypeMappedTypeProperty':
+      case 'ComponentTypeAnnotation':
         return this.mapUnsupportedTypeAnnotation(node);
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
@@ -100,8 +112,12 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapDeclareVariable(node);
       case 'DeclareEnum':
         return this.mapDeclareEnum(node);
+      case 'DeclareComponent':
+        return this.mapDeclareComponent(node);
       case 'JSXElement':
         return this.mapJSXElement(node);
+      case 'ComponentDeclaration':
+        return this.mapComponentDeclaration(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -539,8 +555,201 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
     return this.mapDeclareVariable(nodeUnprocessed);
   }
 
+  mapDeclareComponent(nodeUnprocessed: HermesNode): HermesNode {
+    nodeUnprocessed.id.typeAnnotation =
+      this.mapUnsupportedTypeAnnotation(nodeUnprocessed);
+
+    delete nodeUnprocessed.params;
+    delete nodeUnprocessed.rest;
+    delete nodeUnprocessed.typeParameters;
+    delete nodeUnprocessed.rendersType;
+
+    nodeUnprocessed.type = 'DeclareVariable';
+
+    return this.mapDeclareVariable(nodeUnprocessed);
+  }
+
   mapJSXElement(nodeUnprocessed: HermesNode): HermesNode {
     delete nodeUnprocessed.openingElement.typeArguments;
     return this.mapNodeDefault(nodeUnprocessed);
   }
+
+  mapComponentDeclaration(nodeUnprocessed: HermesNode): HermesNode {
+    let rendersType = nodeUnprocessed.rendersType;
+    if (rendersType == null) {
+      // Create empty loc for return type annotation nodes
+      const createRendersTypeLoc = () => ({
+        loc: {
+          start: {...nodeUnprocessed.body.loc.end},
+          end: {...nodeUnprocessed.body.loc.end},
+          rangeStart: nodeUnprocessed.body.loc.rangeStart,
+          rangeEnd: nodeUnprocessed.body.loc.rangeEnd,
+        },
+      });
+
+      rendersType = {
+        type: 'GenericTypeAnnotation',
+        id: {
+          type: 'QualifiedTypeIdentifier',
+          qualification: {
+            type: 'Identifier',
+            name: 'React',
+            ...createRendersTypeLoc(),
+          },
+          id: {
+            type: 'Identifier',
+            name: 'Node',
+            ...createRendersTypeLoc(),
+          },
+        },
+        typeParameters: null,
+        ...createRendersTypeLoc(),
+      };
+    }
+
+    function getParamName(paramName: HermesNode): string {
+      switch (paramName.type) {
+        case 'Identifier':
+          return paramName.name;
+        case 'StringLiteral':
+          return paramName.value;
+        default:
+          throw createSyntaxError(
+            paramName,
+            `Unknown Component parameter name type of "${paramName.type}"`,
+          );
+      }
+    }
+
+    const properties = nodeUnprocessed.params.map(param => {
+      switch (param.type) {
+        case 'RestElement': {
+          delete param.typeAnnotation;
+          return param;
+        }
+        case 'ComponentParameter': {
+          if (getParamName(param.name) === 'ref') {
+            throw createSyntaxError(
+              param,
+              'Component parameters named "ref" are currently not supported',
+            );
+          }
+
+          if (param.name.type === 'Identifier') {
+            delete param.name.typeAnnotation;
+          }
+          if (param.local.type === 'AssignmentPattern') {
+            delete param.local.left.typeAnnotation;
+            delete param.local.left.optional;
+          } else {
+            delete param.local.typeAnnotation;
+            delete param.local.optional;
+          }
+
+          return {
+            type: 'ObjectProperty',
+            key: param.name,
+            value: param.local,
+            method: false,
+            shorthand: param.shorthand,
+            computed: false,
+            loc: param.loc,
+            start: param.start,
+            end: param.end,
+          };
+        }
+        default: {
+          throw createSyntaxError(
+            param,
+            `Unknown Component parameter type of "${param.type}"`,
+          );
+        }
+      }
+    });
+
+    const paramsLoc = (() => {
+      if (properties.length === 0) {
+        // No props, approximate range via existing nodes.
+        const startLoc =
+          nodeUnprocessed.typeParameters != null
+            ? nodeUnprocessed.typeParameters.loc
+            : nodeUnprocessed.id.loc;
+        return {
+          start: startLoc.end,
+          end: rendersType.loc.start,
+          startRange: startLoc.endRange,
+          endRange: rendersType.loc.startRange,
+        };
+      }
+
+      return {
+        start: properties[0].loc.start,
+        end: properties[properties.length - 1].loc.end,
+        startRange: properties[0].loc.startRange,
+        endRange: properties[properties.length - 1].loc.endRange,
+      };
+    })();
+
+    // Create empty loc for type annotation nodes
+    const createParamsTypeLoc = () => ({
+      loc: {
+        start: {...paramsLoc.end},
+        end: {...paramsLoc.end},
+        startRange: paramsLoc.endRange,
+        endRange: paramsLoc.endRange,
+      },
+    });
+
+    const params = [
+      {
+        type: 'ObjectPattern',
+        properties,
+        typeAnnotation: {
+          type: 'TypeAnnotation',
+          typeAnnotation: {
+            type: 'GenericTypeAnnotation',
+            id: {
+              type: 'Identifier',
+              name: '$ReadOnly',
+              ...createParamsTypeLoc(),
+            },
+            typeParameters: {
+              type: 'TypeParameterInstantiation',
+              params: [
+                {
+                  type: 'ObjectTypeAnnotation',
+                  callProperties: [],
+                  properties: [],
+                  indexers: [],
+                  internalSlots: [],
+                  exact: false,
+                  inexact: true,
+                  ...createParamsTypeLoc(),
+                },
+              ],
+              ...createParamsTypeLoc(),
+            },
+            ...createParamsTypeLoc(),
+          },
+          ...createParamsTypeLoc(),
+        },
+        loc: paramsLoc,
+      },
+    ];
+
+    const functionComponent = {
+      type: 'FunctionDeclaration',
+      id: nodeUnprocessed.id,
+      typeParameters: nodeUnprocessed.typeParameters,
+      params,
+      returnType: rendersType,
+      body: nodeUnprocessed.body,
+      async: false,
+      generator: false,
+      predicate: null,
+      loc: nodeUnprocessed.loc,
+    };
+
+    return this.mapNodeDefault(functionComponent);
+  }
 }

package/dist/generated/ESTreeVisitorKeys.js

@@ -44,16 +44,16 @@ 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'],
+  ComponentDeclaration: ['id', 'params', 'body', 'typeParameters', 'rendersType'],
   ComponentParameter: ['name', 'local'],
-  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'returnType'],
+  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'rendersType'],
   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'],
+  DeclareComponent: ['id', 'params', 'rest', 'typeParameters', 'rendersType'],
   DeclaredPredicate: ['value'],
   DeclareEnum: ['id', 'body'],
   DeclareExportAllDeclaration: ['source'],

package/dist/generated/ParserVisitorKeys.js

@@ -118,7 +118,7 @@ const HERMES_AST_VISITOR_KEYS = {
     params: 'NodeList',
     body: 'Node',
     typeParameters: 'Node',
-    returnType: 'Node'
+    rendersType: 'Node'
   },
   ComponentParameter: {
     name: 'Node',
@@ -128,7 +128,7 @@ const HERMES_AST_VISITOR_KEYS = {
     params: 'NodeList',
     rest: 'Node',
     typeParameters: 'Node',
-    returnType: 'Node'
+    rendersType: 'Node'
   },
   ComponentTypeParameter: {
     name: 'Node',
@@ -162,7 +162,7 @@ const HERMES_AST_VISITOR_KEYS = {
     params: 'NodeList',
     rest: 'Node',
     typeParameters: 'Node',
-    returnType: 'Node'
+    rendersType: 'Node'
   },
   DeclaredPredicate: {
     value: 'Node'

package/dist/index.js

@@ -14,11 +14,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 var _exportNames = {
   parse: true,
+  mutateESTreeASTForPrettier: true,
   FlowVisitorKeys: true,
   astArrayMutationHelpers: true,
   astNodeMutationHelpers: true
 };
-exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = void 0;
+exports.mutateESTreeASTForPrettier = exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = void 0;
 exports.parse = parse;
 
 var HermesParser = _interopRequireWildcard(require("./HermesParser"));
@@ -66,6 +67,10 @@ var _astNodeMutationHelpers = _interopRequireWildcard(require("./transform/astNo
 
 exports.astNodeMutationHelpers = _astNodeMutationHelpers;
 
+var _mutateESTreeASTForPrettier = _interopRequireDefault(require("./utils/mutateESTreeASTForPrettier"));
+
+exports.mutateESTreeASTForPrettier = _mutateESTreeASTForPrettier.default;
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

package/dist/index.js.flow

@@ -90,3 +90,4 @@ export * from './traverse/getVisitorKeys';
 export {FlowVisitorKeys};
 export * as astArrayMutationHelpers from './transform/astArrayMutationHelpers';
 export * as astNodeMutationHelpers from './transform/astNodeMutationHelpers';
+export {default as mutateESTreeASTForPrettier} from './utils/mutateESTreeASTForPrettier';

package/dist/transform/SimpleTransform.js

@@ -54,8 +54,9 @@ class SimpleTransform {
         }
       },
 
-      leave(_node) {}
+      leave(_node) {},
 
+      visitorKeys: options.visitorKeys
     });
 
     return resultRootNode;

package/dist/transform/SimpleTransform.js.flow

@@ -74,6 +74,7 @@ export class SimpleTransform {
         }
       },
       leave(_node: ESNode) {},
+      visitorKeys: options.visitorKeys,
     });
     return resultRootNode;
   }