Napolean Paced Mischeviously
    Have ideas to improve npm?Join in the discussion! »

    ast-types-flow

    0.0.7 • Public • Published

    ast-types-flow

    Flow types for the Javascript AST. Based off of benjamn/ast-types.

    Usage

    First install ast-types-flow via npm, then you can import any of the types that are exported.

    /* @flow */
     
    import type {Node} from 'ast-types-flow';
     
    function getName(node: Node): string {
      switch (node.type) {
        case 'Identifier':
          return node.name;
     
        case 'ClassDeclaration':
          return node.id.name; // Error, id could be null.
     
        case 'FunctionDeclaration':
          return node.id.name; // Fine if it's always there.
     
        case 'FunctionExpression':
          if (node.id) {
            return node.id.name; // Can refine id to make sure it exists.
          } else {
            return 'Unknown';
          }
     
        case 'Literal':
          return node.name; // Error, Literals don't have names, don't be silly.
      }
      return 'Unknown';
    }

    How it works

    A notion of "extends" is added to the Flow syntax via comments. A transform is included that will compile the source code into useful disjoint union types based on how the different types extend each other. For example:

    type Node = {
      common: string,
    };
     
    type Foo = {
      // extends Node
      foo: string,
    };
     
    type Bar = {
      // extends Node
      bar: number,
    };

    Will be transformed into:

    type Node = {
      type: 'Foo',
      _Foo: void,
      common: string,
      foo: string,
    } | {
      type: 'Bar',
      _Bar: void,
      common: string,
      bar: number,
    };
     
    type Foo = {
      type: 'Foo',
      _Foo: void,
      common: string,
      foo: string,
    };
     
    type Bar = {
      type: 'Bar',
      _Foo: void,
      common: string,
      bar: number,
    };

    A few things to note:

    1. The type Node would more ideally be compiled into Foo | Bar but then the disjoint union cannot be properly refined. For now we have to duplicate the complete definitions.
    2. Each entry in a disjoint union has to be structurally unique or Flow will have an error on the definition. That is why the private _Foo: void fields appear in the types.

    Install

    npm i ast-types-flow

    DownloadsWeekly Downloads

    6,598,080

    Version

    0.0.7

    License

    ISC

    Last publish

    Collaborators

    • avatar