Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHESPTRUFRDEEN

Elysia Tools

Navigation

Build Tools

Grunt directory templates, separators and task order | Elysia Tools

Work through three bounded Grunt examples with explicit inputs and independently checkable outcomes.

Samples

Entries inside this sample collection

CodejavascriptSimple

Grunt Basic Tasks

Essential Grunt tasks for modern web development including file processing, watching, and building

Difficulty

3/10

Estimated time

20 min

Tags

grunt, automation, build

Prerequisites

Node.js knowledge, JavaScript basics

javascript
// Grunt Basic Tasks Setup
// Modern Grunt configuration for web development workflows

// ===== package.json =====
{
  "name": "my-grunt-project",
  "version": "1.0.0",
  "description": "Modern web application using Grunt for task automation",
  "main": "index.js",
  "scripts": {
    "dev": "grunt dev",
    "build": "grunt build",
    "watch": "grunt watch",
    "clean": "grunt clean",
    "serve": "grunt serve",
    "test": "grunt test",
    "lint": "grunt lint",
    "deploy": "grunt deploy"
  },
  "devDependencies": {
    "grunt": "^1.6.1",
    "grunt-cli": "^1.4.3",
    "grunt-contrib-sass": "^2.0.0",
    "grunt-contrib-watch": "^1.1.0",
    "grunt-contrib-clean": "^2.0.1",
    "grunt-contrib-copy": "^1.0.0",
    "grunt-contrib-concat": "^2.1.0",
    "grunt-contrib-uglify": "^5.2.2",
    "grunt-contrib-cssmin": "^4.0.0",
    "grunt-contrib-imagemin": "^4.0.0",
    "grunt-contrib-htmlmin": "^3.1.0",
    "grunt-contrib-compress": "^2.0.0",
    "grunt-browser-sync": "^2.2.0",
    "grunt-eslint": "^24.3.0",
    "grunt-stylelint": "^0.18.0",
    "grunt-postcss": "^0.9.0",
    "grunt-autoprefixer": "^4.0.0",
    "grunt-sass-lint": "^0.2.4",
    "grunt-babel": "^8.0.0",
    "@babel/core": "^7.20.0",
    "@babel/preset-env": "^7.20.0",
    "@babel/preset-react": "^7.18.0",
    "grunt-filerev": "^4.0.0",
    "grunt-usemin": "^3.1.1",
    "grunt-replace": "^2.0.2",
    "grunt-newer": "^1.3.0",
    "grunt-notify": "^0.4.5",
    "grunt-shell": "^4.0.0",
    "grunt-run": "^0.8.1",
    "grunt-string-replace": "^1.3.1",
    "grunt-banner": "^0.6.7",
    "grunt-text-replace": "^0.4.0",
    "load-grunt-tasks": "^5.1.0",
    "time-grunt": "^2.0.0",
    "jit-grunt": "^0.10.0",
    "dotenv": "^16.0.0"
  }
}

// ===== Gruntfile.js =====
module.exports = function(grunt) {
    'use strict';

    // Load environment variables
    require('dotenv').config();

    // Measure build time
    require('time-grunt')(grunt);

    // Load grunt tasks automatically
    require('jit-grunt')(grunt, {
        'babel': 'grunt-babel',
        'stylelint': 'grunt-stylelint',
        'sasslint': 'grunt-sass-lint'
    });

    // Project configuration
    grunt.initConfig({
        // Project settings
        pkg: grunt.file.readJSON('package.json'),

        // Environment settings
        env: process.env,

        // Directory structure
        dirs: {
            src: 'src',
            dist: 'dist',
            tmp: '.tmp',
            css: 'src/scss',
            js: 'src/js',
            images: 'src/images',
            fonts: 'src/fonts',
            vendor: 'src/vendor'
        },

        // Clean task
        clean: {
            dist: {
                src: ['<%= dirs.dist %>/**/*', '!<%= dirs.dist %>/.gitkeep']
            },
            tmp: {
                src: ['<%= dirs.tmp %>/**/*']
            },
            server: {
                src: ['.sass-cache']
            }
        },

        // Copy task
        copy: {
            dist: {
                files: [{
                    expand: true,
                    dot: true,
                    cwd: '<%= dirs.src %>',
                    dest: '<%= dirs.dist %>',
                    src: [
                        '*.{ico,png,txt}',
                        '.htaccess',
                        'images/{,*/}*.{webp,gif}',
                        'fonts/**/*',
                        'vendor/**/*'
                    ]
                }]
            },
            styles: {
                expand: true,
                dot: true,
                cwd: '<%= dirs.src %>',
                dest: '<%= dirs.dist %>',
                src: 'css/**/*.css'
            }
        },

        // Sass/SCSS compilation
        sass: {
            options: {
                implementation: require('sass'),
                sourceMap: true,
                outputStyle: 'expanded'
            },
            dist: {
                files: {
                    '<%= dirs.tmp %>/css/main.css': '<%= dirs.css %>/main.scss',
                    '<%= dirs.tmp %>/css/components.css': '<%= dirs.css %>/components.scss'
                }
            },
            server: {
                options: {
                    sourceMap: true
                },
                files: {
                    '<%= dirs.tmp %>/css/main.css': '<%= dirs.css %>/main.scss'
                }
            }
        },

        // PostCSS processing (autoprefixer)
        postcss: {
            options: {
                processors: [
                    require('autoprefixer')({
                        overrideBrowserslist: ['last 2 versions', 'not dead']
                    })
                ]
            },
            dist: {
                src: '<%= dirs.tmp %>/css/*.css'
            }
        },

        // CSS minification
        cssmin: {
            options: {
                level: 2,
                compatibility: 'ie8'
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= dirs.tmp %>/css',
                    dest: '<%= dirs.dist %>/css',
                    src: ['*.css', '!*.min.css'],
                    ext: '.min.css'
                }]
            }
        },

        // JavaScript concatenation
        concat: {
            options: {
                separator: ';'
            },
            dist: {
                src: [
                    '<%= dirs.js %>/libs/jquery.js',
                    '<%= dirs.js %>/libs/bootstrap.js',
                    '<%= dirs.js %>/plugins/*.js',
                    '<%= dirs.js %>/main.js'
                ],
                dest: '<%= dirs.tmp %>/js/scripts.js'
            }
        },

        // Babel transpilation
        babel: {
            options: {
                sourceMap: true,
                presets: [
                    ['@babel/preset-env', {
                        targets: {
                            browsers: ['last 2 versions', 'not dead']
                        }
                    }]
                ]
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= dirs.js %>',
                    src: ['**/*.js', '!libs/**/*.js', '!vendor/**/*.js'],
                    dest: '<%= dirs.tmp %>/js'
                }]
            }
        },

        // JavaScript minification
        uglify: {
            options: {
                banner: '/*! <%= pkg.name %> <%= grunt.template.today("yyyy-mm-dd") %> */\n',
                mangle: true,
                compress: {
                    drop_console: true,
                    drop_debugger: true
                }
            },
            dist: {
                files: {
                    '<%= dirs.dist %>/js/scripts.min.js': ['<%= dirs.tmp %>/js/scripts.js']
                }
            }
        },

        // HTML minification
        htmlmin: {
            dist: {
                options: {
                    collapseWhitespace: true,
                    conservativeCollapse: true,
                    collapseBooleanAttributes: true,
                    removeCommentsFromCDATA: true,
                    removeOptionalTags: true,
                    removeRedundantAttributes: true,
                    removeScriptTypeAttributes: true,
                    removeStyleLinkTypeAttributes: true,
                    useShortDoctype: true,
                    minifyCSS: true,
                    minifyJS: true
                },
                files: [{
                    expand: true,
                    cwd: '<%= dirs.src %>',
                    src: '**/*.html',
                    dest: '<%= dirs.dist %>'
                }]
            }
        },

        // Image optimization
        imagemin: {
            dist: {
                options: {
                    optimizationLevel: 7,
                    progressive: true,
                    interlaced: true,
                    svgoPlugins: [{ removeViewBox: false }]
                },
                files: [{
                    expand: true,
                    cwd: '<%= dirs.images %>',
                    src: ['**/*.{png,jpg,jpeg,gif,svg}'],
                    dest: '<%= dirs.dist %>/images'
                }]
            }
        },

        // File versioning
        filerev: {
            options: {
                encoding: 'utf8',
                algorithm: 'md5',
                length: 8
            },
            dist: {
                src: [
                    '<%= dirs.dist %>/js/*.js',
                    '<%= dirs.dist %>/css/*.css',
                    '<%= dirs.dist %>/images/**/*.{png,jpg,jpeg,gif,webp,svg}',
                    '<%= dirs.dist %>/fonts/**/*.{eot,svg,ttf,woff,woff2}'
                ]
            }
        },

        // Usemin for HTML asset replacement
        useminPrepare: {
            html: '<%= dirs.src %>/index.html',
            options: {
                dest: '<%= dirs.dist %>',
                flow: {
                    html: {
                        steps: {
                            js: ['concat', 'uglifyjs'],
                            css: ['cssmin']
                        },
                        post: {}
                    }
                }
            }
        },

        usemin: {
            html: ['<%= dirs.dist %>/**/*.html'],
            css: ['<%= dirs.dist %>/css/**/*.css'],
            options: {
                assetsDirs: [
                    '<%= dirs.dist %>',
                    '<%= dirs.dist %>/images',
                    '<%= dirs.dist %>/css'
                ]
            }
        },

        // ESLint for JavaScript
        eslint: {
            options: {
                configFile: '.eslintrc.json',
                failOnError: false,
                quiet: true
            },
            target: ['<%= dirs.js %>/**/*.js', '!<%= dirs.js %>/vendor/**/*']
        },

        // Stylelint for CSS/SCSS
        stylelint: {
            all: {
                src: ['<%= dirs.css %>/**/*.scss'],
                options: {
                    configFile: '.stylelintrc.json',
                    failOnError: false,
                    quiet: true
                }
            }
        },

        // Sass linting
        sasslint: {
            allFiles: {
                src: ['<%= dirs.css %>/**/*.scss'],
                options: {
                    configFile: '.sass-lint.yml'
                }
            }
        },

        // Banner for files
        banner: {
            dist: {
                options: {
                    banner: '/*! <%= pkg.name %> <%= pkg.version %> - <%= grunt.template.today("yyyy-mm-dd") %> */\n'
                },
                files: {
                    src: ['<%= dirs.dist %>/css/*.css', '<%= dirs.dist %>/js/*.js']
                }
            }
        },

        // File replacement
        replace: {
            dist: {
                options: {
                    patterns: [{
                        match: /VERSION/g,
                        replacement: '<%= pkg.version %>'
                    }, {
                        match: /BUILD_DATE/g,
                        replacement: '<%= grunt.template.today("yyyy-mm-dd") %>'
                    }]
                },
                files: [{
                    expand: true,
                    flatten: true,
                    src: ['<%= dirs.dist %>/**/*.html'],
                    dest: '<%= dirs.dist %>'
                }]
            }
        },

        // Browser sync for development
        browserSync: {
            dev: {
                bsFiles: {
                    src: [
                        '<%= dirs.tmp %>/css/**/*.css',
                        '<%= dirs.tmp %>/js/**/*.js',
                        '<%= dirs.src %>/**/*.html'
                    ]
                },
                options: {
                    watchTask: true,
                    server: {
                        baseDir: ['<%= dirs.tmp %>', '<%= dirs.src %>'],
                        routes: {
                            '/bower_components': 'bower_components'
                        }
                    },
                    port: 3000,
                    open: true,
                    notify: false
                }
            }
        },

        // Watch task
        watch: {
            options: {
                livereload: true,
                spawn: false
            },
            sass: {
                files: ['<%= dirs.css %>/**/*.{scss,sass}'],
                tasks: ['sass:server', 'postcss']
            },
            js: {
                files: ['<%= dirs.js %>/**/*.js', '!<%= dirs.js %>/vendor/**/*'],
                tasks: ['eslint', 'babel']
            },
            html: {
                files: ['<%= dirs.src %>/**/*.html'],
                tasks: ['copy:html']
            },
            images: {
                files: ['<%= dirs.images %>/**/*.{png,jpg,jpeg,gif,webp,svg}'],
                tasks: ['newer:imagemin']
            }
        },

        // Shell commands
        shell: {
            testUnit: {
                command: 'npm run test:unit'
            },
            testE2E: {
                command: 'npm run test:e2e'
            },
            buildProduction: {
                command: 'NODE_ENV=production npm run build'
            }
        },

        // Notify for build completion
        notify: {
            buildComplete: {
                options: {
                    title: 'Build Complete',
                    message: 'Build completed successfully!'
                }
            },
            watchStart: {
                options: {
                    title: 'Grunt Watch',
                    message: 'Watching files for changes...'
                }
            }
        },

        // ZIP creation
        compress: {
            dist: {
                options: {
                    archive: 'dist-<%= pkg.version %>.zip',
                    mode: 'zip',
                    level: 9,
                    pretty: true
                },
                files: [{
                    src: ['**'],
                    cwd: '<%= dirs.dist %>',
                    expand: true
                }]
            }
        }
    });

    // Development task
    grunt.registerTask('dev', [
        'clean:tmp',
        'clean:server',
        'sass:server',
        'postcss',
        'babel',
        'browserSync',
        'watch',
        'notify:watchStart'
    ]);

    // Build task
    grunt.registerTask('build', [
        'clean:dist',
        'clean:tmp',
        'sass:dist',
        'postcss',
        'babel',
        'concat',
        'copy',
        'cssmin',
        'uglify',
        'htmlmin',
        'imagemin',
        'filerev',
        'usemin',
        'banner:dist',
        'replace:dist',
        'notify:buildComplete'
    ]);

    // Test task
    grunt.registerTask('test', [
        'eslint',
        'stylelint',
        'sasslint',
        'shell:testUnit'
    ]);

    // Lint task
    grunt.registerTask('lint', [
        'eslint',
        'stylelint',
        'sasslint'
    ]);

    // Default task
    grunt.registerTask('default', [
        'build'
    ]);

    // Serve task
    grunt.registerTask('serve', [
        'dev'
    ]);

    // Deploy task
    grunt.registerTask('deploy', [
        'test',
        'build',
        'compress:dist'
    ]);

    // Custom task: Build stats
    grunt.registerTask('build-stats', 'Display build statistics', function() {
        var distDir = grunt.config('dirs.dist');
        var fs = require('fs');
        var path = require('path');
        var stats = {
            files: 0,
            totalSize: 0,
            extensions: {}
        };

        function processDirectory(dir) {
            var files = fs.readdirSync(dir);

            files.forEach(function(file) {
                var filePath = path.join(dir, file);
                var stat = fs.statSync(filePath);

                if (stat.isDirectory()) {
                    processDirectory(filePath);
                } else {
                    stats.files++;
                    stats.totalSize += stat.size;

                    var ext = path.extname(file).toLowerCase();
                    if (ext) {
                        stats.extensions[ext] = (stats.extensions[ext] || 0) + 1;
                    }
                }
            });
        }

        if (fs.existsSync(distDir)) {
            processDirectory(distDir);
        }

        grunt.log.writeln('Build Statistics:');
        grunt.log.writeln('----------------');
        grunt.log.writeln('Total files: ' + stats.files);
        grunt.log.writeln('Total size: ' + (stats.totalSize / 1024).toFixed(2) + ' KB');
        grunt.log.writeln('Extensions:');

        Object.keys(stats.extensions).forEach(function(ext) {
            grunt.log.writeln('  ' + ext + ': ' + stats.extensions[ext]);
        });
    });

    // Custom task: Environment check
    grunt.registerTask('env-check', 'Check environment requirements', function() {
        var nodeVersion = process.version;
        var npmVersion = require('child_process')
            .execSync('npm --version', { encoding: 'utf8' })
            .trim();

        grunt.log.writeln('Environment Check:');
        grunt.log.writeln('-----------------');
        grunt.log.writeln('Node.js: ' + nodeVersion);
        grunt.log.writeln('npm: ' + npmVersion);
        grunt.log.writeln('Environment: ' + (grunt.config('env.NODE_ENV') || 'development'));

        // Check required versions
        var requiredNode = '>=14.0.0';
        if (require('semver').satisfies(nodeVersion, requiredNode)) {
            grunt.log.ok('Node.js version satisfies requirement: ' + requiredNode);
        } else {
            grunt.log.error('Node.js version does not satisfy requirement: ' + requiredNode);
        }
    });
};
CodejavascriptIntermediate

Grunt Advanced Workflows

Advanced Grunt workflows including multi-target builds, optimization, and deployment strategies

Difficulty

7/10

Estimated time

35 min

Tags

grunt, workflows, optimization

Prerequisites

Grunt basics, JavaScript optimization, Build processes

javascript
// Grunt Advanced Workflows
// Complex build processes, optimization, and deployment automation

module.exports = function(grunt) {
    'use strict';

    // Load all grunt tasks
    require('load-grunt-tasks')(grunt);

    // Load environment-specific configuration
    var envConfig = grunt.file.exists('grunt-config.js')
        ? require('./grunt-config')(grunt)
        : {};

    // Merge configurations
    grunt.util._.merge(grunt.config(), envConfig);

    // Advanced configuration
    grunt.initConfig({
        // Multi-environment configuration
        environments: {
            development: {
                dirs: {
                    src: 'src',
                    dist: 'dist-dev',
                    tmp: '.tmp-dev'
                },
                optimization: false,
                sourcemaps: true,
                minify: false,
                watch: true,
                livereload: true
            },
            staging: {
                dirs: {
                    src: 'src',
                    dist: 'dist-staging',
                    tmp: '.tmp-staging'
                },
                optimization: true,
                sourcemaps: true,
                minify: true,
                watch: false,
                livereload: false
            },
            production: {
                dirs: {
                    src: 'src',
                    dist: 'dist-prod',
                    tmp: '.tmp-prod'
                },
                optimization: true,
                sourcemaps: false,
                minify: true,
                watch: false,
                livereload: false
            }
        },

        // Dynamic configuration based on environment
        env: grunt.option('env') || 'development',
        config: grunt.config('environments.<%= env %>'),

        // Advanced clean task with patterns
        clean: {
            dist: {
                files: [{
                    dot: true,
                    src: [
                        '<%= config.dirs.dist %>/**/*',
                        '!<%= config.dirs.dist %>/.gitkeep'
                    ]
                }]
            },
            temp: {
                files: [{
                    dot: true,
                    src: [
                        '<%= config.dirs.tmp %>/**/*',
                        '.sass-cache/**/*',
                        '.tmp/**/*'
                    ]
                }]
            },
            legacy: {
                files: [{
                    src: [
                        'dist/**/*',
                        'tmp/**/*',
                        '.cache/**/*'
                    ]
                }]
            }
        },

        // Multi-target sass compilation
        sass: {
            options: {
                implementation: require('sass'),
                sourceMap: '<%= config.sourcemaps %>',
                outputStyle: '<%= config.minify ? "compressed" : "expanded" %>'
            },
            main: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/scss',
                    src: ['**/*.scss', '!**/_*.scss'],
                    dest: '<%= config.dirs.tmp %>/css',
                    ext: '.css'
                }]
            },
            critical: {
                options: {
                    outputStyle: 'expanded'
                },
                files: {
                    '<%= config.dirs.tmp %>/css/critical.css':
                        '<%= config.dirs.src %>/scss/critical.scss'
                }
            },
            themes: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/scss/themes',
                    src: ['**/*.scss'],
                    dest: '<%= config.dirs.tmp %>/css/themes',
                    ext: '.css'
                }]
            }
        },

        // Advanced PostCSS with multiple processors
        postcss: {
            options: {
                processors: [
                    require('autoprefixer')({
                        overrideBrowserslist: ['last 2 versions', 'not dead']
                    }),
                    require('postcss-flexbugs-fixes')(),
                    require('postcss-preset-env')({
                        stage: 2,
                        features: {
                            'custom-properties': true,
                            'nesting': true,
                            'calc': true
                        }
                    })
                ].concat(
                    grunt.config('config.minify')
                    ? [require('cssnano')({ preset: 'default' })]
                    : []
                )
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.tmp %>/css',
                    src: ['**/*.css'],
                    dest: '<%= config.dirs.tmp %>/css'
                }]
            }
        },

        // Advanced Babel with environment-specific presets
        babel: {
            options: {
                sourceMap: '<%= config.sourcemaps %>',
                presets: [
                    ['@babel/preset-env', {
                        targets: {
                            browsers: grunt.config('config.env') === 'production'
                                ? ['> 0.5%', 'not dead']
                                : ['last 2 versions']
                        },
                        modules: false,
                        useBuiltIns: 'usage',
                        corejs: 3
                    }]
                ],
                plugins: [
                    '@babel/plugin-proposal-class-properties',
                    '@babel/plugin-proposal-object-rest-spread'
                ].concat(
                    grunt.config('config.env') === 'production'
                    ? ['@babel/plugin-transform-runtime']
                    : []
                )
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/js',
                    src: ['**/*.js', '!**/*.min.js'],
                    dest: '<%= config.dirs.tmp %>/js'
                }]
            }
        },

        // Advanced concatenation with multiple targets
        concat: {
            options: {
                separator: grunt.config('config.minify') ? ';' : ';\n',
                process: function(src, filepath) {
                    return '// Source: ' + filepath + '\n' + src;
                }
            },
            vendor: {
                files: {
                    '<%= config.dirs.tmp %>/js/vendor.js': [
                        '<%= config.dirs.src %>/js/libs/jquery.js',
                        '<%= config.dirs.src %>/js/libs/bootstrap.js',
                        '<%= config.dirs.src %>/js/libs/modernizr.js'
                    ]
                }
            },
            app: {
                files: {
                    '<%= config.dirs.tmp %>/js/app.js': [
                        '<%= config.dirs.tmp %>/js/app/**/*.js',
                        '!<%= config.dirs.tmp %>/js/app/vendor.js'
                    ]
                }
            },
            themes: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/js/themes',
                    src: ['**/*.js'],
                    dest: '<%= config.dirs.tmp %>/js/themes',
                    ext: '.bundle.js'
                }]
            }
        },

        // Advanced uglify with multiple configurations
        uglify: {
            options: {
                banner: '/*! <%= pkg.name %> <%= pkg.version %> - ' +
                       grunt.template.today('yyyy-mm-dd') + ' */\n',
                sourceMap: '<%= config.sourcemaps %>',
                sourceMapIncludeSources: true,
                sourceMapRoot: '../../<%= config.dirs.src %>/js',
                mangle: grunt.config('config.minify'),
                compress: {
                    drop_console: grunt.config('config.minify'),
                    drop_debugger: grunt.config('config.minify'),
                    dead_code: true,
                    unused: true,
                    warnings: false
                },
                output: {
                    comments: grunt.config('config.minify') ? false : /^!/
                }
            },
            vendor: {
                files: [{
                    '<%= config.dirs.dist %>/js/vendor.min.js':
                        '<%= concat.vendor.files[0]["<%= config.dirs.tmp %>/js/vendor.js"] %>'
                }]
            },
            app: {
                files: [{
                    '<%= config.dirs.dist %>/js/app.min.js':
                        '<%= concat.app.files[0]["<%= config.dirs.tmp %>/js/app.js"] %>'
                }]
            },
            themes: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.tmp %>/js/themes',
                    src: ['**/*.bundle.js'],
                    dest: '<%= config.dirs.dist %>/js/themes',
                    ext: '.min.js'
                }]
            }
        },

        // Critical CSS extraction
        critical: {
            options: {
                base: '<%= config.dirs.dist %>/',
                css: [
                    '<%= config.dirs.dist %>/css/main.min.css'
                ],
                width: 1200,
                height: 900,
                minify: grunt.config('config.minify'),
                extract: true,
                ignore: []
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>',
                    src: ['**/*.html', '!**/_*.html'],
                    dest: '<%= config.dirs.dist %>'
                }]
            }
        },

        // Advanced image optimization with different strategies
        imagemin: {
            options: {
                cache: false,
                optimizationLevel: grunt.config('config.optimization') ? 7 : 3,
                progressive: true,
                interlaced: true
            },
            static: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/images',
                    src: ['**/*.{png,jpg,jpeg,gif,svg}'],
                    dest: '<%= config.dirs.dist %>/images'
                }]
            },
            dynamic: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/images/uploads',
                    src: ['**/*.{png,jpg,jpeg,gif,svg,webp}'],
                    dest: '<%= config.dirs.dist %>/images/uploads'
                }]
            },
            icons: {
                options: {
                    optimizationLevel: 7,
                    svgoPlugins: [{
                        removeViewBox: false,
                        removeEmptyAttrs: false
                    }]
                },
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/icons',
                    src: ['**/*.svg'],
                    dest: '<%= config.dirs.dist %>/icons'
                }]
            }
        },

        // Sprite generation
        sprite: {
            options: {
                spritemap: '<%= config.dirs.src %>/images/sprite/**/*.png',
                spritesmithPath: require('spritesmith'),
                engine: 'pixelsmith',
                algorithm: 'binary-tree',
                padding: 2
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>/scss',
                    src: ['*.scss'],
                    dest: '<%= config.dirs.tmp %>/scss',
                    rename: function(name) {
                        return '_' + name;
                    }
                }],
                dest: {
                    '<%= config.dirs.tmp %>/images': 'sprite.png'
                }
            }
        },

        // Advanced HTML processing
        processhtml: {
            options: {
                includeBase: '<%= config.dirs.src %>/',
                commentMarker: 'build',
                strip: true,
                data: {
                    version: '<%= pkg.version %>',
                    buildDate: grunt.template.today('yyyy-mm-dd'),
                    environment: grunt.config('config.env')
                }
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.src %>',
                    src: ['**/*.html', '!**/_*.html'],
                    dest: '<%= config.dirs.dist %>'
                }]
            }
        },

        // Advanced file versioning
        filerev: {
            options: {
                algorithm: 'sha256',
                length: 12
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.dist %>',
                    src: [
                        'js/**/*.js',
                        'css/**/*.css',
                        'images/**/*.{png,jpg,jpeg,gif,webp,svg}',
                        'fonts/**/*.{eot,svg,ttf,woff,woff2}'
                    ]
                }]
            }
        },

        // Asset rewriting
        replace: {
            assets: {
                options: {
                    patterns: [{
                        match: /assets\/images\//g,
                        replacement: 'assets/images/'
                    }, {
                        match: /assets\/css\//g,
                        replacement: function(match) {
                            return grunt.filerev.replacements[match] || match;
                        }
                    }, {
                        match: /assets\/js\//g,
                        replacement: function(match) {
                            return grunt.filerev.replacements[match] || match;
                        }
                    }]
                },
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.dist %>',
                    src: ['**/*.html', '**/*.css', '**/*.js']
                }]
            }
        },

        // Cache busting with file hashes
        cacheBust: {
            options: {
                baseDir: '<%= config.dirs.dist %>',
                assets: ['js/**/*.js', 'css/**/*.css'],
                createCopies: false
            },
            dist: {
                files: [{
                    expand: true,
                    cwd: '<%= config.dirs.dist %>',
                    src: ['**/*.html']
                }]
            }
        },

        // Progressive enhancement for IE
        legacy: {
            ie8: {
                options: {
                    dest: '<%= config.dirs.dist %>/legacy',
                    minify: false
                },
                files: {
                    '<%= config.dirs.dist %>/legacy/js/app.ie8.js':
                        '<%= config.dirs.src %>/js/ie/app.ie8.js'
                }
            }
        },

        // Advanced watch with livereload and reload on different events
        watch: {
            options: {
                livereload: {
                    port: 35729,
                    hostname: 'localhost'
                },
                spawn: false,
                interval: 1000
            },
            sass: {
                files: ['<%= config.dirs.src %>/scss/**/*.{scss,sass}'],
                tasks: ['sass', 'postcss'],
                options: {
                    livereload: true
                }
            },
            js: {
                files: ['<%= config.dirs.src %>/js/**/*.js', '!**/*.min.js'],
                tasks: ['babel', 'concat', 'uglify'],
                options: {
                    livereload: true
                }
            },
            images: {
                files: ['<%= config.dirs.src %>/images/**/*.{png,jpg,jpeg,gif,svg,webp}'],
                tasks: ['newer:imagemin'],
                options: {
                    livereload: true
                }
            },
            config: {
                files: ['Gruntfile.js', 'grunt-config.js'],
                tasks: ['config-reload'],
                options: {
                    reload: true
                }
            }
        },

        // Code quality tasks
        eslint: {
            options: {
                configFile: '.eslintrc.json',
                fix: grunt.config('config.env') === 'development',
                cache: true,
                quiet: true
            },
            target: [
                '<%= config.dirs.src %>/js/**/*.js',
                '!<%= config.dirs.src %>/js/vendor/**/*',
                '!<%= config.dirs.src %>/js/libs/**/*'
            ]
        },

        // Performance budgeting
        filesize: {
            options: {
                gzip: true,
                showFiles: true,
                showSizes: true
            },
            js: {
                files: '<%= config.dirs.dist %>/js/**/*.js'
            },
            css: {
                files: '<%= config.dirs.dist %>/css/**/*.css'
            }
        },

        // Bundle analysis
        bundlesize: {
            options: {
                maxSize: '200kb',
                gzip: true
            },
            main: {
                src: '<%= config.dirs.dist %>/js/app.min.js'
            }
        },

        // Custom tasks and workflows
        concurrent: {
            options: {
                logConcurrentOutput: true
            },
            dev: ['watch', 'connect'],
            build: ['sass', 'babel', 'imagemin'],
            deploy: ['build', 'test']
        },

        // Server configuration
        connect: {
            options: {
                port: 9000,
                hostname: 'localhost',
                base: '<%= config.dirs.tmp %>',
                livereload: true,
                open: true,
                middleware: function(connect, options, middlewares) {
                    // Custom middleware for API proxy
                    var proxy = require('grunt-connect-proxy/lib/utils').proxyRequest;
                    middlewares.unshift(proxy);
                    return middlewares;
                }
            },
            proxies: [{
                context: '/api',
                host: 'localhost',
                port: 8080,
                https: false,
                changeOrigin: false,
                xforward: false
            }],
            livereload: {
                options: {
                    base: '<%= config.dirs.tmp %>',
                    open: {
                        target: 'http://localhost:9000'
                    }
                }
            }
        }
    });

    // Environment-specific task registration
    grunt.registerTask('build:dev', function() {
        grunt.option('env', 'development');
        grunt.task.run(['build']);
    });

    grunt.registerTask('build:staging', function() {
        grunt.option('env', 'staging');
        grunt.task.run(['build']);
    });

    grunt.registerTask('build:prod', function() {
        grunt.option('env', 'production');
        grunt.task.run(['build']);
    });

    // Main build task
    grunt.registerTask('build', 'Build the application', function() {
        var tasks = [
            'clean',
            'sass',
            'postcss',
            'sprite',
            'babel',
            'concat',
            'copy',
            'imagemin',
            'eslint',
            'processhtml',
            'cacheBust'
        ];

        if (grunt.config('config.minify')) {
            tasks.push('cssmin', 'uglify');
        }

        tasks.push('replace:assets', 'filerev');

        grunt.task.run(tasks);
    });

    // Development workflow
    grunt.registerTask('dev', [
        'clean:tmp',
        'build:dev',
        'connect',
        'watch'
    ]);

    // Testing workflow
    grunt.registerTask('test', [
        'eslint',
        'bundlesize',
        'filesize',
        'qunit'
    ]);

    // Deployment workflow
    grunt.registerTask('deploy', [
        'test',
        'build:prod',
        'compress'
    ]);

    // Custom task: Performance audit
    grunt.registerTask('performance-audit', 'Run performance audit on built assets', function() {
        var fs = require('fs');
        var path = require('path');
        var distDir = grunt.config('config.dirs.dist');

        var audit = {
            assets: [],
            totalSize: 0,
            recommendations: []
        };

        function analyzeFile(filePath, type) {
            var stats = fs.statSync(filePath);
            var sizeKB = (stats.size / 1024).toFixed(2);

            audit.assets.push({
                type: type,
                path: path.relative(distDir, filePath),
                sizeKB: parseFloat(sizeKB),
                sizeRaw: stats.size
            });

            audit.totalSize += stats.size;

            // Check for optimization opportunities
            if (sizeKB > 100 && type === 'js') {
                audit.recommendations.push(
                    'Consider splitting ' + filePath + ' into smaller modules'
                );
            }

            if (sizeKB > 50 && type === 'css') {
                audit.recommendations.push(
                    'Consider critical CSS extraction for ' + filePath
                );
            }
        }

        // Analyze JavaScript files
        grunt.file.expand(distDir + '/js/**/*.js').forEach(function(file) {
            analyzeFile(file, 'js');
        });

        // Analyze CSS files
        grunt.file.expand(distDir + '/css/**/*.css').forEach(function(file) {
            analyzeFile(file, 'css');
        });

        // Output results
        grunt.log.writeln('Performance Audit Results:');
        grunt.log.writeln('========================');
        grunt.log.writeln('Total assets: ' + audit.assets.length);
        grunt.log.writeln('Total size: ' + (audit.totalSize / 1024).toFixed(2) + ' KB');
        grunt.log.writeln('');

        grunt.log.writeln('Asset Details:');
        audit.assets.forEach(function(asset) {
            grunt.log.writeln(
                '  ' + asset.type.toUpperCase() + ': ' +
                asset.path + ' (' + asset.sizeKB + ' KB)'
            );
        });

        if (audit.recommendations.length > 0) {
            grunt.log.writeln('');
            grunt.log.writeln('Recommendations:');
            audit.recommendations.forEach(function(rec) {
                grunt.log.writeln('  • ' + rec);
            });
        }
    });

    // Custom task: Dependency checker
    grunt.registerTask('deps-check', 'Check for outdated dependencies', function() {
        var shell = require('shelljs');
        var pkg = require('./package.json');

        grunt.log.writeln('Checking for outdated dependencies...');

        var outdated = shell.exec('npm outdated --json', { silent: true }).stdout;

        if (outdated) {
            var outdatedDeps = JSON.parse(outdated);
            var keys = Object.keys(outdatedDeps);

            if (keys.length > 0) {
                grunt.log.writeln('Outdated dependencies found:');
                keys.forEach(function(dep) {
                    var info = outdatedDeps[dep];
                    grunt.log.writeln(
                        '  ' + dep + ': current=' + info.current +
                        ', wanted=' + info.wanted + ', latest=' + info.latest
                    );
                });
            } else {
                grunt.log.writeln('All dependencies are up to date!');
            }
        }
    });

    // Default task
    grunt.registerTask('default', ['build:dev']);
};
CodejavascriptIntermediate

Grunt Plugin Development

Creating custom Grunt plugins and extending Grunt functionality

Difficulty

8/10

Estimated time

40 min

Tags

grunt, plugins, development

Prerequisites

Grunt basics, JavaScript ES6+, Plugin architecture

javascript
// Grunt Plugin Development Guide
// Creating custom plugins and extending Grunt functionality

// ===== BASIC PLUGIN STRUCTURE =====

// 1. Simple File Processor Plugin
// grunt-plugin-file-processor.js
'use strict';

module.exports = function(grunt) {
    grunt.registerMultiTask('fileProcessor', 'Process files with custom logic', function() {
        var options = this.options({
            encoding: 'utf8',
            process: function(content) {
                return content; // Default: no processing
            },
            extension: '.processed'
        });

        this.files.forEach(function(file) {
            var dest = file.dest;
            var contents = file.src.map(function(filepath) {
                var content = grunt.file.read(filepath, { encoding: options.encoding });
                return options.process(content, filepath);
            }).join('\n');

            grunt.file.write(dest, contents);
            grunt.log.writeln('Processed file: ' + dest);
        });
    });
};

// 2. Multi-Task Plugin with Template Support
// grunt-plugin-template-processor.js
module.exports = function(grunt) {
    grunt.registerMultiTask('templateProcessor', 'Process templates with data', function() {
        var options = this.options({
            data: {},
            delimiters: ['{{', '}}'],
            ext: '.html'
        });

        // Load template data
        var templateData = {};
        if (typeof options.data === 'string') {
            templateData = grunt.file.readJSON(options.data);
        } else {
            templateData = options.data;
        }

        this.files.forEach(function(file) {
            var src = file.src[0];
            var dest = file.dest || src;

            if (grunt.file.exists(src)) {
                var content = grunt.file.read(src);
                var processed = grunt.template.process(content, {
                    data: templateData,
                    delimiters: options.delimiters
                });

                grunt.file.write(dest, processed);
                grunt.log.writeln('Processed template: ' + dest);
            }
        });
    });
};

// 3. Async Plugin with Progress Reporting
// grunt-plugin-async-processor.js
module.exports = function(grunt) {
    grunt.registerTask('asyncProcessor', 'Process files asynchronously', function() {
        var done = this.async();
        var options = this.options({
            concurrency: 5,
            timeout: 30000
        });

        var files = this.filesSrc;
        var processed = 0;
        var total = files.length;

        // Progress reporting
        var progressInterval = setInterval(function() {
            grunt.log.writeln('Progress: ' + processed + '/' + total + ' files processed');
        }, 1000);

        // Process files with limited concurrency
        var processFile = function(filepath, callback) {
            var startTime = Date.now();

            setTimeout(function() {
                // Simulate file processing
                grunt.file.read(filepath);
                processed++;

                var duration = Date.now() - startTime;
                grunt.log.writeln('Processed: ' + filepath + ' (' + duration + 'ms)');

                callback(null, filepath);
            }, Math.random() * 2000);
        };

        // Queue management
        var queue = [];
        var active = 0;

        function processQueue() {
            while (active < options.concurrency && queue.length > 0) {
                active++;
                var filepath = queue.shift();

                processFile(filepath, function() {
                    active--;
                    if (queue.length > 0) {
                        processQueue();
                    } else if (active === 0) {
                        clearInterval(progressInterval);
                        done();
                    }
                });
            }
        }

        // Add files to queue
        files.forEach(function(filepath) {
            queue.push(filepath);
        });

        // Start processing
        processQueue();

        // Timeout handling
        setTimeout(function() {
            if (processed < total) {
                clearInterval(progressInterval);
                grunt.log.error('Processing timed out');
                done(false);
            }
        }, options.timeout);
    });
};

// ===== ADVANCED PLUGIN EXAMPLES =====

// 4. CSS Sprite Generator Plugin
// grunt-plugin-css-sprite.js
module.exports = function(grunt) {
    var.spritesmith = require('spritesmith');
    var crypto = require('crypto');

    grunt.registerMultiTask('cssSprite', 'Generate CSS sprites from images', function() {
        var done = this.async();
        var options = this.options({
            algorithm: 'binary-tree',
            padding: 2,
            engine: 'pixelsmith',
            cssFormat: 'css',
            cssTemplate: null,
            cssVarMap: function(sprite) {
                return sprite.name;
            }
        });

        this.files.forEach(function(file) {
            var sprites = file.src.map(function(filepath) {
                return {
                    src: filepath,
                    name: grunt.config('process').basename(filepath, '.png').replace('@2x', '')
                };
            });

            spritesmith.create({
                src: file.src,
                dest: file.dest,
                engine: options.engine,
                algorithm: options.algorithm,
                padding: options.padding
            }, function(err, result) {
                if (err) {
                    grunt.log.error(err);
                    return done(err);
                }

                // Write sprite image
                grunt.file.write(file.dest, result.image);

                // Generate CSS
                var css = generateCSS(result.coordinates, result.properties, options);
                var cssPath = file.dest.replace(/\.png$/, '.' + options.cssFormat);

                grunt.file.write(cssPath, css);

                grunt.log.writeln('Generated sprite: ' + file.dest);
                grunt.log.writeln('Generated CSS: ' + cssPath);
                done();
            });
        });

        function generateCSS(coordinates, properties, options) {
            var css = '';
            var baseName = properties.name || 'sprite';

            for (var name in coordinates) {
                var sprite = coordinates[name];
                css += '.sprite-' + name + ' {\n';
                css += '  background-image: url("' + baseName + '.png");\n';
                css += '  background-position: ' + (-sprite.x) + 'px ' + (-sprite.y) + 'px;\n';
                css += '  width: ' + sprite.width + 'px;\n';
                css += '  height: ' + sprite.height + 'px;\n';
                css += '}\n\n';
            }

            return css;
        }
    });
};

// 5. Performance Optimizer Plugin
// grunt-plugin-perf-optimizer.js
module.exports = function(grunt) {
    var UglifyJS = require('uglify-js');
    var CleanCSS = require('clean-css');
    var imagemin = require('imagemin');
    var mozjpeg = require('imagemin-mozjpeg');
    var pngquant = require('imagemin-pngquant');

    grunt.registerMultiTask('perfOptimizer', 'Optimize files for performance', function() {
        var options = this.options({
            jsOptimization: true,
            cssOptimization: true,
            imageOptimization: true,
            report: true,
            threshold: 1024 * 1024 // 1MB
        });

        var stats = {
            files: 0,
            originalSize: 0,
            optimizedSize: 0,
            compressionRatio: 0
        };

        var done = this.async();

        this.files.forEach(function(file) {
            file.src.forEach(function(src) {
                if (grunt.file.isFile(src)) {
                    var extension = grunt.config('process').extname(src).toLowerCase();
                    var originalContent = grunt.file.read(src);
                    var optimizedContent = originalContent;
                    var originalSize = originalContent.length;

                    stats.files++;
                    stats.originalSize += originalSize;

                    // JavaScript optimization
                    if (extension === '.js' && options.jsOptimization) {
                        var result = UglifyJS.minify(originalContent);
                        if (!result.error) {
                            optimizedContent = result.code;
                            grunt.log.writeln('Optimized JavaScript: ' + src);
                        }
                    }

                    // CSS optimization
                    else if (extension === '.css' && options.cssOptimization) {
                        var cleanCSS = new CleanCSS();
                        var result = cleanCSS.minify(originalContent);
                        optimizedContent = result.styles;
                        grunt.log.writeln('Optimized CSS: ' + src);
                    }

                    // Image optimization
                    else if (['.png', '.jpg', '.jpeg', '.gif', '.svg'].includes(extension) &&
                             options.imageOptimization) {
                        imagemin([src], {
                            plugins: [
                                imagemin.gifsicle(),
                                imagemin.jpegtran(),
                                imagemin.optipng(),
                                imagemin.svgo(),
                                pngquant(),
                                mozjpeg()
                            ]
                        }).then(function(files) {
                            if (files && files[0]) {
                                grunt.file.write(file.dest || src, files[0].data);
                                var optimizedSize = files[0].data.length;
                                updateStats(originalSize, optimizedSize);
                            }
                        });
                        return;
                    }

                    // Write optimized content
                    grunt.file.write(file.dest || src, optimizedContent);
                    updateStats(originalSize, optimizedContent.length);
                }
            });
        });

        function updateStats(original, optimized) {
            stats.optimizedSize += optimized;
            stats.compressionRatio = ((stats.originalSize - stats.optimizedSize) / stats.originalSize * 100).toFixed(2);
        }

        // Generate report
        if (options.report) {
            setTimeout(function() {
                grunt.log.writeln('\nPerformance Optimization Report');
                grunt.log.writeln('================================');
                grunt.log.writeln('Files processed: ' + stats.files);
                grunt.log.writeln('Original size: ' + (stats.originalSize / 1024).toFixed(2) + ' KB');
                grunt.log.writeln('Optimized size: ' + (stats.optimizedSize / 1024).toFixed(2) + ' KB');
                grunt.log.writeln('Compression ratio: ' + stats.compressionRatio + '%');

                if (stats.originalSize > options.threshold) {
                    grunt.log.warn('Total size exceeds threshold of ' + (options.threshold / 1024) + ' KB');
                }

                done();
            }, 1000);
        } else {
            done();
        }
    });
};

// 6. i18n Bundle Generator Plugin
// grunt-plugin-i18n.js
module.exports = function(grunt) {
    grunt.registerMultiTask('i18nBundle', 'Generate i18n translation bundles', function() {
        var options = this.options({
            languages: ['en', 'es', 'fr'],
            defaultLanguage: 'en',
            outputFormat: 'json',
            namespace: 'translations'
        });

        var translations = {};
        var defaultTranslations = {};

        // Load translations from source files
        this.files.forEach(function(file) {
            file.src.forEach(function(src) {
                if (grunt.file.exists(src)) {
                    var content = grunt.file.readJSON(src);
                    var lang = grunt.config('process').basename(src, '.json');

                    translations[lang] = content;

                    if (lang === options.defaultLanguage) {
                        defaultTranslations = content;
                    }
                }
            });
        });

        // Generate bundles
        options.languages.forEach(function(lang) {
            var bundle = mergeTranslations(defaultTranslations, translations[lang]);
            var outputDir = file.dest || 'dist/i18n';
            var outputFile = outputDir + '/' + lang + '.json';

            grunt.file.write(outputFile, JSON.stringify(bundle, null, 2));
            grunt.log.writeln('Generated i18n bundle: ' + outputFile);
        });

        function mergeTranslations(defaults, translations) {
            if (!translations) {
                return defaults;
            }

            var merged = {};
            var keys = Object.keys(defaults);

            keys.forEach(function(key) {
                if (translations[key]) {
                    merged[key] = translations[key];
                } else {
                    merged[key] = defaults[key];
                }
            });

            return merged;
        }
    });
};

// ===== PLUGIN TESTING FRAMEWORK =====

// 7. Plugin Test Framework
// grunt-plugin-test.js
module.exports = function(grunt) {
    var path = require('path');

    grunt.registerTask('testPlugin', 'Test a Grunt plugin', function(pluginName, testFile) {
        if (!pluginName) {
            grunt.log.error('Plugin name is required');
            return;
        }

        var testPath = testFile || 'test/' + pluginName + '_test.js';

        if (!grunt.file.exists(testPath)) {
            grunt.log.error('Test file not found: ' + testPath);
            return;
        }

        // Load the plugin
        var pluginPath = path.resolve('node_modules/grunt-' + pluginName);

        try {
            require(pluginPath);
        } catch (e) {
            // Try local plugin path
            pluginPath = path.resolve('plugins/grunt-' + pluginName + '.js');
            require(pluginPath);
        }

        // Run tests
        try {
            require(testPath)(grunt);
            grunt.log.ok('Plugin tests passed: ' + pluginName);
        } catch (e) {
            grunt.log.error('Plugin tests failed: ' + pluginName);
            grunt.log.error(e.message);
        }
    });
};

// Example test file for fileProcessor plugin
// test/fileProcessor_test.js
module.exports = function(grunt) {
    var fs = require('fs');
    var tempDir = 'test/temp';

    // Setup test environment
    grunt.task.run('setup:test');

    // Test cases
    var tests = [
        {
            name: 'Basic file processing',
            input: 'test/fixtures/sample.txt',
            expected: 'test/expected/sample.processed.txt',
            options: {}
        },
        {
            name: 'Custom processing function',
            input: 'test/fixtures/sample.txt',
            expected: 'test/expected/sample.uppercase.txt',
            options: {
                process: function(content) {
                    return content.toUpperCase();
                }
            }
        }
    ];

    // Run tests
    tests.forEach(function(test) {
        grunt.task.options('fileProcessor', test.options);

        grunt.task.run('fileProcessor', {
            src: [test.input],
            dest: tempDir + '/processed.txt'
        });

        // Verify output
        var actual = fs.readFileSync(tempDir + '/processed.txt', 'utf8');
        var expected = fs.readFileSync(test.expected, 'utf8');

        if (actual === expected) {
            grunt.log.ok('✓ ' + test.name);
        } else {
            grunt.log.error('✗ ' + test.name);
            grunt.log.error('Expected: ' + expected);
            grunt.log.error('Actual: ' + actual);
        }
    });

    // Cleanup
    grunt.task.run('cleanup:test');
};

// ===== PLUGIN REGISTRATION =====

// Register all plugins
module.exports = function(grunt) {
    // Load individual plugins
    require('./grunt-plugin-file-processor')(grunt);
    require('./grunt-plugin-template-processor')(grunt);
    require('./grunt-plugin-async-processor')(grunt);
    require('./grunt-plugin-css-sprite')(grunt);
    require('./grunt-plugin-perf-optimizer')(grunt);
    require('./grunt-plugin-i18n')(grunt);
    require('./grunt-plugin-test')(grunt);

    // Plugin configuration
    grunt.initConfig({
        // File processor configuration
        fileProcessor: {
            basic: {
                files: {
                    'dist/processed.txt': ['src/input.txt']
                }
            },
            advanced: {
                options: {
                    process: function(content, filepath) {
                        return 'Processed from ' + filepath + ':\n' + content;
                    }
                },
                files: {
                    'dist/advanced.txt': ['src/**/*.txt']
                }
            }
        },

        // Template processor configuration
        templateProcessor: {
            development: {
                options: {
                    data: 'config/dev.json'
                },
                files: {
                    'dist/index.html': 'src/index.html'
                }
            }
        },

        // CSS sprite configuration
        cssSprite: {
            options: {
                algorithm: 'binary-tree',
                padding: 2,
                cssFormat: 'scss',
                cssVarMap: function(sprite) {
                    return 'sprite-' + sprite.name;
                }
            },
            all: {
                src: ['src/images/sprites/**/*.png'],
                dest: 'dist/images/sprite.png'
            }
        },

        // Performance optimizer configuration
        perfOptimizer: {
            options: {
                jsOptimization: true,
                cssOptimization: true,
                imageOptimization: true,
                report: true
            },
            assets: {
                files: {
                    'dist/': ['src/**/*.{js,css,png,jpg,jpeg,gif,svg}']
                }
            }
        },

        // i18n configuration
        i18nBundle: {
            options: {
                languages: ['en', 'es', 'fr', 'de', 'ja'],
                defaultLanguage: 'en'
            },
            translations: {
                src: ['src/i18n/*.json'],
                dest: 'dist/i18n'
            }
        }
    });

    // Register tasks
    grunt.registerTask('dev', ['fileProcessor', 'templateProcessor:development']);
    grunt.registerTask('optimize', ['perfOptimizer', 'cssSprite']);
    grunt.registerTask('i18n', ['i18nBundle']);
    grunt.registerTask('build', ['dev', 'optimize', 'i18n']);
    grunt.registerTask('default', ['build']);
};

// ===== PLUGIN DISTRIBUTION =====

// package.json for plugin distribution
{
  "name": "grunt-custom-plugins",
  "version": "1.0.0",
  "description": "Collection of custom Grunt plugins",
  "main": "index.js",
  "scripts": {
    "test": "grunt test",
    "lint": "grunt eslint",
    "build": "grunt build"
  },
  "keywords": ["gruntplugin", "automation", "build", "optimization"],
  "author": "Your Name",
  "license": "MIT",
  "dependencies": {
    "grunt": "^1.6.1",
    "spritesmith": "^4.0.0",
    "uglify-js": "^3.17.0",
    "clean-css": "^5.3.0",
    "imagemin": "^8.0.0",
    "imagemin-mozjpeg": "^10.0.0",
    "imagemin-pngquant": "^9.0.0"
  },
  "peerDependencies": {
    "grunt": ">=1.0.0"
  },
  "devDependencies": {
    "grunt-contrib-clean": "^2.0.0",
    "grunt-contrib-concat": "^2.1.0",
    "grunt-contrib-copy": "^1.0.0",
    "grunt-eslint": "^24.3.0"
  },
  "engines": {
    "node": ">=14.0.0"
  }
}

// Plugin documentation template
/*
# Grunt Custom Plugins

A collection of custom Grunt plugins for advanced build automation.

## Installation

```bash
npm install grunt-custom-plugins --save-dev
```

## Available Plugins

### fileProcessor

Process files with custom logic.

```javascript
grunt.initConfig({
    fileProcessor: {
        options: {
            process: function(content, filepath) {
                // Custom processing logic
                return processedContent;
            }
        },
        files: {
            'dist/processed.txt': ['src/input.txt']
        }
    }
});
```

### templateProcessor

Process templates with data.

```javascript
grunt.initConfig({
    templateProcessor: {
        options: {
            data: 'config.json',
            delimiters: ['{{', '}}']
        },
        files: {
            'dist/index.html': 'src/index.html'
        }
    }
});
```

### cssSprite

Generate CSS sprites from images.

```javascript
grunt.initConfig({
    cssSprite: {
        options: {
            algorithm: 'binary-tree',
            cssFormat: 'scss'
        },
        files: {
            'dist/sprite.png': ['src/sprites/*.png']
        }
    }
});
```

## Testing

```bash
npm test
```

## License

MIT
*/

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Tool usage guide

Sample-focused context for search and workflow understanding

Overview

Use Grunt Basic Tasks for the exercises below. Follow only the named block; the other cards introduce separate language features and dependencies.

Choose the smallest example

Read the named configuration or expression without importing it. All inputs below are hypothetical literals; no build command, hook, package installation or file operation is needed.

Read task declarations without loading Gruntfile.js: it loads environment files and packages. Clean, shell and deployment tasks are excluded from every exercise.

How it works

  1. 1Read the named card and trace the declared values. The sample page displays code; it does not execute this language for you.

Edge cases & common failures

  • Scope of the result

    Results below are source-derived expectations, not recorded compiler or runtime output. Interactive input, time, files, threads, external services and framework setup are outside these exercises.

Examples

1. Trace dirs and concat.dist.dest

How to use

In Grunt Basic Tasks, locate dirs and concat.dist.dest. Use dirs.js=src/js; dirs.tmp=.tmp; follow only the stated operations, preserving their order.

Outcome

Expected: src/js/main.js; .tmp/js/scripts.js. Template expansion substitutes declared directory strings without reading any path.

2. Trace concat.options.separator

How to use

In Grunt Basic Tasks, locate concat.options.separator. Use synthetic fragments "a()", "b()"; separator=";"; follow only the stated operations, preserving their order.

Outcome

Expected: a();b(). Literal concatenation uses the semicolon separator; actual glob expansion is outside this trace.

3. Trace registerTask: lint

How to use

In Grunt Basic Tasks, locate registerTask: lint. Use declared task list; follow only the stated operations, preserving their order.

Outcome

Expected: eslint → stylelint → sasslint. The task list defines order only; lint tools are neither installed nor invoked.

Hub

Singing and Music Practice Tools

Shift songs into a comfortable key, find vocal range, generate tuning references, extract melody and chords, build tempo drills, add swing, and practice pronunciation with repeatable browser audio tools.

Hub

JSON Schema and API Contract Validation Tools

Compare JSON schema validation, OpenAPI response checks, mutation testing, stress testing, and breaking-change detection tools in one hub for API contract review.

Hub

Audio Reverb, Modulation, and Sound Design Effects Tools

Choose, preview, compare, and verify reverb, delay, modulation, and character effects for music, video, podcast, and game sound design.

Hub

API Request Format, Replay Preparation, and Debugging Tools

Check request structure, prepare a local replay, compare responses, and debug API clues. These tools analyze or generate locally and do not replace real authentication or server tests.

Home
Tools3215
Samples593
Visualizations472
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web194

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Media

Audio Bass Boost

Boost the low-frequency (bass) sounds

Media

Batch Image Trim

Trim multiple images simultaneously using various trimming methods with batch processing and ZIP output

Date & Time

Business Day Calculator

Calculate business days excluding weekends

Development

CSS Selector Specificity Calculator

Calculate CSS selector specificity scores, compare multiple selectors, and get suggestions for avoiding cascade conflicts

Design

Image Trim

Trim image borders by removing unwanted edges and margins automatically

Text Processing

Text NLP Annotation Workbench

Run explainable local tokenization, sentence splitting, stopword, lemma, stem, entity and n-gram annotation with JSONL or CoNLL export.

Health

Triathlon Calculator

Calculate total time and pace for triathlon events

Development

URL Parameter Builder

Build and construct URLs with parameters by adding query strings, hash fragments, and path segments

Build Tools

Gulp Task Automation

Gulp task runner examples including build automation, file processing, and development workflows

Build Tools

Parcel Bundler Samples

Parcel zero-configuration bundler examples including project setup, plugins, and advanced configuration

DevOps

GitHub Actions Samples

Comprehensive CI/CD automation examples including workflows, actions, secrets management, and deployment strategies

Build Tools

esbuild Bundler Samples

Modern JavaScript bundler examples including configuration, plugins, optimization, and integration workflows

Build Tools

Rollup Config Samples

Rollup build tool configuration examples including plugins, optimizations, multi-build setups, and modern JavaScript bundling

Build Tools

Webpack Configuration Samples

Webpack configuration examples including basic setup, optimization, loaders, plugins, and modern webpack patterns