EmberApp.prototype._processedVendorTree = function() {
if(this._cachedVendorTree) {
return this._cachedVendorTree;
}
var addonTrees = mergeTrees(this.addonTreesFor('addon'));
addonTrees = mergeTrees([
concatFiles(addonTrees, { inputFiles: ['*.css'], outputFile: '/addons.css', allowNone: true }),
concatFiles(addonTrees, { inputFiles: ['*.js'], outputFile: '/addons.js', allowNone: true })
].concat(this.addonTreesFor('vendor')), {
overwrite: true
});
var trees = this._importTrees.concat(addonTrees);
if (this.trees.vendor) {
trees.push(this.trees.vendor);
}
var mergedVendor = mergeTrees(trees, {
overwrite: true,
description: 'TreeMerger (vendor)'
});
this._cachedVendorTree = pickFiles(mergedVendor, {
srcDir: '/',
destDir: 'vendor/'
});
return this._cachedVendorTree;
};
function getPackageTrees(packageName) {
// Lib
var lib = moveFile(pickFiles('packages/' + packageName + '/lib', {
srcDir: '/',
destDir: '/' + packageName
}), {
srcFile: packageName + '/main.js',
destFile: '/' + packageName + '.js'
});
var transpiledLib = transpileES6(lib, { moduleName: true });
var concatenatedLib = concatFiles(transpiledLib, {
inputFiles: ['**/*.js'],
outputFile: '/' + packageName + '.amd.js'
});
// Tests
var testSupports = pickFiles('test/support', {
srcDir: '/',
destDir: '/test/support'
});
var tests = pickFiles('packages/' + packageName + '/tests', {
srcDir: '/',
destDir: '/' + packageName + '-tests'
});
var jsHintLib = jsHint(lib, { destFile: '/' + packageName + '-jshint/lib.js' });
var jsHintTests = jsHint(tests, { destFile: '/' + packageName + '-jshint/tests.js' });
var allTests = mergeTrees([testSupports, tests, jsHintLib, jsHintTests]);
var transpiledTests = transpileES6(allTests, { moduleName: true });
var concatenatedTests = concatFiles(transpiledTests, {
inputFiles: ['**/*.js'],
outputFile: '/test/' + packageName + '-tests.amd.js'
});
return [concatenatedLib, concatenatedTests];
}
Perfome.prototype.javascript = function() {
var benchmarksJs = this.benchmarks();
var es6 = compileES6(benchmarksJs, {
loaderFile: 'assets/perfome/loader.js',
inputFiles: [
this.name + '/**/*.js'
],
wrapInEval: this.options.wrapInEval,
outputFile: '/assets/' + this.name + '.js',
});
var implementationsJs = concatFiles(benchmarksJs, {
inputFiles: ['implementations/**/*.js'],
outputFile: '/assets/implementations.js',
separator: EOL + ';'
});
var dependenciesJs = concatFiles(benchmarksJs, {
inputFiles: ['dependencies/**/*.js'],
outputFile: '/assets/dependencies.js',
separator: EOL + ';'
});
return mergeTrees([dependenciesJs, implementationsJs, es6]);
};
/*
* Concatenates all test support files into one, as follows:
*
* Given an input tree that looks like:
*
* ```
* addon-tree-output/
* bower_components/
* the-best-app-ever/
* tests/
* ├── acceptance/
* ├── helpers/
* ├── index.html
* ├── integration/
* ├── test-helper.js
* └── unit/
* vendor/
* ```
*
* Returns:
*
* ```
* assets/
* test-support.js
* test-support.map (if sourcemaps are enabled)
* test-support.css
* ```
*
* @private
* @method packageTestFiles
* @return {BroccoliTree}
*/
packageTestFiles(tree, coreTestTree) {
let testSupportPath = this.distPaths.testSupportJsFile;
testSupportPath = testSupportPath.testSupport || testSupportPath;
let emberCLITree = this.packageEmberCliInternalFiles();
let headerFiles = [].concat(
'vendor/ember-cli/test-support-prefix.js',
this.legacyTestFilesToAppend
);
let inputFiles = ['addon-test-support/**/*.js'];
let footerFiles = ['vendor/ember-cli/test-support-suffix.js'];
let external = this.applyCustomTransforms(tree);
let baseMergedTree = mergeTrees([emberCLITree, tree, external, coreTestTree], {
overwrite: true,
});
let testJs = concat(baseMergedTree, {
headerFiles,
inputFiles,
footerFiles,
outputFile: testSupportPath,
annotation: 'Concat: Test Support JS',
allowNone: true,
});
let testemPath = path.join(__dirname, 'testem');
testemPath = path.dirname(testemPath);
let testemTree = new Funnel(new UnwatchedDir(testemPath), {
files: ['testem.js'],
annotation: 'Funnel (testem)',
});
let sourceTrees = [
testemTree,
testJs,
];
if (this.vendorTestStaticStyles.length > 0) {
sourceTrees.push(
concat(tree, {
headerFiles: this.vendorTestStaticStyles,
outputFile: this.distPaths.testSupportCssFile,
annotation: 'Concat: Test Support CSS',
})
);
}
return mergeTrees(sourceTrees, {
overwrite: true,
annotation: 'TreeMerger (testFiles)',
});
}
module.exports = function() {
var app = new StubApp({
name: 'twiddle',
sourcemaps: {
enabled: false
},
minifyCSS: {
enabled: false,
},
minifyJS: {
enabled: false
},
trees: {
app: new EmptyTree(),
styles: new EmptyTree(['app.css', 'app.scss']),
templates: new EmptyTree(),
public: new EmptyTree()
}
});
var addonTree = concat(app.addonTree(), {
inputFiles: '**/*.js',
outputFile: 'vendor/addons.js'
});
var fullTree = mergeTrees([app.appAndDependencies(), app.styles(), app.addonTree(), addonTree], { overwrite: true });
return mergeTrees([
concat(fullTree, {
headerFiles: importedCssFiles,
inputFiles: ['**/*.css'],
outputFile: '/addon.css',
allowNone: false,
sourceMapConfig: { enabled: false },
annotation: 'Concat: Addon CSS'
}),
new Funnel(app.otherAssets(), {
srcDir:'assets',
destDir:'.',
allowEmpty:true
}),
concat(fullTree, {
headerFiles: importedJsFiles.concat(app.legacyFilesToAppend || []).concat(['vendor/addons.js']),
inputFiles: ['twiddle/**/*.js'],
outputFile: '/addon.js',
allowNone: true,
sourceMapConfig: { enabled: false },
annotation: 'Concat: Addon JS'
})
]);
};
EmberApp.prototype.testFiles = function() {
var testSupportPath = this.options.outputPaths.testSupport.js;
var external = this._processedExternalTree();
var emberCLITree = this._processedEmberCLITree();
var testJs = concatFiles(external, {
inputFiles: this.legacyTestFilesToAppend,
outputFile: testSupportPath
});
testJs = concatFiles(mergeTrees([testJs, emberCLITree]), {
inputFiles: ['vendor/ember-cli/test-support-suffix.js', testSupportPath.slice(1)],
outputFile: testSupportPath
});
var testCss = concatFiles(external, {
inputFiles: this.vendorTestStaticStyles,
outputFile: this.options.outputPaths.testSupport.css
});
var testemPath = path.join(__dirname, 'testem');
testemPath = path.dirname(testemPath);
var testemTree = pickFiles(unwatchedTree(testemPath), {
files: ['testem.js'],
srcDir: '/',
destDir: '/'
});
if (this.options.fingerprint && this.options.fingerprint.exclude) {
this.options.fingerprint.exclude.push('testem');
}
var testLoader = pickFiles(external, {
files: ['test-loader.js'],
srcDir: '/' + this.bowerDirectory + '/ember-cli-test-loader',
destDir: '/assets/'
});
var sourceTrees = [
testJs,
testCss,
testLoader,
testemTree
];
return mergeTrees(sourceTrees, {
overwrite: true,
description: 'TreeMerger (testFiles)'
});
};
EmberApp.prototype.testFiles = memoize(function() {
var vendor = this._processedVendorTree();
var testJs = concatFiles(vendor, {
inputFiles: this.legacyTestFilesToAppend,
outputFile: '/assets/test-support.js'
});
var testCss = concatFiles(vendor, {
inputFiles: this.vendorTestStaticStyles,
outputFile: '/assets/test-support.css'
});
var testemPath = path.join(__dirname, 'testem');
testemPath = path.dirname(testemPath);
var testemTree = pickFiles(unwatchedTree(testemPath), {
files: ['testem.js'],
srcDir: '/',
destDir: '/'
});
if (this.options.fingerprint && this.options.fingerprint.exclude) {
this.options.fingerprint.exclude.push('testem');
}
var iconsTree = pickFiles(this.trees.vendor, {
files: ['passed.png', 'failed.png'],
srcDir: '/ember-qunit-notifications',
destDir: '/assets/'
});
var testLoader = pickFiles(this.trees.vendor, {
files: ['test-loader.js'],
srcDir: '/ember-cli-test-loader',
destDir: '/assets/'
});
var sourceTrees = [
testJs,
testCss,
testemTree,
iconsTree,
testLoader
];
return mergeTrees(sourceTrees, {
overwrite: true,
description: 'TreeMerger (testFiles)'
});
});
codemirrorAssets = function () {
let codemirrorFiles = [
// 'lib/codemirror.css',
'theme/xq-light.css',
'lib/codemirror.js',
'mode/htmlmixed/htmlmixed.js',
'mode/xml/xml.js',
'mode/css/css.js',
'mode/javascript/javascript.js'
];
if (environment === 'test') {
return {import: codemirrorFiles};
}
let config = {};
config.public = {
include: codemirrorFiles,
destDir: '/',
processTree(tree) {
let jsTree = concat(tree, {
outputFile: 'assets/codemirror/codemirror.js',
headerFiles: ['lib/codemirror.js'],
inputFiles: ['mode/**/*'],
sourceMapConfig: {enabled: false}
});
let cssTree = concat(tree, {
outputFile: 'assets/codemirror/codemirror.css',
inputFiles: ['**/*.css']
});
if (isProduction) {
jsTree = uglify(jsTree);
cssTree = new CleanCSS(cssTree);
}
return mergeTrees([tree, jsTree, cssTree]);
}
};
// put the files in vendor ready for importing into the test-support file
if (environment === 'development') {
config.vendor = codemirrorFiles;
}
return config;
};
/**
* This is a copy of all of the emblem files, but not rolled up into a single file.
* This allows for unit tests to run against pieces of the final app.
*/
function buildEmblemFiles() {
const appFiles = new Funnel(emblemTree, {
include: ['**/*.js']
});
const transpiledAppFiles = babel(appFiles, {
plugins: ['@babel/plugin-transform-modules-amd'],
moduleIds: true,
// Transforms /index.js files to use their containing directory name
getModuleId: name => {
const shortenedName = name.replace(currentDir + '/', '');
return shortenedName;
}
});
const testAppBundle = concat(transpiledAppFiles, {
inputFiles: '**/*.js',
outputFile: outputDir + 'emblem.js',
sourceMapConfig: { enabled: false },
});
return broccoliStew.mv(testAppBundle, outputDir + 'test-app');
}
EmberApp.prototype.javascript = function() {
var applicationJs = this.appAndDependencies();
var legacyFilesToAppend = this.legacyFilesToAppend;
var es6 = compileES6(applicationJs, {
loaderFile: 'assets/ember-cli/loader.js',
ignoredModules: Object.keys(this.importWhitelist),
inputFiles: [
this.name + '/**/*.js'
],
wrapInEval: this.options.wrapInEval,
outputFile: this.options.outputPaths.app.js,
});
var vendor = concatFiles(applicationJs, {
inputFiles: legacyFilesToAppend.concat(['vendor/addons.js']),
outputFile: this.options.outputPaths.vendor.js,
separator: EOL + ';'
});
var vendorAndApp = mergeTrees([vendor, es6]);
if (this.options.minifyJS.enabled === true) {
var options = this.options.minifyJS.options || {};
return uglifyJavaScript(vendorAndApp, options);
} else {
return vendorAndApp;
}
};
vendorJavascript(thirdPartyDeps) {
let vendorJs = browserify('node_modules', {
browserify: {
debug: false
},
bundles: {
'scripts/vendor.js': {
entryPoints: [],
require: thirdPartyDeps
}
}
});
let externalJs = funnel('./', {
include: this.otherJavascriptFiles
});
let allVendorJs = mergeTrees([vendorJs, externalJs]);
return concat(allVendorJs, {
inputFiles: ['**/*'],
outputFile: 'scripts/vendor.js',
allowEmpty: true,
allowNone: true
});
}
treeForPublic: function(tree) {
var relativeDir = this.project.relativeDir || '.',
splashFiles = [
'splash_utils/es5-shim-fixes.js',
'node_modules/es5-shim/es5-shim.js',
'node_modules/mutationobserver-shim/MutationObserver.js',
'vendor/mutation-summary.js',
'vendor/tree-mirror.js',
'splash_utils/local-storage-shim.js',
'splash_utils/inject_this.js'
].map(function(p) { return '../'+p; });
var splashTree = concat(relativeDir + '/splash_utils', {
inputFiles: splashFiles,
outputFile: '/splash_content_scripts/combined.js',
wrapInFunction: false,
header: '(function(){',
footer: '})();'
});
return mergeTrees([
funnel(tree, { destDir: '/' }),
splashTree
]);
},
}).map(function (templatesTree) {
return concat(templatesTree.tree, {
outputFile: `${templatesTree.name}/templates.js`,
inputFiles: [
"**/*.js"
],
header: `
'use strict';
System.register(['handlebars'], function (_export) {
if (typeof Handlebars === 'undefined') { var Handlebars; }
if (typeof templates === 'undefined') { var templates = {};}
return {
setters: [function (_handlebars) {
Handlebars = _handlebars['default'];
}],
execute: function () {
`,
footer: `
_export('default', templates);
}
};
});
`
});
})
function generateNamedAMDTree(inputTree, outputFile) {
var workingTree = compileModules(inputTree, {
inputFiles: ['**/*.js'],
output: '/',
formatter: new AMDFormatter()
});
workingTree = concat(mergeTrees([workingTree, configTree]), {
inputFiles: [
'versionTemplate.txt',
'**/*.js'
],
outputFile: '/' + outputFile
});
workingTree = replace(workingTree, {
files: [ outputFile ],
pattern: {
match: /VERSION_PLACEHOLDER_STRING/g,
replacement: calculateVersion()
}
});
return workingTree;
}
/*
Concatenates all javascript Broccoli trees into one, as follows:
Given an input tree that looks like:
```
addon-tree-output/
ember-ajax/
ember-data/
ember-engines/
ember-resolver/
...
bower_components/
usertiming/
sinonjs/
...
the-best-app-ever/
components/
config/
helpers/
routes/
...
vendor/
...
babel-core/
...
broccoli-concat/
...
ember-cli-template-lint/
...
```
Produces a tree that looks like:
```
assets/
the-best-app-ever.js
the-best-app-ever.map (if sourcemaps are enabled)
vendor.js
vendor.map (if sourcemaps are enabled)
```
@method bundleAppJs
@param {Tree} applicationAndDepsTree Broccoli tree with application and dependencies
@return {Tree} Concatenated tree (application and dependencies).
*/
bundleJs(applicationAndDepsTree, options) {
options = options || {};
let scriptOutputFiles = options.scriptOutputFiles;
let appJs = concat(applicationAndDepsTree, {
inputFiles: [`${this.name}/**/*.js`],
headerFiles: [
'vendor/ember-cli/app-prefix.js',
],
footerFiles: [
'vendor/ember-cli/app-suffix.js',
'vendor/ember-cli/app-config.js',
'vendor/ember-cli/app-boot.js',
],
outputFile: this.appOutputPath,
annotation: 'Concat: App',
sourceMapConfig: this.sourcemaps,
});
if (!this.isBabelAvailable) {
appJs = processModulesOnly(appJs, 'Babel: Modules for app/');
}
let vendorFiles = this.getVendorFiles(applicationAndDepsTree, scriptOutputFiles);
return mergeTrees(vendorFiles.concat(appJs), {
annotation: 'TreeMerger (vendor & appJS)',
});
}
function buildTestTree() {
const qUnitShim = new Funnel('lib/build', {
files: ['qunit-shim.js']
});
const testFiles = new Funnel('tests', {
include: ['**/*.js']
});
const transpiledTestFiles = babel(testFiles, {
plugins: ['@babel/plugin-transform-modules-amd'],
moduleIds: true,
// Transforms /index.js files to use their containing directory name
getModuleId: name => {
const shortenedName = name.replace(currentDir, 'tests');
return shortenedName;
}
});
const testBundle = concat(mergeTrees([transpiledTestFiles, qUnitShim]), {
inputFiles: '**/*.js',
outputFile: outputDir + 'tests.js',
sourceMapConfig: { enabled: false },
});
const nonJsTree = new Funnel('tests', {
exclude: ['**/*.js']
});
return mergeTrees([
qUnitShim,
testBundle,
nonJsTree,
]);
}
/*
Creates an array of Broccoli concatenates trees to be included into `vendor.js` file.
Given an input tree that looks like:
```
addon-tree-output/
ember-ajax/
ember-data/
ember-engines/
ember-resolver/
...
bower_components/
usertiming/
sinonjs/
...
the-best-app-ever/
components/
config/
helpers/
routes/
...
vendor/
...
babel-core/
...
broccoli-concat/
...
ember-cli-template-lint/
...
```
And a map that looks like:
{
'assets/vendor.js': [
'vendor/ember-cli-shims/app-shims.js',
'vendor/loader/loader.js',
'vendor/ember-resolver/legacy-shims.js',
...
]
}
Produces an array of Broccoli trees to be included into `vendor.js`.
@private
@method getVendorFiles
@param {Tree} applicationAndDepsTree Broccoli tree with application and dependencies
@param {Object} scriptOutputFiles A map with a key as a file name and list of files to include into `<file-name>.js`
@return {Array} Array of trees to be included into resulting `vendor.js` file.
*/
getVendorFiles(applicationAndDepsTree, scriptOutputFiles) {
let vendorFiles = [];
for (let outputFile in scriptOutputFiles) {
let isMainVendorFile = outputFile === this.vendorFilePath;
let headerFiles = scriptOutputFiles[outputFile];
let inputFiles = isMainVendorFile ? ['addon-tree-output/**/*.js'] : [];
let footerFiles = isMainVendorFile ? ['vendor/ember-cli/vendor-suffix.js'] : [];
vendorFiles.push(
concat(applicationAndDepsTree, {
headerFiles,
inputFiles,
footerFiles,
outputFile,
allowNone: true,
separator: '\n;',
annotation: `Concat: Vendor ${outputFile}`,
sourceMapConfig: this.sourcemaps,
})
);
}
return vendorFiles;
}
}].map(config => {
const baseTree = sourceTree(pathConfig, config.moduleType);
const bareTree = concat(mergeTrees([baseTree].concat(config.additionalTrees)), Object.assign({
inputFiles: ['**/*.js'],
outputFile: `${pkg.name}.${config.name}.js`,
}, config.concatOptions));
const polyfilledLibTree = concat(mergeTrees([polyfillTree, bareTree]), {
headerFiles: ['polyfills.js'],
inputFiles: ['**/*.js'],
outputFile: `${pkg.name}.polyfilled.${config.name}.js`,
});
return mergeTrees([bareTree, polyfilledLibTree]);
});
/*
Resolves dependencies for ember-runtime and compiles / concats them to /ember-runtime.js
Dependency graph looks like this:
```
'ember-runtime': {vendorRequirements: ['rsvp'], requirements: ['container', 'ember-metal']}
```
*/
function buildRuntimeTree() {
es6Package('ember-runtime');
var runtimeTrees = [packages['ember-runtime'].trees.lib];
var runtimeVendorTrees = packages['ember-runtime'].vendorRequirements.map(function(req){ return vendoredPackages[req];});
packages['ember-runtime'].requirements.forEach(function(req){
es6Package(req);
runtimeTrees.push(packages[req].trees.lib);
(packages[req].vendorRequirements || []).forEach(function(vreq) {
runtimeVendorTrees.push(vendoredPackages[vreq]);
});
});
var compiledRuntime = concatES6(mergeTrees(runtimeTrees), {
includeLoader: true,
bootstrapModule: 'ember-runtime',
vendorTrees: mergeTrees(runtimeVendorTrees),
inputFiles: ['**/*.js'],
destFile: '/ember-runtime.js'
});
var exportsTree = writeFile('export-ember', ';module.exports = Ember;\n');
return concat(mergeTrees([compiledRuntime, exportsTree]), {
wrapInEval: false,
inputFiles: ['ember-runtime.js', 'export-ember'],
outputFile: '/ember-runtime.js'
});
}
function collapse(tree, outputFileName) {
var loaderDir = path.join(__dirname, '..', 'node_modules', 'loader.js', 'lib', 'loader');
var loader = new Funnel(loaderDir, {
include: ['loader.js']
});
var emberShim = new Funnel(__dirname, {
include: ['ember-shim.js']
});
var generatorDir = path.join(__dirname, '..', 'generators');
var license = new Funnel(generatorDir, {include: ['license.js']});
license = versionReplace(license);
var emberDataShimsPath = path.join(__dirname, 'ember-data-shims.js');
var emberDataShims = fs.readFileSync(emberDataShimsPath, { encoding: 'utf8' });
var emberDataInitialierPath = path.join(__dirname, '../tests/ember-data-initializers.js');
var emberDataInitialier = fs.readFileSync(emberDataInitialierPath, { encoding: 'utf8' });
var withLoader = merge([tree, loader, license, emberShim]);
return concat(withLoader, {
inputFiles: ['license.js', 'loader.js', '**/*.js'],
outputFile: '/' + outputFileName,
header: '(function(){ \n"use strict";\n',
footer: '\nrequire("ember-data");\n})();\n' + emberDataShims + emberDataInitialier
});
}
EmberApp.prototype.styles = memoize(function() {
var addonTrees = this.addonTreesFor('styles');
var vendor = this._processedVendorTree();
var styles = pickFiles(this.trees.styles, {
srcDir: '/',
destDir: '/app/styles'
});
var trees = [vendor].concat(addonTrees);
trees.push(styles);
var stylesAndVendor = mergeTrees(trees, {
description: 'TreeMerger (stylesAndVendor)'
});
var processedStyles = preprocessCss(stylesAndVendor, '/app/styles', '/assets');
var vendorStyles = concatFiles(stylesAndVendor, {
inputFiles: this.vendorStaticStyles,
outputFile: '/assets/vendor.css',
description: 'concatFiles - vendorStyles'
});
if (this.env === 'production' && this.options.minifyCSS.enabled === true) {
var options = this.options.minifyCSS.options || {};
processedStyles = preprocessMinifyCss(processedStyles, options);
vendorStyles = preprocessMinifyCss(vendorStyles, options);
}
return mergeTrees([
processedStyles,
vendorStyles
], {
description: 'styles'
});
});
module.exports = function(broccoli) {
var concatenate = require('broccoli-concat'),
uglify = require('broccoli-uglify-js'),
mergeTrees = require('broccoli-merge-trees');
var sourceTree = 'src';
var concatenated = concatenate(sourceTree, {
inputFiles: [
'vendor/lru.js',
'base.js',
'remote_expiry.js',
'identity_map.js',
'fetch.js',
'ember-resource.js',
'debug_adapter.js'
],
outputFile: '/ember-resource.js'
});
var minified = uglify(concatenated, {
targetExtension: 'min.js'
});
return mergeTrees([concatenated, minified]);
};
TemplateLinter.create = function(inputNode, options) {
options = options || {};
if (!options.groupName) {
return new TemplateLinter(inputNode, options);
}
if (testGeneratorNames.indexOf(options.testGenerator) === -1) {
throw new Error(`The "groupName" options can only be used with a "testGenerator" option of: ${testGeneratorNames}`);
}
let testGenerator = testGenerators[options.testGenerator];
let headerName = 'TemplateLint';
if (options.groupName !== 'templates') {
headerName += ` | ${options.groupName}`;
}
let header = testGenerator.suiteHeader(headerName);
let footer = testGenerator.suiteFooter();
let lint = new TemplateLinter(inputNode, options);
return concat(lint, {
outputFile: `/${options.groupName}.template.lint-test.js`,
header,
inputFiles: ['**/*.template.lint-test.js'],
footer,
sourceMapConfig: { enabled: false },
allowNone: true
});
};
function concatAs(outputFile) {
return merge([
concat(merge([es6Promise, header]), {
headerFiles: ['config/versionTemplate.txt'],
inputFiles: ['es6-promise.js'],
outputFile: outputFile
}),
concat(merge([es6PromiseAuto, header]), {
headerFiles: ['config/versionTemplate.txt'],
inputFiles: ['es6-promise.auto.js'],
outputFile: outputFile.replace('es6-promise', 'es6-promise.auto'),
}),
]);
}
function getPackageTrees(packageName) {
// Lib
var libRoot = 'packages/' + packageName + '/lib';
var transpiledLibCJS = moveFile(pickFiles(esNext(transpileES6(libRoot, { moduleName: true, type: 'cjs' })), {
srcDir: '/',
destDir: '/cjs/handlebars-serializer'
}), {
srcFile: '/cjs/' + packageName + '/main.js',
destFile: '/cjs/' + packageName + '.js'
});
var lib = moveFile(pickFiles(libRoot, {
srcDir: '/',
destDir: '/' + packageName
}), {
srcFile: packageName + '/main.js',
destFile: '/' + packageName + '.js'
});
var transpiledLibAMD = esNext(transpileES6(lib, { moduleName: true }));
var concatenatedLib = concatFiles(transpiledLibAMD, {
inputFiles: ['**/*.js'],
outputFile: '/amd/' + packageName + '.js'
});
// Tests
var testSupports = pickFiles('test/support', {
srcDir: '/',
destDir: '/test/support'
});
var tests = pickFiles('packages/' + packageName + '/tests', {
srcDir: '/',
destDir: '/' + packageName + '-tests'
});
var jsHintLib = jsHint(lib, { destFile: '/' + packageName + '-jshint/lib.js' });
var jsHintTests = jsHint(tests, { destFile: '/' + packageName + '-jshint/tests.js' });
var allTests = mergeTrees([testSupports, tests, jsHintLib, jsHintTests]);
var transpiledTests = esNext(transpileES6(allTests, { moduleName: true }));
var concatenatedTests = concatFiles(transpiledTests, {
inputFiles: ['**/*.js'],
outputFile: '/test/' + packageName + '-tests.amd.js'
});
return [concatenatedLib, concatenatedTests, transpiledLibCJS];
}
/*
* Compiles application css files, runs pre/post-processors hooks on the them,
* concatenates them into one application and vendor files and returns a
* single tree.
*
* Given an input tree that looks like:
*
* ```
* addon-tree-output/
* ...
* bower_components/
* hint.css/
* ...
* the-best-app-ever/
* styles/
* ...
* vendor/
* font-awesome/
* ...
* ```
*
* Returns:
*
* ```
* assets/
* the-best-app-ever.css
* vendor.css
* ```
*
* @private
* @method packageStyles
* @return {BroccoliTree}
*/
packageStyles(tree) {
if (this._cachedProcessedStyles === null) {
let cssMinificationEnabled = this.minifyCSS.enabled;
let options = {
outputPaths: this.distPaths.appCssFile,
registry: this.registry,
minifyCSS: this.minifyCSS.options,
};
let stylesAndVendor = callAddonsPreprocessTreeHook(this.project, 'css', tree);
stylesAndVendor = this._debugTree(stylesAndVendor, 'mu-layout:addonsPreprocessTree:css');
let preprocessedStyles = preprocessCss(
stylesAndVendor,
this.isModuleUnificationEnabled ? 'src/ui/styles' : '/app/styles',
'/assets',
options
);
preprocessedStyles = this._debugTree(preprocessedStyles, 'mu-layout:preprocess:css');
let vendorStyles = [];
for (let outputFile in this.styleOutputFiles) {
let isMainVendorFile = outputFile === this.distPaths.vendorCssFile;
let headerFiles = this.styleOutputFiles[outputFile];
let inputFiles = isMainVendorFile ? ['addon-tree-output/**/*.css'] : [];
vendorStyles.push(
concat(stylesAndVendor, {
headerFiles,
inputFiles,
outputFile,
allowNone: true,
annotation: `Concat: Vendor Styles${outputFile}`,
})
);
}
vendorStyles = mergeTrees(vendorStyles, {
annotation: 'TreeMerger (vendorStyles)',
overwrite: true,
});
if (cssMinificationEnabled === true) {
options.minifyCSS.registry = options.registry;
preprocessedStyles = preprocessMinifyCss(preprocessedStyles, options.minifyCSS);
vendorStyles = preprocessMinifyCss(vendorStyles, options.minifyCSS);
}
this._cachedProcessedStyles = callAddonsPostprocessTreeHook(
this.project,
'css',
mergeTrees([preprocessedStyles, vendorStyles], {
annotation: 'Packaged Styles',
})
);
}
return this._cachedProcessedStyles;
}
EmberApp.prototype.concatFiles = function(tree, options) {
this.project.ui.writeDeprecateLine('EmberApp.concatFiles() is deprecated. Please use the `broccoli-concat` module directly.',
arguments[2] === SECRET_DEPRECATION_PREVENTION_SYMBOL);
options.sourceMapConfig = this.options.sourcemaps;
return concat(tree, options);
};
module.exports = function(defaults) {
var concatenate = require('broccoli-concat');
var merge = require('broccoli-merge-trees');
var app = new EmberApp({fingerprint: {enabled: false}});
// Use `app.import` to add additional libraries to the generated
// output files.
//
// If you need to use different assets in different
// environments, specify an object as the first parameter. That
// object's keys should be the environment name and the values
// should be the asset to use in that environment.
//
// If the library that you are including contains AMD or ES6
// modules that you would like to import into your application
// please specify an object with the list of modules as keys
// along with the exports of each module as its value.
app.import("vendor/authentication.js");
app.import("vendor/html-parser.js");
app.import("vendor/meta_hack.js");
app.import('bower_components/ember/ember-template-compiler.js');
app.import('bower_components/js-yaml/dist/js-yaml.js');
app.import('bower_components/moment/moment.js');
app.import('bower_components/js-base64/base64.js');
app.import('bower_components/jquery-sortable/source/js/jquery-sortable.js');
app.import('bower_components/jt.timepicker/jquery.timepicker.js');
app.import('bower_components/jquery.scrollTo/jquery.scrollTo.js');
var appTree = app.toTree();
var jsRelease = concatenate(appTree, {
inputFiles : ['assets/vendor.js','assets/cms.js'],
outputFile : '/cms.js',
header : '/** Copyright MakerLoop Inc. 2015 **/'
});
var cssRelease = concatenate(appTree, {
inputFiles : ['assets/vendor.css','assets/cms.css'],
outputFile : '/cms.css',
header : '/** Copyright MakerLoop Inc. 2015 **/'
});
return merge([appTree, jsRelease, cssRelease]);
};
EmberApp.prototype.javascript = function() {
var applicationJs = this.appAndDependencies();
var legacyFilesToAppend = this.legacyFilesToAppend;
var appOutputPath = this.options.outputPaths.app.js;
var modulePrefix = this.project.config(this.env).modulePrefix;
this.importWhitelist[modulePrefix + '/config/environment'] = [
'default'
];
var es6 = compileES6(applicationJs, {
loaderFile: 'vendor/ember-cli/loader.js',
ignoredModules: this._isIgnoredModule.bind(this),
inputFiles: [
this.name + '/**/*.js'
],
wrapInEval: this.options.wrapInEval,
outputFile: appOutputPath,
});
es6 = concatFiles(mergeTrees([es6, this._processedEmberCLITree()]), {
inputFiles: [appOutputPath.slice(1), 'vendor/ember-cli/app-suffix.js'],
outputFile: appOutputPath
});
var inputFiles = ['vendor/ember-cli/vendor-prepend.js']
.concat(legacyFilesToAppend)
.concat('vendor/addons.js');
var vendor = concatFiles(applicationJs, {
inputFiles: inputFiles,
outputFile: this.options.outputPaths.vendor.js,
separator: EOL + ';'
});
var vendorAndApp = mergeTrees([vendor, es6]);
if (this.options.minifyJS.enabled === true) {
var options = this.options.minifyJS.options || {};
return uglifyJavaScript(vendorAndApp, options);
} else {
return vendorAndApp;
}
};
var testTree = (function() {
var testAmd = (function() {
var tree = pickFiles('test', {
srcDir: '/',
destDir: 'coalesce-test'
});
tree = coffee(tree, {
bare: true
});
var transpiled = traceur(tree, {
moduleName: true,
modules: 'amd'
});
return concat(transpiled, {
inputFiles: ['**/*.js'],
outputFile: '/coalesce-test.amd.js'
});
})();
var testVendorJs = concat(vendor, {
inputFiles: [
'sinonjs/sinon.js',
'mocha/mocha.js',
'mocha-lazy-bdd/dist/mocha-lazy-bdd.js',
'chai/chai.js',
'jquery/dist/jquery.js',
'lodash/dist/lodash.js',
'loader/loader.js',
'traceur-runtime.js',
'backburner.amd.js'
],
outputFile: '/vendor.js'
});
var testVendorCss = pickFiles(vendor, {
srcDir: '/mocha',
files: ['mocha.css'],
destDir: '/'
});
var trees = mergeTrees([testVendorJs, testAmd, devAmd, 'test', testVendorCss]);
return pickFiles(trees, {
srcDir: '/',
files: [
'vendor.js',
'mocha.css',
'coalesce.amd.js',
'coalesce-test.amd.js',
'index.html'
],
destDir: 'test'
});
})();