require.extensions['.js'] = function(module, filename) {
var src = fs.readFileSync(filename, {encoding: 'utf8'});
if (!filename.match(/(node_modules)/)) {
src = babel.transform(src, {sourceMaps: 'inline', filename: filename}).code;
if (!filename.match(/(.*_test\.js$|polyfills)/)) {
src = instrumenter.instrumentSync(src, filename);
}
}
module._compile(src, filename);
};
test('some import that does not exist', () => {
const basic = `
import { thisDoesNotExist } from './styled/macro'
const someOtherVar = thisDoesNotExist
`
const { code } = babel.transform(basic, {
plugins: ['babel-macros'],
filename: __filename,
babelrc: false
})
expect(code).toMatchSnapshot()
})
test('css object', () => {
const basic = `
import { css } from '../src/macro'
const cls1 = css({ display: 'flex' })
`
const { code } = babel.transform(basic, {
plugins: ['babel-macros'],
filename: __filename,
babelrc: false
})
expect(code).toMatchSnapshot()
})
module.exports = function parseStringifiedCode(code) {
return babel.transform(code, {
presets: [
es2015,
],
plugins: [
syntaxFlow,
flowcheckParser,
stripFlow,
],
}).code;
};
Babelify.prototype._flush = function (callback) {
try {
var result = babel.transform(this._data, this._opts);
this.emit("babelify", result, this._filename);
var code = result.code;
this.push(code);
} catch(err) {
this.emit("error", err);
return;
}
callback();
};
function transform (source, options) {
return babel.transform(source.sourceCode, {
ast: false,
filename: source.sourceFileName,
inputSourceMap: source.inputSourceMap,
sourceMaps: options.sourceMaps, // .map
sourceRoot: options.root,
plugins: plugins.concat([
[ require('babel-plugin-transform-format-message'), options ]
])
})
}
process: function (src, filename) {
// Ignore all files within node_modules
// babel files can be .js, .es, .jsx or .es6
if (filename.indexOf("node_modules") === -1 && babel.util.canCompile(filename)) {
return babel.transform(src, {
filename: filename,
retainLines: true
}).code;
}
return src;
}
const transform = (code) => {
code = "'use extensible';\n" + code;
const filename = context + '.js';
return babel.transform(code, {
retainLines: true,
compact: true,
comments: false,
filename,
sourceFileName: filename,
sourceMaps: false,
}).code;
};
it('transforms the relative path into an absolute path with the configured root-path', () => {
const targetRequire = slash('/some/custom/root/some/example.js');
const transformedCode = babel.transform("import SomeExample from '~/some/example.js';", {
plugins: [[
BabelRootImportPlugin, {
rootPathSuffix: 'some/custom/root'
}
]]
});
expect(transformedCode.code).to.contain(targetRequire);
});
it('preserves whitespace only children', function () {
const code = '<span display-if={boo}> </span>';
const expected = `"use strict";
boo ? j(
"span",
null,
" "
) : null;`;
const compiled = transform(code, transformOptions).code;
expect(b(compiled)).to.equal(b(expected));
});
transform: function ( code, path ) {
// this is awkward - dependencies written in ES6 don't
// get transpiled by the previous step. So we have to
// hack around it. not ideal...
if ( /node_modules/.test( path ) ) {
return babel.transform( code, {
blacklist: [ 'es6.modules', 'useStrict' ]
}).code;
}
return code;
}
it('can be used on JSXElements nested in other JSXElements', function() {
const code = '<div><div display-if={yay}/></div>';
const expected = `"use strict";
j(
"div",
null,
yay ? j("div", null) : null
);`
const compiled = transform(code, transformOptions).code;
expect(b(compiled)).to.equal(b(expected));
});
it('can be used on JSX elements with a closing element and children', function() {
const code = '<div display-if={true}>yay</div>';
const expected = `"use strict";
true ? j(
"div",
null,
"yay"
) : null;`;
const compiled = transform(code, transformOptions).code;
expect(b(compiled)).to.equal(b(expected));
});
.then(result => {
console.log(`compiling react component for ${name}. ${remaining} files left`);
remaining--;
const babelResult = babel.transform(result, {
presets: ["es2015", "stage-2", "react"],
plugins: [htmlToReactAttributes]
});
fs.writeFileSync(`${reactDest}/${name}.js`, babelResult.code, { encoding: 'UTF-8' });
fs.writeFileSync(`${reactDest}/${name}.jsx`, result, { encoding: 'UTF-8' });
resolve();
})
test('css call with no args', () => {
const basic = `
import { css } from '../src/macro'
const cls1 = css()
`
const { code } = babel.transform(basic, {
plugins: ['babel-macros'],
filename: __filename,
babelrc: false
})
expect(code).toMatchSnapshot()
})
test('flush', () => {
const basic = `
import { flush } from '../src/macro'
const someOtherVar = flush
`
const { code } = babel.transform(basic, {
plugins: ['babel-macros'],
filename: __filename,
babelrc: false
})
expect(code).toMatchSnapshot()
})
}).then(function(bundle) {
// Generate bundle + sourcemap
var result = bundle.generate({
sourceMap: true,
format: 'umd',
moduleName: 'avalon'
});
// Cache our bundle for later use (optional)
cache = bundle;
result.code = result.code.replace(
/Object\.defineProperty\(exports,\s*'__esModule',\s*\{\s*value:\s*true\s*\}\);/,
"exports.__esModule = true").
replace(/version\:\s*1/, v)
result = babel.transform(result.code, {
presets: ['avalon'],
compact: false
})
function heredoc(fn) {
return fn.toString().replace(/^[^\/]+\/\*!?\s?/, '').
replace(/\*\/[^\/]+$/, '').trim().replace(/>\s*</g, '><')
}
var feather = heredoc(function() {
/*
https://github.com/RubyLouvre/avalon/tree/2.2.4
修正IE下 orderBy BUG
更改下载Promise的提示
修复avalon.modern 在Proxy 模式下使用ms-for 循环对象时出错的BUG
修复effect内部传参 BUG
重构ms-validate的绑定事件的机制
*/
})
var now = new Date
var snow = now.getFullYear() + '-' + (now.getMonth() + 1) +
'-' + now.getDate() + ':' + now.getHours() + ':' + now.getMinutes()
var banner = '/*!\nbuilt in ' + snow + ' version ' + json.version + ' by 司徒正美\n' + feather + '\n\n*/'
var code = banner + transform(result.code).
replace(/\}\)\(undefined,/, '})(this,').
replace(/avalon\$\d/g, 'avalon')
//这个不需要了
// replace(/'use strict';?/g, '')
fs.writeFileSync('./dist/avalon.js', less(code));
}).catch(function(e) {
function xform(mapping) {
var generator = new sourceMap.SourceMapGenerator({
file: "foo.js",
sourceRoot: "http://example.com/"
});
generator.addMapping(mapping);
babel.transform("a=1", {
sourceMaps: true,
inputSourceMap: JSON.parse(generator.toString()),
});
}
it('Should return a result for dnpgettext', function() {
var result = babel.transform('dnpgettext("mydomain", "mycontext", "msg", "plurial", 10)', {
plugins: [
[plugin, {
fileName: './test/dnpgettext.po',
}],
],
});
assert(!!result);
var content = fs.readFileSync('./test/dnpgettext.po');
assert(content.indexOf('msgid "msg"') !== -1);
assert(content.indexOf('msgid_plural "plurial"') !== -1);
});
it("function with defined $inject array", function () {
let result = babel.transform(`
function fn ($q) {
}
fn.$inject = ["$q"];
angular.module('test')
.directive('testDirective', fn);
`, presets).code;
expect(pullDecorated(result)).toBe("fn");
});
/**
* Create new JS minified file
* @param {Array} files - files composes the minified file
* @param {String} name - name file
*/
function createMinFile(files, name) {
var code = utils.combineFiles(files);
var result = babel.transform(code, {
"presets": ["env"],
"env": {
"production": {
"presets": ["babili"]
}
}
});
var path = opts.outputPath + '/' + name;
fs.writeFileSync(path, result.code);
}
it('uses "@" as custom prefix to detect a root-import path and has a custom rootPathSuffix', () => {
const targetRequire = slash(`${process.cwd()}/some/example.js`);
const transformedImport = babel.transform("import SomeExample from '@/example.js';", {
plugins: [[
BabelRootImportPlugin, {
rootPathPrefix: '@',
rootPathSuffix: 'some'
}
]]
});
const transformedRequire = babel.transform("var SomeExample = require('@/example.js');", {
plugins: [[
BabelRootImportPlugin, {
rootPathPrefix: '@',
rootPathSuffix: 'some'
}
]]
});
expect(transformedImport.code).to.contain(targetRequire);
expect(transformedRequire.code).to.contain(targetRequire);
});
function transform(path) {
var content = getContent(path);
if (path.indexOf('.coffee') > -1) {
return coffeeTransformer.transform(content);
}
if (!babel.canCompile(path)) {
return '';
}
return babel.transform(content).code;
}
process: function(src, filename) {
// Ignore all files within node_modules
// babel files can be .js, .es, .jsx or .es6
if (filename.indexOf("node_modules") === -1 && babel.canCompile(filename)) {
return babel.transform(src, { filename: filename }).code;
} else if(filename.match(/\.coffee$/) || filename.match(/\.cjsx$/)) {
// Coffee or cjsx
return coffeeReact.compile(src);
} else {
// No coffee and no babel (probably will never get here?)
return src;
}
}
function transform(src, filename, options) {
options = options || {};
const babelConfig = buildBabelConfig(filename, options);
const result = babel.transform(src, babelConfig);
return {
ast: result.ast,
code: result.code,
map: result.map,
filename: filename,
};
}
describe('#getCachePath', function() {
var compiler = new BabelCompiler();
var file = fs.readFileSync(path.join(__dirname, 'test.jsx'), 'utf8');
var defaults = BabelCompiler.DEFAULTS;
var source = babel.transform(file, defaults).code;
var version = require('babel-core/package.json').version;
var versionDir = path.join('js', 'babel', compiler._createDigest(version, defaults));
var expected = path.join(versionDir, '90fec0caffa65c1db6422fa4aa2d7c6ba2c954f6.js');
it('returns the digested cache path', function() {
expect(compiler.getCachePath(source)).to.equal(expected);
});
});
transform: (content, filename) => {
if (filename.indexOf('node_modules') === -1) {
const result = Babel.transform(content, {
sourceMap: 'inline',
filename: filename,
sourceFileName: filename,
});
return result.code;
}
return content;
},
var coffeeBabel = function (module, filename) {
var c = CoffeeScript._compileFile(filename, false, true)
var opts = new babel.OptionManager().init(extend(
{ sourceRoot: path.dirname(filename) },
{ filename: filename, ast: false, sourceMaps: 'both' }
));
var b = babel.transform(c, opts)
module._compile(b.code, filename)
}
export default function(source) {
// Make these modules available to the schema author through a require shim.
function require(path) {
switch (path) {
case 'graphql': return GraphQL;
case 'graphql-relay': return GraphQLRelay;
default: throw new Error(`Cannot find module "${path}"`);
}
}
const {code} = transform(source, {ast: false, code: true});
return eval(code);
}
test('does not write to the css file when it is the same as is already written', () => {
fs.existsSync.mockReturnValueOnce(true)
fs.readFileSync.mockReturnValueOnce(output)
const { code } = transform(basic, {
plugins: [[plugin, { extractStatic: true }]],
filename: __filename,
babelrc: false
})
expect(fs.existsSync).toBeCalledWith(cssFilepath)
expect(touch.sync).not.toHaveBeenCalled()
expect(fs.writeFileSync).not.toHaveBeenCalled()
expect(code).toMatchSnapshot()
})