itee-tasks 1.0.3

package/sources/helps/help.task.mjs

@@ -0,0 +1,154 @@
+import colors from 'ansi-colors'
+import log    from 'fancy-log'
+import {
+    getPrettyNodeVersion,
+    getPrettyNpmVersion,
+    getPrettyPackageName,
+    getPrettyPackageVersion,
+    Indenter,
+    logLoadingTask
+}             from '../_utils.mjs'
+
+const {
+          red,
+          green,
+          blue,
+          cyan,
+          yellow,
+          magenta,
+          unstyle
+      } = colors
+
+function alignTextCenter( text, width ) {
+
+    const unstyledText = unstyle( text.repeat( 1 ) )
+    const marginLength = ( width - unstyledText.length ) / 2
+
+    let leftMargin, rightMargin
+    if ( Number.isInteger( marginLength ) ) {
+        leftMargin  = marginLength
+        rightMargin = marginLength
+    } else {
+        const flooredMargin = Math.floor( marginLength )
+        leftMargin          = flooredMargin
+        rightMargin         = flooredMargin + 1
+    }
+
+    return ' '.repeat( leftMargin ) + text + ' '.repeat( rightMargin )
+
+}
+
+function alignTextLeft( text, width ) {
+
+    const unstyledText = unstyle( text.repeat( 1 ) )
+    let repeatTime     = width - unstyledText.length
+    repeatTime         = ( repeatTime > 0 ) ? repeatTime : 0
+
+    return text + ' '.repeat( repeatTime )
+
+}
+
+function alignTextRight( text, width ) {
+
+    const unstyledText = unstyle( text.repeat( 1 ) )
+    let repeatTime     = width - unstyledText.length
+    repeatTime         = ( repeatTime > 0 ) ? repeatTime : 0
+
+    return ' '.repeat( repeatTime ) + text
+
+}
+
+/**
+ * @method npm run help ( default )
+ * @global
+ * @description Will display the help in console
+ */
+const helpTask       = ( done ) => {
+
+    const bannerWidth          = 70
+    const prettyPackageName    = getPrettyPackageName()
+    const prettyPackageVersion = getPrettyPackageVersion()
+    const prettyNodeVersion    = getPrettyNodeVersion()
+    const prettyNpmVersion     = getPrettyNpmVersion()
+
+    const tableCharset = {
+        topLeftCorner:       '┏',
+        topRightCorner:      '┓',
+        bottomRightCorner:   '┛',
+        bottomLeftCorner:    '┗',
+        horizontalBorder:    '━',
+        horizontalSeparator: '─',
+        leftJoinSeparator:   '┠',
+        rightJoinSeparator:  '┨',
+        verticalBorder:      '┃',
+        verticalSeparator:   '',
+    }
+
+    const mainBorder     = tableCharset.horizontalBorder.repeat( bannerWidth )
+    const thinBorder     = tableCharset.horizontalSeparator.repeat( bannerWidth )
+    const tableTop       = `${ tableCharset.topLeftCorner }${ mainBorder }${ tableCharset.topRightCorner }`
+    const tableSeparator = `${ tableCharset.leftJoinSeparator }${ thinBorder }${ tableCharset.rightJoinSeparator }`
+    const tableBottom    = `${ tableCharset.bottomLeftCorner }${ mainBorder }${ tableCharset.bottomRightCorner }`
+    const tableLine      = ( innerText ) => `${ tableCharset.verticalBorder }${ innerText }${ tableCharset.verticalBorder }`
+
+    const {
+              I_,
+              I__,
+              I___,
+              I____,
+          } = new Indenter( '\t', 4 )
+
+    const npmRun = blue( 'npm run' )
+
+    log( '' )
+    log( tableTop )
+    log( tableLine( alignTextCenter( 'HELP', bannerWidth ) ) )
+    log( tableLine( alignTextCenter( prettyPackageName, bannerWidth ) ) )
+    log( tableLine( alignTextCenter( prettyPackageVersion, bannerWidth ) ) )
+    log( tableSeparator )
+    log( tableLine( alignTextLeft( prettyNodeVersion, bannerWidth ) ) )
+    log( tableLine( alignTextLeft( prettyNpmVersion, bannerWidth ) ) )
+    log( tableBottom )
+    log( I_, 'Available commands are:' )
+    log( I__, npmRun, cyan( 'help' ), '- Display this help.' )
+    log( I__, npmRun, cyan( 'patch' ), '- Will apply some patch/replacements in dependencies.', red( '(Apply only once after run "npm install")' ) )
+    log( I__, npmRun, cyan( 'clean' ), '- Will delete builds and temporary folders.' )
+    log( I__, npmRun, cyan( 'lint' ), '- Will run the eslint in pedantic mode with auto fix when possible.' )
+    log( I__, npmRun, cyan( 'doc' ), '- Will run jsdoc, and create documentation under `documentation` folder, using the docdash theme' )
+    log( I__, npmRun, cyan( 'test' ), '- Will run the test framworks (unit and bench), and create reports under `documentation/report` folder, using the mochawesome theme' )
+    log( I__, npmRun, cyan( 'unit' ), '- Will run the karma server for unit tests.' )
+    log( I__, npmRun, cyan( 'bench' ), '- Will run the karma server for benchmarks.' )
+    log( I__, npmRun, cyan( 'build' ), yellow( '--' ), green( '<options>' ), '- Will build the application for development and/or production environments.' )
+    log( I___, yellow( 'Note: The two dash are only required if you provide options !' ) )
+    log( I___, 'The available', green( '<options>' ), 'are:' )
+    log( I____, green( '-i' ), 'or', green( '--input' ), '- The main file path to build', cyan( '[Default: "sources/main.js"]' ), '.' )
+    log( I____, green( '-o' ), 'or', green( '--output' ), '- The folder where output the build', cyan( '[Default: "builds"]' ), '.' )
+    log(
+        I____,
+        green( '-f:' ),
+        magenta( '<format>' ),
+        'or',
+        green( '--format:' ),
+        magenta( '<format>' ),
+        ' - to specify the output build type. Where format could be any of:', magenta( 'cjs, esm, iife, umd' ), '.'
+    )
+    log( I____, green( '-e:' ), magenta( '<env>' ), 'or', green( '--env:' ), magenta( '<env>' ), ' - to specify the build environment. Where env could be any of:', magenta(
+        'dev' ), magenta( 'prod' ), cyan( '[Default: "dev"]' ), '.' )
+    log( I____, green( '-s' ), 'or', green( '--sourcemap' ), ' - to build with related source map', cyan( '[Default: true]' ), '.' )
+    log( I____, green( '-t' ), 'or', green( '--treeshake' ), ' - allow to perform treeshaking when building', cyan( '[Default: true]' ), '.' )
+    log( I__, npmRun, cyan( 'release' ), '- Will run all the lint, test stuff, and if succeed will build the application.' )
+    log( '' )
+    log( I_, 'In case you have', blue( 'gulp' ), 'installed globally, you could use also:' )
+    log( I__, blue( 'gulp' ), cyan( 'command' ), '- It will perform the command like using "npm run" but with less characters to type... Because you\'re a developer, right ?' )
+    log( '' )
+
+    done()
+
+}
+helpTask.displayName = 'help'
+helpTask.description = 'Display the package help'
+helpTask.flags       = null
+
+logLoadingTask( import.meta.filename, helpTask )
+
+export { helpTask }

package/sources/index.mjs

@@ -0,0 +1,21 @@
+export { buildTask }                           from './builds/build.task.mjs'
+export { cleanTask }                           from './cleans/clean.task.mjs'
+export { docTask }                             from './docs/doc.task.mjs'
+export { helpTask }                            from './helps/help.task.mjs'
+export { lintTask }                            from './lints/lint.task.mjs'
+export { releaseTask }                         from './releases/release.task.mjs'
+export { runTestsTask }                        from './tests/run-tests.task.mjs'
+export { computeUnitTestsTask }                from './tests/units/compute-unit-tests.task.mjs'
+export { runUnitTestsTask }                    from './tests/units/run-unit-tests.task.mjs'
+export { runUnitTestsForBackendTask }          from './tests/units/run-unit-tests-for-backend.task.mjs'
+export { runUnitTestsForFrontendTask }         from './tests/units/run-unit-tests-for-frontend.task.mjs'
+export { checkBundlingFromEsmBuildImportTask } from './tests/bundlings/check-bundling-from-esm-build-import.task.mjs'
+export { checkBundlingFromEsmFilesDirectTask } from './tests/bundlings/check-bundling-from-esm-files-direct.task.mjs'
+export { checkBundlingFromEsmFilesImportTask } from './tests/bundlings/check-bundling-from-esm-files-import.task.mjs'
+export { checkBundlingTask }                   from './tests/bundlings/check-bundling.task.mjs'
+export { computeBenchmarksTask }               from './tests/benchmarks/compute-benchmarks.task.mjs'
+export { runBenchmarksTestsTask }              from './tests/benchmarks/run-benchmarks.task.mjs'
+export { runBenchmarksForBackendTask }         from './tests/benchmarks/run-benchmarks-for-backend.task.mjs'
+export { runBenchmarksForFrontendTask }        from './tests/benchmarks/run-benchmarks-for-frontend.task.mjs'
+
+export * from './_utils.mjs'

package/sources/lints/lint.task.mjs

@@ -0,0 +1,47 @@
+import colors        from 'ansi-colors'
+import log           from 'fancy-log'
+import child_process from 'node:child_process'
+import { promisify } from 'node:util'
+import { join }      from 'path'
+import {
+    getConfigurationPathFor,
+    logLoadingTask
+}                    from '../_utils.mjs'
+
+const execFile = promisify( child_process.execFile )
+const { red }        = colors
+
+const configurationLocation = join( 'lints', 'lint.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+
+/**
+ * @method npm run lint
+ * @global
+ * @description Will lint the sources files and try to fix the style when possible
+ */
+const lintTask       = async ( done ) => {
+
+    try {
+
+        const { stdout } = await execFile( 'npx', [ 'eslint', '--config', configurationPath, '--fix' ] )
+        if ( stdout !== '' ) {
+            log( stdout )
+        }
+
+        done()
+
+    } catch ( error ) {
+
+        log( error.stdout )
+        done( red( error.message ) )
+
+    }
+
+}
+lintTask.displayName = 'lint'
+lintTask.description = 'Will lint the sources files and try to fix the style when possible.'
+lintTask.flags       = null
+
+logLoadingTask( import.meta.filename, lintTask, configurationPath )
+
+export { lintTask }

package/sources/refresh.mjs

@@ -0,0 +1,100 @@
+import colors            from 'ansi-colors'
+import log               from 'fancy-log'
+import { writeFileSync } from 'fs'
+import {
+    basename,
+    join,
+    relative
+}                        from 'path'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    getFilesFrom,
+    iteePackageRootDirectory,
+    iteePackageSourcesDirectory,
+    packageNodeModulesDirectory,
+    packageRootDirectory,
+    packageTasksDirectory
+}                        from './_utils.mjs'
+
+const {
+          green,
+          yellow
+      } = colors
+
+const configurationPath = getConfigurationPathFor( 'refresh.conf.mjs' )
+const configuration     = await getConfigurationFrom( configurationPath )
+
+// Get and filter tasks to expose
+const defaultTaskPattern = join( iteePackageSourcesDirectory, '/{*.task.mjs,**/*.task.mjs,**/**/*.task.mjs}' )
+const defaultTaskFiles   = getFilesFrom(
+    defaultTaskPattern,
+    filePath => {
+        const relativeFilepath = relative( iteePackageSourcesDirectory, filePath )
+        const filename         = basename( filePath )
+        const included         = !configuration.includes( filename )
+
+        included
+        ? log( 'Include default task from', green( relativeFilepath ) )
+        : log( 'Exclude default task from', yellow( relativeFilepath ) )
+
+        return included
+    }
+)
+
+const userTaskPattern = join( packageTasksDirectory, '/{*.task.mjs,**/*.task.mjs,**/**/*.task.mjs}' )
+const userTaskFiles   = getFilesFrom(
+    userTaskPattern,
+    filePath => {
+        const relativeFilepath = relative( packageRootDirectory, filePath )
+        const filename         = basename( filePath )
+        const included         = !configuration.includes( filename )
+
+        included
+        ? log( 'Include user task from', green( relativeFilepath ) )
+        : log( 'Exclude user task from', yellow( relativeFilepath ) )
+
+        return included
+    }
+)
+
+// Prepare gulpfile content with header
+let gulpfileContent = '' +
+    '/**\n' +
+    ' * This file is auto-generated by internal gulp command.\n' +
+    ' * If you want to customize the available gulp tasks, create your own in .tasks folder\n' +
+    ' * and run "gulp refresh"\n' +
+    ' */\n\n'
+
+// Generate default tasks exports and append to gulpfile content
+gulpfileContent += '// Default Itee tasks\n'
+for ( const taskFile of defaultTaskFiles ) {
+
+    // we are calling from client and use relative path from it
+    if ( iteePackageRootDirectory.includes( 'node_modules' ) ) {
+
+        const relativeTaskFile = relative( packageNodeModulesDirectory, taskFile )
+        gulpfileContent += `export * from '${ relativeTaskFile }'\n`
+
+    } else { // we are refreshing itee-tasks package internally
+
+        const relativeTaskFile = relative( iteePackageRootDirectory, taskFile )
+        gulpfileContent += `export * from './${ relativeTaskFile }'\n`
+
+    }
+
+}
+
+gulpfileContent += '\n'
+
+// Generate user tasks exports and append to gulpfile content
+gulpfileContent += '// User defined tasks\n'
+for ( const taskFile of userTaskFiles ) {
+    const relativeTaskFile = relative( packageRootDirectory, taskFile )
+    gulpfileContent += `export * from './${ relativeTaskFile }'\n`
+}
+
+// Create gulpfile file
+const gulpfilePath = join( packageRootDirectory, 'gulpfile.mjs' )
+log( 'Refresh', green( gulpfilePath ) )
+writeFileSync( gulpfilePath, gulpfileContent )

package/sources/releases/release.task.mjs

@@ -0,0 +1,31 @@
+import { series }                from 'gulp'
+import { logLoadingTask }        from '../_utils.mjs'
+import { buildTask }             from '../builds/build.task.mjs'
+import { cleanTask }             from '../cleans/clean.task.mjs'
+import { docTask }               from '../docs/doc.task.mjs'
+import { lintTask }              from '../lints/lint.task.mjs'
+import { computeBenchmarksTask } from '../tests/benchmarks/compute-benchmarks.task.mjs'
+import { runTestsTask }          from '../tests/run-tests.task.mjs'
+import { computeUnitTestsTask }  from '../tests/units/compute-unit-tests.task.mjs'
+
+/**
+ * @method npm run release
+ * @global
+ * @description Will perform a complete release of the library including 'clean', 'lint', 'doc', 'build-tests', 'test' and finally 'build'.
+ */
+const releaseTask       = series(
+    cleanTask,
+    buildTask,
+    computeBenchmarksTask,
+    computeUnitTestsTask,
+    runTestsTask,
+    lintTask,
+    docTask,
+)
+releaseTask.displayName = 'release'
+releaseTask.description = 'Will perform a complete release of the library including \'clean\', \'lint\', \'doc\', \'test\' and finally \'build\'.'
+releaseTask.flags       = null
+
+logLoadingTask( import.meta.filename, releaseTask )
+
+export { releaseTask }

package/sources/tests/benchmarks/compute-benchmarks.task.mjs

@@ -0,0 +1,224 @@
+import colors       from 'ansi-colors'
+import childProcess from 'child_process'
+import log          from 'fancy-log'
+import {
+    basename,
+    dirname,
+    extname,
+    join,
+    relative
+}                   from 'path'
+import {
+    createDirectoryIfNotExist,
+    createFile,
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask,
+    packageName,
+    packageNodeModulesDirectory,
+    packageSourcesDirectory as sourcesDir,
+    packageTestsBenchmarksDirectory as benchesDir,
+    packageTestsDirectory
+}                   from '../../_utils.mjs'
+
+const {
+          red,
+          yellow,
+      } = colors
+
+const configurationLocation = join( 'tests', 'benchmarks', 'compute-benchmarks.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+const configuration         = await getConfigurationFrom( configurationPath )
+
+/**
+ * @description Will generate benchmarks files from source code against provided alternatives
+ */
+const computeBenchmarksTask       = ( done ) => {
+
+    createDirectoryIfNotExist( benchesDir )
+
+    const benchRootImports = []
+    for ( let sourceFile of configuration ) {
+
+        const specificFilePath = sourceFile.replace( sourcesDir, '' )
+        const specificDir      = dirname( specificFilePath )
+
+        const fileName      = basename( sourceFile, extname( sourceFile ) )
+        const benchFileName = `${ fileName }.bench.js`
+        const benchDirPath  = join( benchesDir, specificDir )
+        const benchFilePath = join( benchDirPath, benchFileName )
+
+        const nsName         = `${ fileName }Namespace`
+        const importDirPath  = relative( benchDirPath, sourcesDir )
+        const importFilePath = join( importDirPath, specificFilePath ).replace( /\\/g, '/' )
+
+        try {
+
+            const jsdocPath   = join( packageNodeModulesDirectory, '/jsdoc/jsdoc.js' )
+            const jsdocOutput = childProcess.execFileSync( 'node', [ jsdocPath, '-X', sourceFile ] ).toString()
+
+            const classNames    = []
+            const usedLongnames = []
+            const jsonData      = JSON.parse( jsdocOutput ).filter( data => {
+
+                const longName = data.longname
+
+                const kind = data.kind
+                if ( kind !== 'function' ) {
+                    if ( kind === 'class' && !classNames.includes( longName ) ) {
+                        classNames.push( longName )
+                    }
+                    return false
+                }
+
+                // We don't care that data bloc have comment they are unused to generate benchmarks
+                // const undocumented = data.undocumented
+                // if ( undocumented ) {
+                //     return false
+                // }
+
+                const scope = data.scope
+                if ( ![ 'global', 'static' ].includes( scope ) ) {
+                    return false
+                }
+
+                if ( longName.includes( ' ' ) || longName.includes( '~' ) || usedLongnames.includes( longName ) ) {
+                    return false
+                }
+
+                for ( let className of classNames ) {
+                    if ( longName.includes( className ) ) {
+                        return false
+                    }
+                }
+
+                usedLongnames.push( longName )
+
+                return true
+
+            } )
+
+            if ( jsonData.length === 0 ) {
+                log( 'Ignoring', yellow( `${ sourceFile }, no usable exports found` ) )
+                continue
+            }
+
+            // Compute benchmark suites by grouping logically function by name[_x]
+            const suiteGroups = {}
+            for ( let docData of jsonData ) {
+
+                try {
+
+                    const functionName = docData.name
+                    const nameSplits   = functionName.split( '_' )
+                    const rootName     = nameSplits[ 0 ]
+
+                    if ( !( rootName in suiteGroups ) ) {
+                        suiteGroups[ rootName ] = []
+                    }
+
+                    suiteGroups[ rootName ].push( functionName )
+
+                } catch ( error ) {
+
+                    log( red( error.message ) )
+
+                }
+
+            }
+
+            // Generate suites
+            let benchSuites       = ''
+            const suitesToExports = []
+            for ( let suiteGroupName in suiteGroups ) {
+                suitesToExports.push( `${ suiteGroupName }Suite` )
+                benchSuites += `const ${ suiteGroupName }Suite = Benchmark.Suite( '${ nsName }.${ suiteGroupName }', Testing.createSuiteOptions() )` + '\n'
+
+                for ( let suiteGroupValue of suiteGroups[ suiteGroupName ] ) {
+                    benchSuites += `                                     .add( '${ suiteGroupValue }()', Testing.iterateOverDataMap( ${ nsName }.${ suiteGroupValue } ), Testing.createBenchmarkOptions() )` + '\n'
+                }
+
+                benchSuites += '\n'
+            }
+
+            // compute relative level to get import wrappers
+            const wrapperDirPath          = relative( benchDirPath, packageTestsDirectory )
+            const importBenchmarkFilePath = join( wrapperDirPath, 'import.benchmarks.js' )
+            const importTestingFilePath   = join( wrapperDirPath, 'import.testing.js' )
+
+            const template = '' +
+                `import * as ${ nsName } from '${ importFilePath }'` + '\n' +
+                `import { getBenchmarkPackage } from '${ importBenchmarkFilePath }'` + '\n' +
+                `import { getTestingPackage } from '${ importTestingFilePath }'` + '\n' +
+                '\n' +
+                `const Benchmark = await getBenchmarkPackage()` + '\n' +
+                `const Testing   = await getTestingPackage()` + '\n' +
+                '\n' +
+                `${ benchSuites }` +
+                // '\n' +
+                `export { ${ suitesToExports } }` + '\n' +
+                '\n'
+
+            const importBenchFilePath = relative( benchesDir, benchFilePath ).replace( /\\/g, '/' )
+            benchRootImports.push( {
+                path:    importBenchFilePath,
+                exports: suitesToExports
+            } )
+
+            createDirectoryIfNotExist( benchDirPath )
+            createFile( benchFilePath, template )
+
+        } catch ( error ) {
+
+            log( red( error.message ) )
+
+        }
+
+    }
+
+    let templateImports = ''
+    let suites          = []
+    for ( let i = 0 ; i < benchRootImports.length ; i++ ) {
+
+        const currentBench = benchRootImports[ i ]
+        const namedExports = currentBench.exports
+        const imports      = namedExports.join( ', ' )
+        suites.push( ...namedExports )
+
+        templateImports += `import {${ imports }} from './${ currentBench.path }'` + '\n'
+
+    }
+
+    // Use a fallback in case no benches were found at all
+    if ( benchRootImports.length === 0 ) {
+        log( 'Warning ', yellow( 'No usable exports found, generate default file to avoid frontend breakage.' ) )
+        const defaultBenchesDir  = join( benchesDir, 'default' )
+        const defaultBenchesPath = join( defaultBenchesDir, 'default.bench.js' )
+
+        createDirectoryIfNotExist( defaultBenchesDir )
+        createFile( defaultBenchesPath, '// Avoid web test runner crash on empty benches' )
+    }
+
+    const benchesTemplate = '' +
+        `${ templateImports }` + '\n' +
+        'const suites = [' + '\n' +
+        `${ suites.map( suite => `\t${ suite }` ).join( ',\n' ) }` + '\n' +
+        ']' + '\n' +
+        '\n' +
+        `for ( const suite of suites ) {` + '\n' +
+        `\tsuite.run()` + '\n' +
+        `}` + '\n'
+
+    const benchesFilePath = join( benchesDir, `${ packageName }.benchmarks.js` )
+    createFile( benchesFilePath, benchesTemplate )
+
+    done()
+
+}
+computeBenchmarksTask.displayName = 'compute-benchmarks'
+computeBenchmarksTask.description = 'Will generate benchmarks files from source code against provided alternatives.'
+computeBenchmarksTask.flags       = null
+
+logLoadingTask( import.meta.filename, computeBenchmarksTask, configurationPath )
+
+export { computeBenchmarksTask }

package/sources/tests/benchmarks/run-benchmarks-for-backend.task.mjs

@@ -0,0 +1,42 @@
+import colors         from 'ansi-colors'
+import log            from 'fancy-log'
+import { existsSync } from 'fs'
+import { join }       from 'path'
+import {
+    logLoadingTask,
+    packageName,
+    packageTestsBenchmarksDirectory
+}                     from '../../_utils.mjs'
+
+const {
+          red,
+          yellow
+      } = colors
+
+/**
+ * @description Will run benchmarks with node
+ */
+const runBenchmarksForBackendTask       = async ( done ) => {
+
+    const benchesPath = join( packageTestsBenchmarksDirectory, `/${ packageName }.benchmarks.js` )
+    if ( !existsSync( benchesPath ) ) {
+        log( yellow( `${ benchesPath } does not exist, skip backend benchmarks...` ) )
+        done()
+        return
+    }
+
+    try {
+        await import(benchesPath)
+        done()
+    } catch ( error ) {
+        done( red( error ) )
+    }
+
+}
+runBenchmarksForBackendTask.displayName = 'run-benchmarks-for-backend'
+runBenchmarksForBackendTask.description = 'Will run benchmarks with node'
+runBenchmarksForBackendTask.flags       = null
+
+logLoadingTask( import.meta.filename, runBenchmarksForBackendTask )
+
+export { runBenchmarksForBackendTask }

package/sources/tests/benchmarks/run-benchmarks-for-frontend.task.mjs

@@ -0,0 +1,52 @@
+import { startTestRunner } from '@web/test-runner'
+import colors              from 'ansi-colors'
+import { join }            from 'path'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask
+}                          from '../../_utils.mjs'
+
+const { red } = colors
+
+const configurationLocation = join( 'tests', 'benchmarks', 'run-benchmarks-for-frontend.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+
+/**
+ * @description Will run benchmarks with web-test-runner
+ */
+const runBenchmarksForFrontendTask       = () => {
+    return new Promise( async ( resolve, reject ) => {
+
+        const configuration = await getConfigurationFrom( configurationPath )
+        const testRunner    = await startTestRunner( {
+            config:          configuration,
+            readCliArgs:     false,
+            readFileConfig:  false,
+            autoExitProcess: false,
+        } )
+
+        if ( !testRunner ) {
+            reject( red( 'Internal test runner error.' ) )
+            return
+        }
+
+        // To ensure that testRunner exit event won't be used by other instance of test runner,
+        // we need to be sure that current test runner is ended
+        testRunner.on( 'finished', () => {
+            testRunner.stop()
+        } )
+
+        testRunner.on( 'stopped', () => {
+            resolve()
+        } )
+
+    } )
+}
+runBenchmarksForFrontendTask.displayName = 'run-benchmarks-for-frontend'
+runBenchmarksForFrontendTask.description = 'Will run benchmarks with web-test-runner.'
+runBenchmarksForFrontendTask.flags       = null
+
+logLoadingTask( import.meta.filename, runBenchmarksForFrontendTask, configurationPath )
+
+export { runBenchmarksForFrontendTask }