@plaudit/webpack-extensions 3.21.2 → 4.0.0-rc.1

package/dist/utils/common-config-helpers.js

@@ -1,489 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinPossiblyAbsolutePaths = joinPossiblyAbsolutePaths;
-exports.groupEntrypointsByAssetFile = groupEntrypointsByAssetFile;
-exports.resolveEntryFromDirectory = resolveEntryFromDirectory;
-exports.commonMakeWebpackConfig = commonMakeWebpackConfig;
-const node_fs_1 = __importDefault(require("node:fs"));
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const location_encoding_filename_parser_1 = require("./location-encoding-filename-parser");
-const path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
-const shared_1 = require("../shared");
-const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-webpack-plugin"));
-function joinPossiblyAbsolutePaths(...paths) {
-    return paths.filter((p) => !!p)
-        .reduce((res, p) => !res || (0, node_path_1.isAbsolute)(p) ? p : (0, node_path_1.join)(res, p), '') || '.';
-}
-function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
-    const seenPaths = new Map();
-    for (const entrypoint of entrypoints) {
-        const entrypointName = entrypointNameExtractor(entrypoint);
-        const key = entrypointName.substring(0, entrypointName.length - (0, node_path_1.extname)(entrypointName).length);
-        let seen = seenPaths.get(key);
-        if (seen === undefined) {
-            seenPaths.set(key, seen = []);
-        }
-        seen.push(entrypoint);
-    }
-    return seenPaths;
-}
-function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
-    const { mapper = ep => ep, dest } = args;
-    return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
-        .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
-        .filter(ep => supportedExtensions(ep) && node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
-        .map(path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)
-        .map(([ep, rawPathQueryParameters]) => {
-        const parsedEntrypoint = (0, node_path_1.parse)(ep);
-        const entrypointField = shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'viewScriptModule' : 'script';
-        const { flags: enqueuingFlags, remainder: pathQueryParameters, handle } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, ep, 'path query parameters');
-        const fakeEntrypointInfo = {
-            blockJsonOrigin: args.entrypointJsonOrigin,
-            entrypointField,
-            originalValue: ep,
-            entrypointName: parsedEntrypoint.name,
-            handle: handle ?? dest.locations.handle ? (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handle ?? dest.locations.handle, parsedEntrypoint.name, parsedEntrypoint.name) : parsedEntrypoint.name,
-            handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
-            dest,
-            absoluteSrc: ep,
-            pathQueryParameters,
-            enqueuingFlags,
-        };
-        return [joinPossiblyAbsolutePaths(dest.destination, (0, node_path_1.basename)(parsedEntrypoint.dir), parsedEntrypoint.name),
-            { import: [ep], plauditMetadata: fakeEntrypointInfo }];
-    });
-}
-function parseEntrypointsJSON(dir, dest, supportedExtensions) {
-    const entrypointJsonOrigin = (0, node_path_1.join)(dir, 'entrypoints.json');
-    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(entrypointJsonOrigin, 'utf8'));
-    if (Array.isArray(entrypointsJSON)) {
-        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { dest, entrypointJsonOrigin });
-    }
-    else {
-        return Object.entries(entrypointsJSON).flatMap(([name, config]) => {
-            if (Array.isArray(config)) {
-                return config.flatMap(c => mapToRealEntrypoints(c, dir, supportedExtensions, { dest, entrypointJsonOrigin }));
-            }
-            else {
-                return [[name, config]];
-                /* TODO: Fix compat with entrypoints.json in object mode
-                if (typeof config.import === 'string') {
-                    config.import = joinPossiblyAbsolutePaths(dir, config.import);
-                } else {
-                    config.import = config.import.map(c => joinPossiblyAbsolutePaths(dir, c));
-                }
-                return [name, config];
-                */
-            }
-        });
-    }
-}
-function determineEntrypointType(entrypoint, scriptExtension) {
-    let res = (0, shared_1.scriptOrStyleTest)(entrypoint[0], scriptExtension);
-    if (res) {
-        return res;
-    }
-    if (typeof entrypoint[1] === 'string') {
-        return (0, shared_1.scriptOrStyleTest)(entrypoint[1], scriptExtension);
-    }
-    else if (Array.isArray(entrypoint[1])) {
-        return entrypoint[1].reduce((prior, ep) => prior || (0, shared_1.scriptOrStyleTest)(ep, scriptExtension), "");
-    }
-    else if (typeof entrypoint[1].import === 'string') {
-        return (0, shared_1.scriptOrStyleTest)(entrypoint[1].import, scriptExtension);
-    }
-    else {
-        return entrypoint[1].import.reduce((prior, ep) => prior || (0, shared_1.scriptOrStyleTest)(ep, scriptExtension), "");
-    }
-}
-function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
-    const entrypointBasename = entrypointName.substring(0, entrypointName.length - (0, node_path_1.extname)(entrypointName).length);
-    const parts = [];
-    if (type) {
-        parts.push(type);
-    }
-    if (typeCounts[type] ?? (typeCounts[type] = 0)) {
-        parts.push(typeCounts[type].toString());
-    }
-    typeCounts[type] += 1;
-    return `${entrypointBasename}_${parts.join('-')}${(0, node_path_1.extname)(entrypointName)}`;
-}
-function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, scriptExtension) {
-    const type = determineEntrypointType(entrypoint, scriptExtension);
-    let potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
-    while (entry[potentialKey]) {
-        potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
-    }
-    entry[potentialKey] = entrypoint[1];
-}
-function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
-    const { entrypointFields, processingModules, scriptExtension } = commonConfig;
-    return async () => {
-        const seenExplicitHandles = { scriptHandles: {}, styleHandles: {}, scriptModuleHandles: {} };
-        const loadingEntrypoints = [];
-        for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-            if (!dirent.isDirectory() || (0, shared_1.shouldBeSkipped)(dirent.name)) {
-                continue;
-            }
-            const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
-            loadingEntrypoints.push(new Promise(async (resolve) => {
-                const rawEntrypoints = [];
-                const wpmlFiles = [];
-                try {
-                    const blockJsonOrigin = (0, node_path_1.join)(dir, 'block.json');
-                    const blockJson = JSON.parse(await (0, promises_1.readFile)(blockJsonOrigin, 'utf8'));
-                    const blockJsonChunkName = (0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), "block");
-                    const filesRegisteredByJson = [];
-                    const presentEntrypoints = (await Promise.all(entrypointFields
-                        .filter(entrypointField => (0, shared_1.isScriptModuleField)(entrypointField) === processingModules && entrypointField in blockJson)
-                        .flatMap(entrypointField => {
-                        return (Array.isArray(blockJson[entrypointField]) ? blockJson[entrypointField] : [blockJson[entrypointField]])
-                            .filter(originalValue => typeof originalValue === 'string')
-                            .filter(originalValue => originalValue?.startsWith("file:"))
-                            .map(async (originalValue) => {
-                            const [entrypointPath, rawLocalPathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(originalValue);
-                            const absoluteSrc = (0, node_path_1.normalize)((0, node_path_1.join)(dir, entrypointPath));
-                            filesRegisteredByJson.push(absoluteSrc);
-                            const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilenameForBlock)(absoluteSrc);
-                            const { flags: localEnqueuingFlags, handle, remainder: localPathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawLocalPathQueryParameters, absoluteSrc, "path query parameters");
-                            const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(absoluteSrc, localEnqueuingFlags, parsedFilename?.flags, dest.enqueuingFlags);
-                            const pathQueryParameters = { ...dest.pathQueryParameters, ...localPathQueryParameters };
-                            try {
-                                const stats = await (0, promises_1.stat)(absoluteSrc);
-                                if (!stats.isFile()) {
-                                    return undefined;
-                                }
-                                //TODO: Handle alternate methods of declaring a handle
-                                const parsedEntrypoint = (0, node_path_1.parse)((0, node_path_1.normalize)((0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), entrypointPath)));
-                                const extensionlessExpectedSrc = (0, node_path_1.normalize)((0, node_path_1.join)(parsedEntrypoint.dir, parsedEntrypoint.name));
-                                const entrypointName = (0, node_path_1.normalize)(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
-                                return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc, pathQueryParameters, enqueuingFlags, handle };
-                            }
-                            catch {
-                                return undefined;
-                            }
-                        });
-                    })))
-                        .filter(pe => pe !== undefined);
-                    for await (const dirent of await (0, promises_1.opendir)(dir)) {
-                        if (!dirent.isFile()) {
-                            continue;
-                        }
-                        const absoluteSrc = (0, node_path_1.normalize)((0, node_path_1.join)(dir, dirent.name));
-                        if (filesRegisteredByJson.includes(absoluteSrc)) {
-                            continue;
-                        }
-                        const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilenameForBlock)(absoluteSrc);
-                        if (!parsedFilename) {
-                            continue;
-                        }
-                        const { type, locations, handle, flags } = parsedFilename;
-                        if (((type === 'script-module') !== processingModules)) {
-                            continue;
-                        }
-                        let entrypointField;
-                        if (Object.keys(locations).length === 2) {
-                            if (type === 'script-module') {
-                                console.error(`Blocks cannot have script modules enqueued in editor mode. Found one enqueued in both editor and view in ${dirent.parentPath}. It will be enqueued in view alone.`);
-                                entrypointField = 'viewScriptModule';
-                            }
-                            else {
-                                entrypointField = type;
-                            }
-                        }
-                        else {
-                            const location = (0, shared_1.constantKeys)(locations)[0];
-                            if (type === 'script-module') {
-                                if (location !== 'clientView') {
-                                    console.error(`Blocks cannot have script modules enqueued in editor mode. Found one in ${dirent.parentPath}. It will be ignored`);
-                                    continue;
-                                }
-                                entrypointField = 'viewScriptModule';
-                            }
-                            else {
-                                entrypointField = (location.substring(6).toLowerCase() + type.substring(0, 1).toUpperCase() + type.substring(1));
-                            }
-                        }
-                        const parsedEntrypoint = (0, node_path_1.parse)((0, node_path_1.normalize)((0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), `./${dirent.name}`)));
-                        const extensionlessExpectedSrc = (0, node_path_1.normalize)((0, node_path_1.join)(parsedEntrypoint.dir, parsedEntrypoint.name));
-                        const entrypointName = (0, node_path_1.normalize)(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
-                        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(absoluteSrc, flags, dest.enqueuingFlags);
-                        presentEntrypoints.push({
-                            entrypointField,
-                            originalValue: dirent.name,
-                            entrypointName,
-                            extensionlessExpectedSrc,
-                            absoluteSrc,
-                            pathQueryParameters: dest.pathQueryParameters,
-                            enqueuingFlags,
-                            handle
-                        });
-                    }
-                    const entrypointNamesWithEffectiveDuplicates = presentEntrypoints
-                        .reduce((a, entry) => {
-                        // If it's undefined, then this is the first instance, otherwise, it's not the first instance and, therefore, is expected to be a duplicate
-                        a[entry.entrypointName] = (a[entry.entrypointName] !== undefined);
-                        return a;
-                    }, {});
-                    const getDefaultHandle = (presentEntrypoint) => {
-                        const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
-                        let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
-                        while (((deduplicatedEntrypointName = (presentEntrypoint.entrypointName + suffix)) in allocatedDestinations)
-                            && allocatedDestinations[deduplicatedEntrypointName] !== presentEntrypoint.originalValue) {
-                            suffix = baseSuffix + "_" + (++count);
-                        }
-                        return { count, suffix, deduplicatedEntrypointName };
-                    };
-                    const handlePrefix = blockJson['name']?.toString() ?? `__UNKNOWN_PREFIX__/${dirent.name}`;
-                    const allocatedDestinations = {};
-                    const resolvedBlockEntrypoints = presentEntrypoints
-                        .map(presentEntrypoint => {
-                        const overallSource = (0, node_path_1.dirname)(blockJsonOrigin);
-                        // The handle suffix is the asset's extensionless name relative to its own block, so it
-                        // has to come off the real on-disk path rather than the destination-relative expected src.
-                        const parsedAbsoluteSrc = (0, node_path_1.parse)(presentEntrypoint.absoluteSrc);
-                        const overallSourceRelativeName = (0, node_path_1.normalize)((0, node_path_1.join)((0, node_path_1.relative)(overallSource, parsedAbsoluteSrc.dir), parsedAbsoluteSrc.name));
-                        const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
-                        let explicitlySetHandle;
-                        if (presentEntrypoint.handle) {
-                            if (typeof presentEntrypoint.handle === 'string') {
-                                explicitlySetHandle = presentEntrypoint.handle;
-                            }
-                            else if ('niceName' in presentEntrypoint.handle) {
-                                explicitlySetHandle = `${handlePrefix}/${presentEntrypoint.handle.niceName}`;
-                            }
-                            else {
-                                explicitlySetHandle = presentEntrypoint.handle(`${handlePrefix}/${getDefaultHandle(presentEntrypoint)}`);
-                            }
-                            if (explicitlySetHandle.length < 5) {
-                                throw (0, shared_1.newWebpackErrorForFile)(`The handle was invalid. Received: ${explicitlySetHandle}. Expected: a string that is at least 5 characters long`, overallSourceRelativeName);
-                            }
-                            (seenExplicitHandles[handleGroup][explicitlySetHandle] ??= []).push(overallSource);
-                        }
-                        else {
-                            explicitlySetHandle = undefined;
-                        }
-                        const emittableHandle = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, handlePrefix, explicitlySetHandle ? explicitlySetHandle.substring(handlePrefix.length + 1) : overallSourceRelativeName);
-                        if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: emittableHandle, dest, handleGroup };
-                        }
-                        const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
-                        let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
-                        while (((deduplicatedEntrypointName = (presentEntrypoint.entrypointName + suffix)) in allocatedDestinations)
-                            && allocatedDestinations[deduplicatedEntrypointName] !== presentEntrypoint.originalValue) {
-                            suffix = baseSuffix + "_" + (++count);
-                        }
-                        allocatedDestinations[deduplicatedEntrypointName] = presentEntrypoint.originalValue;
-                        const deduplicatedExtensionlessExpectedSrc = presentEntrypoint.extensionlessExpectedSrc + suffix;
-                        return {
-                            blockJsonOrigin,
-                            ...presentEntrypoint,
-                            entrypointName: deduplicatedEntrypointName,
-                            extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: emittableHandle,
-                            handleGroup,
-                            dest
-                        };
-                    });
-                    rawEntrypoints.push(...resolvedBlockEntrypoints
-                        .map(resolvedBlockEntrypoint => {
-                        return [
-                            resolvedBlockEntrypoint.entrypointName,
-                            {
-                                import: [resolvedBlockEntrypoint.absoluteSrc],
-                                plauditMetadata: resolvedBlockEntrypoint
-                            }
-                        ];
-                    }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
-                    wpmlFiles.push((0, node_path_1.join)(dir, 'block.json'));
-                }
-                catch (e) {
-                    try {
-                        const packageJsonOrigin = (0, node_path_1.join)(dir, 'package.json');
-                        const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonOrigin, 'utf8'));
-                        if (packageJson['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, s => commonConfig.scriptExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
-                        }
-                        if (!processingModules && packageJson['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, s => shared_1.styleExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
-                        }
-                    }
-                    catch (e) {
-                        try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || (!processingModules && shared_1.styleExtension.test(ep))));
-                        }
-                        catch (e) {
-                            // This just means that the directory doesn't contain any declared entrypoints.
-                        }
-                    }
-                }
-                if (!processingModules) {
-                    try {
-                        const wpmlFilePath = (0, node_path_1.join)(dir, "wpml-config.xml");
-                        await (0, promises_1.access)(wpmlFilePath);
-                        wpmlFiles.push(wpmlFilePath);
-                    }
-                    catch (e) {
-                        // This just means that the file doesn't exist
-                    }
-                }
-                resolve([rawEntrypoints, wpmlFiles]);
-            }));
-        }
-        const allEntrypoints = await Promise.all(loadingEntrypoints);
-        const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(allEntrypoints.flatMap(e => e[0]), e => e[0]);
-        const conflictingHandles = Object.values(seenExplicitHandles)
-            .flatMap(handles => Object.entries(handles))
-            .filter(([, sources]) => sources.length > 1)
-            .map(([handle, sources]) => `${handle}: ${sources.join(", ")}`);
-        if (conflictingHandles.length > 0) {
-            throw (0, shared_1.newCleanWebpackError)("Encountered conflicting explicitly-set handles:\n" + conflictingHandles.join("\n"));
-        }
-        const currentEntry = {};
-        for (const groupedEntrypoints of perAssetPathGroupedEntrypoints.values()) {
-            if (groupedEntrypoints.length === 1 && groupedEntrypoints[0] !== undefined) {
-                currentEntry[groupedEntrypoints[0][0]] = groupedEntrypoints[0][1];
-            }
-            else {
-                const typeCounts = {};
-                for (const entrypoint of groupedEntrypoints) {
-                    addPotentiallyDuplicatedEntrypointName(currentEntry, entrypoint, typeCounts, scriptExtension);
-                }
-            }
-        }
-        if (!processingModules) {
-            const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
-            const absoluteSrc = (0, node_path_1.join)(srcRoot, "wpml-config.xml");
-            try {
-                await (0, promises_1.access)(absoluteSrc);
-                currentEntry["wpml-config.xml"] = { import: [(0, node_path_1.join)(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: { purpose: "wpml-config-xml", dest, absoluteSrc } };
-            }
-            catch (e) {
-                // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
-                if (wpmlEntrypointFiles.length) {
-                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: { purpose: "wpml-config-xml", dest, absoluteSrc } };
-                }
-            }
-        }
-        return currentEntry;
-    };
-}
-function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externalize, plugins, canClean) {
-    const { variablesFilePath } = config;
-    const { fixedRules, processingModules, updateCurrentVariables } = commonConfig;
-    const outPath = joinPossiblyAbsolutePaths(process.cwd(), config.outputDir);
-    let publicPath = webpackConfig.output?.publicPath;
-    let viableRoots = [...(Array.isArray(webpackConfig.context) ? webpackConfig.context : [webpackConfig.context ?? process.cwd()])];
-    let wpContentHolderDirectory = process.cwd();
-    while (wpContentHolderDirectory.length > 5) {
-        if ((0, node_path_1.basename)(wpContentHolderDirectory) === 'wp-content') {
-            wpContentHolderDirectory = (0, node_path_1.dirname)(wpContentHolderDirectory);
-            if (wpContentHolderDirectory.length > 5) {
-                viableRoots.push(wpContentHolderDirectory);
-            }
-            break;
-        }
-        wpContentHolderDirectory = (0, node_path_1.dirname)(wpContentHolderDirectory);
-    }
-    const distinctViableRoots = new Set();
-    viableRoots = viableRoots.filter(value => distinctViableRoots.has(value) ? false : distinctViableRoots.add(value) && true);
-    let outputLibrary;
-    if (externalize) {
-        if (Array.isArray(externalize) || typeof externalize === 'string') {
-            outputLibrary = {
-                name: externalize,
-                type: "window"
-            };
-        }
-        else {
-            const originalLibrary = webpackConfig.output?.library;
-            if (originalLibrary && typeof originalLibrary === 'object' && !Array.isArray(originalLibrary)) {
-                outputLibrary = {
-                    ...originalLibrary,
-                    ...externalize
-                };
-            }
-            else {
-                outputLibrary = externalize;
-            }
-        }
-    }
-    else {
-        outputLibrary = webpackConfig.output?.library;
-    }
-    const extensions = processingModules ? ['.mjsx', '.mjs', '.mtsx', '.mts', '...'] : ['.jsx', '.tsx', '.ts', '...'];
-    // `dist` (SERVER_MODE=production, or omitDistDev) is always minified production. `dist-dev` follows NODE_ENV so `wp-scripts start` stays fast.
-    const isProductionBuild = !(0, shared_1.isDistDevOutputPath)(config.outputDir) || process.env['NODE_ENV'] === 'production';
-    return {
-        ...webpackConfig,
-        devtool: isProductionBuild ? 'source-map' : (webpackConfig.devtool ?? 'eval-cheap-module-source-map'),
-        mode: isProductionBuild ? 'production' : 'development',
-        output: {
-            ...webpackConfig.output,
-            path: outPath,
-            chunkFilename: 'webpack-chunks/[id].js',
-            publicPath: publicPath,
-            library: outputLibrary,
-            clean: canClean ? webpackConfig.output?.clean : false
-        },
-        optimization: {
-            ...webpackConfig.optimization,
-            minimize: isProductionBuild,
-            splitChunks: {
-                ...(webpackConfig.optimization?.splitChunks || {}),
-                cacheGroups: {
-                    style: {
-                        // This is a flagrant abuse of cache groups, but it fixes a persistent problem wherein the dependencies and versions of scripts and styles were bleeding into each other
-                        type: 'css/mini-extract',
-                        chunks: 'all',
-                        enforce: true,
-                        name(_, chunks, cacheGroupKey) {
-                            const chunkName = chunks.find(chunk => chunk.name)?.name;
-                            // We use "__${cacheGroupKey}__" instead of "${cacheGroupKey}-" to make it easier to remove when generating the filename
-                            const filename = `__${cacheGroupKey}__${(0, node_path_1.basename)(chunkName)}`;
-                            const chunkDirname = (0, node_path_1.dirname)(chunkName);
-                            return chunkDirname === '.' ? filename : `${chunkDirname}/${filename}`;
-                        }
-                    },
-                    default: false
-                }
-            },
-            minimizer: isProductionBuild
-                ? [
-                    ...(webpackConfig.optimization?.minimizer || []),
-                    new css_minimizer_webpack_plugin_1.default()
-                ]
-                : webpackConfig.optimization?.minimizer
-        },
-        module: {
-            ...webpackConfig.module,
-            rules: fixedRules
-        },
-        resolve: {
-            ...webpackConfig.resolve,
-            roots: viableRoots,
-            extensions
-        },
-        stats: config.stats,
-        plugins,
-        entry() {
-            if (variablesFilePath) {
-                delete require.cache[require.resolve(variablesFilePath)];
-                updateCurrentVariables(require(variablesFilePath));
-            }
-            return {};
-        },
-        performance: {
-            ...webpackConfig.performance,
-            assetFilter(assetFilename) {
-                // We don't want to warn about the sizes of incompressible assets
-                return !/\.(map|svg|png|jpe?g|gif)$/i.test(assetFilename);
-            }
-        }
-    };
-}

package/dist/utils/css-writer.d.ts

@@ -1,4 +0,0 @@
-export type WritableCSSObject = {
-    [property: string]: string | WritableCSSObject;
-};
-export declare function convertToCSS(writableCSSObject: WritableCSSObject, pretty?: string | boolean): string;

package/dist/utils/css-writer.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToCSS = convertToCSS;
-function convertToCSS(writableCSSObject, pretty = true) {
-    if (typeof pretty === 'string') {
-        return convertToCSSPretty(writableCSSObject, pretty);
-    }
-    else if (pretty) {
-        return convertToCSSPretty(writableCSSObject, "");
-    }
-    else {
-        return convertToCSSUgly(writableCSSObject);
-    }
-}
-function convertToCSSPretty(writableCSSObject, indentation) {
-    let res = "";
-    const entries = Object.entries(writableCSSObject)
-        .sort(([a], [b]) => a.localeCompare(b));
-    for (const [selectorOrAttribute, value] of entries) {
-        res += `${indentation}${selectorOrAttribute}`;
-        if (typeof value === 'string') {
-            res += `: ${value};\n`;
-        }
-        else {
-            res += " {\n";
-            res += convertToCSSPretty(value, indentation + "\t");
-            res += indentation + "}\n";
-        }
-    }
-    return res;
-}
-function convertToCSSUgly(writableCSSObject) {
-    let res = "";
-    const entries = Object.entries(writableCSSObject)
-        .sort(([a], [b]) => a.localeCompare(b));
-    for (const [selectorOrAttribute, value] of entries) {
-        res += selectorOrAttribute;
-        if (typeof value === 'string') {
-            res += `:${value};`;
-        }
-        else {
-            res += "{" + convertToCSSUgly(value) + "}";
-        }
-    }
-    return res;
-}

package/dist/utils/entrypoint-resolution-logic.d.ts

@@ -1,13 +0,0 @@
-import { type AdvancedOutputConfig, type PathQueryParameters, type PlauditWordpressWebpackConfig } from "../shared";
-export declare const enum SourceType {
-    blocks = "blocks",
-    extensions = "extensions",
-    plain = "plain"
-}
-export declare function isSourceType(str: string): str is SourceType;
-type ResolvedSourceConfig = AdvancedOutputConfig & {
-    pathQueryParameters?: PathQueryParameters;
-};
-type Entrypoints = [string, ResolvedSourceConfig][];
-export declare function resolveAllConfigLevelEntrypoints(config: PlauditWordpressWebpackConfig, projectRoot?: string): Record<'staticEntrypoints' | 'dynamicEntrypoints', Entrypoints>;
-export {};

package/dist/utils/entrypoint-resolution-logic.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSourceType = isSourceType;
-exports.resolveAllConfigLevelEntrypoints = resolveAllConfigLevelEntrypoints;
-const node_path_1 = require("node:path");
-const location_encoding_filename_parser_1 = require("./location-encoding-filename-parser");
-const path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
-const shared_1 = require("../shared");
-function isSourceType(str) {
-    return str === "blocks" /* SourceType.blocks */ || str === "extensions" /* SourceType.extensions */ || str === "plain" /* SourceType.plain */;
-}
-function resolveAllConfigLevelEntrypoints(config, projectRoot = process.cwd()) {
-    const srcDir = config.srcDir ?? "";
-    const normalizeSrcAndDestination = ([rawSrc, dest]) => {
-        let [src, pathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(rawSrc);
-        if (srcDir) {
-            src = (0, node_path_1.join)(srcDir, src);
-        }
-        src = (0, node_path_1.isAbsolute)(src) ? (0, node_path_1.relative)(projectRoot, src) : src;
-        let resultObject;
-        if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
-            resultObject = { ...dest, destination: (0, node_path_1.relative)(projectRoot, dest.destination) };
-        }
-        else {
-            resultObject = { ...dest };
-        }
-        return [src, pathQueryParameters ? { ...resultObject, pathQueryParameters } : resultObject];
-    };
-    if (Array.isArray(config.src)) {
-        return {
-            staticEntrypoints: config.src.map(s => normalizeSrcAndDestination([s, { destination: s }])),
-            dynamicEntrypoints: []
-        };
-    }
-    else {
-        const configSrc = config.src ?? {};
-        // We check for files with location-encoding filenames and add the pertinent ones to the sources
-        const dynamicallyIncludedEntrypoints = [];
-        if (srcDir) { // This will only work if we have a unified src root
-            const dynamicallyIncludedEntrypointsRoot = (0, node_path_1.isAbsolute)(srcDir) ? srcDir : (0, node_path_1.join)(projectRoot, srcDir);
-            for (const dirent of (0, shared_1.synchronousDirIterator)(dynamicallyIncludedEntrypointsRoot)) {
-                if (dirent.name in configSrc || `./${dirent.name}` in configSrc) {
-                    continue;
-                }
-                if (dirent.isDirectory()) {
-                    // If it's a directory that does not have an existing config entry, but does correspond to one of the non-plain SourceTypes, assume that it matches that source type
-                    if (isSourceType(dirent.name) && dirent.name !== "plain" /* SourceType.plain */) {
-                        dynamicallyIncludedEntrypoints.push([dirent.name, { directoryLayout: dirent.name }]);
-                        continue;
-                    }
-                    for (const nestedDirent of (0, shared_1.synchronousDirIterator)((0, node_path_1.join)(dynamicallyIncludedEntrypointsRoot, dirent.name))) {
-                        if (!nestedDirent.isFile()) {
-                            continue;
-                        }
-                        const cfgName = (0, node_path_1.join)(dirent.name, nestedDirent.name);
-                        if (cfgName in configSrc || `./${cfgName}` in configSrc) {
-                            continue;
-                        }
-                        const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(cfgName);
-                        if (parsedFilename === undefined) {
-                            continue;
-                        }
-                        dynamicallyIncludedEntrypoints.push([cfgName, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
-                    }
-                }
-                else if (dirent.isFile()) {
-                    const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
-                    if (parsedFilename === undefined) {
-                        continue;
-                    }
-                    dynamicallyIncludedEntrypoints.push([dirent.name, { locations: parsedFilename.locations, enqueuingFlags: parsedFilename.flags }]);
-                }
-            }
-        }
-        return {
-            staticEntrypoints: Object.entries(configSrc).map(([k, v]) => {
-                return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
-            }),
-            dynamicEntrypoints: dynamicallyIncludedEntrypoints.map(normalizeSrcAndDestination)
-        };
-    }
-}