@plaudit/webpack-extensions 2.53.1 → 2.55.0

package/build/plugins/SpecialAssetHandlingPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { Compiler, WebpackPluginInstance } from "webpack";
+export declare class SpecialAssetHandlingPlugin implements WebpackPluginInstance {
+    private readonly outputDir;
+    private static readonly semaphore;
+    private static readonly previouslyIncludedFilenames;
+    private static hasAttachedAssetCollatorForCurrentBatch;
+    private static validPathname?;
+    private readonly id;
+    constructor(outputDir: string);
+    apply(compiler: Compiler): void;
+    private collateAssets;
+}

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecialAssetHandlingPlugin = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./PlainEntrypointsConfigFileGeneratorPlugin");
+const php_writer_1 = require("../utils/php-writer");
+const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+class SpecialAssetHandlingPlugin {
+    outputDir;
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({});
+    static previouslyIncludedFilenames = new Set(); // This allows us to ensure that assets that were previously being preloaded can be removed
+    static hasAttachedAssetCollatorForCurrentBatch = false;
+    static validPathname = undefined;
+    id;
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+        this.id = Math.random().toString();
+        SpecialAssetHandlingPlugin.semaphore.register(this.id);
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = false;
+            SpecialAssetHandlingPlugin.semaphore.reset(this.id);
+            compilation.hooks.processAssets.tapPromise(this.constructor.name, 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) {
+                            if (SpecialAssetHandlingPlugin.previouslyIncludedFilenames.has(filename)) {
+                                specialAssetData[filename] = {
+                                    preload: false,
+                                    fetchpriority: null,
+                                    crossorigin: null
+                                };
+                            }
+                            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);
+                    if (!SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch) {
+                        SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = true;
+                        const collatedSpecialAssetData = (await SpecialAssetHandlingPlugin.semaphore.wait())
+                            .reduce((collector, current) => ({ ...collector, ...current }), {});
+                        this.collateAssets(compilation, collatedSpecialAssetData);
+                    }
+                }
+                catch (e) {
+                    SpecialAssetHandlingPlugin.semaphore.reject(this.id);
+                    throw e;
+                }
+            });
+        });
+    }
+    collateAssets(compilation, collatedSpecialAssetData) {
+        const preloadedAssets = Object.entries(collatedSpecialAssetData)
+            .filter(([_, { preload }]) => preload)
+            .sort(([a], [b]) => a.localeCompare(b));
+        const outputFile = this.outputDir ? "special-assets.php" : node_path_1.default.join(node_path_1.default.dirname(node_path_1.default.dirname(SpecialAssetHandlingPlugin.validPathname)), "special-assets.php");
+        const writer = new php_writer_1.PHPWriter();
+        if (!preloadedAssets.length) {
+            writer.emitAsset(compilation, outputFile);
+            return;
+        }
+        PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin.emitResolveBaseUriFunction(writer);
+        writer.action("wp_head", writer => {
+            writer.call("plaudit_webpack_extensions__resolve_base_uri", [], { assignTo: "$base_uri" }).closePHP();
+            for (let [filename, { preload, fetchpriority, crossorigin }] of preloadedAssets) {
+                if (!preload) {
+                    continue;
+                }
+                let fileExtension = node_path_1.default.extname(filename);
+                if (fileExtension.startsWith(".")) {
+                    fileExtension = fileExtension.substring(1).toLowerCase();
+                }
+                else {
+                    fileExtension = fileExtension.toLowerCase();
+                }
+                const attributes = [];
+                if (["woff", "woff2", "ttf", "otf", "eot"].includes(fileExtension)) {
+                    if (!crossorigin) {
+                        crossorigin = "anonymous";
+                    }
+                    attributes.push(["as", "font"], ["type", `font/${fileExtension}`]);
+                }
+                else if (fileExtension === "svg") {
+                    attributes.push(["as", "image"], ["type", `image/svg+xml`]);
+                }
+                else if (fileExtension === "jpeg" || fileExtension === "jpg") {
+                    attributes.push(["as", "image"], ["type", `image/jpeg`]);
+                }
+                else if (["png", "webp", "avif", "gif", "bmp"].includes(fileExtension)) {
+                    attributes.push(["as", "image"], ["type", `image/${fileExtension}`]);
+                }
+                else {
+                    compilation.errors.push(new Error(`Encountered preloading markup on an unsupported file extension (${fileExtension})`));
+                    continue;
+                }
+                if (fetchpriority && fetchpriority !== 'auto') {
+                    attributes.push(["fetchpriority", fetchpriority]);
+                }
+                if (crossorigin || crossorigin === "") {
+                    attributes.push(["crossorigin", crossorigin]);
+                }
+                const dynamicAttrs = attributes.map(([k, v]) => v ? `${k}="${v}"` : k).join(" ");
+                writer.append(`<link rel="preload" href="<?= esc_url($base_uri.'${filename}') ?>" ${dynamicAttrs}>`);
+            }
+            writer.openPHP();
+        });
+        writer.emitAsset(compilation, outputFile);
+    }
+}
+exports.SpecialAssetHandlingPlugin = SpecialAssetHandlingPlugin;

package/build/{wordpress-scripts-wrapper → plugins}/VariablesJSMonitorPlugin.js

@@ -7,7 +7,7 @@ class VariablesJSMonitorPlugin {
         this.variablesFilePath = variablesFilePath;
     }
     apply(compiler) {
-        compiler.hooks.make.tap('VariablesJSMonitorPlugin', compilation => {
+        compiler.hooks.make.tap(this.constructor.name, compilation => {
             if (!compilation.fileDependencies.has(this.variablesFilePath)) {
                 compilation.fileDependencies.add(this.variablesFilePath);
             }

package/build/{wordpress-scripts-wrapper → plugins}/WPMLConfigBuilder.d.ts

@@ -1,12 +1,13 @@
-import { type Compiler, type WebpackPluginInstance } from "webpack";
 import { BlockJSONManagingPlugin } from "./BlockJSONManagingPlugin";
+import { type Compiler, type WebpackPluginInstance } from "webpack";
 export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
     private readonly blockJSONManagingPlugin;
+    private readonly destDir;
     private static jsdomInstance?;
     private static domParser?;
     private static xmlSerializer?;
     private readonly parsedDocumentsCache;
-    constructor(blockJSONManagingPlugin: BlockJSONManagingPlugin);
+    constructor(blockJSONManagingPlugin: BlockJSONManagingPlugin, destDir: string);
     apply(compiler: Compiler): void;
     private static getJSDOMInstance;
     private static getDOMParser;

package/build/{wordpress-scripts-wrapper → plugins}/WPMLConfigBuilder.js

@@ -5,17 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WPMLConfigBuilderPlugin = void 0;
 const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
 const jsdom_1 = require("jsdom");
 const webpack_1 = require("webpack");
 const xml_formatter_1 = __importDefault(require("xml-formatter"));
 class WPMLConfigBuilderPlugin {
     blockJSONManagingPlugin;
+    destDir;
     static jsdomInstance;
     static domParser;
     static xmlSerializer;
     parsedDocumentsCache = new Map();
-    constructor(blockJSONManagingPlugin) {
+    constructor(blockJSONManagingPlugin, destDir) {
         this.blockJSONManagingPlugin = blockJSONManagingPlugin;
+        this.destDir = destDir;
     }
     apply(compiler) {
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
@@ -30,8 +33,9 @@ class WPMLConfigBuilderPlugin {
                     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'))))
                 ]);
+                const wpmlEmitPath = node_path_1.default.join(this.destDir, "wpml-config.xml");
                 for (const name of Object.keys(assets)) {
-                    if (name.startsWith("wpml-config.xml")) {
+                    if (name.startsWith("wpml-config.xml") || name.startsWith(wpmlEmitPath)) {
                         compilation.deleteAsset(name);
                     }
                 }
@@ -141,7 +145,7 @@ class WPMLConfigBuilderPlugin {
                 appendNamedElementsListToConfig("shortcodes", mergedConfig.shortcodes, config);
                 appendNamedElementsListToConfig("taxonomies", mergedConfig.taxonomies, config);
                 this.blockJSONManagingPlugin.additionalMetadata.set("wpml-config", true);
-                compilation["wpml-config.xml" in compilation.assets ? 'updateAsset' : 'emitAsset']("wpml-config.xml", new webpack_1.sources.RawSource(WPMLConfigBuilderPlugin.prettyPrintXML(config)));
+                compilation[wpmlEmitPath in compilation.assets ? 'updateAsset' : 'emitAsset'](wpmlEmitPath, new webpack_1.sources.RawSource(WPMLConfigBuilderPlugin.prettyPrintXML(config)));
             });
         });
     }

package/build/{wordpress-scripts-wrapper → plugins}/dependency-extraction-webpack-plugin-config-builder.d.ts

@@ -1,12 +1,6 @@
 import DependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
+import type { Externals } from "../shared";
 import type { Configuration } from "webpack";
-export type IndividualExternalDepConfig = string | {
-    import?: string | [string, ...string[]];
-    handle: string;
-};
-export type Externals = {
-    [dep: string]: IndividualExternalDepConfig;
-};
 export declare function makeDependencyExtractionPlugin(externals: Externals | undefined, assumeGlobalizedPlauditLibraries: boolean, wantsGroupedDepData: boolean, externalizing: Required<Configuration>['output']['library']): {
     instance: DependencyExtractionWebpackPlugin;
     addExternalizedDep: (dep: string) => void;

package/build/shared.d.ts

@@ -1,11 +1,88 @@
-export type SharedCache = {
-    specialAssets?: {
-        files: {
-            [k: string]: {
-                preload?: true;
-                fetchpriority?: string | null;
-                crossorigin?: string | null;
-            };
-        };
+import type { Options as PostcssFunctionsOptions } from "postcss-functions";
+import type { Configuration } from "webpack";
+export type RawAssetData = Record<string, {
+    dependencies: string[];
+    version: string;
+}>;
+export declare function isRawAssetData(thing: any): thing is RawAssetData;
+type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
+export type HandleData = {
+    src: string;
+    rest: BaseRestType | [...BaseRestType, {
+        strategy?: 'defer' | 'async';
+        in_footer?: boolean;
+    } | boolean];
+};
+export declare const standardLocationNames: readonly ["clientView", "clientEditor", "admin", "login", "customizer", "analytics"];
+export type StandardLocationNames = typeof standardLocationNames[number];
+export type UsageLocations = {
+    [K in StandardLocationNames]?: boolean | number;
+} & {
+    register?: boolean | number;
+    handle?: string;
+    registerScriptArgs?: {
+        strategy?: 'defer' | 'async';
+        in_footer?: boolean;
+    } | boolean;
+};
+export declare const enum SourceType {
+    blocks = "blocks",
+    extensions = "extensions",
+    plain = "plain"
+}
+export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
+export type IndividualExternalDepConfig = string | {
+    import?: string | [string, ...string[]];
+    handle: string;
+};
+export type Externals = {
+    [dep: string]: IndividualExternalDepConfig;
+};
+export type AdvancedOutputConfig = {
+    destination: string;
+    withLegacyBlocksIn?: string | undefined;
+    additionalDependencies?: string[];
+    directoryLayout?: SourceType;
+    assumeGlobalizedPlauditLibraries?: boolean;
+    externalize?: Required<Configuration>['output']['library'];
+    bundleAnalyzer?: boolean;
+    locations?: UsageLocations;
+};
+export type PlauditWordpressWebpackConfig = {
+    standaloneBlocks?: boolean;
+    variables?: Record<string, any>;
+    verbose?: boolean;
+    src: string[] | Record<string, string | AdvancedOutputConfig>;
+    stats?: Configuration['stats'];
+    postcss?: {
+        functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions'];
     };
+    externals?: Externals;
+    assumeGlobalizedPlauditLibraries?: boolean;
+    processTranslationConfigs?: boolean;
+    combineAssetMetadata?: boolean;
+    useWebpackResourceFiltering?: boolean;
+    outputDir?: string;
+    extensionsVersion?: 1 | 2;
+    plainEntrypointsHandlePrefix?: string;
+    plainEntrypointsVersion?: 1 | 2;
+    srcDir?: string;
+};
+export declare function makeEmittableConfigPHP(data: any): string;
+export type Sync<V> = {
+    sync: Promise<V>;
+    resolve(v: V): void;
+    reject(): void;
+    done: boolean;
+};
+type Readiness<V> = {
+    nonModule: Sync<V>;
+    module: Sync<V>;
 };
+export declare class SyncsManager<V> {
+    private readonly readinessMapping;
+    get(name: string): Readiness<V>;
+    private makeSync;
+}
+export declare function leadingSlashIt(pathOrSomething: string): string;
+export {};

package/build/shared.js

@@ -1,2 +1,72 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncsManager = exports.standardLocationNames = void 0;
+exports.isRawAssetData = isRawAssetData;
+exports.determineCurrentSourceType = determineCurrentSourceType;
+exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
+exports.leadingSlashIt = leadingSlashIt;
+const json_to_php_but_with____injection_1 = __importDefault(require("./utils/json-to-php-but-with-__-injection"));
+function isRawAssetData(thing) {
+    if (!thing || typeof thing !== 'object') {
+        return false;
+    }
+    for (const value of Object.values(thing)) {
+        if ((!value || typeof value !== 'object') ||
+            (!('dependencies' in value) || !Array.isArray(value.dependencies) || value.dependencies.some(d => typeof d !== 'string')) ||
+            (!('version' in value) || !value.version || typeof value.version !== 'string')) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.standardLocationNames = ['clientView', 'clientEditor', 'admin', 'login', 'customizer', 'analytics'];
+function determineCurrentSourceType(dest, srcIsDirectory) {
+    if (typeof dest === 'string') {
+        return srcIsDirectory ? "blocks" /* SourceType.blocks */ : "plain" /* SourceType.plain */;
+    }
+    else {
+        if (dest.directoryLayout === undefined) {
+            return srcIsDirectory ? "blocks" /* SourceType.blocks */ : "plain" /* SourceType.plain */;
+        }
+        if (dest.directoryLayout === "extensions" /* SourceType.extensions */ || dest.directoryLayout === "blocks" /* SourceType.blocks */) {
+            if (!srcIsDirectory) {
+                throw new Error(`The '${dest.directoryLayout}' source type must be associated with a directory`);
+            }
+        }
+        return dest.directoryLayout;
+    }
+}
+function makeEmittableConfigPHP(data) {
+    return "<?php return "
+        + json_to_php_but_with____injection_1.default.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, "")
+            .replaceAll(/(\n\t*)\[\s+],/gs, "$1[],")
+            .replaceAll(/\[\n\t+([^\n]+)\n\t+]/gs, (_, inner) => `[${inner.trim()}]`)
+            .replaceAll(/'rest' => \[\n\t+(\[(?:'[^']+')?]),\n\t+('[^']+')(?:,\n\t+(\[[^\n]+]))?\n\t+]/gs, (_, deps, hash, args) => `'rest' => [${[deps, hash, args].filter(value => !!value).join(", ")}]`)
+        + ";";
+}
+class SyncsManager {
+    readinessMapping = new Map();
+    get(name) {
+        const res = this.readinessMapping.get(name);
+        if (res) {
+            return res;
+        }
+        this.readinessMapping.set(name, { nonModule: this.makeSync(), module: this.makeSync() });
+        return this.readinessMapping.get(name);
+    }
+    makeSync() {
+        const res = { done: false };
+        res.sync = new Promise((resolve, reject) => {
+            res.resolve = (v) => resolve(v);
+            res.reject = () => reject();
+        });
+        return res;
+    }
+}
+exports.SyncsManager = SyncsManager;
+function leadingSlashIt(pathOrSomething) {
+    return pathOrSomething.startsWith('/') ? pathOrSomething : ('/' + pathOrSomething);
+}

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

@@ -0,0 +1,26 @@
+import type { AdvancedOutputConfig, PlauditWordpressWebpackConfig } from "../shared";
+import type { Compiler, Configuration, EntryObject, WebpackPluginInstance } from "webpack";
+import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
+export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
+    variablesFilePath?: string;
+    currentVariables: Record<string, any>;
+} & Pick<PlauditWordpressWebpackConfig, 'externals'>;
+export type CommonPluginConfig = {
+    plugins: (WebpackPluginInstance | ((this: Compiler, compiler: Compiler) => void))[];
+    removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
+};
+export type CommonConfigProcessingResult = {
+    entrypointFields: string[];
+    fixedRules: NonNullable<Configuration['module']>['rules'];
+    processingModules: boolean | undefined;
+    scriptExtension: RegExp;
+    updateCurrentVariables: (value: VerifiedPlauditWordpressWebpackConfig['currentVariables']) => unknown;
+};
+export declare const scriptWithoutModuleExtension: RegExp;
+export declare const scriptWithModuleExtension: RegExp;
+export declare const styleExtension: RegExp;
+export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "" | "script" | "style";
+export declare function joinPossiblyAbsolutePaths(...paths: (string | undefined)[]): string;
+export declare function groupEntrypointsByAssetFile<T>(entrypoints: T[], entrypointNameExtractor: (t: T) => string): Map<string, T[]>;
+export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: AdvancedOutputConfig): () => Promise<EntryObject>;
+export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: string | AdvancedOutputConfig, src: string, srcRoot: string | string[], entry: () => Promise<EntryObject> | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;