gulp.task('sass', function()
{
return gulp.src( paths.sass.source )
.pipe(plumber({
errorHandler: errorHandler
}))
.pipe(sassGlob())
.pipe(sass({
outputStyle: 'expanded'
}))
.pipe(postcss([
require('autoprefixer')({ browsers: [ '> 1%', 'IE >= 10' ]}),
require('css-mqpacker')({ sort: true })
]))
.pipe(gulp.dest( paths.sass.output ));
});
gulp.task('sass', function () {
var sassOptions = {
errLogToConsole: true,
outputStyle: 'expanded'
};
return gulp
.src(inputSass)
.pipe(sassGlob())
.pipe(sourcemaps.init())
.pipe(sass(sassOptions).on('error', sass.logError))
.pipe(autoprefixer())
.pipe(cssnano())
.pipe(sourcemaps.write())
.pipe(gulp.dest(output))
.pipe(browserSync.stream());
});
gulp.task('sass', function() {
return gulp.src('app/scss/**/*.scss')
.pipe(sassGlob())
.pipe(sourcemaps.init())
.pipe(sass({
errLogToConsole: true
}))
.pipe(sourcemaps.write())
.pipe(autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe(gulp.dest('app/css'))
.pipe(browserSync.reload({
stream: true
}));
});
gulp.task('sass', function() {
// gulp.src locates the source files for the process.
// This globbing function tells gulp to use all files
// ending with .scss or .sass within the scss folder.
gulp.src('./scss/**/*.{scss,sass}')
// Converts Sass into CSS with Gulp Sass
.pipe(sassGlob())
.pipe(sass())
// Logs compilation errors to console
.on('error', sass.logError)
// Runs autoprefixer on CSS where necessary
.pipe(autoprefixer())
.pipe(gulp.dest('css'))
});
function styles() {
return gulp.src(config.styles.sass)
.pipe(sourcemaps.init()) // Sourcemaps need to init before compilation
.pipe(sassGlob()) // Allow for globbed @import statements in SCSS
.pipe(sass()) // Compile
.on('error', sass.logError) // Error reporting
.pipe(postcss([
autoprefixer(), // Autoprefix resulting CSS
cssnano() // Minify
]))
.pipe(rename({ // Rename to .min.css
suffix: '.min'
}))
.pipe(sourcemaps.write()) // Write the sourcemap files
.pipe(gulp.dest(config.styles.dest)) // Drop the resulting CSS file in the specified dir
.pipe(browserSync.stream());
}
gulp.task('compile-example:styles', () => {
return getPipe([
gulp.src('./example/styles/app.scss'),
sourcemaps.init(),
sassGlob(),
sass({
outputStyle: 'expanded'
}).on('error', sass.logError),
autoprefixer({
browsers: ['last 2 versions'],
cascade: true
}),
sourcemaps.write('./'),
gulp.dest('./example'),
browserSync.stream()
])
})
gulp.task('styles', function() {
gulp.src('app/styles/*.{scss,sass}')
.pipe(sourcemaps.init())
.pipe(plumber({errorHandler: errorHandler(`Error in \'styles\' task`)}))
.pipe(gulpIf(isDebug, sourcemaps.init()))
.pipe(sassGlob())
.pipe(sass({
style: 'expanded',
sourcemap: true,
includePaths: require('node-bourbon').includePaths
}))
.pipe(autoprefixer())
.pipe(gulpIf(!isDebug, gcmq()))
.pipe(gulpIf(!isDebug, nano({zindex: false})))
.pipe(rename({suffix: '.min'}))
.pipe(gulpIf(isDebug, sourcemaps.write()))
.pipe(gulp.dest('dist/assets/styles'))
});
gulp.task('sass', function () {
return gulp.src('assets/styles/scss/**/*.scss')
.pipe(plumber({errorHandler: errorAlert}))
.pipe(sassGlobbing())
.pipe(sass())
.pipe(autoprefixer({
browsers: ['> 5%'],
cascade: false
}))
.pipe(gulp.dest('assets/styles/css/'))
.pipe(browsersync.stream())
.pipe(cssimport())
.pipe(cssmin({processImport: true}))
.pipe(rename({suffix: '.min'}))
.pipe(gulp.dest('assets/styles/css'));
//.pipe(notify({message: "Sass compilation complete", title: "Compilation Successful"}));
});
gulp.task("sass", ["clean:sass"], (cb) => {
return gulp.src(kernel.setSourceStack("sass", config.sass.inputExt))
.pipe(sassLint({
options: {
'formatter': 'stylish',
'merge-default-rules': false
},
files: {ignore: '**/*.scss'},
rules: {
'no-ids': 1,
'no-mergeable-selectors': 0
},
config: '.sass-lint.yml'
}))
.pipe(sassLint.format())
.pipe($.plumber())
.pipe(cached(config.destPublicDir + config.dest, {
extension: '.css'
}))
.pipe(buffer())
.pipe($.if(!process.isProd, sourcemaps.init()))
.pipe(sassGlobbing())
.pipe(sass(config.sass.opts))
.pipe($.rename((filepath) => {
kernel.rewritePath(filepath, config.app);
}))
.pipe(kernel.addSuffixPath())
.pipe(mergeMq({ log: true }))
.pipe(postcss([ autoprefixer(config.autoprefixer), gradientfixer() ]))
.pipe($.if(!process.isProd, sourcemaps.write({
includeContent: false, // !! outer files sourcemaps broken if true
addComment: true
})))
.pipe($.if(process.isProd, cssnano(config.sass.cssnano)))
.pipe($.if(process.isProd, mirror(gzip())))
.pipe($.size({
showFiles: true
}))
.pipe(gulp.dest(config.destPublicDir + config.dest))
.pipe($.if(process.isProd, $.browserSync.reload({
stream: true
})));
});
gulp.task('scss', function() {
return gulp.src('assets/scss/*.scss')
.pipe(glob())
.pipe(plumber({
errorHandler: function (error) {
notify.onError({
title: "Gulp",
subtitle: "Failure!",
message: "Error: <%= error.message %>",
sound: "Beep"
}) (error);
this.emit('end');
}}))
.pipe(sass({
style: 'compressed',
errLogToConsole: true
}))
.pipe(autoprefixer('last 2 versions', '> 1%', 'ie 9', 'ie 10'))
.pipe(gulp.dest('assets/css'));
});
gulp.task("style", function () {
gulp.src("sass/style.scss")
.pipe(plumber())
.pipe(gulpGlob())
.pipe(sass())
.pipe(postcss([
autoprefixer({
browsers: [
"last 2 version"
]
}),
mqpacker({
sort: true
})
]))
.pipe(gulp.dest("build/css"))
.pipe(minify())
.pipe(rename("style.min.css"))
.pipe(gulp.dest("build/css"))
.pipe(server.reload({stream: true}));
});
gulp.task('sass', function() {
return gulp.src('scss/**/*.scss')
.pipe($.sourcemaps.init())
// Convert sass into css
.pipe(sassGlob())
.pipe($.sass({
outputStyle: 'nested', // libsass doesn't support expanded yet
precision: 10
}))
// Show errors
.on('error', reportError)
// Autoprefix properties
.pipe($.autoprefixer({
browsers: ['last 2 versions']
}))
// Write sourcemaps
.pipe($.sourcemaps.write())
// Save css
.pipe(gulp.dest('styles'))
.pipe(livereload());
});
gulp.task('styles', function() {
return gulp
.src(sassPath)
.pipe(sourcemaps.init())
.pipe(sassGlob())
.pipe(plumber({
errorHandler: notify.onError({
title: 'Gulp',
message: '<%= error.message %>',
})
}))
.pipe(sass(sassOptions).on('error', sass.logError))
.pipe(autoprefixer(autoprefixerOptions))
.pipe(sourcemaps.write('/'))
.pipe(gulp.dest(cssPath))
.pipe(notify({
title: 'Gulp',
message: 'Styles Completed'
}))
.resume();
});
gulp.task('css', () => {
// sass
let src = [];
let dir = './src/css';
let files = fs.readdirSync(dir);
files.forEach(file => {
let name = dir + '/' + file;
if (!fs.statSync(name).isDirectory() && path.extname(name) == '.sass') {
src.push(name);
}
});
return gulp.src(src, {
base: '.'
})
.pipe(glob())
.pipe(sass({
includePaths: ['node_modules']
}))
.on('error', notify.onError('Error: <%= error.message %>'))
.pipe(autoprefixer({
browsers: ['last 3 version', 'ie >= 11'],
grid: true
}))
.pipe(gcmq())
.pipe(gulpif(isProd, cssnano({
zindex: false
})))
.pipe(flatten())
.pipe(rename({
suffix: '.min'
}))
.pipe(gulp.dest('dist/assets/css/'))
.pipe(browserSync.reload({
stream: true
}));
});
gulp.task('scss', () => {
return gulp.src('scss/styles.scss')
.pipe(plumber({ errorHandler: function(err) {
notify.onError({
title: "Gulp error in " + err.plugin,
message: err.toString()
})(err);
beeper();
}}))
.pipe(sourcemaps.init())
.pipe(sassGlob())
.pipe(sass({outputStyle: 'compressed'}))
.pipe(cssnano({zindex: false}))
.pipe(postcss([
prefix({
browsers: ['last 3 versions'],
cascade: false })
]))
.pipe(sourcemaps.write('../css/maps'))
.pipe(gulp.dest('css'))
.pipe(reload({stream:true}));
});
gulp.task('css', function() {
return gulp.src(
[
dir.src.css + '/style.scss',
],
{base: dir.src.css}
)
.pipe(sassGlob())
.pipe(sass({
includePaths: require('node-normalize-scss').includePaths
}))
.pipe(postcss([
autoprefixer({
browsers: ['last 2 versions'],
cascade: false
})
]))
.pipe(gulp.dest(dir.dist.css))
.pipe(postcss([cssnano()]))
.pipe(rename({ suffix: '.min' }))
.pipe(gulp.dest(dir.dist.css));
});
gulp.task('styles', function () {
return gulp.src('source/sass/mtpc-styles.scss')
.pipe(cssglob({
extensions: ['.scss']
}))
.pipe(plumber({
errorHandler: function (error) {
notify.onError({
title: "Gulp",
subtitle: "Failure!",
message: "Error: <%= error.message %>",
sound: "Beep"
})(error);
this.emit('end');
}
}))
.pipe(sourcemaps.init())
.pipe(sass({
importer: nodeSassGlobbing,
style: 'compressed',
errLogToConsole: true
}))
.pipe(autoprefixer({
browsers: [
'last 2 versions',
'IE >= 10',
'safari 5',
'opera 12.1',
'ios 6',
'android 4']
}))
.pipe(csscomb())
.pipe(rename({suffix: '.min'}))
.pipe(cssmin())
.pipe(sourcemaps.write('./'))
.pipe(gulp.dest('build/css'))
.pipe(browserSync.reload({stream: true}));
});
gulp.task('css', function() {
return gulp.src(config.css.src)
.pipe(glob())
.pipe(plumber({
errorHandler: function (error) {
notify.onError({
title: "Gulp",
subtitle: "Failure!",
message: "Error: <%= error.message %>",
sound: "Beep"
}) (error);
this.emit('end');
}}))
.pipe(sourcemaps.init())
.pipe(sass({
style: 'compressed',
errLogToConsole: true,
includePaths: config.css.includePaths
}))
.pipe(autoprefix('last 2 versions', '> 1%', 'ie 9', 'ie 10'))
.pipe(sourcemaps.write('./'))
.pipe(gulp.dest(config.css.dest));
});
gulp.task('styles', function() {
return gulp.src('modules/all.scss')
.pipe(plumber({
errorHandler: function (err) {
console.log(err);
this.emit('end');
}
}))
.pipe(sassGlob())
.pipe(sass({
errLogToConsole: true,
includePaths: [ './modules/' ]
}))
.pipe(autoprefixer({
browsers: autoPrefixBrowserList,
cascade: true
}))
.on('error', gutil.log)
.pipe(concat('decent.css'))
.pipe(minifyCSS())
.pipe(gulp.dest('./css'))
.pipe(browserSync.reload({stream: true}));
});
const css = () => {
return gulp.src(['**/*.scss', '!**/_*.scss'], {cwd: 'source/static/styles/'})
.pipe(plumber(plumberConfig))
.pipe(sourcemaps.init())
.pipe(sassGlob())
.pipe(sass(sassConfig))
.pipe(postcss(postcssConfig))
.pipe(mmq(mmqConfig))
.pipe(gulpIf(!isDevelopment,
csscomb(csscombConfig)
))
.pipe(gulpIf(!isDevelopment,
gulp.dest(path.build.css)
))
.pipe(gulpIf(!isDevelopment,
csso(cssoConfig)
))
.pipe(gulpIf(!isDevelopment,
rename({suffix: '.min'})
))
.pipe(sourcemaps.write('.'))
.pipe(gulp.dest(path.build.css))
.pipe(browserSync.stream());
};
gulp.task('css', () => {
return gulp.src('source/css/cms.scss')
.pipe(sassGlob())
.pipe(sass())
.pipe(gulp.dest('assets/css'));
});
run: function(taskParams) {
taskParams = taskParams || { isWatch: false };
var injector = new appData.Injector('styles', appData, taskParams);
var stream;
var src = injector.run('src', [appData.dirs.src.styles + '*.scss']);
if (injector.isTaskCanceled(src)) {
return Promise.resolve();
}
if (!injector.isCanceled) {
stream = gulp.src(appData.app.taskUtils.sanitizeGlob(src))
.pipe(plumber({
errorHandler: function (error) {
console.log(error.message);
this.emit('end');
}
}));
}
else {
stream = src;
}
if (injector.taskConfig.sourceMaps) {
stream = injector.run('sourceMapsInit', stream);
if (!injector.isCanceled) {
stream = stream.pipe(sourcemaps.init());
}
}
stream = injector.run('sassGlob', stream);
if (!injector.isCanceled) {
stream = stream.pipe(sassGlob());
}
stream = injector.run('sass', stream);
if (!injector.isCanceled) {
stream = stream.pipe(sass(injector.taskConfig.sass).on('error', sass.logError));
}
stream = injector.run('autoprefixer', stream);
if (!injector.isCanceled) {
stream = stream.pipe(postcss([ autoprefixer(injector.taskConfig.autoprefixer) ]));
}
stream = injector.run('optimizeMediaQueries', stream);
if (!injector.isCanceled) {
stream = stream.pipe(gcmq());
}
stream = injector.run('optimize', stream);
if (!injector.isCanceled) {
stream = stream.pipe(cssnano(injector.taskConfig.cssnano));
}
if (injector.taskConfig.sourceMaps) {
stream = injector.run('sourceMapsWrite', stream);
if (!injector.isCanceled) {
//saving sourcemaps inline - external file causes Browsersync to reload whole page on SASS change
stream = stream.pipe(sourcemaps.write(/*'.'*/null, { sourceRoot: injector.taskConfig.sourceMapsRoot }));
}
}
stream = injector.run('dest', stream);
if (!injector.isCanceled) {
stream = stream.pipe(gulp.dest(appData.dirs.dist.styles));
}
stream = injector.run('reload', stream);
if (!injector.isCanceled) {
stream = stream.pipe(appData.browserSync.stream());
}
stream = injector.run('finish', stream);
return appData.app.taskUtils.streamToPromise(stream);
}