cypress-vue-unit-test/dist/preprocessor/webpack.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var webpack_1 = __importDefault(require("webpack"));
var util_1 = __importDefault(require("util"));
// Cypress webpack bundler adaptor
// https://github.com/cypress-io/cypress-webpack-preprocessor
var webpackPreprocessor = require('@cypress/webpack-preprocessor');
var debug = require('debug')('cypress-vue-unit-test');
var VueLoaderPlugin = require('vue-loader/lib/plugin');
// const { VueLoaderPlugin } = require('vue-loader')
var fw = require('find-webpack');
// Preventing chunks because we don't serve static assets
function preventChunking(options) {
    if (options === void 0) { options = {}; }
    if (options && options.optimization && options.optimization.splitChunks) {
        delete options.optimization.splitChunks;
    }
    options.plugins = options.plugins || [];
    options.plugins.push(new webpack_1.default.optimize.LimitChunkCountPlugin({
        maxChunks: 1,
    }));
    return options;
}
// Base 64 all the things because we don't serve static assets
function inlineUrlLoadedAssets(options) {
    if (options === void 0) { options = {}; }
    var isUrlLoader = function (use) {
        return use && use.loader && use.loader.indexOf('url-loader') > -1;
    };
    var mergeUrlLoaderOptions = function (use) {
        if (isUrlLoader(use)) {
            use.options = use.options || {};
            use.options.limit = Number.MAX_SAFE_INTEGER;
        }
        return use;
    };
    if (options.module && options.module.rules) {
        options.module.rules = options.module.rules.map(function (rule) {
            if (Array.isArray(rule.use)) {
                rule.use = rule.use.map(mergeUrlLoaderOptions);
            }
            return rule;
        });
    }
    return options;
}
function compileTemplate(options) {
    if (options === void 0) { options = {}; }
    options.resolve = options.resolve || {};
    options.resolve.alias = options.resolve.alias || {};
    options.resolve.alias['vue$'] = 'vue/dist/vue.esm.js';
}
/**
 * Warning: modifies the input object
 * @param {WebpackOptions} options
 */
function removeForkTsCheckerWebpackPlugin(options) {
    if (!Array.isArray(options.plugins)) {
        return;
    }
    options.plugins = options.plugins.filter(function (plugin) {
        return plugin.typescript === undefined;
    });
}
/**
 * Warning: modifies the input object
 * @param {Cypress.ConfigOptions} config
 * @param {WebpackOptions} options
 */
function insertBabelLoader(config, options) {
    var skipCodeCoverage = config && config.env && config.env.coverage === false;
    if (!options.devtool) {
        options.devtool = '#eval-source-map';
    }
    var babelRule = {
        test: /\.js$/,
        loader: 'babel-loader',
        exclude: /node_modules/,
        options: {
            plugins: [
                // this plugin allows ES6 imports mocking
                [
                    '@babel/plugin-transform-modules-commonjs',
                    {
                        loose: true,
                    },
                ],
            ],
        },
    };
    if (skipCodeCoverage) {
        debug('not adding code instrument plugin');
    }
    else {
        debug('adding code coverage plugin');
        // this plugin instruments the loaded code
        // which allows us to collect code coverage
        var instrumentPlugin = [
            'babel-plugin-istanbul',
            {
                // specify some options for NYC instrumentation here
                // like tell it to instrument both JavaScript and Vue files
                extension: ['.js', '.vue'],
            },
        ];
        babelRule.options.plugins.push(instrumentPlugin);
    }
    options.module.rules.push(babelRule);
    options.plugins = options.plugins || [];
    var pluginFound = options.plugins.find(function (plugin) {
        return (plugin.constructor && plugin.constructor.name === VueLoaderPlugin.name);
    });
    if (!pluginFound) {
        debug('inserting VueLoaderPlugin');
        options.plugins.push(new VueLoaderPlugin());
    }
    else {
        debug('found plugin VueLoaderPlugin already');
    }
}
/**
 * Basic Cypress Vue Webpack file loader for .vue files.
 */
var onFileDefaultPreprocessor = function (config) {
    var webpackOptions = fw.getWebpackOptions();
    if (!webpackOptions) {
        debug('Could not find webpack options, starting with default');
        webpackOptions = {};
    }
    webpackOptions.mode = 'development';
    inlineUrlLoadedAssets(webpackOptions);
    preventChunking(webpackOptions);
    compileTemplate(webpackOptions);
    insertBabelLoader(config, webpackOptions);
    // if I remove it, then get another message
    // [VueLoaderPlugin Error] No matching use for vue-loader is found.
    // removeForkTsCheckerWebpackPlugin(webpackOptions)
    if (debug.enabled) {
        console.error('final webpack');
        console.error(util_1.default.inspect(webpackOptions, false, 2, true));
    }
    return webpackPreprocessor({
        webpackOptions: webpackOptions,
    });
};
/**
 * Custom Vue loader from the client projects that already have `webpack.config.js`
 *
 * @example
 *    const {
 *      onFilePreprocessor
 *    } = require('cypress-vue-unit-test/preprocessor/webpack')
 *    module.exports = on => {
 *      on('file:preprocessor', onFilePreprocessor('../path/to/webpack.config'))
 *    }
 */
var onFilePreprocessor = function (webpackOptions) {
    if (typeof webpackOptions === 'string') {
        // load webpack config from the given path
        webpackOptions = require(webpackOptions);
    }
    return webpackPreprocessor({
        webpackOptions: webpackOptions,
    });
};
module.exports = { onFilePreprocessor: onFilePreprocessor, onFileDefaultPreprocessor: onFileDefaultPreprocessor };