destDir: '/'
});
var lib = pickFiles('lib', {
srcDir: '/',
files: ['**/*.js'],
destDir: '/'
});
var tests = pickFiles('tests', {
srcDir: '/',
files: ['test-support/*.js', '*.js'],
destDir: '/tests'
});
var main = mergeTrees([loader, klassy, lib, tests]);
main = compileES6(main, {
loaderFile: '/loader.js',
inputFiles: ['**/*.js'],
ignoredModules: ['ember'],
outputFile: '/assets/ember-test-helpers-tests.amd.js'
});
// --- Select and concat vendor / support files ---
var vendor = concat('bower_components', {
inputFiles: ['jquery/dist/jquery.js',
'handlebars/handlebars.js',
'ember/ember.js',
'ember-data/ember-data.js'],
outputFile: '/assets/vendor.js'
var concat = require("broccoli-concat");
var AMDFormatter = require("es6-module-transpiler-amd-formatter");
var source = pickFiles("src", {
srcDir: "/",
files: ["**/*.coffee", "**/*.js"],
destDir: "/flexure"
});
source = coffee(source, {
bare: true,
});
var AMDBuild = es6(source, {
formatter: new AMDFormatter()
});
AMDBuild = concat(AMDBuild, {
inputFiles: ["**/*.js"],
separator: "\n",
outputFile: "/ember-flexure.amd.js"
});
var globalBuild = es6(source, {
formatter: "bundle",
output: "ember-flexure.js"
});
module.exports = merge([globalBuild, AMDBuild]);
/* global require, module */
var browserify = require('broccoli-fast-browserify')
var cleanCss = require('broccoli-clean-css')
var compileLess = require('broccoli-less-single')
var concat = require('broccoli-concat')
var env = require('broccoli-env').getEnv()
var esTranspiler = require('broccoli-babel-transpiler')
var funnel = require('broccoli-funnel')
var mergeTrees = require('broccoli-merge-trees')
var uglify = require('broccoli-uglify-js')
var appJsTree = mergeTrees([ funnel('frontend/js'), funnel('backend/common') ])
var appPublic = funnel('frontend/public')
var appLessTree = funnel('frontend/less')
var appCss = compileLess(appLessTree, 'app.less', 'app.css')
var appJs = browserify(
esTranspiler(appJsTree, {})
, {
bundles: {
'app.js': {
entryPoints: [ 'app.js' ]
}
}
, externals: [ 'jquery' ]
}
)
var vendorTree = funnel('bower_components')
var vendorCss = compileLess(vendorTree, 'bootstrap/less/bootstrap.less', 'vendor.css')
var vendorJs = concat(
var mergeTrees = require('broccoli-merge-trees'),
unwatchedTree = require('broccoli-unwatched-tree'),
compileModules = require('./lib/compile-modules'),
graphModules = require('./lib/graph'),
cssWithMQs = require('./lib/css-with-mqs'),
stripMQs = require('./lib/css-strip-mqs'),
mapFiles = require('./lib/map-files');
var bower_components = unwatchedTree('bower_components/'),
node_modules = unwatchedTree('node_modules/');
var vendor = mergeTrees([
mapFiles(bower_components, {
'rainbow/js/': 'vendor/rainbow/'
}),
mapFiles(node_modules, {
'css-mediaquery/index.js' : 'vendor/css-mediaquery.js',
'handlebars/dist/handlebars.runtime.js': 'vendor/handlebars.runtime.js'
})
]);
var pub = 'public/';
// Calculate the ES6 module dependency graph.
var modGraph = graphModules(pub, {
basePath : 'js/',
resolveImports: true
});
// Compile ES6 Modules in `pub`.
pub = compileModules(pub, {
app.publicTree = function() {
var publicTree = app.oldPublic();
return mergeTrees([publicTree, envTree], { overwrite: true })
};
module.exports = function(_options) {
var options = _options || {};
var packages = __dirname + '/packages';
var tslintConfig = __dirname + '/tslint.json';
var bower = __dirname + '/bower_components';
var hasBower = existsSync(bower);
var babelOptions = buildBabelOptions(options);
var tsOptions = buildTSOptions();
var benchmarkTrees = [find(__dirname + '/bench', {
include: ['*.html'],
destDir: 'bench'
})];
var benchmarkPath = __dirname + '/node_modules/benchmark';
if (existsSync(benchmarkPath)) {
benchmarkTrees.push(find(benchmarkPath, {
include: ['benchmark.js'],
destDir: 'bench'
}));
}
var demos = find(__dirname + '/demos', {
include: ['*.html'],
destDir: 'demos'
});
var simpleDOMPath = path.dirname(require.resolve('simple-dom'));
var simpleDOM = find(simpleDOMPath, {
include: ['simple-dom.js']
});
/*
* ES6 Build
*/
var tokenizerPath = path.join(require.resolve('simple-html-tokenizer'), '..', '..', 'lib');
// TODO: WAT, why does { } change the output so much....
var HTMLTokenizer = find(tokenizerPath, { });
var tsTree = find(packages, {
include: ['**/*.ts'],
exclude: ['**/*.d.ts']
});
var tsLintTree = new TSLint(tsTree, {
configuration: tslintConfig
});
/* tslint:enable:no-unused-variable */
var transpiledTSLintTree = typescript(tsLintTree, tsOptions);
var jsTree = typescript(tsTree, tsOptions);
var libTree = find(jsTree, {
include: ['*/index.js', '*/lib/**/*.js']
});
libTree = merge([libTree, HTMLTokenizer, handlebarsInlinedTrees.compiler]);
var es6LibTree = mv(libTree, 'es6');
/*
* ES5 Named AMD Build
*/
libTree = transpile(libTree, babelOptions, 'ES5 Lib Tree');
var es5LibTree = mv(libTree, 'named-amd');
/*
* CommonJS Build
*/
tsOptions = buildTSOptions({
module: "commonjs",
target: "es5"
});
var cjsTree = typescript(tsTree, tsOptions);
// SimpleHTMLTokenizer ships as either ES6 or a single AMD-ish file, so we have to
// compile it from ES6 modules to CJS using TypeScript. broccoli-typescript-compiler
// only works with `.ts` files, so we rename the `.js` files to `.ts` first.
var simpleHTMLTokenizerLib = rename(tokenizerPath, '.js', '.ts');
var simpleHTMLTokenizerJSTree = typescript(simpleHTMLTokenizerLib, tsOptions);
var handlebarsPath = path.join(require.resolve('handlebars'), '..', '..', 'dist', 'cjs');
cjsTree = merge([cjsTree, simpleHTMLTokenizerJSTree, handlebarsPath, simpleDOM]);
// Glimmer packages require other Glimmer packages using non-relative module names
// (e.g., `glimmer-compiler` may import `glimmer-util` instead of `../glimmer-util`),
// which doesn't work with Node's module resolution strategy.
// As a workaround, naming the CommonJS directory `node_modules` allows us to treat each
// package inside as a top-level module.
cjsTree = mv(cjsTree, 'node_modules');
/*
* Anonymous AMD Build
*/
var glimmerCommon = find(libTree, {
include: [
'glimmer/**/*.js',
'glimmer-object/**/*.js',
'glimmer-object-reference/**/*.js',
'glimmer-reference/**/*.js',
'glimmer-util/**/*.js',
'glimmer-wire-format/**/*.js'
]
});
var glimmerRuntime = find(libTree, {
include: ['glimmer-runtime/**/*']
});
var glimmerCompiler = merge([
find(libTree, {
include: [
'glimmer-syntax/**/*.js',
'glimmer-compiler/**/*.js',
'simple-html-tokenizer/**/*.js',
'handlebars/**/*.js'
]
})
]);
var glimmerDemos = merge([
find(libTree, {
include: [
'glimmer-test-helpers/**/*.js',
'glimmer-demos/**/*.js',
]
})
]);
var glimmerBenchmarks = merge([
find(libTree, {
include: [
'glimmer-test-helpers/**/*.js',
'glimmer-benchmarks/**/*.js',
]
})
]);
var glimmerTests = merge([
transpiledTSLintTree,
find(jsTree, { include: ['*/tests/**/*.js'], exclude: ['glimmer-node/tests/**/*.js'] }),
find(jsTree, { include: ['glimmer-test-helpers/**/*.js'] })
]);
glimmerTests = transpile(glimmerTests, babelOptions, 'glimmer-tests');
// Test Assets
var testHarnessTrees = [
find(__dirname + '/tests', {
srcDir: '/',
files: [ 'index.html' ],
destDir: '/tests'
})
];
if (hasBower) {
testHarnessTrees.push(find(bower, {
srcDir: '/qunit/qunit',
destDir: '/tests'
}));
}
var testHarness = merge(testHarnessTrees);
glimmerCommon = concat(glimmerCommon, {
inputFiles: ['**/*.js'],
outputFile: '/amd/glimmer-common.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
glimmerCompiler = concat(glimmerCompiler, {
inputFiles: ['**/*.js'],
outputFile: '/amd/glimmer-compiler.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
glimmerRuntime = concat(glimmerRuntime, {
inputFiles: ['**/*.js'],
outputFile: '/amd/glimmer-runtime.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
glimmerDemos = concat(glimmerDemos, {
inputFiles: ['**/*.js'],
outputFile: '/amd/glimmer-demos.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
glimmerBenchmarks = concat(glimmerBenchmarks, {
inputFiles: ['**/*.js'],
outputFile: '/amd/glimmer-benchmarks.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
glimmerTests = concat(glimmerTests, {
inputFiles: ['**/*.js'],
outputFile: '/amd/glimmer-tests.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
var finalTrees = [
testHarness,
demos,
merge(benchmarkTrees),
glimmerCommon,
glimmerCompiler,
glimmerRuntime,
glimmerTests,
glimmerDemos,
glimmerBenchmarks,
cjsTree,
es5LibTree,
es6LibTree
];
if (hasBower) {
var loader = find(__dirname + '/node_modules', {
srcDir: '/loader.js/lib/loader',
files: [ 'loader.js' ],
destDir: '/assets'
});
finalTrees.push(loader);
}
return merge(finalTrees);
};
}),
pickFiles('bower_components/jquery/dist', {
files: ['jquery.js'],
srcDir: '/',
destDir: '/jquery'
}),
pickFiles('bower_components/handlebars', {
files: ['handlebars.js'],
srcDir: '/',
destDir: '/handlebars'
}),
];
bowerFiles = mergeTrees(bowerFiles);
var iifeStart = writeFile('iife-start', '(function() {');
var iifeStop = writeFile('iife-stop', '})();');
var vendoredPackages = {
'loader': vendoredPackage('loader'),
'rsvp': vendoredPackage('rsvp'),
'metamorph': vendoredPackage('metamorph'),
'backburner': vendoredPackage('backburner'),
'router': vendoredPackage('router'),
'route-recognizer': vendoredPackage('route-recognizer'),
};
var emberHandlebarsCompiler = pickFiles('packages/ember-handlebars-compiler/lib', {
files: ['main.js'],
module.exports = function(defaults) {
/*
an example of a Broccoli tree: appTree, sass, css, etc
A tree can be any string representing a directory path
or an Objectthat conforms to the Broccoli.JS Plugin API specification
*/
let appTree = new Angular2App(defaults, {
/*
sassCompiler takes the same arguments that node-sass does
https://github.com/sass/node-sass
*/
sassCompiler: {
/*
will not compile the global SASS, but it does configure the node-sass compiler
to find files when using the @import directive. Now you can import SASS from
`src/style` anywhere in your app to use SASS variables declared globally
inside component level SASS.
*/
includePaths: [
'src/styles'
]
},
// specifies an Array of file globs that this app will load into the `/dist/vendor` directory
vendorNpmFiles: [
'systemjs/dist/system-polyfills.js',
'systemjs/dist/system.src.js',
'zone.js/dist/**/*.+(js|js.map)',
'es6-shim/es6-shim.js',
'reflect-metadata/**/*.+(ts|js|js.map)',
'rxjs/**/*.+(js|js.map)',
'@angular/**/*.+(js|js.map)',
'@ngrx/**/*.+(js|js.map)',
'ngrx-store-logger/dist/*.+(js|js.map)'
]
});
/*
requires that global SASS resides in the `/src` folder, but as an added side effect
it also compiles the rest of the component level SASS in the same directory.
Transform the path slightly for the compileSass plug-in, removing the `src/`.
compileSass takes the tree that needs to be compiled (in this case 'src'),
the file path for the SASS file, and the file path of the destination CSS file.
Since the files are being iterated, each file passes through this function and
will be compiled into CSS.
*/
let sass = mergeTrees(_.map(glob.sync('src/**/*.sass'), (sassFile) => {
sassFile = sassFile.replace('src/', '');
return compileSass(['src'], sassFile, sassFile.replace(/.sass$/, '.css'));
}));
// pass the SASS tree (which output the file paths of the .css files) and the options
let css = compileCSS(sass, options);
/*
mergeTrees 1st argument is an Array, optionally 2nd argument with an Object of options.
Set `overwrite: true` to override the default SASS compile for new custom compile
important the trees are in this order, so they override each other correctly
*/
return mergeTrees([appTree, sass, css], { overwrite: true });
};
var compileSass = require('broccoli-sass');
var mergeTrees = require('broccoli-merge-trees');
var concatenate = require('broccoli-concat');
var uglifyJs = require('broccoli-uglify-js');
var sassDir = 'client/app/styles';
var appCss = compileSass([sassDir], 'app.scss', 'app.css');
var appJs = concatenate('client/app', {
inputFiles: ['**/*.js'],
outputFile: 'app.js'
});
appJs = uglifyJs(appJs, {
compress: true
});
module.exports = mergeTrees([appCss, appJs]);
/*
Responsible for concatenating ES6 modules together wrapped in loader and iife
(immediately-invoked function expression)
*/
function concatES6(sourceTrees, options) {
// see vendoredPackage
var loader = vendoredPackages['loader'];
var inputFiles = options.inputFiles;
var destFile = options.destFile;
// if given an array of trees merge into single tree
if (util.isArray(sourceTrees)) {
sourceTrees = mergeTrees(sourceTrees, {overwrite: true});
}
sourceTrees = transpileES6(sourceTrees, {
moduleName: true
});
/*
In order to ensure that tree is compliant with older Javascript versions we
recast these trees here. For example, in ie6 the following would be an
error:
```
{default: "something"}.default
```
However, in ECMA5 this is allowed. es3recast will convert the above into:
```
{default: "something"}['default']
```
*/
if (options.es3Safe) {
sourceTrees = es3recast(sourceTrees);
}
// see defeatureify
if (!disableDefeatureify) {
sourceTrees = defeatureify(sourceTrees, defeatureifyConfig(options.defeatureifyOptions));
}
var concatTrees = [loader, 'generators', iifeStart, iifeStop, sourceTrees];
if (options.includeLoader === true) {
inputFiles.unshift('loader.js');
}
if (options.bootstrapModule) {
var bootstrapTree = writeFile('bootstrap', 'requireModule("' + options.bootstrapModule + '");\n');
concatTrees.push(bootstrapTree);
inputFiles.push('bootstrap');
}
// do not modify inputFiles after here (otherwise IIFE will be messed up)
if (options.wrapInIIFE !== false) {
inputFiles.unshift('iife-start');
inputFiles.push('iife-stop');
}
if (options.includeLicense !== false) {
inputFiles.unshift('license.js');
}
if (options.vendorTrees) { concatTrees.push(options.vendorTrees); }
// concats the local `concatTrees` variable see concat options here:
// https://github.com/rlivsey/broccoli-concat/blob/master/README.md
return concat(mergeTrees(concatTrees), {
wrapInEval: options.wrapInEval,
inputFiles: inputFiles,
outputFile: destFile
});
}
module.exports = function(defaults) {
let disabledAddons = [];
let environment = EmberApp.env();
let isProduction = environment === 'production';
// let isTest = environment === 'test';
let swDisabled = process.env.SW_DISABLED;
let version = gitRev.short();
console.log('\n---------------');
console.log('environment: ', environment);
console.log('isProduction: ', isProduction);
console.log('SW_DISABLED: ', swDisabled);
console.log('git version: ', version);
console.log('---------------\n');
let app = new EmberApp(defaults, {
hinting: false,
minifyJS: { enabled: isProduction },
// TODO: find a way to remove legacy browser support from css
minifyCSS: { enabled: isProduction },
sourcemaps: {
enabled: !isProduction,
extensions: 'js',
},
autoImport: {
alias: {
'qr-scanner': 'qr-scanner/qr-scanner.min.js',
},
exclude: ['libsodium', 'libsodium-wrappers', 'phoenix', 'showdown', 'qrcode', 'uuid'],
},
'ember-cli-babel': {
includePolyfill: false,
disablePresetEnv: true,
disableDebugTooling: isProduction,
includeExternalHelpers: true,
// Will not build if uncommented:
// disableEmberModulesAPIPolyfill: true
// compileModules: false,
},
'ember-test-selectors': {
strip: isProduction,
},
eslint: {
testGenerator: 'qunit',
group: true,
rulesDir: 'eslint-rules',
extensions: ['js', 'ts'],
},
addons: { blacklist: disabledAddons },
'asset-cache': {
version,
include: ['assets/**/*', '**/*.html', 'index.html'],
exclude: ['.well-known/**/*', 'bundle.html', 'favicon.ico', 'robots.txt'],
},
});
// 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.
// phoenix sockets!
app.import('node_modules/phoenix/assets/js/phoenix.js', {
using: [{ transformation: 'cjs', as: 'phoenix' }],
});
// libsodium
app.import('node_modules/libsodium/dist/modules/libsodium.js');
app.import('node_modules/libsodium/dist/modules/libsodium-wrappers.js');
app.import('vendor/shims/libsodium.js');
app.import('vendor/shims/libsodium-wrappers.js');
// markdown
app.import('node_modules/showdown/dist/showdown.js', {
using: [{ transformation: 'cjs', as: 'showdown' }],
});
// qrcode
app.import('node_modules/qrcode/build/qrcode.min.js');
app.import('vendor/shims/qrcode.js');
// qr-scanner hardcoded this path.... -.-
var qrScannerWorker = new Funnel('node_modules/qr-scanner/', {
include: ['qr-scanner-worker.min.js'],
destDir: '/libraries/qr-scanner/',
});
// uuid
app.import('node_modules/uuid/index.js', {
using: [{ transformation: 'cjs', as: 'uuid' }],
});
return mergeTrees([app.toTree(), qrScannerWorker]);
};
function es6Package(packageName) {
var pkg = packages[packageName],
libTree;
/*
Prematurely returns if already defined. Trees is (will be) an object that looks like:
```
{lib: libTree, compiledTree: compiledTrees, vendorTrees: vendorTrees};
```
*/
if (pkg['trees']) {
return pkg['trees'];
}
/*
Recursively load dependency graph as outlined in `lib/packages.js`
#TODO: moar detail!!!
*/
var dependencyTrees = packageDependencyTree(packageName);
var vendorTrees = packages[packageName].vendorTrees;
/*
For packages that are maintained by ember we assume the following structure:
```
packages/ember-extension-support
├── lib
│ ├── container_debug_adapter.js
│ ├── data_adapter.js
│ ├── initializers.js
│ └── main.js
├── package.json
└── tests
├── container_debug_adapter_test.js
└── data_adapter_test.js
```
And the following following will manipulate the above tree into something
usuable for distribution
*/
/*
The following command will give us a libeTree which will look like the following:
```
ember-extension-support
├── container_debug_adapter.js
├── data_adapter.js
├── initializers.js
└── main.js
```
*/
libTree = pickFiles('packages/' + packageName + '/lib', {
srcDir: '/',
files: ['**/*.js'],
destDir: packageName
});
/*
Will rename the main.js file to packageName.js.
```
ember-extension-support
├── container_debug_adapter.js
├── data_adapter.js
├── initializers.js
└── ember-extension-support.js
```
*/
libTree = moveFile(libTree, {
srcFile: packageName + '/main.js',
destFile: packageName + '.js'
});
/*
Add templateCompiler to libTree. This is done to ensure that the templates
are precompiled with the local version of `ember-handlebars-compiler` (NOT
the `npm` version), and includes any changes. Specifically, so that you
can work on the template compiler and still have functional builds.
*/
libTree = mergeTrees([libTree, templateCompilerTree]);
/*
Utilizing the templateCompiler to compile inline handlebars templates to
handlebar template functions. This is done so that only Handlebars runtime
is required instead of all of Handlebars.
*/
libTree = inlineTemplatePrecompiler(libTree);
// Remove templateCompiler from libTree as it is no longer needed.
libTree = removeFile(libTree, {
srcFile: 'ember-template-compiler.js'
});
var libJSHintTree = jshintTree(libTree);
var testTree = pickFiles('packages/' + packageName + '/tests', {
srcDir: '/',
files: ['**/*.js'],
destDir: '/' + packageName + '/tests'
});
var testJSHintTree = jshintTree(testTree);
/*
Merge jshint into testTree in order to ensure that if you have a jshint
failure you'll see them fail in your browser tests
*/
var testTrees;
if (disableJSHint) {
testTrees = testTree;
} else {
testTrees = mergeTrees([testTree, libJSHintTree, testJSHintTree]);
}
var compiledLib = concatES6([dependencyTrees, libTree], {
includeLoader: true,
vendorTrees: vendorTrees,
inputFiles: [packageName + '/**/*.js', packageName + '.js'],
destFile: '/packages/' + packageName + '.js'
});
var compiledTrees = [compiledLib];
/*
Produces tree for packages. This will eventually be merged into a single
file for use in browser tests.
*/
var compiledTest = concatES6(testTrees, {
includeLoader: false,
inputFiles: ['**/*.js'],
destFile: '/packages/' + packageName + '-tests.js'
});
if (!pkg.skipTests) { compiledTrees.push(compiledTest); }
compiledTrees = mergeTrees(compiledTrees);
/*
Memoizes trees. Guard above ensures that if this is set will automatically return.
*/
pkg['trees'] = {lib: libTree, compiledTree: compiledTrees, vendorTrees: vendorTrees};
// tests go boom if you try to pick them and they don't exists
if (!pkg.skipTests) { pkg['trees'].tests = testTrees; }
// Baboom!! Return the trees.
return pkg.trees;
}
}),
pickFiles('bower_components/jquery/dist', {
files: ['jquery.js'],
srcDir: '/',
destDir: '/jquery'
}),
pickFiles('bower_components/handlebars', {
files: ['handlebars.js'],
srcDir: '/',
destDir: '/handlebars'
}),
];
bowerFiles = mergeTrees(bowerFiles);
// iife - Immediately Invoking Function Expression
// http://en.wikipedia.org/wiki/Immediately-invoked_function_expression
var iifeStart = writeFile('iife-start', '(function() {');
var iifeStop = writeFile('iife-stop', '})();');
/*
For use in dependency resolution. If referenced from within
`lib/pacakage.js` under the vendorRequirements property will resolve
dependency graph on behalf of requiring library.
For example:
```
'ember-metal': {trees: null, vendorRequirements: ['backburner']}
```
module.exports = function(_options) {
var options = _options || {};
var packages = __dirname + '/packages';
var tslintConfig = __dirname + '/tslint.json';
var bower = __dirname + '/bower_components';
var hasBower = existsSync(bower);
var babelOptions = buildBabelOptions(options);
var tsOptions = buildTSOptions();
var benchmarkTrees = [find(__dirname + '/bench', {
include: ['*.html'],
destDir: 'bench'
})];
var benchmarkPath = __dirname + '/node_modules/benchmark';
if (existsSync(benchmarkPath)) {
benchmarkTrees.push(find(benchmarkPath, {
include: ['benchmark.js'],
destDir: 'bench'
}));
}
var demos = find(__dirname + '/demos', {
include: ['*.html'],
destDir: 'demos'
});
/*
* ES6 Build
*/
var cancellationTokenPath = path.dirname(require.resolve('cancellation-token'));
var cancellationToken = mv(cancellationTokenPath, 'cancellation-token');
var tsTree = find(packages, {
include: ['**/*.ts'],
exclude: ['**/*.d.ts']
});
var tsLintTree = new TSLint(tsTree, {
configuration: tslintConfig
});
/* tslint:enable:no-unused-variable */
var transpiledTSLintTree = typescript(tsLintTree, tsOptions);
var jsTree = typescript(tsTree, tsOptions);
var libTree = find(jsTree, {
include: ['*/index.js', '*/lib/**/*.js']
});
libTree = merge([libTree, cancellationToken]);
var es6LibTree = mv(libTree, 'es6');
/*
* ES5 Named AMD Build
*/
libTree = transpile(libTree, babelOptions, 'ES5 Lib Tree');
var es5LibTree = mv(libTree, 'named-amd');
/*
* CommonJS Build
*/
tsOptions = buildTSOptions({
module: "commonjs",
target: "es5"
});
var cjsTree = typescript(tsTree, tsOptions);
// CancellationToken ships as ES6, so we have to compile it from ES6 modules to
// CJS using TypeScript. broccoli-typescript-compiler only works with `.ts` files,
// so we rename the `.js` files to `.ts` first.
var cancellationTokenLib = rename(cancellationTokenPath, '.js', '.ts');
var cancellationTokenJSTree = typescript(cancellationTokenLib, tsOptions);
cjsTree = merge([cjsTree, cancellationTokenJSTree]);
// igniter packages require other igniter packages using non-relative module names
// (e.g., `igniter-test-helpers` may import `igniter-runtime` instead of `../igniter-test-helpers`),
// which doesn't work with Node's module resolution strategy.
// As a workaround, naming the CommonJS directory `node_modules` allows us to treat each
// package inside as a top-level module.
cjsTree = mv(cjsTree, 'node_modules');
/*
* Anonymous AMD Build
*/
var igniterRuntime = find(libTree, {
include: [
'igniter-runtime/**/*',
'igniter-debug/**/*',
'cancellation-token/**/*'
]
});
var igniterDemos = merge([
find(libTree, {
include: [
'igniter-test-helpers/**/*.js',
'igniter-demos/**/*.js',
]
})
]);
var igniterBenchmarks = merge([
find(libTree, {
include: [
'igniter-test-helpers/**/*.js',
'igniter-benchmarks/**/*.js',
]
})
]);
var igniterTests = merge([
transpiledTSLintTree,
find(jsTree, { include: ['*/tests/**/*.js'], exclude: ['igniter-node/tests/**/*.js'] }),
find(jsTree, { include: ['igniter-test-helpers/**/*.js'] })
]);
igniterTests = transpile(igniterTests, babelOptions, 'igniter-tests');
// Test Assets
var testHarnessTrees = [
find(__dirname + '/tests', {
srcDir: '/',
files: [ 'index.html' ],
destDir: '/tests'
})
];
if (hasBower) {
testHarnessTrees.push(find(bower, {
srcDir: '/qunit/qunit',
destDir: '/tests'
}));
}
var testHarness = merge(testHarnessTrees);
igniterRuntime = concat(igniterRuntime, {
inputFiles: ['**/*.js'],
outputFile: '/amd/igniter-runtime.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
igniterDemos = concat(igniterDemos, {
inputFiles: ['**/*.js'],
outputFile: '/amd/igniter-demos.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
igniterBenchmarks = concat(igniterBenchmarks, {
inputFiles: ['**/*.js'],
outputFile: '/amd/igniter-benchmarks.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
igniterTests = concat(igniterTests, {
inputFiles: ['**/*.js'],
outputFile: '/amd/igniter-tests.amd.js',
sourceMapConfig: {
enabled: true,
cache: null,
sourceRoot: '/'
}
});
var finalTrees = [
testHarness,
demos,
merge(benchmarkTrees),
igniterRuntime,
igniterTests,
igniterDemos,
igniterBenchmarks,
cjsTree,
es5LibTree,
es6LibTree
];
if (hasBower) {
var loader = find(__dirname + '/node_modules', {
srcDir: '/loader.js/lib/loader',
files: [ 'loader.js' ],
destDir: '/assets'
});
finalTrees.push(loader);
}
return merge(finalTrees);
};
treeForVendor(tree) {
let registerVersionTree = writeFile(
"ember-cli-jstree/register-version.js",
`Ember.libraries.register('Ember CLI jsTree', '${version}')`
);
let stylesTree = new Funnel(
path.join(this._jstreePath(), "dist/themes/default"),
{
include: ["*.css"],
destDir: "ember-cli-jstree"
}
);
let jsTree = new Funnel(path.join(this._jstreePath(), "dist"), {
include: ["*.js"],
destDir: "ember-cli-jstree"
});
return tree ? mergeTrees([tree, registerVersionTree, jsTree, stylesTree], {overwrite: true}) : mergeTrees([registerVersionTree, jsTree, stylesTree], {overwrite: true});
},
treeForPublic() {
return new Funnel(path.join(this._jstreePath(), "dist/themes/default"), {
include: ["**/*.png", "**/*.gif"],
destDir: "/assets"
});
}
};
function getES6Package(packages, packageName, opts) {
var pkg = packages[packageName];
var options = opts || {};
var jsRegExp = /js$/;
var configPath = options.configPath || '';
var libTree;
/*
Prematurely returns if already defined. Trees is (will be) an object that looks like:
```
{lib: libTree, vendorTrees: vendorTrees};
```
*/
if (pkg['trees']) {
return pkg['trees'];
}
/*
Recursively load dependency graph as outlined in `lib/packages.js`
#TODO: moar detail!!!
*/
packageDependencyTree(packages, packageName, {
vendoredPackages: options.vendoredPackages
});
var vendorTrees = pkg.vendorTrees;
/*
The list of files to select. This is passed to `Funnel` below.
*/
var files = [ jsRegExp ];
if (pkg.hasTemplates) {
files.push(/hbs$/);
}
/*
For packages that are maintained by ember we assume the following structure:
```
packages/ember-extension-support
├── lib
│ ├── container_debug_adapter.js
│ ├── data_adapter.js
│ ├── initializers.js
│ └── main.js
└── tests
├── container_debug_adapter_test.js
└── data_adapter_test.js
```
And the following following will manipulate the above tree into something
usuable for distribution
*/
/*
The following command will give us a libeTree which will look like the following:
```
ember-extension-support
├── container_debug_adapter.js
├── data_adapter.js
├── initializers.js
── ember-extenstion-support.js
```
*/
libTree = new Funnel(options.libPath || 'packages/' + packageName + '/lib', {
include: files,
destDir: packageName,
getDestinationPath: function(relativePath) {
if (relativePath === 'main.js') {
return '../' + packageName + '.js';
}
return relativePath;
},
});
var libJSCSTree = jscsTree(libTree, {
configPath: configPath
});
var libJSHintTree = jshintTree(libTree);
if (pkg.hasTemplates) {
/*
Utilizing the templateCompiler to compile inline templates to
template functions. This is done so that HTMLBars compiler is
not required for running Ember.
*/
libTree = inlineTemplatePrecompiler(libTree, {
htmlbars: options.htmlbars
});
}
var testTree = new Funnel(options.testPath || 'packages/' + packageName + '/tests', {
include: [ jsRegExp ],
destDir: '/' + packageName + '/tests'
});
var testJSCSTree = jscsTree(testTree, {
configPath: configPath
});
var testJSHintTree = jshintTree(testTree);
/*
Merge jshint into testTree in order to ensure that if you have a jshint
failure you'll see them fail in your browser tests
*/
var testTrees = [];
if (!disableJSHint) {
testTrees.push(libJSHintTree);
testTrees.push(testJSHintTree);
}
if (!disableJSCS) {
testTrees.push(libJSCSTree);
testTrees.push(testJSCSTree);
}
testTrees.push(testTree);
testTrees = testTrees.length > 0 ? mergeTrees(testTrees, { overwrite: true }) : testTree;
// Memoizes trees. Guard above ensures that if this is set will automatically return.
pkg['trees'] = {
lib: libTree,
vendorTrees: vendorTrees
};
// tests go boom if you try to pick them and they don't exists
if (!pkg.skipTests) {
pkg['trees'].tests = testTrees;
}
// Baboom!! Return the trees.
return pkg['trees'];
}
// var jshinted = jshint(libTree);
// jshinted = wrap(jshinted, {
// wrapper: [ "if (!QUnit.urlParams.nojshint) {\n", "\n}"]
// });
// test = merge([jshinted, test]);
return test;
}
var testFiles = testTree(halAdapterFiles, 'ember-data-hal-adapter');
testFiles = concat(testFiles, {
inputFiles: ['**/*.js'],
seperator: '\n',
wrapInEval: true,
wrapInFunction: true,
outputFile: '/tests/tests.js'
});
var buildFiles = halAdapterFiles;
var trees = merge([
testFiles,
buildFiles
]);
module.exports = trees;
// 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(app.bowerDirectory + '/ember-simple-auth/simple-auth.amd.js', {
exports: {
'simple-auth/authenticators/base': ['default'],
'simple-auth/authorizers/base': ['default'],
'simple-auth/mixins/application-route-mixin': ['default'],
'simple-auth/mixins/authenticated-route-mixin': ['default'],
'simple-auth/mixins/unauthenticated-route-mixin': ['default'],
'simple-auth/mixins/authentication-controller-mixin': ['default'],
'simple-auth/mixins/login-controller-mixin': ['default'],
'simple-auth/stores/base': ['default'],
'simple-auth/stores/ephemeral': ['default'],
'simple-auth/stores/local-storage': ['default'],
'simple-auth/session': ['default'],
'simple-auth/configuration': ['default'],
'simple-auth/setup': ['default']
}
});
var sinon = pickFiles(app.bowerDirectory + '/sinon', {
srcDir: '/',
files: ['index.js'],
destDir: '/assets/sinon'
});
module.exports = mergeTrees([app.toTree(), sinon]);
destDir: '/'
});
var srcES6 = pickFiles('src', {
srcDir: '/',
files: ['**/*.js'],
destDir: '/src'
});
var testsES6 = pickFiles('tests', {
srcDir: '/',
files: ['**/*.js'],
destDir: '/tests'
});
var toHint = pickFiles(mergeTrees([srcES6, testsES6]), {
srcDir: '/',
files: ['**/*.js'],
destDir: '/jshint'
});
var hinted = jshint(toHint);
var scripts = esTranspiler(mergeTrees([srcES6, testsES6]), {
sourceMap: 'inline',
modules: 'amd',
moduleIds: true,
loose: ['all']
});
HotCSS.prototype.modifyTree = function(tree) {
var jsClient = fs.readFileSync(__dirname+'/hot-css-client.js', 'utf8');
return mergeTrees([writeFile('hot-css-client.js', jsClient.replace(/@port@/g, this.port)), tree]);
}
function es6Package(packageName) {
var pkg = packages[packageName],
libTree;
if (pkg['trees']) {
return pkg['trees'];
}
var dependencyTrees = packageDependencyTree(packageName);
var vendorTrees = packages[packageName].vendorTrees;
libTree = pickFiles('packages/' + packageName + '/lib', {
srcDir: '/',
files: ['**/*.js'],
destDir: packageName
});
libTree = moveFile(libTree, {
srcFile: packageName + '/main.js',
destFile: packageName + '.js'
});
libTree = mergeTrees([libTree, templateCompilerTree]);
libTree = inlineTemplatePrecompiler(libTree);
libTree = removeFile(libTree, {
srcFile: 'ember-template-compiler.js'
});
var libJSHintTree = jshintTree(libTree, {
destFile: '/' + packageName + '/tests/lib-jshint.js'
});
var testTree = pickFiles('packages/' + packageName + '/tests', {
srcDir: '/',
files: ['**/*.js'],
destDir: '/' + packageName + '/tests'
});
var testJSHintTree = jshintTree(testTree, {
destFile: '/' + packageName + '/tests/tests-jshint.js'
});
var testTrees;
if (disableJSHint) {
testTrees = testTree;
} else {
testTrees = mergeTrees([testTree, libJSHintTree, testJSHintTree]);
}
var compiledLib = concatES6([dependencyTrees, libTree], {
includeLoader: true,
vendorTrees: vendorTrees,
inputFiles: [packageName + '/**/*.js', packageName + '.js'],
destFile: '/packages/' + packageName + '.js'
})
var compiledTrees = [compiledLib];
var compiledTest = concatES6(testTrees, {
includeLoader: false,
inputFiles: ['**/*.js'],
destFile: '/packages/' + packageName + '-tests.js'
})
if (!pkg.skipTests) { compiledTrees.push(compiledTest); }
compiledTrees = mergeTrees(compiledTrees);
pkg['trees'] = {lib: libTree, compiledTree: compiledTrees, vendorTrees: vendorTrees};
if (!pkg.skipTests) { pkg['trees'].tests = testTrees; }
return pkg.trees;
}
// VENDOR:
// SCC+CSS Files
// var vendorCssFiles = mergeTrees([
// pickFiles(new UnwatchedDir('src'), { include: ['vendor2.scss']}),
// pickFiles(new UnwatchedDir('node_modules/angular'), { include: ['angular-csp.css']}),
// pickFiles(new UnwatchedDir('node_modules/angular-material'), { include: ['angular-material.css']}),
// ])
// vendorCssFiles = new compileSas([vendorCssFiles], 'vendor2.scss', 'vendor.css')
// VENDOR:
// SCC+CSS Files
var vendorCssFiles = [];
var vendorCssArr = require('./configs/brocfile-vendor-css.js');
vendorCssArr.forEach(function(entry) {
node = pickFiles(new UnwatchedDir(entry.dir), { include: entry.files });
vendorCssFiles.push(node);
})
var vendorCssFiles = mergeTrees(vendorCssFiles);
vendorCssFiles = new compileSas([vendorCssFiles], 'vendor.scss', 'vendor.css')
//VENDOR:
//JS FILES
var vendorFiles = new UnwatchedDir('assets');
module.exports = mergeTrees([htmlFiles, tsFiles, vendorFiles, cssFiles, vendorCssFiles])
// // print process.argv
// process.argv.forEach(function (val, index, array) {
// console.log(index + ': ' + val);
// });
var mergeTrees = require('broccoli-merge-trees');
var wintersmith = require('broccoli-wintersmith');
var wintersmithPublicOutput = 'basic-wintersmith-site';
wintersmithPublicOutput = wintersmith(wintersmithPublicOutput);
module.exports = mergeTrees([wintersmithPublicOutput]);
destDir: '/tests'
});
var cliSauce = new Funnel('./node_modules/ember-cli-sauce', {
srcDir: '/vendor',
files: [ 'export-test-results.js' ],
destDir: '/tests'
});
// Export trees
var trees = [demos, test, loader, qunit, cliSauce];
for (var packageName in packages.dependencies) {
var packageTrees = getPackageTrees(packageName, packages.dependencies[packageName]);
var libTree = mergeTrees(packageTrees[0]),
testTree = mergeTrees(packageTrees[1]);
// ES6
var pickedEs6Lib = new Funnel(libTree, {
destDir: '/es6/'
});
trees.push(pickedEs6Lib);
// AMD lib
var transpiledAmdLib = transpileES6(libTree, { moduleName: true, type: 'amd' });
var concatenatedAmdLib = concatFiles(transpiledAmdLib, {
inputFiles: ['**/*.js'],
outputFile: '/amd/' + packageName + '.amd.js'
});
trees.push(concatenatedAmdLib);
bust: false
},
view: {
layout: 'packed',
sprite: '../svg/packed.svg',
bust: false
}
}
};
function writeFile(file, content) {
try {
mkdirp.sync(path.dirname(file));
fs.writeFileSync(file, content);
return file;
} catch (e) {
return null;
}
}
orthogonalSpriter = new svgSpriter(inputFiles, orthogonal);
console.log('Writing Files');
console.log(orthogonalSpriter._destDir);
module.exports = merge([orthogonalSpriter]);
let blogAuthorTrees = this.authors.map(author => {
return this._writeAuthorComponentTree(author);
});
let recentPostsByTopic = collectRecentPosts(this.posts);
let recentPostsTrees = _.reduce(
recentPostsByTopic,
(acc, posts, topic) => {
acc.push(this._writeRecentPostsComponentTree(topic, posts));
return acc;
},
[],
);
return mergeTrees([tree, blogStartPageTree, ...blogPostTrees, ...blogAuthorTrees, ...recentPostsTrees]);
} else {
return tree;
}
},
treeFor(type) {
if (type === 'public') {
return writeFile('feed.xml', generateFeed(this.posts));
}
},
_writePostComponentTree(post, related) {
let trees = [];
let excerpt = htmlizeExcerpt(post.excerpt);
let body = htmlizeBody(post.content);
var testHarness = new Funnel( 'tests', {
files: ['index.html'],
destDir: destination
});
var qunit = new Funnel('bower_components/qunit/qunit', {
files: ['qunit.js', 'qunit.css'],
destDir: destination
});
return mergeTrees([tests, testHarness, qunit]);
}
var lib = new Funnel( 'lib', {
destDir: '/'
});
var version = require('./package.json').version;
lib = replace(lib, {
files: [ '**/*.js' ],
patterns: [
{ match: /VERSION_STRING_PLACEHOLDER/g, replacement: version }
]
});
var testSuite = buildTestSuite(lib);
var distLibs = buildDistLib(lib);
module.exports = mergeTrees([distLibs, testSuite]);
files: ['loader.js'],
destDir: '/assets/'
});
// TODO - this manual dependency management has got to go!
var klassy = new Funnel('bower_components', {
srcDir: '/klassy/lib',
files: ['klassy.js'],
destDir: '/'
});
var emberTestHelpers = new Funnel('bower_components', {
srcDir: '/ember-test-helpers/lib',
include: [/.js$/],
destDir: '/'
});
var deps = mergeTrees([klassy, emberTestHelpers]);
var lib = new Funnel('lib', {
srcDir: '/',
include: [/.js$/],
destDir: '/'
});
var tests = new Funnel('tests', {
srcDir: '/',
include: [/test-support\/.+.js$/, /.js$/],
destDir: '/tests'
});
var main = mergeTrees([deps, lib]);
var es6Main = new compileES6(main, {
module.exports = function(defaults) {
let checker = new VersionChecker(defaults);
let emberChecker = checker.forEmber();
if (emberChecker.isAbove('3.0.0')) {
options.vendorFiles = { 'jquery.js': null };
}
let app = new EmberApp(defaults, options);
// 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.
//
const env = process.env.EMBER_ENV;
app.import('vendor/babel-polyfill.js', { prepend: true });
app.import('node_modules/basiccontext/dist/basicContext.min.css');
app.import('node_modules/basiccontext/dist/themes/default.min.css');
app.import('node_modules/basiccontext/dist/basicContext.min.js');
app.import('node_modules/compare-versions/index.js');
// Ember Debug
let emberDebug = 'ember_debug';
emberDebug = new Funnel(emberDebug, {
destDir: 'ember-debug',
include: ['**/*.js'],
exclude: [
'vendor/loader.js',
'vendor/source-map.js',
'vendor/startup-wrapper.js',
]
});
emberDebug = esTranspiler(emberDebug, {
moduleIds: true,
plugins: [[modulesBabelPlugin, { noInterop: true }]],
resolveModuleSource: moduleResolver
});
const previousEmberVersionsSupportedString = `[${packageJson.previousEmberVersionsSupported.map(function(item) {
return `'${item}'`;
}).join(',')}]`;
const emberVersionsSupportedString = `[${packageJson.emberVersionsSupported.map(function(item) {
return `'${item}'`;
}).join(',')}]`;
let startupWrapper = new Funnel('ember_debug', {
srcDir: 'vendor',
files: ['startup-wrapper.js'],
});
startupWrapper = replace(startupWrapper, {
files: ['startup-wrapper.js'],
patterns: [{
match: /{{EMBER_VERSIONS_SUPPORTED}}/,
replacement: emberVersionsSupportedString
}]
});
let sourceMap = new Funnel('ember_debug', {
srcDir: 'vendor',
files: ['source-map.js'],
});
const loader = new Funnel('ember_debug', {
srcDir: 'vendor',
files: ['loader.js'],
});
sourceMap = map(sourceMap, '**/*.js', function(content) {
return `(function() {\n${content}\n}());`;
});
emberDebug = mergeTrees([loader, startupWrapper, sourceMap, emberDebug]);
emberDebug = concatFiles(emberDebug, {
headerFiles: ['loader.js'],
inputFiles: ['**/*.js'],
outputFile: '/ember_debug.js',
sourceMapConfig: { enabled: false }
});
const emberDebugs = [];
['basic', 'chrome', 'firefox', 'bookmarklet', 'websocket'].forEach(function(dist) {
emberDebugs[dist] = map(emberDebug, '**/*.js', function(content) {
return `(function(adapter, env) {\n${content}\n}('${dist}', '${env}'));`;
});
});
let tree = app.toTree();
const emberInspectorVersionPattern = [{
match: /{{EMBER_INSPECTOR_VERSION}}/g,
replacement: packageJson.version
}];
tree = replace(tree, {
files: ['**/*.js'],
patterns: emberInspectorVersionPattern
});
const minimumVersion = packageJson.emberVersionsSupported[0].replace(/\./g, '-');
const webExtensionRoot = `panes-${minimumVersion}`;
let replacementPattern = [{
match: /{{env}}/,
replacement: env === 'development' ? ' [DEV]' : ''
}, {
match: /{{PANE_ROOT}}/g,
replacement: `panes-${minimumVersion}`
}, {
match: /{{PREVIOUS_EMBER_VERSIONS_SUPPORTED}}/g,
replacement: previousEmberVersionsSupportedString
}, {
match: /{{EMBER_VERSIONS_SUPPORTED}}/g,
replacement: emberVersionsSupportedString
}];
replacementPattern = replacementPattern.concat(emberInspectorVersionPattern);
const skeletonWebExtension = replace('skeletons/web-extension', {
files: ['*'],
patterns: replacementPattern
});
const skeletonBookmarklet = replace('skeletons/bookmarklet', {
files: ['*'],
patterns: replacementPattern
});
let firefox = mergeTrees([
mv(mergeTrees([tree, emberDebugs.firefox]), webExtensionRoot),
skeletonWebExtension
]);
let chrome = mergeTrees([
mv(mergeTrees([tree, emberDebugs.chrome]), webExtensionRoot),
skeletonWebExtension
]);
let bookmarklet = mergeTrees([
mv(mergeTrees([tree, emberDebugs.bookmarklet]), webExtensionRoot),
skeletonBookmarklet
]);
packageJson.previousEmberVersionsSupported.forEach(function(version) {
version = version.replace(/\./g, '-');
if (env === 'production') {
const prevDist = `dist_prev/${env}`;
bookmarklet = mergeTrees([
mv(`${prevDist}/bookmarklet/panes-${version}`, `panes-${version}`),
bookmarklet
]);
firefox = mergeTrees([
mv(`${prevDist}/firefox/panes-${version}`, `panes-${version}`),
firefox
]);
chrome = mergeTrees([
mv(`${prevDist}/chrome/panes-${version}`, `panes-${version}`),
chrome
]);
} else {
const file = writeFile('index.html', "This Ember version is not supported in development environment.");
const emberDebugFile = writeFile('ember_debug.js', 'void(0);');
chrome = mergeTrees([mv(file, `panes-${version}`), chrome]);
firefox = mergeTrees([mv(file, `panes-${version}`), firefox]);
bookmarklet = mergeTrees([mv(file, `panes-${version}`), mv(emberDebugFile, `panes-${version}`), bookmarklet]);
}
});
// Pass the current dist to the Ember Inspector app.
// EMBER DIST
const dists = {
chrome,
firefox,
bookmarklet,
websocket: mergeTrees([tree, emberDebugs.websocket]),
basic: mergeTrees([tree, emberDebugs.basic])
};
Object.keys(dists).forEach(function(key) {
dists[key] = replace(dists[key], {
files: ['**/*.js'],
patterns: [{
match: /{{EMBER_DIST}}/g,
replacement: key
}]
});
});
// Add {{ remote-port }} to the head
// so that the websocket addon can replace it.
dists.websocket = replace(dists.websocket, {
files: ['index.html'],
patterns: [{
match: /<head>/,
replacement: '<head>\n{{ remote-port }}\n'
}]
});
let output;
if (env === 'test') {
// `ember test` expects the index.html file to be in the
// output directory.
output = dists.basic;
} else {
// Change base tag for running tests in development env.
dists.basic = replace(dists.basic, {
files: ['tests/index.html'],
patterns: [{
match: /<base.*\/>/,
replacement: '<base href="../" />'
}]
});
output = mergeTrees([
mv(dists.bookmarklet, 'bookmarklet'),
mv(dists.firefox, 'firefox'),
mv(dists.chrome, 'chrome'),
mv(dists.websocket, 'websocket'),
mv(dists.basic, 'testing')
]);
}
return output;
};
treeForAddon: function(tree) {
var versioned = merge([ version(), tree ]);
return this._super.treeForAddon.call(this, versioned);
}