itee-tasks 1.0.3

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "itee-tasks",
+  "version": "1.0.3",
+  "description": "Allow to manage all commons itee gulp tasks into one place ",
+  "keywords": [
+    "itee",
+    "gulp",
+    "tasks"
+  ],
+  "author": {
+    "name": "Itee (Tristan Valcke)",
+    "url": "https://github.com/Itee"
+  },
+  "contributors": [],
+  "license": "BSD-3-Clause",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Itee/itee-tasks.git"
+  },
+  "type": "module",
+  "main": "sources/index.mjs",
+  "homepage": "https://github.com/Itee/itee-tasks#readme",
+  "bugs": {
+    "url": "https://github.com/Itee/itee-tasks/issues"
+  },
+  "scripts": {
+    "default": "gulp --tasks",
+    "refresh": "node ./sources/refresh.mjs",
+    "help": "gulp help",
+    "patch": "gulp patch",
+    "clean": "gulp clean",
+    "lint": "gulp lint",
+    "doc": "gulp doc",
+    "build": "gulp build",
+    "tests:run": "gulp run-tests",
+    "tests:bundling": "gulp check-bundling",
+    "tests:bundling:build-import": "gulp check-bundling-from-esm-build-import",
+    "tests:bundling:files-import": "gulp check-bundling-from-esm-files-import",
+    "tests:bundling:files-direct": "gulp check-bundling-from-esm-files-direct",
+    "tests:benches:compute": "gulp compute-benchmarks",
+    "tests:benches:run": "gulp run-benchmarks",
+    "tests:benches:run:back": "gulp run-benchmarks-for-backend",
+    "tests:benches:run:front": "gulp run-benchmarks-for-frontend",
+    "tests:units:compute": "gulp compute-unit-tests",
+    "tests:units:run": "gulp run-unit-tests",
+    "tests:units:run:back": "gulp run-unit-tests-for-backend",
+    "tests:units:run:front": "gulp run-unit-tests-for-frontend",
+    "release": "gulp release",
+    "semantic-release": "semantic-release --dry-run --no-ci",
+    "postversion": "gulp build"
+  },
+  "devDependencies": {
+    "cz-emoji": "^1.3.2-canary.2",
+    "semantic-release": "^24.2.9",
+    "semantic-release-gitmoji": "^1.6.8"
+  },
+  "dependencies": {
+    "@eslint/js": "^9.39.2",
+    "@itee/benchmarks-framework": "^1.0.0",
+    "@itee/json-reporter": "^1.0.2",
+    "@rollup/plugin-commonjs": "^28.0.9",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.6",
+    "@semantic-release/npm": "^12.0.2",
+    "@web/test-runner": "^0.20.2",
+    "@web/test-runner-playwright": "^0.11.1",
+    "ansi-colors": "^4.1.3",
+    "benchmark": "^2.1.4",
+    "del": "^8.0.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-mocha": "^11.2.0",
+    "fancy-log": "^2.0.0",
+    "figlet": "^1.9.4",
+    "glob": "^13.0.0",
+    "globals": "^16.5.0",
+    "gulp": "^5.0.1",
+    "ink-docstrap": "^1.3.2",
+    "itee-validators": "^6.0.0",
+    "jsdoc": "^4.0.5",
+    "lodash": "^4.17.21",
+    "mochawesome": "^7.1.4",
+    "platform": "^1.3.6",
+    "rollup": "^4.55.1",
+    "rollup-plugin-cleanup": "^3.2.1",
+    "rollup-plugin-re": "^1.0.7"
+  }
+}

package/sources/_utils.mjs

@@ -0,0 +1,389 @@
+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 {
+    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 getConfigurationPathFor( configurationLocation ) {
+
+    const packageConfigurationPath = join( packageTasksConfigurationsDirectory, configurationLocation )
+    const defaultConfigurationPath = join( iteePackageConfigurationsDirectory, configurationLocation )
+
+    let configurationPath
+
+    if ( existsSync( packageConfigurationPath ) ) {
+
+        configurationPath = packageConfigurationPath
+
+    } else if ( existsSync( defaultConfigurationPath ) ) {
+
+        configurationPath = defaultConfigurationPath
+
+    } else {
+
+        throw new Error( `Unable to find configuration for path ${ packageConfigurationPath } or ${ defaultConfigurationPath }` )
+
+    }
+
+    return configurationPath
+
+}
+
+async function getConfigurationFrom( path ) {
+
+    let jsonData = null
+
+    try {
+
+        if ( extname( path ) !== '.json' ) {
+
+            const moduleData = await import(path)
+            jsonData         = moduleData.default
+
+        } else {
+
+            jsonData = getJsonFrom( path )
+
+        }
+
+    } catch ( e ) {
+
+        log( red( e ) )
+
+    }
+
+    return jsonData
+
+}
+
+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, task, configurationPath ) {
+
+    const taskPath = relative( packageRootDirectory, filename )
+
+    let logValue = `Loading  ${ green( taskPath ) } with task ${ blue( task.displayName ) }`
+
+    if ( configurationPath ) {
+
+        const relativeConfigurationPath = relative( packageRootDirectory, configurationPath )
+        logValue += ` and configuration from ${ cyan( relativeConfigurationPath ) }`
+
+    }
+
+    log( logValue )
+
+}
+
+///
+
+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,
+    getConfigurationPathFor,
+    getConfigurationFrom,
+    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,55 @@
+import colors     from 'ansi-colors'
+import log        from 'fancy-log'
+import { join }   from 'path'
+import { rollup } from 'rollup'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask
+}                 from '../_utils.mjs'
+
+const {
+          red,
+          green,
+          yellow,
+      } = colors
+
+const configurationLocation = join( 'builds', 'build.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+
+const buildTask       = async ( done ) => {
+
+    const configuration = await getConfigurationFrom( configurationPath )
+    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 = 'build'
+buildTask.description = 'Todo...'
+buildTask.flags       = null
+
+logLoadingTask( import.meta.filename, buildTask, configurationPath )
+
+export { buildTask }

package/sources/cleans/clean.task.mjs

@@ -0,0 +1,36 @@
+import colors          from 'ansi-colors'
+import { deleteAsync } from 'del'
+import log             from 'fancy-log'
+import { join }        from 'path'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask
+}                      from '../_utils.mjs'
+
+const { red }  = colors
+
+const configurationLocation = join( 'cleans', 'clean.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+const configuration         = await getConfigurationFrom( configurationPath )
+
+/**
+ * @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 = 'clean'
+cleanTask.description = 'Will delete builds and temporary folders'
+cleanTask.flags       = null
+
+logLoadingTask( import.meta.filename, cleanTask, configurationPath )
+
+export { cleanTask }

package/sources/docs/doc.task.mjs

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