itee-tasks 1.0.4 → 1.0.6

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

@@ -1,55 +1,69 @@
 import colors       from 'ansi-colors'
 import childProcess from 'child_process'
 import log          from 'fancy-log'
+import { glob }     from 'glob'
 import {
     basename,
     dirname,
     extname,
     join,
+    normalize,
     relative
 }                   from 'path'
 import {
     createDirectoryIfNotExist,
     createFile,
-    getConfigurationFrom,
-    getConfigurationPathFor,
+    getTaskConfigurationFor,
     logLoadingTask,
     packageName,
     packageNodeModulesDirectory,
-    packageSourcesDirectory as sourcesDir,
-    packageTestsBenchmarksDirectory as benchesDir,
+    packageSourcesDirectory,
+    packageTestsBenchmarksDirectory,
     packageTestsDirectory
 }                   from '../../_utils.mjs'
 
+logLoadingTask( import.meta.filename )
+
 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 ) => {
+const computeBenchmarksTask       = async ( done ) => {
+
+    createDirectoryIfNotExist( packageTestsBenchmarksDirectory )
 
-    createDirectoryIfNotExist( benchesDir )
+    // 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 && isNotPrivateFile && isNotIgnoredFile
+                            } )
 
     const benchRootImports = []
-    for ( let sourceFile of configuration ) {
+    for ( let sourceFile of sourceFiles ) {
 
-        const specificFilePath = sourceFile.replace( sourcesDir, '' )
+        const specificFilePath = sourceFile.replace( packageSourcesDirectory, '' )
         const specificDir      = dirname( specificFilePath )
 
         const fileName      = basename( sourceFile, extname( sourceFile ) )
         const benchFileName = `${ fileName }.bench.js`
-        const benchDirPath  = join( benchesDir, specificDir )
+        const benchDirPath  = join( packageTestsBenchmarksDirectory, specificDir )
         const benchFilePath = join( benchDirPath, benchFileName )
 
         const nsName         = `${ fileName }Namespace`
-        const importDirPath  = relative( benchDirPath, sourcesDir )
+        const importDirPath  = relative( benchDirPath, packageSourcesDirectory )
         const importFilePath = join( importDirPath, specificFilePath ).replace( /\\/g, '/' )
 
         try {
@@ -159,7 +173,7 @@ const computeBenchmarksTask       = ( done ) => {
                 `export { ${ suitesToExports } }` + '\n' +
                 '\n'
 
-            const importBenchFilePath = relative( benchesDir, benchFilePath ).replace( /\\/g, '/' )
+            const importBenchFilePath = relative( packageTestsBenchmarksDirectory, benchFilePath ).replace( /\\/g, '/' )
             benchRootImports.push( {
                 path:    importBenchFilePath,
                 exports: suitesToExports
@@ -192,7 +206,7 @@ const computeBenchmarksTask       = ( done ) => {
     // 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 defaultBenchesDir  = join( packageTestsBenchmarksDirectory, 'default' )
         const defaultBenchesPath = join( defaultBenchesDir, 'default.bench.js' )
 
         createDirectoryIfNotExist( defaultBenchesDir )
@@ -209,16 +223,14 @@ const computeBenchmarksTask       = ( done ) => {
         `\tsuite.run()` + '\n' +
         `}` + '\n'
 
-    const benchesFilePath = join( benchesDir, `${ packageName }.benchmarks.js` )
+    const benchesFilePath = join( packageTestsBenchmarksDirectory, `${ packageName }.benchmarks.js` )
     createFile( benchesFilePath, benchesTemplate )
 
     done()
 
 }
-computeBenchmarksTask.displayName = 'compute-benchmarks'
+computeBenchmarksTask.displayName = basename( import.meta.filename, '.task.mjs' )
 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

@@ -1,6 +1,7 @@
 import colors         from 'ansi-colors'
 import log            from 'fancy-log'
 import { existsSync } from 'fs'
+import { basename }   from 'node:path'
 import { join }       from 'path'
 import {
     logLoadingTask,
@@ -8,6 +9,8 @@ import {
     packageTestsBenchmarksDirectory
 }                     from '../../_utils.mjs'
 
+logLoadingTask( import.meta.filename )
+
 const {
           red,
           yellow
@@ -33,10 +36,8 @@ const runBenchmarksForBackendTask       = async ( done ) => {
     }
 
 }
-runBenchmarksForBackendTask.displayName = 'run-benchmarks-for-backend'
+runBenchmarksForBackendTask.displayName = basename( import.meta.filename, '.task.mjs' )
 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

@@ -1,16 +1,14 @@
 import { startTestRunner } from '@web/test-runner'
 import colors              from 'ansi-colors'
-import { join }            from 'path'
+import { basename }        from 'node:path'
 import {
-    getConfigurationFrom,
-    getConfigurationPathFor,
+    getTaskConfigurationFor,
     logLoadingTask
 }                          from '../../_utils.mjs'
 
-const { red } = colors
+logLoadingTask( import.meta.filename )
 
-const configurationLocation = join( 'tests', 'benchmarks', 'run-benchmarks-for-frontend.conf.mjs' )
-const configurationPath     = getConfigurationPathFor( configurationLocation )
+const { red } = colors
 
 /**
  * @description Will run benchmarks with web-test-runner
@@ -18,7 +16,7 @@ const configurationPath     = getConfigurationPathFor( configurationLocation )
 const runBenchmarksForFrontendTask       = () => {
     return new Promise( async ( resolve, reject ) => {
 
-        const configuration = await getConfigurationFrom( configurationPath )
+        const configuration = await getTaskConfigurationFor( import.meta.filename )
         const testRunner    = await startTestRunner( {
             config:          configuration,
             readCliArgs:     false,
@@ -43,10 +41,8 @@ const runBenchmarksForFrontendTask       = () => {
 
     } )
 }
-runBenchmarksForFrontendTask.displayName = 'run-benchmarks-for-frontend'
+runBenchmarksForFrontendTask.displayName = basename( import.meta.filename, '.task.mjs' )
 runBenchmarksForFrontendTask.description = 'Will run benchmarks with web-test-runner.'
 runBenchmarksForFrontendTask.flags       = null
 
-logLoadingTask( import.meta.filename, runBenchmarksForFrontendTask, configurationPath )
-
 export { runBenchmarksForFrontendTask }

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

@@ -1,21 +1,16 @@
-import { join } from 'path'
+import { basename } from 'node:path'
 import {
-    getConfigurationFrom,
-    getConfigurationPathFor,
+    getTaskConfigurationFor,
     logLoadingTask,
     serializeTasksFrom
-}               from '../../_utils.mjs'
+}                   from '../../_utils.mjs'
 
+logLoadingTask( import.meta.filename )
 
-const configurationLocation = join( 'tests', 'benchmarks', 'run-benchmarks.conf.mjs' )
-const configurationPath     = getConfigurationPathFor( configurationLocation )
-const configuration         = await getConfigurationFrom( configurationPath )
-
+const configuration                = await getTaskConfigurationFor( import.meta.filename )
 const runBenchmarksTestsTask       = await serializeTasksFrom( configuration )
-runBenchmarksTestsTask.displayName = 'run-benchmarks'
+runBenchmarksTestsTask.displayName = basename( import.meta.filename, '.task.mjs' )
 runBenchmarksTestsTask.description = 'Will run benchmarks in back and front environments.'
 runBenchmarksTestsTask.flags       = null
 
-logLoadingTask( import.meta.filename, runBenchmarksTestsTask, configurationPath )
-
 export { runBenchmarksTestsTask }

package/sources/tests/bundlings/check-bundling-from-esm-build-import.task.mjs

@@ -14,26 +14,24 @@ import {
 }                 from 'path'
 import { rollup } from 'rollup'
 import {
-    getConfigurationFrom,
-    getConfigurationPathFor,
+    getTaskConfigurationFor,
     logLoadingTask,
     packageBuildsDirectory,
     packageName,
     packageTestsBundlesDirectory
 }                 from '../../_utils.mjs'
 
+logLoadingTask( import.meta.filename )
+
 const {
           red,
           green,
           magenta,
       } = colors
 
-const configurationLocation = join( 'tests', 'bundlings', 'check-bundling-from-esm-build-import.conf.mjs' )
-const configurationPath     = getConfigurationPathFor( configurationLocation )
-
 const checkBundlingFromEsmBuildImportTask       = async ( done ) => {
 
-    const configuration = await getConfigurationFrom( configurationPath )
+    const configuration = await getTaskConfigurationFor( import.meta.filename )
 
     const buildFilePath = join( packageBuildsDirectory, `${ packageName }.esm.js` )
     if ( !existsSync( buildFilePath ) ) {
@@ -122,10 +120,8 @@ const checkBundlingFromEsmBuildImportTask       = async ( done ) => {
     }
 
 }
-checkBundlingFromEsmBuildImportTask.displayName = 'check-bundling-from-esm-build-import'
+checkBundlingFromEsmBuildImportTask.displayName = basename( import.meta.filename, '.task.mjs' )
 checkBundlingFromEsmBuildImportTask.description = 'Verify that the project esm build is correctly importable in third party esm files'
 checkBundlingFromEsmBuildImportTask.flags       = null
 
-logLoadingTask( import.meta.filename, checkBundlingFromEsmBuildImportTask, configurationPath )
-
 export { checkBundlingFromEsmBuildImportTask }

package/sources/tests/bundlings/check-bundling-from-esm-files-direct.task.mjs

@@ -4,33 +4,30 @@ import {
     existsSync,
     rmSync
 }                 from 'fs'
+import { glob }   from 'glob'
 import {
     basename,
     dirname,
     extname,
-    join
+    join,
+    normalize
 }                 from 'path'
 import { rollup } from 'rollup'
 import {
-    getConfigurationFrom,
-    getConfigurationPathFor,
+    getTaskConfigurationFor,
     logLoadingTask,
     packageSourcesDirectory,
     packageTestsBundlesDirectory
 }                 from '../../_utils.mjs'
 
+logLoadingTask( import.meta.filename )
+
 const {
           red,
           green,
           magenta,
       } = colors
 
-const sourcesFilesLocation = join( 'tests', 'bundlings', 'check-bundling.conf.mjs' )
-const sourcesFilesPath     = getConfigurationPathFor( sourcesFilesLocation )
-
-const configurationLocation = join( 'tests', 'bundlings', 'check-bundling-from-esm-files-direct.conf.mjs' )
-const configurationPath     = getConfigurationPathFor( configurationLocation )
-
 /**
  * @description In view to detect bundling side effects this task will
  * create intermediary file for each individual export from this package
@@ -45,10 +42,21 @@ const checkBundlingFromEsmFilesDirectTask       = async ( done ) => {
         rmSync( outputDir, { recursive: true } )
     }
 
-    const sourcesFiles  = await getConfigurationFrom( sourcesFilesPath )
-    const configuration = await getConfigurationFrom( configurationPath )
+    const configuration = await getTaskConfigurationFor( import.meta.filename )
 
-    for ( let sourceFile of sourcesFiles ) {
+    // 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 = !configuration.ignoredFiles.includes( fileName )
+                                return isJsFile && isNotPrivateFile && isNotIgnoredFile
+                            } )
+
+    for ( let sourceFile of sourceFiles ) {
 
         const specificFilePath = sourceFile.replace( packageSourcesDirectory, '' )
         const specificDir      = dirname( specificFilePath )
@@ -57,16 +65,16 @@ const checkBundlingFromEsmFilesDirectTask       = async ( done ) => {
         const bundleFileName = `${ fileName }.bundle.js`
         const bundleFilePath = join( outputDir, specificDir, bundleFileName )
 
-        configuration.input       = sourceFile
-        configuration.output.file = bundleFilePath
+        configuration.buildOptions.input       = sourceFile
+        configuration.buildOptions.output.file = bundleFilePath
 
         try {
 
-            log( 'Bundling', green( configuration.output.file ) )
+            log( 'Bundling', green( configuration.buildOptions.output.file ) )
 
-            const bundle = await rollup( configuration )
-            await bundle.generate( configuration.output )
-            await bundle.write( configuration.output )
+            const bundle = await rollup( configuration.buildOptions )
+            await bundle.generate( configuration.buildOptions.output )
+            await bundle.write( configuration.buildOptions.output )
 
         } catch ( error ) {
 
@@ -79,10 +87,8 @@ const checkBundlingFromEsmFilesDirectTask       = async ( done ) => {
     done()
 
 }
-checkBundlingFromEsmFilesDirectTask.displayName = 'check-bundling-from-esm-files-direct'
+checkBundlingFromEsmFilesDirectTask.displayName = basename( import.meta.filename, '.task.mjs' )
 checkBundlingFromEsmFilesDirectTask.description = 'In view to detect bundling side effects this task will create intermediary file for each individual export from this package and then create rollup config for each of them and bundle'
 checkBundlingFromEsmFilesDirectTask.flags       = null
 
-logLoadingTask( import.meta.filename, checkBundlingFromEsmFilesDirectTask, configurationPath )
-
 export { checkBundlingFromEsmFilesDirectTask }

package/sources/tests/bundlings/check-bundling-from-esm-files-import.task.mjs

@@ -6,19 +6,21 @@ import {
     rmSync,
     writeFileSync
 }                 from 'fs'
+import { glob }   from 'glob'
 import {
+    basename,
     dirname,
     join,
+    normalize,
     parse,
     relative
 }                 from 'path'
 import { rollup } from 'rollup'
 import {
-    getConfigurationFrom,
-    getConfigurationPathFor,
+    getTaskConfigurationFor,
     logLoadingTask,
-    packageSourcesDirectory as sourcesDir,
-    packageTestsBundlesDirectory as bundleDir
+    packageSourcesDirectory,
+    packageTestsBundlesDirectory
 }                 from '../../_utils.mjs'
 
 const {
@@ -27,15 +29,9 @@ const {
           magenta,
       } = colors
 
-const sourcesFilesLocation = join( 'tests', 'bundlings', 'check-bundling.conf.mjs' )
-const sourcesFilesPath     = getConfigurationPathFor( sourcesFilesLocation )
-
-const configurationLocation = join( 'tests', 'bundlings', 'check-bundling-from-esm-files-import.conf.mjs' )
-const configurationPath     = getConfigurationPathFor( configurationLocation )
-
 const checkBundlingFromEsmFilesImportTask       = async ( done ) => {
 
-    const outputDir      = join( bundleDir, 'from_files_import' )
+    const outputDir      = join( packageTestsBundlesDirectory, 'from_files_import' )
     const temporariesDir = join( outputDir, '.tmp' )
 
     if ( existsSync( outputDir ) ) {
@@ -43,17 +39,28 @@ const checkBundlingFromEsmFilesImportTask       = async ( done ) => {
         rmSync( outputDir, { recursive: true } )
     }
 
-    const sourcesFiles  = await getConfigurationFrom( sourcesFilesPath )
-    const configuration = await getConfigurationFrom( configurationPath )
+    const configuration = 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 = !configuration.ignoredFiles.includes( fileName )
+                                return isJsFile && isNotPrivateFile && isNotIgnoredFile
+                            } )
 
-    for ( let sourceFile of sourcesFiles ) {
+    for ( let sourceFile of sourceFiles ) {
 
         const {
                   dir:  sourceDir,
                   base: sourceBase,
                   name: sourceName
               }                = parse( sourceFile )
-        const specificFilePath = sourceFile.replace( sourcesDir, '' )
+        const specificFilePath = sourceFile.replace( packageSourcesDirectory, '' )
         const specificDir      = dirname( specificFilePath )
 
         // Create temp import file per file in package
@@ -68,8 +75,8 @@ const checkBundlingFromEsmFilesImportTask       = async ( done ) => {
         const bundleFileName = `${ sourceName }.bundle.js`
         const bundleFilePath = join( outputDir, specificDir, bundleFileName )
 
-        configuration.input       = temporaryFile
-        configuration.output.file = bundleFilePath
+        configuration.buildOptions.input       = temporaryFile
+        configuration.buildOptions.output.file = bundleFilePath
 
         // create tmp file
         try {
@@ -77,13 +84,13 @@ const checkBundlingFromEsmFilesImportTask       = async ( done ) => {
             mkdirSync( temporaryDir, { recursive: true } )
             writeFileSync( temporaryFile, temporaryFileData )
 
-            const bundle     = await rollup( configuration )
-            const { output } = await bundle.generate( configuration.output )
+            const bundle     = await rollup( configuration.buildOptions )
+            const { output } = await bundle.generate( configuration.buildOptions.output )
 
             let code = output[ 0 ].code
             if ( code.length > 1 ) {
                 log( red( `[${ specificFilePath }] contain side-effects !` ) )
-                await bundle.write( configuration.output )
+                await bundle.write( configuration.buildOptions.output )
             } else {
                 log( green( `[${ specificFilePath }] is side-effect free.` ) )
             }
@@ -97,10 +104,10 @@ const checkBundlingFromEsmFilesImportTask       = async ( done ) => {
     done()
 
 }
-checkBundlingFromEsmFilesImportTask.displayName = 'check-bundling-from-esm-files-import'
+checkBundlingFromEsmFilesImportTask.displayName = basename( import.meta.filename, '.task.mjs' )
 checkBundlingFromEsmFilesImportTask.description = 'In view to detect bundling side effects this task will create intermediary file for each individual export from this package and then create rollup config for each of them and bundle'
 checkBundlingFromEsmFilesImportTask.flags       = null
 
-logLoadingTask( import.meta.filename, checkBundlingFromEsmFilesImportTask, configurationPath )
+logLoadingTask( import.meta.filename )
 
 export { checkBundlingFromEsmFilesImportTask }

package/sources/tests/bundlings/check-bundling.task.mjs

@@ -1,9 +1,12 @@
 import { series }                              from 'gulp'
+import { basename }                            from 'node:path'
 import { logLoadingTask }                      from '../../_utils.mjs'
 import { checkBundlingFromEsmBuildImportTask } from './check-bundling-from-esm-build-import.task.mjs'
 import { checkBundlingFromEsmFilesDirectTask } from './check-bundling-from-esm-files-direct.task.mjs'
 import { checkBundlingFromEsmFilesImportTask } from './check-bundling-from-esm-files-import.task.mjs'
 
+logLoadingTask( import.meta.filename )
+
 /**
  * @description In view to detect bundling side effects this task will
  * create intermediary file for each individual export from this package
@@ -15,9 +18,7 @@ const checkBundlingTask       = series(
     checkBundlingFromEsmBuildImportTask,
     checkBundlingFromEsmFilesDirectTask
 )
-checkBundlingTask.displayName = 'check-bundling'
+checkBundlingTask.displayName = basename( import.meta.filename, '.task.mjs' )
 checkBundlingTask.description = 'In view to detect bundling side effects this task will create intermediary file for each individual export and then try to bundle them.'
 
-logLoadingTask( import.meta.filename, checkBundlingTask )
-
 export { checkBundlingTask }

package/sources/tests/run-tests.task.mjs

@@ -1,8 +1,11 @@
 import { series }                 from 'gulp'
+import { basename }               from 'node:path'
 import { logLoadingTask }         from '../_utils.mjs'
 import { runBenchmarksTestsTask } from './benchmarks/run-benchmarks.task.mjs'
 import { runUnitTestsTask }       from './units/run-unit-tests.task.mjs'
 
+logLoadingTask( import.meta.filename )
+
 /**
  * @method npm run test
  * @global
@@ -12,10 +15,8 @@ const runTestsTask       = series(
     runBenchmarksTestsTask,
     runUnitTestsTask,
 )
-runTestsTask.displayName = 'run-tests'
+runTestsTask.displayName = basename( import.meta.filename, '.task.mjs' )
 runTestsTask.description = 'Will run unit tests and benchmarks for backend (node) and frontend (web-test-runner) environments.'
 runTestsTask.flags       = null
 
-logLoadingTask( import.meta.filename, runTestsTask )
-
 export { runTestsTask }

package/sources/tests/units/compute-unit-tests.task.mjs

@@ -1,31 +1,30 @@
 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,
-    getConfigurationFrom,
-    getConfigurationPathFor,
     getPrettyPackageName,
+    getTaskConfigurationFor,
     Indenter,
     logLoadingTask,
     packageName,
     packageNodeModulesDirectory,
-    packageSourcesDirectory as sourcesDir,
-    packageTestsUnitsDirectory as unitsDir
+    packageSourcesDirectory,
+    packageTestsUnitsDirectory
 }                          from '../../_utils.mjs'
 
-const configurationLocation = join( 'tests', 'units', 'compute-unit-tests.conf.mjs' )
-const configurationPath     = getConfigurationPathFor( configurationLocation )
-const configuration         = await getConfigurationFrom( configurationPath )
+logLoadingTask( import.meta.filename )
 
 const {
           red,
@@ -35,24 +34,39 @@ const {
 /**
  * @description Will generate unit test files from source code using type inference from comments
  */
-const computeUnitTestsTask       = ( done ) => {
+const computeUnitTestsTask       = async ( done ) => {
 
-    createDirectoryIfNotExist( unitsDir )
+    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 && isNotPrivateFile && isNotIgnoredFile
+                            } )
 
     const unitsImportMap = []
-    for ( let sourceFile of configuration ) {
+    for ( let sourceFile of sourceFiles ) {
 
-        const specificFilePath = sourceFile.replace( sourcesDir, '' )
+        const specificFilePath = sourceFile.replace( packageSourcesDirectory, '' )
         const specificDir      = dirname( specificFilePath )
 
         const fileName     = basename( sourceFile, extname( sourceFile ) )
         const unitFileName = `${ fileName }.unit.mjs`
-        const unitDirPath  = join( unitsDir, specificDir )
+        const unitDirPath  = join( packageTestsUnitsDirectory, specificDir )
         const unitFilePath = join( unitDirPath, unitFileName )
 
         const nsName         = `${ fileName }Namespace`
         const unitName       = `${ fileName }Units`
-        const importDirPath  = relative( unitDirPath, sourcesDir )
+        const importDirPath  = relative( unitDirPath, packageSourcesDirectory )
         const importFilePath = join( importDirPath, specificFilePath ).replace( /\\/g, '/' )
 
         try {
@@ -477,7 +491,7 @@ const computeUnitTestsTask       = ( done ) => {
                 '' +
                 `} )` + '\n'
 
-            const importUnitFilePath = relative( unitsDir, unitFilePath )
+            const importUnitFilePath = relative( packageTestsUnitsDirectory, unitFilePath )
             unitsImportMap.push( {
                 exportName: unitName,
                 path:       importUnitFilePath.replace( /\\/g, '/' )
@@ -509,7 +523,7 @@ const computeUnitTestsTask       = ( done ) => {
     } else {
 
         log( 'Warning ', yellow( 'No tests were generated. Create fallback global root import file.' ) )
-        const defaultUnitsDir  = join( unitsDir, 'default' )
+        const defaultUnitsDir  = join( packageTestsUnitsDirectory, 'default' )
         const defaultUnitsPath = join( defaultUnitsDir, 'default.unit.mjs' )
 
         createDirectoryIfNotExist( defaultUnitsDir )
@@ -520,16 +534,14 @@ const computeUnitTestsTask       = ( done ) => {
 
     }
 
-    const unitsFilePath = join( unitsDir, `${ packageName }.units.mjs` )
+    const unitsFilePath = join( packageTestsUnitsDirectory, `${ packageName }.units.mjs` )
     createFile( unitsFilePath, unitsTemplate )
 
     done()
 
 }
-computeUnitTestsTask.displayName = 'compute-unit-tests'
+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
 
-logLoadingTask( import.meta.filename, computeUnitTestsTask, configurationPath )
-
 export { computeUnitTestsTask }