@plaudit/webpack-extensions 2.61.2 → 2.62.1

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -8,40 +8,27 @@ 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 webpack_1 = require("webpack");
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
-class PlainEntrypointsConfigFileGeneratorPlugin {
+const webpack_1 = require("webpack");
+class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     buildRoot;
     outputDir;
     usageLocations;
     handlePrefix;
     useUnifiedLoader;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore([], "Plain");
-    static phaseTwoAttached = false;
-    id;
     constructor(buildRoot, outputDir, usageLocations, handlePrefix, useUnifiedLoader) {
+        super("plain-entrypoints-v2", [PlainEntrypointsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.buildRoot = buildRoot;
         this.outputDir = outputDir;
         this.usageLocations = usageLocations;
         this.handlePrefix = handlePrefix;
         this.useUnifiedLoader = useUnifiedLoader;
-        this.id = Math.random().toString();
-        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.register(this.id);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
     }
     apply(compiler) {
+        super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached = false;
-            PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reset(this.id);
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached) {
-                    PlainEntrypointsConfigFileGeneratorPlugin.phaseTwoAttached = true;
-                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-                        this.afterProcessAssets(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
-                    });
-                }
-            });
             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;
@@ -82,17 +69,17 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                             chunkFiles[0][1] = true;
                         }
                         for (const [file, useHandleName] of chunkFiles) {
-                            const isScript = file.toLowerCase().endsWith(".js");
+                            const extension = node_path_1.default.extname(file).toLowerCase();
+                            const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
+                            const isScript = type !== 'style';
                             const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
                             const rest = isScript && this.usageLocations.registerScriptArgs !== undefined
                                 ? [dependencies, assetData.version, this.usageLocations.registerScriptArgs] : [dependencies, assetData.version];
                             const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
                             handles.push({
-                                src: destPath,
-                                rest,
+                                src: destPath, rest, type,
                                 locations: this.usageLocations,
-                                isScript,
-                                handleName: useHandleName ? this.usageLocations.handle : undefined
+                                handleName: useHandleName ? this.usageLocations.handle : undefined,
                             });
                         }
                         myAssetHandles.push({
@@ -101,10 +88,9 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                             handlePrefix: this.handlePrefix
                         });
                     }
-                    compilation.deleteAsset("assets.json");
                     PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
                     UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myAssetHandles.length
-                        ? { group: 'plain-entrypoints-v2', requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
+                        ? { group: this.libraryType, requiresBaseURI: true, action: writer => writer.append("require_once __DIR__.'/plain-entrypoints-loader.php';") }
                         : undefined);
                 }
                 catch (e) {
@@ -113,9 +99,12 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                     throw e;
                 }
             });
+            compilation.hooks.afterProcessAssets.tap(this.constructor.name, () => {
+                compilation.deleteAsset("assets.json");
+            });
         });
     }
-    afterProcessAssets(compilation, assets) {
+    generatePlainEntrypointsLoader(compilation, assets) {
         const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
         const handleLists = {
             register: [],
@@ -130,15 +119,13 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
             .flatMap(({ handles }) => handles)
             .filter((handle) => !!handle.handleName)
             .sort((a, b) => a.src.localeCompare(b.src));
-        const usedScriptHandleNames = Object.fromEntries(allNamedHandles
-            .filter(handle => handle.isScript)
-            .map(handle => [handle.handleName, handle.src]));
-        const usedStyleHandleNames = Object.fromEntries(allNamedHandles
-            .filter(handle => !handle.isScript)
-            .map(handle => [handle.handleName, handle.src]));
-        const plainEntrypointsConfig = { scriptHandles: {}, styleHandles: {} };
+        const usedHandleNames = Object.fromEntries(['script', 'script_module', 'style']
+            .map(type => [type, Object.fromEntries(allNamedHandles
+                .filter(handle => handle.type === 'script')
+                .map(handle => [handle.handleName, handle.src]))]));
+        const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
-            for (const { src, rest, locations, isScript, handleName } of handles) {
+            for (const { src, rest, locations, type, handleName } of handles) {
                 let finalHandleName;
                 if (handleName) {
                     finalHandleName = handleName;
@@ -146,46 +133,48 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
                 else {
                     const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                     const baseFinalHandleName = `${handlePrefix}.${(0, shared_1.kebabCase)(basename)}`;
-                    const handleNameMap = (isScript ? usedScriptHandleNames : usedStyleHandleNames);
+                    const handleNameMap = usedHandleNames[type];
                     finalHandleName = baseFinalHandleName;
                     for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                         finalHandleName = `${baseFinalHandleName}-${++count}`;
                     }
                     handleNameMap[finalHandleName] = src;
                 }
-                plainEntrypointsConfig[isScript ? 'scriptHandles' : 'styleHandles'][finalHandleName] = {
+                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = {
                     src,
                     rest,
                     locations,
-                    isScript
+                    type
                 };
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
             .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script_module', Object.entries(plainEntrypointsConfig.script_moduleHandles)
+            .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
         const sortedStyleHandles = Object.entries(plainEntrypointsConfig.styleHandles)
             .toSorted(([a], [b]) => a.localeCompare(b));
         PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('style', sortedStyleHandles, handleLists);
-        //TODO: Do we want to sort by type first? Pro: all calls of the same type are together; Con: not all calls for the same block will be together
-        const callItemSorter = (a, b) => /*a.type.localeCompare(b.type) || */ a.handle.localeCompare(b.handle);
+        const callItemSorter = (a, b) => a.handle.localeCompare(b.handle);
         for (const list of Object.values(handleLists)) {
             list.sort(callItemSorter);
         }
         const writer = new php_writer_1.PHPWriter();
         if (handleLists.register.length > 0) {
             if (!this.useUnifiedLoader) {
-                PlainEntrypointsConfigFileGeneratorPlugin.emitResolveBaseUriFunction(writer);
+                (0, shared_1.emitResolveBaseUriFunction)(writer);
             }
+            const baseUriVar = new php_writer_1.Var("base_uri");
             for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleLists.register)) {
                 writer.action("init", writer => {
-                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [new php_writer_1.Expr('__DIR__')], { assignTo: "$base_uri" });
+                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__], { assignTo: baseUriVar });
                     for (const { handle, type, data } of prioritizedHandleList) {
-                        writer.call(`wp_register_${type}`, [handle, new php_writer_1.Expr(`$base_uri.${php_writer_1.Expr.jsonToPHPConverter(node_path_1.default.relative(emitDir, data.src))}`), ...data.rest]);
+                        writer.call(`wp_register_${type}`, [handle, php_writer_1.Op.join(baseUriVar, node_path_1.default.relative(emitDir, data.src)), ...data.rest]);
                     }
                 }, { priority, accountForAlreadyDoing: true });
             }
             const sortedEditorStyleHandles = sortedStyleHandles
-                .filter(([_, { locations: { clientEditor }, isScript }]) => !isScript && (clientEditor || typeof clientEditor === 'number'))
+                .filter(([_, { locations: { clientEditor }, type }]) => type === 'style' && (clientEditor || typeof clientEditor === 'number'))
                 .map(info => info[1]);
             if (sortedEditorStyleHandles.length > 0) {
                 writer.linebreak();
@@ -249,25 +238,10 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
         }
         return lists.entries().toArray().sort((a, b) => a[0] - b[0]);
     }
-    /**
-     * 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
-     */
-    static emitResolveBaseUriFunction(writer) {
-        writer.function("plaudit_webpack_extensions__resolve_base_uri", ["$dir"], writer => {
-            writer
-                .static("$base_uris", { initializer: [] })
-                .if("isset($base_uris[$dir])")
-                .return(new php_writer_1.Expr("$base_uris[$dir]"))
-                .elseIf("str_starts_with($dir, ABSPATH)")
-                .append("$path = ltrim(substr($dir, strlen(ABSPATH)), '/');")
-                .elseIf("str_starts_with($dir, '/workspace/website')")
-                .append("$path = ltrim(substr($dir, 18), '/');")
-                .else()
-                .call("error_log", ["UNABLE TO FIGURE OUT WHAT THE RELATIVE PATH TO THE BUILT FILES DIRECTORY SHOULD BE"])
-                .append("$path = '';")
-                .endIf()
-                .call("trailingslashit", [new php_writer_1.Expr("home_url($path)")], { return: true, assignTo: "$base_uris[$dir]" });
-        }, { returnType: "string", includeExistenceCheck: true });
+    attachSecondPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            this.generatePlainEntrypointsLoader(compilation, (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat());
+        });
     }
 }
 exports.PlainEntrypointsConfigFileGeneratorPlugin = PlainEntrypointsConfigFileGeneratorPlugin;

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.d.ts

@@ -0,0 +1,25 @@
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
+import { Compilation, type Compiler } from "webpack";
+import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
+export declare class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlugin {
+    private readonly config;
+    private readonly blocksDest;
+    private readonly webpackRemoveEmptyScriptsPlugin;
+    private static readonly semaphore;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, blocksDest: string, webpackRemoveEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin);
+    apply(compiler: Compiler): void;
+    private emitBlockLoaderFile;
+    private transformBlocks;
+    private static extractAssetSource;
+    private static convertToScriptHandles;
+    private static doFileOrHandleReplacements;
+    private stripOffBlocksDestPrefix;
+    private static hashThingForAsset;
+    private static stripFilePrefix;
+    static findCommonAncestor(...paths: string[]): string[];
+    static findRelativeRouteBetween(path1: string, path2: string): string;
+    private static remapReferencedPHPFilesOnKey;
+    private static normalizeRenderTemplate;
+    protected attachSecondPhase(compilation: Compilation): void;
+}