function sourceTree(pathConfig, moduleType) {
const lib = babelTranspiler(pathConfig.lib, babelConfig(pkg.name, moduleType));
const shims = babelTranspiler(
funnel(pathConfig.shims, { include: ['fetch.js', 'promise.js'] }),
babelConfig(null, moduleType)
);
return mergeTrees([lib, shims]);
}
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,
]);
}
var bundler = function (sourceDir, app, options) {
options = options || {};
options.entry = options.entry || 'index.js';
options.dist = options.dist || dist;
var babelized = babelTranspiler(sourceDir, {
comments: false,
blacklist: options.blacklist || ['es6.modules']
});
var modularized = new ES6Modules(babelized, {
esperantoOptions: {
name: app,
amdName: app
},
bundleOptions: {
entry: options.entry,
name: app
},
format: 'umd'
});
var inDist = pickFiles(modularized, {
srcDir: './',
destDir: options.dist
});
return inDist;
};
function transpileCommonJS(pkgName, esVersion, tree) {
let pkgTree = funnel(tree, {
include: [`${pkgName}/**/*`],
exclude: ['**/*.d.ts']
});
let options = {
annotation: `Transpile CommonJS - ${pkgName} - ${esVersion}`,
plugins: [
[debugMacros, {
envFlags: {
source: '@glimmer/local-debug-flags',
flags: {
DEBUG: false
}
},
debugTools: {
source: '@glimmer/debug'
},
externalizeHelpers: {
module: true
}
}],
'transform-es2015-modules-commonjs'
],
sourceMaps: 'inline'
};
let commonjsTree = babel(pkgTree, options);
return funnel(commonjsTree, {
srcDir: pkgName,
destDir: `${pkgName}/dist/commonjs/${esVersion}`
});
}
var transpile = function (tree, opts) {
return esTranspiler(tree, {
stage: 0,
moduleIds: true,
modules: opts.modules,
loose: ['es6.classes', 'es6.modules'],
// Transforms /index.js files to use their containing directory name
getModuleId: function (name) {
name = pkg.name + '/' + name;
return name.replace(/\/index$/, '');
},
// Fix relative imports inside /index's
resolveModuleSource: function (source, filename) {
var match = filename.match(/(.+)\/index\.\S+$/i);
// is this an import inside an /index file?
if (match) {
var path = match[1];
return source
.replace(/^\.\//, path + '/')
.replace(/^\.\.\//, '');
} else {
return source;
}
}
});
};
/**
* 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');
}
module.exports = function(defaults) {
var fingerprintOptions = {
enabled: true
//exclude: ['datafruits']
};
var app = new EmberApp(defaults, {
// Add options here
fingerprint: fingerprintOptions,
emberCliFontAwesome: {
useScss: true
}
});
// 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(app.bowerDirectory + '/bootstrap/dist/js/bootstrap.js');
app.import(app.bowerDirectory + '/bootstrap/dist/css/bootstrap.css');
app.import(app.bowerDirectory + '/moment/moment.js');
app.import(app.bowerDirectory + '/fullcalendar/dist/fullcalendar.css');
app.import(app.bowerDirectory + '/fullcalendar/dist/fullcalendar.js');
app.import(app.bowerDirectory + '/jplayer/dist/jplayer/jquery.jplayer.js');
app.import(app.bowerDirectory + '/jsTimezoneDetect/jstz.min.js');
app.import(app.bowerDirectory + '/moment-timezone/builds/moment-timezone-with-data-2010-2020.js');
app.import(app.bowerDirectory + '/emojione/assets/css/emojione.css');
app.import(app.bowerDirectory + '/emojione/lib/js/emojione.js');
app.import(app.bowerDirectory + '/autolink/autolink-min.js');
app.import(app.bowerDirectory + '/jquery-textcomplete/dist/jquery.textcomplete.min.js');
app.import('/vendor/emojione_autocomplete.css');
var phoenixTree = "./vendor/phoenix";
var phoenixAmdFiles = new ES6Modules(phoenixTree, {
format: 'amd',
esperantoOptions: {
strict: true,
amdName: "phoenix"
}
});
var phoenixTranspiledFiles = esTranspiler(phoenixAmdFiles, {});
return mergeTrees([app.toTree(), phoenixTranspiledFiles]);
};
function transpileNodeTestsToCommonJS(jsTree) {
let testTree = funnel(jsTree, {
include: [
'@glimmer/node/test/**/*.js'
]
});
return babel(testTree, {
sourceMaps: 'inline',
plugins: [
'transform-es2015-modules-commonjs'
]
});
}
module.exports = function transpileToES5(inputNode, modules = false) {
return babel(inputNode, {
annotation: 'Babel - ES5',
sourceMaps: 'inline',
moduleIds: true,
presets: [
['env', {
loose: true,
modules,
exclude: [
// Transforms all `typeof` checks to account for Symbol, which we don't
// rely on, so can safely skip.
'transform-es2015-typeof-symbol'
]
}]
],
plugins: [
// Required for tests to pass in IE <=10, which rely on inheritance of
// static class methods. This doesn't work in IE 10 and below so we
// statically copy properties off __proto__ at class definition time.
'transform-proto-to-assign'
]
});
}
var babel = require('broccoli-babel-transpiler');
var merge = require('broccoli-merge-trees');
var mv = require('broccoli-stew').mv;
module.exports = merge([
mv(babel('tests'), 'tests'),
babel('src'),
]);
var babel = require('broccoli-babel-transpiler');
var tree = babel('lib', {
modules: 'umd',
moduleIds: true,
loose: ['es6.modules']
});
module.exports = tree;
RSSGenerator.prototype.transpile = function(tree){
return esTranspiler(tree, {
modules: 'commonStrict',
stage: 0
});
}
module.exports = function(defaults) {
var EmberApp = require('ember-cli/lib/broccoli/ember-app');
var funnel = require('broccoli-funnel');
var concat = require('broccoli-concat');
var mergeTrees = require('broccoli-merge-trees');
var pickFiles = require('broccoli-static-compiler');
var babelTranspiler = require('broccoli-babel-transpiler');
var path = require('path');
var env = EmberApp.env();
var isProductionLikeBuild = ['production', 'staging'].indexOf(env) > -1;
var prepend = null;
if(isProductionLikeBuild) {
prepend = env === 'production' ? '//assets.ember-twiddle.com/' : '//canary-assets.ember-twiddle.com/';
}
var blueprintsCode = getEmberCLIBlueprints();
var app = new EmberApp(defaults, {
SRI: {
runsIn: "production"
},
fingerprint: {
enabled: isProductionLikeBuild,
prepend: prepend,
extensions: ['js', 'css', 'png', 'jpg', 'gif', 'map', 'svg', 'eot', 'ttf', 'woff', 'woff2', 'ico'],
exclude: ['test-loader', 'test-support', 'testem']
},
codemirror: {
modes: ['xml', 'javascript', 'handlebars', 'htmlmixed', 'css'],
keyMaps: ['emacs', 'sublime', 'vim']
},
'ember-cli-bootstrap-sassy': {
'js': ['dropdown', 'collapse']
},
fileCreator: [{filename: '/lib/blueprints.js', content: blueprintsCode}],
sourcemaps: {
enabled: !isProductionLikeBuild
},
minifyCSS: {
enabled: isProductionLikeBuild
},
minifyJS: {
enabled: isProductionLikeBuild,
options: {
// Fix for minification bug with Uglify & Babel: Babel depends on constructor.name === "Plugin"
mangle: {
except: ['Plugin']
}
}
},
babel: {
includePolyfill: true
},
tests: true,
hinting: process.env.EMBER_CLI_TEST_COMMAND || !isProductionLikeBuild,
vendorFiles: {
'ember.js': {
staging: 'bower_components/ember/ember.prod.js'
}
}
});
app.import('bower_components/ember/ember-template-compiler.js');
app.import('vendor/bootstrap-dropdown-submenu-fix.css');
app.import('vendor/hint.css');
app.import('vendor/drags.js');
var loaderTree = funnel(path.dirname(require.resolve('loader.js')), {
files: ['loader.js'],
destDir: '/assets'
});
var emberDataShims = funnel('vendor', {
files: ['ember-data-shims.js']
});
var bowerTree = funnel('bower_components');
var baseResolverTree = funnel('node_modules/ember-resolver/addon', {
destDir: 'ember-resolver'
});
var transpiledResolverTree = babelTranspiler(baseResolverTree, {
loose: true,
moduleIds: true,
modules: 'amdStrict'
});
var baseInitializersTree = funnel('node_modules/ember-load-initializers/addon', {
destDir: 'ember-load-initializers'
});
var transpiledInitializersTree = babelTranspiler(baseInitializersTree, {
loose: true,
moduleIds: true,
modules: 'amdStrict'
});
var mergedDepsTree = mergeTrees([bowerTree, transpiledInitializersTree, transpiledResolverTree, emberDataShims]);
var twiddleVendorTree = concat(mergedDepsTree, {
inputFiles: [
'ember-cli-shims/app-shims.js',
'ember-load-initializers/**/*.js',
'ember-resolver/**/*.js',
'ember-data-shims.js'
],
outputFile: '/assets/twiddle-deps.js'
});
return mergeTrees([app.toTree(), twiddleVendorTree, loaderTree]);
};
// copy index.html
var staticFiles = new Funnel('src', {
files: ['index.html']
});
// convert SCSS into CSS
var cssFiles = compileSass(['src'], 'styles/app.scss', 'styles/app.css');
// exclude tests from build
var jsFiles = new Funnel('src', {
exclude: [new RegExp(/__tests__/)],
include: [new RegExp(/\.js$/)]
});
// transpile ES6/7 into ES5
jsFiles = babelTranspiler(jsFiles, {stage: 0});
// transpile for the browser
jsFiles = fastBrowserify(jsFiles, {
bundles: {
'index.js': {
entryPoints: ['index.js']
}
}
});
if (env === 'production') {
jsFiles = uglifyJavaScript(jsFiles);
jsFiles = gzipFiles(jsFiles, {
extensions: ['js', 'css'],
keepUncompressed: true
'node_modules/loader.js/lib/loader/',
'node_modules/vue/dist/',
], {overwrite: true});
const vendorFiles = new Funnel(vendorFolder, {
files: vendorFileNames,
});
const vendor = Concat(vendorFiles, {
inputFiles: vendorFileNames,
outputFile: '/vendor.js',
});
const babelScript = Babel('src', {
browserPolyfill: true,
stage: 0,
moduleIds: true,
modules: 'amd',
});
const appScript = Concat(babelScript, {
inputFiles: [
'**/*.js',
],
outputFile: '/app.js',
});
const compiledSass = new Sass(stylePaths, 'app.scss', 'app.css', {});
const optimizedCSS = new CssOptimizer(compiledSass);
const styles = new Autoprefixer(optimizedCSS);
if (process.env.EMBER_ENV === 'test') {
// Node path module
var path = require('path');
// Babel transpiler
var babel = require('broccoli-babel-transpiler');
// filter trees (subsets of files)
var funnel = require('broccoli-funnel');
// concatenate trees
var concat = require('broccoli-concat');
// merge trees
var mergeTrees = require('broccoli-merge-trees');
// Transpile the source files
var appJs = babel('src', {browserPolyfill: true});
// Concatenate all the JS files into a single file
appJs = concat(appJs, {
inputFiles: ['**/*.js'],
outputFile: '/js/my-app.js'
});
// Grab the index file
var index = funnel('src', {files: ['index.html']});
// Grab all our trees and
// export them as a single and final tree
module.exports = mergeTrees([index, appJs]);
function sourceTree(pathConfig, moduleType) {
return babelTranspiler(pathConfig.lib, babelConfig(pkg.name, moduleType));
}
module.exports = function(packageName, tree, _options) {
var options = babelOptions(packageName, _options);
return babel(tree, options);
};
module.exports = function() {
return funnel(babel('assets/demo/'), {
destDir: 'demo'
});
};
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(
vendorTree, {
inputFiles: [
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']
});
module.exports = mergeTrees([
hinted,
scripts,
testHTML,
jasmine,
requirejs,
specRunner,
perfFiles,
benchmark,
rxjs2,
lodash,
var babelTranspiler = require("broccoli-babel-transpiler");
var mergeTrees = require('broccoli-merge-trees');
var pickFiles = require('broccoli-static-compiler');
var compileSass = require('broccoli-sass');
var concat = require('broccoli-concat');
var jsAssessments = [];
[
'card-collection',
'cars',
'dmv',
'file-system',
'parking-lot',
'playlist',
'robots',
'toll-road',
].forEach(function (dir) {
jsAssessments.push(pickFiles(dir, { srcDir: '/', destDir: dir }));
});
var appAndDependencies = new mergeTrees(jsAssessments, { overwrite: true });
var appJs = babelTranspiler(appAndDependencies);
module.exports = mergeTrees([
appJs
]);
var appHtml = funnel('src', {
srcDir : '/',
files : ['index.html'],
destDir : '/'
});
// var maps = funnel('out', {
// include: ["**/*.map"],
// destDir : 'js'
// });
var transpiled = esTranspiler('out', {
stage: 0,
moduleIds: true,
modules: 'amd',
sourceMaps: true,
only: '**/*.js',
});
var publics = funnel('public', {
include : ['**/*'],
destDir: '.',
});
// var fableScripts = funnel(transpiled, {
// include : ['**/*.js'],
// destDir: 'out',
// });
// var main = concat(fableScripts, {
}
emberDebug = removeFile(emberDebug, {
files: [
'ember-debug/vendor/startup-wrapper.js',
'ember-debug/vendor/loader.js'
]
});
emberDebug = new ES6Modules(emberDebug, {
esperantoOptions: {
absolutePaths: true,
strict: true
}
});
emberDebug = esTranspiler(emberDebug);
var startupWrapper = pickFiles('ember_debug', {
srcDir: '/vendor',
files: ['startup-wrapper.js'],
destDir: '/'
});
var sourceMap = pickFiles('ember_debug', {
srcDir: '/vendor',
files: ['source-map.js'],
destDir: '/'
});
var loader = pickFiles('ember_debug', {
srcDir: '/vendor',
var transpile = require('broccoli-babel-transpiler'),
concat = require('broccoli-concat');
var tree = transpile('src', {
modules: 'amdStrict',
moduleRoot: 'webaudio-player',
moduleIds: true
});
module.exports = concat(tree, {
inputFiles: ['**/*.js'],
outputFile: '/webaudio-player.js'
});
var concat = require('broccoli-concat');
var env = require('broccoli-env').getEnv()
var rename = require('broccoli-stew').rename;
// Tests
var testsStatic = pickFiles('./dev/tests', {
include: ['tests.html', 'tests-min.html', 'lib/*', 'css/*'],
destDir: './tests'
});
var tests = pickFiles('./dev/tests', {
include: ['tests.js', 'tests.html', 'tests-min.html'],
destDir: './tests'
});
tests = esTranspiler(tests);
tests = concat(tests, {
header: "var module;",
outputFile: './tests/tests.js',
inputFiles: ['./tests/tests.js'],
footer: "module.exports(QUnit.test, Where);",
sourceMapConfig: { enabled: false },
});
// Library
const antlr4 = pickFiles('node_modules/antlr4', {
destDir: './antlr4'
});
var tool = pickFiles('./dev', {
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;
};
this.treeForPublic = function() {
// NOT LAZY LOADING!
// In this scenario we just want to do the default behavior and bail.
var publicResult = originalTreeForPublic.apply(this, arguments);
if (this.lazyLoading !== true) {
return publicResult;
}
// LAZY LOADING!
// But we have to implement everything manually for the lazy loading scenario.
// Move the public tree. It is already all in a folder named `this.name`
var publicRelocated;
if (publicResult) {
publicRelocated = new Funnel(publicResult, {
destDir: 'engines-dist'
});
}
// Get the child addons public trees.
// Sometimes this will be an engine tree in which case we need to handle it differently.
var childAddonsPublicTrees = this.eachAddonInvoke('treeFor', ['public']);
var childAddonsPublicTreesMerged = mergeTrees(childAddonsPublicTrees, { overwrite: true });
var childLazyEngines = new Funnel(childAddonsPublicTreesMerged, {
srcDir: 'engines-dist',
destDir: 'engines-dist'
});
var childAddonsPublicTreesRelocated = new Funnel(childAddonsPublicTreesMerged, {
exclude: ['engines-dist', 'engines-dist/**/*.*'],
destDir: 'engines-dist/' + this.name
});
var addonsEnginesPublicTreesMerged = mergeTrees([childLazyEngines, childAddonsPublicTreesRelocated], { overwrite: true });
var vendorTree = buildVendorTree.call(this);
var vendorJSTree = buildVendorJSTree.call(this, vendorTree);
var vendorCSSTree = buildVendorCSSTree.call(this, vendorTree);
var externalTree = new Funnel(vendorTree, {
include: ['vendor/**/*.*']
});
var engineAppTree = buildEngineAppTree.call(this);
// Splice out the routes.js file which we pushed into the host application.
var engineAppTreeWithoutRoutes = rollupFunnel(engineAppTree, {
exclude: true,
rollup: {
entry: this.name+'/routes.js'
}
});
// Babelify, but only to the extent of converting modules.
var babelOptions = {
modules: 'amdStrict',
moduleIds: true,
resolveModuleSource: amdNameResolver
};
var transpiledEngineTree = babelTranspiler(engineAppTreeWithoutRoutes, babelOptions);
// Concatenate all of the engine's JavaScript into a single file.
var concatTranspiledEngineTree = concat(transpiledEngineTree, {
allowNone: true,
inputFiles: ['**/*.js'],
outputFile: 'engines-dist/' + this.name + '/assets/engine.js'
});
// Combine all of the "vendor" trees which have JavaScript.
var transpiledVendorJSTree = babelTranspiler(vendorJSTree, babelOptions);
// And concatenate them.
var concatTranspiledVendorJSTree = concat(transpiledVendorJSTree, {
allowNone: true,
inputFiles: ['**/*.js'],
outputFile: 'engines-dist/' + this.name + '/assets/engine-vendor.js'
});
var concatMergedVendorJSTree = mergeTrees([concatTranspiledVendorJSTree, externalTree]);
// So, this is weird, but imports are processed in order.
// This gives the chance for somebody to prepend onto the vendor files.
var vendorJSImportTree = buildVendorJSWithImports.call(this, concatMergedVendorJSTree);
var concatVendorCSSTree = concat(vendorCSSTree, {
allowNone: true,
inputFiles: ['**/*.css'],
outputFile: 'engines-dist/' + this.name + '/assets/engine-vendor.css'
});
var concatMergedVendorCSSTree = mergeTrees([concatVendorCSSTree, externalTree]);
// So, this is weird, but imports are processed in order.
// This gives the chance for somebody to prepend onto the vendor files.
var vendorCSSImportTree = buildVendorCSSWithImports.call(this, concatMergedVendorCSSTree);
// Get base styles tree.
var engineStylesTree = this.compileStyles(this._treeFor('addon-styles'));
// Move styles tree into the correct place.
// `**/*.css` all gets merged.
// The addon.css file has already been renamed to match `this.name`.
// All we need to do is concatenate it down.
var primaryStyleTree;
if (engineStylesTree) {
primaryStyleTree = concat(engineStylesTree, {
allowNone: true,
inputFiles: ['**/*.css'],
outputFile: 'engines-dist/' + this.name + '/assets/engine.css'
});
}
var otherAssets;
if (this.otherAssets) {
otherAssets = this.otherAssets();
}
// Merge all of our final trees!
return mergeTrees(
[
publicRelocated,
addonsEnginesPublicTreesMerged,
otherAssets,
vendorCSSImportTree,
primaryStyleTree,
vendorJSImportTree,
concatTranspiledEngineTree
].filter(Boolean),
{ overwrite: true }
);
};
/* eslint-disable no-var */
var babel = require('broccoli-babel-transpiler');
var mergeTrees = require('broccoli-merge-trees');
/*
Node Module
supports:
- require('mock-socket').WebSocket
- require('mock-socket/dist/websocket');
- require('mock-socket/dist/server');
- require('mock-socket/dist/socket-io');
*/
var transpiledNodeModuleTree = babel('src');
module.exports = mergeTrees([transpiledNodeModuleTree]);
var pickFiles = require('broccoli-static-compiler');
var esTranspiler = require('broccoli-babel-transpiler');
var mergeTrees = require('broccoli-merge-trees');
var app = pickFiles('app', {
srcDir: '/',
destDir: '/'
})
var bower = pickFiles('bower_components', {
srcDir: '/',
destDir: '/deps'
});
app = esTranspiler(app, {});
var injectLivereload = require('broccoli-inject-livereload');
app = injectLivereload(app);
var tree = mergeTrees([bower, app]);
module.exports = tree;