docs/compilation.json
{
"name": "compile",
"node": {
"path": "src/compile/index.js",
"pluggableLine": 111,
"edges": [
"getModuleSeeds",
"compileModules",
"generateModuleMaps",
"generateBundles",
"buildOutput"
],
"fnParams": [],
"name": "compile",
"fnStart": 111,
"fnEnd": 119,
"doc": "*\n * Loads, transforms, and bundles an application using the provided options.\n * Modules are collected and transformed, bundles are formed from those modules,\n * and those bundles are finally converted into a format that can be written\n * to disk or served over HTTP.\n *\n * @return {Promise} Resolves to an object with three properties: `bundles`,\n * `opts`, and `cache`.\n ",
"parsedDoc": {
"tags": [
{
"tag": "return",
"type": "Promise",
"name": "Resolves",
"optional": false,
"description": "to an object with three properties: `bundles`,\n`opts`, and `cache`.",
"line": 6,
"source": "@return {Promise} Resolves to an object with three properties: `bundles`,\n`opts`, and `cache`."
}
],
"line": 0,
"description": "Loads, transforms, and bundles an application using the provided options.\nModules are collected and transformed, bundles are formed from those modules,\nand those bundles are finally converted into a format that can be written\nto disk or served over HTTP.",
"source": "Loads, transforms, and bundles an application using the provided options.\nModules are collected and transformed, bundles are formed from those modules,\nand those bundles are finally converted into a format that can be written\nto disk or served over HTTP.\n\n@return {Promise} Resolves to an object with three properties: `bundles`,\n`opts`, and `cache`."
}
},
"children": [
{
"name": "getModuleSeeds",
"node": {
"path": "src/compile/modules/get-seeds.js",
"pluggableLine": 16,
"edges": [
"resolveModule"
],
"fnParams": [],
"name": "getModuleSeeds",
"fnStart": 16,
"fnEnd": 23,
"doc": "*\n * Inspect the compilation options for bundle definitions (provided as\n * key/value pairs to options.entry and options.split), resolve references,\n * and return an object of the early-stage modules indexed by their path\n * relative to the compilation context.\n *\n * @return {Object} Early-stage modules indexed by relative path.\n ",
"parsedDoc": {
"tags": [
{
"tag": "return",
"type": "Object",
"name": "Early-stage",
"optional": false,
"description": "modules indexed by relative path.",
"line": 6,
"source": "@return {Object} Early-stage modules indexed by relative path."
}
],
"line": 0,
"description": "Inspect the compilation options for bundle definitions (provided as\nkey/value pairs to options.entry and options.split), resolve references,\nand return an object of the early-stage modules indexed by their path\nrelative to the compilation context.",
"source": "Inspect the compilation options for bundle definitions (provided as\nkey/value pairs to options.entry and options.split), resolve references,\nand return an object of the early-stage modules indexed by their path\nrelative to the compilation context.\n\n@return {Object} Early-stage modules indexed by relative path."
}
},
"children": [
{
"name": "resolveModule",
"node": {
"path": "src/compile/modules/resolve.js",
"pluggableLine": 53,
"edges": [
"preresolve"
],
"fnParams": [
"requireStr",
"contextPath",
"ns",
"nsRoot",
"extensions"
],
"name": "resolveModule",
"fnStart": 32,
"fnEnd": 51,
"doc": "*\n * Given a require string and some context, resolve that require string\n * to a file on disk, returning a module seed.\n *\n * @param {String} requireStr Require string or comparable value.\n * @param {String} contextPath Absolute path from which to resolve any relative\n * paths.\n * @param {String} ns Namespace to set on module seed if the resolved\n * module is of the same namespace as its context.\n * @param {String} nsRoot Absolute path of default namespace.\n * @param {Array} extensions Array of file extension strings, including the leading\n * dot.\n *\n * @return {Object} Module seed.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "String",
"name": "requireStr",
"optional": false,
"description": "Require string or comparable value.",
"line": 4,
"source": "@param {String} requireStr Require string or comparable value."
},
{
"tag": "param",
"type": "String",
"name": "contextPath",
"optional": false,
"description": "Absolute path from which to resolve any relative\npaths.",
"line": 5,
"source": "@param {String} contextPath Absolute path from which to resolve any relative\npaths."
},
{
"tag": "param",
"type": "String",
"name": "ns",
"optional": false,
"description": "Namespace to set on module seed if the resolved\nmodule is of the same namespace as its context.",
"line": 7,
"source": "@param {String} ns Namespace to set on module seed if the resolved\nmodule is of the same namespace as its context."
},
{
"tag": "param",
"type": "String",
"name": "nsRoot",
"optional": false,
"description": "Absolute path of default namespace.",
"line": 9,
"source": "@param {String} nsRoot Absolute path of default namespace."
},
{
"tag": "param",
"type": "Array",
"name": "extensions",
"optional": false,
"description": "Array of file extension strings, including the leading\ndot.",
"line": 10,
"source": "@param {Array} extensions Array of file extension strings, including the leading\ndot."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "seed.",
"line": 13,
"source": "@return {Object} Module seed."
}
],
"line": 0,
"description": "Given a require string and some context, resolve that require string\nto a file on disk, returning a module seed.",
"source": "Given a require string and some context, resolve that require string\nto a file on disk, returning a module seed.\n\n@param {String} requireStr Require string or comparable value.\n@param {String} contextPath Absolute path from which to resolve any relative\npaths.\n@param {String} ns Namespace to set on module seed if the resolved\nmodule is of the same namespace as its context.\n@param {String} nsRoot Absolute path of default namespace.\n@param {Array} extensions Array of file extension strings, including the leading\ndot.\n\n@return {Object} Module seed."
}
},
"children": [
{
"name": "preresolve",
"node": {
"path": "src/compile/modules/resolve.js",
"pluggableLine": 13,
"edges": [],
"fnParams": [
"requireStr"
],
"name": "preresolve",
"fnStart": 13,
"fnEnd": 15,
"doc": "*\n * Transform the require string before it is resolved to a file on disk.\n * No transformations occur by default - the output is the same as the input.\n *\n * @param {String} requireStr Require string or comparable value.\n *\n * @return {String} Transformed require string.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "String",
"name": "requireStr",
"optional": false,
"description": "Require string or comparable value.",
"line": 4,
"source": "@param {String} requireStr Require string or comparable value."
},
{
"tag": "return",
"type": "String",
"name": "Transformed",
"optional": false,
"description": "require string.",
"line": 6,
"source": "@return {String} Transformed require string."
}
],
"line": 0,
"description": "Transform the require string before it is resolved to a file on disk.\nNo transformations occur by default - the output is the same as the input.",
"source": "Transform the require string before it is resolved to a file on disk.\nNo transformations occur by default - the output is the same as the input.\n\n@param {String} requireStr Require string or comparable value.\n\n@return {String} Transformed require string."
}
},
"children": [],
"markdown": "## preresolve\n \nTransform the require string before it is resolved to a file on disk.\nNo transformations occur by default - the output is the same as the input.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **requireStr** | String | Require string or comparable value. |\n| Return value | | String | Transformed require string. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/resolve.js#L13-L15).\n\n ",
"size": 1
}
],
"markdown": "## resolveModule\n \nGiven a require string and some context, resolve that require string\nto a file on disk, returning a module seed.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **requireStr** | String | Require string or comparable value. |\n| Parameter | **contextPath** | String | Absolute path from which to resolve any relative paths. |\n| Parameter | **ns** | String | Namespace to set on module seed if the resolved module is of the same namespace as its context. |\n| Parameter | **nsRoot** | String | Absolute path of default namespace. |\n| Parameter | **extensions** | Array | Array of file extension strings, including the leading dot. |\n| Return value | | Object | Module seed. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/resolve.js#L53).\n The function that it wraps can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/resolve.js#L32-L51).\n\n "
}
],
"markdown": "## getModuleSeeds\n \nInspect the compilation options for bundle definitions (provided as\nkey/value pairs to options.entry and options.split), resolve references,\nand return an object of the early-stage modules indexed by their path\nrelative to the compilation context.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Return value | | Object | Early-stage modules indexed by relative path. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/get-seeds.js#L16-L23).\n\n "
},
{
"name": "compileModules",
"node": {
"path": "src/compile/modules/compile.js",
"pluggableLine": 122,
"edges": [
"compileModule"
],
"fnParams": [
"moduleSeeds"
],
"name": "compileModules",
"fnStart": 122,
"fnEnd": 130,
"doc": "*\n * Given one or more module seeds, traverse their dependency graph, collecting any and\n * all dependency modules, and then parse, transform, and hash those modules. Return\n * a promise that resolves to the full set of modules, once they have been correctly\n * gathered and compiled.\n *\n * @param {Array} moduleSeeds Module seeds, i.e. modules that have not yet been\n * populated with properties such as ast, `dependencies`,\n * etc. Module objects _should_ have path, rawSource,\n * and namespace values.\n *\n * @return {Promise} Resolves to array of all compiled modules.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "moduleSeeds",
"optional": false,
"description": "Module seeds, i.e. modules that have not yet been\npopulated with properties such as ast, `dependencies`,\netc. Module objects _should_ have path, rawSource,\nand namespace values.",
"line": 6,
"source": "@param {Array} moduleSeeds Module seeds, i.e. modules that have not yet been\npopulated with properties such as ast, `dependencies`,\netc. Module objects _should_ have path, rawSource,\nand namespace values."
},
{
"tag": "return",
"type": "Promise",
"name": "Resolves",
"optional": false,
"description": "to array of all compiled modules.",
"line": 11,
"source": "@return {Promise} Resolves to array of all compiled modules."
}
],
"line": 0,
"description": "Given one or more module seeds, traverse their dependency graph, collecting any and\nall dependency modules, and then parse, transform, and hash those modules. Return\na promise that resolves to the full set of modules, once they have been correctly\ngathered and compiled.",
"source": "Given one or more module seeds, traverse their dependency graph, collecting any and\nall dependency modules, and then parse, transform, and hash those modules. Return\na promise that resolves to the full set of modules, once they have been correctly\ngathered and compiled.\n\n@param {Array} moduleSeeds Module seeds, i.e. modules that have not yet been\npopulated with properties such as ast, `dependencies`,\netc. Module objects _should_ have path, rawSource,\nand namespace values.\n\n@return {Promise} Resolves to array of all compiled modules."
}
},
"children": [
{
"name": "compileModule",
"node": {
"path": "src/compile/modules/compile.js",
"pluggableLine": 85,
"edges": [
"loadModule",
"parseModule",
"transformModule",
"generateDependencies",
"hashModule",
"generateModuleId",
"updateReferences"
],
"fnParams": [
"module"
],
"name": "compileModule",
"fnStart": 85,
"fnEnd": 107,
"doc": "*\n * Given an unprocess module that has been loaded from disk, return a promise\n * that resolves to the same module in a processed/compiled state, and whose\n * dependencies have also been processed/compiled.\n *\n * @param {Object} module Seed module.\n *\n * @return {Promise} Resolves to compiled module.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Seed module.",
"line": 5,
"source": "@param {Object} module Seed module."
},
{
"tag": "return",
"type": "Promise",
"name": "Resolves",
"optional": false,
"description": "to compiled module.",
"line": 7,
"source": "@return {Promise} Resolves to compiled module."
}
],
"line": 0,
"description": "Given an unprocess module that has been loaded from disk, return a promise\nthat resolves to the same module in a processed/compiled state, and whose\ndependencies have also been processed/compiled.",
"source": "Given an unprocess module that has been loaded from disk, return a promise\nthat resolves to the same module in a processed/compiled state, and whose\ndependencies have also been processed/compiled.\n\n@param {Object} module Seed module.\n\n@return {Promise} Resolves to compiled module."
}
},
"children": [
{
"name": "loadModule",
"node": {
"path": "src/compile/modules/load.js",
"pluggableLine": 55,
"edges": [
"readSource",
"setModuleType"
],
"fnParams": [
"module"
],
"name": "loadModule",
"fnStart": 55,
"fnEnd": 60,
"doc": "*\n * Given a module seed, read the module from disk and determine its type.\n *\n * @param {Object} module Module seed.\n *\n * @return {Object} Module seed plus `rawSource` and `type` properties.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module seed.",
"line": 3,
"source": "@param {Object} module Module seed."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "seed plus `rawSource` and `type` properties.",
"line": 5,
"source": "@return {Object} Module seed plus `rawSource` and `type` properties."
}
],
"line": 0,
"description": "Given a module seed, read the module from disk and determine its type.",
"source": "Given a module seed, read the module from disk and determine its type.\n\n@param {Object} module Module seed.\n\n@return {Object} Module seed plus `rawSource` and `type` properties."
}
},
"children": [
{
"name": "readSource",
"node": {
"path": "src/compile/modules/load.js",
"pluggableLine": 30,
"edges": [],
"fnParams": [
"module"
],
"name": "readSource",
"fnStart": 30,
"fnEnd": 33,
"doc": "*\n * This function is invoked whenever the compiler attempts to read a source-file\n * from the disk. It takes an raw-module object as its only input. The properties\n * available on that object are as follows:\n *\n * - `path` - the absolute path of the file\n * - `ns` - the namespace of the module (either the default ns, or borrowed from its\n * containing package)\n * - `nsRoot` - the absolute path to the root of the namespace\n * - `nsPath` - the file's path relative to the root of the namespace\n *\n * The function should output an object with the same properties, plus one additional\n * property: `rawSource`. This property should be the string-value of the module\n * source.\n *\n * @param {Object} module Module object.\n *\n * @return {Object} Module object + `rawSource`.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module object.",
"line": 15,
"source": "@param {Object} module Module object."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "object + `rawSource`.",
"line": 17,
"source": "@return {Object} Module object + `rawSource`."
}
],
"line": 0,
"description": "This function is invoked whenever the compiler attempts to read a source-file\nfrom the disk. It takes an raw-module object as its only input. The properties\navailable on that object are as follows:\n\n- `path` - the absolute path of the file\n- `ns` - the namespace of the module (either the default ns, or borrowed from its\ncontaining package)\n- `nsRoot` - the absolute path to the root of the namespace\n- `nsPath` - the file's path relative to the root of the namespace\n\nThe function should output an object with the same properties, plus one additional\nproperty: `rawSource`. This property should be the string-value of the module\nsource.",
"source": "This function is invoked whenever the compiler attempts to read a source-file\nfrom the disk. It takes an raw-module object as its only input. The properties\navailable on that object are as follows:\n\n- `path` - the absolute path of the file\n- `ns` - the namespace of the module (either the default ns, or borrowed from its\ncontaining package)\n- `nsRoot` - the absolute path to the root of the namespace\n- `nsPath` - the file's path relative to the root of the namespace\n\nThe function should output an object with the same properties, plus one additional\nproperty: `rawSource`. This property should be the string-value of the module\nsource.\n\n@param {Object} module Module object.\n\n@return {Object} Module object + `rawSource`."
}
},
"children": [],
"markdown": "## readSource\n \nThis function is invoked whenever the compiler attempts to read a source-file\nfrom the disk. It takes an raw-module object as its only input. The properties\navailable on that object are as follows:\n\n- `path` - the absolute path of the file\n- `ns` - the namespace of the module (either the default ns, or borrowed from its\ncontaining package)\n- `nsRoot` - the absolute path to the root of the namespace\n- `nsPath` - the file's path relative to the root of the namespace\n\nThe function should output an object with the same properties, plus one additional\nproperty: `rawSource`. This property should be the string-value of the module\nsource.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module object. |\n| Return value | | Object | Module object + `rawSource`. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/load.js#L30-L33).\n\n ",
"size": 1
},
{
"name": "setModuleType",
"node": {
"path": "src/compile/modules/load.js",
"pluggableLine": 44,
"edges": [],
"fnParams": [
"module"
],
"name": "setModuleType",
"fnStart": 44,
"fnEnd": 46,
"doc": "*\n * Given the early-stage module (module seed + rawSource property), determine and set\n * its type. This value defaults to \"javascript\" and is used to determine whether\n * default behaviors for parsing and processing modules should be used on the module.\n *\n * @param {Object} module Early-stage module.\n *\n * @return {Object} Module with new `type` property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Early-stage module.",
"line": 5,
"source": "@param {Object} module Early-stage module."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "with new `type` property.",
"line": 7,
"source": "@return {Object} Module with new `type` property."
}
],
"line": 0,
"description": "Given the early-stage module (module seed + rawSource property), determine and set\nits type. This value defaults to \"javascript\" and is used to determine whether\ndefault behaviors for parsing and processing modules should be used on the module.",
"source": "Given the early-stage module (module seed + rawSource property), determine and set\nits type. This value defaults to \"javascript\" and is used to determine whether\ndefault behaviors for parsing and processing modules should be used on the module.\n\n@param {Object} module Early-stage module.\n\n@return {Object} Module with new `type` property."
}
},
"children": [],
"markdown": "## setModuleType\n \nGiven the early-stage module (module seed + rawSource property), determine and set\nits type. This value defaults to \"javascript\" and is used to determine whether\ndefault behaviors for parsing and processing modules should be used on the module.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Early-stage module. |\n| Return value | | Object | Module with new `type` property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/load.js#L44-L46).\n\n ",
"size": 1
}
],
"markdown": "## loadModule\n \nGiven a module seed, read the module from disk and determine its type.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module seed. |\n| Return value | | Object | Module seed plus `rawSource` and `type` properties. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/load.js#L55-L60).\n\n "
},
{
"name": "parseModule",
"node": {
"path": "src/compile/modules/parse.js",
"pluggableLine": 19,
"edges": [],
"fnParams": [
"module"
],
"name": "parseModule",
"fnStart": 19,
"fnEnd": 52,
"doc": "*\n * Parse the source of the provided early-stage module. Resolves to the same\n * module object, with additional `ast` and `sourcePath` properties (or equivalent\n * for non-JavaScript modules).\n *\n * @param {Object} module Unparsed module with rawSource property.\n *\n * @return {Object} Parsed module with new `ast` and `sourcePath` properties.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Unparsed module with rawSource property.",
"line": 5,
"source": "@param {Object} module Unparsed module with rawSource property."
},
{
"tag": "return",
"type": "Object",
"name": "Parsed",
"optional": false,
"description": "module with new `ast` and `sourcePath` properties.",
"line": 7,
"source": "@return {Object} Parsed module with new `ast` and `sourcePath` properties."
}
],
"line": 0,
"description": "Parse the source of the provided early-stage module. Resolves to the same\nmodule object, with additional `ast` and `sourcePath` properties (or equivalent\nfor non-JavaScript modules).",
"source": "Parse the source of the provided early-stage module. Resolves to the same\nmodule object, with additional `ast` and `sourcePath` properties (or equivalent\nfor non-JavaScript modules).\n\n@param {Object} module Unparsed module with rawSource property.\n\n@return {Object} Parsed module with new `ast` and `sourcePath` properties."
}
},
"children": [],
"markdown": "## parseModule\n \nParse the source of the provided early-stage module. Resolves to the same\nmodule object, with additional `ast` and `sourcePath` properties (or equivalent\nfor non-JavaScript modules).\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Unparsed module with rawSource property. |\n| Return value | | Object | Parsed module with new `ast` and `sourcePath` properties. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/parse.js#L19-L52).\n\n ",
"size": 1
},
{
"name": "transformModule",
"node": {
"path": "src/compile/modules/transform.js",
"pluggableLine": 19,
"edges": [],
"fnParams": [
"module"
],
"name": "transformModule",
"fnStart": 19,
"fnEnd": 58,
"doc": "*\n * Transforms the module's AST, returning a module object with transformed\n * `ast` property as well as a new `synchronousRequires` property. If the\n * module is not of type \"javascript\", transformations to type-specific\n * intermediate representation should occur at this step.\n *\n * @param {Object} module Module object, with `ast` property.\n *\n * @return {Object} Module object with transformed `ast` property\n * and new `synchronousRequires` property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module object, with `ast` property.",
"line": 6,
"source": "@param {Object} module Module object, with `ast` property."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "object with transformed `ast` property\nand new `synchronousRequires` property.",
"line": 8,
"source": "@return {Object} Module object with transformed `ast` property\nand new `synchronousRequires` property."
}
],
"line": 0,
"description": "Transforms the module's AST, returning a module object with transformed\n`ast` property as well as a new `synchronousRequires` property. If the\nmodule is not of type \"javascript\", transformations to type-specific\nintermediate representation should occur at this step.",
"source": "Transforms the module's AST, returning a module object with transformed\n`ast` property as well as a new `synchronousRequires` property. If the\nmodule is not of type \"javascript\", transformations to type-specific\nintermediate representation should occur at this step.\n\n@param {Object} module Module object, with `ast` property.\n\n@return {Object} Module object with transformed `ast` property\nand new `synchronousRequires` property."
}
},
"children": [],
"markdown": "## transformModule\n \nTransforms the module's AST, returning a module object with transformed\n`ast` property as well as a new `synchronousRequires` property. If the\nmodule is not of type \"javascript\", transformations to type-specific\nintermediate representation should occur at this step.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module object, with `ast` property. |\n| Return value | | Object | Module object with transformed `ast` property and new `synchronousRequires` property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/transform.js#L19-L58).\n\n ",
"size": 1
},
{
"name": "generateDependencies",
"node": {
"path": "src/compile/modules/compile.js",
"pluggableLine": 39,
"edges": [
"resolveModule",
"compileModuleR"
],
"fnParams": [
"module"
],
"name": "generateDependencies",
"fnStart": 39,
"fnEnd": 74,
"doc": "*\n * Given a module whose dependency references (like require strings) have been\n * determined, recursively compile all dependencies and return the module with\n * new dependency properties.\n *\n * @param {Object} module Module for whom dependencies should be compiled.\n *\n * @return {Object} Module with new dependency properties.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module for whom dependencies should be compiled.",
"line": 5,
"source": "@param {Object} module Module for whom dependencies should be compiled."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "with new dependency properties.",
"line": 7,
"source": "@return {Object} Module with new dependency properties."
}
],
"line": 0,
"description": "Given a module whose dependency references (like require strings) have been\ndetermined, recursively compile all dependencies and return the module with\nnew dependency properties.",
"source": "Given a module whose dependency references (like require strings) have been\ndetermined, recursively compile all dependencies and return the module with\nnew dependency properties.\n\n@param {Object} module Module for whom dependencies should be compiled.\n\n@return {Object} Module with new dependency properties."
}
},
"children": [
{
"name": "resolveModule",
"node": {
"path": "src/compile/modules/resolve.js",
"pluggableLine": 53,
"edges": [
"preresolve"
],
"fnParams": [
"requireStr",
"contextPath",
"ns",
"nsRoot",
"extensions"
],
"name": "resolveModule",
"fnStart": 32,
"fnEnd": 51,
"doc": "*\n * Given a require string and some context, resolve that require string\n * to a file on disk, returning a module seed.\n *\n * @param {String} requireStr Require string or comparable value.\n * @param {String} contextPath Absolute path from which to resolve any relative\n * paths.\n * @param {String} ns Namespace to set on module seed if the resolved\n * module is of the same namespace as its context.\n * @param {String} nsRoot Absolute path of default namespace.\n * @param {Array} extensions Array of file extension strings, including the leading\n * dot.\n *\n * @return {Object} Module seed.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "String",
"name": "requireStr",
"optional": false,
"description": "Require string or comparable value.",
"line": 4,
"source": "@param {String} requireStr Require string or comparable value."
},
{
"tag": "param",
"type": "String",
"name": "contextPath",
"optional": false,
"description": "Absolute path from which to resolve any relative\npaths.",
"line": 5,
"source": "@param {String} contextPath Absolute path from which to resolve any relative\npaths."
},
{
"tag": "param",
"type": "String",
"name": "ns",
"optional": false,
"description": "Namespace to set on module seed if the resolved\nmodule is of the same namespace as its context.",
"line": 7,
"source": "@param {String} ns Namespace to set on module seed if the resolved\nmodule is of the same namespace as its context."
},
{
"tag": "param",
"type": "String",
"name": "nsRoot",
"optional": false,
"description": "Absolute path of default namespace.",
"line": 9,
"source": "@param {String} nsRoot Absolute path of default namespace."
},
{
"tag": "param",
"type": "Array",
"name": "extensions",
"optional": false,
"description": "Array of file extension strings, including the leading\ndot.",
"line": 10,
"source": "@param {Array} extensions Array of file extension strings, including the leading\ndot."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "seed.",
"line": 13,
"source": "@return {Object} Module seed."
}
],
"line": 0,
"description": "Given a require string and some context, resolve that require string\nto a file on disk, returning a module seed.",
"source": "Given a require string and some context, resolve that require string\nto a file on disk, returning a module seed.\n\n@param {String} requireStr Require string or comparable value.\n@param {String} contextPath Absolute path from which to resolve any relative\npaths.\n@param {String} ns Namespace to set on module seed if the resolved\nmodule is of the same namespace as its context.\n@param {String} nsRoot Absolute path of default namespace.\n@param {Array} extensions Array of file extension strings, including the leading\ndot.\n\n@return {Object} Module seed."
}
},
"children": [
{
"name": "preresolve",
"node": {
"path": "src/compile/modules/resolve.js",
"pluggableLine": 13,
"edges": [],
"fnParams": [
"requireStr"
],
"name": "preresolve",
"fnStart": 13,
"fnEnd": 15,
"doc": "*\n * Transform the require string before it is resolved to a file on disk.\n * No transformations occur by default - the output is the same as the input.\n *\n * @param {String} requireStr Require string or comparable value.\n *\n * @return {String} Transformed require string.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "String",
"name": "requireStr",
"optional": false,
"description": "Require string or comparable value.",
"line": 4,
"source": "@param {String} requireStr Require string or comparable value."
},
{
"tag": "return",
"type": "String",
"name": "Transformed",
"optional": false,
"description": "require string.",
"line": 6,
"source": "@return {String} Transformed require string."
}
],
"line": 0,
"description": "Transform the require string before it is resolved to a file on disk.\nNo transformations occur by default - the output is the same as the input.",
"source": "Transform the require string before it is resolved to a file on disk.\nNo transformations occur by default - the output is the same as the input.\n\n@param {String} requireStr Require string or comparable value.\n\n@return {String} Transformed require string."
}
},
"children": [],
"markdown": "## preresolve\n \nTransform the require string before it is resolved to a file on disk.\nNo transformations occur by default - the output is the same as the input.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **requireStr** | String | Require string or comparable value. |\n| Return value | | String | Transformed require string. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/resolve.js#L13-L15).\n\n ",
"size": 1
}
],
"markdown": "## resolveModule\n \nGiven a require string and some context, resolve that require string\nto a file on disk, returning a module seed.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **requireStr** | String | Require string or comparable value. |\n| Parameter | **contextPath** | String | Absolute path from which to resolve any relative paths. |\n| Parameter | **ns** | String | Namespace to set on module seed if the resolved module is of the same namespace as its context. |\n| Parameter | **nsRoot** | String | Absolute path of default namespace. |\n| Parameter | **extensions** | Array | Array of file extension strings, including the leading dot. |\n| Return value | | Object | Module seed. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/resolve.js#L53).\n The function that it wraps can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/resolve.js#L32-L51).\n\n "
},
{
"name": "compileModuleR",
"node": {
"path": "src/compile/modules/compile.js",
"pluggableLine": 26,
"edges": [],
"fnParams": [],
"name": "compileModuleR",
"fnStart": 26,
"fnEnd": 28,
"doc": "*\n * Because the `compileModule` and `generateDependencies` functions interact\n * recursively, defining a stand-in pluggable for `compileModule` allows for\n * plugins to utilize `compileModule` from within an overridden `generateDependencies`.\n *\n * For true behavior, please see documentation for `compileModule`.\n *\n * @return {Promise} Resolves to compiled module.\n ",
"parsedDoc": {
"tags": [
{
"tag": "return",
"type": "Promise",
"name": "Resolves",
"optional": false,
"description": "to compiled module.",
"line": 7,
"source": "@return {Promise} Resolves to compiled module."
}
],
"line": 0,
"description": "Because the `compileModule` and `generateDependencies` functions interact\nrecursively, defining a stand-in pluggable for `compileModule` allows for\nplugins to utilize `compileModule` from within an overridden `generateDependencies`.\n\nFor true behavior, please see documentation for `compileModule`.",
"source": "Because the `compileModule` and `generateDependencies` functions interact\nrecursively, defining a stand-in pluggable for `compileModule` allows for\nplugins to utilize `compileModule` from within an overridden `generateDependencies`.\n\nFor true behavior, please see documentation for `compileModule`.\n\n@return {Promise} Resolves to compiled module."
}
},
"children": [],
"markdown": "## compileModuleR\n \nBecause the `compileModule` and `generateDependencies` functions interact\nrecursively, defining a stand-in pluggable for `compileModule` allows for\nplugins to utilize `compileModule` from within an overridden `generateDependencies`.\n\nFor true behavior, please see documentation for `compileModule`.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Return value | | Promise | Resolves to compiled module. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/compile.js#L26-L28).\n\n ",
"size": 1
}
],
"markdown": "## generateDependencies\n \nGiven a module whose dependency references (like require strings) have been\ndetermined, recursively compile all dependencies and return the module with\nnew dependency properties.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module for whom dependencies should be compiled. |\n| Return value | | Object | Module with new dependency properties. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/compile.js#L39-L74).\n\n "
},
{
"name": "hashModule",
"node": {
"path": "src/compile/modules/hash.js",
"pluggableLine": 36,
"edges": [
"updateModuleHash"
],
"fnParams": [
"module"
],
"name": "hashModule",
"fnStart": 36,
"fnEnd": 48,
"doc": "*\n * Given a mostly-compiled module, generate a hash for that module and resolve\n * to that module with a new `hash` property.\n *\n * @param {Object} module Module that needs to be hashed hash.\n *\n * @return {Object} Module that now has a hash property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module that needs to be hashed hash.",
"line": 4,
"source": "@param {Object} module Module that needs to be hashed hash."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "that now has a hash property.",
"line": 6,
"source": "@return {Object} Module that now has a hash property."
}
],
"line": 0,
"description": "Given a mostly-compiled module, generate a hash for that module and resolve\nto that module with a new `hash` property.",
"source": "Given a mostly-compiled module, generate a hash for that module and resolve\nto that module with a new `hash` property.\n\n@param {Object} module Module that needs to be hashed hash.\n\n@return {Object} Module that now has a hash property."
}
},
"children": [
{
"name": "updateModuleHash",
"node": {
"path": "src/compile/modules/hash.js",
"pluggableLine": 18,
"edges": [],
"fnParams": [
"update",
"module"
],
"name": "updateModuleHash",
"fnStart": 18,
"fnEnd": 26,
"doc": "*\n * Use data from the provided module to generate a hash, utilizing the provided\n * update function. Only string values should be passed to the update function.\n * The resulting hash should be deterministic for the same inputs in the same order.\n *\n * @param {Object} module Module that needs a hash property.\n * @param {Function} update Function to be invoked with data that uniquely\n * identifies the module (or, more precisely, the\n * run-time behavior of the module).\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module that needs a hash property.",
"line": 5,
"source": "@param {Object} module Module that needs a hash property."
},
{
"tag": "param",
"type": "Function",
"name": "update",
"optional": false,
"description": "Function to be invoked with data that uniquely\nidentifies the module (or, more precisely, the\nrun-time behavior of the module).",
"line": 6,
"source": "@param {Function} update Function to be invoked with data that uniquely\nidentifies the module (or, more precisely, the\nrun-time behavior of the module)."
}
],
"line": 0,
"description": "Use data from the provided module to generate a hash, utilizing the provided\nupdate function. Only string values should be passed to the update function.\nThe resulting hash should be deterministic for the same inputs in the same order.",
"source": "Use data from the provided module to generate a hash, utilizing the provided\nupdate function. Only string values should be passed to the update function.\nThe resulting hash should be deterministic for the same inputs in the same order.\n\n@param {Object} module Module that needs a hash property.\n@param {Function} update Function to be invoked with data that uniquely\nidentifies the module (or, more precisely, the\nrun-time behavior of the module)."
}
},
"children": [],
"markdown": "## updateModuleHash\n \nUse data from the provided module to generate a hash, utilizing the provided\nupdate function. Only string values should be passed to the update function.\nThe resulting hash should be deterministic for the same inputs in the same order.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module that needs a hash property. |\n| Parameter | **update** | Function | Function to be invoked with data that uniquely identifies the module (or, more precisely, the run-time behavior of the module). |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/hash.js#L18-L26).\n\n ",
"size": 1
}
],
"markdown": "## hashModule\n \nGiven a mostly-compiled module, generate a hash for that module and resolve\nto that module with a new `hash` property.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module that needs to be hashed hash. |\n| Return value | | Object | Module that now has a hash property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/hash.js#L36-L48).\n\n "
},
{
"name": "generateModuleId",
"node": {
"path": "src/compile/modules/generate-id.js",
"pluggableLine": 13,
"edges": [],
"fnParams": [
"module"
],
"name": "generateModuleId",
"fnStart": 13,
"fnEnd": 21,
"doc": "*\n * Given a mostly-compiled module, generate an ID for that module\n * and resolve the same module with an `id` property.\n *\n * @param {Object} module Module that needs an ID.\n *\n * @return {Object} Module that now has an `id` property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module that needs an ID.",
"line": 4,
"source": "@param {Object} module Module that needs an ID."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "that now has an `id` property.",
"line": 6,
"source": "@return {Object} Module that now has an `id` property."
}
],
"line": 0,
"description": "Given a mostly-compiled module, generate an ID for that module\nand resolve the same module with an `id` property.",
"source": "Given a mostly-compiled module, generate an ID for that module\nand resolve the same module with an `id` property.\n\n@param {Object} module Module that needs an ID.\n\n@return {Object} Module that now has an `id` property."
}
},
"children": [],
"markdown": "## generateModuleId\n \nGiven a mostly-compiled module, generate an ID for that module\nand resolve the same module with an `id` property.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module that needs an ID. |\n| Return value | | Object | Module that now has an `id` property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/generate-id.js#L13-L21).\n\n ",
"size": 1
},
{
"name": "updateReferences",
"node": {
"path": "src/compile/modules/update-references.js",
"pluggableLine": 19,
"edges": [],
"fnParams": [
"module"
],
"name": "updateReferences",
"fnStart": 19,
"fnEnd": 33,
"doc": "*\n * Given a module whose dependencies have been identified and compiled,\n * replace all original references with run-time references. In the case\n * of JavaScript, this will mean updating references like `path/to/dep`\n * or `./sibling-dep` with each dependency's module ID.\n *\n * @param {Object} module Module with AST containing original require expressions.\n *\n * @return {Object} Module with AST containing require expressions whose\n * arguments have been replaced with corresponding dependency\n * module hashes.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "module",
"optional": false,
"description": "Module with AST containing original require expressions.",
"line": 6,
"source": "@param {Object} module Module with AST containing original require expressions."
},
{
"tag": "return",
"type": "Object",
"name": "Module",
"optional": false,
"description": "with AST containing require expressions whose\narguments have been replaced with corresponding dependency\nmodule hashes.",
"line": 8,
"source": "@return {Object} Module with AST containing require expressions whose\narguments have been replaced with corresponding dependency\nmodule hashes."
}
],
"line": 0,
"description": "Given a module whose dependencies have been identified and compiled,\nreplace all original references with run-time references. In the case\nof JavaScript, this will mean updating references like `path/to/dep`\nor `./sibling-dep` with each dependency's module ID.",
"source": "Given a module whose dependencies have been identified and compiled,\nreplace all original references with run-time references. In the case\nof JavaScript, this will mean updating references like `path/to/dep`\nor `./sibling-dep` with each dependency's module ID.\n\n@param {Object} module Module with AST containing original require expressions.\n\n@return {Object} Module with AST containing require expressions whose\narguments have been replaced with corresponding dependency\nmodule hashes."
}
},
"children": [],
"markdown": "## updateReferences\n \nGiven a module whose dependencies have been identified and compiled,\nreplace all original references with run-time references. In the case\nof JavaScript, this will mean updating references like `path/to/dep`\nor `./sibling-dep` with each dependency's module ID.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Module with AST containing original require expressions. |\n| Return value | | Object | Module with AST containing require expressions whose arguments have been replaced with corresponding dependency module hashes. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/update-references.js#L19-L33).\n\n ",
"size": 1
}
],
"markdown": "## compileModule\n \nGiven an unprocess module that has been loaded from disk, return a promise\nthat resolves to the same module in a processed/compiled state, and whose\ndependencies have also been processed/compiled.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **module** | Object | Seed module. |\n| Return value | | Promise | Resolves to compiled module. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/compile.js#L85-L107).\n\n "
}
],
"markdown": "## compileModules\n \nGiven one or more module seeds, traverse their dependency graph, collecting any and\nall dependency modules, and then parse, transform, and hash those modules. Return\na promise that resolves to the full set of modules, once they have been correctly\ngathered and compiled.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **moduleSeeds** | Array | Module seeds, i.e. modules that have not yet been populated with properties such as ast, `dependencies`, etc. Module objects _should_ have path, rawSource, and namespace values. |\n| Return value | | Promise | Resolves to array of all compiled modules. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/compile.js#L122-L130).\n\n "
},
{
"name": "generateModuleMaps",
"node": {
"path": "src/compile/modules/generate-maps.js",
"pluggableLine": 16,
"edges": [],
"fnParams": [
"modules"
],
"name": "generateModuleMaps",
"fnStart": 16,
"fnEnd": 25,
"doc": "*\n * Given a set of fully compiled modules, generate and return two\n * hashmaps of those modules, indexed by their hash and their\n * absolute path.\n *\n * @param {Array} modules Fully compiles modules.\n *\n * @return {Object} Fully compiled modules, indexed by hash and\n * absolute path.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "modules",
"optional": false,
"description": "Fully compiles modules.",
"line": 5,
"source": "@param {Array} modules Fully compiles modules."
},
{
"tag": "return",
"type": "Object",
"name": "Fully",
"optional": false,
"description": "compiled modules, indexed by hash and\nabsolute path.",
"line": 7,
"source": "@return {Object} Fully compiled modules, indexed by hash and\nabsolute path."
}
],
"line": 0,
"description": "Given a set of fully compiled modules, generate and return two\nhashmaps of those modules, indexed by their hash and their\nabsolute path.",
"source": "Given a set of fully compiled modules, generate and return two\nhashmaps of those modules, indexed by their hash and their\nabsolute path.\n\n@param {Array} modules Fully compiles modules.\n\n@return {Object} Fully compiled modules, indexed by hash and\nabsolute path."
}
},
"children": [],
"markdown": "## generateModuleMaps\n \nGiven a set of fully compiled modules, generate and return two\nhashmaps of those modules, indexed by their hash and their\nabsolute path.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **modules** | Array | Fully compiles modules. |\n| Return value | | Object | Fully compiled modules, indexed by hash and absolute path. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/modules/generate-maps.js#L16-L25).\n\n ",
"size": 1
},
{
"name": "generateBundles",
"node": {
"path": "src/compile/bundles/generate.js",
"pluggableLine": 64,
"edges": [
"partitionBundles",
"hashBundle",
"interpolateFilename",
"populateBundleModules"
],
"fnParams": [
"moduleSeeds",
"moduleMaps"
],
"name": "generateBundles",
"fnStart": 64,
"fnEnd": 71,
"doc": "*\n * Given a set of module seeds - originally generated from the bundle definitions\n * passed into the Interlock constructor - and the set of fully generated modules,\n * generate the full set of bundles that should be emitted, populate them with\n * module objects, hash them, and interpolate any output filenames.\n *\n * Bundles outputted from this function should be ready to be transformed into\n * strings using AST->source transformation, and then written to disk.\n *\n * @param {Object} moduleSeeds Early-stage module objects, indexed by their\n * path relative to the compilation context.\n * @param {Object} moduleMaps Maps of fully compiled modules, indexed by both\n * absolute path and hash.\n *\n * @return {Array} Fully compiled bundles.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "moduleSeeds",
"optional": false,
"description": "Early-stage module objects, indexed by their\npath relative to the compilation context.",
"line": 9,
"source": "@param {Object} moduleSeeds Early-stage module objects, indexed by their\npath relative to the compilation context."
},
{
"tag": "param",
"type": "Object",
"name": "moduleMaps",
"optional": false,
"description": "Maps of fully compiled modules, indexed by both\nabsolute path and hash.",
"line": 11,
"source": "@param {Object} moduleMaps Maps of fully compiled modules, indexed by both\nabsolute path and hash."
},
{
"tag": "return",
"type": "Array",
"name": "Fully",
"optional": false,
"description": "compiled bundles.",
"line": 14,
"source": "@return {Array} Fully compiled bundles."
}
],
"line": 0,
"description": "Given a set of module seeds - originally generated from the bundle definitions\npassed into the Interlock constructor - and the set of fully generated modules,\ngenerate the full set of bundles that should be emitted, populate them with\nmodule objects, hash them, and interpolate any output filenames.\n\nBundles outputted from this function should be ready to be transformed into\nstrings using AST->source transformation, and then written to disk.",
"source": "Given a set of module seeds - originally generated from the bundle definitions\npassed into the Interlock constructor - and the set of fully generated modules,\ngenerate the full set of bundles that should be emitted, populate them with\nmodule objects, hash them, and interpolate any output filenames.\n\nBundles outputted from this function should be ready to be transformed into\nstrings using AST->source transformation, and then written to disk.\n\n@param {Object} moduleSeeds Early-stage module objects, indexed by their\npath relative to the compilation context.\n@param {Object} moduleMaps Maps of fully compiled modules, indexed by both\nabsolute path and hash.\n\n@return {Array} Fully compiled bundles."
}
},
"children": [
{
"name": "partitionBundles",
"node": {
"path": "src/compile/bundles/generate.js",
"pluggableLine": 42,
"edges": [
"getBundleSeeds",
"dedupeExplicit",
"dedupeImplicit"
],
"fnParams": [
"moduleSeeds",
"moduleMaps"
],
"name": "partitionBundles",
"fnStart": 42,
"fnEnd": 46,
"doc": "*\n * Given a set of module seeds and the set of fully generated modules, generate\n * a finalized array of bundles. These bundles will be early-stage and should\n * not be populated with the actual modules. Instead, each bundle will be defined\n * by the module hashes (unique IDs) of the modules that comprise the bundle.\n *\n * @param {Object} moduleSeeds Early-stage module objects, indexed by their\n * path relative to the compilation context.\n * @param {Object} moduleMaps Maps of fully compiled modules, indexed by both\n * absolute path and hash.\n *\n * @return {Array} Early-stage bundles.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "moduleSeeds",
"optional": false,
"description": "Early-stage module objects, indexed by their\npath relative to the compilation context.",
"line": 6,
"source": "@param {Object} moduleSeeds Early-stage module objects, indexed by their\npath relative to the compilation context."
},
{
"tag": "param",
"type": "Object",
"name": "moduleMaps",
"optional": false,
"description": "Maps of fully compiled modules, indexed by both\nabsolute path and hash.",
"line": 8,
"source": "@param {Object} moduleMaps Maps of fully compiled modules, indexed by both\nabsolute path and hash."
},
{
"tag": "return",
"type": "Array",
"name": "Early-stage",
"optional": false,
"description": "bundles.",
"line": 11,
"source": "@return {Array} Early-stage bundles."
}
],
"line": 0,
"description": "Given a set of module seeds and the set of fully generated modules, generate\na finalized array of bundles. These bundles will be early-stage and should\nnot be populated with the actual modules. Instead, each bundle will be defined\nby the module hashes (unique IDs) of the modules that comprise the bundle.",
"source": "Given a set of module seeds and the set of fully generated modules, generate\na finalized array of bundles. These bundles will be early-stage and should\nnot be populated with the actual modules. Instead, each bundle will be defined\nby the module hashes (unique IDs) of the modules that comprise the bundle.\n\n@param {Object} moduleSeeds Early-stage module objects, indexed by their\npath relative to the compilation context.\n@param {Object} moduleMaps Maps of fully compiled modules, indexed by both\nabsolute path and hash.\n\n@return {Array} Early-stage bundles."
}
},
"children": [
{
"name": "getBundleSeeds",
"node": {
"path": "src/compile/bundles/get-seeds.js",
"pluggableLine": 20,
"edges": [
"initBundle"
],
"fnParams": [
"moduleSeeds",
"modulesByPath"
],
"name": "getBundleSeeds",
"fnStart": 20,
"fnEnd": 31,
"doc": "*\n * Given the set of early-stage modules (originally generated from the bundle definitions)\n * and the set of fully compiled modules (indexed by their absolute path), return an array\n * of early-stage bundles. These bundles do not yet know about which modules they contain,\n * but do hold a reference to the root module of their branch of the dependency graph.\n *\n * @param {Object} moduleSeeds Early-stage modules, indexed by path relative to\n * the compilation context.\n * @param {Object} modulesByPath Fully compiled modules, indexed by absolute path.\n *\n * @return {Array} Early-stage bundles with `module` property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "moduleSeeds",
"optional": false,
"description": "Early-stage modules, indexed by path relative to\nthe compilation context.",
"line": 6,
"source": "@param {Object} moduleSeeds Early-stage modules, indexed by path relative to\nthe compilation context."
},
{
"tag": "param",
"type": "Object",
"name": "modulesByPath",
"optional": false,
"description": "Fully compiled modules, indexed by absolute path.",
"line": 8,
"source": "@param {Object} modulesByPath Fully compiled modules, indexed by absolute path."
},
{
"tag": "return",
"type": "Array",
"name": "Early-stage",
"optional": false,
"description": "bundles with `module` property.",
"line": 10,
"source": "@return {Array} Early-stage bundles with `module` property."
}
],
"line": 0,
"description": "Given the set of early-stage modules (originally generated from the bundle definitions)\nand the set of fully compiled modules (indexed by their absolute path), return an array\nof early-stage bundles. These bundles do not yet know about which modules they contain,\nbut do hold a reference to the root module of their branch of the dependency graph.",
"source": "Given the set of early-stage modules (originally generated from the bundle definitions)\nand the set of fully compiled modules (indexed by their absolute path), return an array\nof early-stage bundles. These bundles do not yet know about which modules they contain,\nbut do hold a reference to the root module of their branch of the dependency graph.\n\n@param {Object} moduleSeeds Early-stage modules, indexed by path relative to\nthe compilation context.\n@param {Object} modulesByPath Fully compiled modules, indexed by absolute path.\n\n@return {Array} Early-stage bundles with `module` property."
}
},
"children": [
{
"name": "initBundle",
"node": {
"path": "src/compile/bundles/init.js",
"pluggableLine": 4,
"edges": [],
"fnParams": [
null
],
"name": "initBundle",
"fnStart": 4,
"fnEnd": 30,
"doc": null,
"parsedDoc": null
},
"children": [],
"markdown": "## initBundle\n \n \n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/init.js#L4-L30).\n\n ",
"size": 1
}
],
"markdown": "## getBundleSeeds\n \nGiven the set of early-stage modules (originally generated from the bundle definitions)\nand the set of fully compiled modules (indexed by their absolute path), return an array\nof early-stage bundles. These bundles do not yet know about which modules they contain,\nbut do hold a reference to the root module of their branch of the dependency graph.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **moduleSeeds** | Object | Early-stage modules, indexed by path relative to the compilation context. |\n| Parameter | **modulesByPath** | Object | Fully compiled modules, indexed by absolute path. |\n| Return value | | Array | Early-stage bundles with `module` property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/get-seeds.js#L20-L31).\n\n "
},
{
"name": "dedupeExplicit",
"node": {
"path": "src/compile/bundles/dedupe-explicit.js",
"pluggableLine": 53,
"edges": [],
"fnParams": [
"bundleSeeds",
"modulesByAbsPath"
],
"name": "dedupeExplicit",
"fnStart": 27,
"fnEnd": 51,
"doc": "*\n * First, update the bundle's `module` property to refer to the compiled\n * version of the module. Then generate a moduleHashes property for each\n * of the bundles, containing all hashes for all modules in the bundle's\n * dependency branch.\n *\n * Then, identify bundles that include the entry module from another bundle.\n * When found, remove all of the second module's bundles from the first.\n *\n * This will ensure that for any explicitly-defined bundle, other bundles\n * will not include its module or module-dependencies. This avoids copies\n * of a module from appearing in multiple bundles.\n *\n * @param {Array} bundleSeeds Early-stage bundle objects without module\n * or moduleHashes properties.\n * @param {Object} modulesByAbsPath Map of absolute paths to compiled modules.\n *\n * @return {Array} Bundle objects with explicit intersections\n * removed and new module and moduleHashes\n * properties.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "bundleSeeds",
"optional": false,
"description": "Early-stage bundle objects without module\nor moduleHashes properties.",
"line": 13,
"source": "@param {Array} bundleSeeds Early-stage bundle objects without module\nor moduleHashes properties."
},
{
"tag": "param",
"type": "Object",
"name": "modulesByAbsPath",
"optional": false,
"description": "Map of absolute paths to compiled modules.",
"line": 15,
"source": "@param {Object} modulesByAbsPath Map of absolute paths to compiled modules."
},
{
"tag": "return",
"type": "Array",
"name": "Bundle",
"optional": false,
"description": "objects with explicit intersections\nremoved and new module and moduleHashes\nproperties.",
"line": 17,
"source": "@return {Array} Bundle objects with explicit intersections\nremoved and new module and moduleHashes\nproperties."
}
],
"line": 0,
"description": "First, update the bundle's `module` property to refer to the compiled\nversion of the module. Then generate a moduleHashes property for each\nof the bundles, containing all hashes for all modules in the bundle's\ndependency branch.\n\nThen, identify bundles that include the entry module from another bundle.\nWhen found, remove all of the second module's bundles from the first.\n\nThis will ensure that for any explicitly-defined bundle, other bundles\nwill not include its module or module-dependencies. This avoids copies\nof a module from appearing in multiple bundles.",
"source": "First, update the bundle's `module` property to refer to the compiled\nversion of the module. Then generate a moduleHashes property for each\nof the bundles, containing all hashes for all modules in the bundle's\ndependency branch.\n\nThen, identify bundles that include the entry module from another bundle.\nWhen found, remove all of the second module's bundles from the first.\n\nThis will ensure that for any explicitly-defined bundle, other bundles\nwill not include its module or module-dependencies. This avoids copies\nof a module from appearing in multiple bundles.\n\n@param {Array} bundleSeeds Early-stage bundle objects without module\nor moduleHashes properties.\n@param {Object} modulesByAbsPath Map of absolute paths to compiled modules.\n\n@return {Array} Bundle objects with explicit intersections\nremoved and new module and moduleHashes\nproperties."
}
},
"children": [],
"markdown": "## dedupeExplicit\n \nFirst, update the bundle's `module` property to refer to the compiled\nversion of the module. Then generate a moduleHashes property for each\nof the bundles, containing all hashes for all modules in the bundle's\ndependency branch.\n\nThen, identify bundles that include the entry module from another bundle.\nWhen found, remove all of the second module's bundles from the first.\n\nThis will ensure that for any explicitly-defined bundle, other bundles\nwill not include its module or module-dependencies. This avoids copies\nof a module from appearing in multiple bundles.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundleSeeds** | Array | Early-stage bundle objects without module or moduleHashes properties. |\n| Parameter | **modulesByAbsPath** | Object | Map of absolute paths to compiled modules. |\n| Return value | | Array | Bundle objects with explicit intersections removed and new module and moduleHashes properties. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/dedupe-explicit.js#L53).\n The function that it wraps can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/dedupe-explicit.js#L27-L51).\n\n ",
"size": 1
},
{
"name": "dedupeImplicit",
"node": {
"path": "src/compile/bundles/dedupe-implicit.js",
"pluggableLine": 50,
"edges": [
"initBundle"
],
"fnParams": [
"explicitBundles"
],
"name": "dedupeImplicit",
"fnStart": 50,
"fnEnd": 52,
"doc": "*\n * Given an array of explicitly defined bundles, generate a new array of bundles\n * including new implicit bundles. These implicit bundles will be generated from\n * the intersections of two (or more) bundles' module hashes.\n *\n * This ensures that no module is included in more than one bundle. It further\n * ensures that any module that is depended upon by more than one bundle will be\n * split off into its own new bundle.\n *\n * @param {Array} explicitBundles Bundles with module and moduleHashes properties.\n *\n * @return {Array} Explicit bundles plus new implicit bundles.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "explicitBundles",
"optional": false,
"description": "Bundles with module and moduleHashes properties.",
"line": 9,
"source": "@param {Array} explicitBundles Bundles with module and moduleHashes properties."
},
{
"tag": "return",
"type": "Array",
"name": "Explicit",
"optional": false,
"description": "bundles plus new implicit bundles.",
"line": 11,
"source": "@return {Array} Explicit bundles plus new implicit bundles."
}
],
"line": 0,
"description": "Given an array of explicitly defined bundles, generate a new array of bundles\nincluding new implicit bundles. These implicit bundles will be generated from\nthe intersections of two (or more) bundles' module hashes.\n\nThis ensures that no module is included in more than one bundle. It further\nensures that any module that is depended upon by more than one bundle will be\nsplit off into its own new bundle.",
"source": "Given an array of explicitly defined bundles, generate a new array of bundles\nincluding new implicit bundles. These implicit bundles will be generated from\nthe intersections of two (or more) bundles' module hashes.\n\nThis ensures that no module is included in more than one bundle. It further\nensures that any module that is depended upon by more than one bundle will be\nsplit off into its own new bundle.\n\n@param {Array} explicitBundles Bundles with module and moduleHashes properties.\n\n@return {Array} Explicit bundles plus new implicit bundles."
}
},
"children": [
{
"name": "initBundle",
"node": {
"path": "src/compile/bundles/init.js",
"pluggableLine": 4,
"edges": [],
"fnParams": [
null
],
"name": "initBundle",
"fnStart": 4,
"fnEnd": 30,
"doc": null,
"parsedDoc": null
},
"children": [],
"markdown": "## initBundle\n \n \n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/init.js#L4-L30).\n\n ",
"size": 1
}
],
"markdown": "## dedupeImplicit\n \nGiven an array of explicitly defined bundles, generate a new array of bundles\nincluding new implicit bundles. These implicit bundles will be generated from\nthe intersections of two (or more) bundles' module hashes.\n\nThis ensures that no module is included in more than one bundle. It further\nensures that any module that is depended upon by more than one bundle will be\nsplit off into its own new bundle.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **explicitBundles** | Array | Bundles with module and moduleHashes properties. |\n| Return value | | Array | Explicit bundles plus new implicit bundles. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/dedupe-implicit.js#L50-L52).\n\n "
}
],
"markdown": "## partitionBundles\n \nGiven a set of module seeds and the set of fully generated modules, generate\na finalized array of bundles. These bundles will be early-stage and should\nnot be populated with the actual modules. Instead, each bundle will be defined\nby the module hashes (unique IDs) of the modules that comprise the bundle.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **moduleSeeds** | Object | Early-stage module objects, indexed by their path relative to the compilation context. |\n| Parameter | **moduleMaps** | Object | Maps of fully compiled modules, indexed by both absolute path and hash. |\n| Return value | | Array | Early-stage bundles. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/generate.js#L42-L46).\n\n "
},
{
"name": "hashBundle",
"node": {
"path": "src/compile/bundles/hash.js",
"pluggableLine": 47,
"edges": [
"updateBundleHash"
],
"fnParams": [
"bundle"
],
"name": "hashBundle",
"fnStart": 29,
"fnEnd": 45,
"doc": "*\n * Given an otherwise prepared bundle, generate a hash for that bundle and resolve\n * to that same bundle with a new `hash` property.\n *\n * @param {Object} bundle Unhashed bundle.\n *\n * @returns {Object} Bundle plus new `hash` property, a 40-character SHA1\n * that uniquely identifies the bundle.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "bundle",
"optional": false,
"description": "Unhashed bundle.",
"line": 4,
"source": "@param {Object} bundle Unhashed bundle."
},
{
"tag": "returns",
"type": "Object",
"name": "Bundle",
"optional": false,
"description": "plus new `hash` property, a 40-character SHA1\nthat uniquely identifies the bundle.",
"line": 6,
"source": "@returns {Object} Bundle plus new `hash` property, a 40-character SHA1\nthat uniquely identifies the bundle."
}
],
"line": 0,
"description": "Given an otherwise prepared bundle, generate a hash for that bundle and resolve\nto that same bundle with a new `hash` property.",
"source": "Given an otherwise prepared bundle, generate a hash for that bundle and resolve\nto that same bundle with a new `hash` property.\n\n@param {Object} bundle Unhashed bundle.\n\n@returns {Object} Bundle plus new `hash` property, a 40-character SHA1\nthat uniquely identifies the bundle."
}
},
"children": [
{
"name": "updateBundleHash",
"node": {
"path": "src/compile/bundles/hash.js",
"pluggableLine": 14,
"edges": [],
"fnParams": [
"update",
"bundle"
],
"name": "updateBundleHash",
"fnStart": 14,
"fnEnd": 18,
"doc": "*\n * Calculate the bundle's hash by invoking `update` with data from the bundle.\n * `update` should be called with string data only.\n *\n * @param {Function} update Updates the ongoing computation of bundle hash.\n * @param {Object} bundle The bundle object.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Function",
"name": "update",
"optional": false,
"description": "Updates the ongoing computation of bundle hash.",
"line": 4,
"source": "@param {Function} update Updates the ongoing computation of bundle hash."
},
{
"tag": "param",
"type": "Object",
"name": "bundle",
"optional": false,
"description": "The bundle object.",
"line": 5,
"source": "@param {Object} bundle The bundle object."
}
],
"line": 0,
"description": "Calculate the bundle's hash by invoking `update` with data from the bundle.\n`update` should be called with string data only.",
"source": "Calculate the bundle's hash by invoking `update` with data from the bundle.\n`update` should be called with string data only.\n\n@param {Function} update Updates the ongoing computation of bundle hash.\n@param {Object} bundle The bundle object."
}
},
"children": [],
"markdown": "## updateBundleHash\n \nCalculate the bundle's hash by invoking `update` with data from the bundle.\n`update` should be called with string data only.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **update** | Function | Updates the ongoing computation of bundle hash. |\n| Parameter | **bundle** | Object | The bundle object. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/hash.js#L14-L18).\n\n ",
"size": 1
}
],
"markdown": "## hashBundle\n \nGiven an otherwise prepared bundle, generate a hash for that bundle and resolve\nto that same bundle with a new `hash` property.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundle** | Object | Unhashed bundle. |\n| Return value | | Object | Bundle plus new `hash` property, a 40-character SHA1 that uniquely identifies the bundle. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/hash.js#L47).\n The function that it wraps can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/hash.js#L29-L45).\n\n "
},
{
"name": "interpolateFilename",
"node": {
"path": "src/compile/bundles/interpolate-filename.js",
"pluggableLine": 13,
"edges": [],
"fnParams": [
"bundle"
],
"name": "interpolateFilename",
"fnStart": 13,
"fnEnd": 23,
"doc": "*\n * Given a bundle, determine its ultimate output filepath by replacing\n * supported placeholders with their dynamic equivalents.\n *\n * @param {Object} bundle Late-stage bundle object.\n *\n * @return {Object} Bundle with interpolated `dest` property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "bundle",
"optional": false,
"description": "Late-stage bundle object.",
"line": 4,
"source": "@param {Object} bundle Late-stage bundle object."
},
{
"tag": "return",
"type": "Object",
"name": "Bundle",
"optional": false,
"description": "with interpolated `dest` property.",
"line": 6,
"source": "@return {Object} Bundle with interpolated `dest` property."
}
],
"line": 0,
"description": "Given a bundle, determine its ultimate output filepath by replacing\nsupported placeholders with their dynamic equivalents.",
"source": "Given a bundle, determine its ultimate output filepath by replacing\nsupported placeholders with their dynamic equivalents.\n\n@param {Object} bundle Late-stage bundle object.\n\n@return {Object} Bundle with interpolated `dest` property."
}
},
"children": [],
"markdown": "## interpolateFilename\n \nGiven a bundle, determine its ultimate output filepath by replacing\nsupported placeholders with their dynamic equivalents.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundle** | Object | Late-stage bundle object. |\n| Return value | | Object | Bundle with interpolated `dest` property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/interpolate-filename.js#L13-L23).\n\n ",
"size": 1
},
{
"name": "populateBundleModules",
"node": {
"path": "src/compile/bundles/generate.js",
"pluggableLine": 23,
"edges": [],
"fnParams": [
"bundle",
"moduleMaps"
],
"name": "populateBundleModules",
"fnStart": 23,
"fnEnd": 27,
"doc": "*\n * Define the canonical modules array for a bundle. This should occur after\n * bundle module hashes are deduped.\n *\n * @param {Object} bundle The bundle object, with no modules property.\n * @param {Object} moduleMaps Has two properties - byAbsPath and byHash -\n * where each of these map to the compiled module\n * via the respective value.\n *\n * @return {Object} The bundle object, with modules property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "bundle",
"optional": false,
"description": "The bundle object, with no modules property.",
"line": 4,
"source": "@param {Object} bundle The bundle object, with no modules property."
},
{
"tag": "param",
"type": "Object",
"name": "moduleMaps",
"optional": false,
"description": "Has two properties - byAbsPath and byHash -\nwhere each of these map to the compiled module\nvia the respective value.",
"line": 5,
"source": "@param {Object} moduleMaps Has two properties - byAbsPath and byHash -\nwhere each of these map to the compiled module\nvia the respective value."
},
{
"tag": "return",
"type": "Object",
"name": "The",
"optional": false,
"description": "bundle object, with modules property.",
"line": 9,
"source": "@return {Object} The bundle object, with modules property."
}
],
"line": 0,
"description": "Define the canonical modules array for a bundle. This should occur after\nbundle module hashes are deduped.",
"source": "Define the canonical modules array for a bundle. This should occur after\nbundle module hashes are deduped.\n\n@param {Object} bundle The bundle object, with no modules property.\n@param {Object} moduleMaps Has two properties - byAbsPath and byHash -\nwhere each of these map to the compiled module\nvia the respective value.\n\n@return {Object} The bundle object, with modules property."
}
},
"children": [],
"markdown": "## populateBundleModules\n \nDefine the canonical modules array for a bundle. This should occur after\nbundle module hashes are deduped.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundle** | Object | The bundle object, with no modules property. |\n| Parameter | **moduleMaps** | Object | Has two properties - byAbsPath and byHash - where each of these map to the compiled module via the respective value. |\n| Return value | | Object | The bundle object, with modules property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/generate.js#L23-L27).\n\n ",
"size": 1
}
],
"markdown": "## generateBundles\n \nGiven a set of module seeds - originally generated from the bundle definitions\npassed into the Interlock constructor - and the set of fully generated modules,\ngenerate the full set of bundles that should be emitted, populate them with\nmodule objects, hash them, and interpolate any output filenames.\n\nBundles outputted from this function should be ready to be transformed into\nstrings using AST->source transformation, and then written to disk.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **moduleSeeds** | Object | Early-stage module objects, indexed by their path relative to the compilation context. |\n| Parameter | **moduleMaps** | Object | Maps of fully compiled modules, indexed by both absolute path and hash. |\n| Return value | | Array | Fully compiled bundles. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/generate.js#L64-L71).\n\n "
},
{
"name": "buildOutput",
"node": {
"path": "src/compile/index.js",
"pluggableLine": 88,
"edges": [
"getUrls",
"emitRawBundles"
],
"fnParams": [
"bundles"
],
"name": "buildOutput",
"fnStart": 88,
"fnEnd": 100,
"doc": "*\n * Reduces an array of compiled bundles into a compilation object. This compilation\n * object will have three key/value pairs:\n *\n * - **cache:** populated from the compilation process\n * - **bundles:** a mapping of destination paths to `raw` code\n * - **opts:** the original options passed to the compilation\n *\n * @param {Array} bundles Compiled bundles, generated by generateBundles.\n *\n * @return {Promise} Compilation object.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "bundles",
"optional": false,
"description": "Compiled bundles, generated by generateBundles.",
"line": 8,
"source": "@param {Array} bundles Compiled bundles, generated by generateBundles."
},
{
"tag": "return",
"type": "Promise",
"name": "Compilation",
"optional": false,
"description": "object.",
"line": 10,
"source": "@return {Promise} Compilation object."
}
],
"line": 0,
"description": "Reduces an array of compiled bundles into a compilation object. This compilation\nobject will have three key/value pairs:\n\n- **cache:** populated from the compilation process\n- **bundles:** a mapping of destination paths to `raw` code\n- **opts:** the original options passed to the compilation",
"source": "Reduces an array of compiled bundles into a compilation object. This compilation\nobject will have three key/value pairs:\n\n- **cache:** populated from the compilation process\n- **bundles:** a mapping of destination paths to `raw` code\n- **opts:** the original options passed to the compilation\n\n@param {Array} bundles Compiled bundles, generated by generateBundles.\n\n@return {Promise} Compilation object."
}
},
"children": [
{
"name": "getUrls",
"node": {
"path": "src/compile/index.js",
"pluggableLine": 24,
"edges": [],
"fnParams": [
"bundles"
],
"name": "getUrls",
"fnStart": 24,
"fnEnd": 29,
"doc": "*\n * Given an array of bundles, generate a lookup dictionary of module hashes\n * to the destination path of the bundles that contains them.\n *\n * @param {Array} bundles Compiled bundles.\n *\n * @return {Object} moduleHash-to-URL lookup dictionary.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "bundles",
"optional": false,
"description": "Compiled bundles.",
"line": 4,
"source": "@param {Array} bundles Compiled bundles."
},
{
"tag": "return",
"type": "Object",
"name": "moduleHash-to-URL",
"optional": false,
"description": "lookup dictionary.",
"line": 6,
"source": "@return {Object} moduleHash-to-URL lookup dictionary."
}
],
"line": 0,
"description": "Given an array of bundles, generate a lookup dictionary of module hashes\nto the destination path of the bundles that contains them.",
"source": "Given an array of bundles, generate a lookup dictionary of module hashes\nto the destination path of the bundles that contains them.\n\n@param {Array} bundles Compiled bundles.\n\n@return {Object} moduleHash-to-URL lookup dictionary."
}
},
"children": [],
"markdown": "## getUrls\n \nGiven an array of bundles, generate a lookup dictionary of module hashes\nto the destination path of the bundles that contains them.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundles** | Array | Compiled bundles. |\n| Return value | | Object | moduleHash-to-URL lookup dictionary. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/index.js#L24-L29).\n\n ",
"size": 1
},
{
"name": "emitRawBundles",
"node": {
"path": "src/compile/index.js",
"pluggableLine": 66,
"edges": [
"constructBundle",
"generateRawBundles"
],
"fnParams": [
"bundlesArr",
"urls"
],
"name": "emitRawBundles",
"fnStart": 66,
"fnEnd": 74,
"doc": "*\n * Given an array of compiled bundles and a moduleHash-to-URL lookup dictionary,\n * generate a new array of bundles with new `ast` and `raw` properties.\n *\n * Some compiled bundles (as internally represented) will result in more than\n * one output file. The canonical example of this is a JS file and its source-map.\n * Plugins may also implement mechanisms to output multiple files per bundle.\n *\n * This one-to-many relationship is defined by the generateRawBundles method, which\n * may output an array of raw bundles.\n *\n * @param {Array} bundlesArr Compiled bundles.\n * @param {Object} urls moduleHash-to-URL lookup dictionary.\n *\n * @return {Array} Bundles with new `raw` properties.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "bundlesArr",
"optional": false,
"description": "Compiled bundles.",
"line": 11,
"source": "@param {Array} bundlesArr Compiled bundles."
},
{
"tag": "param",
"type": "Object",
"name": "urls",
"optional": false,
"description": "moduleHash-to-URL lookup dictionary.",
"line": 12,
"source": "@param {Object} urls moduleHash-to-URL lookup dictionary."
},
{
"tag": "return",
"type": "Array",
"name": "Bundles",
"optional": false,
"description": "with new `raw` properties.",
"line": 14,
"source": "@return {Array} Bundles with new `raw` properties."
}
],
"line": 0,
"description": "Given an array of compiled bundles and a moduleHash-to-URL lookup dictionary,\ngenerate a new array of bundles with new `ast` and `raw` properties.\n\nSome compiled bundles (as internally represented) will result in more than\none output file. The canonical example of this is a JS file and its source-map.\nPlugins may also implement mechanisms to output multiple files per bundle.\n\nThis one-to-many relationship is defined by the generateRawBundles method, which\nmay output an array of raw bundles.",
"source": "Given an array of compiled bundles and a moduleHash-to-URL lookup dictionary,\ngenerate a new array of bundles with new `ast` and `raw` properties.\n\nSome compiled bundles (as internally represented) will result in more than\none output file. The canonical example of this is a JS file and its source-map.\nPlugins may also implement mechanisms to output multiple files per bundle.\n\nThis one-to-many relationship is defined by the generateRawBundles method, which\nmay output an array of raw bundles.\n\n@param {Array} bundlesArr Compiled bundles.\n@param {Object} urls moduleHash-to-URL lookup dictionary.\n\n@return {Array} Bundles with new `raw` properties."
}
},
"children": [
{
"name": "constructBundle",
"node": {
"path": "src/compile/index.js",
"pluggableLine": 40,
"edges": [
"constructBundleAst"
],
"fnParams": [
"bundle",
"urls"
],
"name": "constructBundle",
"fnStart": 40,
"fnEnd": 48,
"doc": "*\n * Given a compiled bundle and moduleHash-to-URL lookup object, output\n * the same bundle with generated AST.\n *\n * @param {Object} bundle Fully compiled bundle, ready to be outputed.\n * @param {Object} urls moduleHash-to-URL lookup dictionary.\n *\n * @return {Object} Bundle with new `ast` property.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "bundle",
"optional": false,
"description": "Fully compiled bundle, ready to be outputed.",
"line": 4,
"source": "@param {Object} bundle Fully compiled bundle, ready to be outputed."
},
{
"tag": "param",
"type": "Object",
"name": "urls",
"optional": false,
"description": "moduleHash-to-URL lookup dictionary.",
"line": 5,
"source": "@param {Object} urls moduleHash-to-URL lookup dictionary."
},
{
"tag": "return",
"type": "Object",
"name": "Bundle",
"optional": false,
"description": "with new `ast` property.",
"line": 7,
"source": "@return {Object} Bundle with new `ast` property."
}
],
"line": 0,
"description": "Given a compiled bundle and moduleHash-to-URL lookup object, output\nthe same bundle with generated AST.",
"source": "Given a compiled bundle and moduleHash-to-URL lookup object, output\nthe same bundle with generated AST.\n\n@param {Object} bundle Fully compiled bundle, ready to be outputed.\n@param {Object} urls moduleHash-to-URL lookup dictionary.\n\n@return {Object} Bundle with new `ast` property."
}
},
"children": [
{
"name": "constructBundleAst",
"node": {
"path": "src/compile/construct/index.js",
"pluggableLine": 165,
"edges": [
"constructBundleBody"
],
"fnParams": [
"opts"
],
"name": "constructBundleAst",
"fnStart": 165,
"fnEnd": 170,
"doc": "*\n * Construct the AST for an output bundle. A number of optional options-args are\n * allowed, to give flexibility to the compiler for what sort of bundle should be\n * constructed.\n *\n * For example, in the case of a bundle with an entry module, you'll want everything\n * to be included. The run-time is needed, because there is no guarantee another\n * bundle has already loaded the run-time. The module-hash-to-bundle-URLs object\n * should be included, as again there is no guarantee another bundle has already\n * set those values. The modules of the bundle itself need to be included, etc.\n *\n * However, you might instead generate a specialized bundle that only contains the\n * run-time and URLs. This bundle might be inlined into the page, or guaranteed\n * to be loaded first, so that redundant copies of the run-time be included in\n * every other bundle generated.\n *\n * The output for this function should be a root AST node, ready to be transformed\n * back into JavaScript code.\n *\n * @param {Object} opts Options.\n * @param {Boolean} opts.includeRuntime Indicates whether Interlock run-time should be emitted.\n * @param {Object} opts.urls Optional. If included, map of module hashes to URLs\n * will be emitted.\n * @param {Array} opts.modules Optional. If included, the module objects will be\n * transformed into output module AST and emitted.\n * @param {String} opts.entryModuleId Optional. If included, a statement will be rendered\n * to invoke the specified module on load.\n *\n * @return {ASTnode} Single program AST node.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "opts",
"optional": false,
"description": "Options.",
"line": 19,
"source": "@param {Object} opts Options."
},
{
"tag": "param",
"type": "Boolean",
"name": "opts.includeRuntime",
"optional": false,
"description": "Indicates whether Interlock run-time should be emitted.",
"line": 20,
"source": "@param {Boolean} opts.includeRuntime Indicates whether Interlock run-time should be emitted."
},
{
"tag": "param",
"type": "Object",
"name": "opts.urls",
"optional": false,
"description": "Optional. If included, map of module hashes to URLs\nwill be emitted.",
"line": 21,
"source": "@param {Object} opts.urls Optional. If included, map of module hashes to URLs\nwill be emitted."
},
{
"tag": "param",
"type": "Array",
"name": "opts.modules",
"optional": false,
"description": "Optional. If included, the module objects will be\ntransformed into output module AST and emitted.",
"line": 23,
"source": "@param {Array} opts.modules Optional. If included, the module objects will be\ntransformed into output module AST and emitted."
},
{
"tag": "param",
"type": "String",
"name": "opts.entryModuleId",
"optional": false,
"description": "Optional. If included, a statement will be rendered\nto invoke the specified module on load.",
"line": 25,
"source": "@param {String} opts.entryModuleId Optional. If included, a statement will be rendered\nto invoke the specified module on load."
},
{
"tag": "return",
"type": "ASTnode",
"name": "Single",
"optional": false,
"description": "program AST node.",
"line": 28,
"source": "@return {ASTnode} Single program AST node."
}
],
"line": 0,
"description": "Construct the AST for an output bundle. A number of optional options-args are\nallowed, to give flexibility to the compiler for what sort of bundle should be\nconstructed.\n\nFor example, in the case of a bundle with an entry module, you'll want everything\nto be included. The run-time is needed, because there is no guarantee another\nbundle has already loaded the run-time. The module-hash-to-bundle-URLs object\nshould be included, as again there is no guarantee another bundle has already\nset those values. The modules of the bundle itself need to be included, etc.\n\nHowever, you might instead generate a specialized bundle that only contains the\nrun-time and URLs. This bundle might be inlined into the page, or guaranteed\nto be loaded first, so that redundant copies of the run-time be included in\nevery other bundle generated.\n\nThe output for this function should be a root AST node, ready to be transformed\nback into JavaScript code.",
"source": "Construct the AST for an output bundle. A number of optional options-args are\nallowed, to give flexibility to the compiler for what sort of bundle should be\nconstructed.\n\nFor example, in the case of a bundle with an entry module, you'll want everything\nto be included. The run-time is needed, because there is no guarantee another\nbundle has already loaded the run-time. The module-hash-to-bundle-URLs object\nshould be included, as again there is no guarantee another bundle has already\nset those values. The modules of the bundle itself need to be included, etc.\n\nHowever, you might instead generate a specialized bundle that only contains the\nrun-time and URLs. This bundle might be inlined into the page, or guaranteed\nto be loaded first, so that redundant copies of the run-time be included in\nevery other bundle generated.\n\nThe output for this function should be a root AST node, ready to be transformed\nback into JavaScript code.\n\n@param {Object} opts Options.\n@param {Boolean} opts.includeRuntime Indicates whether Interlock run-time should be emitted.\n@param {Object} opts.urls Optional. If included, map of module hashes to URLs\nwill be emitted.\n@param {Array} opts.modules Optional. If included, the module objects will be\ntransformed into output module AST and emitted.\n@param {String} opts.entryModuleId Optional. If included, a statement will be rendered\nto invoke the specified module on load.\n\n@return {ASTnode} Single program AST node."
}
},
"children": [
{
"name": "constructBundleBody",
"node": {
"path": "src/compile/construct/index.js",
"pluggableLine": 121,
"edges": [
"constructModuleSet",
"constructRuntime",
"constructRegisterUrls"
],
"fnParams": [
"opts"
],
"name": "constructBundleBody",
"fnStart": 121,
"fnEnd": 133,
"doc": "*\n * Builds body of output bundle, to be inserted into the IIFE.\n *\n * @param {Object} opts Same options object passed to constructBundleBody.\n *\n * @return {Array} Body of bundle.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "opts",
"optional": false,
"description": "Same options object passed to constructBundleBody.",
"line": 3,
"source": "@param {Object} opts Same options object passed to constructBundleBody."
},
{
"tag": "return",
"type": "Array",
"name": "Body",
"optional": false,
"description": "of bundle.",
"line": 5,
"source": "@return {Array} Body of bundle."
}
],
"line": 0,
"description": "Builds body of output bundle, to be inserted into the IIFE.",
"source": "Builds body of output bundle, to be inserted into the IIFE.\n\n@param {Object} opts Same options object passed to constructBundleBody.\n\n@return {Array} Body of bundle."
}
},
"children": [
{
"name": "constructModuleSet",
"node": {
"path": "src/compile/construct/index.js",
"pluggableLine": 66,
"edges": [
"constructCommonModule"
],
"fnParams": [
"modules",
"globalName",
"entryModuleId"
],
"name": "constructModuleSet",
"fnStart": 66,
"fnEnd": 82,
"doc": "*\n * Given an array of compiled modules, construct the AST for JavaScript that would\n * register those modules for consumption by the Interlock run-time.\n *\n * @param {Array} modules Array of compiled modules.\n * @param {String} globalName Global variable name of the Interlock run-time.\n * @param {String} entryModuleId Module-hash of the entry module.\n *\n * @return {Array} Array of AST nodes to be emitted as JavaScript.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "modules",
"optional": false,
"description": "Array of compiled modules.",
"line": 4,
"source": "@param {Array} modules Array of compiled modules."
},
{
"tag": "param",
"type": "String",
"name": "globalName",
"optional": false,
"description": "Global variable name of the Interlock run-time.",
"line": 5,
"source": "@param {String} globalName Global variable name of the Interlock run-time."
},
{
"tag": "param",
"type": "String",
"name": "entryModuleId",
"optional": false,
"description": "Module-hash of the entry module.",
"line": 6,
"source": "@param {String} entryModuleId Module-hash of the entry module."
},
{
"tag": "return",
"type": "Array",
"name": "Array",
"optional": false,
"description": "of AST nodes to be emitted as JavaScript.",
"line": 8,
"source": "@return {Array} Array of AST nodes to be emitted as JavaScript."
}
],
"line": 0,
"description": "Given an array of compiled modules, construct the AST for JavaScript that would\nregister those modules for consumption by the Interlock run-time.",
"source": "Given an array of compiled modules, construct the AST for JavaScript that would\nregister those modules for consumption by the Interlock run-time.\n\n@param {Array} modules Array of compiled modules.\n@param {String} globalName Global variable name of the Interlock run-time.\n@param {String} entryModuleId Module-hash of the entry module.\n\n@return {Array} Array of AST nodes to be emitted as JavaScript."
}
},
"children": [
{
"name": "constructCommonModule",
"node": {
"path": "src/compile/construct/index.js",
"pluggableLine": 39,
"edges": [],
"fnParams": [
"moduleBody",
"deps"
],
"name": "constructCommonModule",
"fnStart": 39,
"fnEnd": 46,
"doc": "*\n * Given an array of AST nodes from a module's body along with that module's\n * dependencies, construct an AST object expression that represents its run-time\n * equivalent.\n *\n * @param {Array} moduleBody Array of AST nodes.\n * @param {Array} deps Array of modules upon which module is dependent.\n *\n * @return {ASTnode} Object expression AST node.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Array",
"name": "moduleBody",
"optional": false,
"description": "Array of AST nodes.",
"line": 5,
"source": "@param {Array} moduleBody Array of AST nodes."
},
{
"tag": "param",
"type": "Array",
"name": "deps",
"optional": false,
"description": "Array of modules upon which module is dependent.",
"line": 6,
"source": "@param {Array} deps Array of modules upon which module is dependent."
},
{
"tag": "return",
"type": "ASTnode",
"name": "Object",
"optional": false,
"description": "expression AST node.",
"line": 8,
"source": "@return {ASTnode} Object expression AST node."
}
],
"line": 0,
"description": "Given an array of AST nodes from a module's body along with that module's\ndependencies, construct an AST object expression that represents its run-time\nequivalent.",
"source": "Given an array of AST nodes from a module's body along with that module's\ndependencies, construct an AST object expression that represents its run-time\nequivalent.\n\n@param {Array} moduleBody Array of AST nodes.\n@param {Array} deps Array of modules upon which module is dependent.\n\n@return {ASTnode} Object expression AST node."
}
},
"children": [],
"markdown": "## constructCommonModule\n \nGiven an array of AST nodes from a module's body along with that module's\ndependencies, construct an AST object expression that represents its run-time\nequivalent.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **moduleBody** | Array | Array of AST nodes. |\n| Parameter | **deps** | Array | Array of modules upon which module is dependent. |\n| Return value | | ASTnode | Object expression AST node. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/construct/index.js#L39-L46).\n\n ",
"size": 1
}
],
"markdown": "## constructModuleSet\n \nGiven an array of compiled modules, construct the AST for JavaScript that would\nregister those modules for consumption by the Interlock run-time.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **modules** | Array | Array of compiled modules. |\n| Parameter | **globalName** | String | Global variable name of the Interlock run-time. |\n| Parameter | **entryModuleId** | String | Module-hash of the entry module. |\n| Return value | | Array | Array of AST nodes to be emitted as JavaScript. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/construct/index.js#L66-L82).\n\n "
},
{
"name": "constructRuntime",
"node": {
"path": "src/compile/construct/index.js",
"pluggableLine": 91,
"edges": [],
"fnParams": [
"globalName"
],
"name": "constructRuntime",
"fnStart": 91,
"fnEnd": 95,
"doc": "*\n * Construct the guts of the Interlock run-time for inclusion in file output.\n *\n * @param {String} globalName Global variable name of Interlock run-time.\n *\n * @return {Array} Array of AST nodes.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "String",
"name": "globalName",
"optional": false,
"description": "Global variable name of Interlock run-time.",
"line": 3,
"source": "@param {String} globalName Global variable name of Interlock run-time."
},
{
"tag": "return",
"type": "Array",
"name": "Array",
"optional": false,
"description": "of AST nodes.",
"line": 5,
"source": "@return {Array} Array of AST nodes."
}
],
"line": 0,
"description": "Construct the guts of the Interlock run-time for inclusion in file output.",
"source": "Construct the guts of the Interlock run-time for inclusion in file output.\n\n@param {String} globalName Global variable name of Interlock run-time.\n\n@return {Array} Array of AST nodes."
}
},
"children": [],
"markdown": "## constructRuntime\n \nConstruct the guts of the Interlock run-time for inclusion in file output.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **globalName** | String | Global variable name of Interlock run-time. |\n| Return value | | Array | Array of AST nodes. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/construct/index.js#L91-L95).\n\n ",
"size": 1
},
{
"name": "constructRegisterUrls",
"node": {
"path": "src/compile/construct/index.js",
"pluggableLine": 105,
"edges": [],
"fnParams": [
"urls",
"globalName"
],
"name": "constructRegisterUrls",
"fnStart": 105,
"fnEnd": 112,
"doc": "*\n * Transforms a map of module-hashes-to-URLs to the AST equivalent.\n *\n * @param {Object} urls Keys are module hashes, values are URL strings.\n * @param {String} globalName Global variable name of Interlock run-time.\n *\n * @return {ASTnode} Single AST node.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "urls",
"optional": false,
"description": "Keys are module hashes, values are URL strings.",
"line": 3,
"source": "@param {Object} urls Keys are module hashes, values are URL strings."
},
{
"tag": "param",
"type": "String",
"name": "globalName",
"optional": false,
"description": "Global variable name of Interlock run-time.",
"line": 4,
"source": "@param {String} globalName Global variable name of Interlock run-time."
},
{
"tag": "return",
"type": "ASTnode",
"name": "Single",
"optional": false,
"description": "AST node.",
"line": 6,
"source": "@return {ASTnode} Single AST node."
}
],
"line": 0,
"description": "Transforms a map of module-hashes-to-URLs to the AST equivalent.",
"source": "Transforms a map of module-hashes-to-URLs to the AST equivalent.\n\n@param {Object} urls Keys are module hashes, values are URL strings.\n@param {String} globalName Global variable name of Interlock run-time.\n\n@return {ASTnode} Single AST node."
}
},
"children": [],
"markdown": "## constructRegisterUrls\n \nTransforms a map of module-hashes-to-URLs to the AST equivalent.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **urls** | Object | Keys are module hashes, values are URL strings. |\n| Parameter | **globalName** | String | Global variable name of Interlock run-time. |\n| Return value | | ASTnode | Single AST node. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/construct/index.js#L105-L112).\n\n ",
"size": 1
}
],
"markdown": "## constructBundleBody\n \nBuilds body of output bundle, to be inserted into the IIFE.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **opts** | Object | Same options object passed to constructBundleBody. |\n| Return value | | Array | Body of bundle. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/construct/index.js#L121-L133).\n\n "
}
],
"markdown": "## constructBundleAst\n \nConstruct the AST for an output bundle. A number of optional options-args are\nallowed, to give flexibility to the compiler for what sort of bundle should be\nconstructed.\n\nFor example, in the case of a bundle with an entry module, you'll want everything\nto be included. The run-time is needed, because there is no guarantee another\nbundle has already loaded the run-time. The module-hash-to-bundle-URLs object\nshould be included, as again there is no guarantee another bundle has already\nset those values. The modules of the bundle itself need to be included, etc.\n\nHowever, you might instead generate a specialized bundle that only contains the\nrun-time and URLs. This bundle might be inlined into the page, or guaranteed\nto be loaded first, so that redundant copies of the run-time be included in\nevery other bundle generated.\n\nThe output for this function should be a root AST node, ready to be transformed\nback into JavaScript code.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **opts** | Object | Options. |\n| Parameter | **opts.includeRuntime** | Boolean | Indicates whether Interlock run-time should be emitted. |\n| Parameter | **opts.urls** | Object | Optional. If included, map of module hashes to URLs will be emitted. |\n| Parameter | **opts.modules** | Array | Optional. If included, the module objects will be transformed into output module AST and emitted. |\n| Parameter | **opts.entryModuleId** | String | Optional. If included, a statement will be rendered to invoke the specified module on load. |\n| Return value | | ASTnode | Single program AST node. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/construct/index.js#L165-L170).\n\n "
}
],
"markdown": "## constructBundle\n \nGiven a compiled bundle and moduleHash-to-URL lookup object, output\nthe same bundle with generated AST.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundle** | Object | Fully compiled bundle, ready to be outputed. |\n| Parameter | **urls** | Object | moduleHash-to-URL lookup dictionary. |\n| Return value | | Object | Bundle with new `ast` property. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/index.js#L40-L48).\n\n "
},
{
"name": "generateRawBundles",
"node": {
"path": "src/compile/bundles/generate-raw.js",
"pluggableLine": 64,
"edges": [
"generateJsCode"
],
"fnParams": [
"bundle"
],
"name": "generateRawBundles",
"fnStart": 64,
"fnEnd": 92,
"doc": "*\n * Given a compiled bundle object, return an array of one or more bundles with\n * new `raw` property. This raw property should be generated from the bundle's\n * AST or equivalent intermediate representation.\n *\n * This is a one-to-many transformation because it is quite possible for multiple\n * output files to result from a single bundle object. The canonical example (and\n * default behavior of this function, when sourcemaps are enabled) is for one\n * bundle to result in a `.js` file and a `.map` file.\n *\n * @param {Object} bundle Bundle object without `raw` property.\n *\n * @return {Array} Array of bundle objects. At minimum, these bundle\n * objects should have a `raw` property - a string\n * representation of the file to be written to disk -\n * and a `dest` property - the relative filepath\n * of the file to be written to disk.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "bundle",
"optional": false,
"description": "Bundle object without `raw` property.",
"line": 10,
"source": "@param {Object} bundle Bundle object without `raw` property."
},
{
"tag": "return",
"type": "Array",
"name": "Array",
"optional": false,
"description": "of bundle objects. At minimum, these bundle\nobjects should have a `raw` property - a string\nrepresentation of the file to be written to disk -\nand a `dest` property - the relative filepath\nof the file to be written to disk.",
"line": 12,
"source": "@return {Array} Array of bundle objects. At minimum, these bundle\nobjects should have a `raw` property - a string\nrepresentation of the file to be written to disk -\nand a `dest` property - the relative filepath\nof the file to be written to disk."
}
],
"line": 0,
"description": "Given a compiled bundle object, return an array of one or more bundles with\nnew `raw` property. This raw property should be generated from the bundle's\nAST or equivalent intermediate representation.\n\nThis is a one-to-many transformation because it is quite possible for multiple\noutput files to result from a single bundle object. The canonical example (and\ndefault behavior of this function, when sourcemaps are enabled) is for one\nbundle to result in a `.js` file and a `.map` file.",
"source": "Given a compiled bundle object, return an array of one or more bundles with\nnew `raw` property. This raw property should be generated from the bundle's\nAST or equivalent intermediate representation.\n\nThis is a one-to-many transformation because it is quite possible for multiple\noutput files to result from a single bundle object. The canonical example (and\ndefault behavior of this function, when sourcemaps are enabled) is for one\nbundle to result in a `.js` file and a `.map` file.\n\n@param {Object} bundle Bundle object without `raw` property.\n\n@return {Array} Array of bundle objects. At minimum, these bundle\nobjects should have a `raw` property - a string\nrepresentation of the file to be written to disk -\nand a `dest` property - the relative filepath\nof the file to be written to disk."
}
},
"children": [
{
"name": "generateJsCode",
"node": {
"path": "src/compile/bundles/generate-raw.js",
"pluggableLine": 22,
"edges": [],
"fnParams": [
"opts"
],
"name": "generateJsCode",
"fnStart": 22,
"fnEnd": 44,
"doc": "*\n * Given an AST and a set of options, generate the corresponding JavaScript\n * source and optional sourcemap string.\n *\n * @param {Object} opts The generation options.\n * @param {AST} opts.ast The AST to render.\n * @param {Boolean} opts.sourceMaps Whether to render a source-map.\n * @param {String} opts.sourceMapTarget The output filename.\n * @param {Boolean} opts.pretty Whether to output formatted JS.\n * @param {Boolean} opts.includeComments Whether to include comments in the output.\n * @param {Object} opts.sources A hash of source filenames to source content.\n *\n * @return {Object} An object with `code` and `map` strings,\n * where `map` can be null.\n ",
"parsedDoc": {
"tags": [
{
"tag": "param",
"type": "Object",
"name": "opts",
"optional": false,
"description": "The generation options.",
"line": 4,
"source": "@param {Object} opts The generation options."
},
{
"tag": "param",
"type": "AST",
"name": "opts.ast",
"optional": false,
"description": "The AST to render.",
"line": 5,
"source": "@param {AST} opts.ast The AST to render."
},
{
"tag": "param",
"type": "Boolean",
"name": "opts.sourceMaps",
"optional": false,
"description": "Whether to render a source-map.",
"line": 6,
"source": "@param {Boolean} opts.sourceMaps Whether to render a source-map."
},
{
"tag": "param",
"type": "String",
"name": "opts.sourceMapTarget",
"optional": false,
"description": "The output filename.",
"line": 7,
"source": "@param {String} opts.sourceMapTarget The output filename."
},
{
"tag": "param",
"type": "Boolean",
"name": "opts.pretty",
"optional": false,
"description": "Whether to output formatted JS.",
"line": 8,
"source": "@param {Boolean} opts.pretty Whether to output formatted JS."
},
{
"tag": "param",
"type": "Boolean",
"name": "opts.includeComments",
"optional": false,
"description": "Whether to include comments in the output.",
"line": 9,
"source": "@param {Boolean} opts.includeComments Whether to include comments in the output."
},
{
"tag": "param",
"type": "Object",
"name": "opts.sources",
"optional": false,
"description": "A hash of source filenames to source content.",
"line": 10,
"source": "@param {Object} opts.sources A hash of source filenames to source content."
},
{
"tag": "return",
"type": "Object",
"name": "An",
"optional": false,
"description": "object with `code` and `map` strings,\nwhere `map` can be null.",
"line": 12,
"source": "@return {Object} An object with `code` and `map` strings,\nwhere `map` can be null."
}
],
"line": 0,
"description": "Given an AST and a set of options, generate the corresponding JavaScript\nsource and optional sourcemap string.",
"source": "Given an AST and a set of options, generate the corresponding JavaScript\nsource and optional sourcemap string.\n\n@param {Object} opts The generation options.\n@param {AST} opts.ast The AST to render.\n@param {Boolean} opts.sourceMaps Whether to render a source-map.\n@param {String} opts.sourceMapTarget The output filename.\n@param {Boolean} opts.pretty Whether to output formatted JS.\n@param {Boolean} opts.includeComments Whether to include comments in the output.\n@param {Object} opts.sources A hash of source filenames to source content.\n\n@return {Object} An object with `code` and `map` strings,\nwhere `map` can be null."
}
},
"children": [],
"markdown": "## generateJsCode\n \nGiven an AST and a set of options, generate the corresponding JavaScript\nsource and optional sourcemap string.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **opts** | Object | The generation options. |\n| Parameter | **opts.ast** | AST | The AST to render. |\n| Parameter | **opts.sourceMaps** | Boolean | Whether to render a source-map. |\n| Parameter | **opts.sourceMapTarget** | String | The output filename. |\n| Parameter | **opts.pretty** | Boolean | Whether to output formatted JS. |\n| Parameter | **opts.includeComments** | Boolean | Whether to include comments in the output. |\n| Parameter | **opts.sources** | Object | A hash of source filenames to source content. |\n| Return value | | Object | An object with `code` and `map` strings, where `map` can be null. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/generate-raw.js#L22-L44).\n\n ",
"size": 1
}
],
"markdown": "## generateRawBundles\n \nGiven a compiled bundle object, return an array of one or more bundles with\nnew `raw` property. This raw property should be generated from the bundle's\nAST or equivalent intermediate representation.\n\nThis is a one-to-many transformation because it is quite possible for multiple\noutput files to result from a single bundle object. The canonical example (and\ndefault behavior of this function, when sourcemaps are enabled) is for one\nbundle to result in a `.js` file and a `.map` file.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundle** | Object | Bundle object without `raw` property. |\n| Return value | | Array | Array of bundle objects. At minimum, these bundle objects should have a `raw` property - a string representation of the file to be written to disk - and a `dest` property - the relative filepath of the file to be written to disk. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/bundles/generate-raw.js#L64-L92).\n\n "
}
],
"markdown": "## emitRawBundles\n \nGiven an array of compiled bundles and a moduleHash-to-URL lookup dictionary,\ngenerate a new array of bundles with new `ast` and `raw` properties.\n\nSome compiled bundles (as internally represented) will result in more than\none output file. The canonical example of this is a JS file and its source-map.\nPlugins may also implement mechanisms to output multiple files per bundle.\n\nThis one-to-many relationship is defined by the generateRawBundles method, which\nmay output an array of raw bundles.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundlesArr** | Array | Compiled bundles. |\n| Parameter | **urls** | Object | moduleHash-to-URL lookup dictionary. |\n| Return value | | Array | Bundles with new `raw` properties. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/index.js#L66-L74).\n\n "
}
],
"markdown": "## buildOutput\n \nReduces an array of compiled bundles into a compilation object. This compilation\nobject will have three key/value pairs:\n\n- **cache:** populated from the compilation process\n- **bundles:** a mapping of destination paths to `raw` code\n- **opts:** the original options passed to the compilation\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Parameter | **bundles** | Array | Compiled bundles, generated by generateBundles. |\n| Return value | | Promise | Compilation object. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/index.js#L88-L100).\n\n "
}
],
"markdown": "## compile\n \nLoads, transforms, and bundles an application using the provided options.\nModules are collected and transformed, bundles are formed from those modules,\nand those bundles are finally converted into a format that can be written\nto disk or served over HTTP.\n\n \n| | Name | Type | Description |\n| --- | ---- | ---- | ----------- |\n| Return value | | Promise | Resolves to an object with three properties: `bundles`, `opts`, and `cache`. |\n\n\n This Pluggable's definition can be found [here](http://github.com/interlockjs/interlock/tree/master/src/compile/index.js#L111-L119).\n\n "
}