This code snippet provides a function tasksToPromise that allows you to run a series of Gulp tasks asynchronously and obtain a Promise that resolves when all tasks are finished.

Run example

npm run import -- "use a Promise as a gulp task"

use a Promise as a gulp task

var gulp = require('gulp');

// I wish Linus Torvolds had absolute power over everything javascript(+derivatives) and he could just do a massive purge of all the bullshit.
function tasksToPromise(tasks) {
    return new Promise((resolve, reject) => {
        gulp.series.apply(gulp, tasks.concat([function (done) {
            resolve(done());
        }]))();
    });
};

module.exports = tasksToPromise;

// Import gulp module and assign it to a constant for better readability
const gulp = require('gulp');

/**
 * A utility function to convert gulp tasks into promises.
 * This allows for easier handling of asynchronous tasks in a synchronous manner.
 *
 * @param {Array} tasks - An array of gulp tasks to be executed in series
 * @returns {Promise} - A promise that resolves when all tasks are completed
 */
function tasksToPromise(tasks) {
    // Check if the tasks array is valid before proceeding
    if (!Array.isArray(tasks) || tasks.length === 0) {
        throw new Error('tasks must be a non-empty array');
    }

    return new Promise((resolve, reject) => {
        // Use gulp.series to execute tasks in series and resolve the promise when all tasks are done
        gulp.series(tasks, (done) => {
            // Resolve the promise with the result of the 'done' callback
            resolve(done());
        })((err) => {
            // Reject the promise if any task fails
            reject(err);
        })();
    });
}

// Replace the previous exports with a more explicit export using ES6 syntax
export default tasksToPromise;

This code snippet defines a function called tasksToPromise that converts a list of Gulp tasks into a Promise.

Here's a breakdown:

1. var gulp = require('gulp');: Imports the Gulp library, which is essential for defining build tasks and pipelines.

2. function tasksToPromise(tasks) { ... }: Defines a function named tasksToPromise that takes an array of Gulp tasks as input.

3. return new Promise((resolve, reject) => { ... });: Creates a new Promise object. Promises are a way to handle asynchronous operations in JavaScript.

4. gulp.series.apply(gulp, tasks.concat([function (done) { resolve(done()); }]))();: This is the core of the function. It does the following:

   • tasks.concat([function (done) { resolve(done()); }]): Appends a final function to the tasks array. This function simply calls resolve(done()) when it's executed. This ensures that the Promise resolves successfully once all the tasks in the array have completed.
   • gulp.series.apply(gulp, ...): Uses gulp.series to execute the tasks in the array sequentially. apply is used to pass the gulp object as the context for gulp.series.

5. module.exports = tasksToPromise;: Exports the tasksToPromise function so it can be used in other parts of the project.

In essence, this code provides a way to run a series of Gulp tasks asynchronously and get a Promise that resolves when all tasks are complete. This can be useful for integrating Gulp tasks into larger asynchronous workflows.