@plaudit/webpack-extensions 2.85.3 → 2.87.0

package/build/shared.d.ts

@@ -1,6 +1,9 @@
 import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
 import { AssetInfo, Compilation, Configuration, Entrypoint, WebpackError, Compiler } from "webpack";
+import { SourceType } from "./utils/entrypoint-resolution-logic";
+import type { NormalizedEnqueuingControlFlags } from "./utils/path-query-and-related-helpers";
+export * from "./utils/entrypoint-resolution-logic";
 export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
@@ -54,16 +57,19 @@ export type StandardLocationNameMeta = {
     };
 };
 export type StandardLocationNames = keyof typeof standardLocationNamesMeta;
+export declare function isStandardLocationName(name: string): name is StandardLocationNames;
 type LocationWithHookNameSupport = boolean | number | string | string[] | {
     hook_name?: string | string[];
     priority?: number;
 };
 type InputRegisterScriptArgs = ScriptArgsObject | boolean | 'lazy' | 'eager' | 'inline';
-export type UsageLocations = {
+export declare function isRegisterScriptArgsShorthandName(name: string): name is Extract<InputRegisterScriptArgs, string>;
+export type RealUsageLocations = {
     [K in StandardLocationNames]?: typeof standardLocationNamesMeta[K] extends {
         supports_hook_name: true;
     } ? LocationWithHookNameSupport : boolean | number;
-} & {
+};
+export type UsageLocations = RealUsageLocations & {
     register?: boolean | number;
     inline?: number;
     handle?: string | ((generatedHandle: string) => string);
@@ -74,16 +80,11 @@ export type NormalizedUsageLocations = Omit<UsageLocations, 'registerScriptArgs'
 };
 export declare function isNormalizedUsageLocations(usageLocations: UsageLocations): usageLocations is NormalizedUsageLocations;
 export declare function constantKeys<K extends string, V>(object: {
-    [k in K]: V;
+    [k in K]?: V;
 }): K[];
 export declare function constantEntries<K extends string, V>(object: {
     [k in K]: V;
 }): [K, V][];
-export declare const enum SourceType {
-    blocks = "blocks",
-    extensions = "extensions",
-    plain = "plain"
-}
 export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
 export interface WebpackPlugin {
     apply(compiler: Compiler): void;
@@ -107,17 +108,20 @@ export type AdvancedOutputConfig = {
     locations?: UsageLocations | UsageLocations['handle'];
     lazyLoader?: string;
     pathQueryParameters?: PathQueryParameters;
+    enqueuingFlags?: NormalizedEnqueuingControlFlags;
 };
 type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader' | 'pathQueryParameters';
-export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
+export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | 'enqueuingFlags' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
+    enqueuingFlags: NormalizedEnqueuingControlFlags | undefined;
     locations: NormalizedUsageLocations;
 };
 export type SourcesObject = Record<string, string | AdvancedOutputConfig | boolean>;
 export type PlauditWordpressWebpackConfig = {
+    standard?: '2026-03-13';
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
     verbose?: boolean;
-    src: string[] | SourcesObject;
+    src?: string[] | SourcesObject;
     stats?: Configuration['stats'];
     postcss?: {
         functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions'];
@@ -138,6 +142,41 @@ export type PlauditWordpressWebpackConfig = {
     omitDistDev?: boolean;
     onlyRunPostCSSOnPCSS?: boolean;
 };
+export declare function applyStandards(config: PlauditWordpressWebpackConfig): {
+    readonly standard?: "2026-03-13";
+    readonly standaloneBlocks?: boolean;
+    readonly variables?: Record<string, any>;
+    readonly verbose?: boolean;
+    readonly src?: string[] | SourcesObject;
+    readonly stats?: Configuration["stats"];
+    readonly postcss?: {
+        functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions["functions"];
+    };
+    readonly externals?: Externals;
+    readonly assumeGlobalizedPlauditLibraries?: boolean;
+    readonly processTranslationConfigs?: boolean;
+    readonly combineAssetMetadata?: boolean;
+    useWebpackResourceFiltering?: boolean;
+    outputDir?: string;
+    extensionsVersion?: 1 | 2 | 3;
+    readonly targetHandlePrefix?: string;
+    plainEntrypointsVersion?: 1 | 2;
+    srcDir?: string;
+    readonly srcPrefixes?: string[];
+    useUnifiedLoader?: boolean;
+    readonly includePostInitFallback?: boolean;
+    readonly omitDistDev?: boolean;
+    onlyRunPostCSSOnPCSS?: boolean;
+};
+export declare function resolveStandard(standard: PlauditWordpressWebpackConfig['standard']): {
+    readonly useWebpackResourceFiltering: true;
+    readonly extensionsVersion: 3;
+    readonly plainEntrypointsVersion: 2;
+    readonly srcDir: "src";
+    readonly outputDir: "dist";
+    readonly useUnifiedLoader: true;
+    readonly onlyRunPostCSSOnPCSS: true;
+} | undefined;
 export type FileSegmentBlockEntrypointInfo = {
     blockJsonOrigin: string;
     entrypointField: EntrypointFields[number];
@@ -148,6 +187,7 @@ export type FileSegmentBlockEntrypointInfo = {
     dest: VerifiedAdvancedOutputConfig;
     absoluteSrc: string;
     pathQueryParameters: PathQueryParameters | undefined;
+    enqueuingFlags: NormalizedEnqueuingControlFlags | undefined;
 };
 export type PathQueryParameters = Record<string, unknown | [unknown, ...unknown[]]>;
 export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
@@ -169,7 +209,7 @@ export declare const scriptExtension: RegExp;
 export declare const scriptWithoutModuleExtension: RegExp;
 export declare const scriptWithModuleExtension: RegExp;
 export declare const styleExtension: RegExp;
-export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "style" | "script" | "";
+export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "script" | "style" | "";
 export declare function isStyleField(field: string): field is 'style' | 'viewStyle' | 'editorStyle';
 export declare function isScriptModuleField(field: string): field is 'viewScriptModule';
 export declare function getHandleGroup(field: string): 'styleHandles' | 'scriptHandles' | 'scriptModuleHandles';
@@ -208,4 +248,3 @@ export declare function resolveLegacyBlockScriptsInFolder(folder: string): strin
  * @param file something that represents the file that is being inlined (this is purely for error-reporting purposes)
  */
 export declare function appendAddInlineAssetCall(compilation: Compilation, writer: PHPWriter, handle: string, type: 'script' | 'style' | 'script_module', inlinedAsset: InlinedAsset, handleData: HandleData, file: string): void;
-export {};

package/build/shared.js

@@ -1,14 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.entrypointFields = exports.standardLocationNamesMeta = void 0;
 exports.isParsedAssetsJson = isParsedAssetsJson;
+exports.isStandardLocationName = isStandardLocationName;
+exports.isRegisterScriptArgsShorthandName = isRegisterScriptArgsShorthandName;
 exports.isNormalizedUsageLocations = isNormalizedUsageLocations;
 exports.constantKeys = constantKeys;
 exports.constantEntries = constantEntries;
 exports.determineCurrentSourceType = determineCurrentSourceType;
+exports.applyStandards = applyStandards;
+exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
@@ -30,13 +48,14 @@ exports.emitPHPWriterAsAsset = emitPHPWriterAsAsset;
 exports.dedent = dedent;
 exports.resolveLegacyBlockScriptsInFolder = resolveLegacyBlockScriptsInFolder;
 exports.appendAddInlineAssetCall = appendAddInlineAssetCall;
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const webpack_1 = require("webpack");
-const node_crypto_1 = require("node:crypto");
+__exportStar(require("./utils/entrypoint-resolution-logic"), exports);
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -59,6 +78,12 @@ exports.standardLocationNamesMeta = {
     customizer: { action: "customize_controls_enqueue_scripts" },
     analytics: { action: "plaudit_enqueue_analytics" },
 };
+function isStandardLocationName(name) {
+    return name in exports.standardLocationNamesMeta;
+}
+function isRegisterScriptArgsShorthandName(name) {
+    return ['lazy', 'eager', 'inline'].includes(name);
+}
 function isNormalizedUsageLocations(usageLocations) {
     return typeof usageLocations.registerScriptArgs !== 'string';
 }
@@ -84,6 +109,35 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         return dest.directoryLayout;
     }
 }
+function applyStandards(config) {
+    switch (config.standard) {
+        case '2026-03-13':
+            return {
+                ...resolveStandard('2026-03-13'),
+                ...config
+            };
+        case undefined:
+            return config;
+        default:
+            throw `Invalid standard: ${config.standard}`;
+    }
+}
+function resolveStandard(standard) {
+    switch (standard) {
+        case "2026-03-13":
+            return {
+                useWebpackResourceFiltering: true,
+                extensionsVersion: 3,
+                plainEntrypointsVersion: 2,
+                srcDir: "src",
+                outputDir: "dist",
+                useUnifiedLoader: true,
+                onlyRunPostCSSOnPCSS: true,
+            };
+        default:
+            return undefined;
+    }
+}
 function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
     const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
     return emittableHandle.replaceAll("{basename}", generatedHandle);
@@ -107,7 +161,7 @@ function leadingSlashIt(pathOrSomething) {
 exports.scriptExtension = /(?<filename>.+)(?<extension>\.m?[jt]sx?)$/i;
 exports.scriptWithoutModuleExtension = /(?<filename>.+)(?<extension>\.[jt]sx?)($|\?)/i;
 exports.scriptWithModuleExtension = /(?<filename>.+)(?<extension>\.m[jt]sx?)($|\?)/i;
-exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)($|\?)/i;
+exports.styleExtension = /(?<filename>.+)(?<extension>\.([ps]?c|sa)ss)($|\?)/i;
 function scriptOrStyleTest(entryPath, scriptExtension) {
     return scriptExtension.test(entryPath) ? "script" : (exports.styleExtension.test(entryPath) ? "style" : "");
 }

package/build/utils/common-config-helpers.d.ts

@@ -3,7 +3,7 @@ import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDe
 import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata, WebpackPlugin } from "../shared";
 import type { Compiler, Configuration, DynamicEntryPlugin, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
+export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals' | 'standard'>> & {
     variablesFilePath?: string;
     currentVariables: Record<string, any>;
 } & Pick<PlauditWordpressWebpackConfig, 'externals'>;

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

@@ -10,6 +10,7 @@ exports.commonMakeWebpackConfig = commonMakeWebpackConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(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"));
@@ -36,9 +37,10 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
         .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, pathQueryParameters]) => {
+        .map(([ep, rawPathQueryParameters]) => {
         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,
@@ -48,7 +50,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
             dest,
             absoluteSrc: ep,
-            pathQueryParameters
+            pathQueryParameters,
+            enqueuingFlags,
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
@@ -133,6 +136,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                     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 filesRegisteredByJson = [];
                     const presentEntrypoints = (await Promise.all(entrypointFields
                         .filter(entrypointField => entrypointField in blockJson)
                         .flatMap(entrypointField => {
@@ -140,16 +144,19 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             .filter(originalValue => typeof originalValue === 'string')
                             .filter(originalValue => originalValue?.startsWith("file:"))
                             .map(originalValue => {
-                            const [entrypointPath, localPathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(originalValue);
+                            const [entrypointPath, rawLocalPathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(originalValue);
                             const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, entrypointPath));
-                            const pathQueryParameters = (0, path_query_and_related_helpers_1.mergeInPathQueryParameters)(absoluteSrc, localPathQueryParameters, dest.pathQueryParameters);
+                            filesRegisteredByJson.push(absoluteSrc);
+                            const { flags: localEnqueuingFlags, remainder: localPathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawLocalPathQueryParameters, absoluteSrc, "path query parameters");
+                            const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(absoluteSrc, localEnqueuingFlags, dest.enqueuingFlags);
+                            const pathQueryParameters = { ...dest.pathQueryParameters, ...localPathQueryParameters };
                             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, pathQueryParameters };
+                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc, pathQueryParameters, enqueuingFlags };
                                 }
                                 else {
                                     return undefined;
@@ -157,6 +164,56 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }, () => undefined);
                         });
                     }))).filter(pe => pe !== undefined);
+                    for await (const dirent of await promises_1.default.opendir(dir)) {
+                        if (!dirent.isFile()) {
+                            continue;
+                        }
+                        const absoluteSrc = node_path_1.default.normalize(node_path_1.default.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;
+                                }
+                                entrypointField = 'viewScriptModule';
+                            }
+                            else {
+                                entrypointField = (location.substring(6).toLowerCase() + type.substring(0, 1).toUpperCase() + type.substring(1));
+                            }
+                        }
+                        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), `./${dirent.name}`)));
+                        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));
+                        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(absoluteSrc, flags, dest.enqueuingFlags);
+                        presentEntrypoints.push({
+                            entrypointField,
+                            originalValue: dirent.name,
+                            entrypointName,
+                            extensionlessExpectedSrc,
+                            absoluteSrc,
+                            pathQueryParameters: dest.pathQueryParameters,
+                            enqueuingFlags
+                        });
+                    }
                     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
@@ -201,7 +258,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin, pathQueryParameters: undefined } }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {

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

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

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSourceType = isSourceType;
+exports.resolveAllConfigLevelEntrypoints = resolveAllConfigLevelEntrypoints;
+const node_fs_1 = require("node:fs");
+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");
+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);
+            using dir = (0, node_fs_1.opendirSync)(dynamicallyIncludedEntrypointsRoot);
+            for (let dirent; (dirent = dir.readSync()) !== null;) {
+                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;
+                    }
+                    using nestedDir = (0, node_fs_1.opendirSync)((0, node_path_1.join)(dynamicallyIncludedEntrypointsRoot, dirent.name));
+                    for (let nestedDirent; (nestedDirent = nestedDir.readSync()) !== null;) {
+                        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)
+        };
+    }
+}

package/build/utils/location-encoding-filename-parser.d.ts

@@ -0,0 +1,26 @@
+import { RealUsageLocations } from "../shared";
+import { NormalizedEnqueuingControlFlags } from "./path-query-and-related-helpers";
+export type ParsedLocationEncodingFilename = {
+    type: 'script' | 'style' | 'script-module';
+    locations: RealUsageLocations & {
+        register?: boolean | number;
+    };
+    flags: NormalizedEnqueuingControlFlags;
+    niceName?: string;
+};
+export declare function parseLocationEncodingFilename(filename: string): ParsedLocationEncodingFilename | undefined;
+export declare function parseLocationEncodingFilenameForBlock(filename: string, errorBuilder?: (message: string, filename: string) => unknown): Omit<ParsedLocationEncodingFilename, 'locations'> & {
+    locations: Pick<RealUsageLocations, 'clientEditor' | 'clientView'>;
+} | undefined;
+/**
+ * This handles detecting all keys of standardLocationNamesMeta as well as "view", "client-view", "editor", "client-editor", and "block-assets".
+ * It MUST be kept in sync with standardLocationNamesMeta
+ * @param segment
+ */
+export declare function extractLocationFromPropertyEncodingFilenameSegment(segment: string): {
+    readonly locationName: "clientView" | "clientEditor" | "blockAssets" | "admin" | "login" | "customizer" | "analytics" | "register";
+    readonly priority: number | true;
+} | {
+    readonly locationName: false;
+    readonly priority?: undefined;
+};

package/build/utils/location-encoding-filename-parser.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLocationEncodingFilename = parseLocationEncodingFilename;
+exports.parseLocationEncodingFilenameForBlock = parseLocationEncodingFilenameForBlock;
+exports.extractLocationFromPropertyEncodingFilenameSegment = extractLocationFromPropertyEncodingFilenameSegment;
+const node_path_1 = require("node:path");
+const shared_1 = require("../shared");
+function parseLocationEncodingFilename(filename) {
+    const { name, ext } = (0, node_path_1.parse)(filename);
+    if (name.startsWith("~")) {
+        return undefined;
+    }
+    let type = /^\.(?:s[ac]|p?c)ss$/i.test(ext) ? 'style' : /^\.m[jt]sx?/i.test(ext) ? 'script-module' : /^\.[jt]sx?/i.test(ext) ? 'script' : false;
+    if (type === false) {
+        return undefined;
+    }
+    const locations = {};
+    const flags = {};
+    const nameSegments = name.split("."); //Split always returns at least one string
+    const typeOverrideMatch = /^(?<enqueuePosition>.+)-(?<typeOverride>script|style|script-module)$|^(?<typeOverride>script|style|script-module)$/.exec(nameSegments[0]);
+    if (typeOverrideMatch) {
+        nameSegments[0] = typeOverrideMatch.groups?.["enqueuePosition"] ?? "both"; // We override the first segment with the version without the type override
+        type = typeOverrideMatch.groups?.["typeOverride"];
+    }
+    const inlinePattern = /^(?<inline>inline)(?:[-=](?<position>before|after))?$|^strategy[-=](?<inline>inline)(?:-(?<position>before|after))?$/;
+    const strategyPattern = /^strategy[-=](?<strategy>eager|lazy|defer|async)$|^(?<strategy>lazy|eager)$/;
+    const fetchpriorityPattern = /^fetchpriority[-=](auto|low|high)$/;
+    const bothViewAndEditorLocationPattern = /^(?:client-)?(?<both>both)(?:[-=](?<priority>-?\d+))?$/;
+    let niceName = undefined;
+    for (const segment of nameSegments) {
+        const { locationName, priority } = extractLocationFromPropertyEncodingFilenameSegment(segment);
+        if (locationName) {
+            locations[locationName] = priority;
+            continue;
+        }
+        const lcSegment = segment.toLowerCase();
+        const { both, priority: bothPriority } = bothViewAndEditorLocationPattern.exec(lcSegment)?.groups ?? {};
+        if (both) {
+            const priority = bothPriority !== undefined ? parseInt(bothPriority) : true;
+            locations.clientView = priority;
+            locations.clientEditor = priority;
+            continue;
+        }
+        const { inline, position: inlinePosition } = (inlinePattern.exec(lcSegment)?.groups ?? {});
+        if (inline) {
+            flags.inline = true;
+            flags.position = inlinePosition;
+            continue;
+        }
+        const strategy = strategyPattern.exec(lcSegment)?.groups?.['strategy']?.toLowerCase();
+        if (strategy) {
+            flags.strategy = strategy;
+            continue;
+        }
+        const fetchpriority = fetchpriorityPattern.exec(lcSegment)?.[1];
+        if (fetchpriority !== undefined) {
+            flags.fetchpriority = fetchpriority;
+            continue;
+        }
+        switch (segment.toLowerCase()) {
+            // Loading flags
+            case "in-footer":
+            case "in_footer":
+                flags.in_footer = true;
+                break;
+            case "in-header":
+            case "in_header":
+                flags.in_footer = false;
+                break;
+            default:
+                if (niceName === undefined) {
+                    niceName = segment;
+                }
+                break;
+        }
+    }
+    // This means that it wasn't a location-encoding filename
+    if (Object.values(locations).length === 0) {
+        return undefined;
+    }
+    return { type, locations, flags, niceName };
+}
+function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1.newWebpackErrorForFile) {
+    const parsedFilename = parseLocationEncodingFilename(filename);
+    if (parsedFilename !== undefined) {
+        if ((0, shared_1.constantKeys)(parsedFilename.locations).some(value => value !== 'clientView' && value !== 'clientEditor')) {
+            throw errorBuilder(`Block assets cannot be enqueued anywhere other than view, editor, or both. Saw: ${(0, shared_1.constantKeys)(parsedFilename).join(", ")}`, filename);
+        }
+        if (Object.values(parsedFilename.locations).some(value => typeof value === 'number')) {
+            throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);
+        }
+    }
+    return parsedFilename;
+}
+const standardLocationNamesAndPriorityPatternInFilenameSegment = /^(?:(?<view>clientView|client-view|view)|(?<editor>clientEditor|client-editor|editor)|(?<blockAssets>blockAssets|block-assets)|(?<locationName>admin|login|customizer|analytics|register))(?:[-=](?<priority>-?\d+))?$/;
+/**
+ * This handles detecting all keys of standardLocationNamesMeta as well as "view", "client-view", "editor", "client-editor", and "block-assets".
+ * It MUST be kept in sync with standardLocationNamesMeta
+ * @param segment
+ */
+function extractLocationFromPropertyEncodingFilenameSegment(segment) {
+    const { view, editor, blockAssets, locationName, priority: rawPriority } = standardLocationNamesAndPriorityPatternInFilenameSegment.exec(segment)
+        ?.groups ?? {};
+    const priority = rawPriority !== undefined ? parseInt(rawPriority) : true;
+    if (view) {
+        return { locationName: "clientView", priority };
+    }
+    if (editor) {
+        return { locationName: "clientEditor", priority };
+    }
+    if (blockAssets) {
+        return { locationName: "blockAssets", priority };
+    }
+    if (locationName) {
+        return { locationName, priority };
+    }
+    return { locationName: false };
+}