@plaudit/webpack-extensions 2.64.0 → 2.65.1

package/build/wordpress-scripts-wrapper.js

@@ -360,7 +360,7 @@ function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins)
         }
     }
 }
-function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies) {
+function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize) {
     const { externals } = config;
     const processingModules = webpackConfig.output?.module ?? false;
     const plugins = webpackConfig.plugins?.filter(v => !!v)
@@ -388,7 +388,9 @@ function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGl
         ignore: /block\.json/
     });
     plugins.push(removeEmptyScriptsPlugin, new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
-    plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config));
+    if (config.useWebpackResourceFiltering) {
+        plugins.push(new SpecialAssetHandlingPlugin_1.SpecialAssetHandlingPlugin(config));
+    }
     plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(config));
     const dependencyExtractionPluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
     if (dependencyExtractionPluginIndex === -1) {
@@ -401,7 +403,7 @@ function buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGl
     return {
         plugins, removeEmptyScriptsPlugin,
         makeAdditionalDependencyInjectorPlugin(referencePlugin) {
-            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(additionalDependencies ?? [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
+            return new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(config, processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep, referencePlugin);
         }
     };
 }
@@ -444,9 +446,9 @@ function destToKey(dest) {
     const externalize = typeof dest.externalize === 'object' && dest.externalize !== undefined
         ? (Array.isArray(dest.externalize) ? dest.externalize.join("_") : (dest.externalize ? Object.entries(dest.externalize).flat().sort().join() : "undefined"))
         : dest.externalize?.toString() ?? "undefined";
-    return [dest.additionalDependencies.join("_"), dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize, dest.withLegacyBlocksIn].join("~");
+    return [dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize].join("~");
 }
-function processIndividualWebpackConfig(config, webpackConfig, sources) {
+function processIndividualWebpackConfig(config, webpackConfig, sources, canClean) {
     const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
     const { processingModules, scriptExtension } = commonConfig;
     const allSrcRoots = sources.map(([src, dest]) => {
@@ -465,9 +467,10 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
         const key = destToKey(entry.dest);
         (groupedSrcRoots[key] ?? (groupedSrcRoots[key] = [])).push(entry);
     }
-    return Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem).map(currentBatch => {
-        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies } = currentBatch[0].dest;
-        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies);
+    const batches = Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem);
+    return batches.map(currentBatch => {
+        const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize } = currentBatch[0].dest;
+        const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize);
         handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
         for (const { dest, src, srcIsDirectory, srcRoot } of currentBatch) {
             let plugin;
@@ -492,7 +495,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
                         if (dirent.isFile() && !dirent.name.startsWith("~")) {
                             if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
                                 const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                                rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: [file], plauditMetadata: "entrypoint-v2" }]);
+                                rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: [file], plauditMetadata: { dest } }]);
                             }
                         }
                     }
@@ -514,15 +517,15 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
                 if (config.plainEntrypointsVersion > 1) {
                     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: "plain-entrypoint" } });
-                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.plainEntrypointsHandlePrefix, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
+                        : () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest } } });
+                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
                 }
                 else {
                     if (srcIsDirectory) {
                         console.error("Using directory mode with legacy plain entrypoint handling is not supported");
                         continue;
                     }
-                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(config, webpackConfig.context ?? process.cwd(), () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: "plain-entrypoint" } }));
+                    plugin = new EnhancedDynamicEntryPlugin_1.EnhancedDynamicEntryPlugin(config, webpackConfig.context ?? process.cwd(), () => ({ [baseDest]: { import: Array.isArray(srcRoot) ? srcRoot : [srcRoot], plauditMetadata: { purpose: "plain-entrypoint", dest } } }));
                 }
                 plugins.push(plugin);
             }
@@ -543,7 +546,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
             }
         }
         plugins.push(new UnifiedLoaderGenerator_1.UnifiedLoaderGenerator(config));
-        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, externalize, plugins);
+        return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, externalize, plugins, canClean && batches.length < 2);
     }).filter(cfg => cfg !== undefined);
 }
 function stripExtension(filepath) {
@@ -551,13 +554,16 @@ function stripExtension(filepath) {
 }
 module.exports = function (config, webpackConfig = require("@wordpress/scripts/config/webpack.config")) {
     const { cfg, sources } = buildVerifiedConfig(config);
+    if (Array.isArray(webpackConfig) && (0, shared_1.hasAtLeastOneItem)(webpackConfig)) {
+        webpackConfig = webpackConfig[0];
+    }
     if (Array.isArray(webpackConfig)) {
         return webpackConfig.toSorted((a, b) => {
             if (a.output?.module) {
                 return b.output?.module ? 0 : -1;
             }
             return b.output?.module ? 1 : 0;
-        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources));
+        }).flatMap(wpCfg => processIndividualWebpackConfig(cfg, wpCfg, sources, false));
     }
-    return processIndividualWebpackConfig(cfg, webpackConfig, sources);
+    return processIndividualWebpackConfig(cfg, webpackConfig, sources, true);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.64.0",
+  "version": "2.65.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -16,9 +16,9 @@
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.75.0",
+    "@plaudit/gutenberg-api-extensions": "^2.76.1",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.3.1",
     "@types/postcss-functions": "^4.0.4",
     "@types/tapable": "^2.2.7",
     "@types/webpack": "^5.28.5",

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.d.ts

@@ -1,21 +0,0 @@
-import { RawAssetData } from "../shared";
-import type { ExtensibleEntryObject, VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { PseudoSemaphore } from "../utils/pseduo-semaphore";
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
-import { Compilation, Compiler, Entrypoint } from "webpack";
-export type EntryProvider<M> = () => ExtensibleEntryObject<M> | Promise<ExtensibleEntryObject<M>>;
-export declare abstract class AbstractMultiPhaseLibraryAndEntryPlugin<M> extends AbstractMultiPhaseLibraryPlugin {
-    private readonly context;
-    private readonly entry;
-    private static readonly configuredCompilations;
-    private readonly entryMetadataRecord;
-    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, libraryType: string, semaphores: PseudoSemaphore<any>[], context: string, entry: EntryProvider<M>);
-    apply(compiler: Compiler): void;
-    getRelevantEntrypoints(compilation: Compilation): {
-        entrypoint: Entrypoint;
-        srcPath: string;
-        metadata: M;
-    }[];
-    protected abstract processAssets(compilation: Compilation, rawAssetData: RawAssetData): Promise<void> | void;
-    protected extractRelevantAssetData(compilation: Compilation, rawAssetData: RawAssetData): RawAssetData;
-}

package/build/plugins/AbstractMultiPhaseLibraryAndEntryPlugin.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractMultiPhaseLibraryAndEntryPlugin = void 0;
-const shared_1 = require("../shared");
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
-const webpack_1 = require("webpack");
-class AbstractMultiPhaseLibraryAndEntryPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
-    context;
-    entry;
-    static configuredCompilations = new WeakSet();
-    entryMetadataRecord = {};
-    constructor(config, libraryType, semaphores, context, entry) {
-        super(config, libraryType, semaphores);
-        this.context = context;
-        this.entry = entry;
-    }
-    apply(compiler) {
-        super.apply(compiler);
-        compiler.hooks.compilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
-            if (AbstractMultiPhaseLibraryAndEntryPlugin.configuredCompilations.has(compilation)) {
-                return;
-            }
-            AbstractMultiPhaseLibraryAndEntryPlugin.configuredCompilations.add(compilation);
-            const dummyEntry = webpack_1.EntryPlugin.createDependency("", "");
-            compilation.dependencyFactories.set(dummyEntry.constructor, normalModuleFactory);
-        });
-        compiler.hooks.make.tapPromise(this.constructor.name, async (compilation) => {
-            const entry = await this.entry();
-            const promises = [];
-            for (const [name, { plauditMetadata, ...desc }] of Object.entries(entry)) {
-                const options = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, name, desc);
-                this.entryMetadataRecord[name] = plauditMetadata;
-                for (const entry of desc.import) {
-                    promises.push(new Promise((resolve, reject) => {
-                        compilation.addEntry(this.context, webpack_1.EntryPlugin.createDependency(entry, options), options, err => {
-                            if (err) {
-                                return reject(err);
-                            }
-                            resolve();
-                        });
-                    }));
-                }
-            }
-            await Promise.all(promises);
-        });
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
-                if (!("assets.json" in assets)) {
-                    return;
-                }
-                try {
-                    //TODO: It should be possible to use EntryPoints to determine the "original" file
-                    //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
-                    const rawAssetDataSource = assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        this.rejectSemaphores();
-                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
-                        return;
-                    }
-                    const rawAssetData = JSON.parse(rawAssetDataSource);
-                    if (!(0, shared_1.isRawAssetData)(rawAssetData)) {
-                        this.rejectSemaphores();
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    await this.processAssets(compilation, rawAssetData);
-                }
-                catch (e) {
-                    this.rejectSemaphores();
-                    if (e instanceof Error) {
-                        compilation.errors.push(e);
-                        return;
-                    }
-                    throw e;
-                }
-            });
-        });
-    }
-    getRelevantEntrypoints(compilation) {
-        return compilation.entrypoints.values()
-            .map(entrypoint => {
-            const name = entrypoint.name;
-            if (!name) {
-                return undefined;
-            }
-            const metadata = this.entryMetadataRecord[name];
-            if (metadata === undefined) {
-                return undefined;
-            }
-            const srcPath = entrypoint.origins[0]?.request;
-            if (!srcPath) {
-                return undefined;
-            }
-            return { entrypoint, srcPath, metadata };
-        })
-            .filter(item => item !== undefined)
-            .toArray();
-    }
-    extractRelevantAssetData(compilation, rawAssetData) {
-        const relevantAssetData = {};
-        const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
-        for (const { entrypoint, srcPath } of relevantEntrypoints) {
-            const fileWithAssetData = entrypoint.getEntrypointChunk().files.values().find(file => rawAssetData[file]);
-            if (!fileWithAssetData) {
-                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
-                continue;
-            }
-            relevantAssetData[fileWithAssetData] = rawAssetData[fileWithAssetData];
-        }
-        return relevantAssetData;
-    }
-}
-exports.AbstractMultiPhaseLibraryAndEntryPlugin = AbstractMultiPhaseLibraryAndEntryPlugin;

package/build/plugins/AbstractMultiPhaseLibraryPlugin.d.ts

@@ -1,17 +0,0 @@
-import { Compilation, Compiler, type WebpackPluginInstance } from "webpack";
-import { PseudoSemaphore } from "../utils/pseduo-semaphore";
-import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-export declare abstract class AbstractMultiPhaseLibraryPlugin implements WebpackPluginInstance {
-    protected readonly config: VerifiedPlauditWordpressWebpackConfig;
-    readonly libraryType: string;
-    private readonly semaphores;
-    protected static readonly phaseTwoAttached: {
-        [key in string]: any;
-    };
-    protected readonly id: string;
-    protected constructor(config: VerifiedPlauditWordpressWebpackConfig, libraryType: string, semaphores: PseudoSemaphore<any>[]);
-    apply(compiler: Compiler): void;
-    protected resetSemaphores(): void;
-    protected rejectSemaphores(): void;
-    protected abstract attachSecondPhase(compilation: Compilation): void;
-}

package/build/plugins/AbstractMultiPhaseLibraryPlugin.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractMultiPhaseLibraryPlugin = void 0;
-const webpack_1 = require("webpack");
-class AbstractMultiPhaseLibraryPlugin {
-    config;
-    libraryType;
-    semaphores;
-    static phaseTwoAttached = {};
-    id;
-    constructor(config, libraryType, semaphores) {
-        this.config = config;
-        this.libraryType = libraryType;
-        this.semaphores = semaphores;
-        this.id = Math.random().toString();
-    }
-    apply(compiler) {
-        webpack_1.library.EnableLibraryPlugin.setEnabled(compiler, this.libraryType);
-        for (const semaphore of this.semaphores) {
-            semaphore.register(this.id);
-        }
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType] = false;
-            this.resetSemaphores();
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType]) {
-                    AbstractMultiPhaseLibraryPlugin.phaseTwoAttached[this.libraryType] = this;
-                    this.attachSecondPhase(compilation);
-                }
-            });
-        });
-    }
-    resetSemaphores() {
-        for (const semaphore of this.semaphores) {
-            semaphore.reset(this.id);
-        }
-    }
-    rejectSemaphores() {
-        for (const semaphore of this.semaphores) {
-            semaphore.reject(this.id);
-        }
-    }
-}
-exports.AbstractMultiPhaseLibraryPlugin = AbstractMultiPhaseLibraryPlugin;