@plaudit/webpack-extensions 2.89.2 → 3.0.0-rc.2

package/{dist → build}/utils/common-config-helpers.js

@@ -8,21 +8,19 @@ 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 promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
 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), '') || '.';
+        .reduce((res, p) => !res || node_path_1.default.isAbsolute(p) ? p : node_path_1.default.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);
+        const key = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
         let seen = seenPaths.get(key);
         if (seen === undefined) {
             seenPaths.set(key, seen = []);
@@ -36,11 +34,9 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, 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);
+        .map(ep => {
+        const parsedEntrypoint = node_path_1.default.parse(ep);
         const entrypointField = shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'viewScriptModule' : 'script';
-        const { flags: enqueuingFlags, remainder: pathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, ep, 'path query parameters');
         const fakeEntrypointInfo = {
             blockJsonOrigin: args.entrypointJsonOrigin,
             entrypointField,
@@ -49,16 +45,14 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name),
             handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
             dest,
-            absoluteSrc: ep,
-            pathQueryParameters,
-            enqueuingFlags,
+            absoluteSrc: ep
         };
-        return [joinPossiblyAbsolutePaths(dest.destination, (0, node_path_1.basename)(parsedEntrypoint.dir), parsedEntrypoint.name),
+        return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.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 entrypointJsonOrigin = node_path_1.default.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 });
@@ -101,7 +95,7 @@ function determineEntrypointType(entrypoint, scriptExtension) {
     }
 }
 function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
-    const entrypointBasename = entrypointName.substring(0, entrypointName.length - (0, node_path_1.extname)(entrypointName).length);
+    const entrypointBasename = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
     const parts = [];
     if (type) {
         parts.push(type);
@@ -110,7 +104,7 @@ function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
         parts.push(typeCounts[type].toString());
     }
     typeCounts[type] += 1;
-    return `${entrypointBasename}_${parts.join('-')}${(0, node_path_1.extname)(entrypointName)}`;
+    return `${entrypointBasename}_${parts.join('-')}${node_path_1.default.extname(entrypointName)}`;
 }
 function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, scriptExtension) {
     const type = determineEntrypointType(entrypoint, scriptExtension);
@@ -123,9 +117,8 @@ function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, s
 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)) {
+        for await (const dirent of await promises_1.default.opendir(srcRoot)) {
             if (!dirent.isDirectory() || dirent.name.startsWith("~")) {
                 continue;
             }
@@ -134,91 +127,31 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                 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 blockJsonOrigin = node_path_1.default.join(dir, 'block.json');
+                    const blockJson = JSON.parse(await promises_1.default.readFile(blockJsonOrigin, 'utf8'));
+                    const blockJsonChunkName = node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), "block");
                     const presentEntrypoints = (await Promise.all(entrypointFields
                         .filter(entrypointField => 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;
+                            .filter(originalValue => originalValue.startsWith("file:"))
+                            .map(originalValue => {
+                            const entrypointPath = originalValue.substring(5);
+                            const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, entrypointPath));
+                            return promises_1.default.stat(absoluteSrc)
+                                .then(stats => {
+                                if (stats.isFile()) {
+                                    const parsedEntrypoint = node_path_1.default.parse(node_path_1.default.normalize(node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), entrypointPath)));
+                                    const extensionlessExpectedSrc = node_path_1.default.normalize(node_path_1.default.join(parsedEntrypoint.dir, parsedEntrypoint.name));
+                                    const entrypointName = node_path_1.default.normalize(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
+                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc };
                                 }
-                                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, flags } = parsedFilename;
-                        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;
+                                else {
+                                    return undefined;
                                 }
-                                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: undefined
+                            }, () => undefined);
                         });
-                    }
+                    }))).filter(pe => pe !== undefined);
                     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
@@ -229,15 +162,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                     const allocatedDestinations = {};
                     const resolvedBlockEntrypoints = presentEntrypoints
                         .map(presentEntrypoint => {
-                        const overallSource = (0, node_path_1.dirname)(blockJsonOrigin);
-                        const overallSourceRelativeName = (0, node_path_1.relative)(overallSource, (0, node_path_1.normalize)((0, node_path_1.join)(blockJsonOrigin, (0, node_path_1.relative)(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
+                        const overallSource = node_path_1.default.dirname(blockJsonOrigin);
+                        const overallSourceRelativeName = node_path_1.default.relative(overallSource, node_path_1.default.normalize(node_path_1.default.join(blockJsonOrigin, node_path_1.default.relative(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
                         const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
-                        if (presentEntrypoint.handle) {
-                            (seenExplicitHandles[handleGroup][presentEntrypoint.handle] ??= []).push(overallSource);
-                        }
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: presentEntrypoint.handle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
+                            return { blockJsonOrigin, ...presentEntrypoint, handle: `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -252,7 +182,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: presentEntrypoint.handle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`, handleGroup,
+                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`, handleGroup,
                             dest
                         };
                     });
@@ -267,12 +197,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         ];
                     }));
                     rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
-                    wpmlFiles.push((0, node_path_1.join)(dir, 'block.json'));
+                    wpmlFiles.push(node_path_1.default.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'));
+                        const packageJsonOrigin = node_path_1.default.join(dir, 'package.json');
+                        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonOrigin, 'utf8'));
                         if (packageJson['main']) {
                             rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
@@ -291,8 +221,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                 }
                 if (!processingModules) {
                     try {
-                        const wpmlFilePath = (0, node_path_1.join)(dir, "wpml-config.xml");
-                        await (0, promises_1.access)(wpmlFilePath);
+                        const wpmlFilePath = node_path_1.default.join(dir, "wpml-config.xml");
+                        await promises_1.default.access(wpmlFilePath);
                         wpmlFiles.push(wpmlFilePath);
                     }
                     catch (e) {
@@ -304,13 +234,6 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         }
         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) {
@@ -325,10 +248,10 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         }
         if (!processingModules) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
-            const absoluteSrc = (0, node_path_1.join)(srcRoot, "wpml-config.xml");
+            const absoluteSrc = node_path_1.default.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 } };
+                await promises_1.default.access(absoluteSrc);
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.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
@@ -348,14 +271,14 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
     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 (node_path_1.default.basename(wpContentHolderDirectory) === 'wp-content') {
+            wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
             if (wpContentHolderDirectory.length > 5) {
                 viableRoots.push(wpContentHolderDirectory);
             }
             break;
         }
-        wpContentHolderDirectory = (0, node_path_1.dirname)(wpContentHolderDirectory);
+        wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
     }
     const distinctViableRoots = new Set();
     viableRoots = viableRoots.filter(value => distinctViableRoots.has(value) ? false : distinctViableRoots.add(value) && true);
@@ -402,16 +325,16 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
                 ...(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
+                        // 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}`;
+                            const filename = `__${cacheGroupKey}__${node_path_1.default.basename(chunkName)}`;
+                            const dirname = node_path_1.default.dirname(chunkName);
+                            return dirname === '.' ? filename : `${dirname}/${filename}`;
                         }
                     },
                     default: false

package/{dist → build}/wordpress-scripts-wrapper.js

@@ -6,9 +6,7 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const shared_1 = require("./shared");
-const entrypoint_resolution_logic_1 = require("./utils/entrypoint-resolution-logic");
 const common_config_helpers_1 = require("./utils/common-config-helpers");
-const path_query_and_related_helpers_1 = require("./utils/path-query-and-related-helpers");
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
 const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
 const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
@@ -27,7 +25,6 @@ const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
 const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
 const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-empty-scripts"));
-const location_encoding_filename_parser_1 = require("./utils/location-encoding-filename-parser");
 function testForDuplicatedEntryPaths(sources) {
     const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(sources)
         ? sources.map(s => typeof s === 'string' ? s : s[1].destination)
@@ -88,8 +85,8 @@ function replaceDefaultURLProcessing(useWebpackResourceFiltering) {
         return rules;
     };
 }
-function injectPostcssConfigOverrides(rules, config, variables, postcssFunctionsConfig, verbose) {
-    const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(verbose, name => variables(name) ?? (name === 'ENV' ? '' : undefined), postcssFunctionsConfig);
+function injectPostcssConfigOverrides(rules, config, variables, postcssFunctionsConfig) {
+    const postcssConfig = (0, static_configs_1.postcssConfigBuilder)(name => variables(name) ?? (name === 'ENV' ? '' : undefined), postcssFunctionsConfig);
     return recursivelyAddParentDirectoryStepToImagesAndFonts(rules.map(rule => {
         if (rule && typeof rule === 'object') {
             if (Array.isArray(rule.use)) {
@@ -166,7 +163,6 @@ function injectSupportForInliningSVGsAsStrings(rules) {
     });
 }
 function buildVerifiedConfig(config) {
-    config = (0, shared_1.applyStandards)(config);
     const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, processTranslationConfigs = true, combineAssetMetadata = true, useWebpackResourceFiltering = true, plainEntrypointsVersion = 1, srcDir = "", useUnifiedLoader = false, includePostInitFallback = false, omitDistDev = false, onlyRunPostCSSOnPCSS = false } = config;
     let outputDir = config.outputDir ?? "";
     if (outputDir && useUnifiedLoader && !omitDistDev && (process.env['SERVER_MODE'] ?? 'development') === 'development') {
@@ -192,8 +188,22 @@ function buildVerifiedConfig(config) {
             throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
         }
     }
-    const { staticEntrypoints, dynamicEntrypoints } = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(config);
-    const rawSources = [...staticEntrypoints, ...dynamicEntrypoints];
+    const normalizeSrcAndDestination = ([src, dest]) => {
+        if (srcDir) {
+            src = (0, node_path_1.join)(srcDir, src);
+        }
+        src = (0, node_path_1.isAbsolute)(src) ? (0, node_path_1.relative)(process.cwd(), src) : src;
+        if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
+            dest = { ...dest, destination: (0, node_path_1.relative)(process.cwd(), dest.destination) };
+        }
+        return [src, dest];
+    };
+    const rawSources = Array.isArray(config.src)
+        ? config.src.map(s => normalizeSrcAndDestination([s, { destination: s }]))
+        : Object.entries(config.src)
+            .map(([k, v]) => {
+            return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
+        });
     let variablesFilePath = undefined;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
@@ -211,24 +221,29 @@ function buildVerifiedConfig(config) {
     // Destination -> source map
     const allocatedDestinations = {};
     const partiallyVerifiedSources = rawSources.map(rawSource => {
-        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader, pathQueryParameters: rawPathQueryParameters, enqueuingFlags: rawEnqueuingFlags } = rawSource[1];
-        const { flags: queryEnqueuingFlags, remainder: pathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, rawSource[0], 'path query parameters');
-        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(rawSource[0], rawEnqueuingFlags, queryEnqueuingFlags);
+        const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader } = rawSource[1];
         const normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn, lazyLoader };
         const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function'
             ? { handle: rawSource[1].locations } : rawSource[1].locations ?? {};
-        if (typeof locations.registerScriptArgs === 'string' && !['lazy', 'eager', 'inline'].includes(locations.registerScriptArgs)) {
-            throw new ReferenceError("The only supported string values for registerScriptArgs are 'lazy', 'eager', and 'inline'");
+        let normalizedLocations;
+        if ((0, shared_1.isNormalizedUsageLocations)(locations)) {
+            normalizedLocations = locations;
+        }
+        else if (locations.registerScriptArgs === 'lazy') {
+            normalizedLocations = { ...locations, registerScriptArgs: { strategy: 'defer', in_footer: true } };
+        }
+        else {
+            throw new ReferenceError("The only supported string value for registerScript args is 'lazy'");
         }
         if (destination !== undefined) {
             const effectiveDestination = toEffectiveWebpackDestination(destination);
-            allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically declared destinations
-            return [rawSource[0], { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true, pathQueryParameters, enqueuingFlags }];
+            allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically-declared destinations
+            return [rawSource[0], { ...normalizedParts, locations: normalizedLocations, destination, effectiveDestination, staticallyDeclaredDestination: true }];
         }
         else {
             const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(rawSource, srcPrefixes);
             const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [rawSource[0], { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters, enqueuingFlags }];
+            return [rawSource[0], { ...normalizedParts, locations: normalizedLocations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
         }
     });
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
@@ -426,7 +441,7 @@ function commonConfigProcessingPrep(config, webpackConfig) {
     const fixedRules = [
         replaceDefaultURLProcessing(config.useWebpackResourceFiltering),
         (rules) => {
-            return injectPostcssConfigOverrides(rules, config, name => currentVariables[name], config.postcss.functions ?? (() => ({})), config.verbose);
+            return injectPostcssConfigOverrides(rules, config, name => currentVariables[name], config.postcss.functions ?? (() => ({})));
         },
         injectSupportForInliningSVGsAsStrings
     ].reduce((r, a) => a(r), webpackConfig.module?.rules ?? []);
@@ -507,22 +522,12 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 const entry = async () => {
                     const rawEntrypoints = [];
                     for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-                        if (dirent.name.startsWith("~")) {
-                            continue;
-                        }
-                        if (dirent.isFile()) {
-                            if ((commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name))) {
+                        if (dirent.isFile() && !dirent.name.startsWith("~")) {
+                            if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
                                 const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                                const extensionId = (0, node_path_1.parse)(dirent.name).name;
-                                rawEntrypoints.push([(0, node_path_1.join)(dest.destination, (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc))), {
-                                        import: [absoluteSrc],
-                                        plauditMetadata: { dest, absoluteSrc, extensionId }
-                                    }]);
+                                rawEntrypoints.push([(0, node_path_1.join)(dest.destination, (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc))), { import: [absoluteSrc], plauditMetadata: { dest, absoluteSrc } }]);
                             }
                         }
-                        else if (dirent.isDirectory()) {
-                            rawEntrypoints.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, [dirent.name]));
-                        }
                     }
                     return Object.fromEntries(rawEntrypoints);
                 };
@@ -563,7 +568,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
             if (canCopyFiles) {
                 plugins.push(new copy_webpack_plugin_1.default({
                     patterns: [{
-                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)', //TODO: I'm pretty sure that the dots need proper escaping
+                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)',
                             to: dest.destination,
                             context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
                         }]
@@ -574,45 +579,6 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
         return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, externalize, plugins, canClean && batches.length < 2);
     }).filter(cfg => cfg !== undefined);
 }
-async function walkExtensionsTree(srcRoot, dest, parents) {
-    const res = [];
-    for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-        if (dirent.name.startsWith("~")) {
-            continue;
-        }
-        if (dirent.isFile()) {
-            const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilename)(dirent.name);
-            if (parsedFilename === undefined) {
-                continue;
-            }
-            const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-            let destFile;
-            if (Object.keys(parsedFilename.locations).length === 1) {
-                if (parsedFilename.locations.clientView) {
-                    destFile = `view-${parsedFilename.type}`;
-                }
-                else if (parsedFilename.locations.clientEditor) {
-                    destFile = `editor-${parsedFilename.type}`;
-                }
-                else {
-                    destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
-                }
-            }
-            else {
-                destFile = (0, node_path_1.basename)(absoluteSrc, (0, node_path_1.extname)(absoluteSrc));
-            }
-            const extensionId = parents.join("-") + "-" + destFile;
-            res.push([(0, node_path_1.join)(dest.destination, ...parents, destFile), {
-                    import: [absoluteSrc],
-                    plauditMetadata: { dest, absoluteSrc, extensionId }
-                }]);
-        }
-        else if (dirent.isDirectory()) {
-            res.push(...await walkExtensionsTree((0, node_path_1.join)(srcRoot, dirent.name), dest, [...parents, dirent.name]));
-        }
-    }
-    return res;
-}
 function stripExtension(filepath) {
     return (0, node_path_1.join)((0, node_path_1.dirname)(filepath), (0, node_path_1.basename)(filepath, (0, node_path_1.extname)(filepath)));
 }

package/package.json

@@ -1,82 +1,73 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.89.2",
+  "version": "3.0.0-rc.2",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
-    "/dist",
+    "/build",
     "README.md",
     "LICENSE.md",
     "CHANGELOG.md",
     "USER-GUIDE.md"
   ],
   "exports": {
-    "./wordpress-scripts-wrapper": "./dist/wordpress-scripts-wrapper.js",
-    "./location-encoding-filename-parser": "./dist/utils/location-encoding-filename-parser.js",
-    "./shared": "./dist/shared.js"
+    "./wordpress-scripts-wrapper": "./build/wordpress-scripts-wrapper.js",
+    "./shared": "./build/shared.js"
   },
   "typesVersions": {
     "*": {
       "wordpress-scripts-wrapper": [
-        "dist/wordpress-scripts-wrapper.d.ts"
-      ],
-      "location-encoding-filename-parser": [
-        "dist/location-encoding-filename-parser.d.ts"
+        "build/wordpress-scripts-wrapper.d.ts"
       ],
       "shared": [
-        "dist/shared.d.ts"
+        "build/shared.d.ts"
       ]
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.94.1",
+    "@plaudit/gutenberg-api-extensions": "^2.85.0",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^25.6.0",
+    "@types/node": "^25.2.3",
     "@types/postcss-functions": "^4.0.4",
+    "@types/postcss-import": "^14.0.3",
     "@types/tapable": "^2.3.0",
     "@types/webpack-sources": "^3.2.3",
-    "postcss-load-config": "^4.0.2",
-    "postcss-loader": "^7.3.4",
-    "typescript": "^6.0.3",
-    "webpack-bundle-analyzer": "^4.10.2"
+    "typescript": "^5.9.3",
+    "webpack-bundle-analyzer": "^5.2.0"
   },
   "dependencies": {
-    "@plaudit/php-writer": "^1.4.1",
+    "@plaudit/php-writer": "^1.3.3",
     "@plaudit/postcss-color-function": "^5.0.0",
-    "@plaudit/postcss-legacy-shorthand": "^1.0.0",
-    "@plaudit/postcss-silent-extend": "^3.0.0",
     "@plaudit/postcss-strip-units": "^3.0.0",
-    "@plaudit/postcss-variables": "^1.1.0",
-    "@wordpress/dependency-extraction-webpack-plugin": "^6.44.0",
-    "@wordpress/scripts": "^32.0.0",
-    "autoprefixer": "^10.5.0",
+    "@plaudit/postcss-variables": "^2.0.0",
+    "@wordpress/dependency-extraction-webpack-plugin": "^6.39.0",
+    "@wordpress/scripts": "^31.4.0",
+    "autoprefixer": "^10.4.24",
     "browser-sync": "^3.0.4",
     "copy-webpack-plugin": "10.2.4",
-    "css-minimizer-webpack-plugin": "^6.0.0",
+    "css-minimizer-webpack-plugin": "^7.0.4",
+    "cssnano": "^7.1.2",
     "fork-ts-checker-webpack-plugin": "^9.1.0",
     "http-proxy-middleware": "^3.0.5",
     "json2php": "^0.0.12",
-    "postcss": "^8.5.12",
-    "postcss-calc": "^9.0.1",
-    "postcss-discard-comments": "^6.0.2",
+    "postcss": "^8.5.6",
+    "postcss-calc": "^10.1.1",
     "postcss-functions": "^4.0.2",
     "postcss-import": "^16.1.1",
-    "postcss-media-minmax": "^5.0.0",
-    "postcss-mixins": "6.2.3",
-    "postcss-nested": "^6.2.0",
+    "postcss-loader": "^8.2.0",
+    "postcss-mixins": "^12.1.2",
+    "postcss-nested": "^7.0.2",
     "postcss-property-lookup": "^3.0.0",
     "postcss-reporter": "^7.1.0",
-    "postcss-simple-vars": "^7.0.1",
-    "postcss-url": "^10.1.3",
-    "webpack": "^5.106.2",
+    "webpack": "^5.105.2",
     "webpack-remove-empty-scripts": "^1.1.1",
-    "xml-formatter": "^3.7.0"
+    "xml-formatter": "^3.6.7"
   },
   "engines": {
     "node": ">=20"
   },
   "scripts": {
     "build": "tsc",
-    "clean": "rm -rf dist",
+    "clean": "rm -rf build",
     "build:clean": "pnpm run clean && pnpm run build",
     "watch": "tsc -w"
   }

package/dist/plugins/static-configs.d.ts

@@ -1,3 +0,0 @@
-import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import type { PostCSSLoaderOptions } from "postcss-loader/dist/config";
-export declare function postcssConfigBuilder(verbose: boolean, variables: (name: string) => string | undefined, postCSSFunctions: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions']): PostCSSLoaderOptions;