npm - @itee/tasks - Versions diffs - 1.1.1 → 1.2.0 - Mend

@itee/tasks 1.1.1 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (63) hide show

package/CHANGELOG.md +6 -0
package/configs/docs/doc.conf.mjs +55 -0
package/docs/-_utils.mjs.html +848 -0
package/docs/cleans_clean.task.mjs.html +239 -0
package/docs/fonts/glyphicons-halflings-regular.eot +0 -0
package/docs/fonts/glyphicons-halflings-regular.svg +288 -0
package/docs/fonts/glyphicons-halflings-regular.ttf +0 -0
package/docs/fonts/glyphicons-halflings-regular.woff +0 -0
package/docs/fonts/glyphicons-halflings-regular.woff2 +0 -0
package/docs/global.html +1668 -0
package/docs/helps_help.task.mjs.html +362 -0
package/docs/img/glyphicons-halflings-white.png +0 -0
package/docs/img/glyphicons-halflings.png +0 -0
package/docs/index.html +228 -0
package/docs/lints_lint.task.mjs.html +252 -0
package/docs/patches_patch.task.mjs.html +251 -0
package/docs/quicksearch.html +31 -0
package/docs/releases_release.task.mjs.html +238 -0
package/docs/scripts/docstrap.lib.js +11 -0
package/docs/scripts/fulltext-search-ui.js +89 -0
package/docs/scripts/fulltext-search.js +36 -0
package/docs/scripts/lunr.min.js +6 -0
package/docs/scripts/prettify/Apache-License-2.0.txt +202 -0
package/docs/scripts/prettify/jquery.min.js +6 -0
package/docs/scripts/prettify/lang-css.js +21 -0
package/docs/scripts/prettify/prettify.js +496 -0
package/docs/scripts/sunlight.js +1157 -0
package/docs/scripts/toc.js +203 -0
package/docs/styles/darkstrap.css +960 -0
package/docs/styles/prettify-tomorrow.css +132 -0
package/docs/styles/site.cerulean.css +7008 -0
package/docs/styles/site.cosmo.css +7061 -0
package/docs/styles/site.cyborg.css +7048 -0
package/docs/styles/site.darkly.css +7171 -0
package/docs/styles/site.darkstrap.css +5638 -0
package/docs/styles/site.dibs-bootstrap.css +5899 -0
package/docs/styles/site.flatly.css +7147 -0
package/docs/styles/site.journal.css +6973 -0
package/docs/styles/site.lumen.css +7298 -0
package/docs/styles/site.paper.css +7623 -0
package/docs/styles/site.readable.css +6997 -0
package/docs/styles/site.sandstone.css +7035 -0
package/docs/styles/site.simplex.css +7023 -0
package/docs/styles/site.slate.css +7343 -0
package/docs/styles/site.spacelab.css +7055 -0
package/docs/styles/site.superhero.css +7131 -0
package/docs/styles/site.united.css +6895 -0
package/docs/styles/site.yeti.css +7195 -0
package/docs/styles/sunlight.dark.css +345 -0
package/docs/styles/sunlight.default.css +344 -0
package/docs/tests_benchmarks_compute-benchmarks.task.mjs.html +442 -0
package/docs/tests_benchmarks_run-benchmarks-for-backend.task.mjs.html +249 -0
package/docs/tests_benchmarks_run-benchmarks-for-frontend.task.mjs.html +254 -0
package/docs/tests_bundlings_check-bundling-from-esm-files-direct.task.mjs.html +300 -0
package/docs/tests_bundlings_check-bundling.task.mjs.html +231 -0
package/docs/tests_run-tests.task.mjs.html +228 -0
package/docs/tests_units_compute-unit-tests.task.mjs.html +753 -0
package/docs/tests_units_run-unit-tests-for-backend.task.mjs.html +254 -0
package/docs/tests_units_run-unit-tests-for-frontend.task.mjs.html +254 -0
package/package.json +5 -2
package/sources/_utils.mjs +19 -1
package/sources/patches/patch.task.mjs +45 -0
package/configs/docs/doc.conf.json +0 -1

package/docs/tests_units_compute-unit-tests.task.mjs.html ADDED Viewed

@@ -0,0 +1,753 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width">
+	<title>@itee/tasks v1.1.1 Source: tests/units/compute-unit-tests.task.mjs</title>
+	<!--[if lt IE 9]>
+	<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
+	<![endif]-->
+	<link type="text/css" rel="stylesheet" href="styles/sunlight.dark.css">
+	<link type="text/css" rel="stylesheet" href="styles/site.cyborg.css">
+</head>
+<body>
+<div class="navbar navbar-default navbar-fixed-top ">
+<div class="container">
+	<div class="navbar-header">
+		<a class="navbar-brand" href="index.html">@itee/tasks v1.1.1</a>
+		<button class="navbar-toggle" type="button" data-toggle="collapse" data-target="#topNavigation">
+			<span class="icon-bar"></span>
+			<span class="icon-bar"></span>
+			<span class="icon-bar"></span>
+        </button>
+	</div>
+	<div class="navbar-collapse collapse" id="topNavigation">
+		<ul class="nav navbar-nav">
+			<li class="dropdown">
+				<a href="global.html" class="dropdown-toggle" data-toggle="dropdown">Global<b class="caret"></b></a>
+				<ul class="dropdown-menu inline">
+					<li><a href="global.html#checkBundlingFromEsmFilesDirectTask">checkBundlingFromEsmFilesDirectTask</a></li><li><a href="global.html#checkBundlingTask">checkBundlingTask</a></li><li><a href="global.html#computeBenchmarksTask">computeBenchmarksTask</a></li><li><a href="global.html#computeUnitTestsTask">computeUnitTestsTask</a></li><li><a href="global.html#createRollupConfigs">createRollupConfigs</a></li><li><a href="global.html#npmrunclean">npm run clean</a></li><li><a href="global.html#npmrunhelpdefault">npm run help ( default )</a></li><li><a href="global.html#npmrunlint">npm run lint</a></li><li><a href="global.html#npmrunpatch">npm run patch</a></li><li><a href="global.html#npmrunrelease">npm run release</a></li><li><a href="global.html#npmruntest">npm run test</a></li><li><a href="global.html#runBenchmarksForBackendTask">runBenchmarksForBackendTask</a></li><li><a href="global.html#runBenchmarksForFrontendTask">runBenchmarksForFrontendTask</a></li><li><a href="global.html#runUnitTestsForBackendTask">runUnitTestsForBackendTask</a></li><li><a href="global.html#runUnitTestsForFrontendTask">runUnitTestsForFrontendTask</a></li>
+				</ul>
+			</li>
+		</ul>
+            <div class="col-sm-3 col-md-3">
+                <form class="navbar-form" role="search">
+                    <div class="input-group">
+                        <input type="text" class="form-control" placeholder="Search" name="q" id="search-input">
+                        <div class="input-group-btn">
+                            <button class="btn btn-default" id="search-submit"><i class="glyphicon glyphicon-search"></i></button>
+                        </div>
+                    </div>
+                </form>
+            </div>
+	</div>
+</div>
+</div>
+<div class="container" id="toc-content">
+<div class="row">
+	<div class="col-md-12">
+		<div id="main">
+		<h1 class="page-title">Source: tests/units/compute-unit-tests.task.mjs</h1>
+<section>
+    <article>
+        <pre
+            class="sunlight-highlight-javascript linenums">import colors              from 'ansi-colors'
+import childProcess        from 'child_process'
+import log                 from 'fancy-log'
+import { glob }            from 'glob'
+import { isNotEmptyArray } from 'itee-validators'
+import {
+    basename,
+    dirname,
+    extname,
+    join,
+    normalize,
+    relative
+}                          from 'path'
+import {
+    createDirectoryIfNotExist,
+    createFile,
+    getPrettyPackageName,
+    getTaskConfigurationFor,
+    Indenter,
+    logLoadingTask,
+    packageName,
+    packageNodeModulesDirectory,
+    packageSourcesDirectory,
+    packageTestsUnitsDirectory
+}                          from '../../_utils.mjs'
+logLoadingTask( import.meta.filename )
+const {
+          red,
+          yellow,
+      } = colors
+/**
+ * @description Will generate unit test files from source code using type inference from comments
+ */
+const computeUnitTestsTask       = async ( done ) => {
+    createDirectoryIfNotExist( packageTestsUnitsDirectory )
+    // Get task configuration
+    const filePathsToIgnore = await getTaskConfigurationFor( import.meta.filename )
+    // Get source files to process
+    const pattern     = join( packageSourcesDirectory, '**' )
+    const sourceFiles = glob.sync( pattern )
+                            .map( filePath => normalize( filePath ) )
+                            .filter( filePath => {
+                                const fileName         = basename( filePath )
+                                const isJsFile         = fileName.endsWith( '.js' )
+                                const isNotPrivateFile = !fileName.startsWith( '_' )
+                                const isNotIgnoredFile = !filePathsToIgnore.includes( fileName )
+                                return isJsFile &amp;&amp; isNotPrivateFile &amp;&amp; isNotIgnoredFile
+                            } )
+    const unitsImportMap = []
+    for ( let sourceFile of sourceFiles ) {
+        const specificFilePath = sourceFile.replace( packageSourcesDirectory, '' )
+        const specificDir      = dirname( specificFilePath )
+        const fileName     = basename( sourceFile, extname( sourceFile ) )
+        const unitFileName = `${ fileName }.unit.mjs`
+        const unitDirPath  = join( packageTestsUnitsDirectory, specificDir )
+        const unitFilePath = join( unitDirPath, unitFileName )
+        const nsName         = `${ fileName }Namespace`
+        const unitName       = `${ fileName }Units`
+        const importDirPath  = relative( unitDirPath, packageSourcesDirectory )
+        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' &amp;&amp; !classNames.includes( longName ) ) {
+                        classNames.push( longName )
+                    }
+                    return false
+                }
+                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
+            }
+            let describes = ''
+            const {
+                      I,
+                      I_,
+                      I__,
+                      I___,
+                  }       = new Indenter( '\t', 3 )
+            for ( let docData of jsonData ) {
+                try {
+                    //check input parameters and types
+                    const docParameters = docData.params || []
+                    const parameters    = []
+                    for ( let pIndex = 0 ; pIndex &lt; docParameters.length ; pIndex++ ) {
+                        const param   = docParameters[ pIndex ]
+                        let paramName = param.name
+                        if ( !paramName ) {
+                            paramName = `param${ pIndex }`
+                            log( yellow( `Missing parameter name for [${ docData.longname }]. Defaulting to [${ paramName }]` ) )
+                        }
+                        const paramType = param.type
+                        if ( !paramType ) {
+                            throw new ReferenceError( `Missing parameter type. Unable to create unit test for [${ docData.longname }] !` )
+                        }
+                        const parameter = {
+                            name:  paramName,
+                            types: []
+                        }
+                        const paramTypeNames = paramType.names
+                        for ( let type of paramTypeNames ) {
+                            parameter.types.push( type )
+                        }
+                        parameters.push( parameter )
+                    }
+                    // Check returns types
+                    const docReturns = docData.returns || []
+                    const returns    = []
+                    for ( let docReturn of docReturns ) {
+                        const returnType = docReturn.type
+                        if ( !returnType ) {
+                            throw new ReferenceError( `Missing return type for [${ docData.longname }]. Ignore current target !` )
+                        }
+                        returns.push( ...returnType.names )
+                    }
+                    // Todo check throws
+                    // Get user define rules
+                    // const rules = []
+                    // Infer basic rules
+                    const baseIndent = 2
+                    let its          = ''
+                    if ( parameters.length === 0 ) {
+                        if ( returns.length === 0 ) {
+                            const result = `${ I._( baseIndent + 1 ) }const result = ${ nsName }.${ docData.name }()` + '\n'
+                            const expect = `${ I._( baseIndent + 1 ) }expect(result).to.be.a('undefined')` + '\n'
+                            its += '' +
+                                `${ I._( baseIndent ) }it( 'should return undefined value on call', async function () {` + '\n' +
+                                '\n' +
+                                `${ result }` +
+                                `${ expect }` +
+                                '\n' +
+                                `${ I._( baseIndent ) }} )` + '\n'
+                        } else if ( returns.length === 1 ) {
+                            const firstReturnType = returns[ 0 ]
+                            const lowerName       = firstReturnType.toLowerCase()
+                            const result = `${ I._( baseIndent + 1 ) }const result = ${ nsName }.${ docData.name }()` + '\n'
+                            let expect = ''
+                            if ( lowerName.startsWith( 'array' ) ) {
+                                //todo array of...
+                                expect += `${ I._( baseIndent + 1 ) }expect(result).to.be.a('array')` + '\n'
+                            } else {
+                                expect += `${ I._( baseIndent + 1 ) }expect(result).to.be.a('${ lowerName }')` + '\n'
+                            }
+                            its += '' +
+                                `${ I._( baseIndent ) }it( 'should return value of type ${ lowerName }', async function() {` + '\n' +
+                                '\n' +
+                                `${ result }` +
+                                `${ expect }` +
+                                '\n' +
+                                `${ I._( baseIndent ) }} )` + '\n'
+                        } else {
+                            const result = `${ I._( baseIndent + 1 ) }const result = ${ nsName }.${ docData.name }()` + '\n'
+                            let returnTypesLabel = []
+                            let oneOf            = []
+                            for ( let returnType of returns ) {
+                                const lowerName = returnType.toLowerCase()
+                                returnTypesLabel.push( lowerName )
+                                if ( lowerName.startsWith( 'array' ) ) {
+                                    //todo array of...
+                                    oneOf.push( 'array' )
+                                } else {
+                                    oneOf.push( `'${ lowerName }'` )
+                                }
+                            }
+                            const underlyingType = `${ I._( baseIndent + 1 ) }const resultType = (result === null) ? 'null' : typeof result` + '\n'
+                            const expect         = `${ I._( baseIndent + 1 ) }expect(resultType).to.be.oneOf([${ oneOf.join( ',' ) }])` + '\n'
+                            its += '' +
+                                `${ I._( baseIndent ) }it( 'should return value where type is ${ returnTypesLabel.join( ' or ' ) }', async function() {` + '\n' +
+                                '\n' +
+                                `${ result }` +
+                                `${ underlyingType }` +
+                                `${ expect }` +
+                                '\n' +
+                                `${ I._( baseIndent ) }} )` + '\n'
+                        }
+                    } else {
+                        if ( returns.length === 0 ) {
+                            let itDeclaration = []
+                            let index         = 0
+                            let indent        = baseIndent + 1
+                            let localIndent   = indent
+                            let dataSets      = ''
+                            let forLoopOpens  = ''
+                            let forLoopCloses = ''
+                            let args          = []
+                            for ( let parameter of parameters ) {
+                                const parameterType = parameter.types[ 0 ]
+                                itDeclaration.push( `${ parameter.name } is of type ${ parameterType }` )
+                                dataSets += `${ I._( indent ) }const dataSet${ index } = _dataMap[ '${ parameterType }s' ]` + '\n'
+                                // dataSets += `${ I._( indent ) }const dataSet${ index } = this._dataMap[ '${ parameterType }s' ]` + '\n'
+                                forLoopOpens += '' + '\n' +
+                                    `${ I._( localIndent ) }for ( let key${ index } in dataSet${ index } ) {` + '\n' +
+                                    `${ I._( localIndent + 1 ) }const dataSetValue${ index } = dataSet${ index }[ key${ index } ]` + '\n'
+                                args.push( `dataSetValue${ index }` )
+                                forLoopCloses = `${ I._( localIndent ) }}` + '\n' + `${ forLoopCloses }`
+                                index++
+                                localIndent++
+                            }
+                            const result = `${ I._( localIndent ) }const result = ${ nsName }.${ docData.name }( ${ args.join( ', ' ) } )` + '\n'
+                            const expect = `${ I._( localIndent ) }expect(result).to.be.a('undefined')` + '\n'
+                            const param = '' +
+                                `${ dataSets }` +
+                                `${ forLoopOpens }` +
+                                `${ result }` +
+                                `${ expect }` +
+                                `${ forLoopCloses }`
+                            its += '' +
+                                `${ I._( baseIndent ) }it( 'should return undefined value when ${ itDeclaration.join( ' and ' ) }', async function() {` + '\n' +
+                                '\n' +
+                                `${ param }` +
+                                '\n' +
+                                `${ I._( baseIndent ) }} )` + '\n'
+                        } else if ( returns.length === 1 ) {
+                            const firstReturnType = returns[ 0 ]
+                            const lowerName       = firstReturnType.toLowerCase()
+                            let itDeclaration = []
+                            let index         = 0
+                            let indent        = baseIndent + 1
+                            let localIndent   = indent
+                            let dataSets      = ''
+                            let forLoopOpens  = ''
+                            let forLoopCloses = ''
+                            let args          = []
+                            for ( let parameter of parameters ) {
+                                const parameterType = parameter.types[ 0 ]
+                                const isAnyType     = ( parameterType === '*' || parameterType.toLowerCase() === 'any' )
+                                const declaration   = ( isAnyType )
+                                                      ? `${ parameter.name } is of any type`
+                                                      : `${ parameter.name } is of type ${ parameterType }`
+                                itDeclaration.push( declaration )
+                                if ( isAnyType ) {
+                                    dataSets += `${ I._( indent ) }const dataMap${ index } = _dataMap` + '\n' +
+                                        // dataSets += `${ I._( indent ) }const dataMap${ index } = this._dataMap` + '\n' +
+                                        `${ I._( localIndent ) }for ( let dataSetKey${ index } in dataMap${ index } ) {` + '\n'
+                                    localIndent++
+                                    dataSets += `${ I._( indent + 1 ) }const dataSet${ index } = dataMap${ index }[ dataSetKey${ index } ]` + '\n'
+                                    forLoopOpens += '' + '\n' +
+                                        `${ I._( localIndent ) }for ( let key${ index } in dataSet${ index } ) {` + '\n' +
+                                        `${ I._( localIndent + 1 ) }const dataSetValue${ index } = dataSet${ index }[ key${ index } ]` + '\n'
+                                    args.push( `dataSetValue${ index }` )
+                                    forLoopCloses = `${ I._( localIndent ) }}` + '\n' +
+                                        `${ I._( localIndent - 1 ) }}` + '\n' +
+                                        `${ forLoopCloses }`
+                                } else {
+                                    dataSets += `${ I._( indent ) }const dataSet${ index } = _dataMap[ '${ parameterType }s' ]` + '\n'
+                                    // dataSets += `${ I._( indent ) }const dataSet${ index } = this._dataMap[ '${ parameterType }s' ]` + '\n'
+                                    forLoopOpens += '' + '\n' +
+                                        `${ I._( localIndent ) }for ( let key${ index } in dataSet${ index } ) {` + '\n' +
+                                        `${ I._( localIndent + 1 ) }const dataSetValue${ index } = dataSet${ index }[ key${ index } ]` + '\n'
+                                    args.push( `dataSetValue${ index }` )
+                                    forLoopCloses = `${ I._( localIndent ) }}` + '\n' + `${ forLoopCloses }`
+                                }
+                                index++
+                                localIndent++
+                            }
+                            const result = `${ I._( localIndent ) }const result = ${ nsName }.${ docData.name }( ${ args.join( ', ' ) } )` + '\n'
+                            let expect = ''
+                            if ( lowerName.startsWith( 'array' ) ) {
+                                expect = `${ I._( localIndent ) }expect(result).to.be.a('array')` + '\n'
+                                //todo array of...
+                            } else {
+                                expect = `${ I._( localIndent ) }expect(result).to.be.a('${ lowerName }')` + '\n'
+                            }
+                            const param = '' +
+                                `${ dataSets }` +
+                                `${ forLoopOpens }` +
+                                `${ result }` +
+                                `${ expect }` +
+                                `${ forLoopCloses }`
+                            its += '' +
+                                `${ I._( baseIndent ) }it( 'should return value of type ${ lowerName } when ${ itDeclaration.join( ' and ' ) }', async function() {` + '\n' +
+                                '\n' +
+                                `${ param }` +
+                                '\n' +
+                                `${ I._( baseIndent ) }} )` + '\n'
+                        } else {
+                            let itDeclaration = []
+                            let index         = 0
+                            let indent        = baseIndent + 1
+                            let localIndent   = indent
+                            let dataSets      = ''
+                            let forLoopOpens  = ''
+                            let forLoopCloses = ''
+                            let args          = []
+                            for ( let parameter of parameters ) {
+                                const parameterType = parameter.types[ 0 ]
+                                itDeclaration.push( `${ parameter.name } is of type ${ parameterType }` )
+                                dataSets += `${ I._( localIndent ) }const dataSet${ index } = _dataMap[ '${ parameterType }s' ]` + '\n'
+                                // dataSets += `${ I._( indent ) }const dataSet${ index } = this._dataMap[ '${ parameterType }s' ]` + '\n'
+                                forLoopOpens += '' + '\n' +
+                                    `${ I._( localIndent ) }for ( let key${ index } in dataSet${ index } ) {` + '\n' +
+                                    `${ I._( localIndent + 1 ) }const dataSetValue${ index } = dataSet${ index }[ key${ index } ]` + '\n'
+                                args.push( `dataSetValue${ index }` )
+                                forLoopCloses = `${ I._( localIndent ) }}` + '\n' + `${ forLoopCloses }`
+                                index++
+                                localIndent++
+                            }
+                            const result = `${ I._( localIndent + 1 ) }const result = ${ nsName }.${ docData.name }( ${ args.join( ', ' ) } )` + '\n'
+                            let returnTypesLabel = []
+                            let oneOf            = []
+                            for ( let returnType of returns ) {
+                                const lowerName = returnType.toLowerCase()
+                                returnTypesLabel.push( lowerName )
+                                if ( lowerName.startsWith( 'array' ) ) {
+                                    //todo array of...
+                                    oneOf.push( 'array' )
+                                } else {
+                                    oneOf.push( `'${ lowerName }'` )
+                                }
+                            }
+                            const underlyingType = `${ I._( localIndent + 1 ) }const resultType = (result === null) ? 'null' : typeof result` + '\n'
+                            const expect         = `${ I._( localIndent + 1 ) }expect(resultType).to.be.oneOf([${ oneOf.join( ',' ) }])` + '\n'
+                            const param = '' +
+                                `${ dataSets }` +
+                                `${ forLoopOpens }` +
+                                `${ result }` +
+                                `${ underlyingType }` +
+                                `${ expect }` +
+                                `${ forLoopCloses }`
+                            its += '' +
+                                `${ I._( baseIndent ) }it( 'should return value of type ${ returnTypesLabel.join( ' or ' ) } when ${ itDeclaration.join( ' and ' ) }', async function() {` + '\n' +
+                                '\n' +
+                                `${ param }` +
+                                '\n' +
+                                `${ I._( baseIndent ) }} )` + '\n'
+                        }
+                    }
+                    describes += '' +
+                        `${ I_ }describe( '${ docData.name }()', function () {` + '\n' +
+                        '\n' +
+                        `${ I__ }it( 'should be bundlable', async function () {` + '\n' +
+                        '\n' +
+                        `${ I___ }expect(${ nsName }.${ docData.name }).to.exist` + '\n' +
+                        '\n' +
+                        `${ I__ }} )` + '\n' +
+                        '\n' +
+                        `${ its }` +
+                        '\n' +
+                        `${ I_ }} )` + '\n' +
+                        '\n'
+                } catch ( error ) {
+                    log( red( error.message ) )
+                }
+            }
+            const template = '' +
+                `import { expect }       from 'chai'` + '\n' +
+                `import { Testing }      from 'itee-utils/sources/testings/benchmarks.js'` + '\n' +
+                `import * as ${ nsName } from '${ importFilePath }'` + '\n' +
+                '\n' +
+                `describe( '${ unitName }', function () {` + '\n' +
+                '\n' +
+                `${ I_ }let _dataMap` + '\n' +
+                `${ I_ }before( function() {` + '\n' +
+                `${ I__ }_dataMap = Testing.createDataMap()` + '\n' +
+                `${ I_ }} )` + '\n' +
+                '\n' +
+                `${ describes }` +
+                '' +
+                `} )` + '\n'
+            const importUnitFilePath = relative( packageTestsUnitsDirectory, unitFilePath )
+            unitsImportMap.push( {
+                exportName: unitName,
+                path:       importUnitFilePath.replace( /\\/g, '/' )
+            } )
+            createDirectoryIfNotExist( unitDirPath )
+            createFile( unitFilePath, template )
+        } catch ( error ) {
+            log( red( error.message ) )
+        }
+    }
+    // If some tests to import generate global units file
+    let unitsTemplate
+    if ( isNotEmptyArray( unitsImportMap ) ) {
+        let computedImports = []
+        for ( let entry of unitsImportMap ) {
+            // computedImports.push(`import { ${ entry.exportName } }   from './${ entry.path }'`)
+            computedImports.push( `export * from './${ entry.path }'` )
+        }
+        unitsTemplate = computedImports.join( '\n' )
+    } else {
+        log( 'Warning ', yellow( 'No tests were generated. Create fallback global root import file.' ) )
+        const defaultUnitsDir  = join( packageTestsUnitsDirectory, 'default' )
+        const defaultUnitsPath = join( defaultUnitsDir, 'default.unit.mjs' )
+        createDirectoryIfNotExist( defaultUnitsDir )
+        createFile( defaultUnitsPath, '// Avoid web test runner crash on empty benches' )
+        const prettyPackageName = getPrettyPackageName( '#' )
+        unitsTemplate           = `describe( '${ prettyPackageName }', () => {} )` + '\n'
+    }
+    const unitsFilePath = join( packageTestsUnitsDirectory, `${ packageName }.units.mjs` )
+    createFile( unitsFilePath, unitsTemplate )
+    done()
+}
+computeUnitTestsTask.displayName = basename( import.meta.filename, '.task.mjs' )
+computeUnitTestsTask.description = 'Will generate unit test files from source code using type inference from comments'
+computeUnitTestsTask.flags       = null
+export { computeUnitTestsTask }</pre>
+    </article>
+</section>
+		</div>
+	</div>
+	<div class="clearfix"></div>
+</div>
+</div>
+    <div class="modal fade" id="searchResults">
+      <div class="modal-dialog">
+        <div class="modal-content">
+          <div class="modal-header">
+            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+            <h4 class="modal-title">Search results</h4>
+          </div>
+          <div class="modal-body"></div>
+          <div class="modal-footer">
+            <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+          </div>
+        </div><!-- /.modal-content -->
+      </div><!-- /.modal-dialog -->
+    </div>
+<footer>
+	<span class="copyright">
+	Copyright 2015-Present <a href="https://github.com/Itee">Itee</a> (Tristan Valcke)
+	</span>
+<span class="jsdoc-message">
+	Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 4.0.5</a>
+	using the <a href="https://github.com/docstrap/docstrap">DocStrap template</a>.
+</span>
+</footer>
+<script src="scripts/docstrap.lib.js"></script>
+<script src="scripts/toc.js"></script>
+    <script type="text/javascript" src="scripts/fulltext-search-ui.js"></script>
+<script>
+$( function () {
+	$( "[id*='$']" ).each( function () {
+		var $this = $( this );
+		$this.attr( "id", $this.attr( "id" ).replace( "$", "__" ) );
+	} );
+	$( ".tutorial-section pre, .readme-section pre, pre.prettyprint.source" ).each( function () {
+		var $this = $( this );
+		var example = $this.find( "code" );
+		exampleText = example.html();
+		var lang = /{@lang (.*?)}/.exec( exampleText );
+		if ( lang && lang[1] ) {
+			exampleText = exampleText.replace( lang[0], "" );
+			example.html( exampleText );
+			lang = lang[1];
+		} else {
+			var langClassMatch = example.parent()[0].className.match(/lang\-(\S+)/);
+			lang = langClassMatch ? langClassMatch[1] : "javascript";
+		}
+		if ( lang ) {
+			$this
+			.addClass( "sunlight-highlight-" + lang )
+			.addClass( "linenums" )
+			.html( example.html() );
+		}
+	} );
+	Sunlight.highlightAll( {
+		lineNumbers : true,
+		showMenu : true,
+		enableDoclinks : true
+	} );
+	$.catchAnchorLinks( {
+        navbarOffset: 10
+	} );
+	$( "#toc" ).toc( {
+		anchorName  : function ( i, heading, prefix ) {
+			return $( heading ).attr( "id" ) || ( prefix + i );
+		},
+		selectors   : "#toc-content h1,#toc-content h2,#toc-content h3,#toc-content h4",
+		showAndHide : false,
+		smoothScrolling: true
+	} );
+	$( "#main span[id^='toc']" ).addClass( "toc-shim" );
+	$( '.dropdown-toggle' ).dropdown();
+    $( "table" ).each( function () {
+      var $this = $( this );
+      $this.addClass('table');
+    } );
+} );
+</script>
+<!--Navigation and Symbol Display-->
+<!--Google Analytics-->
+    <script type="text/javascript">
+        $(document).ready(function() {
+            SearcherDisplay.init();
+        });
+    </script>
+</body>
+</html>