@plaudit/webpack-extensions 2.64.0 → 2.65.1

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -8,59 +8,54 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({}, "Special");
+class SpecialAssetHandlingPlugin extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Special");
     static validPathname = undefined;
     constructor(config) {
         super(config, "special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
     }
-    apply(compiler) {
-        if (!this.config.useWebpackResourceFiltering) {
-            return;
-        }
-        super.apply(compiler);
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE }, async (assets) => {
-                try {
-                    const specialAssetData = {};
-                    for (const pathname of Object.keys(assets)) {
-                        if (!SpecialAssetHandlingPlugin.validPathname) {
-                            SpecialAssetHandlingPlugin.validPathname = pathname;
-                        }
-                        const assetInfo = compilation.assetsInfo.get(pathname);
-                        if (!assetInfo?.sourceFilename) {
-                            continue;
-                        }
-                        const filename = node_path_1.default.join(node_path_1.default.basename(node_path_1.default.dirname(pathname)), node_path_1.default.basename(pathname));
-                        const queryStart = assetInfo.sourceFilename.indexOf('?');
-                        if (queryStart < 0) {
-                            continue;
-                        }
-                        const params = new URLSearchParams(assetInfo.sourceFilename.substring(queryStart + 1)
-                            .replace(/(?:fetchPriority|crossOrigin)=/gi, str => str.toLowerCase()) //This ensures consistent capitalization of the fetchPriority parameter
-                        );
-                        if (params.has("preload")) {
-                            SpecialAssetHandlingPlugin.validPathname = pathname;
-                            specialAssetData[filename] = {
-                                preload: true,
-                                fetchpriority: params.get("fetchpriority"),
-                                crossorigin: params.get("crossorigin")
-                            };
-                        }
+    attachStandardPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE }, async (assets) => {
+            try {
+                const specialAssetData = {};
+                for (const pathname of Object.keys(assets)) {
+                    if (!SpecialAssetHandlingPlugin.validPathname) {
+                        SpecialAssetHandlingPlugin.validPathname = pathname;
+                    }
+                    const assetInfo = compilation.assetsInfo.get(pathname);
+                    if (!assetInfo?.sourceFilename) {
+                        continue;
+                    }
+                    const filename = node_path_1.default.join(node_path_1.default.basename(node_path_1.default.dirname(pathname)), node_path_1.default.basename(pathname));
+                    const queryStart = assetInfo.sourceFilename.indexOf('?');
+                    if (queryStart < 0) {
+                        continue;
+                    }
+                    const params = new URLSearchParams(assetInfo.sourceFilename.substring(queryStart + 1)
+                        .replace(/(?:fetchPriority|crossOrigin)=/gi, str => str.toLowerCase()) //This ensures consistent capitalization of the fetchPriority parameter
+                    );
+                    if (params.has("preload")) {
+                        SpecialAssetHandlingPlugin.validPathname = pathname;
+                        specialAssetData[filename] = {
+                            preload: true,
+                            fetchpriority: params.get("fetchpriority"),
+                            crossorigin: params.get("crossorigin")
+                        };
                     }
-                    SpecialAssetHandlingPlugin.semaphore.resolve(this.id, specialAssetData);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(specialAssetData).length > 0
-                        ? { group: 'special-assets', requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/special-assets.php';") }
-                        : undefined);
-                }
-                catch (e) {
-                    this.rejectSemaphores();
-                    throw e;
                 }
-            });
+                SpecialAssetHandlingPlugin.semaphore.resolve(this.id, specialAssetData);
+                UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, Object.keys(specialAssetData).length > 0
+                    ? { group: 'special-assets', requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/special-assets.php';") }
+                    : undefined);
+            }
+            catch (e) {
+                console.error(e);
+                this.rejectSemaphores();
+                throw e;
+            }
         });
     }
     async collateAssets(compilation) {
@@ -127,8 +122,10 @@ class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.Abstr
         });
         writer.emitAsset(compilation, outputFile);
     }
-    attachSecondPhase(compilation) {
-        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
+    attachUniquePhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            await this.collateAssets(compilation);
+        });
     }
 }
 exports.SpecialAssetHandlingPlugin = SpecialAssetHandlingPlugin;

package/build/plugins/UnifiedLoaderGenerator.d.ts

@@ -1,19 +1,19 @@
+import { AbstractBiPhasicGroupPlugin } from "./AbstractBiPhasicGroupPlugin";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { PseudoSemaphore } from "../utils/pseduo-semaphore";
 import { PHPWriter } from "../utils/php-writer";
-import { Compiler, WebpackPluginInstance } from "webpack";
+import { PseudoSemaphore } from "../utils/pseduo-semaphore";
+import { Compilation } from "webpack";
 type LoaderInfo = {
     group: string;
     action(writer: PHPWriter): void;
     requiresBaseURI: boolean;
+    staticallyLoadedEntrypoints?: string[];
     priority?: number;
 };
-export declare class UnifiedLoaderGenerator implements WebpackPluginInstance {
-    private readonly config;
-    static readonly semaphore: PseudoSemaphore<LoaderInfo | undefined>;
-    private static attached;
-    private readonly id;
+export declare class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin {
+    static readonly semaphore: PseudoSemaphore<LoaderInfo>;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);
-    apply(compiler: Compiler): void;
+    protected attachStandardPhase(compilation: Compilation): void;
+    protected attachUniquePhase(compilation: Compilation): void;
 }
 export {};

package/build/plugins/UnifiedLoaderGenerator.js

@@ -5,84 +5,69 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedLoaderGenerator = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const AbstractBiPhasicGroupPlugin_1 = require("./AbstractBiPhasicGroupPlugin");
 const shared_1 = require("../shared");
-const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const json_to_php_but_with____injection_1 = __importDefault(require("../utils/json-to-php-but-with-__-injection"));
 const php_writer_1 = require("../utils/php-writer");
+const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
-class UnifiedLoaderGenerator {
-    config;
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore(undefined, "Unified");
-    static attached = false;
-    id;
+class UnifiedLoaderGenerator extends AbstractBiPhasicGroupPlugin_1.AbstractBiPhasicGroupPlugin {
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore("Unified");
     constructor(config) {
-        this.config = config;
-        this.id = Math.random().toString();
+        super(config, "unified-loader", []);
     }
-    apply(compiler) {
-        compiler.hooks.compilation.tap(`${this.constructor.name}_Cleanup`, compilation => {
-            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-                if (!this.config.useUnifiedLoader) {
-                    const rawAssetDataSource = compilation.assets["assets.json"]?.source();
-                    if (typeof rawAssetDataSource !== 'string') {
-                        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)) {
-                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
-                        return;
-                    }
-                    for (const [file, assetData] of Object.entries(rawAssetData)) {
-                        const escapedDependencies = assetData.dependencies.map(php_writer_1.Expr.convertJsonToPHP).join(", ");
-                        const contents = `<?php return ['dependencies' => [${escapedDependencies}], 'version' => ${php_writer_1.Expr.convertJsonToPHP(assetData.version)}];\n`;
-                        const parsedPath = node_path_1.default.parse(file);
-                        const assetPHPFile = node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php";
-                        compilation.emitAsset(assetPHPFile, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
-                    }
-                }
-                compilation.deleteAsset("assets.json");
-            });
+    attachStandardPhase(compilation) {
+        compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+            compilation.deleteAsset("assets.json");
         });
-        if (!this.config.useUnifiedLoader) {
-            return;
-        }
-        UnifiedLoaderGenerator.semaphore.register(this.id);
-        const tapName = { name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT };
-        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            UnifiedLoaderGenerator.attached = false;
-            UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.processAssets.tapPromise(tapName, async () => {
-                try {
-                    UnifiedLoaderGenerator.semaphore.resolve(this.id, undefined);
-                    if (!UnifiedLoaderGenerator.attached) {
-                        UnifiedLoaderGenerator.attached = true;
-                        const alreadyAllocatedGroups = new Set();
-                        const writerCallbacks = (await UnifiedLoaderGenerator.semaphore.wait())
-                            .filter((a) => a !== undefined)
-                            .sort((a, b) => {
-                            const ap = a.priority ?? 0, bp = b.priority ?? 0;
-                            return ap === bp ? a.group.localeCompare(b.group) : bp - ap;
-                        })
-                            .filter(a => !alreadyAllocatedGroups.has(a.group) && alreadyAllocatedGroups.add(a.group));
-                        if (writerCallbacks.length > 0) {
-                            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
-                                const writer = new php_writer_1.PHPWriter();
-                                if (writerCallbacks.some(wc => wc.requiresBaseURI)) {
-                                    (0, shared_1.emitResolveBaseUriFunction)(writer);
-                                }
-                                for (const writerCallback of writerCallbacks) {
-                                    writerCallback.action(writer);
-                                }
-                                writer.emitAsset(compilation, "unified-loader.php");
-                            });
-                        }
-                    }
+    }
+    attachUniquePhase(compilation) {
+        this.tapWithParsedAssetsJson(compilation, { stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async (parsedAssetsJson) => {
+            const groupedLoaderInfo = Object.values((await UnifiedLoaderGenerator.semaphore.wait())
+                .reduce((acc, cur) => {
+                const accValue = acc[cur.group];
+                if (accValue === undefined) {
+                    acc[cur.group] = { ...cur, priority: cur.priority ?? 0, staticallyLoadedEntrypoints: cur.staticallyLoadedEntrypoints?.length ? [...cur.staticallyLoadedEntrypoints] : [] };
+                    return acc;
+                }
+                if (cur.priority && accValue.priority < cur.priority) {
+                    accValue.priority = cur.priority;
+                    accValue.action = cur.action;
+                    accValue.requiresBaseURI = cur.requiresBaseURI;
+                }
+                else if (cur.requiresBaseURI && !accValue.requiresBaseURI) {
+                    accValue.requiresBaseURI = cur.requiresBaseURI;
                 }
-                catch (e) {
-                    UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    throw e;
+                if (cur.staticallyLoadedEntrypoints?.length) {
+                    accValue.staticallyLoadedEntrypoints.push(...cur.staticallyLoadedEntrypoints);
                 }
+                return acc;
+            }, {}))
+                .sort((a, b) => {
+                const ap = a.priority ?? 0, bp = b.priority ?? 0;
+                return ap === bp ? a.group.localeCompare(b.group) : bp - ap;
             });
+            const staticallyLoadedEntrypoints = new Set(groupedLoaderInfo.flatMap(lig => lig.staticallyLoadedEntrypoints));
+            for (const [file, assetData] of Object.entries(parsedAssetsJson)) {
+                if (staticallyLoadedEntrypoints.has(file)) {
+                    continue;
+                }
+                const parsedPath = node_path_1.default.parse(file);
+                const contents = `<?php return ${(0, json_to_php_but_with____injection_1.default)(assetData)};\n`;
+                compilation.emitAsset(node_path_1.default.join(parsedPath.dir, parsedPath.name) + ".asset.php", new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+            }
+            if (this.config.useUnifiedLoader) {
+                compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+                    const writer = new php_writer_1.PHPWriter();
+                    if (groupedLoaderInfo.some(wc => wc.requiresBaseURI)) {
+                        (0, shared_1.emitResolveBaseUriFunction)(writer);
+                    }
+                    for (const { action } of groupedLoaderInfo) {
+                        action(writer);
+                    }
+                    writer.emitAsset(compilation, "unified-loader.php");
+                });
+            }
         });
     }
 }

package/build/plugins/WPMLConfigBuilder.d.ts

@@ -1,4 +1,4 @@
-import { AbstractMultiPhaseLibraryAndEntryPlugin } from "./AbstractMultiPhaseLibraryAndEntryPlugin";
+import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private readonly destDir;
@@ -7,7 +7,7 @@ export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private static domParser?;
     private static xmlSerializer?;
     private readonly parsedDocumentsCache;
-    constructor(destDir: string, referencePlugin: AbstractMultiPhaseLibraryAndEntryPlugin<any>);
+    constructor(destDir: string, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
     apply(compiler: Compiler): void;
     private static getJSDOMInstance;
     private static getDOMParser;

package/build/shared.d.ts

@@ -1,11 +1,11 @@
 import { PHPWriter } from "./utils/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { type Configuration, type EntryOptions, WebpackError } from "webpack";
-export type RawAssetData = Record<string, {
+import { Compilation, type Configuration, WebpackError } from "webpack";
+export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
 }>;
-export declare function isRawAssetData(thing: any): thing is RawAssetData;
+export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
 type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
 export type HandleData = {
     src: string;
@@ -75,23 +75,18 @@ export type PlauditWordpressWebpackConfig = {
     srcPrefixes?: string[];
     useUnifiedLoader?: boolean;
 };
-export type SmuggledBlockEntrypointInfo = [
-    string,
-    EntrypointFields[number],
-    string,
-    string,
-    string
-];
-export type UnpackedBlockEntrypointInfo = {
+export type FileSegmentBlockEntrypointInfo = {
     blockJsonOrigin: string;
     entrypointField: EntrypointFields[number];
     originalValue: string;
     entrypointName: string;
     handle: string;
+    dest: VerifiedAdvancedOutputConfig;
+};
+export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
+    dest: VerifiedAdvancedOutputConfig;
+    purpose: string;
 };
-export declare function packBlockEntrypointInfoForSmuggling(info: UnpackedBlockEntrypointInfo): SmuggledBlockEntrypointInfo;
-export declare function unpackSmuggledBlockEntrypointInfo(library: EntryOptions['library'], allowedEndings?: string[] | false): UnpackedBlockEntrypointInfo | undefined;
-export declare function isSmuggledLibraryInfo(libraryName: NonNullable<EntryOptions['library']>['name'] | undefined, allowedEndings?: string[] | false): libraryName is SmuggledBlockEntrypointInfo;
 export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], generatedHandle: string): string;
 export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
 export type EntrypointFields = ["viewScriptModule", "scriptModule"] | ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
@@ -117,4 +112,5 @@ export declare function newWebpackErrorForFile(error: string | ConstructorParame
  * The primary benefit of emitting a function instead of baking its contents into each function that uses it is that it allows us to avoid recomputing the base uri multiple times
  */
 export declare function emitResolveBaseUriFunction(writer: PHPWriter): void;
+export declare function getAssetsJson(compilation: Compilation): ParsedAssetsJson;
 export {};

package/build/shared.js

@@ -4,11 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.entrypointFields = exports.standardLocationNames = void 0;
-exports.isRawAssetData = isRawAssetData;
+exports.isParsedAssetsJson = isParsedAssetsJson;
 exports.determineCurrentSourceType = determineCurrentSourceType;
-exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
-exports.unpackSmuggledBlockEntrypointInfo = unpackSmuggledBlockEntrypointInfo;
-exports.isSmuggledLibraryInfo = isSmuggledLibraryInfo;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
@@ -23,11 +20,12 @@ exports.loadEnvFile = loadEnvFile;
 exports.parseEnvFile = parseEnvFile;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
+exports.getAssetsJson = getAssetsJson;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const json_to_php_but_with____injection_1 = __importDefault(require("./utils/json-to-php-but-with-__-injection"));
 const php_writer_1 = require("./utils/php-writer");
 const webpack_1 = require("webpack");
-function isRawAssetData(thing) {
+function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
     }
@@ -57,23 +55,6 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         return dest.directoryLayout;
     }
 }
-function packBlockEntrypointInfoForSmuggling(info) {
-    return [info.blockJsonOrigin, info.entrypointField, info.originalValue, info.entrypointName, info.handle];
-}
-const defaultAllowedEndings = ["/block.json", "/entrypoints.json", "/package.json"];
-function unpackSmuggledBlockEntrypointInfo(library, allowedEndings) {
-    const libraryName = library?.name;
-    if (!isSmuggledLibraryInfo(libraryName, allowedEndings)) {
-        return undefined;
-    }
-    return { blockJsonOrigin: libraryName[0], entrypointField: libraryName[1], originalValue: libraryName[2], entrypointName: libraryName[3], handle: libraryName[4] };
-}
-function isSmuggledLibraryInfo(libraryName, allowedEndings = defaultAllowedEndings) {
-    if (!Array.isArray(libraryName) || !arrayIsLength(libraryName, 5) || libraryName.some(item => typeof item !== 'string')) {
-        return false;
-    }
-    return (!allowedEndings || allowedEndings.some(s => libraryName[0].endsWith(s))) && exports.entrypointFields.includes(libraryName[1]);
-}
 function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
     const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
     return emittableHandle.replaceAll("{basename}", generatedHandle);
@@ -110,7 +91,7 @@ function isScriptModuleField(field) {
     return field.includes("odule");
 }
 function hasAtLeastOneItem(list) {
-    return list.length > 0;
+    return list.length > 0 && list[0] !== undefined && list[0] !== null;
 }
 function arrayIsLength(arr, length) {
     return !!arr && arr.length === length;
@@ -160,3 +141,18 @@ function emitResolveBaseUriFunction(writer) {
             .call("trailingslashit", [php_writer_1.Expr.call("home_url", [path])], { return: true, assignTo: assignmentTarget });
     }, { returnType: "string", includeExistenceCheck: true });
 }
+function getAssetsJson(compilation) {
+    const asset = compilation.getAsset("assets.json");
+    if (!asset) {
+        throw new Error("assets.json is unexpectedly missing");
+    }
+    if (isParsedAssetsJson(asset.info["parsed-assets-json"])) {
+        return asset.info["parsed-assets-json"];
+    }
+    const parsedAssetJson = JSON.parse(asset.source.source().toString('utf-8'));
+    if (!isParsedAssetsJson(parsedAssetJson)) {
+        throw new Error("assets.json is does not match the RawAssetData format");
+    }
+    compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
+    return parsedAssetJson;
+}

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

@@ -1,6 +1,6 @@
-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 { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig } 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'>> & {
@@ -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;
@@ -21,12 +21,12 @@ export type CommonConfigProcessingResult = {
 };
 export declare function joinPossiblyAbsolutePaths(...paths: (string | undefined)[]): string;
 export declare function groupEntrypointsByAssetFile<T>(entrypoints: T[], entrypointNameExtractor: (t: T) => string): Map<string, T[]>;
-export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<UnpackedBlockEntrypointInfo | string>;
+export type BlockJsonExtensibleEntryObject = ExtensibleEntryObject<BlockEntrypointInfo>;
 export type EntryStaticNormalized = Awaited<ReturnType<ConstructorParameters<typeof DynamicEntryPlugin>[1]>>;
 export type ExtensibleEntryObject<M> = {
     [index: string]: Omit<EntryStaticNormalized[string], 'import'> & Required<NonNullable<Pick<EntryStaticNormalized[string], 'import'>>> & {
         plauditMetadata: 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 resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): EntryProvider<BlockEntrypointInfo>;
+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

@@ -44,7 +44,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             entrypointField: shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'scriptModule' : 'script',
             originalValue: ep,
             entrypointName: parsedEntrypoint.name,
-            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name)
+            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name),
+            dest
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
@@ -168,7 +169,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
                             return {
                                 blockJsonOrigin, ...presentEntrypoint,
-                                handle: `${handlePrefix}/${handleSuffix}`
+                                handle: `${handlePrefix}/${handleSuffix}`,
+                                dest
                             };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
@@ -184,7 +186,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`
+                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`,
+                            dest
                         };
                     });
                     rawEntrypoints.push(...resolvedBlockEntrypoints
@@ -197,7 +200,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: "block-json-inclusion-assurance" }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {
@@ -251,19 +254,19 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
             try {
                 await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
-                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: "wpml-config-xml" };
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: { purpose: "wpml-config-xml", dest } };
             }
             catch (e) {
                 // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
                 if (wpmlEntrypointFiles.length) {
-                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: "wpml-config-xml" };
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, plauditMetadata: { purpose: "wpml-config-xml", 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 +330,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;
     }