init: function(configFile) {
elixir.extend('pep', function() {
require('./helpers/Pep').init(configFile);
});
},
elixir(function(mix) {
elixir.extend('sourcemaps', false);
mix.less("style.less", "./WWW/css");
mix.scripts([
"app.js"
], "./WWW/js", "resources/assets/js");
});
module.exports = function(gulp, plugins, manifest) {
Elixir.extend('clean', function() {
new Elixir.Task('clean', function() {
console.log('Start Clean Task');
return (
gulp.src([
manifest.paths.dist + 'js',
manifest.paths.dist + 'css',
manifest.paths.dist + 'fonts',
manifest.paths.dist + 'images',
manifest.paths.build
], {
read: false
})
.pipe(plugins.clean())
);
});
});
};
var gulp = require('gulp');
var shell = require('gulp-shell');
var stripDebug = require('gulp-strip-debug');
var Elixir = require('laravel-elixir');
var Task = Elixir.Task;
Elixir.extend('tripdebug', function(src) {
new Task('tripdebug', function() {
return gulp.src(src)
.pipe(stripDebug())
.pipe(gulp.dest('public/app/pages'));
});
});
var elixir = require('laravel-elixir');
var gulp = require('gulp');
var gulpCopy = require('gulp-copy');
elixir.extend('copyHidden', function() {
return new elixir.Task('copyHidden', function() {
return gulp.src('app/includes/.*')
// prefix prevents creation of app/ and app/includes in public/
.pipe(gulpCopy('public/', {prefix: 2}));
});
});
var gulp = require('gulp');
var Elixir = require('laravel-elixir');
var $ = require('gulp-load-plugins')();
var config = Elixir.config;
Elixir.extend('clean', function(clean) {
var source = (clean) ? clean.source : config.clean.sourceFolder;
var pluginOptions = (clean) ? clean.options : config.clean.pluginOptions;
var readFile = (clean) ? clean.read : config.clean.read;
new Elixir.Task('clean', function() {
return gulp.src(source, {read: readFile})
.pipe($.clean(pluginOptions));
});
});
var elixir = require('laravel-elixir');
var compile = require('./commands/CompileCSS');
/*
|----------------------------------------------------------------
| Less Compilation Task
|----------------------------------------------------------------
|
| This task will compile your Less, including minification and
| and auto-prefixing. Less is one of the CSS pre-processors
| supported by Elixir, along with the Sass CSS processor.
|
*/
elixir.extend('less', function(src, output, options) {
return compile({
compiler: 'Less',
plugin: 'less',
pluginOptions: options,
src: src,
output: output || elixir.config.cssOutput,
search: '**/*.less'
});
});
var gulp = require('gulp');
var shell = require('gulp-shell');
var elixir = require('laravel-elixir');
elixir.config.assetsPath = './resources/';
elixir.config.publicPath = './public/';
elixir.config.sourcemaps = false;
elixir.config.production = true;
elixir.extend('artisan', function (command, watcher) {
new elixir.Task('artisan', function () {
return gulp.src('').pipe(shell('php ../../../artisan ' + command));
})
.watch(watcher);
});
elixir(function (mix) {
mix
.sass('app.scss')
.browserify('app.js')
.version([
elixir.config.publicPath + 'css/app.css',
elixir.config.publicPath + 'js/app.js'
])
.artisan(
'vendor:publish --tag=public --force',
elixir.config.publicPath + 'build/rev-manifest.json'
)
;
});
var webpackConfig = require('../webpack.config.js')
var Elixir = require('laravel-elixir');
var Task = Elixir.Task;
Elixir.extend('angular', function(src, output, outputFilename) {
var baseDir = src || Elixir.config.assetsPath + '/angular/';
new Task('angular in ' + baseDir, function() {
// Main file has to be included first.
return gulp.src([baseDir + "index.main.js", baseDir + "**/*.*.js"])
.pipe(eslint())
.pipe(eslint.format())
.pipe(gulpif(!config.production, sourcemaps.init()))
.pipe(webpack(webpackConfig))
.pipe(ngAnnotate())
.pipe(gulpif(config.production, uglify()))
.pipe(gulpif(!config.production, sourcemaps.write()))
.pipe(gulp.dest(output || config.js.outputFolder))
.pipe(notify({
title: 'Laravel Elixir',
subtitle: 'Angular Compiled!',
icon: __dirname + '/../node_modules/laravel-elixir/icons/laravel.png',
message: 'Angular Compiled!'
}));
}).watch(baseDir + '/**/*.js');
});
Elixir.extend('svg', function(src, output, options) {
var paths;
options = options || {};
config.svg = {
folder: 'svg',
outputFolder: 'svg',
imagemin: {
multipass: true
},
svgstore: {}
};
paths = prepGulpPaths(src, output);
new Elixir.Task('svg', function() {
this.log(paths.src, paths.output);
var errorHandler = function(e) {
new Elixir.Notification.error(e, 'SVG compilation failed');
this.emit('end');
};
return gulp.src(paths.src.path)
.pipe(svgstore(options.svgstore || config.svg.svgstore))
.pipe(imagemin(options.imagemin || config.svg.imagemin))
.pipe(rename(options.name || 'sprite.svg'))
.on('error', errorHandler)
.pipe(gulp.dest(paths.output.baseDir))
.pipe(new Elixir.Notification('SVG sprites compiled!'));
})
.watch(paths.src.path)
.ignore(paths.output.path);
});
var gulp=require("gulp"),Elixir=require("laravel-elixir"),_=require("underscore"),tinypng=require("gulp-tinypng-extended");const config=Elixir.config;config.img=_.extend({folder:"img",outputFolder:"img"},config.img||{});const gulpTask=function(i){var e=(new Elixir.GulpPaths).src(config.get("assets.img.folder")).output(config.get("public.img.outputFolder"));new Elixir.Task("tinypng",function(){return gulp.src(e.src.path+".{png,jpg,jpeg}").pipe(tinypng(i)).pipe(gulp.dest(e.output.path))}).watch(e.src.path+".{png,jpg,jpeg}")};Elixir.extend("tinypng",function(){gulpTask.apply(this,arguments)});
process.env.DISABLE_NOTIFIER = true;
var elixir = require('laravel-elixir'),
gulp = require('gulp'),
htmlmin = require('gulp-htmlmin');
elixir.extend('compress', function() {
new elixir.Task('compress', function() {
return gulp.src('./storage/framework/views/*')
.pipe(htmlmin({
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
minifyJS: true,
minifyCSS: true,
}))
.pipe(gulp.dest('./storage/framework/views/'));
})
.watch('./storage/framework/views/*');
});
elixir(function(mix) {
mix.compress();
mix.sass('app.scss');
mix.copy('resources/assets/fonts/material-design-icons', 'public/fonts/material-design-icons');
mix.copy('vendor/bower/material-design-lite/src/images/', 'public/images/');
mix.copy('vendor/bower/material-design-lite/material.js', 'public/js/');
mix.copy('vendor/bower/material-design-lite/material.min.js', 'public/js/');
'use strict';
var gulp = require('gulp');
var Elixir = require('laravel-elixir');
var _ = require('underscore');
var apidoc = require('gulp-apidoc');
Elixir.extend('apidoc', function (options) {
options = _.extend({
src: 'app/',
dest: 'public/docs/api'
}, options);
new Elixir.Task('apidoc', function () {
apidoc.exec({
src: options.src,
dest: options.dest
});
}).watch(options.src + '**/*.php');
});
var gulp = require('gulp');
var shell = require('gulp-shell');
var elixir = require('laravel-elixir');
require('laravel-elixir-vueify');
elixir.config.assetsPath = 'Assets/';
elixir.config.publicPath = 'Assets/';
elixir.config.js.outputFolder = 'dist/js';
var Task = elixir.Task;
elixir.extend('laroute', function(message) {
new Task('laroute', function() {
return gulp
.src('')
.pipe(shell('php ../../artisan laroute:generate'))
.pipe(new elixir.Notification('Laroute generated!'));
}).watch('Http/routes.php');
});
elixir(function(mix) {
mix.laroute();
mix.browserify('main.js');
//mix.browserSync({
// proxy: 'asgardcms.app',
// open: false
//});
});
var del = require('del');
var elixir = require('laravel-elixir');
var gulp = require('gulp');
var task = elixir.Task;
elixir.extend('remove', function (path) {
new task('remove', function () {
return del(path);
});
});
/*
|--------------------------------------------------------------------------
| Elixir Asset Management
|--------------------------------------------------------------------------
|
| Elixir provides a clean, fluent API for defining some basic Gulp tasks
| for your Laravel application. By default, we are compiling the Sass
| file for our application, as well as publishing vendor resources.
|
*/
elixir(function (mix) {
mix.remove([
'public/css',
'public/js',
'public/fonts',
'public/images',
'public/videos',
'public/csvs',
'public/packages',
var elixir = require('laravel-elixir');
var del = require('del');
elixir.extend('delete', function(src)
{
new elixir.Task('delete', function()
{
elixir.Log
.heading("Deleting files...")
.files(src, true);
return del(src);
});
});
exports.getElixir = function() {
return elixir;
};
Elixir.extend('browserify', function(src, output, baseDir, options) {
var paths = prepGulpPaths(src, baseDir, output);
loadPlugins();
new Elixir.Task('browserify', function() {
var stream = config.js.browserify.watchify.enabled
? watchifyStream
: browserifyStream;
bundle = function(stream, paths) {
this.log(paths.src, paths.output);
return (
stream
.bundle()
.on('error', function(e) {
new Elixir.Notification().error(e, 'Browserify Failed!');
this.emit('end');
})
.pipe(source(paths.output.name))
.pipe(buffer())
.pipe($.if(config.sourcemaps, $.sourcemaps.init({ loadMaps: true })))
.pipe($.if(config.production, $.uglify(config.js.uglify.options)))
.pipe($.if(config.sourcemaps, $.sourcemaps.write('.')))
.pipe(gulp.dest(paths.output.baseDir))
.pipe(new Elixir.Notification('Browserify Compiled!'))
);
}.bind(this);
return bundle(
stream({
paths: paths,
options: options || config.js.browserify.options
}),
paths
);
})
// We'll add this task to be watched, but Watchify
// will handle the process, to speed things up.
.watch();
});
var elixir = require('laravel-elixir');
var del = require('del');
var Elixir = require('laravel-elixir');
var Task = Elixir.Task;
Elixir.extend('clean', function(src) {
new Task('clean', function() {
return del(src);
});
});
elixir(function(mix) {
mix
.clean([
'public/assets',
'public/build',
])
.sass([
'app.scss'
], 'public/assets/css')
.babel([
'../../../node_modules/jquery/dist/jquery.js',
'../../../node_modules/bootstrap-sass/assets/javascripts/bootstrap.js',
'../../../node_modules/bootstrap-filestyle/src/bootstrap-filestyle.js',
'app.js'
], 'public/assets/js/app.js')
.copy(
'node_modules/bootstrap-sass/assets/fonts/bootstrap',
'public/build/assets/fonts/bootstrap'
)
var gulp = require('gulp');
var concat = require('gulp-concat');
var Elixir = require('laravel-elixir');
var Task = Elixir.Task;
Elixir.extend('concatScripts', function(scripts, dest) {
new Task('concat-scripts', function() {
return gulp.src(scripts)
.pipe(concat(dest))
.pipe(gulp.dest(Elixir.config.js.outputFolder));
}).watch(scripts);
});
var del = require('del');
var elixir = require('laravel-elixir');
elixir.extend('remove', function(path) {
new elixir.Task('remove', function() {
del(path);
});
});
elixir(function(mix) {
// mix.copy(
// 'resources/assets/fonts',
// 'public/build/fonts'
// );
mix.less('custom.less', 'public/css/dashboard/');
mix.browserify('bootstrap.min.js', 'public/js/dashboard/');
// Copy bootstrap and AdminLTE CSS files to public directory
mix.copy('bower_components/AdminLTE/bootstrap/css/bootstrap.css', 'public/css/dashboard/bootstrap.css');
mix.copy('bower_components/AdminLTE/dist/css/AdminLTE.css', 'public/css/dashboard/admin-lte.css');
mix.copy('bower_components/AdminLTE/dist/css/skins/_all-skins.css', 'public/css/dashboard/admin-lte-skin.css');
mix.copy('bower_components/AdminLTE/dist/js/app.js', 'public/js/dashboard/admin-lte.js');
// Copy fonts from Glypicons
mix.copy('bower_components/AdminLTE/bootstrap/fonts', 'public/build/fonts');
// Font Awesome
mix.copy('bower_components/font-awesome/css/font-awesome.css', 'public/css/dashboard/font-awesome.css');
elixir.extend('version', function(src, buildDir) {
src = utilities.prefixDirToFiles('public', src);
buildDir = buildDir ? buildDir + '/build' : 'public/build';
gulp.task('version', function() {
var files = vinylPaths();
del.sync(buildDir + '/*', { force: true });
return gulp.src(src, { base: './public' })
.pipe(gulp.dest(buildDir))
.pipe(files)
.pipe(rev())
.pipe(gulp.dest(buildDir))
.pipe(rev.manifest())
.pipe(gulp.dest(buildDir))
.on('end', function() {
// We'll get rid of the duplicated file that
// usually gets put in the "build" folder,
// alongside the suffixed version.
del(files.paths);
});
});
this.registerWatcher('version', src);
return this.queueTask('version');
});
var gulp = require("gulp");
var shell = require('gulp-shell');
var elixir = require('laravel-elixir');
var themeInfo = require('./theme.json');
var task = elixir.Task;
elixir.extend("stylistPublish", function() {
new task("stylistPublish", function() {
return gulp.src("").pipe(shell("php ../../artisan stylist:publish " + themeInfo.name));
}).watch("**/*.less");
});
/*
|--------------------------------------------------------------------------
| Elixir Asset Management
|--------------------------------------------------------------------------
|
| Elixir provides a clean, fluent API for defining some basic Gulp tasks
| for your Laravel application. By default, we are compiling the Sass
| file for our application, as well as publishing vendor resources.
|
*/
elixir(function (mix) {
/**
* Compile less
*/
mix
.less([
"asgard.less"
var $ = Elixir.Plugins;
/*
|----------------------------------------------------------------
| Copying
|----------------------------------------------------------------
|
| This task offers a simple way to copy files from one place to
| another. No more complicated than that! You may either set
| a single file or alternatively you can copy a full dir.
|
*/
Elixir.extend('copy', function(src, output) {
var paths = new Elixir.GulpPaths().src(src).output(output);
new Elixir.Task('copy', function() {
this.log(paths.src, paths.output);
return (
gulp
.src(paths.src.path, { dot: true })
.pipe($.if(! paths.output.isDir, $.rename(paths.output.name)))
.pipe(gulp.dest(paths.output.baseDir))
);
})
.watch(paths.src.path)
.ignore(paths.output.path);
});
*
* @param {object} options
* @param {bool} useRuby
* @returns {object}
*/
var buildOptions = function(options, useRuby) {
var defaults = {};
var outputStyle = useRuby ? 'style' : 'outputStyle';
defaults[outputStyle] = inProduction ? 'compressed' : 'nested';
return _.extend(defaults, options);
};
/*
|----------------------------------------------------------------
| Sass Compilation Task
|----------------------------------------------------------------
|
| This task will compile your Sass, including minification and
| and auto-prefixing. Sass is one of the CSS pre-precessors
| supported by Elixir, along with the Less CSS processor.
|
*/
elixir.extend('sass', addSassTask);
elixir.extend('rubySass', function(src, output, options) {
return addSassTask(src, output, options, true);
});
const gulp = require('gulp');
const Elixir = require('laravel-elixir');
const Task = Elixir.Task;
const htmlmin = require('gulp-htmlmin');
const rtlcss = require('gulp-rtlcss');
const rename = require('gulp-rename');
Elixir.extend('compressHtml', function() {
new Task('compressHtml', function() {
const opts = {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
minifyJS: true
};
return gulp.src('./storage/framework/views/*')
.pipe(htmlmin(opts))
.pipe(gulp.dest('./storage/framework/views/'))
}).watch('./storage/framework/views/*')
});
Elixir.extend('rtlCss', function() {
new Task('rtlCss', function() {
return gulp.src('./resources/assets/css/backend/app.css')
.pipe(rtlcss())
.pipe(rename({ basename: 'backend', suffix: '-rtl' }))
.pipe(gulp.dest('./public/css/'));
})
});
var gulp = require('gulp');
var jshint = require('gulp-jshint');
var Elixir = require('laravel-elixir');
var config = Elixir.config;
Elixir.extend('jshint', function(src, options) {
'use strict';
var paths = new Elixir.GulpPaths().src(src || [
config.get('assets.js.folder') + '/**/*.js',
'!' + config.get('assets.js.folder') + '/vendor/**/*.js',
]);
paths.output = [];
new Elixir.Task('jshint', function() {
return gulp
.src(paths.src.path)
.pipe(jshint(options || {}))
.pipe(jshint.reporter('jshint-stylish'))
.pipe(jshint.reporter('fail'))
.on('error', function(e) {
new Elixir.Notification().error(e, 'JSHint Failed!');
this.emit('end');
})
.pipe(new Elixir.Notification('JSHint Passed!'));
}, paths)
.watch(paths.src.path);
});
var Elixir = require('laravel-elixir');
var del = require('del');
var Task = Elixir.Task;
Elixir.extend('delete', function (paths) {
new Task('delete', function () {
return del(paths);
}, {src: paths, output: 'trash!'}
).recordStep('Deleting Paths');
});
};
/**
* Hook into elixir's API and register the "cachebust" method.
*/
elixir.extend('cachebust',function(src, options){
// overwrite default values in the options.
options = objectAssign(
{ // default settings
method:'hash',
length: 8,
baseDir: "public/",
file: "cachebuster.json"
},
options || {});
src = utilities.prefixDirToFiles(options.baseDir, src);
gulp.task("cache-busting", function() {
return gulp.src( src, {base: './public'} )
.pipe(cacheBust(options))
.pipe(gulp.dest(options.baseDir));
});
this.registerWatcher("cache-busting",src);
return this.queueTask("cache-busting");
});
'sass' : assetsDir + 'sass/', // SASS directory
'js' : assetsDir + 'javascripts/', // JS source directory
'adminjs' : assetsDir + 'javascripts/admin/', // Administration JS source directory
'svg' : assetsDir + 'svg/' // SVG definitions file
},
'fonts' : './public/fonts/', // Public fonts directory
'css' : './public/css/', // Public CSS directory
'javascripts' : './public/js/', // Public JS directory
'svg' : './public/svg/' // Public SVG directory
};
elixir.extend('say', function (message) {
gulp.task('say', function (e) {
var time = '[' + chalk.grey(dateformat(new Date(), 'HH:MM:ss')) + ']';
console.error(time +
chalk.dim.bold.blue(' [' + chalk.cyan.underline('Petrie') + '] ') +
chalk.green(message) + chalk.white(''));
});
return this.queueTask('say');
});
elixir.extend('petrieSass', function (mix) {
var Notification = require(nodeDir + 'laravel-elixir/ingredients/commands/Notification.js');
var notify = new Notification();
gulp.task('style', function () {
return sass(assetsDir + '/sass/style.scss', {
sourcemap : config.sass.sourcemap,
lineNumbers: config.sass.lineNumbers,
container : 'gulp-ruby-sass-style'
})
Elixir.extend('fontastic', function(apiKey, stylePath, fontDir, fontPath, fontName, scss) {
if (apiKey === undefined) {
return new Elixir.Log.message('ERROR: API key missing for Fontastic');
}
fontDir = (fontDir === undefined) ? 'fonts' : fontDir;
stylePath = (stylePath === undefined) ? 'scss' : stylePath;
var options = {
key: apiKey,
style_path: stylePath,
font_dir: fontDir,
font_path: fontPath,
scss: scss
};
new Elixir.Log.message(options);
if (fontName !== undefined) {
options.font_name = fontName;
}
new Task('fontastic', function() {
new Elixir.Log.message('Downloading from Fontastic...');
return gulp.src('')
.pipe(fontastic(options));
});
});