@plaudit/webpack-extensions 2.83.0 → 2.84.0

package/CHANGELOG.md

@@ -5,6 +5,18 @@ 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).
 
+## [2.84.0] - 2026-01-30
+### Added
+- Support for using `lazyLoader` on plain entrypoints
+
+## [2.83.1] - 2026-01-27
+### Fixed
+- An issue wherein the theme-level styles would pollute the editor's UI styles
+  - This was done by reverting the changes from `2.73.1`
+
+### Internals
+- Removed `build` from git
+
 ## [2.83.0] - 2026-01-20
 ### Added
 - Support for `hook_name` condition to the `admin` location for plain entrypoints

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -1,14 +1,14 @@
-import { BlockEntrypointInfo, ParsedAssetJsonProvider, NormalizedUsageLocations } from "../shared";
+import { BlockEntrypointInfo, ParsedAssetJsonProvider, VerifiedAdvancedOutputConfig } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { Compilation } from "webpack";
 export declare class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin<BlockEntrypointInfo> {
     private readonly buildRoot;
     private readonly outputDir;
-    private readonly usageLocations;
+    private readonly dest;
     private readonly useUnifiedLoader;
     private static readonly semaphore;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, usageLocations: NormalizedUsageLocations, useUnifiedLoader: boolean, context: string, entry: EntryProvider<BlockEntrypointInfo>);
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, buildRoot: string, outputDir: string, dest: VerifiedAdvancedOutputConfig, useUnifiedLoader: boolean, context: string, entry: EntryProvider<BlockEntrypointInfo>);
     private generatePlainEntrypointsLoader;
     private static addHandlesToHandleLists;
     private static appendEnqueuingHandleLists;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -15,14 +15,14 @@ const webpack_1 = require("webpack");
 class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     buildRoot;
     outputDir;
-    usageLocations;
+    dest;
     useUnifiedLoader;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Plain");
-    constructor(config, buildRoot, outputDir, usageLocations, useUnifiedLoader, context, entry) {
+    constructor(config, buildRoot, outputDir, dest, useUnifiedLoader, context, entry) {
         super(config, "plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore], context, entry);
         this.buildRoot = buildRoot;
         this.outputDir = outputDir;
-        this.usageLocations = usageLocations;
+        this.dest = dest;
         this.useUnifiedLoader = useUnifiedLoader;
     }
     generatePlainEntrypointsLoader(compilation, assets) {
@@ -41,7 +41,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 .map(handle => [handle.handleName, handle.src]))]));
         const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
-            for (const { src, rest, locations, type, handleName } of handles) {
+            for (const { src, rest, locations, type, handleName, lazyLoader } of handles) {
                 const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
                 if (typeof handleName === 'string') {
@@ -55,12 +55,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                     }
                     handleNameMap[finalHandleName] = src;
                 }
-                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = {
-                    src,
-                    rest,
-                    locations,
-                    type
-                };
+                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader };
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
@@ -90,6 +85,40 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.appendEnqueuingHandleLists(writer, handleLists);
+        const sortedEditorStyleHandles = sortedStyleHandles
+            .filter(([_, { locations: { clientEditor }, type }]) => type === 'style' && (clientEditor || typeof clientEditor === 'number'))
+            .sort((a, b) => {
+            const aPriority = typeof a[1].locations.clientEditor === 'boolean' ? 10 : a[1].locations.clientEditor;
+            const bPriority = typeof b[1].locations.clientEditor === 'boolean' ? 10 : b[1].locations.clientEditor;
+            return aPriority - bPriority;
+        })
+            .map(info => info[1].src);
+        if (sortedEditorStyleHandles.length > 0) {
+            writer.linebreak();
+            for (const handleSrc of sortedEditorStyleHandles) {
+                const handlePath = node_path_1.default.join(this.outputDir, node_path_1.default.relative(emitDir, handleSrc));
+                writer.call("add_editor_style", [(0, shared_1.leadingSlashIt)(handlePath)]);
+            }
+        }
+        const lazyLoadedHandles = Object.values(handleLists)
+            .flatMap(handleList => handleList.map(handle => [handle.data.lazyLoader, handle]))
+            .filter((entry) => entry[0] !== undefined)
+            .sort((a, b) => a[0].localeCompare(b[0]) || a[1].priority - b[1].priority);
+        if (lazyLoadedHandles.length > 0) {
+            writer.linebreak();
+            const groupedLazyLoadedHandles = Object.entries(lazyLoadedHandles
+                .reduce((a, b) => {
+                (a[b[0]] ??= []).push(b[1]);
+                return a;
+            }, {}));
+            for (const [lazyLoader, handles] of groupedLazyLoadedHandles) {
+                writer.function(lazyLoader, [], writer => {
+                    for (const handle of handles) {
+                        writer.call(`wp_enqueue_${handle.type}`, [handle.handle]);
+                    }
+                }, { returnType: "void" });
+            }
+        }
         (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, "plain-entrypoints-loader.php");
     }
     static addHandlesToHandleLists(type, handles, handleLists) {
@@ -101,6 +130,11 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             for (const location of (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)) {
                 let priority, hook_name;
                 const dataLocation = data.locations[location];
+                if (location === 'clientEditor' && type === 'style') {
+                    // We don't include editor styles in the handle list because editor styles are enqueued via a completely separate mechanism at runtime and, therefore,
+                    // cannot be handled by the same code as every other enqueueable item
+                    continue;
+                }
                 if (typeof dataLocation === 'number') {
                     priority = dataLocation;
                     hook_name = undefined;
@@ -131,21 +165,23 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 else {
                     continue;
                 }
-                handleLists[location].push({ handle, type, priority, hook_name });
+                handleLists[location].push({ data, handle, type, priority, hook_name });
             }
         }
     }
     static appendEnqueuingHandleLists(writer, handleLists) {
-        const enqueuingHandleActions = (0, shared_1.constantEntries)(shared_1.standardLocationNamesMeta)
-            .map(([sln, { action, supports_hook_name }]) => [action, [handleLists[sln], supports_hook_name]]);
-        for (const [action, [handleList, supports_hook_name]] of enqueuingHandleActions) {
+        const lazyLoadableHandles = {};
+        for (const [sln, { action, supports_hook_name, additional_action_code }] of (0, shared_1.constantEntries)(shared_1.standardLocationNamesMeta)) {
+            const handleList = handleLists[sln];
             if (handleList.length > 0) {
+                writer.linebreak();
                 for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleList)) {
                     if (supports_hook_name) {
                         const hookNamedHandleLists = PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByHookName(prioritizedHandleList);
                         if (!(0, shared_1.arrayIsLength)(hookNamedHandleLists, 1) || hookNamedHandleLists[0][0] !== "") {
                             const hook_name_var = new expressions_1.Var("hook_name", "?string");
                             writer.action(action, writer => {
+                                additional_action_code?.before?.(writer);
                                 for (const [hook_name, handles] of hookNamedHandleLists) {
                                     writer.if(expressions_1.Op.binary(hook_name_var, " === ", hook_name));
                                     for (const handle of handles) {
@@ -153,18 +189,22 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                                     }
                                     writer.endIf();
                                 }
+                                additional_action_code?.after?.(writer);
                             }, { priority, functionArgParameters: [hook_name_var] });
                             continue;
                         }
                     }
                     writer.action(action, writer => {
+                        additional_action_code?.before?.(writer);
                         for (const handle of prioritizedHandleList) {
                             writer.call(`wp_enqueue_${handle.type}`, [handle.handle]);
                         }
+                        additional_action_code?.after?.(writer);
                     }, { priority });
                 }
             }
         }
+        return lazyLoadableHandles;
     }
     static separateHandleListByPriority(handleItems) {
         const lists = new Map();
@@ -237,13 +277,14 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
                 const isScript = type !== 'style';
                 const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
-                const rest = isScript && this.usageLocations.registerScriptArgs !== undefined
-                    ? [dependencies, assetData.version, this.usageLocations.registerScriptArgs] : [dependencies, assetData.version];
+                const { registerScriptArgs } = this.dest.locations;
+                const rest = isScript && registerScriptArgs !== undefined ? [dependencies, assetData.version, registerScriptArgs] : [dependencies, assetData.version];
                 const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
                 handles.push({
                     src: destPath, rest, type,
-                    locations: this.usageLocations,
-                    handleName: useHandleName ? this.usageLocations.handle : undefined,
+                    locations: this.dest.locations,
+                    handleName: useHandleName ? this.dest.locations.handle : undefined,
+                    lazyLoader: this.dest.lazyLoader
                 });
             }
             myAssetHandles.push({ handles, handlePrefix: this.config.targetHandlePrefix });

package/build/shared.d.ts

@@ -19,15 +19,12 @@ export type HandleData = {
 export declare const standardLocationNamesMeta: {
     readonly clientView: {
         readonly action: "wp_enqueue_scripts";
-        readonly supports_hook_name: false;
     };
     readonly clientEditor: {
         readonly action: "enqueue_block_editor_assets";
-        readonly supports_hook_name: false;
     };
     readonly blockAssets: {
         readonly action: "enqueue_block_assets";
-        readonly supports_hook_name: false;
     };
     readonly admin: {
         readonly action: "admin_enqueue_scripts";
@@ -35,15 +32,20 @@ export declare const standardLocationNamesMeta: {
     };
     readonly login: {
         readonly action: "login_enqueue_scripts";
-        readonly supports_hook_name: false;
     };
     readonly customizer: {
         readonly action: "customize_controls_enqueue_scripts";
-        readonly supports_hook_name: false;
     };
     readonly analytics: {
         readonly action: "plaudit_enqueue_analytics";
-        readonly supports_hook_name: false;
+    };
+};
+export type StandardLocationNameMeta = {
+    action: typeof standardLocationNamesMeta[keyof typeof standardLocationNamesMeta]['action'];
+    supports_hook_name?: boolean;
+    additional_action_code?: {
+        before?(writer: PHPWriter): unknown;
+        after?(writer: PHPWriter): unknown;
     };
 };
 export type StandardLocationNames = keyof typeof standardLocationNamesMeta;
@@ -52,7 +54,9 @@ type LocationWithHookNameSupport = boolean | number | string | string[] | {
     priority?: number;
 };
 export type UsageLocations = {
-    [K in StandardLocationNames]?: typeof standardLocationNamesMeta[K]['supports_hook_name'] extends true ? LocationWithHookNameSupport : boolean | number;
+    [K in StandardLocationNames]?: typeof standardLocationNamesMeta[K] extends {
+        supports_hook_name: true;
+    } ? LocationWithHookNameSupport : boolean | number;
 } & {
     register?: boolean | number;
     handle?: string | ((generatedHandle: string) => string);

package/build/shared.js

@@ -49,13 +49,13 @@ function isParsedAssetsJson(thing) {
     return true;
 }
 exports.standardLocationNamesMeta = {
-    clientView: { action: "wp_enqueue_scripts", supports_hook_name: false },
-    clientEditor: { action: "enqueue_block_editor_assets", supports_hook_name: false },
-    blockAssets: { action: "enqueue_block_assets", supports_hook_name: false },
+    clientView: { action: "wp_enqueue_scripts" },
+    clientEditor: { action: "enqueue_block_editor_assets" },
+    blockAssets: { action: "enqueue_block_assets" },
     admin: { action: "admin_enqueue_scripts", supports_hook_name: true },
-    login: { action: "login_enqueue_scripts", supports_hook_name: false },
-    customizer: { action: "customize_controls_enqueue_scripts", supports_hook_name: false },
-    analytics: { action: "plaudit_enqueue_analytics", supports_hook_name: false }
+    login: { action: "login_enqueue_scripts" },
+    customizer: { action: "customize_controls_enqueue_scripts" },
+    analytics: { action: "plaudit_enqueue_analytics" },
 };
 function isNormalizedUsageLocations(usageLocations) {
     return typeof usageLocations.registerScriptArgs !== 'string';

package/build/wordpress-scripts-wrapper.js

@@ -548,7 +548,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources, canClean
                     const entry = srcIsDirectory // This being true implies that srcRoot is not an array
                         ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
                         : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest, absoluteSrc } } });
-                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.useUnifiedLoader, contextPath, entry);
+                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest, config.useUnifiedLoader, contextPath, entry);
                 }
                 else {
                     if (srcIsDirectory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.83.0",
+  "version": "2.84.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@plaudit/gutenberg-api-extensions": "^2.84.3",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^25.0.9",
+    "@types/node": "^25.1.0",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.3.0",
     "@types/webpack": "^5.28.5",
@@ -42,9 +42,9 @@
     "@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.38.0",
-    "@wordpress/scripts": "^31.3.0",
-    "autoprefixer": "^10.4.23",
+    "@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",