@plaudit/webpack-extensions 2.84.0 → 2.85.0

package/build/plugins/EnhancedBlockJSONPlugin.d.ts

@@ -1,12 +1,14 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig, ParsedAssetJsonProvider } from "../shared";
+import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig, ParsedAssetJsonProvider, ScriptArgsObject, InlinedAsset } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
-type WorkableBlockEntrypointInfo = Omit<FileSegmentBlockEntrypointInfo, 'originalValue'> & Partial<Pick<FileSegmentBlockEntrypointInfo, 'originalValue'>> & {
+type WorkableBlockEntrypointInfo = Omit<FileSegmentBlockEntrypointInfo, 'originalValue' | 'pathQueryParameters'> & Partial<Pick<FileSegmentBlockEntrypointInfo, 'originalValue'>> & {
     outputPath: string;
     assetData: ParsedAssetsJson[string];
     hash: string;
+    scriptArgsObject: ScriptArgsObject | undefined;
+    inlinedAsset: InlinedAsset | undefined;
 };
 type CollatedWorkableBlockInfo = Record<string, {
     sourcePath?: string;

package/build/plugins/EnhancedBlockJSONPlugin.js

@@ -13,6 +13,7 @@ const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
+const path_query_and_related_helpers_1 = require("../utils/path-query-and-related-helpers");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
 class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
@@ -34,7 +35,6 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             }
             const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypoint.getEntrypointChunk())][0]?.originalSource();
             if (asset) {
-                //TODO: Can we guarantee that entrypoint.name is always non-null?
                 const epBlockJson = entrypoint.name + ".json";
                 if (!applicableBlockJsonFiles[epBlockJson]) {
                     const blockJsonText = EnhancedBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
@@ -62,20 +62,24 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                     continue;
                 }
                 const workableBlockEntrypointsInfo = entrypoint.getFiles()
-                    .map(file => this.stripOffBlocksDestPrefix(file))
-                    .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(node_path_1.default.join(this.dest.destination, file)))
+                    .filter(file => !this.webpackRemoveEmptyScriptsPlugin['trash'].includes(file))
                     .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
                     .filter((item) => item[1] !== '')
                     .map(([file, assetType]) => {
+                    const pathQueryParameters = metadata.pathQueryParameters !== undefined || this.dest.pathQueryParameters !== undefined
+                        ? { ...metadata.pathQueryParameters, ...this.dest.pathQueryParameters }
+                        : undefined;
+                    const { scriptArgsObject, inlinedAsset } = (0, path_query_and_related_helpers_1.parseScriptArgsObjectFromPathQueryParameters)(compilation, file, pathQueryParameters);
                     const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
+                    const outputPath = this.stripOffBlocksDestPrefix(file);
                     if (wasOriginallyAStyleField !== (assetType === "style")) { // This means that the file is extracted
                         const entrypointField = (0, shared_1.convertEntrypointFieldForAssetType)(metadata.entrypointField, assetType);
                         return {
-                            ...metadata, outputPath: file, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
-                            entrypointField, handleGroup: (0, shared_1.getHandleGroup)(entrypointField)
+                            ...metadata, outputPath, assetData, originalValue: undefined, hash: entrypointChunk.hash ?? "",
+                            entrypointField, handleGroup: (0, shared_1.getHandleGroup)(entrypointField), scriptArgsObject, inlinedAsset
                         };
                     }
-                    return ({ ...metadata, outputPath: file, assetData, hash: entrypointChunk.hash ?? "" });
+                    return { ...metadata, outputPath, assetData, hash: entrypointChunk.hash ?? "", scriptArgsObject, inlinedAsset };
                 });
                 if (applicableBlockJsonFiles[epBlockJson]) {
                     applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
@@ -114,18 +118,54 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             action
         } : undefined);
     }
-    emitBlockLoaderFile(compilation, blockData) {
+    emitBlockLoaderFile(compilation, blockDirConfig) {
         if (this.config.useUnifiedLoader) {
-            const metadata = blockData['__metadata'];
-            delete blockData['__metadata'];
-            (0, shared_1.emitPHPWriterAsAsset)(new php_writer_1.PHPWriter()
+            const { '__metadata': metadata, ...blockData } = blockDirConfig;
+            const splitOutInlinedAssets = (handles, type) => {
+                const registerableHandles = {};
+                const inlinedAssets = [];
+                for (const [handle, handleData] of Object.entries(handles)) {
+                    const { inlinedAsset, ...finalizedHandle } = handleData;
+                    if (inlinedAsset !== undefined) {
+                        finalizedHandle.src = false;
+                        inlinedAssets.push([handle, type, inlinedAsset, handleData, handleData.src]);
+                    }
+                    registerableHandles[handle] = finalizedHandle;
+                }
+                return [registerableHandles, inlinedAssets];
+            };
+            const [finalizedScriptHandles, inlinableScripts] = splitOutInlinedAssets(metadata.scriptHandles, 'script');
+            const [finalizedStyleHandles, inlinableStyles] = splitOutInlinedAssets(metadata.styleHandles, 'style');
+            const finalizedMetadata = Object.fromEntries(Object.entries(metadata)
+                .map(([key, value]) => {
+                if (key === 'scriptHandles') {
+                    return [key, finalizedScriptHandles];
+                }
+                if (key === 'styleHandles') {
+                    return [key, finalizedStyleHandles];
+                }
+                return [key, value];
+            }));
+            const writer = new php_writer_1.PHPWriter()
                 .action("init", writer => {
-                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [expressions_1.Constants.__DIR__, new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
-                    expressions_1.Constants.__FILE__, new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
-            }, { accountForAlreadyDoing: this.config.includePostInitFallback }), compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
+                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [
+                    expressions_1.Constants.__DIR__, // string $dir
+                    new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")), // array $blockdirConfig
+                    expressions_1.Constants.__FILE__, // string $blockdirConfigFile
+                    new expressions_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(finalizedMetadata, false, "\t")), // array $metadata
+                    null // ?string $urlPrefix
+                ]);
+                for (const inlinableScript of inlinableScripts) {
+                    (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableScript);
+                }
+                for (const inlinableStyle of inlinableStyles) {
+                    (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableStyle);
+                }
+            }, { accountForAlreadyDoing: this.config.includePostInitFallback });
+            (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
         }
         else {
-            compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockData, true)));
+            compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
         }
     }
     transformBlocks(compilation, collatedWorkableBlockInfo, emittingWpmlXml) {
@@ -173,7 +213,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                     .convertToScriptHandles(handleData.filter(hd => !(0, shared_1.isStyleField)(hd.entrypointField) && (0, shared_1.isScriptModuleField)(hd.entrypointField)))),
                 styleHandles: Object.fromEntries(handleData.filter(hd => (0, shared_1.isStyleField)(hd.entrypointField))
                     .map(hd => {
-                    return [hd.handle, { src: hd.outputPath, rest: [hd.originalValue !== undefined ? hd.assetData.dependencies : [], hd.assetData.version] }];
+                    return [hd.handle, { src: hd.outputPath, rest: [hd.originalValue !== undefined ? hd.assetData.dependencies : [], hd.assetData.version], inlinedAsset: hd.inlinedAsset }];
                 }))
             },
             ...Object.fromEntries(Object.entries(blockData).sort((a, b) => a[0].localeCompare(b[0])))
@@ -186,7 +226,20 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
     static convertToScriptHandles(handleData) {
         return handleData.map(hd => {
             const deps = hd.originalValue !== undefined ? hd.assetData.dependencies : [];
-            return [hd.handle, { src: hd.outputPath, rest: hd.entrypointField.startsWith("editor") ? [deps, hd.assetData.version] : [deps, hd.assetData.version, { strategy: "defer" }] }];
+            let scriptArgsObject;
+            if (hd.scriptArgsObject !== undefined) {
+                scriptArgsObject = hd.scriptArgsObject;
+            }
+            else if (hd.inlinedAsset !== undefined) {
+                scriptArgsObject = hd.inlinedAsset.position === 'before' ? { strategy: "defer" } : undefined;
+            }
+            else if (!hd.entrypointField.startsWith("editor")) {
+                scriptArgsObject = { strategy: "defer" };
+            }
+            else {
+                scriptArgsObject = undefined;
+            }
+            return [hd.handle, { src: hd.outputPath, rest: scriptArgsObject !== undefined ? [deps, hd.assetData.version, scriptArgsObject] : [deps, hd.assetData.version], inlinedAsset: hd.inlinedAsset }];
         });
     }
     static doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, getter) {

package/build/plugins/ExtensionsConfigFileGeneratorPluginV1.d.ts

@@ -1,5 +1,5 @@
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { ParsedAssetJsonProvider } from "../shared";
+import type { ParsedAssetJsonProvider } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation } from "webpack";
 export declare class ExtensionsConfigFileGeneratorPluginV1 extends AbstractBiPhasicGroupAndEntryPlugin {

package/build/plugins/MiniCSSExtractPluginErrorCleaner.d.ts

@@ -1,4 +1,5 @@
-import type { Compiler, WebpackPluginInstance } from "webpack";
-export declare class MiniCSSExtractPluginErrorCleaner implements WebpackPluginInstance {
+import type { Compiler } from "webpack";
+import type { WebpackPlugin } from "../shared";
+export declare class MiniCSSExtractPluginErrorCleaner implements WebpackPlugin {
     apply(compiler: Compiler): void;
 }

package/build/plugins/PackageConfigSanityChecker.d.ts

@@ -1,4 +1,5 @@
-import type { Compiler, WebpackPluginInstance } from "webpack";
-export declare class PackageConfigSanityChecker implements WebpackPluginInstance {
+import type { Compiler } from "webpack";
+import type { WebpackPlugin } from "../shared";
+export declare class PackageConfigSanityChecker implements WebpackPlugin {
     apply(compiler: Compiler): void;
 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -9,6 +9,7 @@ const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const path_query_and_related_helpers_1 = require("../utils/path-query-and-related-helpers");
 const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
@@ -29,6 +30,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
         const handleLists = {
             register: [],
+            inline: [],
             ...Object.fromEntries((0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta).map(sln => [sln, []]))
         };
         const allNamedHandles = assets
@@ -41,7 +43,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 .map(handle => [handle.handleName, handle.src]))]));
         const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
-            for (const { src, rest, locations, type, handleName, lazyLoader } of handles) {
+            for (const { src, rest, locations, type, handleName, lazyLoader, ...otherProps } of handles) {
                 const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
                 if (typeof handleName === 'string') {
@@ -55,7 +57,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                     }
                     handleNameMap[finalHandleName] = src;
                 }
-                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader };
+                plainEntrypointsConfig[`${type}Handles`][finalHandleName] = { src, rest, locations, type, lazyLoader, ...otherProps };
             }
         }
         PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
@@ -79,7 +81,26 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 writer.action("init", writer => {
                     writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
                     for (const { handle, type, data } of prioritizedHandleList) {
-                        writer.call(`wp_register_${type}`, [handle, expressions_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, data.src)), ...data.rest]);
+                        const { inlinedAsset, rest, src } = data;
+                        const emittedSrc = inlinedAsset === undefined
+                            ? expressions_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, src))
+                            : false;
+                        writer.call(`wp_register_${type}`, [handle, emittedSrc, ...rest]);
+                        if (inlinedAsset !== undefined) {
+                            (0, shared_1.appendAddInlineAssetCall)(compilation, writer, handle, type, inlinedAsset, data, src);
+                        }
+                    }
+                }, { priority, accountForAlreadyDoing: this.config.includePostInitFallback });
+            }
+            for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleLists.inline)) {
+                writer.action("init", writer => {
+                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [expressions_1.Constants.__DIR__], { assignTo: baseUriVar });
+                    for (const { handle, type, data } of prioritizedHandleList) {
+                        const { inlinedAsset, rest, src } = data;
+                        writer.call(`wp_register_${type}`, [handle, false, ...rest]);
+                        if (inlinedAsset !== undefined) {
+                            (0, shared_1.appendAddInlineAssetCall)(compilation, writer, handle, type, inlinedAsset, data, src);
+                        }
                     }
                 }, { priority, accountForAlreadyDoing: this.config.includePostInitFallback });
             }
@@ -127,6 +148,9 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
             if (data.locations.register !== false) {
                 handleLists.register.push({ handle, type, data, priority: typeof data.locations.register === 'number' ? data.locations.register : 10 });
             }
+            else if (data.inlinedAsset !== undefined) {
+                handleLists.inline.push({ handle, type, data, priority: typeof data.locations.inline === 'number' ? data.locations.inline : 10 });
+            }
             for (const location of (0, shared_1.constantKeys)(shared_1.standardLocationNamesMeta)) {
                 let priority, hook_name;
                 const dataLocation = data.locations[location];
@@ -277,14 +301,18 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
                 const isScript = type !== 'style';
                 const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
-                const { registerScriptArgs } = this.dest.locations;
-                const rest = isScript && registerScriptArgs !== undefined ? [dependencies, assetData.version, registerScriptArgs] : [dependencies, assetData.version];
+                const { lazyLoader, locations } = this.dest;
+                const { inlinedAsset, scriptArgsObject } = (0, path_query_and_related_helpers_1.parseScriptArgsObjectFromPathQueryParameters)(compilation, file, (0, path_query_and_related_helpers_1.mergeInPathQueryParameters)(file, locations.registerScriptArgs, this.dest.pathQueryParameters));
+                const rest = isScript && scriptArgsObject !== undefined ? [dependencies, assetData.version, scriptArgsObject] : [dependencies, assetData.version];
                 const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
                 handles.push({
-                    src: destPath, rest, type,
-                    locations: this.dest.locations,
-                    handleName: useHandleName ? this.dest.locations.handle : undefined,
-                    lazyLoader: this.dest.lazyLoader
+                    src: destPath,
+                    rest,
+                    type,
+                    locations,
+                    handleName: useHandleName ? locations.handle : undefined,
+                    lazyLoader,
+                    inlinedAsset
                 });
             }
             myAssetHandles.push({ handles, handlePrefix: this.config.targetHandlePrefix });

package/build/plugins/VariablesJSMonitorPlugin.d.ts

@@ -1,6 +1,7 @@
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import type { Compiler, WebpackPluginInstance } from "webpack";
-export declare class VariablesJSMonitorPlugin implements WebpackPluginInstance {
+import type { Compiler } from "webpack";
+import type { WebpackPlugin } from "../shared";
+export declare class VariablesJSMonitorPlugin implements WebpackPlugin {
     private readonly config;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);
     apply(compiler: Compiler): void;

package/build/plugins/WPMLConfigBuilder.d.ts

@@ -1,6 +1,7 @@
+import { type WebpackPlugin } from "../shared";
 import { AbstractBiPhasicGroupAndEntryPlugin } from "./AbstractBiPhasicGroupAndEntryPlugin";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class WPMLConfigBuilderPlugin implements WebpackPluginInstance {
+import { type Compiler } from "webpack";
+export declare class WPMLConfigBuilderPlugin implements WebpackPlugin {
     private readonly destDir;
     private readonly referencePlugin;
     private static jsdomInstance?;

package/build/shared.d.ts

@@ -1,20 +1,25 @@
 import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { AssetInfo, Compilation, type Configuration, Entrypoint, WebpackError } from "webpack";
+import { AssetInfo, Compilation, Configuration, Entrypoint, WebpackError, Compiler } from "webpack";
 export type ParsedAssetsJson = Record<string, {
     dependencies: string[];
     version: string;
 }>;
 export declare function isParsedAssetsJson(thing: any): thing is ParsedAssetsJson;
-type ScriptArgsObject = {
+export type ScriptArgsObject = {
     strategy?: 'defer' | 'async';
     in_footer?: boolean;
     fetchpriority?: 'auto' | 'low' | 'high';
 };
 type BaseRestType = [/* dependencies: */ string[], /* version: */ string];
+export type InlinedAsset = {
+    contents: string;
+    position?: 'before' | 'after';
+};
 export type HandleData = {
     src: string;
-    rest: BaseRestType | [...BaseRestType, ScriptArgsObject | boolean];
+    rest: BaseRestType | [...BaseRestType, ScriptArgsObject];
+    inlinedAsset?: InlinedAsset;
 };
 export declare const standardLocationNamesMeta: {
     readonly clientView: {
@@ -53,17 +58,19 @@ type LocationWithHookNameSupport = boolean | number | string | string[] | {
     hook_name?: string | string[];
     priority?: number;
 };
+type InputRegisterScriptArgs = ScriptArgsObject | boolean | 'lazy' | 'eager' | 'inline';
 export type UsageLocations = {
     [K in StandardLocationNames]?: typeof standardLocationNamesMeta[K] extends {
         supports_hook_name: true;
     } ? LocationWithHookNameSupport : boolean | number;
 } & {
     register?: boolean | number;
+    inline?: number;
     handle?: string | ((generatedHandle: string) => string);
-    registerScriptArgs?: ScriptArgsObject | boolean | 'lazy';
+    registerScriptArgs?: InputRegisterScriptArgs;
 };
 export type NormalizedUsageLocations = Omit<UsageLocations, 'registerScriptArgs'> & {
-    registerScriptArgs?: ScriptArgsObject | boolean;
+    registerScriptArgs?: InputRegisterScriptArgs;
 };
 export declare function isNormalizedUsageLocations(usageLocations: UsageLocations): usageLocations is NormalizedUsageLocations;
 export declare function constantKeys<K extends string, V>(object: {
@@ -78,6 +85,9 @@ export declare const enum SourceType {
     plain = "plain"
 }
 export declare function determineCurrentSourceType(dest: string | AdvancedOutputConfig, srcIsDirectory: boolean): SourceType;
+export interface WebpackPlugin {
+    apply(compiler: Compiler): void;
+}
 export type ObjectIndividualExternalDepConfig = {
     import?: string | [string, ...string[]];
     handle: string;
@@ -96,8 +106,9 @@ export type AdvancedOutputConfig = {
     bundleAnalyzer?: boolean;
     locations?: UsageLocations | UsageLocations['handle'];
     lazyLoader?: string;
+    pathQueryParameters?: PathQueryParameters;
 };
-type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader';
+type OptionalCfgFields = 'directoryLayout' | 'externalize' | 'lazyLoader' | 'pathQueryParameters';
 export type VerifiedAdvancedOutputConfig = Required<Omit<AdvancedOutputConfig, 'locations' | OptionalCfgFields>> & Pick<AdvancedOutputConfig, OptionalCfgFields> & {
     locations: NormalizedUsageLocations;
 };
@@ -136,7 +147,9 @@ export type FileSegmentBlockEntrypointInfo = {
     handle: string;
     dest: VerifiedAdvancedOutputConfig;
     absoluteSrc: string;
+    pathQueryParameters: PathQueryParameters | undefined;
 };
+export type PathQueryParameters = Record<string, unknown | [unknown, ...unknown[]]>;
 export type BlockEntrypointInfo = FileSegmentBlockEntrypointInfo | {
     dest: VerifiedAdvancedOutputConfig;
     purpose: string;
@@ -160,6 +173,7 @@ export declare function scriptOrStyleTest(entryPath: string, scriptExtension: Re
 export declare function isStyleField(field: string): field is 'style' | 'viewStyle' | 'editorStyle';
 export declare function isScriptModuleField(field: string): field is 'viewScriptModule';
 export declare function getHandleGroup(field: string): 'styleHandles' | 'scriptHandles' | 'scriptModuleHandles';
+export type StripFirstTwoItems<A extends any[]> = A extends [any, any, ...rest: infer R] ? R : never;
 export declare function hasAtLeastOneItem<T>(list: T[]): list is [T, ...T[]];
 export type TupleOf<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
 type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
@@ -184,4 +198,14 @@ export declare function getParsedAssetsJsonDataForEntrypoint(compilation: Compil
 export declare function emitPHPWriterAsAsset(writer: PHPWriter, compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
 export declare function dedent(text: TemplateStringsArray): string;
 export declare function resolveLegacyBlockScriptsInFolder(folder: string): string[];
+/**
+ * @param compilation
+ * @param writer
+ * @param handle
+ * @param type 'script_module' is NOT supported at this time; however, it is *handled* in this function
+ * @param inlinedAsset
+ * @param handleData
+ * @param file something that represents the file that is being inlined (this is purely for error-reporting purposes)
+ */
+export declare function appendAddInlineAssetCall(compilation: Compilation, writer: PHPWriter, handle: string, type: 'script' | 'style' | 'script_module', inlinedAsset: InlinedAsset, handleData: HandleData, file: string): void;
 export {};

package/build/shared.js

@@ -29,12 +29,14 @@ exports.getParsedAssetsJsonDataForEntrypoint = getParsedAssetsJsonDataForEntrypo
 exports.emitPHPWriterAsAsset = emitPHPWriterAsAsset;
 exports.dedent = dedent;
 exports.resolveLegacyBlockScriptsInFolder = resolveLegacyBlockScriptsInFolder;
+exports.appendAddInlineAssetCall = appendAddInlineAssetCall;
 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 php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const webpack_1 = require("webpack");
+const node_crypto_1 = require("node:crypto");
 function isParsedAssetsJson(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -103,9 +105,9 @@ function leadingSlashIt(pathOrSomething) {
     return pathOrSomething.startsWith('/') ? pathOrSomething : ('/' + pathOrSomething);
 }
 exports.scriptExtension = /(?<filename>.+)(?<extension>\.m?[jt]sx?)$/i;
-exports.scriptWithoutModuleExtension = /(?<filename>.+)(?<extension>\.[jt]sx?)$/i;
-exports.scriptWithModuleExtension = /(?<filename>.+)(?<extension>\.m[jt]sx?)$/i;
-exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)$/i;
+exports.scriptWithoutModuleExtension = /(?<filename>.+)(?<extension>\.[jt]sx?)($|\?)/i;
+exports.scriptWithModuleExtension = /(?<filename>.+)(?<extension>\.m[jt]sx?)($|\?)/i;
+exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)($|\?)/i;
 function scriptOrStyleTest(entryPath, scriptExtension) {
     return scriptExtension.test(entryPath) ? "script" : (exports.styleExtension.test(entryPath) ? "style" : "");
 }
@@ -250,3 +252,25 @@ function resolveLegacyBlockScriptsInFolder(folder) {
     }
     return blockScriptEntrypoints;
 }
+/**
+ * @param compilation
+ * @param writer
+ * @param handle
+ * @param type 'script_module' is NOT supported at this time; however, it is *handled* in this function
+ * @param inlinedAsset
+ * @param handleData
+ * @param file something that represents the file that is being inlined (this is purely for error-reporting purposes)
+ */
+function appendAddInlineAssetCall(compilation, writer, handle, type, inlinedAsset, handleData, file) {
+    if (type === 'script_module') {
+        throw newWebpackErrorForFile("WordPress does not support inlined script modules", file);
+    }
+    if (handleData.rest[0]?.length) { // If there are any dependencies
+        compilation.errors.push(newWebpackErrorForFile("Inlined scripts MUST NOT have dependencies. It WILL cause runtime inconsistencies and potentially cause sever performance issues", handleData.src));
+    }
+    const args = [handle, new expressions_1.HereOrNowDoc(`plaudit_inlined_${type}_${(0, node_crypto_1.createHash)('md5').update(handle).digest("hex")}`, inlinedAsset.contents, false)];
+    if (type === 'script' && inlinedAsset.position === 'before') {
+        args.push('before');
+    }
+    writer.call(`wp_add_inline_${type}`, args);
+}

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

@@ -1,6 +1,6 @@
 import type { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "../plugins/AbstractBiPhasicGroupAndEntryPlugin";
 import type { AdditionalDependencyInjectorPlugin } from "../plugins/AdditionalDependencyInjectorPlugin";
-import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata } from "../shared";
+import { EntrypointFields, PlauditWordpressWebpackConfig, BlockEntrypointInfo, VerifiedAdvancedOutputConfig, MinimumViableMetadata, WebpackPlugin } 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'>> & {
@@ -8,7 +8,7 @@ export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpre
     currentVariables: Record<string, any>;
 } & Pick<PlauditWordpressWebpackConfig, 'externals'>;
 export type CommonPluginConfig = {
-    plugins: (WebpackPluginInstance | ((this: Compiler, compiler: Compiler) => void))[];
+    plugins: (WebpackPluginInstance | WebpackPlugin | ((this: Compiler, compiler: Compiler) => void))[];
     removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
     makeAdditionalDependencyInjectorPlugin(referencePlugin: AbstractBiPhasicGroupAndEntryPlugin<any>): AdditionalDependencyInjectorPlugin;
 };

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

@@ -10,6 +10,7 @@ exports.commonMakeWebpackConfig = commonMakeWebpackConfig;
 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 path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
 const shared_1 = require("../shared");
 const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-webpack-plugin"));
 function joinPossiblyAbsolutePaths(...paths) {
@@ -34,7 +35,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
     return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
         .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
         .filter(ep => supportedExtensions(ep) && node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
-        .map(ep => {
+        .map(path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)
+        .map(([ep, pathQueryParameters]) => {
         const parsedEntrypoint = node_path_1.default.parse(ep);
         const entrypointField = shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'viewScriptModule' : 'script';
         const fakeEntrypointInfo = {
@@ -45,7 +47,8 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name),
             handleGroup: (0, shared_1.getHandleGroup)(entrypointField),
             dest,
-            absoluteSrc: ep
+            absoluteSrc: ep,
+            pathQueryParameters
         };
         return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
@@ -134,17 +137,19 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         .filter(entrypointField => entrypointField in blockJson)
                         .flatMap(entrypointField => {
                         return (Array.isArray(blockJson[entrypointField]) ? blockJson[entrypointField] : [blockJson[entrypointField]])
-                            .filter(originalValue => originalValue.startsWith("file:"))
+                            .filter(originalValue => typeof originalValue === 'string')
+                            .filter(originalValue => originalValue?.startsWith("file:"))
                             .map(originalValue => {
-                            const entrypointPath = originalValue.substring(5);
+                            const [entrypointPath, localPathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(originalValue);
                             const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, entrypointPath));
+                            const pathQueryParameters = (0, path_query_and_related_helpers_1.mergeInPathQueryParameters)(absoluteSrc, localPathQueryParameters, dest.pathQueryParameters);
                             return promises_1.default.stat(absoluteSrc)
                                 .then(stats => {
                                 if (stats.isFile()) {
                                     const parsedEntrypoint = node_path_1.default.parse(node_path_1.default.normalize(node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), entrypointPath)));
                                     const extensionlessExpectedSrc = node_path_1.default.normalize(node_path_1.default.join(parsedEntrypoint.dir, parsedEntrypoint.name));
                                     const entrypointName = node_path_1.default.normalize(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
-                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc };
+                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc, pathQueryParameters };
                                 }
                                 else {
                                     return undefined;
@@ -196,7 +201,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             }
                         ];
                     }));
-                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
+                    rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin, pathQueryParameters: undefined } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
                 }
                 catch (e) {

package/build/utils/path-query-and-related-helpers.d.ts

@@ -0,0 +1,53 @@
+import { Compilation } from "webpack";
+import { InlinedAsset, PathQueryParameters, ScriptArgsObject, UsageLocations } from "../shared";
+export declare function getAssetFileContents(compilation: Compilation, name: string): string;
+export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [string, PathQueryParameters | undefined];
+/**
+ * The following substitutions are performed:
+ * <ul>
+ *     <li>parameters without an assigned value -> a boolean parameter set to true</li>
+ *     <li>true and false -> their boolean equivalents</li>
+ *     <li>numeric values -> their number equivalents</li>
+ * </ul>
+ *
+ * @param pathQuery the part after the "?" in a webpack inclusion path
+ * @return the query as an object with common string -> JS type conversions already performed
+ */
+export declare function unpackPathQuery(pathQuery: string): PathQueryParameters | undefined;
+export type LoadingStrategy = boolean | 'defer' | 'async' | 'eager' | 'lazy' | 'inline';
+export declare function isValidLoadingStrategy(strategy: any): strategy is LoadingStrategy | undefined;
+export declare function newInvalidLoadingStrategyError(strategy: unknown, file: string): import("webpack").WebpackError;
+export type InFooter = boolean;
+export declare function isValidInFooter(in_footer: unknown): in_footer is InFooter;
+export declare function newInvalidInFooterError(in_footer: unknown, file: string): import("webpack").WebpackError;
+export type FetchPriority = 'auto' | 'low' | 'high';
+export declare function isValidFetchPriority(fetchpriority: unknown): fetchpriority is FetchPriority;
+export declare function newInvalidFetchPriorityError(fetchpriority: unknown, file: string): import("webpack").WebpackError;
+export type PositionForInlineStrategy = 'before' | 'after';
+export declare function isValidPositionForInlineStrategy(position: unknown): position is PositionForInlineStrategy;
+export declare function newInvalidPositionForInlineStrategyError(position: unknown, file: string): import("webpack").WebpackError;
+export declare function mergeInPathQueryParameters(file: string, registerScriptArgs: UsageLocations['registerScriptArgs'], pathQueryParameters: PathQueryParameters | undefined): NormalizedScriptEnqueuingControlFlags | undefined;
+/**
+ * This function ensures that the passed pathQueryParameters are normalized for the config-loading step, NOT the emission step
+ */
+export type NormalizedScriptEnqueuingControlFlags = {
+    strategy?: Exclude<LoadingStrategy, 'inline'>;
+    in_footer?: InFooter;
+    inline?: boolean;
+    fetchpriority?: FetchPriority;
+    position?: 'before' | 'after';
+};
+/**
+ * This function does a few things:
+ * <ol>
+ *     <li>It extracts strategy, in_footer, and fetchpriority from pathQueryParameters</li>
+ *     <li>If the strategy is, 'inline', it records the contents of the asset for later injection inline and removes the asset from the compilation output</li>
+ * </ol>
+ * @param compilation
+ * @param file
+ * @param pathQueryParameters
+ */
+export declare function parseScriptArgsObjectFromPathQueryParameters(compilation: Compilation, file: string, pathQueryParameters: PathQueryParameters | undefined): {
+    scriptArgsObject?: ScriptArgsObject;
+    inlinedAsset?: InlinedAsset;
+};