function preprocess () {
try {
var
source = rework('@import \'./' + path.basename(input) + '\';', {
source: input
})
.use(npm({
prefilter: options.watch ? watch(function (file) {
console.log('modified:', file);
preprocess();
}) : null,
root: options.cwd || process.cwd()
}))
.use(variables())
.use(shade())
.toString({
compress: options.minify,
sourcemap: options.sourcemap
});
source = autoprefixer().process(source, {
from: input
}).css;
next(null, source);
} catch (error) {
next(error);
}
}
gulp.task('css', function() {
return gulp.src('index.css')
.pipe(rework(reworkNPM(), classPrefix('splendor-'), media(), reworkVars()))
.pipe(size({ gzip: true, showFiles: true }))
.pipe(name('splendor.css'))
.pipe(gulp.dest('css'));
});
function bundle (opts) {
var resolvedEntry = path.resolve(process.cwd(), opts.entry)
, css = rework(read(resolvedEntry), {source: resolvedEntry})
css.use(npm({
root: path.dirname(resolvedEntry),
prefilter: prefilter
}))
// even if variables were not provided
// use rework-vars to process default values
css.use(vars(opts.variables))
if (opts.assets) {
css.use(assets({
src: path.dirname(resolvedEntry)
, dest: opts.assets.dest || ''
, prefix: opts.assets.prefix || ''
}))
}
// utilize any custom rework plugins provided
if (opts.plugins) {
opts.plugins.forEach(function (plugin) {
css.use(getPlugin(plugin, path.dirname(resolvedEntry)))
})
}
return css.toString({
sourcemap: opts.debug || opts.sourcemap
, compress: opts.compress
})
}
module.exports = function(src, options, toStringOptions) {
var options = options || {};
var toStringOptions = toStringOptions || {};
var css = rework(src, options)
.use(reworkNPM())
.use(reworkVars())
.use(reworkMedia())
.use(reworkCalc)
.use(reworkColor)
.use(reworkPluginColors()) // For legacy support
.use(namespace(options.namespace, options.namespaceOptions))
.toString(toStringOptions);
// Process css as object
if (toStringOptions.sourcemapAsObject) {
css.code = autoprefixer().process(css.code).css;
}
// Process as string
else {
css = autoprefixer().process(css).css;
}
return css;
};
function roro(str, options) {
options = options || {};
if(typeof str !== 'string') {
throw new Error('`str` argument must be a String');
}
var browsers = options.browsers || autoprefixer['default'],
baseFontSize = options.baseFontSize ? parseInt(options.baseFontSize, 10) : 16,
dir = options.dir,
css;
css = rework(str)
.use(reworkNPM(dir))
.use(vars())
.use(hex)
.use(color)
.use(calc)
.use(remFallback(baseFontSize))
.use(rework.extend())
.use(rework.mixin({
opacity: opacity,
absolute: mixins.absolute,
relative: mixins.relative,
fixed: mixins.fixed,
size: mixins.size
}))
.use(autoprefixer(browsers).rework)
.toString();
return css;
}
gulp.task('build:css', function () {
var reworkPlugins = [
inliner(),
customMedia(breakPoints),
easeFunctions(),
palette(),
colors(),
vars(),
calc,
suitConformance,
{ sourcemap: !config.isProd }
];
return gulp.src(config.css.src)
.pipe($.plumber())
.pipe($.rework.apply(null, reworkPlugins))
.pipe($.if(!config.isProd, $.sourcemaps.init()))
.pipe($.autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe($.if(config.isProd, $.csso()))
.pipe($.if(!config.isProd, $.sourcemaps.write()))
.pipe(gulp.dest(config.css.dest))
.pipe($.size({ gzip: true }))
.pipe(reload({ stream: true }));
});
gulp.task('css', function() {
return gulp.src('index.scss')
.pipe(sass())
.pipe(rework(reworkNPM(), media(), reworkVars()))
.pipe(size({ gzip: true, showFiles: true }))
.pipe(name('main.css'))
.pipe(gulp.dest('css'));
});
gulp.task('styles', function() {
gulp
.src('client/styles/index.css')
.pipe(rework(npm(), vars(), rework.colors(), rework.extend(), breakpoints))
.pipe(autoprefixer('last 2 versions', '> 1%', 'ie 10'))
.pipe(csso(true))
.pipe(rename('styles.css'))
.pipe(gulp.dest('build/styles'));
});
function getCSS() {
var css = fs.readFileSync(__dirname + '/index.css', 'utf8')
css = rework(css)
.use(rwnpm({ dir: __dirname }))
.use(rework.ease())
.use(rework.inline(__dirname + '/../assets'))
.toString()
css = auto.process(css).css
return css
}
gulp.task('css', function(){
var file = path.resolve(PATHS.src.css.main);
var source = path.relative(__dirname, file);
mkpath.sync('dist');
var output = fs.createWriteStream('dist/build.css');
var contents = fs.readFileSync(file, { encoding: 'utf8' });
var css = rework(contents);
css.use(npmRework());
output.write(css.toString());
output.end();
})
gulp.task('reworkcss', function() {
var file = path.resolve('index.css');
var source = path.relative(__dirname, file);
var output = fs.createWriteStream('build/build.css');
var contents = fs.readFileSync(file, {encoding: 'utf8'});
// Initialize and pluginize `rework`
var css = rework(contents);
css.use(npmRework());
// write result
output.write(css.toString())
output.end();
});
test('use with importing modules', function(t) {
rimraf.sync('build');
var result = rework('@import "./fixtures/test.css";')
.use(reworkNpm())
.use(assets({ dest: 'build' }))
.toString();
t.equal(result, [
'.test {',
' test: url(' + HASH + '.txt);',
'}'
].join('\n'));
t.ok(fs.existsSync('build/' + HASH + '.txt'), 'copied file');
t.end();
});
gulp.task('buildcss', function () {
return gulp.src('./css/style.css')
.pipe(rework(reworkNPM({
shim: {
'purecss': 'build/pure.css'
}}),
vars(),
inherit(),
imprt({
path: './css/modules/'
})
)
)
.pipe(autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe(gulp.dest('public/css/'));
});
gulp.task('styles', function() {
var handleErrors = require('../util/handleErrors');
var paths = require('../config/paths');
var autoprefixer = require('gulp-autoprefixer');
var calc = require('rework-calc');
var customMedia = require('rework-custom-media');
var inliner = require('rework-npm');
var vars = require('rework-vars');
var dedupe = require('rework-deduplicate');
var ease = require('rework-plugin-ease');
var inherit = require('rework-inherit');
var color = require('rework-color-function');
var hexAlpha = require('rework-hex-alpha');
var fontVariant = require('rework-font-variant');
var namespace = require('rework-namespace');
var plumber = require('gulp-plumber');
var rename = require('gulp-rename');
var rework = require('gulp-rework');
var suit = require('rework-suit');
var svg = require('rework-svg');
var ns = '';
return gulp.src(paths.source.main_style)
.pipe(plumber(handleErrors))
.pipe(rework(
svg(),
inliner(),
customMedia(),
vars(),
calc,
hexAlpha,
color,
inherit(),
ease(),
dedupe(),
namespace(ns),
{sourcemap: true}))
.pipe(autoprefixer())
.pipe(gulp.dest(paths.dest.styles));
});
gulp.task('reworkcss',['clean'], function() {
return gulp.src('client/styles/index.css')
.pipe(rework(reworknpm()))
.pipe(gulp.dest('build'));
});
/* global require, module */
var EmberAddon = require('ember-cli/lib/broccoli/ember-addon');
var reworkVars = require('rework-vars');
var reworkNPM = require('rework-npm');
var app = new EmberAddon({
rework: {
plugins: [reworkNPM(), reworkVars()]
}
});
// 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.
module.exports = app.toTree();