@videinfra/static-website-builder 1.11.0 → 1.12.0

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.12.0] - 2024-02-25
+### Added
+- Support for multiple entry lists which each has its own "shared" chunk file
+
+## [1.11.1] - 2024-02-24
+### Fixed
+- Fixed dependencies
+
 ## [1.11.0] - 2024-02-24
 ### Updated
 - Added dynamic entries, webpack will rebuild when entries change

package/lib/generate-gulp-tasks.js

@@ -3,6 +3,7 @@ const assign = require('lodash/assign');
 const filter = require('lodash/filter');
 const { series, parallel } = require('gulp');
 const { DEFAULT_TASKS, BUILD_TASKS } = require('./task-order');
+const resolveDynamicTask = require('./gulp/resolve-dynamic-task');
 
 
 /**
@@ -28,16 +29,16 @@ function generateTaskList (taskConfig) {
 
                 // Create individual tasks, which can be run separatelly
                 for (let gulpTaskName in gulpTaskList) {
-                    taskList.separate[`${ taskName }-${ gulpTaskName }`] = gulpTaskList[gulpTaskName];
+                    taskList.separate[`${ taskName }-${ gulpTaskName }`] = resolveDynamicTask(gulpTaskList[gulpTaskName]);
                 }
 
                 for (let t = 0; t < DEFAULT_TASKS.length; t++) {
                     if (DEFAULT_TASKS[t] in gulpTaskList) {
-                        const gulpTask = gulpTaskList[DEFAULT_TASKS[t]];
+                        const gulpTask = resolveDynamicTask(gulpTaskList[DEFAULT_TASKS[t]]);
                         taskList.default[t].push(gulpTask);
                     }
                     if (BUILD_TASKS[t] in gulpTaskList) {
-                        const gulpTask = gulpTaskList[BUILD_TASKS[t]];
+                        const gulpTask = resolveDynamicTask(gulpTaskList[BUILD_TASKS[t]]);
                         taskList.build[t].push(gulpTask);
                     }
                 }

package/lib/get-config.js

@@ -1,157 +1,157 @@
-const fs = require('fs');
-const path = require('path');
-const getPath = require('./get-path');
-const runPreprocess = require('./run-preprocess');
-const merge = require('./merge');
-const logError = require('./log-error');
-
-const each = require('lodash/each');
-const omit = require('lodash/omit');
-const isPlainObject = require('lodash/isPlainObject');
-const isArray = require('lodash/isArray');
-const reduce = require('lodash/reduce');
-const get = require('lodash/get');
-
-
-/**
- * Returns builder and project specific task and plugin configurations combined
- * Configuration is preprocessed
- *
- * @returns {object} Task configurations
- */
-
-let taskConfig = null;
-
-function getConfig (builderConfigFile) {
-    if (!taskConfig) {
-        // Load all task configs
-        taskConfig = itterateConfig(loadConfig(), mergeConfigMode);
-
-        // 1. First load project specific config.js
-        const projectConfigPath = getPath.getProjectPath(builderConfigFile);
-        let   projectTaskConfig = {};
-        let   hasProjectConfigFile = true;
-
-        try {
-            fs.accessSync(projectConfigPath);
-        } catch (err) {
-            logError({'plugin': 'static-website-builder', 'message': `Couldn't find configuration file "${ projectConfigPath }"`});
-            hasProjectConfigFile = false;
-        }
-
-        if (hasProjectConfigFile) {
-            projectTaskConfig = itterateConfig(require(projectConfigPath), mergeConfigMode);
-        }
-
-        // 2. Marge plugins into the config, each plugin is just a config
-        const plugins = (taskConfig.plugins || []).concat(projectTaskConfig.plugins || []);
-        if (plugins) {
-            taskConfig.plugins = null;
-            projectTaskConfig.plugins = null;
-
-            each(plugins, (plugin) => {
-                taskConfig = merge(taskConfig, itterateConfig(plugin, mergeConfigMode));
-            });
-        }
-
-        // 3. Only after plugins has been executed, merge project specific config.js into main config
-        if (projectTaskConfig) {
-            taskConfig = merge(taskConfig, projectTaskConfig);
-        }
-
-        // 4. Preprocess
-        taskConfig = runPreprocess(taskConfig);
-    }
-
-    return taskConfig;
-};
-
-/**
- * Returns task sub-config by path
- *
- * @param  {...string} path Path to the sub-config
- * @returns {any} Task sub-config
- */
-function getTaskConfig (...path) {
-    return get(getConfig(), path, null);
-}
-
-/**
- * Itterate over each config property and call function on
- * each object or array
- *
- * @param {*} object
- * @param {*} fn
- * @protected
- */
-function itterateConfig (config, fn) {
-    if (config === false) return false;
-    const base = isPlainObject(config) ? {} : [];
-
-    return reduce(config, (object, value, key) => {
-        if (isPlainObject(value)) {
-            object[key]= itterateConfig(fn(value), fn);
-        } else if (isArray(value)) {
-            object[key]= itterateConfig(value, fn);
-        } else {
-            object[key] = value;
-        }
-
-        return object;
-    }, base);
-}
-
-/**
- * Merge 'production' or 'development' mode sub-ojbects into an object and remove
- * mode sub-objects
- *
- * @param {object} config Config
- * @returns {object} Config
- * @protected
- */
-function mergeConfigMode (config) {
-    if ('production' in config || 'development' in config) {
-        const mode = global.production ? 'production' : 'development';
-        const value = merge(config, config[mode]);
-
-        if (value !== false) {
-            return omit(value, ['production', 'development']);
-        } else {
-            return value;
-        }
-    } else {
-        return config;
-    }
-}
-
-/**
- * Load config files
- *
- * @returns {object} Configuration
- * @protected
- */
-function loadConfig () {
-    const taskFolder = path.resolve(__dirname, '../tasks');
-    let taskConfig = {};
-
-    fs.readdirSync(taskFolder).forEach(folderName => {
-        // Ignore task folders which start with underscore
-        if (folderName[0] !== '_') {
-            const configFileName = path.resolve(taskFolder, folderName, 'config.js');
-
-            try {
-                fs.accessSync(configFileName);
-            } catch (err) {
-                return;
-            }
-
-            taskConfig = merge(taskConfig, require(configFileName));
-        }
-    });
-
-    return taskConfig;
-};
-
-
-exports.getConfig = getConfig;
-exports.getTaskConfig = getTaskConfig;
+const fs = require('fs');
+const path = require('path');
+const getPath = require('./get-path');
+const runPreprocess = require('./run-preprocess');
+const merge = require('./merge');
+const logError = require('./log-error');
+
+const each = require('lodash/each');
+const omit = require('lodash/omit');
+const isPlainObject = require('lodash/isPlainObject');
+const isArray = require('lodash/isArray');
+const reduce = require('lodash/reduce');
+const get = require('lodash/get');
+
+
+/**
+ * Returns builder and project specific task and plugin configurations combined
+ * Configuration is preprocessed
+ *
+ * @returns {object} Task configurations
+ */
+
+let taskConfig = null;
+
+function getConfig (builderConfigFile) {
+    if (!taskConfig) {
+        // Load all task configs
+        taskConfig = itterateConfig(loadConfig(), mergeConfigMode);
+
+        // 1. First load project specific config.js
+        const projectConfigPath = getPath.getProjectPath(builderConfigFile);
+        let   projectTaskConfig = {};
+        let   hasProjectConfigFile = true;
+
+        try {
+            fs.accessSync(projectConfigPath);
+        } catch (err) {
+            logError({'plugin': 'static-website-builder', 'message': `Couldn't find configuration file "${ projectConfigPath }"`});
+            hasProjectConfigFile = false;
+        }
+
+        if (hasProjectConfigFile) {
+            projectTaskConfig = itterateConfig(require(projectConfigPath), mergeConfigMode);
+        }
+
+        // 2. Marge plugins into the config, each plugin is just a config
+        const plugins = (taskConfig.plugins || []).concat(projectTaskConfig.plugins || []);
+        if (plugins) {
+            taskConfig.plugins = null;
+            projectTaskConfig.plugins = null;
+
+            each(plugins, (plugin) => {
+                taskConfig = merge(taskConfig, itterateConfig(plugin, mergeConfigMode));
+            });
+        }
+
+        // 3. Only after plugins has been executed, merge project specific config.js into main config
+        if (projectTaskConfig) {
+            taskConfig = merge(taskConfig, projectTaskConfig);
+        }
+
+        // 4. Preprocess
+        taskConfig = runPreprocess(taskConfig);
+    }
+
+    return taskConfig;
+};
+
+/**
+ * Returns task sub-config by path
+ *
+ * @param  {...string} path Path to the sub-config
+ * @returns {any} Task sub-config
+ */
+function getTaskConfig (...path) {
+    return get(getConfig(), path, null);
+}
+
+/**
+ * Itterate over each config property and call function on
+ * each object or array
+ *
+ * @param {*} object
+ * @param {*} fn
+ * @protected
+ */
+function itterateConfig (config, fn) {
+    if (config === false) return false;
+    const base = isPlainObject(config) ? {} : [];
+
+    return reduce(config, (object, value, key) => {
+        if (isPlainObject(value)) {
+            object[key]= itterateConfig(fn(value), fn);
+        } else if (isArray(value)) {
+            object[key]= itterateConfig(value, fn);
+        } else {
+            object[key] = value;
+        }
+
+        return object;
+    }, base);
+}
+
+/**
+ * Merge 'production' or 'development' mode sub-ojbects into an object and remove
+ * mode sub-objects
+ *
+ * @param {object} config Config
+ * @returns {object} Config
+ * @protected
+ */
+function mergeConfigMode (config) {
+    if ('production' in config || 'development' in config) {
+        const mode = global.production ? 'production' : 'development';
+        const value = merge(config, config[mode]);
+
+        if (value !== false) {
+            return omit(value, ['production', 'development']);
+        } else {
+            return value;
+        }
+    } else {
+        return config;
+    }
+}
+
+/**
+ * Load config files
+ *
+ * @returns {object} Configuration
+ * @protected
+ */
+function loadConfig () {
+    const taskFolder = path.resolve(__dirname, '../tasks');
+    let taskConfig = {};
+
+    fs.readdirSync(taskFolder).forEach(folderName => {
+        // Ignore task folders which start with underscore
+        if (folderName[0] !== '_') {
+            const configFileName = path.resolve(taskFolder, folderName, 'config.js');
+
+            try {
+                fs.accessSync(configFileName);
+            } catch (err) {
+                return;
+            }
+
+            taskConfig = merge(taskConfig, require(configFileName));
+        }
+    });
+
+    return taskConfig;
+};
+
+
+exports.getConfig = getConfig;
+exports.getTaskConfig = getTaskConfig;

package/lib/gulp/dynamic-task.js

@@ -0,0 +1,8 @@
+/**
+ * Similar to parallel() and serial() but instead of getting tasks immediatelly
+ * it's executed after config has been loaded
+ */
+module.exports = function dynamicTask (fn) {
+    fn.dynamicTasks = true;
+    return fn;
+}

package/lib/gulp/resolve-dynamic-task.js

@@ -0,0 +1,11 @@
+/**
+ * Similar to parallel() and serial() but instead of getting tasks immediatelly
+ * it's executed after config has been loaded
+ */
+module.exports = function resolveDynamicTask (fn) {
+    if (fn.dynamicTasks) {
+        return fn();
+    } else {
+        return fn;
+    }
+}

package/lib/run-preprocess.js

@@ -19,7 +19,7 @@ module.exports = function runPreprocess (taskConfig) {
                     if (newTaskConfig === false) {
                         taskConfig[taskName] = false;
                         break;
-                    } else if (newTaskConfig && isPlainObject(newTaskConfig)) {
+                    } else if (newTaskConfig && (isPlainObject(newTaskConfig) || Array.isArray(newTaskConfig))) {
                         // Safeguard against empty values
                         taskConfig[taskName] = newTaskConfig;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@videinfra/static-website-builder",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Customizable static site project builder",
   "license": "MIT",
   "engines": {
@@ -50,11 +50,14 @@
     "gulp-sourcemaps": "^3.0.0",
     "gulp-svgmin": "^4.1.0",
     "gulp-svgstore": "^9.0.0",
+    "lodash.clone": "^4.3.2",
+    "lodash.some": "^4.2.2",
     "map-stream": "^0.1.0",
     "minimist": "^1.2.8",
     "nano-memoize": "1.3.0",
     "node-sass": "^7.0.3",
     "sass": "^1.65.1",
+    "through": "^2.3.8",
     "twig": "^1.10.5",
     "webpack": "^4.46.0",
     "webpack-watch-files-plugin": "^1.2.1"

package/tasks/javascripts/config.js

@@ -7,7 +7,15 @@ exports.javascripts = {
     extensions: ['js', 'json'],
 
     // Instead of 'entry' we provide filename which list all entries
-    entryList: '_entries.js',
+    // Can be either an object or array of object to have multiple webpack
+    // build, one for each of the entry list files
+    entryList: {
+        // Path to the entry list file
+        name: '_entries.js',
+
+        // Entry shared chunk name, creates webpack.optimization chunks
+        shared: 'shared',
+    },
 
     // Webpack configuration
     // see https://webpack.js.org/configuration/
@@ -33,8 +41,11 @@ exports.javascripts = {
             ],
         },
 
+        // Default optimization, 'shared' will be overwritten by entryList.shared value
         optimization: {
-            runtimeChunk: {name: 'shared'},
+            runtimeChunk: {
+                name: 'shared'
+            },
             splitChunks: {
                 cacheGroups: {
                     default: false,

package/tasks/javascripts/preprocess-config.js

@@ -2,6 +2,7 @@ const paths = require('../../lib/get-path');
 const merge = require('../../lib/merge');
 const get = require('lodash/get');
 const map = require('lodash/map');
+const cloneDeep = require('lodash/cloneDeep');
 const webpack = require('webpack');
 const WatchExternalFilesPlugin = require('webpack-watch-files-plugin');
 
@@ -22,32 +23,10 @@ function requireUncached(module) {
  * @returns {object} List of entry files
  */
 function getEntry (config) {
-    const entryFile = paths.getSourcePath('javascripts', config.entryList);
-
-    // console.log(require(entryFile));
-    // return () => {
-    //     return new Promise((resolve) => {
-    //         resolve(require(entryFile));
-    //     });
-    // };
-
-    // return () => new Promise((resolve) => {
-    //     resolve(['./demo', './demo2'])
-    // });
+    const entryFile = paths.getSourcePath('javascripts', config.entryList.name);
 
     return function getEntries () {
-        // const entryURL = pathToFileURL(entryFile).href + '?_invalidate-cache=' + (++entriesCounter);
-
-        // console.log(require.cache.);
-        // console.log('loading entries:', entryURL);
-        // return import(entryURL).then((entries) => {
-        //     console.log('loaded entries:', entries.default);
-        //     return entries.default;
-        // });
-
-        const entries = requireUncached(entryFile);
-        console.log('entries:', entries);
-        return entries;
+        return requireUncached(entryFile);
     }
 }
 
@@ -65,56 +44,124 @@ module.exports = function preprocessJavascriptsConfig (config, fullConfig) {
         webpackPlugins = webpackPlugins(webpack);
     }
 
-    return merge(config, {
-        webpack: {
-            mode: global.production ? 'production' : 'development',
-
-            // Input files
-            context: paths.getSourcePath('javascripts'),
-            entry: getEntry(config),
-
-            // Output folder
-            output: merge({
-                path: paths.getDestPath('javascripts'),
-                publicPath: paths.getPublicPath('javascripts'),
-            }, get(config, ['webpack', 'output'], null)),
-
-            // Plugins, add ENV variables
-            plugins: [
-                new webpack.DefinePlugin({
-                    'process.env.NODE_ENV': JSON.stringify(global.production ? 'production' : 'development'),
-                }),
-                new WatchExternalFilesPlugin.default({
-                    verbose: false,
-                    files: [
-                        paths.getSourcePath('javascripts', config.entryList),
+    // User may specify a function, execute it to get object / array
+    if (typeof config.entryList === 'function') {
+        config.entryList = config.entryList(config);
+    }
+
+    // User may specify multiple entry list files, convert to array
+    if (!Array.isArray(config.entryList)) {
+        config.entryList = [config.entryList];
+    }
+
+    // User may specify only a name of the entry file
+    // Set shared chunk name for each of the entry files
+    // Each entryList item is { name: '...', shared: '...' }
+    config.entryList = config.entryList.map((entry, index) => {
+        return {
+            name: typeof entry === 'string' ? entry : entry.name,
+            shared: typeof entry !== 'string' && entry && entry.shared ? entry.shared : (index === 0 ? 'shared' : ''),
+        };
+    });
+
+    return config.entryList.map((entryList) => {
+        const entryConfig = Object.assign({}, config);
+        entryConfig.webpack = Object.assign({}, entryConfig.webpack);
+
+        // One entry file per config
+        entryConfig.entryList = entryList;
+
+        const buildConfig = merge(entryConfig, {
+            webpack: {
+                mode: global.production ? 'production' : 'development',
+
+                // Input files
+                context: paths.getSourcePath('javascripts'),
+                entry: getEntry(entryConfig),
+
+                // Output folder
+                output: merge({
+                    path: paths.getDestPath('javascripts'),
+                    publicPath: paths.getPublicPath('javascripts'),
+                }, get(entryConfig, ['webpack', 'output'], null)),
+
+                // Plugins, add ENV variables
+                plugins: [
+                    new webpack.DefinePlugin({
+                        'process.env.NODE_ENV': JSON.stringify(global.production ? 'production' : 'development'),
+                    }),
+                    new WatchExternalFilesPlugin.default({
+                        verbose: false,
+                        files: [
+                            paths.getSourcePath('javascripts', entryList.name),
+                        ],
+                    }),
+                ].concat(webpackPlugins),
+
+                // Imports
+                resolve: merge({
+                    // File extensions
+                    extensions: map(entryConfig.extensions, (extension) => `.${ extension }`),
+
+                    // Import folders
+                    modules: [
+                        // Allow imports from node_modules
+                        paths.getProjectPath('node_modules'),
+
+                        // Allow imports from source folder
+                        paths.getSourcePath('javascripts'),
                     ],
-                }),
-            ].concat(webpackPlugins),
-
-            // Imports
-            resolve: merge({
-                // File extensions
-                extensions: map(config.extensions, (extension) => `.${ extension }`),
-
-                // Import folders
-                modules: [
-                    // Allow imports from node_modules
-                    paths.getProjectPath('node_modules'),
-
-                    // Allow imports from source folder
-                    paths.getSourcePath('javascripts'),
-                ],
-            }, get(config, ['webpack', 'resolve'], null)),
-
-            // Loader imports
-            resolveLoader: {
-                modules: [
-                    // Allow imports from node_modules
-                    paths.getBuilderPath('node_modules'),
-                    paths.getProjectPath('node_modules'),
-                ]
-            },
+                }, get(entryConfig, ['webpack', 'resolve'], null)),
+
+                // Loader imports
+                resolveLoader: {
+                    modules: [
+                        // Allow imports from node_modules
+                        paths.getBuilderPath('node_modules'),
+                        paths.getProjectPath('node_modules'),
+                    ]
+                },
+            }
+        });
+
+        // Add webpack.optimization.runtimeChunk and webpack.optimization.splitChunks,
+        // if entryConfig.shared doesn't exist, then remove them
+        if (entryList.shared && entryList.shared !== 'shared') {
+            const optimization = buildConfig.webpack.optimization = cloneDeep(buildConfig.webpack.optimization || {});
+
+            if (get(optimization, ['runtimeChunk', 'name'], null) === 'shared') {
+                // Change shared runtimeChunk name
+                optimization.runtimeChunk.name = entryList.shared;
+            } else if (!optimization.runtimeChunk) {
+                // Add shared runtimeChunk
+                optimization.runtimeChunk = {
+                    name: entryList.shared,
+                };
+            }
+
+            if ('shared' in get(optimization, ['splitChunks', 'cacheGroups'], {})) {
+                // Rename split chunks "shared" chunk
+                const cacheGroups = optimization.splitChunks.cacheGroups.shared;
+                delete(optimization.splitChunks.cacheGroups.shared);
+                optimization.splitChunks.cacheGroups[entryList.shared] = cacheGroups;
+                cacheGroups.name = entryList.shared;
+            } else if (!optimization.splitChunks) {
+                // Add splitChunks
+                optimization.splitChunks = optimization.splitChunks || {};
+                optimization.splitChunks.cacheGroups = optimization.splitChunks.cacheGroups || {};
+                optimization.splitChunks.cacheGroups[entryList.shared] = {
+                    name: entryList.shared,
+                    chunks: 'all',
+                    minChunks: 3,
+                    enforce: true,
+                };
+            }
+        } else if (!entryList.shared) {
+            // Remove optimization
+            delete(buildConfig.webpack.optimization);
         }
+
+        return buildConfig;
     });
+
 }

package/tasks/javascripts/task.js

@@ -1,4 +1,5 @@
 const gulp = require('gulp');
+const { parallel } = require('gulp');
 const webpack = require('webpack');
 const gulpWebpack = require('../../vendor/webpack-stream/index.js');
 const memoize = require('nano-memoize');
@@ -11,12 +12,12 @@ const getConfig = require('./../../lib/get-config');
 const taskStart = require('../../lib/gulp/task-start');
 const taskEnd = require('../../lib/gulp/task-end');
 const taskBeforeDest = require('../../lib/gulp/task-before-dest');
-
+const dynamicTask = require('../../lib/gulp/dynamic-task');
 
 const getGlobPaths = memoize(function () {
     const sourcePaths = getPaths.getSourcePaths('javascripts');
-    const extensions = getConfig.getTaskConfig('javascripts', 'webpack', 'resolve', 'extensions');
-    const ignore = getConfig.getTaskConfig('javascripts', 'ignore');
+    const extensions = getConfig.getTaskConfig('javascripts', '0', 'webpack', 'resolve', 'extensions');
+    const ignore = getConfig.getTaskConfig('javascripts', '0', 'ignore');
 
     return globs.generate(
         globs.paths(sourcePaths).filesWithExtensions(extensions), // Files to watch
@@ -26,19 +27,42 @@ const getGlobPaths = memoize(function () {
 
 
 function javascripts (watch) {
-    return gulp.src(getGlobPaths())
-        .pipe(taskStart())
+    const configs = getConfig.getTaskConfig('javascripts');
+
+    // Configs is an array, for each of the entry files separate config is created
+    const tasks = configs.map(function (config, index) {
+        // Gulp task function
+        const fn = function () {
+            return gulp.src(getGlobPaths())
+                .pipe(taskStart())
+
+                .pipe(gulpWebpack(
+                    merge(config.webpack, {'watch': watch === true}),
+                    webpack
+                ))
+
+                .pipe(taskBeforeDest())
+                .pipe(gulp.dest(getPaths.getDestPath('javascripts')))
 
-        .pipe(gulpWebpack(
-            merge(getConfig.getTaskConfig('javascripts', 'webpack'), {'watch': watch === true}),
-            webpack
-        ))
+                // Reload on change
+                .pipe(taskEnd());
+        };
 
-        .pipe(taskBeforeDest())
-        .pipe(gulp.dest(getPaths.getDestPath('javascripts')))
+        // Set name of the gulp task function, currently it doesn't have a name yet
+        // This is needed so that name appears in terminal when running build
+        let name = 'javascripts' + (watch ? 'Watch' : '');
 
-        // Reload on change
-        .pipe(taskEnd());
+        if (configs.length > 1) {
+            let entryFileName = config.entryList.name.replace('.json', '').replace('.js', '');
+            name += entryFileName[0].toUpperCase() + entryFileName.slice(1);
+        }
+
+        Object.defineProperty(fn, 'name', { value: name });
+
+        return fn;
+    });
+
+    return parallel(...tasks);
 }
 
 function javascriptsWatch () {
@@ -46,6 +70,6 @@ function javascriptsWatch () {
     return javascripts(true);
 }
 
-
-exports.build = javascripts;
-exports.watch = javascriptsWatch;
+// Dynamic task will be executed when config is ready and must return gulp tasks
+exports.build = dynamicTask(javascripts);
+exports.watch = dynamicTask(javascriptsWatch);

package/tests/run-preprocess.test.js

@@ -45,8 +45,9 @@ test('Preprocess returning non-object should result in same config config', () =
     const configString = {'task': {'a': 1}, 'preprocess': {'task': [() => 'string']}};
     expect(runPreprocess(configString).task).toEqual({'a': 1});
 
+    // Task config can be an array, this is used for javascripts
     const configArray = {'task': {'a': 1}, 'preprocess': {'task': [() => ['a', 'b']]}};
-    expect(runPreprocess(configArray).task).toEqual({'a': 1});
+    expect(runPreprocess(configArray).task).toEqual(['a', 'b']);
 });
 
 test('Preprocess returning false shouldn\'t call other preprocesses', () => {