itee-validators 6.0.0 → 6.1.1

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

@@ -1,210 +0,0 @@
-import colors           from 'ansi-colors'
-import childProcess     from 'child_process'
-import log              from 'fancy-log'
-import {
-    existsSync,
-    mkdirSync,
-    writeFileSync
-}                       from 'fs'
-import {
-    basename,
-    dirname,
-    extname,
-    join,
-    relative
-}                       from 'path'
-import {
-    nodeModulesDirectory,
-    packageName,
-    packageSourcesDirectory as sourcesDir,
-    packageTestsBenchmarksDirectory as benchesDir
-}                       from '../../_utils.mjs'
-import { sourcesFiles } from '../../configs/compute-benchmarks.conf.mjs'
-
-const {
-          red,
-          green,
-          yellow
-      } = colors
-
-/**
- * @description Will generate benchmarks files from source code against provided alternatives
- */
-const computeBenchmarksTask       = ( done ) => {
-
-    if ( !existsSync( benchesDir ) ) {
-        log( 'Creating', green( benchesDir ) )
-        mkdirSync( benchesDir, { recursive: true } )
-    }
-
-    const benchRootImports = []
-    for ( let sourceFile of sourcesFiles ) {
-
-        const specificFilePath = sourceFile.replace( sourcesDir, '' )
-        const specificDir      = dirname( specificFilePath )
-
-        const fileName      = basename( sourceFile, extname( sourceFile ) )
-        const benchFileName = `${ fileName }.bench.js`
-        const benchDirPath  = join( benchesDir, specificDir )
-        const benchFilePath = join( benchDirPath, benchFileName )
-
-        const nsName         = `${ fileName }Namespace`
-        const importDirPath  = relative( benchDirPath, sourcesDir )
-        const importFilePath = join( importDirPath, specificFilePath ).replace( /\\/g, '/' )
-
-        try {
-
-            const jsdocPath   = join( nodeModulesDirectory, '/jsdoc/jsdoc.js' )
-            const jsdocOutput = childProcess.execFileSync( 'node', [ jsdocPath, '-X', sourceFile ] ).toString()
-
-            const classNames    = []
-            const usedLongnames = []
-            const jsonData      = JSON.parse( jsdocOutput ).filter( data => {
-
-                const longName = data.longname
-
-                const kind = data.kind
-                if ( kind !== 'function' ) {
-                    if ( kind === 'class' && !classNames.includes( longName ) ) {
-                        classNames.push( longName )
-                    }
-                    return false
-                }
-
-                // We don't care that data bloc have comment they are unused to generate benchmarks
-                // const undocumented = data.undocumented
-                // if ( undocumented ) {
-                //     return false
-                // }
-
-                const scope = data.scope
-                if ( ![ 'global', 'static' ].includes( scope ) ) {
-                    return false
-                }
-
-                if ( longName.includes( ' ' ) || longName.includes( '~' ) || usedLongnames.includes( longName ) ) {
-                    return false
-                }
-
-                for ( let className of classNames ) {
-                    if ( longName.includes( className ) ) {
-                        return false
-                    }
-                }
-
-                usedLongnames.push( longName )
-
-                return true
-
-            } )
-
-            if ( jsonData.length === 0 ) {
-                log( 'Ignoring', yellow( `${ sourceFile }, no usable exports found` ) )
-                continue
-            }
-
-            // Compute benchmark suites by grouping logically function by name[_x]
-            const suiteGroups = {}
-            for ( let docData of jsonData ) {
-
-                try {
-
-                    const functionName = docData.name
-                    const nameSplits   = functionName.split( '_' )
-                    const rootName     = nameSplits[ 0 ]
-
-                    if ( !( rootName in suiteGroups ) ) {
-                        suiteGroups[ rootName ] = []
-                    }
-
-                    suiteGroups[ rootName ].push( functionName )
-
-                } catch ( error ) {
-
-                    log( red( error.message ) )
-
-                }
-
-            }
-
-            // Generate suites
-            let benchSuites       = ''
-            const suitesToExports = []
-            for ( let suiteGroupName in suiteGroups ) {
-                suitesToExports.push( `${ suiteGroupName }Suite` )
-                benchSuites += `const ${ suiteGroupName }Suite = Benchmark.Suite( '${ nsName }.${ suiteGroupName }', Testing.createSuiteOptions() )` + '\n'
-
-                for ( let suiteGroupValue of suiteGroups[ suiteGroupName ] ) {
-                    benchSuites += `                                     .add( '${ suiteGroupValue }()', Testing.iterateOverDataMap( ${ nsName }.${ suiteGroupValue } ), Testing.createBenchmarkOptions() )` + '\n'
-                }
-
-                benchSuites += '\n'
-            }
-
-            const template = '' +
-                `import { Testing }      from 'itee-utils/sources/testings/benchmarks.js'` + '\n' +
-                `import * as ${ nsName } from '${ importFilePath }'` + '\n' +
-                '\n' +
-                `${ benchSuites }` +
-                // '\n' +
-                `export { ${ suitesToExports } }` + '\n' +
-                '\n'
-
-            const importBenchFilePath = relative( benchesDir, benchFilePath ).replace( /\\/g, '/' )
-            benchRootImports.push( {
-                path:    importBenchFilePath,
-                exports: suitesToExports
-            } )
-
-            if ( !existsSync( benchDirPath ) ) {
-                log( 'Creating', green( benchDirPath ) )
-                mkdirSync( benchDirPath, { recursive: true } )
-            }
-
-            log( 'Creating', green( benchFilePath ) )
-            writeFileSync( benchFilePath, template )
-
-        } catch ( error ) {
-
-            log( red( error.message ) )
-
-        }
-
-    }
-
-    let templateImports = ''
-    let suites          = []
-    for ( let i = 0 ; i < benchRootImports.length ; i++ ) {
-
-        const currentBench = benchRootImports[ i ]
-        const namedExports = currentBench.exports
-        const imports      = namedExports.join( ', ' )
-        suites.push( ...namedExports )
-
-        templateImports += `import {${ imports }} from './${ currentBench.path }'` + '\n'
-
-    }
-
-    const benchesTemplate = '' +
-        `${ templateImports }` + '\n' +
-        'const suites = [' + '\n' +
-        `${ suites.map( suite => `\t${ suite }` ).join( ',\n' ) }` + '\n' +
-        ']' + '\n' +
-        '\n' +
-        `for ( const suite of suites ) {` + '\n' +
-        `\tsuite.run()` + '\n' +
-        `}` + '\n'
-
-    const benchesFilePath = join( benchesDir, `${ packageName }.benchmarks.js` )
-
-    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 { computeBenchmarksTask }

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

@@ -1,39 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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.task.mjs

@@ -1,123 +0,0 @@
-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 {
-    packageBuildsDirectory as buildsDir,
-    packageName,
-    packageTestsBundlesDirectory as bundlesDir
-}                                    from '../../_utils.mjs'
-import { getRollupConfigurationFor } from '../../configs/build.conf.mjs'
-
-const {
-          red,
-          green,
-          magenta
-      } = colors
-
-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 } )
-    }
-
-    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
-        const config = getRollupConfigurationFor( 'check-bundling-from-esm-build-import' )
-        let fileName, bundleFileName, bundleFilePath
-        for ( const temporaryFilePath of temporaryFilePaths ) {
-
-            fileName       = basename( temporaryFilePath )
-            bundleFileName = fileName.replace( '.tmp.', '.bundle.' )
-            bundleFilePath = join( outputDir, bundleFileName )
-
-            try {
-
-                config.input       = temporaryFilePath
-                config.output.file = bundleFilePath
-
-                const bundle     = await rollup( config )
-                const { output } = await bundle.generate( config.output )
-
-                let code = output[ 0 ].code
-                if ( code.length > 1 ) {
-                    log( red( `[${ bundleFileName }] contain side-effects !` ) )
-                    await bundle.write( config.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
-
-export { checkBundlingFromEsmBuildImportTask }

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

@@ -1,77 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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 }