@typedefs/parser

@typedefs/parser is The Parser For JSDoc Types Written Using Google Closure Compiler Annotations (no TypeScript support). Although most of the typing rules are the same, the main difference is for functions and arrays:

• ✅ function(string, number=): void
• ⛔️ (arg: string, optional?: number) => void The arrow function notation is not supported. Cannot write ? for optional arguments, need to use =.
• ✅ !Array<string>
• ⛔️ string[] The double array bracket notation will not work.
• ✅ { record: (string|undefined) }
• ⛔️ { record?: string } Optional properties cannot be denoted with a question mark.

yarn add @typedefs/parser

Table Of Contents

• Table Of Contents
• API
• parse(type: string): !Type
  • Type
  • FunctionType
• Copyright

API

The package is available by importing its default function:

import parse from '@typedefs/parser'

parse(  type: string,): !Type

Parses a Google Closure Compiler type recursively.

Type: The representation of a type.

| Name | Type | Description | | ----------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | nullable | boolean | Whether the type is nullable. This is defined by writing ? before the type name to state nullability and ! otherwise. The parser does not infer nullability from types being primitive and Function/function. | | name | string | The name of the type. | | union | !Array<!Type> | If the type is defined as a union, e.g., (string\|number), contains the united types. Must include parenthesis. | | record | !Object<string, Type> | If the type is a record, contains its representation. If a property of the record does not have a type, it will be set to null. | | application | !Array<!Type> | The application of the type, e.g., the inner type of Object<Application>. | | function | !FunctionType | The function info with args and return if the type is a function. | | optional | boolean | If the type is returned as an optional argument of a function (function(string=)), this will be set to true. |

FunctionType: The meta information about the function.

| Name | Type | Description | | ------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | args* | !Array<!Type> | The arguments of the function. | | return* | ?Type | The return type of the function. When the value is set to null, it means the function does not have a return. If the return was actually null, it would be specified as return: { name: 'null' }. | | this | !Type | The type of the this argument specified as function(this: Type). | | new | !Type | The type of the new argument specified as function(new: Type). | | variableArgs | !Type | The type of the variable arguments, e.g., function(...Type). |

import parser from '@typedefs/parser'

logHeading('Applications')
log(parser('!Object<string, Promise<Array<!Type>>>'))

logHeading('Unions (parenthesis are required)')
log(parser('(string | number | !Promise<?(string | symbol)>)'))

logHeading('Records')
log(parser(`{
  a: string, b: ?number, c,
  d: !Promise<Array<{e: number}>>,
  f: { g: boolean }
}`))

logHeading('Functions')
log(parser(`function(
  this: Type,
  string,
  function(),
  function(): *=
): function(): null`))

// special case when name is nullable empty string ''
log(parser(`function(): ?`))

Applications:
------------

{ nullable: false,
  name: 'Object',
  application: 
   [ { name: 'string' },
     { name: 'Promise',
       application: 
        [ { name: 'Array',
            application: [ { nullable: false, name: 'Type' } ] } ] } ] }

Unions (parenthesis are required):
---------------------------------

{ union: 
   [ { name: 'string' },
     { name: 'number' },
     { nullable: false,
       name: 'Promise',
       application: 
        [ { union: [ { name: 'string' }, { name: 'symbol' } ],
            nullable: true } ] } ] }

Records:
-------

{ record: 
   { a: { name: 'string' },
     b: { nullable: true, name: 'number' },
     c: null,
     d: 
      { nullable: false,
        name: 'Promise',
        application: 
         [ { name: 'Array',
             application: [ { record: { e: { name: 'number' } } } ] } ] },
     f: { record: { g: { name: 'boolean' } } } } }

Functions:
---------

{ name: 'function',
  function: 
   { return: 
      { name: 'function',
        function: { return: { name: 'null' }, args: [] } },
     args: 
      [ { name: 'string' },
        { name: 'function', function: { return: null, args: [] } },
        { name: 'function',
          function: { return: { name: 'any' }, args: [] },
          optional: true } ],
     this: { name: 'Type' } } }
{ name: 'function',
  function: { return: { nullable: true, name: '' }, args: [] } }

Copyright