@plaudit/webpack-extensions 2.63.2 → 2.65.0

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -8,62 +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 {
-    config;
-    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("special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
-        this.config = 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) {
-                    SpecialAssetHandlingPlugin.semaphore.reject(this.id);
-                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    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) {
@@ -130,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

@@ -1,60 +1,73 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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) {
-        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");
-                            });
-                        }
-                    }
+    attachStandardPhase(compilation) {
+        compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+            compilation.deleteAsset("assets.json");
+        });
+    }
+    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;
                 }
-                catch (e) {
-                    UnifiedLoaderGenerator.semaphore.reject(this.id);
-                    throw e;
+                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;
+                }
+                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,11 +1,13 @@
+import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { type Compiler, type WebpackPluginInstance } from "webpack";
 export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private readonly destDir;
+    private readonly referencePlugin;
     private static jsdomInstance?;
     private static domParser?;
     private static xmlSerializer?;
     private readonly parsedDocumentsCache;
-    constructor(destDir: string);
+    constructor(destDir: string, referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>);
     apply(compiler: Compiler): void;
     private static getJSDOMInstance;
     private static getDOMParser;

package/build/plugins/WPMLConfigBuilder.js

@@ -12,26 +12,29 @@ const webpack_1 = require("webpack");
 const xml_formatter_1 = __importDefault(require("xml-formatter"));
 class WPMLConfigBuilderPlugin {
     destDir;
+    referencePlugin;
     static jsdomInstance;
     static domParser;
     static xmlSerializer;
     parsedDocumentsCache = new Map();
-    constructor(destDir) {
+    constructor(destDir, referencePlugin) {
         this.destDir = destDir;
+        this.referencePlugin = referencePlugin;
     }
     apply(compiler) {
-        //TODO: Filter by library here as well
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
             compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}__processXML`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL }, async (assets) => {
                 const entrypoint = compilation.entrypoints.get("wpml-config.xml");
                 if (!entrypoint) {
                     return;
                 }
+                const blockJsonFiles = this.referencePlugin.getRelevantEntrypoints(compilation)
+                    .map(ep => ep.srcPath)
+                    .filter(srcPath => srcPath.endsWith("block.json"));
                 const files = Promise.all([
                     Promise.all(entrypoint.origins.map(origin => origin.request).filter(request => request.endsWith("wpml-config.xml"))
                         .map(async (request) => this.loadWPMLConfigXML(request, compilation))),
-                    Promise.all(entrypoint.origins.map(origin => origin.request).filter(request => request.endsWith("block.json"))
-                        .map(async (request) => JSON.parse(await promises_1.default.readFile(request, 'utf8'))))
+                    Promise.all(blockJsonFiles.map(async (request) => JSON.parse(await promises_1.default.readFile(request, 'utf8'))))
                 ]);
                 const wpmlEmitPath = node_path_1.default.join(this.destDir, "wpml-config.xml");
                 for (const name of Object.keys(assets)) {

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, type EntryOptions, 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;
@@ -41,7 +41,7 @@ export type Externals = {
 };
 export type AdvancedOutputConfig = {
     destination?: string;
-    withLegacyBlocksIn?: string | undefined;
+    withLegacyBlocksIn?: string | undefined | false;
     additionalDependencies?: string[];
     directoryLayout?: SourceType;
     assumeGlobalizedPlauditLibraries?: boolean;
@@ -49,7 +49,8 @@ export type AdvancedOutputConfig = {
     bundleAnalyzer?: boolean;
     locations?: UsageLocations | UsageLocations['handle'];
 };
-export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination' | 'locations'> & Required<Pick<AdvancedOutputConfig, 'destination'>> & {
+type OptionalCfgFields = 'directoryLayout' | 'externalize';
+export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
     locations: UsageLocations;
 };
 export type PlauditWordpressWebpackConfig = {
@@ -116,4 +117,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,7 +4,7 @@ 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;
@@ -23,11 +23,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;
     }
@@ -110,7 +111,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 +161,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,7 @@
-import type { 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, EntryObject, WebpackPluginInstance } from "webpack";
+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'>> & {
     variablesFilePath?: string;
@@ -9,6 +10,7 @@ export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpre
 export type CommonPluginConfig = {
     plugins: (WebpackPluginInstance | ((this: Compiler, compiler: Compiler) => void))[];
     removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
+    makeAdditionalDependencyInjectorPlugin(referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>): AdditionalDependencyInjectorPlugin;
 };
 export type CommonConfigProcessingResult = {
     entrypointFields: EntrypointFields;
@@ -27,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, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: (() => Promise<EntryObject> | EntryObject) | EntryObject, 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

@@ -11,7 +11,6 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("../shared");
-const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 let isInThemeCache = undefined;
 function isInTheme() {
     return isInThemeCache ?? (isInThemeCache = node_fs_1.default.existsSync(node_path_1.default.join(process.cwd(), "theme.json")));
@@ -122,7 +121,6 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             if (!dirent.isDirectory()) {
                 continue;
             }
-            //TODO: It should be possible to handle all block.json files simultaneously, which would allow for better detection of repeated code
             const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
             loadingEntrypoints.push(new Promise(async (resolve) => {
                 const rawEntrypoints = [];
@@ -265,8 +263,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         return currentEntry;
     };
 }
-function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins) {
-    const { standaloneBlocks, variablesFilePath } = config;
+function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externalize, plugins, canClean) {
+    const { variablesFilePath } = config;
     const { fixedRules, processingModules, updateCurrentVariables } = commonConfig;
     const outPath = joinPossiblyAbsolutePaths(process.cwd(), config.outputDir);
     let publicPath = webpackConfig.output?.publicPath;
@@ -281,12 +279,6 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
         }
     }
     let viableRoots = [...(Array.isArray(webpackConfig.context) ? webpackConfig.context : [webpackConfig.context ?? process.cwd()])];
-    if (Array.isArray(srcRoot)) {
-        viableRoots.push(...(srcIsDirectory ? srcRoot : srcRoot.map(s => node_path_1.default.dirname(s))));
-    }
-    else {
-        viableRoots.push(srcIsDirectory ? srcRoot : node_path_1.default.dirname(srcRoot));
-    }
     let wpContentHolderDirectory = process.cwd();
     while (wpContentHolderDirectory.length > 5) {
         if (node_path_1.default.basename(wpContentHolderDirectory) === 'wp-content') {
@@ -301,10 +293,10 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
     const distinctViableRoots = new Set();
     viableRoots = viableRoots.filter(value => distinctViableRoots.has(value) ? false : distinctViableRoots.add(value) && true);
     let outputLibrary;
-    if (typeof dest === 'object' && dest.externalize) {
-        if (Array.isArray(dest.externalize) || typeof dest.externalize === 'string') {
+    if (externalize) {
+        if (Array.isArray(externalize) || typeof externalize === 'string') {
             outputLibrary = {
-                name: dest.externalize,
+                name: externalize,
                 type: "assign"
             };
         }
@@ -313,30 +305,17 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             if (originalLibrary && typeof originalLibrary === 'object' && !Array.isArray(originalLibrary)) {
                 outputLibrary = {
                     ...originalLibrary,
-                    ...dest.externalize
+                    ...externalize
                 };
             }
             else {
-                outputLibrary = dest.externalize;
+                outputLibrary = externalize;
             }
         }
     }
     else {
         outputLibrary = webpackConfig.output?.library;
     }
-    const canCopyFiles = srcIsDirectory && src !== dest.destination;
-    const possiblePlugins = canCopyFiles
-        ? plugins.filter(plugin => plugin.constructor.name !== 'CleanWebpackPlugin')
-            .map(plugin => !processingModules && plugin.constructor.name === 'CopyPlugin'
-            ? new copy_webpack_plugin_1.default({
-                patterns: [{
-                        from: standaloneBlocks ? '**/*.(php|twig|svg)' : '**/*.(asset\.php|svg)',
-                        to: dest.destination,
-                        context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
-                    }]
-            })
-            : plugin)
-        : plugins.filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin');
     const extensions = processingModules ? ['.mjsx', '.mjs', '.mtsx', '.mts', '...'] : ['.jsx', '.tsx', '.ts', '...'];
     return {
         ...webpackConfig,
@@ -348,7 +327,7 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             chunkFilename: 'webpack-chunks/[id].js',
             publicPath: publicPath,
             library: outputLibrary,
-            clean: false
+            clean: canClean ? webpackConfig.output?.clean : false
         },
         optimization: {
             ...webpackConfig.optimization,
@@ -382,13 +361,13 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             extensions
         },
         stats: config.stats,
-        plugins: possiblePlugins,
+        plugins,
         entry() {
             if (variablesFilePath) {
                 delete require.cache[require.resolve(variablesFilePath)];
                 updateCurrentVariables(require(variablesFilePath));
             }
-            return typeof entry === 'function' ? entry() : entry;
+            return {};
         },
         performance: {
             ...webpackConfig.performance,

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;
     }