@plaudit/webpack-extensions 3.2.1 → 3.2.2

package/CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.2.2] - 2026-03-16
+### Changed
+- Exposed additional aspects of the entrypoint resolution logic to tools that reference this package
+
 ## [3.2.1] - 2026-03-16
 ### Added
 - A function to expose standard flag sets to tools that reference this package

package/build/shared.d.ts

@@ -1,7 +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;
@@ -83,12 +85,6 @@ export declare function constantKeys<K extends string, V>(object: {
 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 isSourceType(str: string): str is SourceType;
 export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
 export interface WebpackPlugin {
     apply(compiler: Compiler): void;
@@ -146,6 +142,32 @@ 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;
@@ -187,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';
@@ -226,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,4 +1,18 @@
 "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 };
 };
@@ -10,8 +24,8 @@ exports.isRegisterScriptArgsShorthandName = isRegisterScriptArgsShorthandName;
 exports.isNormalizedUsageLocations = isNormalizedUsageLocations;
 exports.constantKeys = constantKeys;
 exports.constantEntries = constantEntries;
-exports.isSourceType = isSourceType;
 exports.determineCurrentSourceType = determineCurrentSourceType;
+exports.applyStandards = applyStandards;
 exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
@@ -41,6 +55,7 @@ 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");
+__exportStar(require("./utils/entrypoint-resolution-logic"), exports);
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -78,9 +93,6 @@ function constantKeys(object) {
 function constantEntries(object) {
     return Object.entries(object);
 }
-function isSourceType(str) {
-    return str === "blocks" /* SourceType.blocks */ || str === "extensions" /* SourceType.extensions */ || str === "plain" /* SourceType.plain */;
-}
 function determineCurrentSourceType(dest, srcIsDirectory) {
     if (typeof dest === 'string') {
         return srcIsDirectory ? "blocks" /* SourceType.blocks */ : "plain" /* SourceType.plain */;
@@ -97,6 +109,19 @@ 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":

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

@@ -0,0 +1,8 @@
+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;
+export declare function resolveAllConfigLevelEntrypoints(config: PlauditWordpressWebpackConfig): [string, AdvancedOutputConfig][];

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

@@ -0,0 +1,75 @@
+"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) {
+    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)(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 }];
+    };
+    if (Array.isArray(config.src)) {
+        return config.src.map(s => normalizeSrcAndDestination([s, { destination: s }]));
+    }
+    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)(process.cwd(), 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 [...Object.entries(configSrc), ...dynamicallyIncludedEntrypoints]
+            .map(([k, v]) => {
+            return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
+        });
+    }
+}

package/build/wordpress-scripts-wrapper.js

@@ -6,8 +6,8 @@ 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 location_encoding_filename_parser_1 = require("./utils/location-encoding-filename-parser");
 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");
@@ -165,7 +165,7 @@ function injectSupportForInliningSVGsAsStrings(rules) {
     });
 }
 function buildVerifiedConfig(config) {
-    config = applyStandards(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') {
@@ -191,68 +191,7 @@ 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 }];
-    };
-    let rawSources;
-    if (Array.isArray(config.src)) {
-        rawSources = config.src.map(s => normalizeSrcAndDestination([s, { destination: s }]));
-    }
-    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)(process.cwd(), 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 ((0, shared_1.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 }]);
-                }
-            }
-        }
-        rawSources = [...Object.entries(configSrc), ...dynamicallyIncludedEntrypoints]
-            .map(([k, v]) => {
-            return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
-        });
-    }
+    const rawSources = (0, entrypoint_resolution_logic_1.resolveAllConfigLevelEntrypoints)(config);
     let variablesFilePath = undefined;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
@@ -302,19 +241,6 @@ function buildVerifiedConfig(config) {
     testForDuplicatedEntryPaths(sources);
     return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
 }
-function applyStandards(config) {
-    switch (config.standard) {
-        case '2026-03-13':
-            return {
-                ...(0, shared_1.resolveStandard)('2026-03-13'),
-                ...config
-            };
-        case undefined:
-            return config;
-        default:
-            throw `Invalid standard: ${config.standard}`;
-    }
-}
 function toEffectiveWebpackDestination(destination) {
     const pathParts = (0, node_path_1.parse)(destination);
     return (0, node_path_1.join)(pathParts.dir, pathParts.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build",