@plaudit/webpack-extensions 2.64.0 → 2.65.0

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

@@ -1,4 +1,4 @@
-import type { AbstractMultiPhaseLibraryAndEntryPlugin, EntryProvider } from "../plugins/AbstractMultiPhaseLibraryAndEntryPlugin";
+import type { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "../plugins/AbstractBiPhasicGroupAndEntryPlugin";
 import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDependencyInjectorPlugin";
 import { EntrypointFields, PlauditWordpressWebpackConfig, UnpackedBlockEntrypointInfo, VerifiedAdvancedOutputConfig } from "../shared";
 import type { Compiler, Configuration, DynamicEntryPlugin, WebpackPluginInstance } from "webpack";
@@ -10,7 +10,7 @@ export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpre
 export type CommonPluginConfig = {
     plugins: (WebpackPluginInstance | ((this: Compiler, compiler: Compiler) => void))[];
     removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
-    makeAdditionalDependencyInjectorPlugin(referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>): AdditionalDependencyInjectorPlugin;
+    makeAdditionalDependencyInjectorPlugin(referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>): AdditionalDependencyInjectorPlugin;
 };
 export type CommonConfigProcessingResult = {
     entrypointFields: EntrypointFields;
@@ -29,4 +29,4 @@ export type ExtensibleEntryObject<M> = {
     };
 };
 export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): EntryProvider<UnpackedBlockEntrypointInfo | string>;
-export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, externalize: VerifiedAdvancedOutputConfig['externalize'], plugins: CommonPluginConfig['plugins']): Configuration;
+export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, externalize: VerifiedAdvancedOutputConfig['externalize'], plugins: CommonPluginConfig['plugins'], canClean: boolean): Configuration;

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

@@ -263,7 +263,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         return currentEntry;
     };
 }
-function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externalize, plugins) {
+function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externalize, plugins, canClean) {
     const { variablesFilePath } = config;
     const { fixedRules, processingModules, updateCurrentVariables } = commonConfig;
     const outPath = joinPossiblyAbsolutePaths(process.cwd(), config.outputDir);
@@ -327,7 +327,7 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
             chunkFilename: 'webpack-chunks/[id].js',
             publicPath: publicPath,
             library: outputLibrary,
-            clean: false
+            clean: canClean ? webpackConfig.output?.clean : false
         },
         optimization: {
             ...webpackConfig.optimization,

package/build/utils/json-to-php-but-with-__-injection.js

@@ -5,7 +5,7 @@ const make = (props = {}) => {
     const linebreak = props.linebreak ?? '';
     const indent = props.indent ?? '';
     const stripSpaces = props.stripSpaces ?? false;
-    const shortArraySyntax = props.shortArraySyntax ?? false;
+    const shortArraySyntax = props.shortArraySyntax ?? true;
     const arrOpen = shortArraySyntax ? '[' : 'array(';
     const arrClose = shortArraySyntax ? ']' : ')';
     const arrow = stripSpaces ? '=>' : ' => ';

package/build/utils/pseduo-semaphore.d.ts

@@ -1,12 +1,11 @@
 export declare class PseudoSemaphore<T> {
-    private readonly defaultValue;
     private readonly name;
     private flagSet;
     private readonly flags;
     private readonly debugMode;
-    constructor(defaultValue: T, name: string);
+    constructor(name: string);
     register(id: string): void;
-    resolve(id: string, value: T): void;
+    resolve(id: string, value: T | undefined): void;
     reject(id: string): void;
     reset(id: string): void;
     private getFlag;

package/build/utils/pseduo-semaphore.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudoSemaphore = void 0;
 class PseudoSemaphore {
-    defaultValue;
     name;
     flagSet = 0;
     flags = new Map();
     debugMode = false;
-    constructor(defaultValue, name) {
-        this.defaultValue = defaultValue;
+    constructor(name) {
         this.name = name;
     }
     register(id) {
@@ -16,7 +14,7 @@ class PseudoSemaphore {
             throw new Error();
         }
         this.initializeFlag(id);
-        this.resolve(id, this.defaultValue);
+        this.resolve(id, undefined);
     }
     resolve(id, value) {
         if (this.debugMode) {
@@ -67,7 +65,13 @@ class PseudoSemaphore {
         let res;
         do {
             currentFlagSet = this.flagSet;
-            res = await Promise.all(this.flags.values().map(flag => flag[0]));
+            if (this.debugMode) {
+                console.log("WAITING FOR:", this.name, currentFlagSet);
+            }
+            res = (await Promise.all(this.flags.values().map(flag => flag[0]))).filter(r => r !== undefined);
+            if (this.debugMode) {
+                console.log("POSSIBLY FINISHED WAITING FOR:", this.name, currentFlagSet);
+            }
         } while (currentFlagSet !== this.flagSet);
         return res;
     }

package/build/wordpress-scripts-wrapper.js

@@ -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) {
@@ -446,7 +448,7 @@ function destToKey(dest) {
         : dest.externalize?.toString() ?? "undefined";
     return [dest.additionalDependencies.join("_"), dest.assumeGlobalizedPlauditLibraries, dest.bundleAnalyzer, externalize, dest.withLegacyBlocksIn].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,7 +467,8 @@ 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 batches = Object.values(groupedSrcRoots).filter(shared_1.hasAtLeastOneItem);
+    return batches.map(currentBatch => {
         const { bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies } = currentBatch[0].dest;
         const { plugins, removeEmptyScriptsPlugin, makeAdditionalDependencyInjectorPlugin } = buildCommonPluginConfig(webpackConfig, config, bundleAnalyzer, assumeGlobalizedPlauditLibraries, externalize, additionalDependencies);
         handleDisablingTSCheckerIfNecessary(currentBatch.flatMap(a => a.srcRoots), scriptExtension, plugins);
@@ -515,7 +518,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
                     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);
+                    plugin = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(config, process.cwd(), config.outputDir, dest.locations, config.useUnifiedLoader, webpackConfig.context ?? process.cwd(), entry);
                 }
                 else {
                     if (srcIsDirectory) {
@@ -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.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"

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;