@itee/tasks 1.3.1 → 1.3.2

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,15 +1,11 @@
-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
  */

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
+}

package/sources/utils/packages.mjs

@@ -0,0 +1,172 @@
+import childProcess      from 'child_process'
+import {
+    dirname,
+    join
+}                        from 'node:path'
+import { fileURLToPath } from 'node:url'
+import {
+    red,
+    yellow
+}                        from './colors.mjs'
+import { getJsonFrom }   from './files.mjs'
+import { log }           from './loggings.mjs'
+
+function _getPackageRootDirectory() {
+
+    let __dirname
+
+    if ( import.meta.dirname ) {
+        __dirname = import.meta.dirname
+    } else if ( import.meta.filename ) {
+        __dirname = dirname( import.meta.filename )
+    } else if ( import.meta.url ) {
+        const __filename = fileURLToPath( import.meta.url )
+        __dirname        = dirname( __filename )
+    } else {
+        throw new Error( 'Unable to retrieve module dirname.' )
+    }
+
+    return join( __dirname, '../../' )
+
+}
+
+const iteePackageRootDirectory        = _getPackageRootDirectory()
+const iteePackageJsonPath             = join( iteePackageRootDirectory, 'package.json' )
+const iteePackageNodeModulesDirectory = join( iteePackageRootDirectory, 'node_modules' )
+const iteePackageSourcesDirectory     = join( iteePackageRootDirectory, 'sources' )
+
+const packageRootDirectory                = iteePackageRootDirectory.includes( 'node_modules' ) ? join( iteePackageRootDirectory, '../../../' ) : iteePackageRootDirectory
+const packageTasksDirectory               = join( packageRootDirectory, '.tasks' )
+const packageTasksConfigurationsDirectory = join( packageTasksDirectory, 'configs' )
+const packageNodeModulesDirectory         = join( packageRootDirectory, 'node_modules' )
+const packageBuildsDirectory              = join( packageRootDirectory, 'builds' )
+const packageSourcesDirectory             = join( packageRootDirectory, 'sources' )
+const packageSourcesBackendDirectory      = join( packageSourcesDirectory, 'backend' )
+const packageSourcesCommonDirectory       = join( packageSourcesDirectory, 'common' )
+const packageSourcesFrontendDirectory     = join( packageSourcesDirectory, 'frontend' )
+const packageTestsDirectory               = join( packageRootDirectory, 'tests' )
+const packageTestsBenchmarksDirectory     = join( packageTestsDirectory, 'benchmarks' )
+const packageTestsBundlesDirectory        = join( packageTestsDirectory, 'bundles' )
+const packageTestsUnitsDirectory          = join( packageTestsDirectory, 'units' )
+const packageDocsDirectory                = join( packageRootDirectory, 'docs' )
+const packageTutorialsDirectory           = join( packageRootDirectory, 'tutorials' )
+const packageJsonPath                     = join( packageRootDirectory, 'package.json' )
+
+///
+
+const packageJson        = getJsonFrom( packageJsonPath )
+const packageName        = packageJson.name
+const packageVersion     = packageJson.version
+const packageDescription = packageJson.description
+const packageAuthor      = packageJson.author
+const packageLicense     = packageJson.license
+const packageMain        = packageJson.main
+
+function getUnscopedPackageName() {
+
+    return packageName.startsWith( '@' )
+           ? packageName.split( '/' )[ 1 ]
+           : packageName.split( '-' )[ 1 ]
+
+}
+
+function getPrettyPackageName( separator = ' ' ) {
+
+    let prettyPackageName = ''
+
+    const nameSplits = packageName.startsWith( '@' )
+                       ? packageName.slice( 1 ).split( '/' )
+                       : packageName.split( '-' )
+
+    for ( const nameSplit of nameSplits ) {
+        prettyPackageName += nameSplit.charAt( 0 ).toUpperCase() + nameSplit.slice( 1 ) + separator
+    }
+    prettyPackageName = prettyPackageName.slice( 0, -1 )
+
+    return prettyPackageName
+
+}
+
+function getPrettyPackageVersion() {
+
+    return 'v' + packageVersion
+
+}
+
+function getPrettyNodeVersion() {
+
+    let nodeVersion = 'vX.x.ₓ'
+
+    try {
+        nodeVersion = childProcess.execFileSync( 'node', [ '--version' ] )
+                                  .toString()
+                                  .replace( /(\r\n|\n|\r)/gm, '' )
+    } catch ( e ) {
+        log( red( e ) )
+
+        if ( e.message.includes( 'ENOENT' ) ) {
+            nodeVersion += yellow( ' Not seems to be accessible from the path environment.' )
+        }
+    }
+
+    return ' node: ' + nodeVersion
+
+}
+
+function getPrettyNpmVersion() {
+
+    let npmVersion = 'X.x.ₓ'
+
+    try {
+        npmVersion = childProcess.execFileSync( 'npm', [ '--version' ] )
+                                 .toString()
+                                 .replace( /(\r\n|\n|\r)/gm, '' )
+    } catch ( e ) {
+        log( red( e ) )
+
+        if ( e.message.includes( 'ENOENT' ) ) {
+            npmVersion += yellow( ' Not seems to be accessible from the path environment.' )
+        }
+    }
+
+    return ' npm:  v' + npmVersion
+
+}
+
+
+export {
+    iteePackageRootDirectory,
+    iteePackageJsonPath,
+    iteePackageNodeModulesDirectory,
+    iteePackageSourcesDirectory,
+
+    packageRootDirectory,
+    packageTasksDirectory,
+    packageTasksConfigurationsDirectory,
+    packageNodeModulesDirectory,
+    packageBuildsDirectory,
+    packageSourcesDirectory,
+    packageSourcesBackendDirectory,
+    packageSourcesCommonDirectory,
+    packageSourcesFrontendDirectory,
+    packageTestsDirectory,
+    packageTestsBenchmarksDirectory,
+    packageTestsBundlesDirectory,
+    packageTestsUnitsDirectory,
+    packageDocsDirectory,
+    packageTutorialsDirectory,
+    packageJsonPath,
+
+    packageJson,
+    packageName,
+    packageVersion,
+    packageDescription,
+    packageAuthor,
+    packageLicense,
+    packageMain,
+    getUnscopedPackageName,
+    getPrettyPackageName,
+    getPrettyPackageVersion,
+    getPrettyNodeVersion,
+    getPrettyNpmVersion,
+}