itee-tasks 1.0.3

package/sources/tests/benchmarks/run-benchmarks.task.mjs

@@ -0,0 +1,21 @@
+import { join } from 'path'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask,
+    serializeTasksFrom
+}               from '../../_utils.mjs'
+
+
+const configurationLocation = join( 'tests', 'benchmarks', 'run-benchmarks.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+const configuration         = await getConfigurationFrom( configurationPath )
+
+const runBenchmarksTestsTask       = await serializeTasksFrom( configuration )
+runBenchmarksTestsTask.displayName = 'run-benchmarks'
+runBenchmarksTestsTask.description = 'Will run benchmarks in back and front environments.'
+runBenchmarksTestsTask.flags       = null
+
+logLoadingTask( import.meta.filename, runBenchmarksTestsTask, configurationPath )
+
+export { runBenchmarksTestsTask }

package/sources/tests/bundlings/check-bundling-from-esm-build-import.task.mjs

@@ -0,0 +1,131 @@
+import colors     from 'ansi-colors'
+import log        from 'fancy-log'
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    rmSync,
+    writeFileSync
+}                 from 'fs'
+import {
+    basename,
+    join,
+    relative
+}                 from 'path'
+import { rollup } from 'rollup'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask,
+    packageBuildsDirectory,
+    packageName,
+    packageTestsBundlesDirectory
+}                 from '../../_utils.mjs'
+
+const {
+          red,
+          green,
+          magenta,
+      } = colors
+
+const configurationLocation = join( 'tests', 'bundlings', 'check-bundling-from-esm-build-import.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+
+const checkBundlingFromEsmBuildImportTask       = async ( done ) => {
+
+    const configuration = await getConfigurationFrom( configurationPath )
+
+    const buildFilePath = join( packageBuildsDirectory, `${ packageName }.esm.js` )
+    if ( !existsSync( buildFilePath ) ) {
+        done( red( buildFilePath + ' does not exist' ) )
+    }
+
+    const outputDir      = join( packageTestsBundlesDirectory, 'from_build_import' )
+    const temporaryDir   = join( packageTestsBundlesDirectory, 'from_build_import', '.tmp' )
+    const importDir      = relative( temporaryDir, packageBuildsDirectory )
+    const importFilePath = join( importDir, `${ packageName }.esm.js` )
+
+    if ( existsSync( outputDir ) ) {
+        log( 'Clean up', magenta( outputDir ) )
+        rmSync( outputDir, { recursive: true } )
+    }
+
+    try {
+
+        // Get build exports list
+        const data  = readFileSync( buildFilePath, 'utf8' )
+        const regex = /export\s{\s(.*)\s}/
+        const found = data.match( regex )
+        if ( found === null ) {
+            log( red( `Unable to find exports in ${ buildFilePath }` ) )
+            return
+        }
+
+        const exports = found[ 1 ].split( ',' )
+                                  .map( item => item.trim() )
+
+        // Create temporary imports files for each build export
+        // And then bundle it
+        let temporaryFilePaths = []
+        for ( let namedExport of exports ) {
+            if ( namedExport.includes( ' as ' ) ) {
+                namedExport = namedExport.split( ' as ' )[ 1 ]
+            }
+
+            const temporaryFileName = `${ namedExport }.import.js`
+            const temporaryFilePath = join( temporaryDir, temporaryFileName )
+            const temporaryFileData = `import { ${ namedExport } } from '${ importFilePath.replace( /\\/g, '/' ) }'`
+
+            mkdirSync( temporaryDir, { recursive: true } )
+            writeFileSync( temporaryFilePath, temporaryFileData )
+
+            temporaryFilePaths.push( temporaryFilePath )
+        }
+
+        // Bundle each temporary files and check side effects
+        let fileName, bundleFileName, bundleFilePath
+        for ( const temporaryFilePath of temporaryFilePaths ) {
+
+            fileName       = basename( temporaryFilePath )
+            bundleFileName = fileName.replace( '.tmp.', '.bundle.' )
+            bundleFilePath = join( outputDir, bundleFileName )
+
+            try {
+
+                configuration.input       = temporaryFilePath
+                configuration.output.file = bundleFilePath
+
+                const bundle     = await rollup( configuration )
+                const { output } = await bundle.generate( configuration.output )
+
+                let code = output[ 0 ].code
+                if ( code.length > 1 ) {
+                    log( red( `[${ bundleFileName }] contain side-effects !` ) )
+                    await bundle.write( configuration.output )
+                } else {
+                    log( green( `[${ bundleFileName }] is side-effect free.` ) )
+                }
+
+            } catch ( error ) {
+
+                log( red( error.message ) )
+
+            }
+        }
+
+    } catch ( error ) {
+        log( red( error.message ) )
+    } finally {
+
+        done()
+
+    }
+
+}
+checkBundlingFromEsmBuildImportTask.displayName = 'check-bundling-from-esm-build-import'
+checkBundlingFromEsmBuildImportTask.description = 'Verify that the project esm build is correctly importable in third party esm files'
+checkBundlingFromEsmBuildImportTask.flags       = null
+
+logLoadingTask( import.meta.filename, checkBundlingFromEsmBuildImportTask, configurationPath )
+
+export { checkBundlingFromEsmBuildImportTask }

package/sources/tests/bundlings/check-bundling-from-esm-files-direct.task.mjs

@@ -0,0 +1,88 @@
+import colors     from 'ansi-colors'
+import log        from 'fancy-log'
+import {
+    existsSync,
+    rmSync
+}                 from 'fs'
+import {
+    basename,
+    dirname,
+    extname,
+    join
+}                 from 'path'
+import { rollup } from 'rollup'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask,
+    packageSourcesDirectory,
+    packageTestsBundlesDirectory
+}                 from '../../_utils.mjs'
+
+const {
+          red,
+          green,
+          magenta,
+      } = colors
+
+const sourcesFilesLocation = join( 'tests', 'bundlings', 'check-bundling.conf.mjs' )
+const sourcesFilesPath     = getConfigurationPathFor( sourcesFilesLocation )
+
+const configurationLocation = join( 'tests', 'bundlings', 'check-bundling-from-esm-files-direct.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+
+/**
+ * @description In view to detect bundling side effects this task will
+ * create intermediary file for each individual export from this package
+ * and then create rollup config for each of them and bundle
+ * Todo: Check for different target env like next task below this one
+ */
+const checkBundlingFromEsmFilesDirectTask       = async ( done ) => {
+
+    const outputDir = join( packageTestsBundlesDirectory, 'from_files_direct' )
+    if ( existsSync( outputDir ) ) {
+        log( 'Clean up', magenta( outputDir ) )
+        rmSync( outputDir, { recursive: true } )
+    }
+
+    const sourcesFiles  = await getConfigurationFrom( sourcesFilesPath )
+    const configuration = await getConfigurationFrom( configurationPath )
+
+    for ( let sourceFile of sourcesFiles ) {
+
+        const specificFilePath = sourceFile.replace( packageSourcesDirectory, '' )
+        const specificDir      = dirname( specificFilePath )
+        const fileName         = basename( sourceFile, extname( sourceFile ) )
+
+        const bundleFileName = `${ fileName }.bundle.js`
+        const bundleFilePath = join( outputDir, specificDir, bundleFileName )
+
+        configuration.input       = sourceFile
+        configuration.output.file = bundleFilePath
+
+        try {
+
+            log( 'Bundling', green( configuration.output.file ) )
+
+            const bundle = await rollup( configuration )
+            await bundle.generate( configuration.output )
+            await bundle.write( configuration.output )
+
+        } catch ( error ) {
+
+            log( red( error.message ) )
+
+        }
+
+    }
+
+    done()
+
+}
+checkBundlingFromEsmFilesDirectTask.displayName = 'check-bundling-from-esm-files-direct'
+checkBundlingFromEsmFilesDirectTask.description = 'In view to detect bundling side effects this task will create intermediary file for each individual export from this package and then create rollup config for each of them and bundle'
+checkBundlingFromEsmFilesDirectTask.flags       = null
+
+logLoadingTask( import.meta.filename, checkBundlingFromEsmFilesDirectTask, configurationPath )
+
+export { checkBundlingFromEsmFilesDirectTask }

package/sources/tests/bundlings/check-bundling-from-esm-files-import.task.mjs

@@ -0,0 +1,106 @@
+import colors     from 'ansi-colors'
+import log        from 'fancy-log'
+import {
+    existsSync,
+    mkdirSync,
+    rmSync,
+    writeFileSync
+}                 from 'fs'
+import {
+    dirname,
+    join,
+    parse,
+    relative
+}                 from 'path'
+import { rollup } from 'rollup'
+import {
+    getConfigurationFrom,
+    getConfigurationPathFor,
+    logLoadingTask,
+    packageSourcesDirectory as sourcesDir,
+    packageTestsBundlesDirectory as bundleDir
+}                 from '../../_utils.mjs'
+
+const {
+          red,
+          green,
+          magenta,
+      } = colors
+
+const sourcesFilesLocation = join( 'tests', 'bundlings', 'check-bundling.conf.mjs' )
+const sourcesFilesPath     = getConfigurationPathFor( sourcesFilesLocation )
+
+const configurationLocation = join( 'tests', 'bundlings', 'check-bundling-from-esm-files-import.conf.mjs' )
+const configurationPath     = getConfigurationPathFor( configurationLocation )
+
+const checkBundlingFromEsmFilesImportTask       = async ( done ) => {
+
+    const outputDir      = join( bundleDir, 'from_files_import' )
+    const temporariesDir = join( outputDir, '.tmp' )
+
+    if ( existsSync( outputDir ) ) {
+        log( 'Clean up', magenta( outputDir ) )
+        rmSync( outputDir, { recursive: true } )
+    }
+
+    const sourcesFiles  = await getConfigurationFrom( sourcesFilesPath )
+    const configuration = await getConfigurationFrom( configurationPath )
+
+    for ( let sourceFile of sourcesFiles ) {
+
+        const {
+                  dir:  sourceDir,
+                  base: sourceBase,
+                  name: sourceName
+              }                = parse( sourceFile )
+        const specificFilePath = sourceFile.replace( sourcesDir, '' )
+        const specificDir      = dirname( specificFilePath )
+
+        // Create temp import file per file in package
+        const temporaryFileName = `${ sourceName }.import.js`
+        const temporaryDir      = join( temporariesDir, specificDir )
+        const temporaryFile     = join( temporaryDir, temporaryFileName )
+        const importDir         = relative( temporaryDir, sourceDir )
+        const importFile        = join( importDir, sourceBase )
+        const temporaryFileData = `import '${ importFile.replace( /\\/g, '/' ) }'`
+
+        // Bundle tmp file and check content for side effects
+        const bundleFileName = `${ sourceName }.bundle.js`
+        const bundleFilePath = join( outputDir, specificDir, bundleFileName )
+
+        configuration.input       = temporaryFile
+        configuration.output.file = bundleFilePath
+
+        // create tmp file
+        try {
+
+            mkdirSync( temporaryDir, { recursive: true } )
+            writeFileSync( temporaryFile, temporaryFileData )
+
+            const bundle     = await rollup( configuration )
+            const { output } = await bundle.generate( configuration.output )
+
+            let code = output[ 0 ].code
+            if ( code.length > 1 ) {
+                log( red( `[${ specificFilePath }] contain side-effects !` ) )
+                await bundle.write( configuration.output )
+            } else {
+                log( green( `[${ specificFilePath }] is side-effect free.` ) )
+            }
+
+        } catch ( error ) {
+            log( red( error.message ) )
+        }
+
+    }
+
+    done()
+
+}
+checkBundlingFromEsmFilesImportTask.displayName = 'check-bundling-from-esm-files-import'
+checkBundlingFromEsmFilesImportTask.description = 'In view to detect bundling side effects this task will create intermediary file for each individual export from this package and then create rollup config for each of them and bundle'
+checkBundlingFromEsmFilesImportTask.flags       = null
+
+logLoadingTask( import.meta.filename, checkBundlingFromEsmFilesImportTask, configurationPath )
+
+export { checkBundlingFromEsmFilesImportTask }

package/sources/tests/bundlings/check-bundling.task.mjs

@@ -0,0 +1,23 @@
+import { series }                              from 'gulp'
+import { logLoadingTask }                      from '../../_utils.mjs'
+import { checkBundlingFromEsmBuildImportTask } from './check-bundling-from-esm-build-import.task.mjs'
+import { checkBundlingFromEsmFilesDirectTask } from './check-bundling-from-esm-files-direct.task.mjs'
+import { checkBundlingFromEsmFilesImportTask } from './check-bundling-from-esm-files-import.task.mjs'
+
+/**
+ * @description In view to detect bundling side effects this task will
+ * create intermediary file for each individual export from this package
+ * and then create rollup config for each of them and bundle
+ * Todo: Check for different targets env like next task below this one
+ */
+const checkBundlingTask       = series(
+    checkBundlingFromEsmFilesImportTask,
+    checkBundlingFromEsmBuildImportTask,
+    checkBundlingFromEsmFilesDirectTask
+)
+checkBundlingTask.displayName = 'check-bundling'
+checkBundlingTask.description = 'In view to detect bundling side effects this task will create intermediary file for each individual export and then try to bundle them.'
+
+logLoadingTask( import.meta.filename, checkBundlingTask )
+
+export { checkBundlingTask }

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

@@ -0,0 +1,21 @@
+import { series }                 from 'gulp'
+import { logLoadingTask }         from '../_utils.mjs'
+import { runBenchmarksTestsTask } from './benchmarks/run-benchmarks.task.mjs'
+import { runUnitTestsTask }       from './units/run-unit-tests.task.mjs'
+
+/**
+ * @method npm run test
+ * @global
+ * @description Will run unit tests and benchmarks for backend (node) and frontend (web-test-runner) environments
+ */
+const runTestsTask       = series(
+    runBenchmarksTestsTask,
+    runUnitTestsTask,
+)
+runTestsTask.displayName = 'run-tests'
+runTestsTask.description = 'Will run unit tests and benchmarks for backend (node) and frontend (web-test-runner) environments.'
+runTestsTask.flags       = null
+
+logLoadingTask( import.meta.filename, runTestsTask )
+
+export { runTestsTask }