Refer to Cryrivers#9

just write down a few ways of writing the jsdoc,
need to figure out what is the expected behavior

/**
 * @iterate @faker {{internet.userName}}
 * @iterate cryrivers
 * @iterate @proxy http://name-generator.com
 */
name: string;

expected:
iterate through every call:

• faker's internet username
• "cryrivers"
• proxy value from http://name-generator.com

Note: can have multiline annotations

/**
 * @eval (@query page.size) + (@query page.offset)
 */
next: number;

expected:

• get query's page.size and query's page.offset
• and use eval to evalute javascript

Note: can use ( and ) to wrap

/**
 * @precision 2
 * @range 5 10
 */
value: number;
/**
 * @integer
 * @range 5 10
 */
value2: number;

should be written as -->

/**
 * @precision (@range 5 10) 2
 */
value: number;
/**
 * @integer @range 5 10
 */
value2: number;

/**
 * @example manta-style
 * @qotd
 * @iterate open source
 */
message: string;

plugin like iterate should check whether there's other annotation, if yes, it should give warning
or else, will randomly choose 1 line and run the plugin for that line.

To achieve the above, i propose that plugins should be stored as Map instead of array, and each plugin should define their own annotations key, eg: @example, @qotd.
if 2 installed plugins using the same annotation key, will throw warning/error in plugin system constructor

• LazyTypeAliasDeclaration
  • lazily initialize the TypeAliasDeclaration
  • hoist all declaration of LazyTypeAliasDeclaration to the start of the file
• manta-helpers
  • List all the built-in helper type
  • Only import built-in helper type when used.

use custom loader + webpack to transform the code
webpack comes with watch mode, that will watch all dependencies too

this will come in handy when transforming flow defintions.

I am proposing the following type of plugins:

1. Mock Plugin

• package name for mock plugin should start with 'manta-style-plugin-mock-*'
• the plugin code will look like the following:

module.exports = {
  name: 'plugin-name',
  priority: 1, // do we need priority?
  mock: {
      StringLiteral(type, annotations, next) { }
  }
}

• During deriveLiteral, each *Literal will iterate through mock plugins based on the priority
• Should plugins return value be chained?
  ie: each mock plugin is called with the value returned by the previous plugin.
  • this might need some priority of calling the plugin.
• if no plugin or none of the plugin returns value, will default to the default mock value

2. Syntax Plugin

• This is going to be plugins that affect how you transform your code.
• package name to be like 'manta-style-plugin-sytax-*'
• examples can think of right now is: 'manta-style-plugin-sytax-flowtype', 'manta-style-plugin-sytax-typescript', 'manta-style-plugin-sytax-graphql', etc.

Plugin Discovery

• plugin names should follow a certain format as mentioned above
• will look through package.json, and find out plugins installed.