itee-validators 5.5.0 → 5.6.0

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

@@ -0,0 +1,24 @@
+import path from 'path'
+import childProcess from 'child_process'
+import {
+    getDirname,
+    packageInfos
+} from '../../_utils.mjs'
+
+
+function runBenchmarksForBackend( done ) {
+
+    const projectDir = getDirname()
+    const benchsPath = path.join( projectDir, `tests/benchmarks/builds/${ packageInfos.name }.benchs.cjs.js` )
+    const benchmark  = childProcess.spawn( 'node', [ benchsPath ], { stdio: 'inherit' } )
+    benchmark.on( 'close', ( code ) => {
+
+        ( code === 0 )
+        ? done()
+        : done( `benchmark exited with code ${ code }` )
+
+    } )
+
+}
+
+export { runBenchmarksForBackend }

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

@@ -0,0 +1,38 @@
+import path           from 'path'
+import karma          from 'karma'
+import log            from 'fancy-log'
+import colors         from 'ansi-colors'
+import { getDirname } from '../../_utils.mjs'
+
+const {
+          red,
+          green,
+          blue,
+          cyan,
+          yellow,
+          magenta
+      } = colors
+
+
+async function runBenchmarksForFrontend( done ) {
+
+    const projectDir  = getDirname()
+    const configFile  = path.normalize( `${ projectDir }/configs/karma.benchs.conf.js` )
+    const karmaConfig = karma.config.parseConfig( configFile )
+    const karmaServer = new karma.Server( karmaConfig, ( exitCode ) => {
+        if ( exitCode === 0 ) {
+            log( `Karma server exit with code ${ exitCode }` )
+            done()
+        } else {
+            done( `Karma server exit with code ${ exitCode }` )
+        }
+    } )
+    karmaServer.on( 'browser_error', ( browser, error ) => {
+        log( red( error.message ) )
+    } )
+
+    await karmaServer.start()
+
+}
+
+export { runBenchmarksForFrontend }

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

@@ -0,0 +1,167 @@
+import {
+    join,
+    normalize,
+    basename,
+    parse,
+    dirname,
+    relative
+}                       from 'path'
+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'
+
+
+const {
+          red,
+          green,
+          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` )
+
+    if ( !existsSync( buildFilePath ) ) {
+        done( red( buildFilePath + ' does not exist' ) )
+    }
+
+    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 = {
+            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
+            }
+        }
+        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 ( err ) {
+        log( red( error.message ) )
+    } finally {
+
+        done()
+
+    }
+
+}
+
+export { checkBundlingFromEsmBuildImport }

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

@@ -0,0 +1,129 @@
+import {
+    join,
+    normalize,
+    basename,
+    extname,
+    dirname,
+    relative
+}                               from 'path'
+import {
+    existsSync,
+    rmSync,
+    mkdirSync,
+    writeFileSync
+}                               from 'fs'
+import glob                     from 'glob'
+import { nodeResolve }          from '@rollup/plugin-node-resolve'
+import cleanup                  from 'rollup-plugin-cleanup'
+import { rollup }               from 'rollup'
+import { getGulpConfigForTask } from '../../../configs/gulp.conf.mjs'
+import { getDirname }           from '../../_utils.mjs'
+import log                      from 'fancy-log'
+import colors                   from 'ansi-colors'
+
+const {
+          red,
+          green,
+          blue,
+          cyan,
+          yellow,
+          magenta
+      } = colors
+
+async function checkBundlingFromEsmFilesDirect( done ) {
+
+    const baseDir           = getDirname()
+    const sourcesDir        = join( baseDir, 'sources' )
+    const testsDir          = join( baseDir, 'tests' )
+    const bundlesDir        = join( testsDir, 'bundles' )
+    const outputDir         = join( bundlesDir, 'from_files_direct' )
+    const filePathsToIgnore = getGulpConfigForTask( 'check-bundling' )
+
+    if ( existsSync( outputDir ) ) {
+        log( 'Clean up', magenta( outputDir ) )
+        rmSync( outputDir, { recursive: true } )
+    }
+
+    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
+                             } )
+
+    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 )
+
+        const config = {
+            input:     sourceFile,
+            external:  [ '' ],
+            plugins:   [
+                nodeResolve( {
+                    preferBuiltins: true
+                } ),
+                cleanup( {
+                    comments: 'none'
+                } )
+            ],
+            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:   bundleFilePath
+            }
+        }
+
+        try {
+
+            log( `Bundling ${ 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()
+
+}
+
+export { checkBundlingFromEsmFilesDirect }

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

@@ -0,0 +1,149 @@
+import {
+    join,
+    normalize,
+    basename,
+    parse,
+    dirname,
+    relative
+}                               from 'path'
+import {
+    existsSync,
+    rmSync,
+    mkdirSync,
+    writeFileSync
+}                               from 'fs'
+import log                      from 'fancy-log'
+import glob                     from 'glob'
+import { nodeResolve }          from '@rollup/plugin-node-resolve'
+import cleanup                  from 'rollup-plugin-cleanup'
+import { rollup }               from 'rollup'
+import colors                   from 'ansi-colors'
+import { getGulpConfigForTask } from '../../../configs/gulp.conf.mjs'
+import { getDirname }           from '../../_utils.mjs'
+
+const {
+          red,
+          green,
+          blue,
+          cyan,
+          yellow,
+          magenta
+      } = colors
+
+async function checkBundlingFromEsmFilesImport( done ) {
+
+    const baseDir           = getDirname()
+    const sourcesDir        = join( baseDir, 'sources' )
+    const testsDir          = join( baseDir, 'tests' )
+    const bundleDir         = join( testsDir, 'bundles' )
+    const outputDir         = join( bundleDir, 'from_files_import' )
+    const temporariesDir    = join( outputDir, '.tmp' )
+    const filePathsToIgnore = getGulpConfigForTask( 'check-bundling' )
+
+    if ( existsSync( outputDir ) ) {
+        log( 'Clean up', magenta( outputDir ) )
+        rmSync( outputDir, { recursive: true } )
+    }
+
+    const sourcesFiles = glob.sync( join( sourcesDir, '/**' ) )
+                             .map( filePath => {
+                                 return 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
+                             } )
+
+    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 )
+
+        const config = {
+            input:     temporaryFile,
+            plugins:   [
+                nodeResolve(),
+                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:   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()
+
+}
+
+export { checkBundlingFromEsmFilesImport }

package/.tasks/tests/unit-tests/bundle-unit-tests.mjs

@@ -0,0 +1,33 @@
+import rollupUnitTestsConfigurator from '../../../configs/rollup.units.conf.js'
+import log                         from 'fancy-log'
+import { rollup }                  from 'rollup'
+import colors                      from 'ansi-colors'
+
+const red = colors.red
+
+async function bundleUnitTests( done ) {
+
+    const configs = rollupUnitTestsConfigurator()
+
+    for ( let config of configs ) {
+
+        log( `Building ${ config.output.file }` )
+
+        try {
+
+            const bundle = await rollup( config )
+            await bundle.write( config.output )
+
+        } catch ( error ) {
+
+            log( red( error ) )
+
+        }
+
+    }
+
+    done()
+
+}
+
+export { bundleUnitTests }