gulp-define-module
The gulp define module plugin produces modules from an input source. It allows other plugins to offload module definition to a separate plugin. For consistency, the input source should contain a single JavaScript expression and should not contain a trailing semicolon.
An example input file to create a callable module:
{} {} version: "1.0"
Transformed to CommonJS/Node (defineModule('commonjs')
or defineModule('node')
):
moduleexports = {} {} version: "1.0";
Transformed to AMD (defineModule('amd')
):
;
Transformed to ES6 (defineModule('es6')
):
{} {} version: "1.0";
Transformed to Hybrid (defineModule('hybrid')
):
{ if typeof exports === 'object' moduleexports = ; // CommonJS else if typeof define === 'function' && defineamd ; // AMD else ; // Browser} { return {} {} version: "1.0" ;};
Transformed to Plain (defineModule('plain')
):
{} {} version: "1.0";
To use the module simply include it in your gulp pipeline:
var emberEmblem = ;var defineModule = ; gulp;
API
defineModule(type, [options])
type
Type: String
Default: bare
The desired output type. One of the following:
commonjs
- Produce CommonJS modulesnode
- Produce Node modules (alias forcommonjs
)amd
- Produce AMD moduleses6
- Produce ES6 moduleshybrid
- Produce hybrid modules that can be used in most environmentsplain
- Return an unmolested function definition
options.require
Type: Object
Default: {}
An object containing dependencies that should be imported for this module. This option is only
supported for commonjs
, node
, amd
, es6
and hybrid
modules. For other systems, you will have
to manage the dependency loading in another way.
The property name in the object should be the value of the variable that the dependency will be accessed from, and the property value should be the name of the dependency.
For instance, { Library: 'library' }
will produce:
CommonJS/Node
var Library = Library || ; moduleexports = {};
AMD
;
ES6
;
Hybrid
{ if typeof exports === 'object' moduleexports = ; // CommonJS else if typeof define === 'function' && defineamd ; // AMD else ; // Browser} { return {};};
options.wrapper
Type: String
Default: false
Wrapper in which to wrap input modules. This wrapper will be processed through lodash.template with the following context:
gulp-handlebars, for instance, sets a wrapper of "Handlebars.template(<%= contents %>)"
.
options.context
Type: Object
or Function
Default: undefined
Extend the context that's used to process the wrapper. If you pass an object, it will simply be merged with the default context.
A function argument should have the signature function(context) { return {}; }
. The
default context will be passed to your function and you can return new values to add
to the context. For instance, you can create complex definitions on a per-file basis.
This will result in a template file, app/view.js
with an empty function, function() {}
, being compiled to
MyApp.templates["app.view"] = function() {};
.
options.name
Type: Function
Default: undefined
This option only works with defineModule('amd',...)
and therefore has no effect on other module types.
This function receives the file path as argument and should return a
name for the amd
module. For example:
If no naming function is present, an
anonymous amd
module will be created.
This can be used with Hogan, for example:
gulp
This will result in the following template file:
For gulp plugin developers
Plugin developers can pass options on to this plugin so that users don't have to define values that may be the most common setup for modules.
To do so set the defineModuleOptions
on the file
object. This object will be merged with options that users pass in to their defineModule
pipe
(user's options take precedence). It's recommended that if you define wrapper in these options,
that you make it a single value from the context for usage simplicity.
For an example, see gulp-ember-emblem.
License
This project is distributed under the MIT license.