@itee/tasks 1.3.0 → 1.3.2

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

@@ -0,0 +1,5 @@
+import { getUnscopedPackageName } from '../../utils/packages.mjs'
+
+export default [
+    `${ getUnscopedPackageName() }.js`
+]

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

@@ -1,36 +1,40 @@
-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 { isNotEmptyArray }         from 'itee-validators'
+import childProcess                from 'node:child_process'
 import {
     basename,
     dirname,
     extname,
     join,
-    normalize,
     relative
-}                          from 'path'
+}                                  from 'node:path'
+import {
+    red,
+    yellow
+}                                  from '../../utils/colors.mjs'
 import {
     createDirectoryIfNotExist,
     createFile,
+    getJavascriptSourceFiles
+}                                  from '../../utils/files.mjs'
+import {
+    log,
+    logLoadingTask
+}                                  from '../../utils/loggings.mjs'
+import {
     getPrettyPackageName,
-    getTaskConfigurationFor,
-    Indenter,
-    logLoadingTask,
-    packageName,
+    getUnscopedPackageName,
     packageNodeModulesDirectory,
     packageSourcesDirectory,
     packageTestsUnitsDirectory
-}                          from '../../_utils.mjs'
+}                                  from '../../utils/packages.mjs'
+import { getTaskConfigurationFor } from '../../utils/tasks.mjs'
+import {
+    Indenter,
+    toCamelCase
+}                                  from '../../utils/texts.mjs'
 
 logLoadingTask( import.meta.filename )
 
-const {
-          red,
-          yellow,
-      } = colors
-
 /**
  * @description Will generate unit test files from source code using type inference from comments
  */
@@ -38,20 +42,8 @@ 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 && isNotPrivateFile && isNotIgnoredFile
-                            } )
+    const sourceFiles       = getJavascriptSourceFiles( filePathsToIgnore )
 
     const unitsImportMap = []
     for ( let sourceFile of sourceFiles ) {
@@ -59,20 +51,26 @@ const computeUnitTestsTask       = async ( done ) => {
         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 fileName          = basename( sourceFile, extname( sourceFile ) )
+        const camelCaseFileName = toCamelCase( fileName )
+        const unitFileName      = `${ camelCaseFileName }.unit.mjs`
+        const unitDirPath       = join( packageTestsUnitsDirectory, specificDir )
+        const unitFilePath      = join( unitDirPath, unitFileName )
 
-        const nsName         = `${ fileName }Namespace`
-        const unitName       = `${ fileName }Units`
+        const nsName         = `${ camelCaseFileName }Namespace`
+        const unitName       = `${ camelCaseFileName }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 jsdocOutput = childProcess.execFileSync( 'node', [ jsdocPath, '--explain', sourceFile ] ).toString()
+
+            if ( jsdocOutput.includes( 'There are no input files to process' ) ) {
+                log( 'Error   ', red( `${ sourceFile }, no input files to process` ) )
+                continue
+            }
 
             const classNames    = []
             const usedLongnames = []
@@ -534,7 +532,7 @@ const computeUnitTestsTask       = async ( done ) => {
 
     }
 
-    const unitsFilePath = join( packageTestsUnitsDirectory, `${ packageName }.units.mjs` )
+    const unitsFilePath = join( packageTestsUnitsDirectory, `${ getUnscopedPackageName() }.units.mjs` )
     createFile( unitsFilePath, unitsTemplate )
 
     done()

package/sources/tests/units/run-unit-tests-for-backend.task.mjs

@@ -1,29 +1,31 @@
-import colors         from 'ansi-colors'
-import { spawn }      from 'child_process'
-import log            from 'fancy-log'
-import { existsSync } from 'fs'
-import { basename }   from 'node:path'
-import { join }       from 'path'
+import { spawn }      from 'node:child_process'
+import { existsSync } from 'node:fs'
 import {
-    logLoadingTask,
-    packageName,
+    basename,
+    join
+}                     from 'node:path'
+import {
+    red,
+    yellow
+}                     from '../../utils/colors.mjs'
+import {
+    log,
+    logLoadingTask
+}                     from '../../utils/loggings.mjs'
+import {
+    getUnscopedPackageName,
     packageNodeModulesDirectory,
     packageTestsUnitsDirectory
-}                     from '../../_utils.mjs'
+}                     from '../../utils/packages.mjs'
 
 logLoadingTask( import.meta.filename )
 
-const {
-          red,
-          yellow,
-      } = colors
-
 /**
  * @description Will run unit tests with node
  */
 const runUnitTestsForBackendTask       = ( done ) => {
 
-    const testsPath = join( packageTestsUnitsDirectory, `/${ packageName }.units.mjs` )
+    const testsPath = join( packageTestsUnitsDirectory, `/${ getUnscopedPackageName() }.units.mjs` )
     if ( !existsSync( testsPath ) ) {
         log( yellow( `${ testsPath } does not exist, skip backend unit tests...` ) )
         done()

package/{configs → sources}/tests/units/run-unit-tests-for-frontend.conf.mjs

@@ -1,7 +1,7 @@
 import { playwrightLauncher } from '@web/test-runner-playwright'
 
 export default {
-    files:       [
+    files: [
         'tests/units/**/*.unit.mjs'
     ],
     debug:       false,

package/sources/tests/units/run-unit-tests-for-frontend.task.mjs

@@ -1,28 +1,25 @@
-import { startTestRunner } from '@web/test-runner'
-import colors              from 'ansi-colors'
-import { basename }        from 'node:path'
-import {
-    getTaskConfigurationFor,
-    logLoadingTask
-}                          from '../../_utils.mjs'
+import { startTestRunner }         from '@web/test-runner'
+import { basename }                from 'node:path'
+import { red }                     from '../../utils/colors.mjs'
+import { logLoadingTask }          from '../../utils/loggings.mjs'
+import { getTaskConfigurationFor } from '../../utils/tasks.mjs'
 
 logLoadingTask( import.meta.filename )
 
-const { red } = colors
-
 /**
  * @description Will run unit tests with web-test-runner
  */
-const runUnitTestsForFrontendTask       = () => {
-    return new Promise( async ( resolve, reject ) => {
-
-        const configuration = await getTaskConfigurationFor( import.meta.filename )
-        const testRunner    = await startTestRunner( {
-            config:          configuration,
-            readCliArgs:     false,
-            readFileConfig:  false,
-            autoExitProcess: false,
-        } )
+const runUnitTestsForFrontendTask       = async () => {
+
+    const configuration = await getTaskConfigurationFor( import.meta.filename )
+    const testRunner    = await startTestRunner( {
+        config:          configuration,
+        readCliArgs:     false,
+        readFileConfig:  false,
+        autoExitProcess: false,
+    } )
+
+    return new Promise( ( resolve, reject ) => {
 
         if ( !testRunner ) {
             reject( red( 'Internal test runner error.' ) )
@@ -40,6 +37,7 @@ const runUnitTestsForFrontendTask       = () => {
         } )
 
     } )
+
 }
 runUnitTestsForFrontendTask.displayName = basename( import.meta.filename, '.task.mjs' )
 runUnitTestsForFrontendTask.description = 'Will run unit tests with web-test-runner'

package/{configs → sources}/tests/units/run-unit-tests.conf.mjs

@@ -1,5 +1,5 @@
-import { join }                        from 'path'
-import { iteePackageSourcesDirectory } from '../../../sources/_utils.mjs'
+import { join }                        from 'node:path'
+import { iteePackageSourcesDirectory } from '../../utils/packages.mjs'
 
 export default [
     join( iteePackageSourcesDirectory, 'tests/units/run-unit-tests-for-backend.task.mjs' ),

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

@@ -1,9 +1,9 @@
-import { basename } from 'node:path'
+import { basename }        from 'node:path'
+import { logLoadingTask, } from '../../utils/loggings.mjs'
 import {
     getTaskConfigurationFor,
-    logLoadingTask,
     serializeTasksFrom
-}                   from '../../_utils.mjs'
+}                          from '../../utils/tasks.mjs'
 
 logLoadingTask( import.meta.filename )
 

package/sources/utils/builds.mjs

@@ -0,0 +1,238 @@
+import commonjs    from '@rollup/plugin-commonjs'
+import nodeResolve from '@rollup/plugin-node-resolve'
+import terser      from '@rollup/plugin-terser'
+import figlet      from 'figlet'
+import {
+    basename,
+    join
+}                  from 'node:path'
+import replace     from 'rollup-plugin-re'
+import { red }     from './colors.mjs'
+import { log }     from './loggings.mjs'
+import {
+    getPrettyPackageName,
+    getPrettyPackageVersion,
+    getUnscopedPackageName,
+    packageAuthor,
+    packageBuildsDirectory,
+    packageDescription,
+    packageLicense,
+    packageSourcesDirectory
+}                  from './packages.mjs'
+
+
+function getPrettyFormatForBanner( format ) {
+
+    let prettyFormat = ''
+
+    switch ( format ) {
+
+        case 'cjs':
+            prettyFormat = 'CommonJs'
+            break
+
+        case 'esm':
+            prettyFormat = 'EsModule'
+            break
+
+        case 'iife':
+            prettyFormat = 'Standalone'
+            break
+
+        case 'umd':
+            prettyFormat = 'Universal'
+            break
+
+        default:
+            throw new RangeError( `Invalid switch parameter: ${ format }` )
+
+    }
+
+    return prettyFormat
+
+}
+
+function convertBannerIntoComment( banner ) {
+
+    let bannerCommented = '/**\n'
+    bannerCommented += ' * '
+    bannerCommented += banner.replaceAll( '\n', '\n * ' )
+    bannerCommented += '\n'
+    bannerCommented += ` * @desc    ${ packageDescription }\n`
+    bannerCommented += ` * @author  [${ packageAuthor.name }]{@link ${ packageAuthor.url }}\n`
+    bannerCommented += ` * @license [${ packageLicense }]{@link https://opensource.org/licenses}\n`
+    bannerCommented += ' * \n'
+    bannerCommented += ' */'
+
+    return bannerCommented
+
+}
+
+function computeBannerFor( format ) {
+
+    const packageName    = getPrettyPackageName( '.' )
+    const packageVersion = getPrettyPackageVersion()
+    const prettyFormat   = getPrettyFormatForBanner( format )
+
+    const figText = figlet.textSync(
+        `${ packageName } ${ packageVersion } - ${ prettyFormat }`,
+        {
+            font:             'Tmplr',
+            horizontalLayout: 'default',
+            verticalLayout:   'default',
+            whitespaceBreak:  true,
+        }
+    )
+
+    return convertBannerIntoComment( figText )
+
+}
+
+function computeIntroFor( requestPackages = [] ) {
+
+    let intro = ''
+
+    for ( const requestPackage of requestPackages ) {
+        intro += `if( ${ requestPackage } === undefined ) { throw new Error('${ getPrettyPackageName() } need ${ requestPackage } to be defined first. Please check your scripts loading order.') }` + '\n'
+    }
+
+    return intro
+
+}
+
+function getOutputFileExtensionBasedOnFileFormat( format ) {
+
+    let extension
+
+    if ( format === 'cjs' ) {
+        extension = 'cjs'
+    } else if ( format === 'esm' ) {
+        extension = 'mjs'
+    } else {
+        extension = 'js'
+    }
+
+    return extension
+
+}
+
+/**
+ * Will create an appropriate configuration object for rollup, related to the given arguments.
+ *
+ * @generator
+ * @param options
+ * @return {Array.<json>} An array of rollup configuration
+ */
+function createRollupConfigs( options = {} ) {
+
+    const _options = {
+        input:     join( packageSourcesDirectory, `${ getUnscopedPackageName() }.js` ),
+        output:    packageBuildsDirectory,
+        formats:   [ 'esm', 'cjs', 'iife' ],
+        envs:      [ 'dev', 'prod' ],
+        treeshake: true,
+        ...options
+    }
+
+    const {
+              input,
+              output,
+              formats,
+              envs,
+              treeshake
+          }        = _options
+    const name     = getPrettyPackageName( '.' )
+    const fileName = basename( input, '.js' )
+
+    const configs = []
+
+    for ( let formatIndex = 0, numberOfFormats = formats.length ; formatIndex < numberOfFormats ; ++formatIndex ) {
+
+        for ( let envIndex = 0, numberOfEnvs = envs.length ; envIndex < numberOfEnvs ; envIndex++ ) {
+
+            const env        = envs[ envIndex ]
+            const isProd     = ( env.includes( 'prod' ) )
+            const format     = formats[ formatIndex ]
+            const extension  = getOutputFileExtensionBasedOnFileFormat( format )
+            const outputPath = ( isProd )
+                               ? join( output, `${ fileName }.min.${ extension }` )
+                               : join( output, `${ fileName }.${ extension }` )
+
+            configs.push( {
+                input:    input,
+                external: ( format === 'cjs' ) ? [
+                    'fs'
+                ] : [],
+                plugins: [
+                    replace( {
+                        defines: {
+                            IS_REMOVE_ON_BUILD:  false,
+                            IS_BACKEND_SPECIFIC: ( format === 'cjs' )
+                        }
+                    } ),
+                    commonjs( {
+                        include: 'node_modules/**'
+                    } ),
+                    nodeResolve( {
+                        preferBuiltins: true
+                    } ),
+                    isProd && terser()
+                ],
+                onwarn: ( {
+                    loc,
+                    frame,
+                    message
+                } ) => {
+
+                    // Ignore some errors
+                    if ( message.includes( 'Circular dependency' ) ) { return }
+                    if ( message.includes( 'plugin uglify is deprecated' ) ) { return }
+
+                    let errorMessage = ( loc )
+                                       ? `/!\\ ${ loc.file } (${ loc.line }:${ loc.column }) ${ frame } ${ message }\n`
+                                       : `/!\\ ${ message }\n`
+
+                    log( red( errorMessage ) )
+
+                },
+                treeshake: treeshake,
+                output:    {
+                    // core options
+                    file:    outputPath,
+                    format:  format,
+                    name:    name,
+                    globals: {},
+
+                    // advanced options
+                    paths:     {},
+                    banner:    ( isProd ) ? '' : computeBannerFor( format ),
+                    footer:    '',
+                    intro:     ( !isProd && format === 'iife' ) ? computeIntroFor() : '',
+                    outro:     '',
+                    sourcemap: !isProd,
+                    interop:   'auto',
+
+                    // danger zone
+                    exports: 'auto',
+                    amd:     {},
+                    indent:  '\t',
+                    strict:  true
+                }
+            } )
+
+        }
+
+    }
+
+    return configs
+
+}
+
+
+export {
+    getPrettyFormatForBanner,
+    convertBannerIntoComment,
+    computeBannerFor,
+    computeIntroFor,
+    createRollupConfigs,
+}

package/sources/utils/colors.mjs

@@ -0,0 +1,19 @@
+import colors from 'ansi-colors'
+
+const red     = ( value ) => colors.red( value )
+const green   = ( value ) => colors.green( value )
+const blue    = ( value ) => colors.blue( value )
+const cyan    = ( value ) => colors.cyan( value )
+const yellow  = ( value ) => colors.yellow( value )
+const magenta = ( value ) => colors.magenta( value )
+const unstyle = ( value ) => colors.unstyle( value )
+
+export {
+    red,
+    green,
+    blue,
+    cyan,
+    yellow,
+    magenta,
+    unstyle
+}

package/sources/utils/files.mjs

@@ -0,0 +1,70 @@
+import { glob }                    from 'glob'
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    writeFileSync
+}                                  from 'node:fs'
+import {
+    basename,
+    extname,
+    join,
+    normalize
+}                                  from 'node:path'
+import { green }                   from './colors.mjs'
+import { log }                     from './loggings.mjs'
+import { packageSourcesDirectory } from './packages.mjs'
+
+function createDirectoryIfNotExist( directoryPath ) {
+
+    if ( existsSync( directoryPath ) ) { return }
+
+    log( 'Creating', green( directoryPath ) )
+    mkdirSync( directoryPath, { recursive: true } )
+
+}
+
+function getJsonFrom( path ) {
+
+    const buffer      = readFileSync( path )
+    const fileContent = buffer.toString()
+    return JSON.parse( fileContent )
+
+}
+
+function createFile( filePath, fileContent ) {
+
+    log( 'Creating', green( filePath ) )
+    writeFileSync( filePath, fileContent )
+
+}
+
+function getFilesFrom( globPattern, filter = ( /*any*/ ) => true ) {
+
+    return glob.sync( globPattern )
+               .map( filePath => normalize( filePath ) )
+               .filter( filter )
+
+}
+
+function getJavascriptSourceFiles( filePathsToIgnore = [] ) {
+
+    return glob.sync( join( packageSourcesDirectory, '**' ) )
+               .map( filePath => normalize( filePath ) )
+               .filter( filePath => {
+                   const fileName         = basename( filePath )
+                   const isJsFile         = [ '.js', '.mjs', '.cjs' ].includes( extname( fileName ) )
+                   const isNotPrivateFile = !fileName.startsWith( '_' )
+                   const isNotIgnoredFile = !filePathsToIgnore.includes( fileName )
+                   return isJsFile && isNotPrivateFile && isNotIgnoredFile
+               } )
+
+}
+
+export {
+    createDirectoryIfNotExist,
+    getJsonFrom,
+    createFile,
+    getFilesFrom,
+    getJavascriptSourceFiles
+}

package/sources/utils/loggings.mjs

@@ -0,0 +1,33 @@
+import log                      from 'fancy-log'
+import {
+    basename,
+    relative
+}                               from 'node:path'
+import {
+    blue,
+    green
+}                               from './colors.mjs'
+import { packageRootDirectory } from './packages.mjs'
+
+/* global process */
+const isDebugging = ( process && process.env && process.env.RUNNER_DEBUG && process.env.RUNNER_DEBUG === '1' )
+
+
+function logLoadingTask( filename ) {
+
+    if ( !isDebugging ) {
+        return
+    }
+
+    const taskPath = relative( packageRootDirectory, filename )
+    const taskName = basename( filename, '.task.mjs' )
+
+    log( `Loading  ${ green( taskPath ) } with task ${ blue( taskName ) }` )
+
+}
+
+
+export {
+    log,
+    logLoadingTask
+}