@itee/tasks 1.0.12

package/sources/_utils.mjs

@@ -0,0 +1,412 @@
+import colors            from 'ansi-colors'
+import childProcess      from 'child_process'
+import log               from 'fancy-log'
+import { glob }          from 'glob'
+import {
+    parallel,
+    series
+}                        from 'gulp'
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    writeFileSync
+}                        from 'node:fs'
+import {
+    basename,
+    dirname,
+    extname,
+    join,
+    normalize,
+    relative,
+}                        from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const {
+          red,
+          green,
+          yellow,
+          blue,
+          magenta,
+          cyan
+      } = colors
+
+///
+
+function createDirectoryIfNotExist( directoryPath ) {
+
+    if ( !existsSync( directoryPath ) ) {
+        log( 'Creating', green( directoryPath ) )
+        mkdirSync( directoryPath, { recursive: true } )
+    }
+
+}
+
+function getJsonFrom( path ) {
+
+    const buffer = readFileSync( path )
+    return JSON.parse( buffer.toString() )
+
+}
+
+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.mjs',
+    ]
+
+    const packageConfigurationPaths = []
+    const defaultConfigurationPaths = []
+
+    for ( const replaceValue of replaceValues ) {
+        const configurationLocation    = relativeTaskPath.replace( searchValue, replaceValue )
+        const packageConfigurationPath = join( packageTasksConfigurationsDirectory, configurationLocation )
+        const defaultConfigurationPath = join( iteePackageConfigurationsDirectory, 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
+
+}
+
+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 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 iteePackageConfigurationsDirectory = join( iteePackageRootDirectory, 'configs' )
+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
+
+function getPrettyPackageName( separator = ' ' ) {
+
+    let prettyPackageName = ''
+
+    const nameSplits = 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
+
+}
+
+///
+
+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 )
+
+}
+
+///
+
+function logLoadingTask( filename ) {
+
+    const taskPath = relative( packageRootDirectory, filename )
+    const taskName = basename( filename, '.task.mjs' )
+
+    log( `Loading  ${ green( taskPath ) } with task ${ blue( taskName ) }` )
+
+}
+
+///
+
+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
+    }
+
+}
+
+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 {
+    createDirectoryIfNotExist,
+    getJsonFrom,
+    getTaskConfigurationPathFor,
+    getTaskConfigurationFor,
+    createFile,
+    getFilesFrom,
+
+    iteePackageRootDirectory,
+    iteePackageJsonPath,
+    iteePackageConfigurationsDirectory,
+    iteePackageNodeModulesDirectory,
+    iteePackageSourcesDirectory,
+
+    packageRootDirectory,
+    packageTasksDirectory,
+    packageTasksConfigurationsDirectory,
+    packageNodeModulesDirectory,
+    packageBuildsDirectory,
+    packageSourcesDirectory,
+    packageSourcesBackendDirectory,
+    packageSourcesCommonDirectory,
+    packageSourcesFrontendDirectory,
+    packageTestsDirectory,
+    packageTestsBenchmarksDirectory,
+    packageTestsBundlesDirectory,
+    packageTestsUnitsDirectory,
+    packageDocsDirectory,
+    packageTutorialsDirectory,
+    packageJsonPath,
+    packageJson,
+    packageName,
+    packageVersion,
+    packageDescription,
+    getPrettyPackageName,
+    getPrettyPackageVersion,
+    getPrettyNodeVersion,
+    getPrettyNpmVersion,
+
+    getTasksFrom,
+    serializeTasksFrom,
+    parallelizeTasksFrom,
+    logLoadingTask,
+
+    IndenterFactory as Indenter
+}

package/sources/builds/build.task.mjs

@@ -0,0 +1,52 @@
+import colors     from 'ansi-colors'
+import log        from 'fancy-log'
+import { basename } from 'node:path'
+import { rollup } from 'rollup'
+import {
+    getTaskConfigurationFor,
+    logLoadingTask
+}                 from '../_utils.mjs'
+
+logLoadingTask( import.meta.filename )
+
+const {
+          red,
+          green,
+          yellow,
+      } = colors
+
+const buildTask       = async ( done ) => {
+
+    const configuration = await getTaskConfigurationFor( import.meta.filename )
+
+    for ( let config of configuration ) {
+
+        if ( config === undefined || config === null || config.length === 0 ) {
+            log( yellow( 'Empty configuration object... Skip it!' ) )
+            continue
+        }
+
+        log( 'Building', green( config.output.file ) )
+
+        try {
+
+            const bundle = await rollup( config )
+            await bundle.write( config.output )
+
+        } catch ( error ) {
+
+            done( red( error.message ) )
+            return
+
+        }
+
+    }
+
+    done()
+
+}
+buildTask.displayName = basename( import.meta.filename, '.task.mjs' )
+buildTask.description = 'Todo...'
+buildTask.flags       = null
+
+export { buildTask }

package/sources/cleans/clean.task.mjs

@@ -0,0 +1,32 @@
+import colors          from 'ansi-colors'
+import { deleteAsync } from 'del'
+import log             from 'fancy-log'
+import { basename }    from 'node:path'
+import {
+    getTaskConfigurationFor,
+    logLoadingTask
+}                      from '../_utils.mjs'
+
+logLoadingTask( import.meta.filename )
+
+const { red }       = colors
+const configuration = await getTaskConfigurationFor( import.meta.filename )
+
+/**
+ * @method npm run clean
+ * @global
+ * @description Will delete builds and temporary folders
+ */
+const cleanTask       = () => deleteAsync( configuration, {
+    onProgress: progress => {
+        const path    = progress.path || 'Nothing to clean...'
+        const percent = Math.round( progress.percent * 100 )
+        const spacer  = percent === 100 ? '' : ' '
+        log( `Deleting [${ progress.deletedCount }/${ progress.totalCount }]<${ percent }%>${ spacer }:`, red( path ) )
+    }
+} )
+cleanTask.displayName = basename( import.meta.filename, '.task.mjs' )
+cleanTask.description = 'Will delete builds and temporary folders'
+cleanTask.flags       = null
+
+export { cleanTask }

package/sources/docs/doc.task.mjs

@@ -0,0 +1,48 @@
+import colors        from 'ansi-colors'
+import log           from 'fancy-log'
+import child_process from 'node:child_process'
+import { basename }  from 'node:path'
+import { promisify } from 'node:util'
+import {
+    getTaskConfigurationPathFor,
+    logLoadingTask
+}                    from '../_utils.mjs'
+
+logLoadingTask( import.meta.filename )
+
+const execFile = promisify( child_process.execFile )
+const { red }  = colors
+
+/**
+ * @method npm run doc
+ * @global
+ * @description Will generate this documentation
+ */
+const docTask       = async ( done ) => {
+
+    try {
+
+        const configurationPath = getTaskConfigurationPathFor( import.meta.filename )
+
+        const { stdout } = await execFile(
+            './node_modules/.bin/jsdoc',
+            [
+                '--configure', configurationPath,
+                '--destination', './docs'
+            ]
+        )
+        log( stdout )
+        done()
+
+    } catch ( error ) {
+
+        done( red( error.message ) )
+
+    }
+
+}
+docTask.displayName = basename( import.meta.filename, '.task.mjs' )
+docTask.description = 'Will generate this documentation.'
+docTask.flags       = null
+
+export { docTask }

package/sources/helps/help.task.mjs

@@ -0,0 +1,155 @@
+import colors from 'ansi-colors'
+import log    from 'fancy-log'
+import { basename } from 'node:path'
+import {
+    getPrettyNodeVersion,
+    getPrettyNpmVersion,
+    getPrettyPackageName,
+    getPrettyPackageVersion,
+    Indenter,
+    logLoadingTask
+}             from '../_utils.mjs'
+
+logLoadingTask( import.meta.filename )
+
+const {
+          red,
+          green,
+          blue,
+          cyan,
+          yellow,
+          magenta,
+          unstyle
+      } = colors
+
+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
+
+}
+
+/**
+ * @method npm run help ( default )
+ * @global
+ * @description Will display the help in console
+ */
+const helpTask       = ( done ) => {
+
+    const bannerWidth          = 70
+    const prettyPackageName    = getPrettyPackageName()
+    const prettyPackageVersion = getPrettyPackageVersion()
+    const prettyNodeVersion    = getPrettyNodeVersion()
+    const prettyNpmVersion     = getPrettyNpmVersion()
+
+    const tableCharset = {
+        topLeftCorner:       '┏',
+        topRightCorner:      '┓',
+        bottomRightCorner:   '┛',
+        bottomLeftCorner:    '┗',
+        horizontalBorder:    '━',
+        horizontalSeparator: '─',
+        leftJoinSeparator:   '┠',
+        rightJoinSeparator:  '┨',
+        verticalBorder:      '┃',
+        verticalSeparator:   '',
+    }
+
+    const mainBorder     = tableCharset.horizontalBorder.repeat( bannerWidth )
+    const thinBorder     = tableCharset.horizontalSeparator.repeat( bannerWidth )
+    const tableTop       = `${ tableCharset.topLeftCorner }${ mainBorder }${ tableCharset.topRightCorner }`
+    const tableSeparator = `${ tableCharset.leftJoinSeparator }${ thinBorder }${ tableCharset.rightJoinSeparator }`
+    const tableBottom    = `${ tableCharset.bottomLeftCorner }${ mainBorder }${ tableCharset.bottomRightCorner }`
+    const tableLine      = ( innerText ) => `${ tableCharset.verticalBorder }${ innerText }${ tableCharset.verticalBorder }`
+
+    const {
+              I_,
+              I__,
+              I___,
+              I____,
+          } = new Indenter( '\t', 4 )
+
+    const npmRun = blue( 'npm run' )
+
+    log( '' )
+    log( tableTop )
+    log( tableLine( alignTextCenter( 'HELP', bannerWidth ) ) )
+    log( tableLine( alignTextCenter( prettyPackageName, bannerWidth ) ) )
+    log( tableLine( alignTextCenter( prettyPackageVersion, bannerWidth ) ) )
+    log( tableSeparator )
+    log( tableLine( alignTextLeft( prettyNodeVersion, bannerWidth ) ) )
+    log( tableLine( alignTextLeft( prettyNpmVersion, bannerWidth ) ) )
+    log( tableBottom )
+    log( I_, 'Available commands are:' )
+    log( I__, npmRun, cyan( 'help' ), '- Display this help.' )
+    log( I__, npmRun, cyan( 'patch' ), '- Will apply some patch/replacements in dependencies.', red( '(Apply only once after run "npm install")' ) )
+    log( I__, npmRun, cyan( 'clean' ), '- Will delete builds and temporary folders.' )
+    log( I__, npmRun, cyan( 'lint' ), '- Will run the eslint in pedantic mode with auto fix when possible.' )
+    log( I__, npmRun, cyan( 'doc' ), '- Will run jsdoc, and create documentation under `documentation` folder, using the docdash theme' )
+    log( I__, npmRun, cyan( 'test' ), '- Will run the test framworks (unit and bench), and create reports under `documentation/report` folder, using the mochawesome theme' )
+    log( I__, npmRun, cyan( 'unit' ), '- Will run the karma server for unit tests.' )
+    log( I__, npmRun, cyan( 'bench' ), '- Will run the karma server for benchmarks.' )
+    log( I__, npmRun, cyan( 'build' ), yellow( '--' ), green( '<options>' ), '- Will build the application for development and/or production environments.' )
+    log( I___, yellow( 'Note: The two dash are only required if you provide options !' ) )
+    log( I___, 'The available', green( '<options>' ), 'are:' )
+    log( I____, green( '-i' ), 'or', green( '--input' ), '- The main file path to build', cyan( '[Default: "sources/main.js"]' ), '.' )
+    log( I____, green( '-o' ), 'or', green( '--output' ), '- The folder where output the build', cyan( '[Default: "builds"]' ), '.' )
+    log(
+        I____,
+        green( '-f:' ),
+        magenta( '<format>' ),
+        'or',
+        green( '--format:' ),
+        magenta( '<format>' ),
+        ' - to specify the output build type. Where format could be any of:', magenta( 'cjs, esm, iife, umd' ), '.'
+    )
+    log( I____, green( '-e:' ), magenta( '<env>' ), 'or', green( '--env:' ), magenta( '<env>' ), ' - to specify the build environment. Where env could be any of:', magenta(
+        'dev' ), magenta( 'prod' ), cyan( '[Default: "dev"]' ), '.' )
+    log( I____, green( '-s' ), 'or', green( '--sourcemap' ), ' - to build with related source map', cyan( '[Default: true]' ), '.' )
+    log( I____, green( '-t' ), 'or', green( '--treeshake' ), ' - allow to perform treeshaking when building', cyan( '[Default: true]' ), '.' )
+    log( I__, npmRun, cyan( 'release' ), '- Will run all the lint, test stuff, and if succeed will build the application.' )
+    log( '' )
+    log( I_, 'In case you have', blue( 'gulp' ), 'installed globally, you could use also:' )
+    log( I__, blue( 'gulp' ), cyan( 'command' ), '- It will perform the command like using "npm run" but with less characters to type... Because you\'re a developer, right ?' )
+    log( '' )
+
+    done()
+
+}
+helpTask.displayName = basename( import.meta.filename, '.task.mjs' )
+helpTask.description = 'Display the package help'
+helpTask.flags       = null
+
+export { helpTask }