@plaudit/webpack-extensions 2.85.3 → 2.87.0

package/build/utils/path-query-and-related-helpers.d.ts

@@ -1,5 +1,5 @@
 import type { Compilation } from "webpack";
-import { InlinedAsset, PathQueryParameters, ScriptArgsObject, UsageLocations } from "../shared";
+import { InlinedAsset, PathQueryParameters, ScriptArgsObject } from "../shared";
 export declare function getAssetFileContents(compilation: Compilation, name: string): string;
 export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [string, PathQueryParameters | undefined];
 /**
@@ -26,28 +26,32 @@ export declare function newInvalidFetchPriorityError(fetchpriority: unknown, fil
 export type PositionForInlineStrategy = 'before' | 'after';
 export declare function isValidPositionForInlineStrategy(position: unknown): position is PositionForInlineStrategy;
 export declare function newInvalidPositionForInlineStrategyError(position: unknown, file: string): import("webpack").WebpackError;
-export declare function mergeInPathQueryParameters(file: string, registerScriptArgs: UsageLocations['registerScriptArgs'], pathQueryParameters: PathQueryParameters | undefined): NormalizedScriptEnqueuingControlFlags | undefined;
 /**
  * This function ensures that the passed pathQueryParameters are normalized for the config-loading step, NOT the emission step
  */
-export type NormalizedScriptEnqueuingControlFlags = {
+export type NormalizedEnqueuingControlFlags = {
     strategy?: Exclude<LoadingStrategy, 'inline'>;
     in_footer?: InFooter;
     inline?: boolean;
     fetchpriority?: FetchPriority;
     position?: 'before' | 'after';
 };
+export declare function mergeTwoScriptEnqueuingControlFlagSets(file: string, baseArgs: NormalizedEnqueuingControlFlags | undefined, ancestorArgs: NormalizedEnqueuingControlFlags | undefined): NormalizedEnqueuingControlFlags | undefined;
+export declare function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters: PathQueryParameters | undefined, file: string, sourceType: 'registerScriptArgs' | 'path query parameters'): {
+    flags?: NormalizedEnqueuingControlFlags;
+    remainder?: PathQueryParameters;
+};
 /**
  * This function does a few things:
  * <ol>
- *     <li>It extracts inline, position, strategy, in_footer, and fetchpriority from pathQueryParameters</li>
- *     <li>If inline is true or the strategy is, 'inline', it records the contents of the asset for later injection inline and removes the asset from the compilation output</li>
+ *     <li>It converts the strategy, in_footer, and fetchpriority flags into a valid script args object</li>
+ *     <li>If inline is true, it records the contents of the asset and the value of the position flag for later injection and removes the asset from the compilation output</li>
  * </ol>
  * @param compilation
  * @param file
- * @param pathQueryParameters
+ * @param flags
  */
-export declare function parseScriptArgsObjectFromPathQueryParameters(compilation: Compilation, file: string, pathQueryParameters: PathQueryParameters | undefined): {
+export declare function convertEnqueuingControlFlagsToScriptArgsObject(compilation: Compilation, file: string, flags: NormalizedEnqueuingControlFlags | undefined): {
     scriptArgsObject?: ScriptArgsObject;
     inlinedAsset?: InlinedAsset;
 };

package/build/utils/path-query-and-related-helpers.js

@@ -11,8 +11,9 @@ exports.isValidFetchPriority = isValidFetchPriority;
 exports.newInvalidFetchPriorityError = newInvalidFetchPriorityError;
 exports.isValidPositionForInlineStrategy = isValidPositionForInlineStrategy;
 exports.newInvalidPositionForInlineStrategyError = newInvalidPositionForInlineStrategyError;
-exports.mergeInPathQueryParameters = mergeInPathQueryParameters;
-exports.parseScriptArgsObjectFromPathQueryParameters = parseScriptArgsObjectFromPathQueryParameters;
+exports.mergeTwoScriptEnqueuingControlFlagSets = mergeTwoScriptEnqueuingControlFlagSets;
+exports.unpackEnqueuingControlFlagsFromPathQueryParameters = unpackEnqueuingControlFlagsFromPathQueryParameters;
+exports.convertEnqueuingControlFlagsToScriptArgsObject = convertEnqueuingControlFlagsToScriptArgsObject;
 const node_path_1 = require("node:path");
 const shared_1 = require("../shared");
 function getAssetFileContents(compilation, name) {
@@ -101,96 +102,98 @@ function isValidPositionForInlineStrategy(position) {
 function newInvalidPositionForInlineStrategyError(position, file) {
     return (0, shared_1.newWebpackErrorForFile)(`The position value for the inlined asset was invalid. Received: ${position}, Expected: undefined|'before'|'after'`, file);
 }
-function mergeInPathQueryParameters(file, registerScriptArgs, pathQueryParameters) {
-    const baseArgs = unpackRegisterScriptArgsFromPathQueryParameters(typeof registerScriptArgs === 'object' ? registerScriptArgs : { strategy: registerScriptArgs }, file, 'registerScriptArgs');
-    const pathQueryArgs = unpackRegisterScriptArgsFromPathQueryParameters(pathQueryParameters, file, 'path query parameters');
+function mergeTwoScriptEnqueuingControlFlagSets(file, baseArgs, ancestorArgs) {
     if (baseArgs === undefined) {
-        return pathQueryArgs;
+        return ancestorArgs;
     }
-    if (pathQueryArgs === undefined) {
+    if (ancestorArgs === undefined) {
         return baseArgs;
     }
+    // This must be kept in sync with NormalizedScriptEnqueuingControlFlags
     for (const key of ['strategy', 'in_footer', 'fetchpriority', 'inline', 'position']) {
         if (key in baseArgs) {
-            if (key in pathQueryArgs && pathQueryArgs[key] !== baseArgs[key]) {
+            if (key in ancestorArgs && ancestorArgs[key] !== baseArgs[key]) {
                 throw (0, shared_1.newWebpackErrorForFile)(`The ${key} values in the registerScriptArgs and the pathQueryParameters for the file conflict`, file);
             }
         }
-        else if (key in pathQueryArgs) {
-            baseArgs[key] = pathQueryArgs[key];
+        else if (key in ancestorArgs) {
+            baseArgs[key] = ancestorArgs[key];
         }
     }
     return baseArgs;
 }
-function unpackRegisterScriptArgsFromPathQueryParameters(pathQueryParameters, file, sourceType) {
+function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters, file, sourceType) {
     if (pathQueryParameters === undefined) {
-        return undefined;
+        return {};
     }
-    let baseArgs;
-    const strategy = pathQueryParameters['strategy'];
+    const { strategy, in_footer: normalizedInFooter, 'in-footer': alternateInFooter, fetchpriority, position, ...remainder } = pathQueryParameters;
+    let flags;
     switch (strategy) {
         case 'defer':
         case 'async':
-            baseArgs = { strategy };
+            flags = { strategy };
             break;
         case 'eager':
-            baseArgs = { strategy: 'eager' };
+            flags = { strategy: 'eager' };
             break;
         case 'lazy':
-            baseArgs = { strategy: 'defer', in_footer: true };
+            flags = { strategy: 'defer', in_footer: true };
             break;
         case 'inline':
-            baseArgs = { inline: true };
+            flags = { inline: true };
             break;
         case true:
         case false:
-            baseArgs = { in_footer: strategy };
+            flags = { in_footer: strategy };
             break;
         case null:
         case undefined:
-            baseArgs = {};
+            flags = {};
             break;
         default:
             throw newInvalidLoadingStrategyError(strategy, file);
     }
-    if (baseArgs.inline === undefined && pathQueryParameters['inline'] !== undefined) {
-        baseArgs.inline = !!pathQueryParameters['inline'];
+    if (flags.inline === undefined && pathQueryParameters['inline'] !== undefined) {
+        flags.inline = !!pathQueryParameters['inline'];
     }
-    const in_footer = pathQueryParameters['in_footer'] ?? pathQueryParameters['in-footer'];
+    const in_footer = normalizedInFooter ?? alternateInFooter;
     if (in_footer !== undefined) {
         if (!isValidInFooter(in_footer)) {
             throw newInvalidInFooterError(in_footer, file);
         }
-        baseArgs.in_footer = in_footer;
+        flags.in_footer = in_footer;
     }
     if (pathQueryParameters['fetchpriority'] !== undefined) {
         if (!isValidFetchPriority(pathQueryParameters['fetchpriority'])) {
             throw newInvalidFetchPriorityError(pathQueryParameters['fetchpriority'], file);
         }
-        if (baseArgs.fetchpriority !== undefined && baseArgs.fetchpriority !== pathQueryParameters['fetchpriority']) {
+        if (flags.fetchpriority !== undefined && flags.fetchpriority !== pathQueryParameters['fetchpriority']) {
             throw (0, shared_1.newWebpackErrorForFile)(`The strategy and fetchpriority values in the ${sourceType} for the file conflict. Got ${strategy} and ${pathQueryParameters['fetchpriority']}`, file);
         }
-        baseArgs.fetchpriority = pathQueryParameters['fetchpriority'];
+        flags.fetchpriority = pathQueryParameters['fetchpriority'];
     }
-    return Object.keys(baseArgs).length > 0 ? baseArgs : undefined;
+    if (flags.inline && (pathQueryParameters['position'] === 'before' || pathQueryParameters['position'] === 'after')) {
+        flags.position = pathQueryParameters['position'];
+    }
+    return Object.keys(flags).length > 0 ? { flags, remainder } : { remainder };
 }
 /**
  * This function does a few things:
  * <ol>
- *     <li>It extracts inline, position, strategy, in_footer, and fetchpriority from pathQueryParameters</li>
- *     <li>If inline is true or the strategy is, 'inline', it records the contents of the asset for later injection inline and removes the asset from the compilation output</li>
+ *     <li>It converts the strategy, in_footer, and fetchpriority flags into a valid script args object</li>
+ *     <li>If inline is true, it records the contents of the asset and the value of the position flag for later injection and removes the asset from the compilation output</li>
  * </ol>
  * @param compilation
  * @param file
- * @param pathQueryParameters
+ * @param flags
  */
-function parseScriptArgsObjectFromPathQueryParameters(compilation, file, pathQueryParameters) {
-    if (pathQueryParameters === undefined) {
+function convertEnqueuingControlFlagsToScriptArgsObject(compilation, file, flags) {
+    if (flags === undefined) {
         return {};
     }
+    const { strategy, in_footer, inline, position, fetchpriority } = flags;
     const scriptArgsObject = {};
     let inlinedAsset = undefined;
-    const strategy = pathQueryParameters['strategy'];
     switch (strategy) {
         case 'async':
         case 'defer':
@@ -203,13 +206,6 @@ function parseScriptArgsObjectFromPathQueryParameters(compilation, file, pathQue
             scriptArgsObject.strategy = 'defer';
             scriptArgsObject.in_footer = true;
             break;
-        case 'inline':
-            inlinedAsset = { contents: getAssetFileContents(compilation, file) };
-            removeFileAndAssetPHP(compilation, file);
-            if ('inline' in pathQueryParameters) {
-                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("The inline parameter should not be set when setting strategy to 'inline'", file));
-            }
-            break;
         case true:
         case false:
             scriptArgsObject.in_footer = strategy;
@@ -221,23 +217,20 @@ function parseScriptArgsObjectFromPathQueryParameters(compilation, file, pathQue
         default:
             throw newInvalidLoadingStrategyError(strategy, file);
     }
-    const in_footer = pathQueryParameters['in_footer'] ?? pathQueryParameters['in-footer'];
     if (in_footer !== undefined) {
         if (!isValidInFooter(in_footer)) {
             throw newInvalidInFooterError(in_footer, file);
         }
         scriptArgsObject.in_footer = in_footer;
     }
-    if (inlinedAsset === undefined && pathQueryParameters['inline']) {
+    if (inline) {
         inlinedAsset = { contents: getAssetFileContents(compilation, file) };
         removeFileAndAssetPHP(compilation, file);
-    }
-    if (inlinedAsset !== undefined) {
-        if (pathQueryParameters['position'] !== undefined) {
-            if (!isValidPositionForInlineStrategy(pathQueryParameters['position'])) {
-                throw newInvalidPositionForInlineStrategyError(pathQueryParameters['position'], file);
+        if (position !== undefined) {
+            if (!isValidPositionForInlineStrategy(position)) {
+                throw newInvalidPositionForInlineStrategyError(position, file);
             }
-            inlinedAsset.position = pathQueryParameters['position'];
+            inlinedAsset.position = position;
         }
         if (inlinedAsset.position !== 'before' && scriptArgsObject.strategy !== undefined) {
             compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Deferred and async scripts that have inlined JS attached in the 'after' position will cause WordPress to convert all of their dependencies to eager scripts at runtime", file));
@@ -246,7 +239,6 @@ function parseScriptArgsObjectFromPathQueryParameters(compilation, file, pathQue
             scriptArgsObject.in_footer = true;
         }
     }
-    const fetchpriority = pathQueryParameters['fetchpriority'];
     if (fetchpriority !== undefined) {
         if (!isValidFetchPriority(fetchpriority)) {
             throw newInvalidFetchPriorityError(fetchpriority, file);

package/build/wordpress-scripts-wrapper.js

@@ -6,7 +6,9 @@ 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");
@@ -25,7 +27,7 @@ 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 path_query_and_related_helpers_1 = require("./utils/path-query-and-related-helpers");
+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)
@@ -164,6 +166,7 @@ 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') {
@@ -189,23 +192,8 @@ function buildVerifiedConfig(config) {
             throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
         }
     }
-    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)(process.cwd(), src) : src;
-        if (dest.destination !== undefined && (0, node_path_1.isAbsolute)(dest.destination)) {
-            return [src, { ...dest, destination: (0, node_path_1.relative)(process.cwd(), dest.destination), pathQueryParameters }];
-        }
-        return [src, { ...dest, pathQueryParameters }];
-    };
-    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)]);
-        });
+    const { staticEntrypoints, dynamicEntrypoints } = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(config);
+    const rawSources = [...staticEntrypoints, ...dynamicEntrypoints];
     let variablesFilePath = undefined;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
@@ -223,7 +211,9 @@ 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 } = rawSource[1];
+        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.mergeTwoScriptEnqueuingControlFlagSets)(rawSource[0], rawEnqueuingFlags, queryEnqueuingFlags);
         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 ?? {};
@@ -233,12 +223,12 @@ function buildVerifiedConfig(config) {
         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 }];
+            return [rawSource[0], { ...normalizedParts, locations, destination, effectiveDestination, staticallyDeclaredDestination: true, pathQueryParameters, enqueuingFlags }];
         }
         else {
             const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(rawSource, srcPrefixes);
             const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [rawSource[0], { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters }];
+            return [rawSource[0], { ...normalizedParts, locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false, pathQueryParameters, enqueuingFlags }];
         }
     });
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
@@ -517,12 +507,22 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                 const entry = async () => {
                     const rawEntrypoints = [];
                     for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-                        if (dirent.isFile() && !dirent.name.startsWith("~")) {
-                            if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
+                        if (dirent.name.startsWith("~")) {
+                            continue;
+                        }
+                        if (dirent.isFile()) {
+                            if ((commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name))) {
                                 const absoluteSrc = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.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 } }]);
+                                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 }
+                                    }]);
                             }
                         }
+                        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 +563,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)',
+                            from: config.standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)', //TODO: I'm pretty sure that the dots need proper escaping
                             to: dest.destination,
                             context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
                         }]
@@ -574,6 +574,45 @@ 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,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.85.3",
+  "version": "2.87.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build",
@@ -11,6 +11,7 @@
   ],
   "exports": {
     "./wordpress-scripts-wrapper": "./build/wordpress-scripts-wrapper.js",
+    "./location-encoding-filename-parser": "./build/utils/location-encoding-filename-parser.js",
     "./shared": "./build/shared.js"
   },
   "typesVersions": {
@@ -18,6 +19,9 @@
       "wordpress-scripts-wrapper": [
         "build/wordpress-scripts-wrapper.d.ts"
       ],
+      "location-encoding-filename-parser": [
+        "build/location-encoding-filename-parser.d.ts"
+      ],
       "shared": [
         "build/shared.d.ts"
       ]
@@ -26,7 +30,7 @@
   "devDependencies": {
     "@plaudit/gutenberg-api-extensions": "^2.87.0",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^25.3.5",
+    "@types/node": "^25.5.0",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.3.0",
     "@types/webpack-sources": "^3.2.3",
@@ -65,7 +69,7 @@
     "postcss-url": "^10.1.3",
     "webpack": "^5.105.4",
     "webpack-remove-empty-scripts": "^1.1.1",
-    "xml-formatter": "^3.6.7"
+    "xml-formatter": "^3.7.0"
   },
   "engines": {
     "node": ">=20"