commonsChunkPlugin.ts

import {
    addOrUpdateConfigObject,
    createIdentifierOrLiteral,
    createProperty,
    findAndRemovePluginByName,
    findPluginsByName,
    findRootNodesByName,
} from '@webpack-cli/utils';

import { JSCodeshift, Node } from '../types/NodePath';

// merge test entry prop and function expression. case 6[x]
// TODO: set the proper type once moved to @types/jscodeshift
// eslint-disable-next-line
const mergeTestPropArrowFunction = (j, chunkKey, testFunc): any => {
    return j.property(
        'init',
        createIdentifierOrLiteral(j, 'test'),
        j.arrowFunctionExpression(
            [j.identifier('module')],
            j.blockStatement([
                j.ifStatement(
                    j.callExpression(
                        j.memberExpression(
                            j.callExpression(j.memberExpression(j.identifier('module'), j.identifier('getChunks')), []),
                            j.identifier('some'),
                            false,
                        ),
                        [
                            j.arrowFunctionExpression(
                                [j.identifier('chunk')],
                                j.binaryExpression(
                                    '===',
                                    j.memberExpression(j.identifier('chunk'), j.identifier('name')),
                                    j.literal(chunkKey),
                                ),
                            ),
                        ],
                    ),
                    j.returnStatement(j.literal(true)),
                ),
                j.variableDeclaration('const', [j.variableDeclarator(j.identifier('fn'), testFunc)]),
                j.returnStatement(j.callExpression(j.identifier('fn'), [j.identifier('module')])),
            ]),
        ),
    );
};

/**
 *
 * Transform for CommonsChunkPlugin. If found, removes the
 * plugin and sets optimizations.namedModules to true
 *
 * @param {Object} j - jscodeshift top-level import
 * @param {Node} ast - jscodeshift ast to transform
 * @returns {Node} ast - jscodeshift ast
 */
export default function (j: JSCodeshift, ast: Node): Node {
    const splitChunksProps: Node[] = [];
    const cacheGroupsProps: Node[] = [];
    const optimizationProps: object = {};

    let commonCacheGroupsProps: Node[] = [createProperty(j, 'chunks', 'initial'), createProperty(j, 'enforce', true)];

    // find old options
    const CommonsChunkPlugin: Node = findPluginsByName(j, ast, ['webpack.optimize.CommonsChunkPlugin']);

    if (!CommonsChunkPlugin.size()) {
        return ast;
    }

    // cache group options based on keys
    let cacheGroup: object = {};
    let cacheGroups: Node[] = [];

    // iterate each CommonsChunkPlugin instance
    CommonsChunkPlugin.forEach((path: Node): void => {
        const CCPProps: Node[] = (path.value as Node).arguments[0].properties;

        // reset chunks from old props
        cacheGroup = {};
        cacheGroups = [];

        commonCacheGroupsProps = [createProperty(j, 'chunks', 'initial'), createProperty(j, 'enforce', true)];

        let chunkKey: string;
        let chunkCount = 0;

        // iterate CCP props and map SCP props
        CCPProps.forEach((p: Node): void => {
            const propKey: string = p.key.name;

            switch (propKey) {
                case 'names':
                    (p.value as Node).elements.forEach(({ value: chunkValue }): void => {
                        if (chunkValue === 'runtime') {
                            optimizationProps['runtimeChunk'] = j.objectExpression([createProperty(j, 'name', chunkValue)]);
                        } else {
                            if (!Array.isArray(cacheGroup[chunkValue as string])) {
                                cacheGroup[chunkValue as string] = [];
                            }

                            findRootNodesByName(j, ast, 'entry').forEach(({ value }): void => {
                                const { properties: entries } = (value as Node).value as Node;
                                chunkCount = entries.length;
                                entries.forEach(({ key: { name: entryName } }): void => {
                                    if (entryName === chunkValue) {
                                        cacheGroup[chunkValue as string].push(createProperty(j, 'test', entryName));
                                    }
                                });
                            });
                        }
                    });
                    break;

                case 'name': {
                    const nameKey = (p.value as Node).value as string;

                    if (nameKey === 'runtime') {
                        optimizationProps['runtimeChunk'] = j.objectExpression([createProperty(j, 'name', nameKey)]);
                    } else {
                        chunkKey = nameKey;

                        if (!Array.isArray(cacheGroup[nameKey])) {
                            cacheGroup[nameKey] = [];
                        }

                        findRootNodesByName(j, ast, 'entry').forEach(({ value }): void => {
                            const { properties: entries } = (value as Node).value as Node;
                            chunkCount = entries.length;
                            entries.forEach(({ key: { name: entryName } }): void => {
                                if (entryName === nameKey) {
                                    cacheGroup[nameKey].push(createProperty(j, 'test', entryName));
                                }
                            });
                        });
                    }
                    break;
                }

                case 'filename':
                    if (chunkKey) {
                        if (!Array.isArray(cacheGroup[chunkKey])) {
                            cacheGroup[chunkKey] = [];
                        }
                        cacheGroup[chunkKey].push(createProperty(j, propKey, (p.value as Node).value as string));
                    }
                    break;

                case 'async':
                    if (!Array.isArray(cacheGroup[chunkKey])) {
                        cacheGroup[chunkKey] = [];
                    }
                    cacheGroup[chunkKey].push(createProperty(j, 'chunks', 'async'));
                    break;

                case 'minSize':
                    if (!Array.isArray(cacheGroup[chunkKey])) {
                        cacheGroup[chunkKey] = [];
                    }
                    cacheGroup[chunkKey].push(j.property('init', createIdentifierOrLiteral(j, propKey), p.value as Node));
                    break;

                case 'minChunks': {
                    const { value: pathValue }: Node = p;

                    // minChunk is a function
                    if ((pathValue as Node).type === 'ArrowFunctionExpression' || (pathValue as Node).type === 'FunctionExpression') {
                        if (!Array.isArray(cacheGroup[chunkKey])) {
                            cacheGroup[chunkKey] = [];
                        }

                        cacheGroup[chunkKey] = cacheGroup[chunkKey].map((prop): string | void =>
                            prop.key.name === 'test' ? mergeTestPropArrowFunction(j, chunkKey, pathValue) : prop,
                        );
                    }
                    break;
                }
            }
        });

        Object.keys(cacheGroup).forEach((chunkName: string): void => {
            let chunkProps: Node[] = [createProperty(j, 'name', chunkName)];

            const chunkPropsToAdd = cacheGroup[chunkName];
            const chunkPropsKeys = chunkPropsToAdd.map((prop): string => prop.key.name);

            commonCacheGroupsProps = commonCacheGroupsProps.filter((commonProp): boolean => !chunkPropsKeys.includes(commonProp.key.name));

            chunkProps.push(...commonCacheGroupsProps);

            if (chunkCount > 1) {
                chunkProps.push(j.property('init', createIdentifierOrLiteral(j, 'minChunks'), createIdentifierOrLiteral(j, chunkCount)));
            }

            const chunkPropsContainTest = chunkPropsToAdd.some(
                (prop): boolean => prop.key.name === 'test' && prop.value.type === 'Literal',
            );

            if (chunkPropsContainTest) {
                chunkProps = chunkProps.filter((prop): boolean => prop.key.name !== 'minChunks');
            }

            if (chunkPropsToAdd && Array.isArray(chunkPropsToAdd) && chunkPropsToAdd.length > 0) {
                chunkProps.push(...chunkPropsToAdd);
            }

            cacheGroups.push(j.property('init', createIdentifierOrLiteral(j, chunkName), j.objectExpression([...chunkProps])));
        });

        if (cacheGroups.length > 0) {
            cacheGroupsProps.push(...cacheGroups);
        }
    });

    // Remove old plugin
    const root: Node = findAndRemovePluginByName(j, ast, 'webpack.optimize.CommonsChunkPlugin');

    const rootProps: Node[] = [...splitChunksProps];

    if (cacheGroupsProps.length > 0) {
        rootProps.push(j.property('init', createIdentifierOrLiteral(j, 'cacheGroups'), j.objectExpression([...cacheGroupsProps])));
    }

    // Add new optimizations splitChunks option
    if (root) {
        addOrUpdateConfigObject(j, root, 'optimizations', 'splitChunks', j.objectExpression([...rootProps]));

        Object.keys(optimizationProps).forEach((key: string): void => {
            addOrUpdateConfigObject(j, root, 'optimizations', key, optimizationProps[key]);
        });
    }

    return ast;
}