@itee/tasks 1.3.0 → 1.3.2

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

package/sources/utils/tasks.mjs

@@ -0,0 +1,170 @@
+import {
+    parallel,
+    series
+}                      from 'gulp'
+import { existsSync }  from 'node:fs'
+import {
+    extname,
+    join,
+    relative
+}                      from 'node:path'
+import {
+    blue,
+    cyan,
+    magenta,
+    red,
+}                      from './colors.mjs'
+import { getJsonFrom } from './files.mjs'
+import { log }         from './loggings.mjs'
+import {
+    iteePackageSourcesDirectory,
+    packageRootDirectory,
+    packageTasksConfigurationsDirectory,
+    packageTasksDirectory
+}                      from './packages.mjs'
+
+async function getTasksFrom( taskFiles = [] ) {
+
+    const tasks = []
+    for ( const taskFile of taskFiles ) {
+        const relativeTaskFile = relative( packageRootDirectory, taskFile )
+
+        try {
+
+            const module = await import(taskFile)
+
+            const exportStrings = []
+            for ( const moduleKey in module ) {
+                const task = module[ moduleKey ]
+                tasks.push( task )
+
+                const name         = task.name ?? null
+                const displayName  = task.displayName ?? null
+                const fullName     = ( moduleKey !== name ) ? `${ blue( moduleKey ) }( ${ magenta( name ) } )` : `${ blue( name ) }`
+                const exportAs     = ( displayName ) ? ` as ${ cyan( displayName ) }` : ''
+                const exportString = fullName + exportAs
+                exportStrings.push( exportString )
+            }
+
+            //log( 'Process ', green( relativeTaskFile ), `with task${ ( exportStrings.length > 1 ) ? 's' : '' }`, exportStrings.join( ', ' ) )
+
+        } catch ( error ) {
+
+            log( 'Error   ', red( relativeTaskFile ), error.message )
+
+        }
+
+    }
+
+    return tasks
+
+}
+
+async function serializeTasksFrom( taskFiles = [] ) {
+
+    const tasks = await getTasksFrom( taskFiles )
+    return series( ...tasks )
+
+}
+
+async function parallelizeTasksFrom( taskFiles = [] ) {
+
+    const tasks = await getTasksFrom( taskFiles )
+    return parallel( ...tasks )
+
+}
+
+/// Task configuration management
+
+function getTaskConfigurationPathFor( filename ) {
+
+    // Get relative path of the task between internal or user defined
+    let relativeTaskPath = filename.includes( iteePackageSourcesDirectory )
+                           ? relative( iteePackageSourcesDirectory, filename )
+                           : relative( packageTasksDirectory, filename )
+
+    // Generate all possible config file path depending on file extension and default or user defined
+    const terminalExtension = extname( relativeTaskPath )
+    const searchValue       = relativeTaskPath.includes( '.task.' ) ? `.task${ terminalExtension }` : terminalExtension
+    const replaceValues     = [
+        '.conf.json',
+        '.conf.js',
+        '.conf.cjs',
+        '.conf.mjs',
+    ]
+
+    const packageConfigurationPaths = []
+    const defaultConfigurationPaths = []
+
+    for ( const replaceValue of replaceValues ) {
+        const configurationLocation    = relativeTaskPath.replace( searchValue, replaceValue )
+        const packageConfigurationPath = join( packageTasksConfigurationsDirectory, configurationLocation )
+        const defaultConfigurationPath = join( iteePackageSourcesDirectory, configurationLocation )
+
+        packageConfigurationPaths.push( packageConfigurationPath )
+        defaultConfigurationPaths.push( defaultConfigurationPath )
+    }
+
+    // Take care of the configuration search order (package first then default !)
+    const configurationPaths = [ ...packageConfigurationPaths, ...defaultConfigurationPaths ]
+    let configurationPath    = undefined
+
+    // Looking for existing configuration file
+    for ( const packageConfigurationPath of configurationPaths ) {
+
+        if ( existsSync( packageConfigurationPath ) ) {
+            configurationPath = packageConfigurationPath
+            break
+        }
+
+    }
+
+    // Else throw an error
+    if ( !configurationPath ) {
+        throw new Error( `Unable to find configuration in package configuration paths ${ configurationPaths.join( ', ' ) }.` )
+    }
+
+    return configurationPath
+
+}
+
+async function getTaskConfigurationFor( filename ) {
+
+    const configurationFilePath = getTaskConfigurationPathFor( filename )
+
+    log( `Loading configuration from ${ cyan( configurationFilePath ) }` )
+
+    let configuration = null
+
+    try {
+
+        if ( extname( configurationFilePath ) === '.json' ) {
+
+            configuration = getJsonFrom( configurationFilePath )
+
+        } else {
+
+            const moduleData = await import( configurationFilePath )
+            configuration    = moduleData.default
+
+        }
+
+    } catch ( e ) {
+
+        log( red( e ) )
+
+    }
+
+    return configuration
+
+}
+
+
+export {
+    getTasksFrom,
+    serializeTasksFrom,
+    parallelizeTasksFrom,
+
+    getTaskConfigurationPathFor,
+    getTaskConfigurationFor,
+}

package/sources/utils/texts.mjs

@@ -0,0 +1,98 @@
+import { unstyle } from './colors.mjs'
+
+function alignTextCenter( text, width ) {
+
+    const unstyledText = unstyle( text.repeat( 1 ) )
+    const marginLength = ( width - unstyledText.length ) / 2
+
+    let leftMargin, rightMargin
+    if ( Number.isInteger( marginLength ) ) {
+        leftMargin  = marginLength
+        rightMargin = marginLength
+    } else {
+        const flooredMargin = Math.floor( marginLength )
+        leftMargin          = flooredMargin
+        rightMargin         = flooredMargin + 1
+    }
+
+    return ' '.repeat( leftMargin ) + text + ' '.repeat( rightMargin )
+
+}
+
+function alignTextLeft( text, width ) {
+
+    const unstyledText = unstyle( text.repeat( 1 ) )
+    let repeatTime     = width - unstyledText.length
+    repeatTime         = ( repeatTime > 0 ) ? repeatTime : 0
+
+    return text + ' '.repeat( repeatTime )
+
+}
+
+function alignTextRight( text, width ) {
+
+    const unstyledText = unstyle( text.repeat( 1 ) )
+    let repeatTime     = width - unstyledText.length
+    repeatTime         = ( repeatTime > 0 ) ? repeatTime : 0
+
+    return ' '.repeat( repeatTime ) + text
+
+}
+
+function IndenterFactory( indentationChar = '\t', indentationLevel = 5 ) {
+
+    const indentationLevels = {}
+    let currentProperty     = 'I_'
+    for ( let currentIndentationLevel = 1 ; currentIndentationLevel <= indentationLevel ; currentIndentationLevel++ ) {
+        indentationLevels[ currentProperty ] = indentationChar.repeat( currentIndentationLevel )
+        currentProperty += '_'
+    }
+
+    return {
+        I: new Indenter( indentationChar ),
+        ...indentationLevels
+    }
+
+}
+
+function toCamelCase( string ) {
+
+    return string
+        .trim()
+        .toLowerCase()
+        .replace( /[^a-zA-Z0-9]+(.)/g, ( _, char ) => char.toUpperCase() )
+        .replace( /^[A-Z]/, ( char ) => char.toLowerCase() )
+
+}
+
+class Indenter {
+
+    constructor( indentationChar = '\t' ) {
+
+        this.indentationChar         = indentationChar
+        this.currentIndentationLevel = 0
+
+    }
+
+    _( indentationLevel = null ) {
+        return this.indentationChar.repeat( indentationLevel ?? this.currentIndentationLevel )
+    }
+
+    deeper( level = 1 ) {
+        this.currentIndentationLevel += level
+    }
+
+    shallower( level = 1 ) {
+        this.currentIndentationLevel -= level
+    }
+
+}
+
+
+export {
+    alignTextCenter,
+    alignTextLeft,
+    alignTextRight,
+    toCamelCase,
+    IndenterFactory as Indenter
+}

package/configs/builds/build.conf.mjs

@@ -1,3 +0,0 @@
-import { createRollupConfigs } from '../../sources/_utils.mjs'
-
-export default createRollupConfigs()

package/configs/tests/benchmarks/compute-benchmarks.conf.mjs

@@ -1,5 +0,0 @@
-import { packageName } from '../../../sources/_utils.mjs'
-
-export default [
-    `${ packageName }.js`
-]

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

@@ -1,5 +0,0 @@
-import { packageName } from '../../../sources/_utils.mjs'
-
-export default [
-    `${ packageName }.js`
-]