itee-validators 5.6.0 → 6.0.0

package/.tasks/{tests/benchmarks/compute-benchmarks.mjs → .tests/benchmarks/compute-benchmarks.task.mjs}

@@ -1,52 +1,41 @@
+import colors           from 'ansi-colors'
+import childProcess     from 'child_process'
+import log              from 'fancy-log'
+import {
+    existsSync,
+    mkdirSync,
+    writeFileSync
+}                       from 'fs'
 import {
-    join,
-    normalize,
     basename,
     dirname,
     extname,
+    join,
     relative
-}                               from 'path'
+}                       from 'path'
 import {
-    getDirname,
-    packageInfos
-}                               from '../../_utils.mjs'
-import glob                     from 'glob'
-import fs                       from 'fs'
-import log                      from 'fancy-log'
-import colors                   from 'ansi-colors'
-import { getGulpConfigForTask } from '../../../configs/gulp.conf.mjs'
-import childProcess             from 'child_process'
+    nodeModulesDirectory,
+    packageName,
+    packageSourcesDirectory as sourcesDir,
+    packageTestsBenchmarksDirectory as benchesDir
+}                       from '../../_utils.mjs'
+import { sourcesFiles } from '../../configs/compute-benchmarks.conf.mjs'
 
 const {
           red,
           green,
-          blue,
-          cyan,
-          yellow,
-          magenta
+          yellow
       } = colors
 
+/**
+ * @description Will generate benchmarks files from source code against provided alternatives
+ */
+const computeBenchmarksTask       = ( done ) => {
 
-function computeBenchmarks( done ) {
-
-    const baseDir    = getDirname()
-    const sourcesDir = join( baseDir, 'sources' )
-    const testsDir   = join( baseDir, 'tests' )
-    const benchesDir = join( testsDir, 'benchmarks' )
-
-    fs.mkdirSync( benchesDir, { recursive: true } )
-
-    const filePathsToIgnore = getGulpConfigForTask( 'compute-benchmarks' )
-
-    const sourcesFiles = glob.sync( join( sourcesDir, '**' ) )
-                             .map( filePath => normalize( filePath ) )
-                             .filter( filePath => {
-                                 const fileName         = basename( filePath )
-                                 const isJsFile         = fileName.endsWith( '.js' )
-                                 const isNotPrivateFile = !fileName.startsWith( '_' )
-                                 const isNotIgnoredFile = !filePathsToIgnore.includes( fileName )
-                                 return isJsFile && isNotPrivateFile && isNotIgnoredFile
-                             } )
+    if ( !existsSync( benchesDir ) ) {
+        log( 'Creating', green( benchesDir ) )
+        mkdirSync( benchesDir, { recursive: true } )
+    }
 
     const benchRootImports = []
     for ( let sourceFile of sourcesFiles ) {
@@ -65,7 +54,7 @@ function computeBenchmarks( done ) {
 
         try {
 
-            const jsdocPath   = join( baseDir, '/node_modules/jsdoc/jsdoc.js' )
+            const jsdocPath   = join( nodeModulesDirectory, '/jsdoc/jsdoc.js' )
             const jsdocOutput = childProcess.execFileSync( 'node', [ jsdocPath, '-X', sourceFile ] ).toString()
 
             const classNames    = []
@@ -110,7 +99,7 @@ function computeBenchmarks( done ) {
             } )
 
             if ( jsonData.length === 0 ) {
-                log( yellow( `No usable exports found in [${ sourceFile }]. Ignore it !` ) )
+                log( 'Ignoring', yellow( `${ sourceFile }, no usable exports found` ) )
                 continue
             }
 
@@ -152,9 +141,8 @@ function computeBenchmarks( done ) {
                 benchSuites += '\n'
             }
 
-            const template = '' + '\n' +
-                `import Benchmark   from 'benchmark'` + '\n' +
-                `import { Testing }      from 'itee-utils'` + '\n' +
+            const template = '' +
+                `import { Testing }      from 'itee-utils/sources/testings/benchmarks.js'` + '\n' +
                 `import * as ${ nsName } from '${ importFilePath }'` + '\n' +
                 '\n' +
                 `${ benchSuites }` +
@@ -168,9 +156,13 @@ function computeBenchmarks( done ) {
                 exports: suitesToExports
             } )
 
-            log( green( `Create ${ benchFilePath }` ) )
-            fs.mkdirSync( benchDirPath, { recursive: true } )
-            fs.writeFileSync( benchFilePath, template )
+            if ( !existsSync( benchDirPath ) ) {
+                log( 'Creating', green( benchDirPath ) )
+                mkdirSync( benchDirPath, { recursive: true } )
+            }
+
+            log( 'Creating', green( benchFilePath ) )
+            writeFileSync( benchFilePath, template )
 
         } catch ( error ) {
 
@@ -185,9 +177,9 @@ function computeBenchmarks( done ) {
     for ( let i = 0 ; i < benchRootImports.length ; i++ ) {
 
         const currentBench = benchRootImports[ i ]
-        const exports      = currentBench.exports
-        const imports      = exports.join( ', ' )
-        suites.push( ...exports )
+        const namedExports = currentBench.exports
+        const imports      = namedExports.join( ', ' )
+        suites.push( ...namedExports )
 
         templateImports += `import {${ imports }} from './${ currentBench.path }'` + '\n'
 
@@ -203,13 +195,16 @@ function computeBenchmarks( done ) {
         `\tsuite.run()` + '\n' +
         `}` + '\n'
 
-    const benchesFilePath = join( benchesDir, `${ packageInfos.name }.benchs.js` )
+    const benchesFilePath = join( benchesDir, `${ packageName }.benchmarks.js` )
 
-    log( green( `Create ${ benchesFilePath }` ) )
-    fs.writeFileSync( benchesFilePath, benchesTemplate )
+    log( 'Creating', green( benchesFilePath ) )
+    writeFileSync( benchesFilePath, benchesTemplate )
 
     done()
 
 }
+computeBenchmarksTask.displayName = 'compute-benchmarks'
+computeBenchmarksTask.description = 'Will generate benchmarks files from source code against provided alternatives.'
+computeBenchmarksTask.flags       = null
 
-export { computeBenchmarks }
+export { computeBenchmarksTask }

package/.tasks/.tests/benchmarks/run-benchmarks-for-backend.task.mjs

@@ -0,0 +1,39 @@
+import colors         from 'ansi-colors'
+import log            from 'fancy-log'
+import { existsSync } from 'fs'
+import { join }       from 'path'
+import {
+    packageName,
+    packageTestsBenchmarksDirectory
+}                     from '../../_utils.mjs'
+
+const {
+          red,
+          yellow
+      } = colors
+
+/**
+ * @description Will run benchmarks with node
+ */
+const runBenchmarksForBackendTask       = async ( done ) => {
+
+    const benchesPath = join( packageTestsBenchmarksDirectory, `/builds/${ packageName }.benchmarks.cjs.js` )
+    if ( !existsSync( benchesPath ) ) {
+        log( yellow( `${ benchesPath } does not exist, skip backend benchmarks...` ) )
+        done()
+        return
+    }
+
+    try {
+        await import(benchesPath)
+        done()
+    } catch ( error ) {
+        done( red( error ) )
+    }
+
+}
+runBenchmarksForBackendTask.displayName = 'run-benchmarks-for-backend'
+runBenchmarksForBackendTask.description = 'Will run benchmarks with node'
+runBenchmarksForBackendTask.flags       = null
+
+export { runBenchmarksForBackendTask }

package/.tasks/.tests/benchmarks/run-benchmarks-for-frontend.task.mjs

@@ -0,0 +1,41 @@
+import { startTestRunner }   from '@web/test-runner'
+import colors                from 'ansi-colors'
+import { default as config } from '../../configs/benchmarks.conf.mjs'
+
+const { red } = colors
+
+/**
+ * @description Will run benchmarks with web-test-runner
+ */
+const runBenchmarksForFrontendTask       = () => {
+    return new Promise( async ( resolve, reject ) => {
+
+        const testRunner = await startTestRunner( {
+            config:          config,
+            readCliArgs:     false,
+            readFileConfig:  false,
+            autoExitProcess: false,
+        } )
+
+        if ( !testRunner ) {
+            reject( red( 'Internal test runner error.' ) )
+            return
+        }
+
+        // To ensure that testRunner exit event won't be used by other instance of test runner,
+        // we need to be sure that current test runner is ended
+        testRunner.on( 'finished', () => {
+            testRunner.stop()
+        } )
+
+        testRunner.on( 'stopped', () => {
+            resolve()
+        } )
+
+    } )
+}
+runBenchmarksForFrontendTask.displayName = 'run-benchmarks-for-frontend'
+runBenchmarksForFrontendTask.description = 'Will run benchmarks with web-test-runner.'
+runBenchmarksForFrontendTask.flags       = null
+
+export { runBenchmarksForFrontendTask }

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

@@ -0,0 +1,18 @@
+import { series }                      from 'gulp'
+import { runBenchmarksForBackendTask }  from './run-benchmarks-for-backend.task.mjs'
+import { runBenchmarksForFrontendTask } from './run-benchmarks-for-frontend.task.mjs'
+
+/**
+ * @method npm run build-test
+ * @global
+ * @description Will run benchmarks in back and front environments
+ */
+const runBenchmarksTestsTask       = series(
+    runBenchmarksForBackendTask,
+    runBenchmarksForFrontendTask,
+)
+runBenchmarksTestsTask.displayName = 'run-benchmarks'
+runBenchmarksTestsTask.description = 'Will run benchmarks in back and front environments.'
+runBenchmarksTestsTask.flags       = null
+
+export { runBenchmarksTestsTask }

package/.tasks/{tests/bundling/check-bundling-from-esm-build-import.mjs → .tests/bundling/check-bundling-from-esm-build-import.task.mjs}

@@ -1,26 +1,24 @@
+import colors                        from 'ansi-colors'
+import log                           from 'fancy-log'
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    rmSync,
+    writeFileSync
+}                                    from 'fs'
 import {
-    join,
-    normalize,
     basename,
-    parse,
-    dirname,
+    join,
     relative
-}                       from 'path'
+}                                    from 'path'
+import { rollup }                    from 'rollup'
 import {
-    existsSync,
-    rmSync,
-    mkdirSync,
-    writeFileSync,
-    readFileSync
-}                       from 'fs'
-import log              from 'fancy-log'
-import { nodeResolve }  from '@rollup/plugin-node-resolve'
-import cleanup          from 'rollup-plugin-cleanup'
-import { rollup }       from 'rollup'
-import colors           from 'ansi-colors'
-import { getDirname }   from '../../_utils.mjs'
-import { packageInfos } from '../../_utils.mjs'
-
+    packageBuildsDirectory as buildsDir,
+    packageName,
+    packageTestsBundlesDirectory as bundlesDir
+}                                    from '../../_utils.mjs'
+import { getRollupConfigurationFor } from '../../configs/build.conf.mjs'
 
 const {
           red,
@@ -28,22 +26,18 @@ const {
           magenta
       } = colors
 
-async function checkBundlingFromEsmBuildImport( done ) {
-
-    const baseDir        = getDirname()
-    const buildsDir      = join( baseDir, 'builds' )
-    const buildFilePath  = join( buildsDir, `${ packageInfos.name }.esm.js` )
-    const testsDir       = join( baseDir, 'tests' )
-    const bundlesDir     = join( testsDir, 'bundles' )
-    const outputDir      = join( bundlesDir, 'from_build_import' )
-    const temporaryDir   = join( bundlesDir, 'from_build_import', '.tmp' )
-    const importDir      = relative( temporaryDir, buildsDir )
-    const importFilePath = join( importDir, `${ packageInfos.name }.esm.js` )
+const checkBundlingFromEsmBuildImportTask       = async ( done ) => {
 
+    const buildFilePath = join( buildsDir, `${ packageName }.esm.js` )
     if ( !existsSync( buildFilePath ) ) {
         done( red( buildFilePath + ' does not exist' ) )
     }
 
+    const outputDir      = join( bundlesDir, 'from_build_import' )
+    const temporaryDir   = join( bundlesDir, 'from_build_import', '.tmp' )
+    const importDir      = relative( temporaryDir, buildsDir )
+    const importFilePath = join( importDir, `${ packageName }.esm.js` )
+
     if ( existsSync( outputDir ) ) {
         log( 'Clean up', magenta( outputDir ) )
         rmSync( outputDir, { recursive: true } )
@@ -81,49 +75,8 @@ async function checkBundlingFromEsmBuildImport( done ) {
             temporaryFilePaths.push( temporaryFilePath )
         }
 
-        // Bundle each temporary files and check side-effects
-        const config = {
-            input:     null,
-            external:  [ '' ],
-            plugins:   [
-                nodeResolve( {
-                    preferBuiltins: true
-                } ),
-                cleanup( {
-                    comments: 'all' // else remove __PURE__ declaration... -_-'
-                } )
-            ],
-            onwarn:    ( {
-                loc,
-                frame,
-                message
-            } ) => {
-
-                // Ignore some errors
-                if ( message.includes( 'Circular dependency' ) ) { return }
-                if ( message.includes( 'Generated an empty chunk' ) ) { return }
-
-                if ( loc ) {
-                    process.stderr.write( `/!\\ ${ loc.file } (${ loc.line }:${ loc.column }) ${ frame } ${ message }\n` )
-                } else {
-                    process.stderr.write( `/!\\ ${ message }\n` )
-                }
-
-            },
-            treeshake: {
-                moduleSideEffects:                true,
-                annotations:                      true,
-                correctVarValueBeforeDeclaration: true,
-                propertyReadSideEffects:          true,
-                tryCatchDeoptimization:           true,
-                unknownGlobalSideEffects:         true
-            },
-            output:    {
-                indent: '\t',
-                format: 'esm',
-                file:   null
-            }
-        }
+        // Bundle each temporary files and check side effects
+        const config = getRollupConfigurationFor( 'check-bundling-from-esm-build-import' )
         let fileName, bundleFileName, bundleFilePath
         for ( const temporaryFilePath of temporaryFilePaths ) {
 
@@ -154,7 +107,7 @@ async function checkBundlingFromEsmBuildImport( done ) {
             }
         }
 
-    } catch ( err ) {
+    } catch ( error ) {
         log( red( error.message ) )
     } finally {
 
@@ -163,5 +116,8 @@ async function checkBundlingFromEsmBuildImport( 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
 
-export { checkBundlingFromEsmBuildImport }
+export { checkBundlingFromEsmBuildImportTask }

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

@@ -0,0 +1,77 @@
+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 {
+    packageSourcesDirectory as sourcesDir,
+    packageTestsBundlesDirectory as bundlesDir
+}                                    from '../../_utils.mjs'
+import { getRollupConfigurationFor } from '../../configs/build.conf.mjs'
+import { sourcesFiles }              from '../../configs/check-bundling.conf.mjs'
+
+const {
+          red,
+          green,
+          magenta
+      } = colors
+
+/**
+ * @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( bundlesDir, 'from_files_direct' )
+    if ( existsSync( outputDir ) ) {
+        log( 'Clean up', magenta( outputDir ) )
+        rmSync( outputDir, { recursive: true } )
+    }
+
+    const config = getRollupConfigurationFor( 'check-bundling-from-esm-files-direct' )
+    for ( let sourceFile of sourcesFiles ) {
+
+        const specificFilePath = sourceFile.replace( sourcesDir, '' )
+        const specificDir      = dirname( specificFilePath )
+        const fileName         = basename( sourceFile, extname( sourceFile ) )
+
+        const bundleFileName = `${ fileName }.bundle.js`
+        const bundleFilePath = join( outputDir, specificDir, bundleFileName )
+
+        config.input       = sourceFile
+        config.output.file = bundleFilePath
+
+        try {
+
+            log( 'Bundling', green( config.output.file ) )
+
+            const bundle = await rollup( config )
+            await bundle.generate( config.output )
+            await bundle.write( config.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
+
+export { checkBundlingFromEsmFilesDirectTask }

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

@@ -0,0 +1,95 @@
+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 {
+    packageSourcesDirectory as sourcesDir,
+    packageTestsBundlesDirectory as bundleDir
+}                                    from '../../_utils.mjs'
+import { getRollupConfigurationFor } from '../../configs/build.conf.mjs'
+import { sourcesFiles }              from '../../configs/check-bundling.conf.mjs'
+
+const {
+          red,
+          green,
+          magenta
+      } = colors
+
+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 config = getRollupConfigurationFor( 'check-bundling-from-esm-files-import' )
+    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 )
+
+        config.input       = temporaryFile
+        config.output.file = bundleFilePath
+
+        // create tmp file
+        try {
+
+            mkdirSync( temporaryDir, { recursive: true } )
+            writeFileSync( temporaryFile, temporaryFileData )
+
+            const bundle     = await rollup( config )
+            const { output } = await bundle.generate( config.output )
+
+            let code = output[ 0 ].code
+            if ( code.length > 1 ) {
+                log( red( `[${ specificFilePath }] contain side-effects !` ) )
+                await bundle.write( config.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
+
+export { checkBundlingFromEsmFilesImportTask }

package/.tasks/.tests/bundling/check-bundling.task.mjs

@@ -0,0 +1,20 @@
+import { series }                              from 'gulp'
+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 differents target 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.'
+
+export { checkBundlingTask }

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

@@ -0,0 +1,18 @@
+import { series }                 from 'gulp'
+import { runBenchmarksTestsTask } from './benchmarks/run-benchmarks.task.mjs'
+import { runUnitTestsTask }       from './unit-tests/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
+
+export { runTestsTask }

package/.tasks/.tests/unit-tests/build-unit-tests-backend.task.mjs

@@ -0,0 +1,42 @@
+import colors                                    from 'ansi-colors'
+import log                                       from 'fancy-log'
+import { rollup }                                from 'rollup'
+import { buildUnitTestsBackendConfig as config } from '../../configs/build-unit-tests-backend.conf.mjs'
+
+const {
+          red,
+          green
+      } = colors
+
+/**
+ * @description Will generate unit test bundles based on provided configs
+ */
+const buildUnitTestsBackendTask       = async ( done ) => {
+
+    if ( config === undefined || config === null || config.length === 0 ) {
+        done( red( 'Empty configuration!' ) )
+        return
+    }
+
+    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()
+
+}
+buildUnitTestsBackendTask.displayName = 'build-unit-tests-backend'
+buildUnitTestsBackendTask.description = 'Will generate unit test bundles based on provided configs'
+buildUnitTestsBackendTask.flags       = null
+
+export { buildUnitTestsBackendTask }